http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/configure.ac ---------------------------------------------------------------------- diff --git a/configure.ac b/configure.ac index dad10a7..0452a15 100755 --- a/configure.ac +++ b/configure.ac @@ -129,6 +129,7 @@ if test "$enable_libs" = "no"; then with_d="no" with_nodejs="no" with_lua="no" + with_rs="no" fi @@ -410,6 +411,29 @@ if test "$with_go" = "yes"; then fi AM_CONDITIONAL(WITH_GO, [test "$have_go" = "yes"]) +AX_THRIFT_LIB(rs, [Rust], yes) +have_rs="no" +if test "$with_rs" = "yes"; then + AC_PATH_PROG([CARGO], [cargo]) + AC_PATH_PROG([RUSTC], [rustc]) + if [[ -x "$CARGO" ]] && [[ -x "$RUSTC" ]]; then + min_rustc_version="1.13" + + AC_MSG_CHECKING([for rustc version]) + rustc_version=`$RUSTC --version 2>&1 | $SED -e 's/\(rustc \)\([0-9]\)\.\([0-9][0-9]*\)\.\([0-9][0-9]*\).*/\2.\3/'` + AC_MSG_RESULT($rustc_version) + AC_SUBST([rustc_version],[$rustc_version]) + + AX_COMPARE_VERSION([$min_rustc_version],[le],[$rustc_version],[ + : + have_rs="yes" + ],[ + : + have_rs="no" + ]) + fi +fi +AM_CONDITIONAL(WITH_RS, [test "$have_rs" = "yes"]) AX_THRIFT_LIB(haxe, [Haxe], yes) if test "$with_haxe" = "yes"; then @@ -777,6 +801,8 @@ AC_CONFIG_FILES([ lib/dart/Makefile lib/py/Makefile lib/rb/Makefile + lib/rs/Makefile + lib/rs/test/Makefile lib/lua/Makefile lib/xml/Makefile lib/xml/test/Makefile @@ -798,6 +824,7 @@ AC_CONFIG_FILES([ test/py.twisted/Makefile test/py.tornado/Makefile test/rb/Makefile + test/rs/Makefile tutorial/Makefile tutorial/c_glib/Makefile tutorial/cpp/Makefile @@ -814,6 +841,7 @@ AC_CONFIG_FILES([ tutorial/py.twisted/Makefile tutorial/py.tornado/Makefile tutorial/rb/Makefile + tutorial/rs/Makefile ]) if test "$have_cpp" = "yes" ; then MAYBE_CPP="cpp" ; else MAYBE_CPP="" ; fi @@ -848,6 +876,8 @@ if test "$have_erlang" = "yes" ; then MAYBE_ERLANG="erl" ; else MAYBE_ERLANG="" AC_SUBST([MAYBE_ERLANG]) if test "$have_lua" = "yes" ; then MAYBE_LUA="lua" ; else MAYBE_LUA="" ; fi AC_SUBST([MAYBE_LUA]) +if test "$have_rs" = "yes" ; then MAYBE_RS="rs" ; else MAYBE_RS="" ; fi +AC_SUBST([MAYBE_RS]) AC_OUTPUT @@ -873,6 +903,7 @@ echo "Building Go Library .......... : $have_go" echo "Building D Library ........... : $have_d" echo "Building NodeJS Library ...... : $have_nodejs" echo "Building Lua Library ......... : $have_lua" +echo "Building Rust Library ........ : $have_rs" if test "$have_cpp" = "yes" ; then echo @@ -974,6 +1005,13 @@ if test "$have_lua" = "yes" ; then echo "Lua Library:" echo " Using Lua .............. : $LUA" fi +if test "$have_rs" = "yes" ; then + echo + echo "Rust Library:" + echo " Using Cargo................ : $CARGO" + echo " Using rustc................ : $RUSTC" + echo " Using Rust version......... : $($RUSTC --version)" +fi echo echo "If something is missing that you think should be present," echo "please skim the output of configure to find the missing"
http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/Makefile.am ---------------------------------------------------------------------- diff --git a/lib/Makefile.am b/lib/Makefile.am index 21d807a..636f42c 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am @@ -93,6 +93,10 @@ if WITH_LUA SUBDIRS += lua endif +if WITH_RS +SUBDIRS += rs +endif + # All of the libs that don't use Automake need to go in here # so they will end up in our release tarballs. EXTRA_DIST = \ http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/Cargo.toml ---------------------------------------------------------------------- diff --git a/lib/rs/Cargo.toml b/lib/rs/Cargo.toml new file mode 100644 index 0000000..07c5e67 --- /dev/null +++ b/lib/rs/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "thrift" +description = "Rust bindings for the Apache Thrift RPC system" +version = "1.0.0" +license = "Apache-2.0" +authors = ["Apache Thrift Developers <[email protected]>"] +homepage = "http://thrift.apache.org"; +documentation = "https://thrift.apache.org"; +readme = "README.md" +exclude = ["Makefile*", "test/**"] +keywords = ["thrift"] + +[dependencies] +integer-encoding = "1.0.3" +log = "~0.3.6" +byteorder = "0.5.3" +try_from = "0.2.0" + http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/Makefile.am ---------------------------------------------------------------------- diff --git a/lib/rs/Makefile.am b/lib/rs/Makefile.am new file mode 100644 index 0000000..0a34120 --- /dev/null +++ b/lib/rs/Makefile.am @@ -0,0 +1,46 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +SUBDIRS = . + +if WITH_TESTS +SUBDIRS += test +endif + +install: + @echo '##############################################################' + @echo '##############################################################' + @echo 'The Rust client library should be installed via a Cargo.toml dependency - please see /lib/rs/README.md' + @echo '##############################################################' + @echo '##############################################################' + +check-local: + $(CARGO) test + +all-local: + $(CARGO) build + +clean-local: + $(CARGO) clean + -$(RM) Cargo.lock + +EXTRA_DIST = \ + src \ + Cargo.toml \ + README.md http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/README.md ---------------------------------------------------------------------- diff --git a/lib/rs/README.md b/lib/rs/README.md new file mode 100644 index 0000000..8b35eda --- /dev/null +++ b/lib/rs/README.md @@ -0,0 +1,60 @@ +# Rust Thrift library + +## Overview + +This crate implements the components required to build a working Thrift server +and client. It is divided into the following modules: + + 1. errors + 2. protocol + 3. transport + 4. server + 5. autogen + +The modules are layered as shown. The `generated` layer is code generated by the +Thrift compiler's Rust plugin. It uses the components defined in this crate to +serialize and deserialize types and implement RPC. Users interact with these +types and services by writing their own code on top. + + ```text + +-----------+ + | app dev | + +-----------+ + | generated | <-> errors/results + +-----------+ + | protocol | + +-----------+ + | transport | + +-----------+ + ``` + +## Using this crate + +Add `thrift = "x.y.z"` to your `Cargo.toml`, where `x.y.z` is the version of the +Thrift compiler you're using. + +## API Documentation + +Full [Rustdoc](https://docs.rs/thrift/) + +## Contributing + +Bug reports and PRs are always welcome! Please see the +[Thrift website](https://thrift.apache.org/) for more details. + +Thrift Rust support requires code in several directories: + +* `compiler/cpp/src/thrift/generate/t_rs_generator.cc`: binding code generator +* `lib/rs`: runtime library +* `lib/rs/test`: supplemental tests +* `tutorial/rs`: tutorial client and server +* `test/rs`: cross-language test client and server + +All library code, test code and auto-generated code compiles and passes clippy +without warnings. All new code must do the same! When making changes ensure that: + +* `rustc` does does output any warnings +* `clippy` with default settings does not output any warnings (includes auto-generated code) +* `cargo test` is successful +* `make precross` and `make check` are successful +* `tutorial/bin/tutorial_client` and `tutorial/bin/tutorial_server` communicate http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/src/autogen.rs ---------------------------------------------------------------------- diff --git a/lib/rs/src/autogen.rs b/lib/rs/src/autogen.rs new file mode 100644 index 0000000..289c7be --- /dev/null +++ b/lib/rs/src/autogen.rs @@ -0,0 +1,45 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Thrift compiler auto-generated support. +//! +//! +//! Types and functions used internally by the Thrift compiler's Rust plugin +//! to implement required functionality. Users should never have to use code +//! in this module directly. + +use ::protocol::{TInputProtocol, TOutputProtocol}; + +/// Specifies the minimum functionality an auto-generated client should provide +/// to communicate with a Thrift server. +pub trait TThriftClient { + /// Returns the input protocol used to read serialized Thrift messages + /// from the Thrift server. + fn i_prot_mut(&mut self) -> &mut TInputProtocol; + /// Returns the output protocol used to write serialized Thrift messages + /// to the Thrift server. + fn o_prot_mut(&mut self) -> &mut TOutputProtocol; + /// Returns the sequence number of the last message written to the Thrift + /// server. Returns `0` if no messages have been written. Sequence + /// numbers should *never* be negative, and this method returns an `i32` + /// simply because the Thrift protocol encodes sequence numbers as `i32` on + /// the wire. + fn sequence_number(&self) -> i32; // FIXME: consider returning a u32 + /// Increments the sequence number, indicating that a message with that + /// number has been sent to the Thrift server. + fn increment_sequence_number(&mut self) -> i32; +} http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/src/errors.rs ---------------------------------------------------------------------- diff --git a/lib/rs/src/errors.rs b/lib/rs/src/errors.rs new file mode 100644 index 0000000..a6049d5 --- /dev/null +++ b/lib/rs/src/errors.rs @@ -0,0 +1,678 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +use std::convert::{From, Into}; +use std::error::Error as StdError; +use std::fmt::{Debug, Display, Formatter}; +use std::{error, fmt, io, string}; +use try_from::TryFrom; + +use ::protocol::{TFieldIdentifier, TInputProtocol, TOutputProtocol, TStructIdentifier, TType}; + +// FIXME: should all my error structs impl error::Error as well? +// FIXME: should all fields in TransportError, ProtocolError and ApplicationError be optional? + +/// Error type returned by all runtime library functions. +/// +/// `thrift::Error` is used throughout this crate as well as in auto-generated +/// Rust code. It consists of four variants defined by convention across Thrift +/// implementations: +/// +/// 1. `Transport`: errors encountered while operating on I/O channels +/// 2. `Protocol`: errors encountered during runtime-library processing +/// 3. `Application`: errors encountered within auto-generated code +/// 4. `User`: IDL-defined exception structs +/// +/// The `Application` variant also functions as a catch-all: all handler errors +/// are automatically turned into application errors. +/// +/// All error variants except `Error::User` take an eponymous struct with two +/// required fields: +/// +/// 1. `kind`: variant-specific enum identifying the error sub-type +/// 2. `message`: human-readable error info string +/// +/// `kind` is defined by convention while `message` is freeform. If none of the +/// enumerated kinds are suitable use `Unknown`. +/// +/// To simplify error creation convenience constructors are defined for all +/// variants, and conversions from their structs (`thrift::TransportError`, +/// `thrift::ProtocolError` and `thrift::ApplicationError` into `thrift::Error`. +/// +/// # Examples +/// +/// Create a `TransportError`. +/// +/// ``` +/// use thrift; +/// use thrift::{TransportError, TransportErrorKind}; +/// +/// // explicit +/// let err0: thrift::Result<()> = Err( +/// thrift::Error::Transport( +/// TransportError { +/// kind: TransportErrorKind::TimedOut, +/// message: format!("connection to server timed out") +/// } +/// ) +/// ); +/// +/// // use conversion +/// let err1: thrift::Result<()> = Err( +/// thrift::Error::from( +/// TransportError { +/// kind: TransportErrorKind::TimedOut, +/// message: format!("connection to server timed out") +/// } +/// ) +/// ); +/// +/// // use struct constructor +/// let err2: thrift::Result<()> = Err( +/// thrift::Error::Transport( +/// TransportError::new( +/// TransportErrorKind::TimedOut, +/// "connection to server timed out" +/// ) +/// ) +/// ); +/// +/// +/// // use error variant constructor +/// let err3: thrift::Result<()> = Err( +/// thrift::new_transport_error( +/// TransportErrorKind::TimedOut, +/// "connection to server timed out" +/// ) +/// ); +/// ``` +/// +/// Create an error from a string. +/// +/// ``` +/// use thrift; +/// use thrift::{ApplicationError, ApplicationErrorKind}; +/// +/// // we just use `From::from` to convert a `String` into a `thrift::Error` +/// let err0: thrift::Result<()> = Err( +/// thrift::Error::from("This is an error") +/// ); +/// +/// // err0 is equivalent to... +/// let err1: thrift::Result<()> = Err( +/// thrift::Error::Application( +/// ApplicationError { +/// kind: ApplicationErrorKind::Unknown, +/// message: format!("This is an error") +/// } +/// ) +/// ); +/// ``` +/// +/// Return an IDL-defined exception. +/// +/// ```text +/// // Thrift IDL exception definition. +/// exception Xception { +/// 1: i32 errorCode, +/// 2: string message +/// } +/// ``` +/// +/// ``` +/// use std::convert::From; +/// use std::error::Error; +/// use std::fmt; +/// use std::fmt::{Display, Formatter}; +/// +/// // auto-generated by the Thrift compiler +/// #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] +/// pub struct Xception { +/// pub error_code: Option<i32>, +/// pub message: Option<String>, +/// } +/// +/// // auto-generated by the Thrift compiler +/// impl Error for Xception { +/// fn description(&self) -> &str { +/// "remote service threw Xception" +/// } +/// } +/// +/// // auto-generated by the Thrift compiler +/// impl From<Xception> for thrift::Error { +/// fn from(e: Xception) -> Self { +/// thrift::Error::User(Box::new(e)) +/// } +/// } +/// +/// // auto-generated by the Thrift compiler +/// impl Display for Xception { +/// fn fmt(&self, f: &mut Formatter) -> fmt::Result { +/// self.description().fmt(f) +/// } +/// } +/// +/// // in user code... +/// let err: thrift::Result<()> = Err( +/// thrift::Error::from(Xception { error_code: Some(1), message: None }) +/// ); +/// ``` +pub enum Error { + /// Errors encountered while operating on I/O channels. + /// + /// These include *connection closed* and *bind failure*. + Transport(TransportError), + /// Errors encountered during runtime-library processing. + /// + /// These include *message too large* and *unsupported protocol version*. + Protocol(ProtocolError), + /// Errors encountered within auto-generated code, or when incoming + /// or outgoing messages violate the Thrift spec. + /// + /// These include *out-of-order messages* and *missing required struct + /// fields*. + /// + /// This variant also functions as a catch-all: errors from handler + /// functions are automatically returned as an `ApplicationError`. + Application(ApplicationError), + /// IDL-defined exception structs. + User(Box<error::Error + Sync + Send>), +} + +impl Error { + /// Create an `ApplicationError` from its wire representation. + /// + /// Application code **should never** call this method directly. + pub fn read_application_error_from_in_protocol(i: &mut TInputProtocol) + -> ::Result<ApplicationError> { + let mut message = "general remote error".to_owned(); + let mut kind = ApplicationErrorKind::Unknown; + + i.read_struct_begin()?; + + loop { + let field_ident = i.read_field_begin()?; + + if field_ident.field_type == TType::Stop { + break; + } + + let id = field_ident.id.expect("sender should always specify id for non-STOP field"); + + match id { + 1 => { + let remote_message = i.read_string()?; + i.read_field_end()?; + message = remote_message; + } + 2 => { + let remote_type_as_int = i.read_i32()?; + let remote_kind: ApplicationErrorKind = TryFrom::try_from(remote_type_as_int) + .unwrap_or(ApplicationErrorKind::Unknown); + i.read_field_end()?; + kind = remote_kind; + } + _ => { + i.skip(field_ident.field_type)?; + } + } + } + + i.read_struct_end()?; + + Ok(ApplicationError { + kind: kind, + message: message, + }) + } + + /// Convert an `ApplicationError` into its wire representation and write + /// it to the remote. + /// + /// Application code **should never** call this method directly. + pub fn write_application_error_to_out_protocol(e: &ApplicationError, + o: &mut TOutputProtocol) + -> ::Result<()> { + o.write_struct_begin(&TStructIdentifier { name: "TApplicationException".to_owned() })?; + + let message_field = TFieldIdentifier::new("message", TType::String, 1); + let type_field = TFieldIdentifier::new("type", TType::I32, 2); + + o.write_field_begin(&message_field)?; + o.write_string(&e.message)?; + o.write_field_end()?; + + o.write_field_begin(&type_field)?; + o.write_i32(e.kind as i32)?; + o.write_field_end()?; + + o.write_field_stop()?; + o.write_struct_end()?; + + o.flush() + } +} + +impl error::Error for Error { + fn description(&self) -> &str { + match *self { + Error::Transport(ref e) => TransportError::description(e), + Error::Protocol(ref e) => ProtocolError::description(e), + Error::Application(ref e) => ApplicationError::description(e), + Error::User(ref e) => e.description(), + } + } +} + +impl Debug for Error { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + match *self { + Error::Transport(ref e) => Debug::fmt(e, f), + Error::Protocol(ref e) => Debug::fmt(e, f), + Error::Application(ref e) => Debug::fmt(e, f), + Error::User(ref e) => Debug::fmt(e, f), + } + } +} + +impl Display for Error { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + match *self { + Error::Transport(ref e) => Display::fmt(e, f), + Error::Protocol(ref e) => Display::fmt(e, f), + Error::Application(ref e) => Display::fmt(e, f), + Error::User(ref e) => Display::fmt(e, f), + } + } +} + +impl From<String> for Error { + fn from(s: String) -> Self { + Error::Application(ApplicationError { + kind: ApplicationErrorKind::Unknown, + message: s, + }) + } +} + +impl<'a> From<&'a str> for Error { + fn from(s: &'a str) -> Self { + Error::Application(ApplicationError { + kind: ApplicationErrorKind::Unknown, + message: String::from(s), + }) + } +} + +impl From<TransportError> for Error { + fn from(e: TransportError) -> Self { + Error::Transport(e) + } +} + +impl From<ProtocolError> for Error { + fn from(e: ProtocolError) -> Self { + Error::Protocol(e) + } +} + +impl From<ApplicationError> for Error { + fn from(e: ApplicationError) -> Self { + Error::Application(e) + } +} + +/// Create a new `Error` instance of type `Transport` that wraps a +/// `TransportError`. +pub fn new_transport_error<S: Into<String>>(kind: TransportErrorKind, message: S) -> Error { + Error::Transport(TransportError::new(kind, message)) +} + +/// Information about I/O errors. +#[derive(Debug)] +pub struct TransportError { + /// I/O error variant. + /// + /// If a specific `TransportErrorKind` does not apply use + /// `TransportErrorKind::Unknown`. + pub kind: TransportErrorKind, + /// Human-readable error message. + pub message: String, +} + +impl TransportError { + /// Create a new `TransportError`. + pub fn new<S: Into<String>>(kind: TransportErrorKind, message: S) -> TransportError { + TransportError { + kind: kind, + message: message.into(), + } + } +} + +/// I/O error categories. +/// +/// This list may grow, and it is not recommended to match against it. +#[derive(Clone, Copy, Eq, Debug, PartialEq)] +pub enum TransportErrorKind { + /// Catch-all I/O error. + Unknown = 0, + /// An I/O operation was attempted when the transport channel was not open. + NotOpen = 1, + /// The transport channel cannot be opened because it was opened previously. + AlreadyOpen = 2, + /// An I/O operation timed out. + TimedOut = 3, + /// A read could not complete because no bytes were available. + EndOfFile = 4, + /// An invalid (buffer/message) size was requested or received. + NegativeSize = 5, + /// Too large a buffer or message size was requested or received. + SizeLimit = 6, +} + +impl TransportError { + fn description(&self) -> &str { + match self.kind { + TransportErrorKind::Unknown => "transport error", + TransportErrorKind::NotOpen => "not open", + TransportErrorKind::AlreadyOpen => "already open", + TransportErrorKind::TimedOut => "timed out", + TransportErrorKind::EndOfFile => "end of file", + TransportErrorKind::NegativeSize => "negative size message", + TransportErrorKind::SizeLimit => "message too long", + } + } +} + +impl Display for TransportError { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + write!(f, "{}", self.description()) + } +} + +impl TryFrom<i32> for TransportErrorKind { + type Err = Error; + fn try_from(from: i32) -> Result<Self, Self::Err> { + match from { + 0 => Ok(TransportErrorKind::Unknown), + 1 => Ok(TransportErrorKind::NotOpen), + 2 => Ok(TransportErrorKind::AlreadyOpen), + 3 => Ok(TransportErrorKind::TimedOut), + 4 => Ok(TransportErrorKind::EndOfFile), + 5 => Ok(TransportErrorKind::NegativeSize), + 6 => Ok(TransportErrorKind::SizeLimit), + _ => { + Err(Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::Unknown, + message: format!("cannot convert {} to TransportErrorKind", from), + })) + } + } + } +} + +impl From<io::Error> for Error { + fn from(err: io::Error) -> Self { + match err.kind() { + io::ErrorKind::ConnectionReset | + io::ErrorKind::ConnectionRefused | + io::ErrorKind::NotConnected => { + Error::Transport(TransportError { + kind: TransportErrorKind::NotOpen, + message: err.description().to_owned(), + }) + } + io::ErrorKind::AlreadyExists => { + Error::Transport(TransportError { + kind: TransportErrorKind::AlreadyOpen, + message: err.description().to_owned(), + }) + } + io::ErrorKind::TimedOut => { + Error::Transport(TransportError { + kind: TransportErrorKind::TimedOut, + message: err.description().to_owned(), + }) + } + io::ErrorKind::UnexpectedEof => { + Error::Transport(TransportError { + kind: TransportErrorKind::EndOfFile, + message: err.description().to_owned(), + }) + } + _ => { + Error::Transport(TransportError { + kind: TransportErrorKind::Unknown, + message: err.description().to_owned(), // FIXME: use io error's debug string + }) + } + } + } +} + +impl From<string::FromUtf8Error> for Error { + fn from(err: string::FromUtf8Error) -> Self { + Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::InvalidData, + message: err.description().to_owned(), // FIXME: use fmt::Error's debug string + }) + } +} + +/// Create a new `Error` instance of type `Protocol` that wraps a +/// `ProtocolError`. +pub fn new_protocol_error<S: Into<String>>(kind: ProtocolErrorKind, message: S) -> Error { + Error::Protocol(ProtocolError::new(kind, message)) +} + +/// Information about errors that occur in the runtime library. +#[derive(Debug)] +pub struct ProtocolError { + /// Protocol error variant. + /// + /// If a specific `ProtocolErrorKind` does not apply use + /// `ProtocolErrorKind::Unknown`. + pub kind: ProtocolErrorKind, + /// Human-readable error message. + pub message: String, +} + +impl ProtocolError { + /// Create a new `ProtocolError`. + pub fn new<S: Into<String>>(kind: ProtocolErrorKind, message: S) -> ProtocolError { + ProtocolError { + kind: kind, + message: message.into(), + } + } +} + +/// Runtime library error categories. +/// +/// This list may grow, and it is not recommended to match against it. +#[derive(Clone, Copy, Eq, Debug, PartialEq)] +pub enum ProtocolErrorKind { + /// Catch-all runtime-library error. + Unknown = 0, + /// An invalid argument was supplied to a library function, or invalid data + /// was received from a Thrift endpoint. + InvalidData = 1, + /// An invalid size was received in an encoded field. + NegativeSize = 2, + /// Thrift message or field was too long. + SizeLimit = 3, + /// Unsupported or unknown Thrift protocol version. + BadVersion = 4, + /// Unsupported Thrift protocol, server or field type. + NotImplemented = 5, + /// Reached the maximum nested depth to which an encoded Thrift field could + /// be skipped. + DepthLimit = 6, +} + +impl ProtocolError { + fn description(&self) -> &str { + match self.kind { + ProtocolErrorKind::Unknown => "protocol error", + ProtocolErrorKind::InvalidData => "bad data", + ProtocolErrorKind::NegativeSize => "negative message size", + ProtocolErrorKind::SizeLimit => "message too long", + ProtocolErrorKind::BadVersion => "invalid thrift version", + ProtocolErrorKind::NotImplemented => "not implemented", + ProtocolErrorKind::DepthLimit => "maximum skip depth reached", + } + } +} + +impl Display for ProtocolError { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + write!(f, "{}", self.description()) + } +} + +impl TryFrom<i32> for ProtocolErrorKind { + type Err = Error; + fn try_from(from: i32) -> Result<Self, Self::Err> { + match from { + 0 => Ok(ProtocolErrorKind::Unknown), + 1 => Ok(ProtocolErrorKind::InvalidData), + 2 => Ok(ProtocolErrorKind::NegativeSize), + 3 => Ok(ProtocolErrorKind::SizeLimit), + 4 => Ok(ProtocolErrorKind::BadVersion), + 5 => Ok(ProtocolErrorKind::NotImplemented), + 6 => Ok(ProtocolErrorKind::DepthLimit), + _ => { + Err(Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::Unknown, + message: format!("cannot convert {} to ProtocolErrorKind", from), + })) + } + } + } +} + +/// Create a new `Error` instance of type `Application` that wraps an +/// `ApplicationError`. +pub fn new_application_error<S: Into<String>>(kind: ApplicationErrorKind, message: S) -> Error { + Error::Application(ApplicationError::new(kind, message)) +} + +/// Information about errors in auto-generated code or in user-implemented +/// service handlers. +#[derive(Debug)] +pub struct ApplicationError { + /// Application error variant. + /// + /// If a specific `ApplicationErrorKind` does not apply use + /// `ApplicationErrorKind::Unknown`. + pub kind: ApplicationErrorKind, + /// Human-readable error message. + pub message: String, +} + +impl ApplicationError { + /// Create a new `ApplicationError`. + pub fn new<S: Into<String>>(kind: ApplicationErrorKind, message: S) -> ApplicationError { + ApplicationError { + kind: kind, + message: message.into(), + } + } +} + +/// Auto-generated or user-implemented code error categories. +/// +/// This list may grow, and it is not recommended to match against it. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ApplicationErrorKind { + /// Catch-all application error. + Unknown = 0, + /// Made service call to an unknown service method. + UnknownMethod = 1, + /// Received an unknown Thrift message type. That is, not one of the + /// `thrift::protocol::TMessageType` variants. + InvalidMessageType = 2, + /// Method name in a service reply does not match the name of the + /// receiving service method. + WrongMethodName = 3, + /// Received an out-of-order Thrift message. + BadSequenceId = 4, + /// Service reply is missing required fields. + MissingResult = 5, + /// Auto-generated code failed unexpectedly. + InternalError = 6, + /// Thrift protocol error. When possible use `Error::ProtocolError` with a + /// specific `ProtocolErrorKind` instead. + ProtocolError = 7, + /// *Unknown*. Included only for compatibility with existing Thrift implementations. + InvalidTransform = 8, // ?? + /// Thrift endpoint requested, or is using, an unsupported encoding. + InvalidProtocol = 9, // ?? + /// Thrift endpoint requested, or is using, an unsupported auto-generated client type. + UnsupportedClientType = 10, // ?? +} + +impl ApplicationError { + fn description(&self) -> &str { + match self.kind { + ApplicationErrorKind::Unknown => "service error", + ApplicationErrorKind::UnknownMethod => "unknown service method", + ApplicationErrorKind::InvalidMessageType => "wrong message type received", + ApplicationErrorKind::WrongMethodName => "unknown method reply received", + ApplicationErrorKind::BadSequenceId => "out of order sequence id", + ApplicationErrorKind::MissingResult => "missing method result", + ApplicationErrorKind::InternalError => "remote service threw exception", + ApplicationErrorKind::ProtocolError => "protocol error", + ApplicationErrorKind::InvalidTransform => "invalid transform", + ApplicationErrorKind::InvalidProtocol => "invalid protocol requested", + ApplicationErrorKind::UnsupportedClientType => "unsupported protocol client", + } + } +} + +impl Display for ApplicationError { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + write!(f, "{}", self.description()) + } +} + +impl TryFrom<i32> for ApplicationErrorKind { + type Err = Error; + fn try_from(from: i32) -> Result<Self, Self::Err> { + match from { + 0 => Ok(ApplicationErrorKind::Unknown), + 1 => Ok(ApplicationErrorKind::UnknownMethod), + 2 => Ok(ApplicationErrorKind::InvalidMessageType), + 3 => Ok(ApplicationErrorKind::WrongMethodName), + 4 => Ok(ApplicationErrorKind::BadSequenceId), + 5 => Ok(ApplicationErrorKind::MissingResult), + 6 => Ok(ApplicationErrorKind::InternalError), + 7 => Ok(ApplicationErrorKind::ProtocolError), + 8 => Ok(ApplicationErrorKind::InvalidTransform), + 9 => Ok(ApplicationErrorKind::InvalidProtocol), + 10 => Ok(ApplicationErrorKind::UnsupportedClientType), + _ => { + Err(Error::Application(ApplicationError { + kind: ApplicationErrorKind::Unknown, + message: format!("cannot convert {} to ApplicationErrorKind", from), + })) + } + } + } +} http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/src/lib.rs ---------------------------------------------------------------------- diff --git a/lib/rs/src/lib.rs b/lib/rs/src/lib.rs new file mode 100644 index 0000000..ad18721 --- /dev/null +++ b/lib/rs/src/lib.rs @@ -0,0 +1,87 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Rust runtime library for the Apache Thrift RPC system. +//! +//! This crate implements the components required to build a working +//! Thrift server and client. It is divided into the following modules: +//! +//! 1. errors +//! 2. protocol +//! 3. transport +//! 4. server +//! 5. autogen +//! +//! The modules are layered as shown in the diagram below. The `generated` +//! layer is generated by the Thrift compiler's Rust plugin. It uses the +//! types and functions defined in this crate to serialize and deserialize +//! messages and implement RPC. Users interact with these types and services +//! by writing their own code on top. +//! +//! ```text +//! +-----------+ +//! | user app | +//! +-----------+ +//! | autogen'd | (uses errors, autogen) +//! +-----------+ +//! | protocol | +//! +-----------+ +//! | transport | +//! +-----------+ +//! ``` + +#![crate_type = "lib"] +#![doc(test(attr(allow(unused_variables), deny(warnings))))] + +extern crate byteorder; +extern crate integer_encoding; +extern crate try_from; + +#[macro_use] +extern crate log; + +// NOTE: this macro has to be defined before any modules. See: +// https://danielkeep.github.io/quick-intro-to-macros.html#some-more-gotchas + +/// Assert that an expression returning a `Result` is a success. If it is, +/// return the value contained in the result, i.e. `expr.unwrap()`. +#[cfg(test)] +macro_rules! assert_success { + ($e: expr) => { + { + let res = $e; + assert!(res.is_ok()); + res.unwrap() + } + } +} + +pub mod protocol; +pub mod server; +pub mod transport; + +mod errors; +pub use errors::*; + +mod autogen; +pub use autogen::*; + +/// Result type returned by all runtime library functions. +/// +/// As is convention this is a typedef of `std::result::Result` +/// with `E` defined as the `thrift::Error` type. +pub type Result<T> = std::result::Result<T, self::Error>; http://git-wip-us.apache.org/repos/asf/thrift/blob/8b96bfbf/lib/rs/src/protocol/binary.rs ---------------------------------------------------------------------- diff --git a/lib/rs/src/protocol/binary.rs b/lib/rs/src/protocol/binary.rs new file mode 100644 index 0000000..f3c9ea2 --- /dev/null +++ b/lib/rs/src/protocol/binary.rs @@ -0,0 +1,817 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +use byteorder::{BigEndian, ByteOrder, ReadBytesExt, WriteBytesExt}; +use std::cell::RefCell; +use std::convert::From; +use std::io::{Read, Write}; +use std::rc::Rc; +use try_from::TryFrom; + +use ::{ProtocolError, ProtocolErrorKind}; +use ::transport::TTransport; +use super::{TFieldIdentifier, TInputProtocol, TInputProtocolFactory, TListIdentifier, + TMapIdentifier, TMessageIdentifier, TMessageType}; +use super::{TOutputProtocol, TOutputProtocolFactory, TSetIdentifier, TStructIdentifier, TType}; + +const BINARY_PROTOCOL_VERSION_1: u32 = 0x80010000; + +/// Read messages encoded in the Thrift simple binary encoding. +/// +/// There are two available modes: `strict` and `non-strict`, where the +/// `non-strict` version does not check for the protocol version in the +/// received message header. +/// +/// # Examples +/// +/// Create and use a `TBinaryInputProtocol`. +/// +/// ```no_run +/// use std::cell::RefCell; +/// use std::rc::Rc; +/// use thrift::protocol::{TBinaryInputProtocol, TInputProtocol}; +/// use thrift::transport::{TTcpTransport, TTransport}; +/// +/// let mut transport = TTcpTransport::new(); +/// transport.open("localhost:9090").unwrap(); +/// let transport = Rc::new(RefCell::new(Box::new(transport) as Box<TTransport>)); +/// +/// let mut i_prot = TBinaryInputProtocol::new(transport, true); +/// +/// let recvd_bool = i_prot.read_bool().unwrap(); +/// let recvd_string = i_prot.read_string().unwrap(); +/// ``` +pub struct TBinaryInputProtocol { + strict: bool, + transport: Rc<RefCell<Box<TTransport>>>, +} + +impl TBinaryInputProtocol { + /// Create a `TBinaryInputProtocol` that reads bytes from `transport`. + /// + /// Set `strict` to `true` if all incoming messages contain the protocol + /// version number in the protocol header. + pub fn new(transport: Rc<RefCell<Box<TTransport>>>, strict: bool) -> TBinaryInputProtocol { + TBinaryInputProtocol { + strict: strict, + transport: transport, + } + } +} + +impl TInputProtocol for TBinaryInputProtocol { + #[cfg_attr(feature = "cargo-clippy", allow(collapsible_if))] + fn read_message_begin(&mut self) -> ::Result<TMessageIdentifier> { + let mut first_bytes = vec![0; 4]; + self.transport.borrow_mut().read_exact(&mut first_bytes[..])?; + + // the thrift version header is intentionally negative + // so the first check we'll do is see if the sign bit is set + // and if so - assume it's the protocol-version header + if first_bytes[0] >= 8 { + // apparently we got a protocol-version header - check + // it, and if it matches, read the rest of the fields + if first_bytes[0..2] != [0x80, 0x01] { + Err(::Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::BadVersion, + message: format!("received bad version: {:?}", &first_bytes[0..2]), + })) + } else { + let message_type: TMessageType = TryFrom::try_from(first_bytes[3])?; + let name = self.read_string()?; + let sequence_number = self.read_i32()?; + Ok(TMessageIdentifier::new(name, message_type, sequence_number)) + } + } else { + // apparently we didn't get a protocol-version header, + // which happens if the sender is not using the strict protocol + if self.strict { + // we're in strict mode however, and that always + // requires the protocol-version header to be written first + Err(::Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::BadVersion, + message: format!("received bad version: {:?}", &first_bytes[0..2]), + })) + } else { + // in the non-strict version the first message field + // is the message name. strings (byte arrays) are length-prefixed, + // so we've just read the length in the first 4 bytes + let name_size = BigEndian::read_i32(&first_bytes) as usize; + let mut name_buf: Vec<u8> = Vec::with_capacity(name_size); + self.transport.borrow_mut().read_exact(&mut name_buf)?; + let name = String::from_utf8(name_buf)?; + + // read the rest of the fields + let message_type: TMessageType = self.read_byte().and_then(TryFrom::try_from)?; + let sequence_number = self.read_i32()?; + Ok(TMessageIdentifier::new(name, message_type, sequence_number)) + } + } + } + + fn read_message_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn read_struct_begin(&mut self) -> ::Result<Option<TStructIdentifier>> { + Ok(None) + } + + fn read_struct_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn read_field_begin(&mut self) -> ::Result<TFieldIdentifier> { + let field_type_byte = self.read_byte()?; + let field_type = field_type_from_u8(field_type_byte)?; + let id = match field_type { + TType::Stop => Ok(0), + _ => self.read_i16(), + }?; + Ok(TFieldIdentifier::new::<Option<String>, String, i16>(None, field_type, id)) + } + + fn read_field_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn read_bytes(&mut self) -> ::Result<Vec<u8>> { + let num_bytes = self.transport.borrow_mut().read_i32::<BigEndian>()? as usize; + let mut buf = vec![0u8; num_bytes]; + self.transport.borrow_mut().read_exact(&mut buf).map(|_| buf).map_err(From::from) + } + + fn read_bool(&mut self) -> ::Result<bool> { + let b = self.read_i8()?; + match b { + 0 => Ok(false), + _ => Ok(true), + } + } + + fn read_i8(&mut self) -> ::Result<i8> { + self.transport.borrow_mut().read_i8().map_err(From::from) + } + + fn read_i16(&mut self) -> ::Result<i16> { + self.transport.borrow_mut().read_i16::<BigEndian>().map_err(From::from) + } + + fn read_i32(&mut self) -> ::Result<i32> { + self.transport.borrow_mut().read_i32::<BigEndian>().map_err(From::from) + } + + fn read_i64(&mut self) -> ::Result<i64> { + self.transport.borrow_mut().read_i64::<BigEndian>().map_err(From::from) + } + + fn read_double(&mut self) -> ::Result<f64> { + self.transport.borrow_mut().read_f64::<BigEndian>().map_err(From::from) + } + + fn read_string(&mut self) -> ::Result<String> { + let bytes = self.read_bytes()?; + String::from_utf8(bytes).map_err(From::from) + } + + fn read_list_begin(&mut self) -> ::Result<TListIdentifier> { + let element_type: TType = self.read_byte().and_then(field_type_from_u8)?; + let size = self.read_i32()?; + Ok(TListIdentifier::new(element_type, size)) + } + + fn read_list_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn read_set_begin(&mut self) -> ::Result<TSetIdentifier> { + let element_type: TType = self.read_byte().and_then(field_type_from_u8)?; + let size = self.read_i32()?; + Ok(TSetIdentifier::new(element_type, size)) + } + + fn read_set_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn read_map_begin(&mut self) -> ::Result<TMapIdentifier> { + let key_type: TType = self.read_byte().and_then(field_type_from_u8)?; + let value_type: TType = self.read_byte().and_then(field_type_from_u8)?; + let size = self.read_i32()?; + Ok(TMapIdentifier::new(key_type, value_type, size)) + } + + fn read_map_end(&mut self) -> ::Result<()> { + Ok(()) + } + + // utility + // + + fn read_byte(&mut self) -> ::Result<u8> { + self.transport.borrow_mut().read_u8().map_err(From::from) + } +} + +/// Factory for creating instances of `TBinaryInputProtocol`. +#[derive(Default)] +pub struct TBinaryInputProtocolFactory; + +impl TBinaryInputProtocolFactory { + /// Create a `TBinaryInputProtocolFactory`. + pub fn new() -> TBinaryInputProtocolFactory { + TBinaryInputProtocolFactory {} + } +} + +impl TInputProtocolFactory for TBinaryInputProtocolFactory { + fn create(&mut self, transport: Rc<RefCell<Box<TTransport>>>) -> Box<TInputProtocol> { + Box::new(TBinaryInputProtocol::new(transport, true)) as Box<TInputProtocol> + } +} + +/// Write messages using the Thrift simple binary encoding. +/// +/// There are two available modes: `strict` and `non-strict`, where the +/// `strict` version writes the protocol version number in the outgoing message +/// header and the `non-strict` version does not. +/// +/// # Examples +/// +/// Create and use a `TBinaryOutputProtocol`. +/// +/// ```no_run +/// use std::cell::RefCell; +/// use std::rc::Rc; +/// use thrift::protocol::{TBinaryOutputProtocol, TOutputProtocol}; +/// use thrift::transport::{TTcpTransport, TTransport}; +/// +/// let mut transport = TTcpTransport::new(); +/// transport.open("localhost:9090").unwrap(); +/// let transport = Rc::new(RefCell::new(Box::new(transport) as Box<TTransport>)); +/// +/// let mut o_prot = TBinaryOutputProtocol::new(transport, true); +/// +/// o_prot.write_bool(true).unwrap(); +/// o_prot.write_string("test_string").unwrap(); +/// ``` +pub struct TBinaryOutputProtocol { + strict: bool, + transport: Rc<RefCell<Box<TTransport>>>, +} + +impl TBinaryOutputProtocol { + /// Create a `TBinaryOutputProtocol` that writes bytes to `transport`. + /// + /// Set `strict` to `true` if all outgoing messages should contain the + /// protocol version number in the protocol header. + pub fn new(transport: Rc<RefCell<Box<TTransport>>>, strict: bool) -> TBinaryOutputProtocol { + TBinaryOutputProtocol { + strict: strict, + transport: transport, + } + } + + fn write_transport(&mut self, buf: &[u8]) -> ::Result<()> { + self.transport.borrow_mut().write(buf).map(|_| ()).map_err(From::from) + } +} + +impl TOutputProtocol for TBinaryOutputProtocol { + fn write_message_begin(&mut self, identifier: &TMessageIdentifier) -> ::Result<()> { + if self.strict { + let message_type: u8 = identifier.message_type.into(); + let header = BINARY_PROTOCOL_VERSION_1 | (message_type as u32); + self.transport.borrow_mut().write_u32::<BigEndian>(header)?; + self.write_string(&identifier.name)?; + self.write_i32(identifier.sequence_number) + } else { + self.write_string(&identifier.name)?; + self.write_byte(identifier.message_type.into())?; + self.write_i32(identifier.sequence_number) + } + } + + fn write_message_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn write_struct_begin(&mut self, _: &TStructIdentifier) -> ::Result<()> { + Ok(()) + } + + fn write_struct_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn write_field_begin(&mut self, identifier: &TFieldIdentifier) -> ::Result<()> { + if identifier.id.is_none() && identifier.field_type != TType::Stop { + return Err(::Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::Unknown, + message: format!("cannot write identifier {:?} without sequence number", + &identifier), + })); + } + + self.write_byte(field_type_to_u8(identifier.field_type))?; + if let Some(id) = identifier.id { + self.write_i16(id) + } else { + Ok(()) + } + } + + fn write_field_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn write_field_stop(&mut self) -> ::Result<()> { + self.write_byte(field_type_to_u8(TType::Stop)) + } + + fn write_bytes(&mut self, b: &[u8]) -> ::Result<()> { + self.write_i32(b.len() as i32)?; + self.write_transport(b) + } + + fn write_bool(&mut self, b: bool) -> ::Result<()> { + if b { + self.write_i8(1) + } else { + self.write_i8(0) + } + } + + fn write_i8(&mut self, i: i8) -> ::Result<()> { + self.transport.borrow_mut().write_i8(i).map_err(From::from) + } + + fn write_i16(&mut self, i: i16) -> ::Result<()> { + self.transport.borrow_mut().write_i16::<BigEndian>(i).map_err(From::from) + } + + fn write_i32(&mut self, i: i32) -> ::Result<()> { + self.transport.borrow_mut().write_i32::<BigEndian>(i).map_err(From::from) + } + + fn write_i64(&mut self, i: i64) -> ::Result<()> { + self.transport.borrow_mut().write_i64::<BigEndian>(i).map_err(From::from) + } + + fn write_double(&mut self, d: f64) -> ::Result<()> { + self.transport.borrow_mut().write_f64::<BigEndian>(d).map_err(From::from) + } + + fn write_string(&mut self, s: &str) -> ::Result<()> { + self.write_bytes(s.as_bytes()) + } + + fn write_list_begin(&mut self, identifier: &TListIdentifier) -> ::Result<()> { + self.write_byte(field_type_to_u8(identifier.element_type))?; + self.write_i32(identifier.size) + } + + fn write_list_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn write_set_begin(&mut self, identifier: &TSetIdentifier) -> ::Result<()> { + self.write_byte(field_type_to_u8(identifier.element_type))?; + self.write_i32(identifier.size) + } + + fn write_set_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn write_map_begin(&mut self, identifier: &TMapIdentifier) -> ::Result<()> { + let key_type = identifier.key_type + .expect("map identifier to write should contain key type"); + self.write_byte(field_type_to_u8(key_type))?; + let val_type = identifier.value_type + .expect("map identifier to write should contain value type"); + self.write_byte(field_type_to_u8(val_type))?; + self.write_i32(identifier.size) + } + + fn write_map_end(&mut self) -> ::Result<()> { + Ok(()) + } + + fn flush(&mut self) -> ::Result<()> { + self.transport.borrow_mut().flush().map_err(From::from) + } + + // utility + // + + fn write_byte(&mut self, b: u8) -> ::Result<()> { + self.transport.borrow_mut().write_u8(b).map_err(From::from) + } +} + +/// Factory for creating instances of `TBinaryOutputProtocol`. +#[derive(Default)] +pub struct TBinaryOutputProtocolFactory; + +impl TBinaryOutputProtocolFactory { + /// Create a `TBinaryOutputProtocolFactory`. + pub fn new() -> TBinaryOutputProtocolFactory { + TBinaryOutputProtocolFactory {} + } +} + +impl TOutputProtocolFactory for TBinaryOutputProtocolFactory { + fn create(&mut self, transport: Rc<RefCell<Box<TTransport>>>) -> Box<TOutputProtocol> { + Box::new(TBinaryOutputProtocol::new(transport, true)) as Box<TOutputProtocol> + } +} + +fn field_type_to_u8(field_type: TType) -> u8 { + match field_type { + TType::Stop => 0x00, + TType::Void => 0x01, + TType::Bool => 0x02, + TType::I08 => 0x03, // equivalent to TType::Byte + TType::Double => 0x04, + TType::I16 => 0x06, + TType::I32 => 0x08, + TType::I64 => 0x0A, + TType::String | TType::Utf7 => 0x0B, + TType::Struct => 0x0C, + TType::Map => 0x0D, + TType::Set => 0x0E, + TType::List => 0x0F, + TType::Utf8 => 0x10, + TType::Utf16 => 0x11, + } +} + +fn field_type_from_u8(b: u8) -> ::Result<TType> { + match b { + 0x00 => Ok(TType::Stop), + 0x01 => Ok(TType::Void), + 0x02 => Ok(TType::Bool), + 0x03 => Ok(TType::I08), // Equivalent to TType::Byte + 0x04 => Ok(TType::Double), + 0x06 => Ok(TType::I16), + 0x08 => Ok(TType::I32), + 0x0A => Ok(TType::I64), + 0x0B => Ok(TType::String), // technically, also a UTF7, but we'll treat it as string + 0x0C => Ok(TType::Struct), + 0x0D => Ok(TType::Map), + 0x0E => Ok(TType::Set), + 0x0F => Ok(TType::List), + 0x10 => Ok(TType::Utf8), + 0x11 => Ok(TType::Utf16), + unkn => { + Err(::Error::Protocol(ProtocolError { + kind: ProtocolErrorKind::InvalidData, + message: format!("cannot convert {} to TType", unkn), + })) + } + } +} + +#[cfg(test)] +mod tests { + + use std::rc::Rc; + use std::cell::RefCell; + + use ::protocol::{TFieldIdentifier, TMessageIdentifier, TMessageType, TInputProtocol, + TListIdentifier, TMapIdentifier, TOutputProtocol, TSetIdentifier, + TStructIdentifier, TType}; + use ::transport::{TPassThruTransport, TTransport}; + use ::transport::mem::TBufferTransport; + + use super::*; + + #[test] + fn must_write_message_call_begin() { + let (trans, _, mut o_prot) = test_objects(); + + let ident = TMessageIdentifier::new("test", TMessageType::Call, 1); + assert!(o_prot.write_message_begin(&ident).is_ok()); + + let buf = trans.borrow().write_buffer_to_vec(); + + let expected: [u8; 16] = [0x80, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x74, 0x65, + 0x73, 0x74, 0x00, 0x00, 0x00, 0x01]; + + assert_eq!(&expected, buf.as_slice()); + } + + + #[test] + fn must_write_message_reply_begin() { + let (trans, _, mut o_prot) = test_objects(); + + let ident = TMessageIdentifier::new("test", TMessageType::Reply, 10); + assert!(o_prot.write_message_begin(&ident).is_ok()); + + let buf = trans.borrow().write_buffer_to_vec(); + + let expected: [u8; 16] = [0x80, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x74, 0x65, + 0x73, 0x74, 0x00, 0x00, 0x00, 0x0A]; + + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_round_trip_strict_message_begin() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + let sent_ident = TMessageIdentifier::new("test", TMessageType::Call, 1); + assert!(o_prot.write_message_begin(&sent_ident).is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let received_ident = assert_success!(i_prot.read_message_begin()); + assert_eq!(&received_ident, &sent_ident); + } + + #[test] + fn must_write_message_end() { + assert_no_write(|o| o.write_message_end()); + } + + #[test] + fn must_write_struct_begin() { + assert_no_write(|o| o.write_struct_begin(&TStructIdentifier::new("foo"))); + } + + #[test] + fn must_write_struct_end() { + assert_no_write(|o| o.write_struct_end()); + } + + #[test] + fn must_write_field_begin() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_field_begin(&TFieldIdentifier::new("some_field", TType::String, 22)) + .is_ok()); + + let expected: [u8; 3] = [0x0B, 0x00, 0x16]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_round_trip_field_begin() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + let sent_field_ident = TFieldIdentifier::new("foo", TType::I64, 20); + assert!(o_prot.write_field_begin(&sent_field_ident).is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let expected_ident = TFieldIdentifier { + name: None, + field_type: TType::I64, + id: Some(20), + }; // no name + let received_ident = assert_success!(i_prot.read_field_begin()); + assert_eq!(&received_ident, &expected_ident); + } + + #[test] + fn must_write_stop_field() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_field_stop().is_ok()); + + let expected: [u8; 1] = [0x00]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_round_trip_field_stop() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + assert!(o_prot.write_field_stop().is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let expected_ident = TFieldIdentifier { + name: None, + field_type: TType::Stop, + id: Some(0), + }; // we get id 0 + + let received_ident = assert_success!(i_prot.read_field_begin()); + assert_eq!(&received_ident, &expected_ident); + } + + #[test] + fn must_write_field_end() { + assert_no_write(|o| o.write_field_end()); + } + + #[test] + fn must_write_list_begin() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_list_begin(&TListIdentifier::new(TType::Bool, 5)).is_ok()); + + let expected: [u8; 5] = [0x02, 0x00, 0x00, 0x00, 0x05]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_round_trip_list_begin() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + let ident = TListIdentifier::new(TType::List, 900); + assert!(o_prot.write_list_begin(&ident).is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let received_ident = assert_success!(i_prot.read_list_begin()); + assert_eq!(&received_ident, &ident); + } + + #[test] + fn must_write_list_end() { + assert_no_write(|o| o.write_list_end()); + } + + #[test] + fn must_write_set_begin() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_set_begin(&TSetIdentifier::new(TType::I16, 7)).is_ok()); + + let expected: [u8; 5] = [0x06, 0x00, 0x00, 0x00, 0x07]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_round_trip_set_begin() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + let ident = TSetIdentifier::new(TType::I64, 2000); + assert!(o_prot.write_set_begin(&ident).is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let received_ident_result = i_prot.read_set_begin(); + assert!(received_ident_result.is_ok()); + assert_eq!(&received_ident_result.unwrap(), &ident); + } + + #[test] + fn must_write_set_end() { + assert_no_write(|o| o.write_set_end()); + } + + #[test] + fn must_write_map_begin() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_map_begin(&TMapIdentifier::new(TType::I64, TType::Struct, 32)) + .is_ok()); + + let expected: [u8; 6] = [0x0A, 0x0C, 0x00, 0x00, 0x00, 0x20]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_round_trip_map_begin() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + let ident = TMapIdentifier::new(TType::Map, TType::Set, 100); + assert!(o_prot.write_map_begin(&ident).is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let received_ident = assert_success!(i_prot.read_map_begin()); + assert_eq!(&received_ident, &ident); + } + + #[test] + fn must_write_map_end() { + assert_no_write(|o| o.write_map_end()); + } + + #[test] + fn must_write_bool_true() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_bool(true).is_ok()); + + let expected: [u8; 1] = [0x01]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_write_bool_false() { + let (trans, _, mut o_prot) = test_objects(); + + assert!(o_prot.write_bool(false).is_ok()); + + let expected: [u8; 1] = [0x00]; + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&expected, buf.as_slice()); + } + + #[test] + fn must_read_bool_true() { + let (trans, mut i_prot, _) = test_objects(); + + trans.borrow_mut().set_readable_bytes(&[0x01]); + + let read_bool = assert_success!(i_prot.read_bool()); + assert_eq!(read_bool, true); + } + + #[test] + fn must_read_bool_false() { + let (trans, mut i_prot, _) = test_objects(); + + trans.borrow_mut().set_readable_bytes(&[0x00]); + + let read_bool = assert_success!(i_prot.read_bool()); + assert_eq!(read_bool, false); + } + + #[test] + fn must_allow_any_non_zero_value_to_be_interpreted_as_bool_true() { + let (trans, mut i_prot, _) = test_objects(); + + trans.borrow_mut().set_readable_bytes(&[0xAC]); + + let read_bool = assert_success!(i_prot.read_bool()); + assert_eq!(read_bool, true); + } + + #[test] + fn must_write_bytes() { + let (trans, _, mut o_prot) = test_objects(); + + let bytes: [u8; 10] = [0x0A, 0xCC, 0xD1, 0x84, 0x99, 0x12, 0xAB, 0xBB, 0x45, 0xDF]; + + assert!(o_prot.write_bytes(&bytes).is_ok()); + + let buf = trans.borrow().write_buffer_to_vec(); + assert_eq!(&buf[0..4], [0x00, 0x00, 0x00, 0x0A]); // length + assert_eq!(&buf[4..], bytes); // actual bytes + } + + #[test] + fn must_round_trip_bytes() { + let (trans, mut i_prot, mut o_prot) = test_objects(); + + let bytes: [u8; 25] = [0x20, 0xFD, 0x18, 0x84, 0x99, 0x12, 0xAB, 0xBB, 0x45, 0xDF, 0x34, + 0xDC, 0x98, 0xA4, 0x6D, 0xF3, 0x99, 0xB4, 0xB7, 0xD4, 0x9C, 0xA5, + 0xB3, 0xC9, 0x88]; + + assert!(o_prot.write_bytes(&bytes).is_ok()); + + trans.borrow_mut().copy_write_buffer_to_read_buffer(); + + let received_bytes = assert_success!(i_prot.read_bytes()); + assert_eq!(&received_bytes, &bytes); + } + + fn test_objects + () + -> (Rc<RefCell<Box<TBufferTransport>>>, TBinaryInputProtocol, TBinaryOutputProtocol) + { + let mem = Rc::new(RefCell::new(Box::new(TBufferTransport::with_capacity(40, 40)))); + + let inner: Box<TTransport> = Box::new(TPassThruTransport { inner: mem.clone() }); + let inner = Rc::new(RefCell::new(inner)); + + let i_prot = TBinaryInputProtocol::new(inner.clone(), true); + let o_prot = TBinaryOutputProtocol::new(inner.clone(), true); + + (mem, i_prot, o_prot) + } + + fn assert_no_write<F: FnMut(&mut TBinaryOutputProtocol) -> ::Result<()>>(mut write_fn: F) { + let (trans, _, mut o_prot) = test_objects(); + assert!(write_fn(&mut o_prot).is_ok()); + assert_eq!(trans.borrow().write_buffer_as_ref().len(), 0); + } +}
