API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 6th, 2019
122
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Rust 20.15 KB | None | 0 0
raw download clone embed print report
  1. #[doc = "Vrací seznam globálních tagů"]
  2. #[allow(unused_attributes)]
  3. pub fn g_get(instanceid: String) -> Response {
  4.     let running = POOL.read().unwrap().contains(&"page_g_get");
  5.     if !running {
  6.         {
  7.             use log::{LOG, THREAD_ID};
  8.             use std::io::Write;
  9.             use std::thread;
  10.             let thread_id = THREAD_ID.with(|i| *i);
  11.             thread::spawn(move || match LOG.lock() {
  12.                 Ok(mut lock) => {
  13.                     let _ = lock.write_fmt(::std::fmt::Arguments::new_v1_formatted(
  14.                         &["WRN ", " [", "] ", "\n"],
  15.                         &match (
  16.                             &"LOW",
  17.                             &thread_id,
  18.                             &"page_controller: page_g_get not running, launching...",
  19.                         ) {
  20.                             (arg0, arg1, arg2) => [
  21.                                 ::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt),
  22.                                 ::std::fmt::ArgumentV1::new(arg1, ::std::fmt::LowerHex::fmt),
  23.                                 ::std::fmt::ArgumentV1::new(arg2, ::std::fmt::Display::fmt),
  24.                             ],
  25.                         },
  26.                         &[
  27.                             ::std::fmt::rt::v1::Argument {
  28.                                 position: ::std::fmt::rt::v1::Position::At(0usize),
  29.                                 format: ::std::fmt::rt::v1::FormatSpec {
  30.                                     fill: ' ',
  31.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  32.                                     flags: 0u32,
  33.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  34.                                     width: ::std::fmt::rt::v1::Count::Implied,
  35.                                 },
  36.                             },
  37.                             ::std::fmt::rt::v1::Argument {
  38.                                 position: ::std::fmt::rt::v1::Position::At(1usize),
  39.                                 format: ::std::fmt::rt::v1::FormatSpec {
  40.                                     fill: ' ',
  41.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  42.                                     flags: 0u32,
  43.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  44.                                     width: ::std::fmt::rt::v1::Count::Implied,
  45.                                 },
  46.                             },
  47.                             ::std::fmt::rt::v1::Argument {
  48.                                 position: ::std::fmt::rt::v1::Position::At(2usize),
  49.                                 format: ::std::fmt::rt::v1::FormatSpec {
  50.                                     fill: ' ',
  51.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  52.                                     flags: 0u32,
  53.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  54.                                     width: ::std::fmt::rt::v1::Count::Implied,
  55.                                 },
  56.                             },
  57.                         ],
  58.                     ));
  59.                 }
  60.                 Err(_) => {
  61.                     ::io::_eprint(::std::fmt::Arguments::new_v1(
  62.                         &["failed to acquire lock on log mutex\n"],
  63.                         &match () {
  64.                             () => [],
  65.                         },
  66.                     ));
  67.                 }
  68.             });
  69.         };
  70.         {
  71.             let mut list = POOL.write().unwrap();
  72.             list.push("page_g_get");
  73.             {
  74.                 use log::{LOG, THREAD_ID};
  75.                 use std::io::Write;
  76.                 use std::thread;
  77.                 let thread_id = THREAD_ID.with(|i| *i);
  78.                 thread::spawn(move || match LOG.lock() {
  79.                     Ok(mut lock) => {
  80.                         let _ = lock.write_fmt(::std::fmt::Arguments::new_v1_formatted(
  81.                             &["INF ", " [", "] ", "\n"],
  82.                             &match (
  83.                                 &"LOW",
  84.                                 &thread_id,
  85.                                 &"page_controller: added page_g_get to the pool",
  86.                             ) {
  87.                                 (arg0, arg1, arg2) => [
  88.                                     ::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt),
  89.                                     ::std::fmt::ArgumentV1::new(arg1, ::std::fmt::LowerHex::fmt),
  90.                                     ::std::fmt::ArgumentV1::new(arg2, ::std::fmt::Display::fmt),
  91.                                 ],
  92.                             },
  93.                             &[
  94.                                 ::std::fmt::rt::v1::Argument {
  95.                                     position: ::std::fmt::rt::v1::Position::At(0usize),
  96.                                     format: ::std::fmt::rt::v1::FormatSpec {
  97.                                         fill: ' ',
  98.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  99.                                         flags: 0u32,
  100.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  101.                                         width: ::std::fmt::rt::v1::Count::Implied,
  102.                                     },
  103.                                 },
  104.                                 ::std::fmt::rt::v1::Argument {
  105.                                     position: ::std::fmt::rt::v1::Position::At(1usize),
  106.                                     format: ::std::fmt::rt::v1::FormatSpec {
  107.                                         fill: ' ',
  108.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  109.                                         flags: 0u32,
  110.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  111.                                         width: ::std::fmt::rt::v1::Count::Implied,
  112.                                     },
  113.                                 },
  114.                                 ::std::fmt::rt::v1::Argument {
  115.                                     position: ::std::fmt::rt::v1::Position::At(2usize),
  116.                                     format: ::std::fmt::rt::v1::FormatSpec {
  117.                                         fill: ' ',
  118.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  119.                                         flags: 0u32,
  120.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  121.                                         width: ::std::fmt::rt::v1::Count::Implied,
  122.                                     },
  123.                                 },
  124.                             ],
  125.                         ));
  126.                     }
  127.                     Err(_) => {
  128.                         ::io::_eprint(::std::fmt::Arguments::new_v1(
  129.                             &["failed to acquire lock on log mutex\n"],
  130.                             &match () {
  131.                                 () => [],
  132.                             },
  133.                         ));
  134.                     }
  135.                 });
  136.             };
  137.         }
  138.         thread::spawn(|| {
  139.             Command::new("page_g_get")
  140.                 .stdout(Stdio::inherit())
  141.                 .spawn()
  142.                 .expect("page_g_get failed to launch")
  143.                 .wait()
  144.                 .expect("failed to wait for page_g_get to be killed");
  145.             {
  146.                 use log::{LOG, THREAD_ID};
  147.                 use std::io::Write;
  148.                 use std::thread;
  149.                 let thread_id = THREAD_ID.with(|i| *i);
  150.                 thread::spawn(move || match LOG.lock() {
  151.                     Ok(mut lock) => {
  152.                         let _ = lock.write_fmt(::std::fmt::Arguments::new_v1_formatted(
  153.                             &["WRN ", " [", "] ", "\n"],
  154.                             &match (
  155.                                 &"LOW",
  156.                                 &thread_id,
  157.                                 &"page_controller: page_g_get exited, removing it from the pool...",
  158.                             ) {
  159.                                 (arg0, arg1, arg2) => [
  160.                                     ::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt),
  161.                                     ::std::fmt::ArgumentV1::new(arg1, ::std::fmt::LowerHex::fmt),
  162.                                     ::std::fmt::ArgumentV1::new(arg2, ::std::fmt::Display::fmt),
  163.                                 ],
  164.                             },
  165.                             &[
  166.                                 ::std::fmt::rt::v1::Argument {
  167.                                     position: ::std::fmt::rt::v1::Position::At(0usize),
  168.                                     format: ::std::fmt::rt::v1::FormatSpec {
  169.                                         fill: ' ',
  170.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  171.                                         flags: 0u32,
  172.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  173.                                         width: ::std::fmt::rt::v1::Count::Implied,
  174.                                     },
  175.                                 },
  176.                                 ::std::fmt::rt::v1::Argument {
  177.                                     position: ::std::fmt::rt::v1::Position::At(1usize),
  178.                                     format: ::std::fmt::rt::v1::FormatSpec {
  179.                                         fill: ' ',
  180.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  181.                                         flags: 0u32,
  182.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  183.                                         width: ::std::fmt::rt::v1::Count::Implied,
  184.                                     },
  185.                                 },
  186.                                 ::std::fmt::rt::v1::Argument {
  187.                                     position: ::std::fmt::rt::v1::Position::At(2usize),
  188.                                     format: ::std::fmt::rt::v1::FormatSpec {
  189.                                         fill: ' ',
  190.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  191.                                         flags: 0u32,
  192.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  193.                                         width: ::std::fmt::rt::v1::Count::Implied,
  194.                                     },
  195.                                 },
  196.                             ],
  197.                         ));
  198.                     }
  199.                     Err(_) => {
  200.                         ::io::_eprint(::std::fmt::Arguments::new_v1(
  201.                             &["failed to acquire lock on log mutex\n"],
  202.                             &match () {
  203.                                 () => [],
  204.                             },
  205.                         ));
  206.                     }
  207.                 });
  208.             };
  209.             let mut list = POOL.write().unwrap();
  210.             list.retain(|x| *x != "page_g_get");
  211.         });
  212.     }
  213.     let queue = MessageQueue::new(adler32("page_g_get".as_bytes()))
  214.         .create()
  215.         .init()
  216.         .ok()?;
  217.     let recv_id: i32 = rand::random();
  218.     match queue.send((instanceid.inner(), recv_id), 1) {
  219.         Ok(()) => {
  220.             use log::{LOG, THREAD_ID};
  221.             use std::io::Write;
  222.             use std::thread;
  223.             let thread_id = THREAD_ID.with(|i| *i);
  224.             thread::spawn(move || match LOG.lock() {
  225.                 Ok(mut lock) => {
  226.                     let _ = lock.write_fmt(::std::fmt::Arguments::new_v1_formatted(
  227.                         &["INF ", " [", "] ", "\n"],
  228.                         &match (
  229.                             &"LOW",
  230.                             &thread_id,
  231.                             &::fmt::format(::std::fmt::Arguments::new_v1_formatted(
  232.                                 &["page_controller: data sent to page_g_get with key "],
  233.                                 &match (&recv_id,) {
  234.                                     (arg0,) => [::std::fmt::ArgumentV1::new(
  235.                                         arg0,
  236.                                         ::std::fmt::Display::fmt,
  237.                                     )],
  238.                                 },
  239.                                 &[::std::fmt::rt::v1::Argument {
  240.                                     position: ::std::fmt::rt::v1::Position::At(0usize),
  241.                                     format: ::std::fmt::rt::v1::FormatSpec {
  242.                                         fill: ' ',
  243.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  244.                                         flags: 0u32,
  245.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  246.                                         width: ::std::fmt::rt::v1::Count::Implied,
  247.                                     },
  248.                                 }],
  249.                             )),
  250.                         ) {
  251.                             (arg0, arg1, arg2) => [
  252.                                 ::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt),
  253.                                 ::std::fmt::ArgumentV1::new(arg1, ::std::fmt::LowerHex::fmt),
  254.                                 ::std::fmt::ArgumentV1::new(arg2, ::std::fmt::Display::fmt),
  255.                             ],
  256.                         },
  257.                         &[
  258.                             ::std::fmt::rt::v1::Argument {
  259.                                 position: ::std::fmt::rt::v1::Position::At(0usize),
  260.                                 format: ::std::fmt::rt::v1::FormatSpec {
  261.                                     fill: ' ',
  262.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  263.                                     flags: 0u32,
  264.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  265.                                     width: ::std::fmt::rt::v1::Count::Implied,
  266.                                 },
  267.                             },
  268.                             ::std::fmt::rt::v1::Argument {
  269.                                 position: ::std::fmt::rt::v1::Position::At(1usize),
  270.                                 format: ::std::fmt::rt::v1::FormatSpec {
  271.                                     fill: ' ',
  272.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  273.                                     flags: 0u32,
  274.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  275.                                     width: ::std::fmt::rt::v1::Count::Implied,
  276.                                 },
  277.                             },
  278.                             ::std::fmt::rt::v1::Argument {
  279.                                 position: ::std::fmt::rt::v1::Position::At(2usize),
  280.                                 format: ::std::fmt::rt::v1::FormatSpec {
  281.                                     fill: ' ',
  282.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  283.                                     flags: 0u32,
  284.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  285.                                     width: ::std::fmt::rt::v1::Count::Implied,
  286.                                 },
  287.                             },
  288.                         ],
  289.                     ));
  290.                 }
  291.                 Err(_) => {
  292.                     ::io::_eprint(::std::fmt::Arguments::new_v1(
  293.                         &["failed to acquire lock on log mutex\n"],
  294.                         &match () {
  295.                             () => [],
  296.                         },
  297.                     ));
  298.                 }
  299.             });
  300.         }
  301.         Err(e) => {
  302.             use log::{LOG, THREAD_ID};
  303.             use std::io::Write;
  304.             use std::thread;
  305.             let thread_id = THREAD_ID.with(|i| *i);
  306.             thread::spawn(move || match LOG.lock() {
  307.                 Ok(mut lock) => {
  308.                     let _ = lock.write_fmt(::std::fmt::Arguments::new_v1_formatted(
  309.                         &["ERR ", " [", "] ", "\n"],
  310.                         &match (
  311.                             &"MED",
  312.                             &thread_id,
  313.                             &::fmt::format(::std::fmt::Arguments::new_v1_formatted(
  314.                                 &["page_controller: failed to send data to page_g_get: "],
  315.                                 &match (&e,) {
  316.                                     (arg0,) => {
  317.                                         [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Debug::fmt)]
  318.                                     }
  319.                                 },
  320.                                 &[::std::fmt::rt::v1::Argument {
  321.                                     position: ::std::fmt::rt::v1::Position::At(0usize),
  322.                                     format: ::std::fmt::rt::v1::FormatSpec {
  323.                                         fill: ' ',
  324.                                         align: ::std::fmt::rt::v1::Alignment::Unknown,
  325.                                         flags: 0u32,
  326.                                         precision: ::std::fmt::rt::v1::Count::Implied,
  327.                                         width: ::std::fmt::rt::v1::Count::Implied,
  328.                                     },
  329.                                 }],
  330.                             )),
  331.                         ) {
  332.                             (arg0, arg1, arg2) => [
  333.                                 ::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt),
  334.                                 ::std::fmt::ArgumentV1::new(arg1, ::std::fmt::LowerHex::fmt),
  335.                                 ::std::fmt::ArgumentV1::new(arg2, ::std::fmt::Display::fmt),
  336.                             ],
  337.                         },
  338.                         &[
  339.                             ::std::fmt::rt::v1::Argument {
  340.                                 position: ::std::fmt::rt::v1::Position::At(0usize),
  341.                                 format: ::std::fmt::rt::v1::FormatSpec {
  342.                                     fill: ' ',
  343.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  344.                                     flags: 0u32,
  345.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  346.                                     width: ::std::fmt::rt::v1::Count::Implied,
  347.                                 },
  348.                             },
  349.                             ::std::fmt::rt::v1::Argument {
  350.                                 position: ::std::fmt::rt::v1::Position::At(1usize),
  351.                                 format: ::std::fmt::rt::v1::FormatSpec {
  352.                                     fill: ' ',
  353.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  354.                                     flags: 0u32,
  355.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  356.                                     width: ::std::fmt::rt::v1::Count::Implied,
  357.                                 },
  358.                             },
  359.                             ::std::fmt::rt::v1::Argument {
  360.                                 position: ::std::fmt::rt::v1::Position::At(2usize),
  361.                                 format: ::std::fmt::rt::v1::FormatSpec {
  362.                                     fill: ' ',
  363.                                     align: ::std::fmt::rt::v1::Alignment::Unknown,
  364.                                     flags: 0u32,
  365.                                     precision: ::std::fmt::rt::v1::Count::Implied,
  366.                                     width: ::std::fmt::rt::v1::Count::Implied,
  367.                                 },
  368.                             },
  369.                         ],
  370.                     ));
  371.                 }
  372.                 Err(_) => {
  373.                     ::io::_eprint(::std::fmt::Arguments::new_v1(
  374.                         &["failed to acquire lock on log mutex\n"],
  375.                         &match () {
  376.                             () => [],
  377.                         },
  378.                     ));
  379.                 }
  380.             });
  381.         }
  382.     }
  383.     let recv_queue = MessageQueue::new(recv_id)
  384.         .auto_kill(true)
  385.         .create()
  386.         .init()
  387.         .ok()?;
  388.     recv_queue.recv().ok()?
  389. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!