diff options
author | Allen George <allen.george@gmail.com> | 2017-04-28 10:22:03 -0400 |
---|---|---|
committer | Jens Geyer <jensg@apache.org> | 2017-05-11 01:35:33 +0200 |
commit | bc1344d55fa450289f98b1a1d0d15c7fcb7d37e1 (patch) | |
tree | 8d870fae752635cd913d36f5ec568e49bbb4b20e /test/rs | |
parent | 3966a56a877bf5df8fba8ad3076153a8261b901a (diff) | |
download | thrift-bc1344d55fa450289f98b1a1d0d15c7fcb7d37e1.tar.gz |
THRIFT-4186 Add travis build for Rust
Client: rs
Patch: Allen George <allen.george@gmail.com>
This closes #1260
Diffstat (limited to 'test/rs')
-rw-r--r-- | test/rs/Cargo.toml | 2 | ||||
-rw-r--r-- | test/rs/src/bin/test_client.rs | 251 | ||||
-rw-r--r-- | test/rs/src/bin/test_server.rs | 136 |
3 files changed, 250 insertions, 139 deletions
diff --git a/test/rs/Cargo.toml b/test/rs/Cargo.toml index 816739025..df8450452 100644 --- a/test/rs/Cargo.toml +++ b/test/rs/Cargo.toml @@ -7,6 +7,8 @@ publish = false [dependencies] clap = "2.18.0" +env_logger = "0.4.0" +log = "0.3.7" ordered-float = "0.3.0" try_from = "0.2.0" diff --git a/test/rs/src/bin/test_client.rs b/test/rs/src/bin/test_client.rs index aad78a058..d720313e9 100644 --- a/test/rs/src/bin/test_client.rs +++ b/test/rs/src/bin/test_client.rs @@ -16,6 +16,10 @@ // under the License. #[macro_use] +extern crate log; +extern crate env_logger; + +#[macro_use] extern crate clap; extern crate ordered_float; extern crate thrift; @@ -26,17 +30,22 @@ use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Debug; use thrift::protocol::{TBinaryInputProtocol, TBinaryOutputProtocol, TCompactInputProtocol, - TCompactOutputProtocol, TInputProtocol, TOutputProtocol}; + TCompactOutputProtocol, TInputProtocol, TMultiplexedOutputProtocol, + TOutputProtocol}; use thrift::transport::{ReadHalf, TBufferedReadTransport, TBufferedWriteTransport, TFramedReadTransport, TFramedWriteTransport, TIoChannel, TReadTransport, TTcpChannel, TWriteTransport, WriteHalf}; use thrift_test::*; fn main() { + env_logger::init().expect("logger setup failed"); + + debug!("initialized logger - running cross-test client"); + match run() { - Ok(()) => println!("cross-test client succeeded"), + Ok(()) => info!("cross-test client succeeded"), Err(e) => { - println!("cross-test client failed with error {:?}", e); + info!("cross-test client failed with error {:?}", e); std::process::exit(1); } } @@ -59,7 +68,7 @@ fn run() -> thrift::Result<()> { (@arg protocol: --protocol +takes_value "Thrift protocol implementation to use (\"binary\", \"compact\")") (@arg testloops: -n --testloops +takes_value "Number of times to run tests") ) - .get_matches(); + .get_matches(); let host = matches.value_of("host").unwrap_or("127.0.0.1"); let port = value_t!(matches, "port", u16).unwrap_or(9090); @@ -67,47 +76,81 @@ fn run() -> thrift::Result<()> { let transport = matches.value_of("transport").unwrap_or("buffered"); let protocol = matches.value_of("protocol").unwrap_or("binary"); + + let mut thrift_test_client = { + let (i_prot, o_prot) = build_protocols(host, port, transport, protocol, "ThriftTest")?; + ThriftTestSyncClient::new(i_prot, o_prot) + }; + + let mut second_service_client = if protocol.starts_with("multi") { + let (i_prot, o_prot) = build_protocols(host, port, transport, protocol, "SecondService")?; + Some(SecondServiceSyncClient::new(i_prot, o_prot)) + } else { + None + }; + + info!( + "connecting to {}:{} with {}+{} stack", + host, + port, + protocol, + transport + ); + + for _ in 0..testloops { + make_thrift_calls(&mut thrift_test_client, &mut second_service_client)? + } + + Ok(()) +} + +fn build_protocols( + host: &str, + port: u16, + transport: &str, + protocol: &str, + service_name: &str, +) -> thrift::Result<(Box<TInputProtocol>, Box<TOutputProtocol>)> { let (i_chan, o_chan) = tcp_channel(host, port)?; - let (i_tran, o_tran) = match transport { + let (i_tran, o_tran): (Box<TReadTransport>, Box<TWriteTransport>) = match transport { "buffered" => { - (Box::new(TBufferedReadTransport::new(i_chan)) as Box<TReadTransport>, - Box::new(TBufferedWriteTransport::new(o_chan)) as Box<TWriteTransport>) + (Box::new(TBufferedReadTransport::new(i_chan)), + Box::new(TBufferedWriteTransport::new(o_chan))) } "framed" => { - (Box::new(TFramedReadTransport::new(i_chan)) as Box<TReadTransport>, - Box::new(TFramedWriteTransport::new(o_chan)) as Box<TWriteTransport>) + (Box::new(TFramedReadTransport::new(i_chan)), + Box::new(TFramedWriteTransport::new(o_chan))) } unmatched => return Err(format!("unsupported transport {}", unmatched).into()), }; let (i_prot, o_prot): (Box<TInputProtocol>, Box<TOutputProtocol>) = match protocol { - "binary" => { + "binary" | "multi:binary" => { (Box::new(TBinaryInputProtocol::new(i_tran, true)), Box::new(TBinaryOutputProtocol::new(o_tran, true))) } - "compact" => { + "multi" => { + (Box::new(TBinaryInputProtocol::new(i_tran, true)), + Box::new( + TMultiplexedOutputProtocol::new( + service_name, + TBinaryOutputProtocol::new(o_tran, true), + ), + )) + } + "compact" | "multi:compact" => { (Box::new(TCompactInputProtocol::new(i_tran)), Box::new(TCompactOutputProtocol::new(o_tran))) } + "multic" => { + (Box::new(TCompactInputProtocol::new(i_tran)), + Box::new(TMultiplexedOutputProtocol::new(service_name, TCompactOutputProtocol::new(o_tran)),)) + } unmatched => return Err(format!("unsupported protocol {}", unmatched).into()), }; - println!( - "connecting to {}:{} with {}+{} stack", - host, - port, - protocol, - transport - ); - - let mut client = ThriftTestSyncClient::new(i_prot, o_prot); - - for _ in 0..testloops { - make_thrift_calls(&mut client)? - } - - Ok(()) + Ok((i_prot, o_prot)) } // FIXME: expose "open" through the client interface so I don't have to early @@ -121,57 +164,69 @@ fn tcp_channel( c.split() } -fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box<TOutputProtocol>>,) - -> Result<(), thrift::Error> { - println!("testVoid"); - client.test_void()?; +type BuildThriftTestClient = ThriftTestSyncClient<Box<TInputProtocol>, Box<TOutputProtocol>>; +type BuiltSecondServiceClient = SecondServiceSyncClient<Box<TInputProtocol>, Box<TOutputProtocol>>; - println!("testString"); - verify_expected_result(client.test_string("thing".to_owned()), "thing".to_owned())?; +#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))] +fn make_thrift_calls( + thrift_test_client: &mut BuildThriftTestClient, + second_service_client: &mut Option<BuiltSecondServiceClient>, +) -> Result<(), thrift::Error> { + info!("testVoid"); + thrift_test_client.test_void()?; + + info!("testString"); + verify_expected_result( + thrift_test_client.test_string("thing".to_owned()), + "thing".to_owned(), + )?; - println!("testBool"); - verify_expected_result(client.test_bool(true), true)?; + info!("testBool"); + verify_expected_result(thrift_test_client.test_bool(true), true)?; - println!("testBool"); - verify_expected_result(client.test_bool(false), false)?; + info!("testBool"); + verify_expected_result(thrift_test_client.test_bool(false), false)?; - println!("testByte"); - verify_expected_result(client.test_byte(42), 42)?; + info!("testByte"); + verify_expected_result(thrift_test_client.test_byte(42), 42)?; - println!("testi32"); - verify_expected_result(client.test_i32(1159348374), 1159348374)?; + info!("testi32"); + verify_expected_result(thrift_test_client.test_i32(1159348374), 1159348374)?; - println!("testi64"); - // try!(verify_expected_result(client.test_i64(-8651829879438294565), + info!("testi64"); + // try!(verify_expected_result(thrift_test_client.test_i64(-8651829879438294565), // -8651829879438294565)); - verify_expected_result(client.test_i64(i64::min_value()), i64::min_value())?; + verify_expected_result( + thrift_test_client.test_i64(i64::min_value()), + i64::min_value(), + )?; - println!("testDouble"); + info!("testDouble"); verify_expected_result( - client.test_double(OrderedFloat::from(42.42)), + thrift_test_client.test_double(OrderedFloat::from(42.42)), OrderedFloat::from(42.42), )?; - println!("testTypedef"); + info!("testTypedef"); { let u_snd: UserId = 2348; let u_cmp: UserId = 2348; - verify_expected_result(client.test_typedef(u_snd), u_cmp)?; + verify_expected_result(thrift_test_client.test_typedef(u_snd), u_cmp)?; } - println!("testEnum"); + info!("testEnum"); { - verify_expected_result(client.test_enum(Numberz::TWO), Numberz::TWO)?; + verify_expected_result(thrift_test_client.test_enum(Numberz::TWO), Numberz::TWO)?; } - println!("testBinary"); + info!("testBinary"); { let b_snd = vec![0x77, 0x30, 0x30, 0x74, 0x21, 0x20, 0x52, 0x75, 0x73, 0x74]; let b_cmp = vec![0x77, 0x30, 0x30, 0x74, 0x21, 0x20, 0x52, 0x75, 0x73, 0x74]; - verify_expected_result(client.test_binary(b_snd), b_cmp)?; + verify_expected_result(thrift_test_client.test_binary(b_snd), b_cmp)?; } - println!("testStruct"); + info!("testStruct"); { let x_snd = Xtruct { string_thing: Some("foo".to_owned()), @@ -185,7 +240,7 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< i32_thing: Some(219129), i64_thing: Some(12938492818), }; - verify_expected_result(client.test_struct(x_snd), x_cmp)?; + verify_expected_result(thrift_test_client.test_struct(x_snd), x_cmp)?; } // Xtruct again, with optional values @@ -197,12 +252,11 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< // let x_cmp = Xtruct { string_thing: Some("foo".to_owned()), byte_thing: // Some(0), i32_thing: Some(0), i64_thing: Some(12938492818) }; // the C++ // server is responding correctly - // try!(verify_expected_result(client.test_struct(x_snd), x_cmp)); + // try!(verify_expected_result(thrift_test_client.test_struct(x_snd), x_cmp)); // } // - - println!("testNest"); // (FIXME: try Xtruct2 with optional values) + info!("testNest"); // (FIXME: try Xtruct2 with optional values) { let x_snd = Xtruct2 { byte_thing: Some(32), @@ -228,10 +282,33 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< ), i32_thing: Some(293481098), }; - verify_expected_result(client.test_nest(x_snd), x_cmp)?; + verify_expected_result(thrift_test_client.test_nest(x_snd), x_cmp)?; + } + + // do the multiplexed calls while making the main ThriftTest calls + if let Some(ref mut client) = second_service_client.as_mut() { + info!("SecondService blahBlah"); + { + let r = client.blah_blah(); + match r { + Err(thrift::Error::Application(ref e)) => { + info!("received an {:?}", e); + Ok(()) + } + _ => Err(thrift::Error::User("did not get exception".into())), + }?; + } + + info!("SecondService secondtestString"); + { + verify_expected_result( + client.secondtest_string("test_string".to_owned()), + "testString(\"test_string\")".to_owned(), + )?; + } } - println!("testList"); + info!("testList"); { let mut v_snd: Vec<i32> = Vec::new(); v_snd.push(29384); @@ -243,10 +320,10 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< v_cmp.push(238); v_cmp.push(32498); - verify_expected_result(client.test_list(v_snd), v_cmp)?; + verify_expected_result(thrift_test_client.test_list(v_snd), v_cmp)?; } - println!("testSet"); + info!("testSet"); { let mut s_snd: BTreeSet<i32> = BTreeSet::new(); s_snd.insert(293481); @@ -258,10 +335,10 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< s_cmp.insert(23); s_cmp.insert(3234); - verify_expected_result(client.test_set(s_snd), s_cmp)?; + verify_expected_result(thrift_test_client.test_set(s_snd), s_cmp)?; } - println!("testMap"); + info!("testMap"); { let mut m_snd: BTreeMap<i32, i32> = BTreeMap::new(); m_snd.insert(2, 4); @@ -273,10 +350,10 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< m_cmp.insert(4, 6); m_cmp.insert(8, 7); - verify_expected_result(client.test_map(m_snd), m_cmp)?; + verify_expected_result(thrift_test_client.test_map(m_snd), m_cmp)?; } - println!("testStringMap"); + info!("testStringMap"); { let mut m_snd: BTreeMap<String, String> = BTreeMap::new(); m_snd.insert("2".to_owned(), "4_string".to_owned()); @@ -288,13 +365,13 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< m_rcv.insert("4".to_owned(), "6_string".to_owned()); m_rcv.insert("8".to_owned(), "7_string".to_owned()); - verify_expected_result(client.test_string_map(m_snd), m_rcv)?; + verify_expected_result(thrift_test_client.test_string_map(m_snd), m_rcv)?; } // nested map // expect : {-4 => {-4 => -4, -3 => -3, -2 => -2, -1 => -1, }, 4 => {1 => 1, 2 // => 2, 3 => 3, 4 => 4, }, } - println!("testMapMap"); + info!("testMapMap"); { let mut m_cmp_nested_0: BTreeMap<i32, i32> = BTreeMap::new(); for i in (-4 as i32)..0 { @@ -309,10 +386,10 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< m_cmp.insert(-4, m_cmp_nested_0); m_cmp.insert(4, m_cmp_nested_1); - verify_expected_result(client.test_map_map(42), m_cmp)?; + verify_expected_result(thrift_test_client.test_map_map(42), m_cmp)?; } - println!("testMulti"); + info!("testMulti"); { let mut m_snd: BTreeMap<i16, String> = BTreeMap::new(); m_snd.insert(1298, "fizz".to_owned()); @@ -326,7 +403,7 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< }; verify_expected_result( - client.test_multi(1, -123948, -19234123981, m_snd, Numberz::EIGHT, 81), + thrift_test_client.test_multi(1, -123948, -19234123981, m_snd, Numberz::EIGHT, 81), s_cmp, )?; } @@ -388,12 +465,12 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< s_cmp.insert(1 as UserId, s_cmp_nested_1); s_cmp.insert(2 as UserId, s_cmp_nested_2); - verify_expected_result(client.test_insanity(insanity.clone()), s_cmp)?; + verify_expected_result(thrift_test_client.test_insanity(insanity.clone()), s_cmp)?; } - println!("testException - remote throws Xception"); + info!("testException - remote throws Xception"); { - let r = client.test_exception("Xception".to_owned()); + let r = thrift_test_client.test_exception("Xception".to_owned()); let x = match r { Err(thrift::Error::User(ref e)) => { match e.downcast_ref::<Xception>() { @@ -412,30 +489,31 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< verify_expected_result(Ok(x), &x_cmp)?; } - println!("testException - remote throws TApplicationException"); + info!("testException - remote throws TApplicationException"); { - let r = client.test_exception("TException".to_owned()); + let r = thrift_test_client.test_exception("TException".to_owned()); match r { Err(thrift::Error::Application(ref e)) => { - println!("received an {:?}", e); + info!("received an {:?}", e); Ok(()) } _ => Err(thrift::Error::User("did not get exception".into())), }?; } - println!("testException - remote succeeds"); + info!("testException - remote succeeds"); { - let r = client.test_exception("foo".to_owned()); + let r = thrift_test_client.test_exception("foo".to_owned()); match r { Ok(_) => Ok(()), _ => Err(thrift::Error::User("received an exception".into())), }?; } - println!("testMultiException - remote throws Xception"); + info!("testMultiException - remote throws Xception"); { - let r = client.test_multi_exception("Xception".to_owned(), "ignored".to_owned()); + let r = + thrift_test_client.test_multi_exception("Xception".to_owned(), "ignored".to_owned()); let x = match r { Err(thrift::Error::User(ref e)) => { match e.downcast_ref::<Xception>() { @@ -454,9 +532,10 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< verify_expected_result(Ok(x), &x_cmp)?; } - println!("testMultiException - remote throws Xception2"); + info!("testMultiException - remote throws Xception2"); { - let r = client.test_multi_exception("Xception2".to_owned(), "ignored".to_owned()); + let r = + thrift_test_client.test_multi_exception("Xception2".to_owned(), "ignored".to_owned()); let x = match r { Err(thrift::Error::User(ref e)) => { match e.downcast_ref::<Xception2>() { @@ -485,9 +564,9 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< verify_expected_result(Ok(x), &x_cmp)?; } - println!("testMultiException - remote succeeds"); + info!("testMultiException - remote succeeds"); { - let r = client.test_multi_exception("haha".to_owned(), "RETURNED".to_owned()); + let r = thrift_test_client.test_multi_exception("haha".to_owned(), "RETURNED".to_owned()); let x = match r { Err(e) => Err(thrift::Error::User(format!("received an unexpected exception {:?}", e).into(),),), _ => r, @@ -506,14 +585,14 @@ fn make_thrift_calls(client: &mut ThriftTestSyncClient<Box<TInputProtocol>, Box< verify_expected_result(Ok(x), x_cmp)?; } - println!("testOneWay - remote sleeps for 1 second"); + info!("testOneWay - remote sleeps for 1 second"); { - client.test_oneway(1)?; + thrift_test_client.test_oneway(1)?; } // final test to verify that the connection is still writable after the one-way // call - client.test_void() + thrift_test_client.test_void() } #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))] diff --git a/test/rs/src/bin/test_server.rs b/test/rs/src/bin/test_server.rs index 9c738ab01..a32e93880 100644 --- a/test/rs/src/bin/test_server.rs +++ b/test/rs/src/bin/test_server.rs @@ -16,6 +16,10 @@ // under the License. #[macro_use] +extern crate log; +extern crate env_logger; + +#[macro_use] extern crate clap; extern crate ordered_float; extern crate thrift; @@ -29,17 +33,21 @@ use std::time::Duration; use thrift::protocol::{TBinaryInputProtocolFactory, TBinaryOutputProtocolFactory, TCompactInputProtocolFactory, TCompactOutputProtocolFactory, TInputProtocolFactory, TOutputProtocolFactory}; -use thrift::server::TServer; +use thrift::server::{TMultiplexedProcessor, TServer}; use thrift::transport::{TBufferedReadTransportFactory, TBufferedWriteTransportFactory, TFramedReadTransportFactory, TFramedWriteTransportFactory, TReadTransportFactory, TWriteTransportFactory}; use thrift_test::*; fn main() { + env_logger::init().expect("logger setup failed"); + + debug!("initialized logger - running cross-test server"); + match run() { - Ok(()) => println!("cross-test server succeeded"), + Ok(()) => info!("cross-test server succeeded"), Err(e) => { - println!("cross-test server failed with error {:?}", e); + info!("cross-test server failed with error {:?}", e); std::process::exit(1); } } @@ -70,7 +78,7 @@ fn run() -> thrift::Result<()> { let workers = value_t!(matches, "workers", usize).unwrap_or(4); let listen_address = format!("127.0.0.1:{}", port); - println!("binding to {}", listen_address); + info!("binding to {}", listen_address); let (i_transport_factory, o_transport_factory): (Box<TReadTransportFactory>, Box<TWriteTransportFactory>) = @@ -91,11 +99,11 @@ fn run() -> thrift::Result<()> { let (i_protocol_factory, o_protocol_factory): (Box<TInputProtocolFactory>, Box<TOutputProtocolFactory>) = match &*protocol { - "binary" => { + "binary" | "multi" | "multi:binary" => { (Box::new(TBinaryInputProtocolFactory::new()), Box::new(TBinaryOutputProtocolFactory::new())) } - "compact" => { + "compact" | "multic" | "multi:compact" => { (Box::new(TCompactInputProtocolFactory::new()), Box::new(TCompactOutputProtocolFactory::new())) } @@ -104,91 +112,100 @@ fn run() -> thrift::Result<()> { } }; - let processor = ThriftTestSyncProcessor::new(ThriftTestSyncHandlerImpl {}); - - let mut server = match &*server_type { - "simple" => { - TServer::new( - i_transport_factory, - i_protocol_factory, - o_transport_factory, - o_protocol_factory, - processor, - 1, - ) - } - "thread-pool" => { - TServer::new( - i_transport_factory, - i_protocol_factory, - o_transport_factory, - o_protocol_factory, - processor, - workers, - ) - } - unknown => { - return Err(format!("unsupported server type {}", unknown).into()); + let test_processor = ThriftTestSyncProcessor::new(ThriftTestSyncHandlerImpl {}); + + match &*server_type { + "simple" | "thread-pool" => { + if protocol == "multi" || protocol == "multic" { + let second_service_processor = SecondServiceSyncProcessor::new(SecondServiceSyncHandlerImpl {},); + + let mut multiplexed_processor = TMultiplexedProcessor::new(); + multiplexed_processor + .register("ThriftTest", Box::new(test_processor), true)?; + multiplexed_processor + .register("SecondService", Box::new(second_service_processor), false)?; + + let mut server = TServer::new( + i_transport_factory, + i_protocol_factory, + o_transport_factory, + o_protocol_factory, + multiplexed_processor, + workers, + ); + + server.listen(&listen_address) + } else { + let mut server = TServer::new( + i_transport_factory, + i_protocol_factory, + o_transport_factory, + o_protocol_factory, + test_processor, + workers, + ); + + server.listen(&listen_address) + } } - }; - - server.listen(&listen_address) + unknown => Err(format!("unsupported server type {}", unknown).into()), + } } struct ThriftTestSyncHandlerImpl; impl ThriftTestSyncHandler for ThriftTestSyncHandlerImpl { fn handle_test_void(&self) -> thrift::Result<()> { - println!("testVoid()"); + info!("testVoid()"); Ok(()) } fn handle_test_string(&self, thing: String) -> thrift::Result<String> { - println!("testString({})", &thing); + info!("testString({})", &thing); Ok(thing) } fn handle_test_bool(&self, thing: bool) -> thrift::Result<bool> { - println!("testBool({})", thing); + info!("testBool({})", thing); Ok(thing) } fn handle_test_byte(&self, thing: i8) -> thrift::Result<i8> { - println!("testByte({})", thing); + info!("testByte({})", thing); Ok(thing) } fn handle_test_i32(&self, thing: i32) -> thrift::Result<i32> { - println!("testi32({})", thing); + info!("testi32({})", thing); Ok(thing) } fn handle_test_i64(&self, thing: i64) -> thrift::Result<i64> { - println!("testi64({})", thing); + info!("testi64({})", thing); Ok(thing) } fn handle_test_double(&self, thing: OrderedFloat<f64>) -> thrift::Result<OrderedFloat<f64>> { - println!("testDouble({})", thing); + info!("testDouble({})", thing); Ok(thing) } fn handle_test_binary(&self, thing: Vec<u8>) -> thrift::Result<Vec<u8>> { - println!("testBinary({:?})", thing); + info!("testBinary({:?})", thing); Ok(thing) } fn handle_test_struct(&self, thing: Xtruct) -> thrift::Result<Xtruct> { - println!("testStruct({:?})", thing); + info!("testStruct({:?})", thing); Ok(thing) } fn handle_test_nest(&self, thing: Xtruct2) -> thrift::Result<Xtruct2> { - println!("testNest({:?})", thing); + info!("testNest({:?})", thing); Ok(thing) } fn handle_test_map(&self, thing: BTreeMap<i32, i32>) -> thrift::Result<BTreeMap<i32, i32>> { - println!("testMap({:?})", thing); + info!("testMap({:?})", thing); Ok(thing) } @@ -196,27 +213,27 @@ impl ThriftTestSyncHandler for ThriftTestSyncHandlerImpl { &self, thing: BTreeMap<String, String>, ) -> thrift::Result<BTreeMap<String, String>> { - println!("testStringMap({:?})", thing); + info!("testStringMap({:?})", thing); Ok(thing) } fn handle_test_set(&self, thing: BTreeSet<i32>) -> thrift::Result<BTreeSet<i32>> { - println!("testSet({:?})", thing); + info!("testSet({:?})", thing); Ok(thing) } fn handle_test_list(&self, thing: Vec<i32>) -> thrift::Result<Vec<i32>> { - println!("testList({:?})", thing); + info!("testList({:?})", thing); Ok(thing) } fn handle_test_enum(&self, thing: Numberz) -> thrift::Result<Numberz> { - println!("testEnum({:?})", thing); + info!("testEnum({:?})", thing); Ok(thing) } fn handle_test_typedef(&self, thing: UserId) -> thrift::Result<UserId> { - println!("testTypedef({})", thing); + info!("testTypedef({})", thing); Ok(thing) } @@ -224,7 +241,7 @@ impl ThriftTestSyncHandler for ThriftTestSyncHandlerImpl { /// {-4 => {-4 => -4, -3 => -3, -2 => -2, -1 => -1, }, 4 => {1 => 1, 2 => /// 2, 3 => 3, 4 => 4, }, } fn handle_test_map_map(&self, hello: i32) -> thrift::Result<BTreeMap<i32, BTreeMap<i32, i32>>> { - println!("testMapMap({})", hello); + info!("testMapMap({})", hello); let mut inner_map_0: BTreeMap<i32, i32> = BTreeMap::new(); for i in -4..(0 as i32) { @@ -254,7 +271,7 @@ impl ThriftTestSyncHandler for ThriftTestSyncHandlerImpl { &self, argument: Insanity, ) -> thrift::Result<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>> { - println!("testInsanity({:?})", argument); + info!("testInsanity({:?})", argument); let mut map_0: BTreeMap<Numberz, Insanity> = BTreeMap::new(); map_0.insert(Numberz::TWO, argument.clone()); map_0.insert(Numberz::THREE, argument.clone()); @@ -300,7 +317,7 @@ impl ThriftTestSyncHandler for ThriftTestSyncHandlerImpl { /// else if arg == "TException" throw TException /// else do not throw anything fn handle_test_exception(&self, arg: String) -> thrift::Result<()> { - println!("testException({})", arg); + info!("testException({})", arg); match &*arg { "Xception" => { @@ -370,3 +387,16 @@ impl ThriftTestSyncHandler for ThriftTestSyncHandlerImpl { Ok(()) } } + +struct SecondServiceSyncHandlerImpl; +impl SecondServiceSyncHandler for SecondServiceSyncHandlerImpl { + fn handle_blah_blah(&self) -> thrift::Result<()> { + Err(thrift::new_application_error(thrift::ApplicationErrorKind::Unknown, "blahBlah"),) + } + + fn handle_secondtest_string(&self, thing: String) -> thrift::Result<String> { + info!("testString({})", &thing); + let ret = format!("testString(\"{}\")", &thing); + Ok(ret) + } +} |