简述thrift与应用分析
前言
本篇将以thrift-0.9.0为背景讲述thrift的基础，使用案例，启发。
概述
thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa,JavaScript, Node.js, Smalltalk, and OCaml 这些编程语言间无缝结合的、高效的服务。
thrift最初由facebook开发，07年四月开放源码，08年5月进入apache孵化器。
thrift允许你定义一个简单的定义文件中的数据类型和服务接口。以作为输入文件，编译器生成代码用来方便地生成RPC客户端和服务器通信的无缝跨编程语言。
简单来说，就是提供了rpc框架，序列化功能，多语言的代码生成等功能，跨语言间的协调开发就是基于这些功能来完成。
安装
首先，关于编译前，各语言对应的库的需求可以见这里
boost和libevent都是编译过没有安装的，--with-libevent指定可能有点问题，就换成了在编译时指定路径。
boost可能有依赖到库目录，就指定下库所在的路径，libevent也指定了一下。
另外，如果不需要非阻塞功能的，可以不用去指定libevent相关头文件目录和库目录。
./configure --with-boost=/home/chlaws/packet/boost_1_47_0 --with-qt4=no \
CPPFLAGS="-I /home/chlaws/packet/libevent-2.0.21-stable -I /home/chlaws/packet/libevent-2.0.21-stable/include" \
CXXFLAGS="-I /home/chlaws/packet/libevent-2.0.21-stable -I /home/chlaws/packet/libevent-2.0.21-stable/include" \
LDFLAGS="-L/home/chlaws/packet/boost_1_47_0/stage/lib-L/home/chlaws/packet/libevent-2.0.21-stable/.libs"
make时候，在编译java的库的时候，可能会出现编译会出现有方法找不到的异常，这个我自己是有碰到
在thrift-0.9.0/lib/java中的Makefile中的
all-local:
$(ANT) $(ANT_FLAGS)
改为
all-local:
sudo $(ANT) $(ANT_FLAGS)
或者进入到lib/java以root权限执行sudoant
如果都没有这问题以及boost安装在默认目录了(/usr/local下)，那就简单点，./configure ;make;make install;
另外编译好了，自己验证下：
进入thrift-0.9.0/tutorial 目录执行 thrift -r --gencpp tutorial.thrift
进入thrift-0.9.0/tutorial/cpp 执行Makefile看看是否成功，这里我自己会碰到基础类型没定义和htons之类的没定义的错误
参看thrift wiki上的usage ,在Makefile的编译选项中 指定-DHAVE_INTTYPES_H-DHAVE_NETINET_IN_H (注:其实就是config.h的关系)
下面是我改过的Makefile, 我boost没有安装因此boost目录需要改一下默认的路径
BOOST_DIR = /home/chlaws/packet/boost_1_47_0
THRIFT_DIR = /usr/local/include
#LIB_DIR = -L /usr/local/lib
GEN_SRC = ../gen-cpp/SharedService.cpp../gen-cpp/shared_types.cpp ../gen-cpp/tutorial_types.cpp ../gen-cpp/Calculator.cpp
default: server client
server: CppServer.cpp
g++-DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H -o CppServer -I${THRIFT_DIR}-I${BOOST_DIR} -I../gen-cpp ${LIB_DIR} -lthrift CppServer.cpp${GEN_SRC}
client: CppClient.cpp
g++-DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H -o CppClient -I${THRIFT_DIR}-I${BOOST_DIR} -I../gen-cpp ${LIB_DIR} -lthrift CppClient.cpp ${GEN_SRC}
clean:
$(RM) -rCppClient CppServer
thrift 类型
Base Types
The base types were selected with the goal of simplicityand clarity rather than abundance, focusing on the key types available in allprogramming languages.
· bool: Aboolean value (true or false)
· byte: An8-bit signed integer
· i16: A16-bit signed integer
· i32: A32-bit signed integer
· i64: A64-bit signed integer
· double: A64-bit floating point number
· string: Atext string encoded using UTF-8 encoding
Note the absence of unsigned integer types. This is dueto the fact that there are no native unsigned integer types in many programminglanguages.
这里就是基本类型都有的。
Special Types
binary: a sequence of unencoded bytes
N.B.: This is currently a specialized form of the stringtype above, added to provide better interoperability with Java. The currentplan-of-record is to elevate this to a base type at some point.
还有一个c++中没有的这个对应类型的 binary。
Structs
c中的struct类似的，不过不支持自身的循环嵌套功能，也就是不支持如下定义
struct node{
1:i32 v;
2:node next;
}
在thrift文件中定义出来的struct在代码生成的时候，使用class来描述的(以类形式提供结构体的功能)。
Containers
thrift提供了容器的概念，set,map,list这三个thrift的类型都是属于容器。
对应到c++中就是set,map,vector。对应到java中就是HashSet，ArrayList，HashMap。
Exceptions
异常功能上和struct差不多，不过在这基础之是从各自语言的异常基类中继承来的，可以用于在service中指定异常。
Services
service和java中的interface比较像，或者c++中的public接口。service 定义可以提供什么接口，之后再服务端实现这些接口，客户端就可进行调用。
thrift IDL
IDL就是接口定义语言，在thrift中就是，通过IDL可以定义thrift类型，thrift的代码生成器可以在指定的IDL 文件定义thrift类型，结构来生成各种目标语言的代码。
这其实和protobuf很像，protobuf根据定义的.proto文件，使用代码生成器生成指定语言的代码，之后就可以用生成的代码进行序列化反序列化。
thrift网络协议栈
Transport传输层提供简单的抽象用于对网络的读写。
Protocol 协议指定在网络中以什么样的数据格式进行传输。
Processor 处理器允许同流中读取数据和将数据写到流中，数据输出流是通过协议对象来解释的。
Server 就是将上诉组件一起组合使用，以对外提供访问。
具体对各组件的解释可见这里
+-------------------------------------------+
| Server |
| (single-threaded, event-driven etc) |
+-------------------------------------------+
| Processor |
| (compiler generated) |
+-------------------------------------------+
| Protocol |
| (JSON, compact etc) |
+-------------------------------------------+
| Transport |
| (raw TCP, HTTP etc) |
+-------------------------------------------+入门
首先，thrift解压开后目录格式是如下所示
thrift/
compiler/
Contains the Thrift compiler, implementedin C++.
thrift编译器的c++实现
lib/
Contains the Thrift software libraryimplementation, subdivided by
language of implementation.
thrift的各语言的库实现
cpp/
java/
php/
py/
rb/
test/
Contains sample Thrift files and test codeacross the target programming
languages.
包含.thrift文件和各语言的测试代码
tutorial/
Contains a basic tutorial that will teachyou how to develop software
using Thrift.
包含最基本的使用，用于告知初用者如何使用thrift开发。建议没用过thrift的，先看看该目录下的.thrift定义和各语言的使用。
.thrift 文件编写
//下面介绍的.thrift文件是在tutorial目录下的tutorial.thrift，将简单注释介绍下各定义是什么意思。
include "shared.thrift" //这里是包含另外的.thrift文件，
/**
* Thrift files can namespace, package, or prefixtheir output in various
* target languages.
*/
//namespace 和java的package和c++的namespace差不多，后面跟的是语言的类型，最后tutorial是一个标识名。
namespace cpp tutorial
namespace d tutorial
namespace java tutorial
namespace php tutorial
namespace perl tutorial
/**
* Thrift lets you do typedefs to get pretty namesfor your types. Standard
* C style here.
*/
typedef i32 MyInteger //可以有typedef进行别名定义，和c++中的差不多
/**
* Thrift also lets you define constants for useacross languages. Complex
* types and structs are specified using JSONnotation.
*/
const i32 INT32CONSTANT = 9853 //定义常量
//thrift提供了容器map,map在.thrift中可以初始化，初始化的形式和python中一样。
const map<string,string> MAPCONSTANT ={'hello':'world', 'goodnight':'moon'}
/**
* You can define enums, which are just 32 bitintegers. Values are optional
* and start at 1 if not supplied, C style again.
*/
//thrift中提供了枚举类型，和c++,java中差不多。
enum Operation {
ADD = 1,
SUBTRACT = 2,
MULTIPLY = 3,
DIVIDE = 4
}
/**
* Structs are the basic complex data structures.They are comprised of fields
* which each have an integer identifier, a type, asymbolic name, and an
* optional default value.
*
* Fields can be declared "optional",which ensures they will not be included
* in the serialized output if they aren't set. Note that this requires some
* manual management in some languages.
*/
//也提供了结构体，在结构体中定义依次需要定义的序号，即1: aa,2:bb,
struct Work {
1: i32 num1 = 0,
2: i32 num2,
3: Operation op,
4: optional string comment,
}
/**
* Structs can also be exceptions, if they arenasty.
*/
exception InvalidOperation {
1: i32 what,
2: string why
}
/**
* Ahh, now onto the cool part, defining a service.Services just need a name
* and can optionally inherit from another serviceusing the extends keyword.
*/
service就是个接口的定义，需要在生成代码后在server中实现这些接口。同时，server还提供了继承，可以从另外一个service中继承接口，继承的关键字是用的java中的extend。另外thrift对于service有一些要求，如果继承另外接口，那么不能有重名的接口名(也就是oop中的重载)，还有就是，thrift不提供多态的概念。
service Calculator extends shared.SharedService {
/**
* A method definition looks like C code. Ithas a return type, arguments,
* and optionally a list of exceptions thatit may throw. Note that argument
* lists and exception lists are specifiedusing the exact same syntax as
* field lists in struct or exceptiondefinitions.
*/
void ping(),
i32 add(1:i32 num1, 2:i32 num2),
i32 calculate(1:i32 logid, 2:Work w) throws(1:InvalidOperation ouch),
/**
* This method has a oneway modifier. Thatmeans the client only makes
* a request and does not listen for anyresponse at all. Oneway methods
* must be void.
*/
oneway void zip()
}
如何使用thrift
在编译安装后，会有thrift命令可以用来对.thrift进行生成指定语言的代码，然后对于service进行实现，启动网络进行封装，就可对外提供服务。
以tutorial下的例子为例，先用thrift -r --gen 语言
语言可以是c++,java,python等等，具体可以用thrift --help查看帮助
c++ (thrift-0.9.0/tutorial/cpp的实现例子)
在生成代码后，可以从gen-cpp中copy Calculator_server.skeleton.cpp文件到其他目录，重命名下，比如CppServer.cpp
在其中实现接口(应为还include了shared.thrift，在内部有getStruct方法也要在类中实现)，另外在main中封装server，代码如下:
int main(int argc, char **argv) {
shared_ptr<TProtocolFactory>protocolFactory(new TBinaryProtocolFactory());
shared_ptr<CalculatorHandler> handler(newCalculatorHandler());
shared_ptr<TProcessor> processor(newCalculatorProcessor(handler));
shared_ptr<TServerTransport>serverTransport(new TServerSocket(9090));
shared_ptr<TTransportFactory>transportFactory(new TBufferedTransportFactory());
TSimpleServer server(processor,
serverTransport,
transportFactory,
protocolFactory);
printf("Starting the server...\n");
server.serve();
printf("done.\n");
return 0;
}
编译后，一个RPCserver就完成了。
client的话，可以直接看下提供的client的cpp的实现。
int main(int argc, char** argv) {
shared_ptr<TTransport> socket(newTSocket("localhost", 9090));
shared_ptr<TTransport> transport(newTBufferedTransport(socket));
shared_ptr<TProtocol> protocol(newTBinaryProtocol(transport));
//thrift 在生成serviceCalculator对应的代码的同时也会生成CalculatorClient，
//这样客户端只要在建立连接之后open下，就可正常调用函数样调用server上实现的同名方法。
CalculatorClient client(protocol);
try {
transport->open();
client.ping();
printf("ping()\n");
int32_t sum = client.add(1,1);
printf("1+1=%d\n", sum);
Work work;
work.op = Operation::DIVIDE;
work.num1 = 1;
work.num2 = 0;
try {
int32_t quotient =client.calculate(1, work);
printf("Whoa? We can divide byzero!\n");
} catch (InvalidOperation &io) {
printf("InvalidOperation:%s\n", io.why.c_str());
}
work.op = Operation::SUBTRACT;
work.num1 = 15;
work.num2 = 10;
int32_t diff = client.calculate(1, work);
printf("15-10=%d\n", diff);
// Note that C++ uses return by referencefor complex types to avoid
// costly copy construction
SharedStruct ss;
client.getStruct(ss, 1);
printf("Check log: %s\n",ss.value.c_str());
//断开连接
transport->close();
} catch (TException &tx) {
printf("ERROR: %s\n", tx.what());
}
}
类似开源软件对比
thrift 提供多语言的支持，RPC，序列化等功能。
protobuf 提供了序列化功能。
avro 和thrift类似，但多了动态动态类型。
压缩率的话，protobuf要好一点，另外更详细开销之类的对比可以看这里
hdfs中的thrift使用场景
以hadoop-1.1.2为例，\hadoop-1.1.2\src\contrib\thriftfs\if中定义了thrift的接口，其中service如下
service ThriftHadoopFileSystem
{
// set inactivity timeout period. The period isspecified in seconds.
// if there are no RPC calls to the HadoopThriftserver for this much
// time, then the server kills itself.
void setInactivityTimeoutPeriod(1:i64periodInSeconds),
// close session
void shutdown(1:i32 status),
// create a file and open it for writing
ThriftHandle create(1:Pathname path) throws(1:ThriftIOException ouch),
// create a file and open it for writing
ThriftHandle createFile(1:Pathname path, 2:i16mode,
3:bool overwrite, 4:i32 bufferSize,
5:i16 block_replication, 6:i64blocksize)
throws (1:ThriftIOException ouch),
// returns a handle to an existing file forreading
ThriftHandle open(1:Pathname path) throws(1:ThriftIOException ouch),
// returns a handle to an existing file forappending to it.
ThriftHandle append(1:Pathname path) throws(1:ThriftIOException ouch),
// write a string to the open handle for the file
bool write(1:ThriftHandle handle, string data)throws (1:ThriftIOException ouch),
// read some bytes from the open handle for thefile
string read(1:ThriftHandle handle, i64 offset, i32size) throws (1:ThriftIOException ouch),
// close file
bool close(1:ThriftHandle out) throws(1:ThriftIOException ouch),
// delete file(s) or directory(s)
bool rm(1:Pathname path, 2:bool recursive) throws(1:ThriftIOException ouch),
// rename file(s) or directory(s)
bool rename(1:Pathname path, 2:Pathname dest)throws (1:ThriftIOException ouch),
// create directory
bool mkdirs(1:Pathname path) throws(1:ThriftIOException ouch),
// Does this pathname exist?
bool exists(1:Pathname path) throws(1:ThriftIOException ouch),
// Returns status about the path
FileStatus stat(1:Pathname path) throws(1:ThriftIOException ouch),
// If the path is a directory, then returns thelist of pathnames in that directory
list<FileStatus> listStatus(1:Pathname path)throws (1:ThriftIOException ouch),
// Set permission for this file
void chmod(1:Pathname path, 2:i16 mode) throws(1:ThriftIOException ouch),
// set the owner and group of the file.
void chown(1:Pathname path, 2:string owner,3:string group) throws (1:ThriftIOException ouch),
// set the replication factor for all blocks ofthe specified file
void setReplication(1:Pathname path, 2:i16replication) throws (1:ThriftIOException ouch),
// get the locations of the blocks of this file
list<BlockLocation> getFileBlockLocations(1:Pathnamepath, 2:i64 start, 3:i64 length) throws (1:ThriftIOException ouch),
}
从service上可以看出只是提供了简单的文件读写接口，再看实现，在hadoop-1.1.2\src\contrib\thriftfs\src\java\org\apache\hadoop\thriftfs中实现了ThriftHadoopFileSystem，其中构造函数如下
public HadoopThriftHandler(String name) {
conf = new Configuration();
now = now();
try {
inactivityThread = newDaemon(new InactivityMonitor());
fs =FileSystem.get(conf);
} catch (IOException e) {
LOG.warn("Unable to openhadoop file system...");
Runtime.getRuntime().exit(-1);
}
}
其中fs = FileSystem.get(conf);这里会根据配置中指定的fs.default.name是hdfs://开头的，而确定fs是 DistributedFileSystem对象。
在ThriftHadoopFileSystem内部可以其他文件操作接口的具体实现，都可以看到时调用的DistributedFileSystem的接口。
因此，可以知道，hdfs对于多语言的支持是通过独立提供一个thrift server(达到和hdfs内部协议分离)，在server端通过java实现底层调用的是真正的HDFS客户端接口，客户端只要是thrift支持的语言，就可以与thrift server通信，从而达到对hdfs的文件操作。
storm中的thrift使用场景
storm在storm-0.8.2-src\storm-0.8.2\src中有一个storm.thrift，内部定义的比较长，在thrift文件中定义了3个service，分别是
service Nimbus，serviceDistributedRPC，service DistributedRPCInvocations。需要注意的是storm使用的thrift0.7的版本，
我自己用0.9的thrift生成了下java代码，发现storm-0.8.2-src\storm-0.8.2\src\jvm\backtype\storm\generated和一样，但storm没有用
java去实现这些接口，而是用clojure在核心代码中去完成对接口的实现，从而可以知道，storm和外部多语言的支持是基于thrift的RPC。
了解过thrift后，可以就很清楚的知道了storm的协议，方便了对storm的源码分析。
启发
hdfs和storm都是用thrift作为多语言的支持，但使用的形式不同，对于我们自己的云存储以后对多语言的支持可以考虑使用hdfs类似的方式，
这样内部协议和外部thrift的协议分开，内部协议的改动都只局限在集群内部和Client，而thrift的server只要类似hdfs这样在server内部调用真正的接口就ok。