Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
autoconf
automake -ac --add-missing --foreign || exit 1
-for subdir in ${subdirs}; do
- if [ -x "${subdir}/bootstrap.sh" ]; then
+for subdir in ${subdirs}; do
+ if [ -x "${subdir}/bootstrap.sh" ]; then
cwd="`pwd`"
cd "${subdir}"
./bootstrap.sh
void generate_cocoa_struct_result_writer(std::ofstream& out, t_struct* tstruct);
void generate_cocoa_struct_writer(std::ofstream& out, t_struct* tstruct);
void generate_cocoa_struct_description(std::ofstream& out, t_struct* tstruct);
-
+
std::string function_result_helper_struct_type(t_function* tfunction);
void generate_function_helpers(t_function* tfunction);
-
+
/**
* Service-level generation functions
*/
*/
void generate_deserialize_field (std::ofstream& out,
- t_field* tfield,
+ t_field* tfield,
std::string fieldName);
-
+
void generate_deserialize_struct (std::ofstream& out,
t_struct* tstruct,
std::string prefix="");
-
+
void generate_deserialize_container (std::ofstream& out,
t_type* ttype,
std::string prefix="");
-
+
void generate_deserialize_set_element (std::ofstream& out,
t_set* tset,
std::string prefix="");
ttype = get_true_type(ttype);
return
- ttype->is_container() ||
+ ttype->is_container() ||
ttype->is_struct() ||
ttype->is_xception() ||
ttype->is_string();
string t_csharp_generator::csharp_type_usings() {
return string() +
"using System;\n" +
- "using System.Collections;\n" +
+ "using System.Collections;\n" +
"using System.Collections.Generic;\n" +
- "using System.Text;\n" +
+ "using System.Text;\n" +
"using Thrift;\n";
}
}
scope_down(f_enum);
-
+
end_csharp_namespace(f_enum);
f_enum.close();
indent_down();
indent(out) << "}" << endl << endl;
}
-
+
indent(out) <<
"public " << tstruct->get_name() << "() {" << endl;
indent_up();
indent(out) <<
"TField field;" << endl <<
indent() << "TStruct struc = iprot.ReadStructBegin();" << endl;
-
+
indent(out) <<
"while (true)" << endl;
scope_up(out);
} else if (type->is_base_type() || type->is_enum()) {
indent(out) <<
name << " = ";
-
+
if (type->is_enum())
{
out << "(" << type_name(type, false, true) << ")";
indent(out) <<
"for( int " << i << " = 0; " << i << " < " << obj << ".Count" << "; " << "++" << i << ")" << endl;
scope_up(out);
-
+
if (ttype->is_map()) {
generate_deserialize_map_element(out, (t_map*)ttype, prefix);
} else if (ttype->is_set()) {
f_types_.close();
f_consts_.close();
}
-
+
/**
* Generates a typedef. Ez.
*
}
/**
- * Generates code for an enumerated type.
+ * Generates code for an enumerated type.
* the values.
*
* @param tenum The enumeration
++value;
}
string name = capitalize((*c_iter)->get_name());
-
+
f_types_ <<
indent() << name << " -> " << value << endl;
}
++value;
}
string name = capitalize((*c_iter)->get_name());
-
+
f_types_ <<
indent() << value << " -> " << name << endl;
}
t_type* etype = ((t_set*)type)->get_elem_type();
const vector<t_const_value*>& val = value->get_list();
vector<t_const_value*>::const_iterator v_iter;
- out << "(mkSet [";
+ out << "(mkSet [";
for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
string val = render_const_value(etype, *v_iter);
- out << val;
+ out << val;
}
out << "])";
}
* @param txception The struct definition
*/
void t_hs_generator::generate_xception(t_struct* txception) {
- generate_hs_struct(txception, true);
+ generate_hs_struct(txception, true);
}
/**
}
/**
- * Generates a struct definition for a thrift data type.
+ * Generates a struct definition for a thrift data type.
*
* @param tstruct The struct definition
*/
string tname = type_name(tstruct);
string name = tstruct->get_name();
const vector<t_field*>& members = tstruct->get_members();
- vector<t_field*>::const_iterator m_iter;
+ vector<t_field*>::const_iterator m_iter;
indent(out) << "data "<<tname<<" = "<<tname;
if (members.size() > 0) {
indent(out) << "read_" << sname << "_fields iprot rec = do" << endl;
indent_up(); // do
-
+
// Read beginning field marker
indent(out) << "(_," << t <<","<<id<<") <- readFieldBegin iprot" << endl;
// Check for field STOP marker and break
indent_down(); // -case
indent_down(); // -if
indent_down(); // -do
- indent_down();
+ indent_down();
// read
indent(out) << "read_"<<sname<<" iprot = do" << endl;
f_service_ <<
- "import " << capitalize(program_name_) << "_Types" << endl <<
+ "import " << capitalize(program_name_) << "_Types" << endl <<
"import qualified " << capitalize(service_name_) << "_Iface as Iface" << endl;
-
- // Generate the three main parts of the service
+
+ // Generate the three main parts of the service
generate_service_helpers(tservice);
generate_service_interface(tservice);
generate_service_client(tservice);
indent(f_iface_) << "module " << capitalize(service_name_) << "_Iface where" << endl;
indent(f_iface_) <<
- hs_imports() << endl <<
- "import " << capitalize(program_name_) << "_Types" << endl <<
+ hs_imports() << endl <<
+ "import " << capitalize(program_name_) << "_Types" << endl <<
endl;
-
+
if (tservice->get_extends() != NULL) {
string extends = type_name(tservice->get_extends());
indent(f_iface_) << "import " << extends <<"_Iface" << endl;
indent_up();
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
+ vector<t_function*>::iterator f_iter;
for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
string ft = function_type(*f_iter,true,true,true);
f_iface_ <<
f_client_.open(f_client_name.c_str());
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::const_iterator f_iter;
+ vector<t_function*>::const_iterator f_iter;
string extends = "";
string exports="";
indent(f_client_) << "import " << capitalize(service_name_) << endl;
// DATS RITE A GLOBAL VAR
indent(f_client_) << "seqid = newIORef 0" << endl;
-
+
// Generate client method implementations
indent(f_client_) << "send_" << funname << " op" << fargs;
f_client_ << endl;
-
+
if (!(*f_iter)->is_async()) {
f_client_ << indent();
f_client_ <<
"recv_" << funname << " ip" << endl;
}
indent_down();
-
+
indent(f_client_) <<
"send_" << funname << " op" << fargs << " = do" << endl;
indent_up();
indent(f_client_) << "seq <- seqid" << endl;
indent(f_client_) << "seqn <- readIORef seq" << endl;
std::string argsname = capitalize((*f_iter)->get_name() + "_args");
-
+
// Serialize the request header
f_client_ <<
- indent() << "writeMessageBegin op (\"" << (*f_iter)->get_name() << "\", M_CALL, seqn)" << endl;
+ indent() << "writeMessageBegin op (\"" << (*f_iter)->get_name() << "\", M_CALL, seqn)" << endl;
f_client_ << indent() << "write_" << argsname << " op ("<<argsname<<"{";
bool first = true;
for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
f_client_ << "f_" << argsname <<"_" << (*fld_iter)->get_name() << "=Just arg_" << (*fld_iter)->get_name();
}
f_client_ << "})" << endl;
-
+
// Write to the stream
f_client_ <<
indent() << "writeMessageEnd op" << endl <<
- indent() << "pflush op" << endl;
-
+ indent() << "pflush op" << endl;
+
indent_down();
if (!(*f_iter)->is_async()) {
t_struct noargs(program_);
std::string funname = string("recv_") + (*f_iter)->get_name();
-
+
t_function recv_function((*f_iter)->get_returntype(),
funname,
&noargs);
indent(f_client_) << "Nothing -> do" << endl;
indent_up(); // none
}
-
-
+
+
vector<t_field*>::const_iterator x_iter;
for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
f_client_ <<
indent(f_client_) << "Just _v -> throwDyn _v" << endl;
indent_down(); //-case
}
-
+
// Careful, only return _result if not a void function
if ((*f_iter)->get_returntype()->is_void()) {
indent(f_client_) <<
void t_hs_generator::generate_service_server(t_service* tservice) {
// Generate the dispatch methods
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
+ vector<t_function*>::iterator f_iter;
// Generate the process subfunctions
for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
n++;
}
indent(f_service_) << "rs <- return (" << resultname;
-
+
for(int i=0; i<n;i++){
f_service_ << " Nothing";
}
}
f_service_ << ")" << endl;
indent_down();
-
+
if (xceptions.size() > 0 && !tfunction->is_async()) {
for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
indent(f_service_) << "(\\e -> " <<endl;
case t_base_type::TYPE_VOID:
throw "compiler error: cannot serialize void field in a struct";
break;
- case t_base_type::TYPE_STRING:
+ case t_base_type::TYPE_STRING:
out << "readString";
break;
case t_base_type::TYPE_BOOL:
type->get_name().c_str());
}
}
-
+
/**
* Generates an unserializer for a struct, calling read()
string vtype = tmp("_vtype");
string etype = tmp("_etype");
string con = tmp("_con");
-
+
t_field fsize(g_type_i32, size);
t_field fktype(g_type_byte, ktype);
t_field fvtype(g_type_byte, vtype);
if(name.length() == 0){
name = decapitalize(tfield->get_name());
- }
+ }
if (type->is_struct() || type->is_xception()) {
generate_serialize_struct(out,
default:
throw "compiler error: no hs name for base type " + t_base_type::t_base_name(tbase);
}
-
+
} else if (type->is_enum()) {
string ename = capitalize(type->get_name());
out << "writeI32 oprot (fromEnum "<< name << ")";
}
-
+
} else {
printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s' TYPE '%s'\n",
tfield->get_name().c_str(),
string t_hs_generator::function_type(t_function* tfunc, bool options, bool io, bool method){
string result="";
-
+
const vector<t_field*>& fields = tfunc->get_arglist()->get_members();
vector<t_field*>::const_iterator f_iter;
for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
*/
string t_hs_generator::type_to_enum(t_type* type) {
type = get_true_type(type);
-
+
if (type->is_base_type()) {
t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
switch (tbase) {
*/
string t_hs_generator::render_hs_type(t_type* type) {
type = get_true_type(type);
-
+
if (type->is_base_type()) {
t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
switch (tbase) {
void generate_deserialize_field (std::ofstream &out,
t_field* tfield,
std::string prefix);
-
+
void generate_deserialize_struct (std::ofstream &out,
t_struct* tstruct);
-
+
void generate_deserialize_container (std::ofstream &out,
t_type* ttype);
-
+
void generate_deserialize_set_element (std::ofstream &out,
t_set* tset);
*/
void generate_deserialize_field (std::ofstream& out,
- t_field* tfield,
+ t_field* tfield,
std::string prefix="");
-
+
void generate_deserialize_struct (std::ofstream& out,
t_struct* tstruct,
std::string prefix="");
-
+
void generate_deserialize_container (std::ofstream& out,
t_type* ttype,
std::string prefix="");
-
+
void generate_deserialize_set_element (std::ofstream& out,
t_set* tset,
std::string prefix="");
ttype = get_true_type(ttype);
return
- ttype->is_container() ||
+ ttype->is_container() ||
ttype->is_struct() ||
ttype->is_xception() ||
ttype->is_string();
// Close types file
f_types_.close();
}
-
+
/**
* Generates a typedef. Ez.
*
}
/**
- * Generates code for an enumerated type.
+ * Generates code for an enumerated type.
* the values.
*
* @param tenum The enumeration
++value;
}
string name = capitalize((*c_iter)->get_name());
-
+
f_types_ <<
indent() << "| " << name << " -> " << value << endl;
}
++value;
}
string name = capitalize((*c_iter)->get_name());
-
+
f_types_ <<
indent() << "| " << value << " -> " << name << endl;
}
* @param txception The struct definition
*/
void t_ocaml_generator::generate_xception(t_struct* txception) {
- generate_ocaml_struct(txception, true);
+ generate_ocaml_struct(txception, true);
}
/**
}
/**
- * Generates a struct definition for a thrift data type.
+ * Generates a struct definition for a thrift data type.
*
* @param tstruct The struct definition
*/
t_struct* tstruct,
bool is_exception) {
const vector<t_field*>& members = tstruct->get_members();
- vector<t_field*>::const_iterator m_iter;
+ vector<t_field*>::const_iterator m_iter;
string tname = type_name(tstruct);
indent(out) << "class " << tname << " =" << endl;
indent(out) << "object (self)" << endl;
}
/**
- * Generates a struct definition for a thrift data type.
+ * Generates a struct definition for a thrift data type.
*
* @param tstruct The struct definition
*/
t_struct* tstruct,
bool is_exception) {
const vector<t_field*>& members = tstruct->get_members();
- vector<t_field*>::const_iterator m_iter;
+ vector<t_field*>::const_iterator m_iter;
string tname = type_name(tstruct);
indent(out) << "class " << tname << " :" << endl;
indent(out) << "object" << endl;
indent(out) << "let " << str << " = new " << sname << " in" << endl;
indent_up();
indent(out) <<
- "ignore(iprot#readStructBegin);" << endl;
+ "ignore(iprot#readStructBegin);" << endl;
// Loop over reading in fields
indent(out) <<
"(try while true do" << endl;
indent_up();
indent_up();
-
+
// Read beginning field marker
indent(out) <<
"let (_," << t <<","<<id<<") = iprot#readFieldBegin in" << endl;
-
+
// Check for field STOP marker and break
indent(out) <<
"if " << t <<" = Protocol.T_STOP then" << endl;
"raise Break" << endl;
indent_down();
indent(out) << "else ();" << endl;
-
+
indent(out) << "(match " << id<<" with " << endl;
indent_up();
// Generate deserialization code for known cases
// In the default case we skip the field
out <<
indent() << "| _ -> " << "iprot#skip "<<t<<");" << endl;
- indent_down();
+ indent_down();
// Read field end marker
indent(out) << "iprot#readFieldEnd;" << endl;
indent_down();
}
*/
f_service_ <<
- "open " << capitalize(program_name_) << "_types" << endl <<
+ "open " << capitalize(program_name_) << "_types" << endl <<
endl;
f_service_i_ <<
- "open " << capitalize(program_name_) << "_types" << endl <<
+ "open " << capitalize(program_name_) << "_types" << endl <<
endl;
- // Generate the three main parts of the service
+ // Generate the three main parts of the service
generate_service_helpers(tservice);
generate_service_interface(tservice);
generate_service_client(tservice);
}
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
+ vector<t_function*>::iterator f_iter;
for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
string ft = function_type(*f_iter,true,true);
f_service_ <<
indent(f_service_i_) << "inherit " << extends << ".client" << endl;
}
indent(f_service_) << "val mutable seqid = 0" << endl;
-
+
// Generate client method implementations
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::const_iterator f_iter;
+ vector<t_function*>::const_iterator f_iter;
for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
t_struct* arg_struct = (*f_iter)->get_arglist();
const vector<t_field*>& fields = arg_struct->get_members();
indent(f_service_) <<
"self#send_" << funname;
-
+
for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
f_service_ << " " << decapitalize((*fld_iter)->get_name());
}
f_service_ << ";" << endl;
-
+
if (!(*f_iter)->is_async()) {
f_service_ << indent();
f_service_ <<
"self#recv_" << funname << endl;
}
indent_down();
-
+
indent(f_service_) <<
"method private send_" << function_signature(*f_iter) << " = " << endl;
indent_up();
-
+
std::string argsname = decapitalize((*f_iter)->get_name() + "_args");
-
+
// Serialize the request header
f_service_ <<
indent() << "oprot#writeMessageBegin (\"" << (*f_iter)->get_name() << "\", Protocol.CALL, seqid);" << endl;
-
+
f_service_ <<
indent() << "let args = new " << argsname << " in" << endl;
indent_up();
-
+
for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
f_service_ <<
indent() << "args#set_" << (*fld_iter)->get_name() << " " << (*fld_iter)->get_name() << ";" << endl;
}
-
+
// Write to the stream
f_service_ <<
indent() << "args#write oprot;" << endl <<
indent() << "oprot#writeMessageEnd;" << endl <<
- indent() << "oprot#getTransport#flush" << endl;
-
+ indent() << "oprot#getTransport#flush" << endl;
+
indent_down();
indent_down();
if (!(*f_iter)->is_async()) {
std::string resultname = decapitalize((*f_iter)->get_name() + "_result");
t_struct noargs(program_);
-
+
t_function recv_function((*f_iter)->get_returntype(),
string("recv_") + (*f_iter)->get_name(),
&noargs);
indent() << "match result#get_success with Some v -> v | None -> (" << endl;
indent_up();
}
-
-
+
+
vector<t_field*>::const_iterator x_iter;
for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
f_service_ <<
indent() << "(match result#get_" << (*x_iter)->get_name() << " with None -> () | Some _v ->" << endl;
indent(f_service_) << " raise (" << capitalize(type_name((*x_iter)->get_type())) << " _v));" << endl;
}
-
+
// Careful, only return _result if not a void function
if ((*f_iter)->get_returntype()->is_void()) {
indent(f_service_) <<
f_service_ <<
indent() << "raise (Application_Exn.E (Application_Exn.create Application_Exn.MISSING_RESULT \"" << (*f_iter)->get_name() << " failed: unknown result\")))" << endl;
indent_down();
- }
+ }
// Close function
indent_down();
void t_ocaml_generator::generate_service_server(t_service* tservice) {
// Generate the dispatch methods
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
+ vector<t_function*>::iterator f_iter;
// Generate the header portion
indent() << "inherit Processor.t" << endl <<
endl;
string extends = "";
-
+
if (tservice->get_extends() != NULL) {
extends = type_name(tservice->get_extends());
indent(f_service_) << "inherit " + extends + ".processor (handler :> " + extends + ".iface)" << endl;
indent(f_service_) << "val processMap = Hashtbl.create " << functions.size() << endl;
}
indent(f_service_i_) << "val processMap : (string, int * Protocol.t * Protocol.t -> unit) Hashtbl.t" << endl;
-
+
// Generate the server implementation
indent(f_service_) <<
"method process iprot oprot =" << endl;
for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
f_service_ <<
indent() << "Hashtbl.add processMap \"" << (*f_iter)->get_name() << "\" self#process_" << (*f_iter)->get_name() << ";" << endl;
- }
+ }
indent_down();
indent_down();
indent() << "(try" << endl;
indent_up();
}
-
-
+
+
f_service_ << indent();
if (!tfunction->is_async() && !tfunction->get_returntype()->is_void()) {
f_service_ << "result#set_success ";
}
f_service_ << ");" << endl;
-
+
if (xceptions.size() > 0) {
indent_down();
indent(f_service_) << "with" <<endl;
case t_base_type::TYPE_VOID:
throw "compiler error: cannot serialize void field in a struct";
break;
- case t_base_type::TYPE_STRING:
+ case t_base_type::TYPE_STRING:
out << "readString";
break;
case t_base_type::TYPE_BOOL:
type->get_name().c_str());
}
}
-
+
/**
* Generates an unserializer for a struct, calling read()
string vtype = tmp("_vtype");
string etype = tmp("_etype");
string con = tmp("_con");
-
+
t_field fsize(g_type_i32, size);
t_field fktype(g_type_byte, ktype);
t_field fvtype(g_type_byte, vtype);
if (ttype->is_map()) {
indent(out) << "(let ("<<ktype<<","<<vtype<<","<<size<<") = iprot#readMapBegin in" << endl;
indent(out) << "let "<<con<<" = Hashtbl.create "<<size<<" in" << endl;
- indent_up();
+ indent_up();
indent(out) << "for i = 1 to "<<size<<" do" <<endl;
indent_up();
indent(out) << "let _k = ";
} else if (ttype->is_set()) {
indent(out) << "(let ("<<etype<<","<<size<<") = iprot#readSetBegin in" << endl;
indent(out) << "let "<<con<<" = Hashtbl.create "<<size<<" in" << endl;
- indent_up();
+ indent_up();
indent(out) << "for i = 1 to "<<size<<" do" <<endl;
indent_up();
indent(out) << "Hashtbl.add "<<con<<" ";
} else if (ttype->is_list()) {
indent(out) << "(let ("<<etype<<","<<size<<") = iprot#readListBegin in" << endl;
indent_up();
- indent(out) << "let "<<con<<" = (Array.to_list (Array.init "<<size<<" (fun _ -> ";
+ indent(out) << "let "<<con<<" = (Array.to_list (Array.init "<<size<<" (fun _ -> ";
generate_deserialize_type(out,((t_list*)ttype)->get_elem_type());
out << "))) in" << endl;
indent_up();
if(name.length() == 0){
name = decapitalize(tfield->get_name());
- }
+ }
if (type->is_struct() || type->is_xception()) {
generate_serialize_struct(out,
indent(out) <<
"oprot#";
-
+
if (type->is_base_type()) {
t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
switch (tbase) {
string ename = capitalize(type->get_name());
out << "writeI32("<<ename<<".to_i " << name << ")";
}
-
+
} else {
printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s' TYPE '%s'\n",
tfield->get_name().c_str(),
indent_down();
indent(out) << ") " << prefix << ";" << endl;
}
-
+
if (ttype->is_map()) {
indent(out) <<
"oprot#writeMapEnd";
string t_ocaml_generator::function_type(t_function* tfunc, bool method, bool options){
string result="";
-
+
const vector<t_field*>& fields = tfunc->get_arglist()->get_members();
vector<t_field*>::const_iterator f_iter;
for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
*/
string t_ocaml_generator::type_to_enum(t_type* type) {
type = get_true_type(type);
-
+
if (type->is_base_type()) {
t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
switch (tbase) {
*/
string t_ocaml_generator::render_ocaml_type(t_type* type) {
type = get_true_type(type);
-
+
if (type->is_base_type()) {
t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
switch (tbase) {
void generate_deserialize_field (std::ofstream &out,
t_field* tfield,
std::string prefix);
-
+
void generate_deserialize_struct (std::ofstream &out,
t_struct* tstruct);
-
+
void generate_deserialize_container (std::ofstream &out,
t_type* ttype);
-
+
void generate_deserialize_set_element (std::ofstream &out,
t_set* tset);
public:
t_perl_generator(t_program* program) :
t_oop_generator(program) {
-
+
out_dir_base_ = "gen-perl";
}
| S_IROTH
| S_IXOTH
#endif
- );
+ );
}
/**
*/
void generate_deserialize_field (std::ofstream &out,
- t_field* tfield,
+ t_field* tfield,
std::string prefix="",
bool inclass=false);
-
+
void generate_deserialize_struct (std::ofstream &out,
t_struct* tstruct,
std::string prefix="");
-
+
void generate_deserialize_container (std::ofstream &out,
t_type* ttype,
std::string prefix="");
-
+
void generate_deserialize_set_element (std::ofstream &out,
t_set* tset,
std::string prefix="");
std::string type_to_enum(t_type* ttype);
-
+
std::string ruby_namespace(t_program* p) {
std::string ns = p->get_ruby_namespace();
return ns.size() ? ns : "";
}
-
+
std::vector<std::string> ruby_modules(t_program* p) {
std::string ns = p->get_ruby_namespace();
boost::tokenizer<> tok(ns);
std::vector<std::string> modules;
-
+
for(boost::tokenizer<>::iterator beg=tok.begin(); beg != tok.end(); ++beg) {
modules.push_back(*beg);
}
-
+
return modules;
}
-
+
void begin_namespace(std::ofstream&, std::vector<std::string>);
void end_namespace(std::ofstream&, std::vector<std::string>);
*/
std::ofstream f_types_;
- std::ofstream f_consts_;
+ std::ofstream f_consts_;
std::ofstream f_service_;
};
//This is nasty, but without it we'll break things by prefixing TResult.
string name = ((capitalize(clsName) == "TResult") ? capitalize(clsName) : prefix(clsName));
out << indent() << val << " := " << name << " new." << endl;
-
+
out << indent() << "iprot readStructBegin." << endl <<
indent() << "[" << desc << " := iprot readFieldBegin." << endl <<
indent() << desc << " type = TType stop] whileFalse: [|" << found << "|" << endl;
}
void t_xsd_generator::generate_struct(t_struct* tstruct) {
- vector<t_field*>::const_iterator m_iter;
+ vector<t_field*>::const_iterator m_iter;
const vector<t_field*>& members = tstruct->get_members();
bool xsd_all = tstruct->get_xsd_all();
-
+
indent(s_xsd_types_) << "<xsd:complexType name=\"" << tstruct->get_name() << "\">" << endl;
indent_up();
if (xsd_all) {
indent(s_xsd_types_) << "<xsd:sequence>" << endl;
}
indent_up();
-
+
for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
generate_element(s_xsd_types_, (*m_iter)->get_name(), (*m_iter)->get_type(), (*m_iter)->get_xsd_attrs(), (*m_iter)->get_xsd_optional() || xsd_all, (*m_iter)->get_xsd_nillable());
- }
+ }
indent_down();
if (xsd_all) {
"<xsd:element name=\"" << name << "\"" << soptional << snillable << ">" << endl;
indent_up();
if (attrs == NULL && ttype->is_void()) {
- indent(out) <<
+ indent(out) <<
"<xsd:complexType />" << endl;
} else {
indent(out) <<
"<xsd:complexType>" << endl;
- indent_up();
+ indent_up();
if (ttype->is_list()) {
indent(out) << "<xsd:sequence minOccurs=\"0\" maxOccurs=\"unbounded\">" << endl;
indent_up();
string ns = program_->get_xsd_namespace();
if (ns.size() > 0) {
- ns = " targetNamespace=\"" + ns + "\" xmlns=\"" + ns + "\" " +
+ ns = " targetNamespace=\"" + ns + "\" xmlns=\"" + ns + "\" " +
"elementFormDefault=\"qualified\"";
}
// List the elements that you might actually get
vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
+ vector<t_function*>::iterator f_iter;
for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
string elemname = (*f_iter)->get_name() + "_response";
t_type* returntype = (*f_iter)->get_returntype();
if (ttype->is_struct() || ttype->is_xception()) {
return ttype->get_name();
}
-
+
return "container";
}
const std::map<t_const_value*, t_const_value*>& get_map() const {
return mapVal_;
- }
+ }
void set_list() {
valType_ = CV_LIST;
doc_ = doc;
has_doc_ = true;
}
-
+
const std::string& get_doc() const {
return doc_;
}
-
+
bool has_doc() {
return has_doc_;
}
-
+
private:
std::string doc_;
bool has_doc_;
const std::string& get_name() {
return name_;
}
-
+
bool has_value() {
return has_value_;
}
-
+
int get_value() {
return value_;
}
-
+
private:
std::string name_;
bool has_value_;
int value_;
-};
+};
#endif
t_type* get_elem_type() const {
return elem_type_;
}
-
+
bool is_list() const {
return true;
}
}
private:
-
+
// Map of names to types
std::map<std::string, t_type*> types_;
std::map<std::string, t_const*> constants_;
// Map of names to services
- std::map<std::string, t_service*> services_;
-
+ std::map<std::string, t_service*> services_;
+
};
#endif
-// Distributed under the Thrift Software License\r
-//\r
-// See accompanying file LICENSE or visit the Thrift site at:\r
-// http://developers.facebook.com/thrift/\r
-\r
-/**\r
- * define for mkdir,since the method signature \r
- * is different for the non-POSIX MinGW\r
- */\r
-\r
-#ifdef MINGW\r
-#include <io.h>\r
-#else\r
-#include <sys/types.h>\r
-#include <sys/stat.h>\r
-#endif\r
-\r
-#if defined MINGW\r
-#define MKDIR(x) mkdir(x)\r
-#else\r
-#define MKDIR(x) mkdir(x, S_IRWXU | S_IRWXG | S_IRWXO)\r
-#endif\r
+// Distributed under the Thrift Software License
+//
+// See accompanying file LICENSE or visit the Thrift site at:
+// http://developers.facebook.com/thrift/
+
+/**
+ * define for mkdir,since the method signature
+ * is different for the non-POSIX MinGW
+ */
+
+#ifdef MINGW
+#include <io.h>
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
+#if defined MINGW
+#define MKDIR(x) mkdir(x)
+#else
+#define MKDIR(x) mkdir(x, S_IRWXU | S_IRWXG | S_IRWXO)
+#endif
\begin{document}
-% \conferenceinfo{WXYZ '05}{date, City.}
+% \conferenceinfo{WXYZ '05}{date, City.}
% \copyrightyear{2007}
-% \copyrightdata{[to be supplied]}
+% \copyrightdata{[to be supplied]}
% \titlebanner{banner above paper title} % These are ignored unless
% \preprintfooter{short description of paper} % 'preprint' option specified.
\section{Introduction}
As Facebook's traffic and network structure have scaled, the resource
-demands of many operations on the site (i.e. search,
+demands of many operations on the site (i.e. search,
ad selection and delivery, event logging) have presented technical requirements
drastically outside the scope of the LAMP framework. In our implementation of
these services, various programming languages have been selected to
a C++ programmer should be able to transparently exchange a strongly typed
STL map for a dynamic Python dictionary. Neither
programmer should be forced to write any code below the application layer
-to achieve this. Section 2 details the Thrift type system.
+to achieve this. Section 2 details the Thrift type system.
\textit{Transport.} Each language must have a common interface to
bidirectional raw data transport. The specifics of how a given
contain duplicates.
\item \texttt{set<type>} An unordered set of unique elements. Translates into
an STL \texttt{set}, Java \texttt{HashSet}, \texttt{set} in Python, or native
-dictionary in PHP/Ruby.
+dictionary in PHP/Ruby.
\item \texttt{map<type1,type2>} A map of strictly unique keys to values
Translates into an STL \texttt{map}, Java \texttt{HashMap}, PHP associative
array, or Python/Ruby dictionary.
service StringCache {
void set(1:i32 key, 2:string value),
string get(1:i32 key) throws (1:KeyNotFound knf),
- void delete(1:i32 key)
+ void delete(1:i32 key)
}
\end{verbatim}
A key design choice in the implementation of Thrift was to decouple the
transport layer from the code generation layer. Though Thrift is typically
used on top of the TCP/IP stack with streaming sockets as the base layer of
-communication, there was no compelling reason to build that constraint into
+communication, there was no compelling reason to build that constraint into
the system. The performance tradeoff incurred by an abstracted I/O layer
(roughly one virtual method lookup / function call per operation) was
immaterial compared to the cost of actual I/O operations (typically invoking
service StringCache {
void set(1:i32 key, 2:string value),
string get(1:i32 key) throws (1:KeyNotFound knf),
- void delete(1:i32 key)
+ void delete(1:i32 key)
}
\end{verbatim}
number(10),
bigNumber(0),
decimals(0),
- name("thrifty") {}
+ name("thrifty") {}
int32_t number;
int64_t bigNumber;
} __isset;
...
}
-\end{verbatim}
+\end{verbatim}
\subsection{Case Analysis}
requests from multiple clients. For the Python and Java implementations of
Thrift server logic, the standard threading libraries distributed with the
languages provide adequate support. For the C++ implementation, no standard multithread runtime
-library exists. Specifically, robust, lightweight, and portable
+library exists. Specifically, robust, lightweight, and portable
thread manager and timer class implementations do not exist. We investigated
-existing implementations, namely \texttt{boost::thread},
+existing implementations, namely \texttt{boost::thread},
\texttt{boost::threadpool}, \texttt{ACE\_Thread\_Manager} and
-\texttt{ACE\_Timer}.
+\texttt{ACE\_Timer}.
While \texttt{boost::threads}\cite{boost.threads} provides clean,
lightweight and robust implementations of multi-thread primitives (mutexes,
conditions, threads) it does not provide a thread manager or timer
-implementation.
+implementation.
\texttt{boost::threadpool}\cite{boost.threadpool} also looked promising but
was not far enough along for our purposes. We wanted to limit the dependency on
ACE has both a thread manager and timer class in addition to multi-thread
primitives. The biggest problem with ACE is that it is ACE. Unlike Boost, ACE
API quality is poor. Everything in ACE has large numbers of dependencies on
-everything else in ACE - thus forcing developers to throw out standard
+everything else in ACE - thus forcing developers to throw out standard
classes, such as STL collections, in favor of ACE's homebrewed implementations. In
addition, unlike Boost, ACE implementations demonstrate little understanding
of the power and pitfalls of C++ programming and take no advantage of modern
\end{itemize}
As mentioned above, we were hesitant to introduce any additional dependencies
-on Thrift. We decided to use \texttt{boost::shared\_ptr} because it is so
+on Thrift. We decided to use \texttt{boost::shared\_ptr} because it is so
useful for multithreaded application, it requires no link-time or
runtime libraries (i.e. it is a pure template library) and it is due
to become part of the C++0x standard.
We implement standard \texttt{Mutex} and \texttt{Condition} classes, and a
- \texttt{Monitor} class. The latter is simply a combination of a mutex and
+ \texttt{Monitor} class. The latter is simply a combination of a mutex and
condition variable and is analogous to the \texttt{Monitor} implementation provided for
-the Java \texttt{Object} class. This is also sometimes referred to as a barrier. We
+the Java \texttt{Object} class. This is also sometimes referred to as a barrier. We
provide a \texttt{Synchronized} guard class to allow Java-like synchronized blocks.
-This is just a bit of syntactic sugar, but, like its Java counterpart, clearly
+This is just a bit of syntactic sugar, but, like its Java counterpart, clearly
delimits critical sections of code. Unlike its Java counterpart, we still
have the ability to programmatically lock, unlock, block, and signal monitors.
We again borrowed from Java the distinction between a thread and a runnable
class. A \texttt{Thread} is the actual schedulable object. The
-\texttt{Runnable} is the logic to execute within the thread.
-The \texttt{Thread} implementation deals with all the platform-specific thread
+\texttt{Runnable} is the logic to execute within the thread.
+The \texttt{Thread} implementation deals with all the platform-specific thread
creation and destruction issues, while the \texttt{Runnable} implementation deals
with the application-specific per-thread logic. The benefit of this approach
-is that developers can easily subclass the Runnable class without pulling in
+is that developers can easily subclass the Runnable class without pulling in
platform-specific super-classes.
\subsection{Thread, Runnable, and shared\_ptr}
With the weak reference in hand the \texttt{ThreadMain} function can attempt to get
a strong reference before entering the \texttt{Runnable::run} method of the
\texttt{Runnable} object bound to the \texttt{Thread}. If no strong references to the
-thread are obtained between exiting \texttt{Thread::start} and entering \texttt{ThreadMain}, the weak reference returns \texttt{null} and the function
+thread are obtained between exiting \texttt{Thread::start} and entering \texttt{ThreadMain}, the weak reference returns \texttt{null} and the function
exits immediately.
The need for the \texttt{Thread} to make a weak reference to itself has a
needs to know what \texttt{Runnable} object it is hosting. This interdependency is
further complicated because the lifecycle of each object is independent of the
other. An application may create a set of \texttt{Runnable} object to be reused in different threads, or it may create and forget a \texttt{Runnable} object
-once a thread has been created and started for it.
+once a thread has been created and started for it.
The \texttt{Thread} class takes a \texttt{boost::shared\_ptr} reference to the hosted
\texttt{Runnable} object in its constructor, while the \texttt{Runnable} class has an
\subsection{ThreadManager}
-\texttt{ThreadManager} creates a pool of worker threads and
+\texttt{ThreadManager} creates a pool of worker threads and
allows applications to schedule tasks for execution as free worker threads
-become available. The \texttt{ThreadManager} does not implement dynamic
+become available. The \texttt{ThreadManager} does not implement dynamic
thread pool resizing, but provides primitives so that applications can add
-and remove threads based on load. This approach was chosen because
-implementing load metrics and thread pool size is very application
+and remove threads based on load. This approach was chosen because
+implementing load metrics and thread pool size is very application
specific. For example some applications may want to adjust pool size based
on running-average of work arrival rates that are measured via polled
samples. Others may simply wish to react immediately to work-queue
depth high and low water marks. Rather than trying to create a complex
-API abstract enough to capture these different approaches, we
-simply leave it up to the particular application and provide the
+API abstract enough to capture these different approaches, we
+simply leave it up to the particular application and provide the
primitives to enact the desired policy and sample current status.
\subsection{TimerManager}
\texttt{TimerManager} allows applications to schedule
- \texttt{Runnable} objects for execution at some point in the future. Its specific task
+ \texttt{Runnable} objects for execution at some point in the future. Its specific task
is to allows applications to sample \texttt{ThreadManager} load at regular
intervals and make changes to the thread pool size based on application policy.
Of course, it can be used to generate any number of timer or alarm events.
The default implementation of \texttt{TimerManager} uses a single thread to
-execute expired \texttt{Runnable} objects. Thus, if a timer operation needs to
+execute expired \texttt{Runnable} objects. Thus, if a timer operation needs to
do a large amount of work and especially if it needs to do blocking I/O,
that should be done in a separate thread.
struct instances in the generated C++ code, this would actually be impossible.)
\subsection{TFileTransport}
-The \texttt{TFileTransport} logs Thrift requests/structs by
-framing incoming data with its length and writing it out to disk.
-Using a framed on-disk format allows for better error checking and
+The \texttt{TFileTransport} logs Thrift requests/structs by
+framing incoming data with its length and writing it out to disk.
+Using a framed on-disk format allows for better error checking and
helps with the processing of a finite number of discrete events. The\\
-\texttt{TFileWriterTransport} uses a system of swapping in-memory buffers
-to ensure good performance while logging large amounts of data.
+\texttt{TFileWriterTransport} uses a system of swapping in-memory buffers
+to ensure good performance while logging large amounts of data.
A Thrift log file is split up into chunks of a specified size; logged messages
-are not allowed to cross chunk boundaries. A message that would cross a chunk
-boundary will cause padding to be added until the end of the chunk and the
+are not allowed to cross chunk boundaries. A message that would cross a chunk
+boundary will cause padding to be added until the end of the chunk and the
first byte of the message are aligned to the beginning of the next chunk.
-Partitioning the file into chunks makes it possible to read and interpret data
-from a particular point in the file.
+Partitioning the file into chunks makes it possible to read and interpret data
+from a particular point in the file.
\section{Facebook Thrift Services}
Thrift has been employed in a large number of applications at Facebook, including
The multi-language code generation is well suited for search because it allows for application
development in an efficient server side language (C++) and allows the Facebook PHP-based web application
to make calls to the search service using Thrift PHP libraries. There is also a large
-variety of search stats, deployment and testing functionality that is built on top
+variety of search stats, deployment and testing functionality that is built on top
of generated Python code. Additionally, the Thrift log file format is
-used as a redo log for providing real-time search index updates. Thrift has allowed the
-search team to leverage each language for its strengths and to develop code at a rapid pace.
+used as a redo log for providing real-time search index updates. Thrift has allowed the
+search team to leverage each language for its strengths and to develop code at a rapid pace.
\subsection{Logging}
The Thrift \texttt{TFileTransport} functionality is used for structured logging. Each
service function definition along with its parameters can be considered to be
-a structured log entry identified by the function name. This log can then be used for
+a structured log entry identified by the function name. This log can then be used for
a variety of purposes, including inline and offline processing, stats aggregation and as a redo log.
\section{Conclusions}
[protocol readFieldBeginReturningName: NULL
type: &fieldType
fieldID: &fieldID];
- if (fieldType == TType_STOP) {
+ if (fieldType == TType_STOP) {
break;
}
switch (fieldID) {
case 1:
if (fieldType == TType_STRING) {
reason = [protocol readString];
- } else {
+ } else {
[TProtocolUtil skipType: fieldType onProtocol: protocol];
}
break;
case 2:
if (fieldType == TType_I32) {
type = [protocol readI32];
- } else {
+ } else {
[TProtocolUtil skipType: fieldType onProtocol: protocol];
}
break;
if ([self userInfo] != nil) {
[result appendFormat: @"\n userInfo = %@", [self userInfo]];
}
-
+
return result;
}
- (id) initWithTransport: (id <TTransport>) transport;
-- (id) initWithTransport: (id <TTransport>) transport
+- (id) initWithTransport: (id <TTransport>) transport
strictRead: (BOOL) strictRead
strictWrite: (BOOL) strictWrite;
- (TBinaryProtocol *) newProtocolOnTransport: (id <TTransport>) transport;
-@end
\ No newline at end of file
+@end
static TBinaryProtocolFactory * gSharedFactory = nil;
-@implementation TBinaryProtocolFactory
+@implementation TBinaryProtocolFactory
+ (TBinaryProtocolFactory *) sharedFactory {
if (gSharedFactory == nil) {
gSharedFactory = [[TBinaryProtocolFactory alloc] init];
}
-
+
return gSharedFactory;
}
return [self initWithTransport: transport strictRead: NO strictWrite: NO];
}
-- (id) initWithTransport: (id <TTransport>) transport
+- (id) initWithTransport: (id <TTransport>) transport
strictRead: (BOOL) strictRead
strictWrite: (BOOL) strictWrite
{
@throw [TProtocolException exceptionWithName: @"TProtocolException"
reason: [NSString stringWithFormat: @"Message too big. Size limit is: %d Message size is: %d",
mMessageSizeLimit,
- size]];
+ size]];
}
NSString * messageName = [self readStringBody: size];
if (name != NULL) {
int ft = [self readByte];
if (fieldType != NULL) {
*fieldType = ft;
- }
+ }
if (ft != TType_STOP) {
int fid = [self readI16];
if (fieldID != NULL) {
int32_t size = [self readI32];
uint8_t * buff = malloc(size);
if (buff == NULL) {
- @throw [TProtocolException
+ @throw [TProtocolException
exceptionWithName: @"TProtocolException"
reason: [NSString stringWithFormat: @"Out of memory. Unable to allocate %d bytes trying to read binary data.",
size]];
}
-- (void) writeBinary: (NSData *) data
+- (void) writeBinary: (NSData *) data
{
[self writeI32: [data length]];
[mTransport write: [data bytes] offset: 0 length: [data length]];
NSSocketPort * mServerSocket;
NSFileHandle * mSocketFileHandle;
id <TProtocolFactory> mInputProtocolFactory;
- id <TProtocolFactory> mOutputProtocolFactory;
+ id <TProtocolFactory> mOutputProtocolFactory;
id <TProcessor> mProcessor;
}
mInputProtocolFactory = [protocolFactory retain];
mOutputProtocolFactory = [protocolFactory retain];
mProcessor = [processor retain];
-
+
// create a socket
mServerSocket = [[NSSocketPort alloc] initWithTCPPort: port];
// FIXME - move this separate start method and add method to close
// and cleanup any open ports
-
+
if (mServerSocket == nil) {
NSLog(@"Unable to listen on TCP port %d", port);
} else {
// wrap it in a file handle so we can get messages from it
mSocketFileHandle = [[NSFileHandle alloc] initWithFileDescriptor: [mServerSocket socket]
closeOnDealloc: YES];
-
+
// register for notifications of accepted incoming connections
- [[NSNotificationCenter defaultCenter] addObserver: self
- selector: @selector(connectionAccepted:)
+ [[NSNotificationCenter defaultCenter] addObserver: self
+ selector: @selector(connectionAccepted:)
name: NSFileHandleConnectionAcceptedNotification
object: mSocketFileHandle];
-
+
// tell socket to listen
[mSocketFileHandle acceptConnectionInBackgroundAndNotify];
}
-
+
return self;
}
- (void) connectionAccepted: (NSNotification *) aNotification
{
NSFileHandle * socket = [[aNotification userInfo] objectForKey: NSFileHandleNotificationFileHandleItem];
-
+
// now that we have a client connected, spin off a thread to handle activity
[NSThread detachNewThreadSelector: @selector(handleClientConnection:)
toTarget: self
withObject: socket];
-
+
[[aNotification object] acceptConnectionInBackgroundAndNotify];
}
id <TProtocol> inProtocol = [mInputProtocolFactory newProtocolOnTransport: transport];
id <TProtocol> outProtocol = [mOutputProtocolFactory newProtocolOnTransport: transport];
-
+
@try {
while ([mProcessor processOnInputProtocol: inProtocol outputProtocol: outProtocol]);
}
@catch (TTransportException * te) {
NSLog(@"%@", te);
}
-
+
[pool release];
}
- (id) initWithURL: (NSURL *) aURL;
-- (id) initWithURL: (NSURL *) aURL
+- (id) initWithURL: (NSURL *) aURL
userAgent: (NSString *) userAgent
timeout: (int) timeout;
if (mRequest != nil) {
[mRequest release];
}
-
+
// set up our request object that we'll use for each request
mRequest = [[NSMutableURLRequest alloc] initWithURL: mURL];
[mRequest setHTTPMethod: @"POST"];
}
-- (id) initWithURL: (NSURL *) aURL
+- (id) initWithURL: (NSURL *) aURL
userAgent: (NSString *) userAgent
timeout: (int) timeout
{
if (!self) {
return nil;
}
-
+
mTimeout = timeout;
if (userAgent) {
mUserAgent = [userAgent retain];
// create our request data buffer
mRequestData = [[NSMutableData alloc] initWithCapacity: 1024];
-
+
return self;
}
[aURL retain];
[mURL release];
mURL = aURL;
-
+
[self setupRequest];
}
// make the HTTP request
NSURLResponse * response;
NSError * error;
- NSData * responseData =
+ NSData * responseData =
[NSURLConnection sendSynchronousRequest: mRequest returningResponse: &response error: &error];
[mRequestData setLength: 0];
NSHTTPURLResponse * httpResponse = (NSHTTPURLResponse *) response;
if ([httpResponse statusCode] != 200) {
@throw [TTransportException exceptionWithName: @"TTransportException"
- reason: [NSString stringWithFormat: @"Bad response from HTTP server: %d",
+ reason: [NSString stringWithFormat: @"Bad response from HTTP server: %d",
[httpResponse statusCode]]];
}
-
+
// phew!
[mResponseData release];
mResponseData = [responseData retain];
outputFileHandle: (NSFileHandle *) outputFileHandle
{
self = [super init];
-
+
mInputFileHandle = [inputFileHandle retain];
mOutputFileHandle = [outputFileHandle retain];
-
+
return self;
}
- (void) write: (uint8_t *) data offset: (unsigned int) offset length: (unsigned int) length
{
- NSData * dataObject = [[NSData alloc] initWithBytesNoCopy: data+offset
+ NSData * dataObject = [[NSData alloc] initWithBytesNoCopy: data+offset
length: length
freeWhenDone: NO];
-
+
[mOutputFileHandle writeData: dataObject];
-
+
[dataObject release];
}
-
+
- (void) flush
{
} else if (result != length) {
@throw [TTransportException exceptionWithReason: @"Output stream did not write all of our data."];
}
-}
+}
- (void) flush
{
{
NSInputStream * input = nil;
NSOutputStream * output = nil;
-
+
[NSStream getStreamsToHost: [NSHost hostWithName: hostname]
port: port
- inputStream: &input
+ inputStream: &input
outputStream: &output];
self = [super initWithInputStream: input outputStream: output];
[input open];
[output open];
-
+
return self;
}
include_thrift_HEADERS = \
$(top_srcdir)/config.h \
src/Thrift.h \
- src/TReflectionLocal.h \
+ src/TReflectionLocal.h \
src/reflection_limited_types.h \
src/TProcessor.h \
src/TLogging.h
concurrency_test_LDFLAGS = $(common_ldflags)
EXTRA_DIST = \
- README \
- thrift-nb.pc.in \
- thrift.pc.in \
- thrift-z.pc.in
+ README \
+ thrift-nb.pc.in \
+ thrift.pc.in \
+ thrift-z.pc.in
/**
* T_GLOBAL_DEBUGGING_LEVEL = 0: all debugging turned off, debug macros undefined
- * T_GLOBAL_DEBUGGING_LEVEL = 1: all debugging turned on
+ * T_GLOBAL_DEBUGGING_LEVEL = 1: all debugging turned on
*/
#define T_GLOBAL_DEBUGGING_LEVEL 0
/**
* T_GLOBAL_LOGGING_LEVEL = 0: all logging turned off, logging macros undefined
- * T_GLOBAL_LOGGING_LEVEL = 1: all logging turned on
+ * T_GLOBAL_LOGGING_LEVEL = 1: all logging turned on
*/
#define T_GLOBAL_LOGGING_LEVEL 1
-/**
+/**
* Standard wrapper around fprintf what will prefix the file name and line
* number to the line. Uses T_GLOBAL_DEBUGGING_LEVEL to control whether it is
* turned on or off.
*
- * @param format_string
+ * @param format_string
*/
#if T_GLOBAL_DEBUGGING_LEVEL > 0
#define T_DEBUG(format_string,...) \
if (T_GLOBAL_DEBUGGING_LEVEL > 0) { \
fprintf(stderr,"[%s,%d] " #format_string " \n", __FILE__, __LINE__,##__VA_ARGS__); \
- }
+ }
#else
#define T_DEBUG(format_string,...)
#endif
-/**
- * analagous to T_DEBUG but also prints the time
+/**
+ * analagous to T_DEBUG but also prints the time
*
* @param string format_string input: printf style format string
*/
#endif
-/**
+/**
* analagous to T_DEBUG but uses input level to determine whether or not the string
* should be logged.
*
}
-/**
+/**
* Explicit error logging. Prints time, file name and line number
*
* @param string format_string input: printf style format string
}
-/**
+/**
* Analagous to T_ERROR, additionally aborting the process.
* WARNING: macro calls abort(), ending program execution
*
}
-/**
+/**
* Log input message
*
* @param string format_string input: printf style format string
dbgtime[24] = '\0'; \
fprintf(stderr,"[%s] " #format_string " \n", dbgtime,##__VA_ARGS__); \
} \
- }
+ }
#else
#define T_LOG_OPER(format_string,...)
#endif
#include <protocol/TProtocol.h>
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift {
+namespace facebook { namespace thrift {
/**
* A processor is a generic object that acts upon two streams of data, one
while (true) {
xfer += iprot->readFieldBegin(fname, ftype, fid);
- if (ftype == facebook::thrift::protocol::T_STOP) {
+ if (ftype == facebook::thrift::protocol::T_STOP) {
break;
}
switch (fid) {
type_(UNKNOWN) {}
TApplicationException(TApplicationExceptionType type) :
- TException(),
+ TException(),
type_(type) {}
TApplicationException(const std::string& message) :
class IllegalStateException : public facebook::thrift::TException {};
class TimedOutException : public facebook::thrift::TException {
-public:
+public:
TimedOutException():TException("TimedOutException"){};
- TimedOutException(const std::string& message ) :
+ TimedOutException(const std::string& message ) :
TException(message) {}
};
class TooManyPendingTasksException : public facebook::thrift::TException {
-public:
+public:
TooManyPendingTasksException():TException("TooManyPendingTasksException"){};
- TooManyPendingTasksException(const std::string& message ) :
+ TooManyPendingTasksException(const std::string& message ) :
TException(message) {}
};
using boost::shared_ptr;
-namespace facebook { namespace thrift { namespace concurrency {
+namespace facebook { namespace thrift { namespace concurrency {
-/**
+/**
* Implementation of Mutex class using POSIX mutex
*
* @author marc
void Mutex::unlock() const { impl_->unlock(); }
-/**
+/**
* Implementation of ReadWriteMutex class using POSIX rw lock
*
* @author boz
void release() const { pthread_rwlock_unlock(&rw_lock_); }
-private:
+private:
mutable pthread_rwlock_t rw_lock_;
mutable bool initialized_;
};
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift { namespace concurrency {
+namespace facebook { namespace thrift { namespace concurrency {
/**
* A simple mutex class
// this releases both read and write locks
virtual void release() const;
-
+
private:
class impl;
};
class Guard {
- public:
+ public:
Guard(const Mutex& value) : mutex_(value) {
mutex_.lock();
}
};
class RWGuard {
- public:
+ public:
RWGuard(const ReadWriteMutex& value, bool write = 0) : rw_mutex_(value) {
if (write) {
rw_mutex_.acquireWrite();
} else {
rw_mutex_.acquireRead();
}
- }
+ }
~RWGuard() {
rw_mutex_.release();
- }
- private:
+ }
+ private:
const ReadWriteMutex& rw_mutex_;
-};
+};
// A little hack to prevent someone from trying to do "Guard(m);"
#include <iostream>
#include <set>
-namespace facebook { namespace thrift { namespace concurrency {
+namespace facebook { namespace thrift { namespace concurrency {
using boost::shared_ptr;
Task(shared_ptr<Runnable> runnable) :
runnable_(runnable),
state_(WAITING) {}
-
+
~Task() {
}
-
+
void run() {
if (state_ == EXECUTING) {
runnable_->run();
class TimerManager::Dispatcher: public Runnable {
public:
- Dispatcher(TimerManager* manager) :
+ Dispatcher(TimerManager* manager) :
manager_(manager) {}
-
+
~Dispatcher() {}
-
+
/**
* Dispatcher entry point
*
Synchronized s(manager_->monitor_);
task_iterator expiredTaskEnd;
int64_t now = Util::currentTime();
- while (manager_->state_ == TimerManager::STARTED &&
+ while (manager_->state_ == TimerManager::STARTED &&
(expiredTaskEnd = manager_->taskMap_.upper_bound(now)) == manager_->taskMap_.begin()) {
int64_t timeout = 0LL;
if (!manager_->taskMap_.empty()) {
} catch (TimedOutException &e) {}
now = Util::currentTime();
}
-
+
if (manager_->state_ == TimerManager::STARTED) {
for (task_iterator ix = manager_->taskMap_.begin(); ix != expiredTaskEnd; ix++) {
shared_ptr<TimerManager::Task> task = ix->second;
manager_->taskMap_.erase(manager_->taskMap_.begin(), expiredTaskEnd);
}
}
-
+
for (std::set<shared_ptr<Task> >::iterator ix = expiredTasks.begin(); ix != expiredTasks.end(); ix++) {
(*ix)->run();
}
-
+
} while (manager_->state_ == TimerManager::STARTED);
{
Synchronized s(manager_->monitor_);
if (manager_->state_ == TimerManager::STOPPING) {
- manager_->state_ = TimerManager::STOPPED;
+ manager_->state_ = TimerManager::STOPPED;
manager_->monitor_.notify();
}
}
// If we haven't been explicitly stopped, do so now. We don't need to grab
// the monitor here, since stop already takes care of reentrancy.
-
+
if (state_ != STOPPED) {
try {
stop();
taskMap_.erase(ix);
}
- // Remove dispatcher's reference to us.
+ // Remove dispatcher's reference to us.
dispatcher_->manager_ = NULL;
}
}
shared_ptr<const ThreadFactory> TimerManager::threadFactory() const {
- Synchronized s(monitor_);
+ Synchronized s(monitor_);
return threadFactory_;
}
-
+
void TimerManager::threadFactory(shared_ptr<const ThreadFactory> value) {
- Synchronized s(monitor_);
+ Synchronized s(monitor_);
threadFactory_ = value;
}
size_t TimerManager::taskCount() const {
return taskCount_;
}
-
+
void TimerManager::add(shared_ptr<Runnable> task, int64_t timeout) {
int64_t now = Util::currentTime();
timeout += now;
{
- Synchronized s(monitor_);
+ Synchronized s(monitor_);
if (state_ != TimerManager::STARTED) {
throw IllegalStateException();
}
void TimerManager::remove(shared_ptr<Runnable> task) {
- Synchronized s(monitor_);
+ Synchronized s(monitor_);
if (state_ != TimerManager::STARTED) {
throw IllegalStateException();
}
#include <map>
#include <time.h>
-namespace facebook { namespace thrift { namespace concurrency {
+namespace facebook { namespace thrift { namespace concurrency {
/**
- * Timer Manager
- *
+ * Timer Manager
+ *
* This class dispatches timer tasks when they fall due.
- *
+ *
* @author marc
* @version $Id:$
*/
virtual void threadFactory(boost::shared_ptr<const ThreadFactory> value);
/**
- * Starts the timer manager service
+ * Starts the timer manager service
*
* @throws IllegalArgumentException Missing thread factory attribute
*/
/**
* Adds a task to be executed at some time in the future by a worker thread.
- *
+ *
* @param task The task to execute
* @param timeout Time in milliseconds to delay before executing task
*/
/**
* Adds a task to be executed at some time in the future by a worker thread.
- *
+ *
* @param task The task to execute
* @param timeout Absolute time in the future to execute task.
- */
+ */
virtual void add(boost::shared_ptr<Runnable> task, const struct timespec& timeout);
/**
- * Removes a pending task
+ * Removes a pending task
*
* @throws NoSuchTaskException Specified task doesn't exist. It was either
* processed already or this call was made for a
STOPPING,
STOPPED
};
-
+
virtual const STATE state() const;
private:
#include <sys/time.h>
#endif // defined(HAVE_CLOCK_GETTIME)
-namespace facebook { namespace thrift { namespace concurrency {
+namespace facebook { namespace thrift { namespace concurrency {
/**
* Utility methods
* and other common platform-dependent concurrency operations.
* It should not be included in API headers for other concurrency library
* headers, since it will, by definition, pull in all sorts of horrid
- * platform dependent crap. Rather it should be inluded directly in
+ * platform dependent crap. Rather it should be inluded directly in
* concurrency library implementation source.
*
* @author marc
* @param time or duration in milliseconds
*/
static void toTimespec(struct timespec& result, int64_t value) {
- result.tv_sec = value / MS_PER_S; // ms to s
+ result.tv_sec = value / MS_PER_S; // ms to s
result.tv_nsec = (value % MS_PER_S) * NS_PER_MS; // ms to ns
}
using namespace facebook::thrift::concurrency;
/**
- * ThreadManagerTests class
+ * ThreadManagerTests class
*
* @author marc
* @version $Id:$
class Task: public Runnable {
public:
-
- Task(Monitor& monitor, int64_t timeout) :
+
+ Task(Monitor& monitor, int64_t timeout) :
_timeout(timeout),
_startTime(Util::currentTime()),
_monitor(monitor),
if(error < ERROR) {
_success = true;
}
-
+
_done = true;
- std::cout << "\t\t\tTimerManagerTests::Task[" << this << "] done" << std::endl; //debug
+ std::cout << "\t\t\tTimerManagerTests::Task[" << this << "] done" << std::endl; //debug
{Synchronized s(_monitor);
_monitor.notifyAll();
}
- }
+ }
int64_t _timeout;
int64_t _startTime;
{
TimerManager timerManager;
-
+
timerManager.threadFactory(shared_ptr<PosixThreadFactory>(new PosixThreadFactory()));
-
+
timerManager.start();
-
+
assert(timerManager.state() == TimerManager::STARTED);
shared_ptr<TimerManagerTests::Task> task = shared_ptr<TimerManagerTests::Task>(new TimerManagerTests::Task(_monitor, timeout));
};
const double TimerManagerTests::ERROR = .20;
-
+
}}}} // facebook::thrift::concurrency
using namespace facebook::thrift::protocol;
using namespace facebook::thrift;
-namespace facebook { namespace thrift { namespace processor {
+namespace facebook { namespace thrift { namespace processor {
PeekProcessor::PeekProcessor() {
memoryBuffer_.reset(new TMemoryBuffer());
}
}
-bool PeekProcessor::process(boost::shared_ptr<TProtocol> in,
+bool PeekProcessor::process(boost::shared_ptr<TProtocol> in,
boost::shared_ptr<TProtocol> out) {
std::string fname;
uint32_t size;
memoryBuffer_->getBuffer(&buffer, &size);
peekBuffer(buffer, size);
-
+
// Done peeking at variables
peekEnd();
void PeekProcessor::peekBuffer(uint8_t* buffer, uint32_t size) {
}
-void PeekProcessor::peek(boost::shared_ptr<TProtocol> in,
+void PeekProcessor::peek(boost::shared_ptr<TProtocol> in,
TType ftype,
int16_t fid) {
in->skip(ftype);
#include <transport/TTransportUtils.h>
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift { namespace processor {
+namespace facebook { namespace thrift { namespace processor {
/*
* Class for peeking at the raw data that is being processed by another processor
* @author James Wang <jwang@facebook.com>
*/
class PeekProcessor : public facebook::thrift::TProcessor {
-
+
public:
PeekProcessor();
virtual ~PeekProcessor();
void setTargetTransport(boost::shared_ptr<facebook::thrift::transport::TTransport> targetTransport);
- virtual bool process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> in,
+ virtual bool process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> in,
boost::shared_ptr<facebook::thrift::protocol::TProtocol> out);
// The following three functions can be overloaded by child classes to
// achieve desired peeking behavior
virtual void peekName(const std::string& fname);
virtual void peekBuffer(uint8_t* buffer, uint32_t size);
- virtual void peek(boost::shared_ptr<facebook::thrift::protocol::TProtocol> in,
+ virtual void peek(boost::shared_ptr<facebook::thrift::protocol::TProtocol> in,
facebook::thrift::protocol::TType ftype,
int16_t fid);
virtual void peekEnd();
#include <protocol/TProtocol.h>
#include <TProcessor.h>
-namespace facebook { namespace thrift { namespace processor {
+namespace facebook { namespace thrift { namespace processor {
/*
* Class for keeping track of function call statistics and printing them if desired
*/
class StatsProcessor : public facebook::thrift::TProcessor {
public:
- StatsProcessor(bool print, bool frequency)
+ StatsProcessor(bool print, bool frequency)
: print_(print),
frequency_(frequency)
{}
break;
case facebook::thrift::protocol::T_DOUBLE:
{
- double dub;
+ double dub;
piprot_->readDouble(dub);
if (print_) {
printf("%f", dub);
}
}
break;
- case facebook::thrift::protocol::T_STRING:
+ case facebook::thrift::protocol::T_STRING:
{
std::string str;
piprot_->readString(str);
}
}
break;
- case facebook::thrift::protocol::T_STRUCT:
+ case facebook::thrift::protocol::T_STRUCT:
{
std::string name;
int16_t fid;
//return *reinterpret_cast<To*>(&from); // BAD!!!
//return *static_cast<To*>(static_cast<void*>(&from)); // BAD!!!
//return *(To*)(void*)&from; // BAD!!!
-
+
// Super clean and paritally blessed by section 3.9 of the standard.
//unsigned char c[sizeof(from)];
//memcpy(c, &from, sizeof(from));
}
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
uint32_t TBinaryProtocol::writeMessageBegin(const std::string& name,
const TMessageType messageType,
uint32_t TBinaryProtocol::writeFieldStop() {
return
writeByte((int8_t)T_STOP);
-}
-
+}
+
uint32_t TBinaryProtocol::writeMapBegin(const TType keyType,
const TType valType,
const uint32_t size) {
trans_->write((uint8_t*)&net, 8);
return 8;
}
-
+
uint32_t TBinaryProtocol::writeDouble(const double dub) {
BOOST_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t));
BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559);
return 8;
}
-
+
uint32_t TBinaryProtocol::writeString(const string& str) {
uint32_t size = str.size();
uint32_t result = writeI32((int32_t)size);
result += readI16(fieldId);
return result;
}
-
+
uint32_t TBinaryProtocol::readFieldEnd() {
return 0;
}
-
+
uint32_t TBinaryProtocol::readMapBegin(TType& keyType,
TType& valType,
uint32_t& size) {
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
/**
* The default binary protocol for thrift. Writes all data in a very basic
uint32_t writeFieldEnd();
uint32_t writeFieldStop();
-
+
uint32_t writeMapBegin(const TType keyType,
const TType valType,
const uint32_t size);
uint32_t readFieldBegin(std::string& name,
TType& fieldType,
int16_t& fieldId);
-
+
uint32_t readFieldEnd();
-
+
uint32_t readMapBegin(TType& keyType,
TType& valType,
uint32_t& size);
uint32_t readListBegin(TType& elemType,
uint32_t& size);
-
+
uint32_t readListEnd();
uint32_t readSetBegin(TType& elemType,
}
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
string TDebugProtocol::fieldTypeName(TType type) {
switch (type) {
return writeIndented(
id_str + ": " +
- name + " (" +
+ name + " (" +
fieldTypeName(fieldType) + ") = ");
}
uint32_t TDebugProtocol::writeFieldStop() {
return 0;
//writeIndented("***STOP***\n");
-}
-
+}
+
uint32_t TDebugProtocol::writeMapBegin(const TType keyType,
const TType valType,
const uint32_t size) {
uint32_t TDebugProtocol::writeI64(const int64_t i64) {
return writeItem(boost::lexical_cast<string>(i64));
}
-
+
uint32_t TDebugProtocol::writeDouble(const double dub) {
return writeItem(boost::lexical_cast<string>(dub));
}
-
+
uint32_t TDebugProtocol::writeString(const string& str) {
// XXX Raw/UTF-8?
#include <transport/TTransportUtils.h>
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
/*
uint32_t writeFieldEnd();
uint32_t writeFieldStop();
-
+
uint32_t writeMapBegin(const TType keyType,
const TType valType,
const uint32_t size);
}}} // facebook::thrift::protocol
-namespace facebook { namespace thrift {
+namespace facebook { namespace thrift {
template<typename ThriftStruct>
std::string ThriftDebugString(const ThriftStruct& ts) {
* The dense protocol is designed to use as little space as possible.
*
* There are two types of dense protocol instances. Standalone instances
- * are not used for RPC and just encoded and decode structures of
+ * are not used for RPC and just encoded and decode structures of
* a predetermined type. Non-standalone instances are used for RPC.
* Currently, only standalone instances exist.
*
#include "TProtocol.h"
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
/**
* Abstract class for implementing a protocol that can only be written,
throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
subclass_ + " does not support reading (yet).");
}
-
+
uint32_t readFieldEnd() {
throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
subclass_ + " does not support reading (yet).");
}
-
+
uint32_t readMapBegin(TType& keyType,
TType& valType,
uint32_t& size) {
throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
subclass_ + " does not support reading (yet).");
}
-
+
uint32_t readListEnd() {
throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
subclass_ + " does not support reading (yet).");
#include <string>
#include <map>
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
using facebook::thrift::transport::TTransport;
virtual uint32_t writeStructBegin(const std::string& name) = 0;
-
+
virtual uint32_t writeStructEnd() = 0;
-
+
virtual uint32_t writeFieldBegin(const std::string& name,
const TType fieldType,
const int16_t fieldId) = 0;
virtual uint32_t writeFieldEnd() = 0;
virtual uint32_t writeFieldStop() = 0;
-
+
virtual uint32_t writeMapBegin(const TType keyType,
const TType valType,
const uint32_t size) = 0;
virtual uint32_t writeMapEnd() = 0;
-
+
virtual uint32_t writeListBegin(const TType elemType,
const uint32_t size) = 0;
virtual uint32_t readMessageBegin(std::string& name,
TMessageType& messageType,
int32_t& seqid) = 0;
-
+
virtual uint32_t readMessageEnd() = 0;
virtual uint32_t readStructBegin(std::string& name) = 0;
virtual uint32_t readFieldBegin(std::string& name,
TType& fieldType,
int16_t& fieldId) = 0;
-
+
virtual uint32_t readFieldEnd() = 0;
-
+
virtual uint32_t readMapBegin(TType& keyType,
TType& valType,
uint32_t& size) = 0;
ptrans_(ptrans) {
trans_ = ptrans.get();
}
-
+
boost::shared_ptr<TTransport> ptrans_;
TTransport* trans_;
#include <boost/lexical_cast.hpp>
#include <string>
-namespace facebook { namespace thrift { namespace protocol {
+namespace facebook { namespace thrift { namespace protocol {
/**
* Class to encapsulate all the possible types of protocol errors that may
type_(UNKNOWN) {}
TProtocolException(TProtocolExceptionType type) :
- facebook::thrift::TException(),
+ facebook::thrift::TException(),
type_(type) {}
TProtocolException(const std::string& message) :
}
protected:
- /**
+ /**
* Error code
*/
TProtocolExceptionType type_;
-
+
};
}}} // facebook::thrift::protocol
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
using facebook::thrift::TProcessor;
using facebook::thrift::protocol::TProtocolFactory;
// last successful dispatch point
int32_t lastDispatchPtr_;
-
+
void resetState(uint32_t lastDispatchPtr) {
readingSize_ = true;
eventSizeBuffPos_ = 0;
}
} readState;
-
+
/**
* TFileTransportBuffer - buffer class used by TFileTransport for queueing up events
* to be written to disk. Should be used in the following way:
* 5) Go back to 2, or destroy buffer
*
* The buffer should never be written to after it is read from, unless it is reset first.
- * Note: The above rules are enforced mainly for debugging its sole client TFileTransport
+ * Note: The above rules are enforced mainly for debugging its sole client TFileTransport
* which uses the buffer in this way.
- *
+ *
* @author James Wang <jwang@facebook.com>
*/
class TFileTransportBuffer {
void reset();
bool isFull();
bool isEmpty();
-
+
private:
TFileTransportBuffer(); // should not be used
};
/**
- * File implementation of a transport. Reads and writes are done to a
+ * File implementation of a transport. Reads and writes are done to a
* file on disk.
*
* @author Aditya Agarwal <aditya@facebook.com>
bool isOpen() {
return true;
}
-
+
void write(const uint8_t* buf, uint32_t len);
void flush();
return chunkSize_;
}
- void setEventBufferSize(uint32_t bufferSize) {
+ void setEventBufferSize(uint32_t bufferSize) {
if (bufferAndThreadInitialized_) {
GlobalOutput("Cannot change the buffer size after writer thread started");
return;
// max number of corrupted events per chunk
uint32_t maxCorruptedEvents_;
static const uint32_t DEFAULT_MAX_CORRUPTED_EVENTS = 0;
-
+
// sleep duration when EOF is hit
uint32_t eofSleepTime_;
static const uint32_t DEFAULT_EOF_SLEEP_TIME_US = 500 * 1000;
// sleep duration when a corrupted event is encountered
uint32_t corruptedEventSleepTime_;
static const uint32_t DEFAULT_CORRUPTED_SLEEP_TIME_US = 1 * 1000 * 1000;
-
+
// writer thread id
pthread_t writerThreadId_;
- // buffers to hold data before it is flushed. Each element of the buffer stores a msg that
+ // buffers to hold data before it is flushed. Each element of the buffer stores a msg that
// needs to be written to the file. The buffers are swapped by the writer thread.
TFileTransportBuffer *dequeueBuffer_;
TFileTransportBuffer *enqueueBuffer_;
-
+
// conditions used to block when the buffer is full or empty
pthread_cond_t notFull_, notEmpty_;
volatile bool closing_;
// wrapper class to process events from a file containing thrift events
class TFileProcessor {
public:
- /**
+ /**
* Constructor that defaults output transport to null transport
- *
+ *
* @param processor processes log-file events
* @param protocolFactory protocol factory
* @param inputTransport file transport
boost::shared_ptr<TProtocolFactory> outputProtocolFactory,
boost::shared_ptr<TFileReaderTransport> inputTransport);
- /**
+ /**
* Constructor
- *
+ *
* @param processor processes log-file events
* @param protocolFactory protocol factory
* @param inputTransport input file transport
* @param output output transport
- */
+ */
TFileProcessor(boost::shared_ptr<TProcessor> processor,
boost::shared_ptr<TProtocolFactory> protocolFactory,
boost::shared_ptr<TFileReaderTransport> inputTransport,
*
*/
void processChunk();
-
+
private:
boost::shared_ptr<TProcessor> processor_;
boost::shared_ptr<TProtocolFactory> inputProtocolFactory_;
boost::shared_ptr<TTransport> outputTransport_;
};
-
+
}}} // facebook::thrift::transport
#endif // _THRIFT_TRANSPORT_TFILETRANSPORT_H_
#include "THttpClient.h"
#include "TSocket.h"
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
using namespace std;
httpPos_ = 0;
httpBufLen_ = 0;
refill();
-
+
// Now have available however much we read
avail = httpBufLen_;
}
}
return size;
}
-
+
char* THttpClient::readLine() {
while (true) {
char* eol = NULL;
throw TTransportException("Out of memory.");
}
}
-
+
// Read more data
uint32_t got = transport_->read((uint8_t*)(httpBuf_+httpBufLen_), httpBufSize_-httpBufLen_);
httpBufLen_ += got;
httpBuf_[httpBufLen_] = '\0';
-
+
if (got == 0) {
throw TTransportException("Could not refill buffer");
}
parseHeader(line);
}
}
- }
+ }
}
bool THttpClient::parseStatusLine(char* status) {
if (code == NULL) {
throw TTransportException(string("Bad Status: ") + status);
}
-
+
*code = '\0';
while (*(code++) == ' ');
#include <transport/TTransportUtils.h>
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
/**
* HTTP client implementation of the thrift transport. This was irritating
bool isOpen() {
return transport_->isOpen();
}
-
- bool peek() {
+
+ bool peek() {
return transport_->peek();
}
void readEnd();
void write(const uint8_t* buf, uint32_t len);
-
+
void flush();
private:
#include "TServerTransport.h"
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
class TSocket;
#include "TTransportException.h"
#include <boost/shared_ptr.hpp>
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
/**
* Server transport framework. A server needs to have some facility for
#include "TSocketPool.h"
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
using namespace std;
#include <vector>
#include "TSocket.h"
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
/**
* TCP Socket implementation of the TTransport interface.
#include <transport/TTransportException.h>
#include <string>
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
/**
* Generic interface for a method of transporting data. A TTransport may be
virtual uint32_t readAll(uint8_t* buf, uint32_t len) {
uint32_t have = 0;
uint32_t get = 0;
-
+
while (have < len) {
get = read(buf+have, len-have);
if (get <= 0) {
}
have += get;
}
-
+
return have;
}
/**
- * Called when read is completed.
+ * Called when read is completed.
* This can be over-ridden to perform a transport-specific action
* e.g. logging the request to a file
*
}
/**
- * Called when write is completed.
+ * Called when write is completed.
* This can be over-ridden to perform a transport-specific action
* at the end of a request.
*
using std::string;
using boost::lexical_cast;
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
string TTransportException::strerror_s(int errno_copy) {
#ifndef HAVE_STRERROR_R
#include <string>
#include <Thrift.h>
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
/**
* Class to encapsulate all the possible types of transport errors that may
CORRUPTED_DATA = 7,
INTERNAL_ERROR = 8,
};
-
+
TTransportException() :
facebook::thrift::TException(),
type_(UNKNOWN) {}
TTransportException(TTransportExceptionType type) :
- facebook::thrift::TException(),
+ facebook::thrift::TException(),
type_(type) {}
TTransportException(const std::string& message) :
return message_.c_str();
}
}
-
+
protected:
/** Just like strerror_r but returns a C++ string object. */
std::string strerror_s(int errno_copy);
using std::string;
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
uint32_t TBufferedTransport::read(uint8_t* buf, uint32_t len) {
uint32_t need = len;
memcpy(buf, rBuf_+rPos_, rLen_-rPos_);
need -= rLen_-rPos_;
buf += rLen_-rPos_;
- }
+ }
// Get more from underlying transport up to buffer size
rLen_ = transport_->read(rBuf_, rBufSize_);
rPos_ = 0;
}
-
+
// Hand over whatever we have
uint32_t give = need;
if (rLen_-rPos_ < give) {
// Read another chunk
readFrame();
}
-
+
// Hand over whatever we have
uint32_t give = need;
if (rLen_-rPos_ < give) {
// Copy the old buffer to the new one
memcpy(wBuf2, wBuf_, wLen_);
-
+
// Now point buf to the new one
delete [] wBuf_;
wBuf_ = wBuf2;
sz = (int32_t)htonl(sz);
transport_->write((const uint8_t*)&sz, 4);
-
+
// Write frame body
if (wLen_ > 0) {
transport_->write(wBuf_, wLen_);
// Copy into buffer and increment rPos_
memcpy(buf, buffer_ + rPos_, give);
rPos_ += give;
-
+
return give;
}
str.reserve(str.length()+give);
str.append((char*)buffer_ + rPos_, give);
rPos_ += give;
-
+
return give;
}
uint32_t TPipedTransport::read(uint8_t* buf, uint32_t len) {
uint32_t need = len;
-
+
// We don't have enough data yet
if (rLen_-rPos_ < need) {
// Copy out whatever we have
rBufSize_ *=2;
rBuf_ = (uint8_t *)realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
}
-
+
// try to fill up the buffer
rLen_ += srcTrans_->read(rBuf_+rPos_, rBufSize_ - rPos_);
}
srcTrans_->flush();
}
-TPipedFileReaderTransport::TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans)
+TPipedFileReaderTransport::TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans)
: TPipedTransport(srcTrans, dstTrans),
srcTrans_(srcTrans) {
}
uint32_t TPipedFileReaderTransport::readAll(uint8_t* buf, uint32_t len) {
uint32_t have = 0;
uint32_t get = 0;
-
+
while (have < len) {
get = read(buf+have, len-have);
if (get <= 0) {
}
have += get;
}
-
+
return have;
}
using std::string;
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
// Don't call this outside of the constructor.
void TZlibTransport::initZlib() {
struct z_stream_s;
-namespace facebook { namespace thrift { namespace transport {
+namespace facebook { namespace thrift { namespace transport {
class TZlibTransportException : public TTransportException {
public:
~TZlibTransport();
bool isOpen();
-
+
void open() {
transport_->open();
}
}
uint32_t read(uint8_t* buf, uint32_t len);
-
+
void write(const uint8_t* buf, uint32_t len);
void flush();
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
-// General Information about an assembly is controlled through the following
+// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ThriftMSBuildTask")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components. If you need to access a type in this assembly from
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// Version information for an assembly consists of the following four values:
//
// Major Version
-// Minor Version
+// Minor Version
// Build Number
// Revision
//
-// You can specify all the values or you can default the Build and Revision Numbers
+// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
- <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+ <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
-</Project>
\ No newline at end of file
+</Project>
// TBinaryProtocol.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
// Will Palmeri <will@imeem.com>
//
// TField.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TList.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TMap.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TMessage.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TMessageType.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TProtocol.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TProtocolFactory.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Distributed under the Thrift Software License
// TProtocolUtil.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TSet.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TStruct.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TType.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TServer.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Distributed under the Thrift Software License
// TSimpleServer.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Distributed under the Thrift Software License
// TThreadPoolServer.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Distributed under the Thrift Software License
outputTransport = outputTransportFactory.GetTransport(client);
inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
- while (processor.Process(inputProtocol, outputProtocol))
+ while (processor.Process(inputProtocol, outputProtocol))
{
//keep processing requests until client disconnects
}
// TApplicationException.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TProcessor.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Distributed under the Thrift Software License
// TServerTransport.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
// TServerTransport.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
// TSocket.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
// TStreamTransport.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
// TTransport.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
// TTransportException.cs
//
// Begin: Aug 19, 2007
-// Authors:
+// Authors:
// Todd Berman <tberman@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
// TTransportFactory.cs
//
// Begin: Dec 3, 2007
-// Authors:
+// Authors:
// Will Palmeri <wpalmeri@imeem.com>
//
// Copyright (C) 2007 imeem, inc. <http://www.imeem.com>
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
#
# 5> code:which(acca_inets).
# "/home/martin/work/otp/releases/<app>/../../acca/ebin/<app>.beam"
-#
+#
# 8> beam_lib:version(code:which(<app>)).
# {ok,{<app>,['$Id: beamver,v 1.1.1.1 2003/06/13 21:43:21 mlogan Exp $ ']}}
# ERL_TOP is root of Erlang source tree
# ERL_RUN_TOP is root of Erlang target tree (some Ericsson Makefiles use $ROOT)
-# ERLANG_OTP is target root for Erlang code
+# ERLANG_OTP is target root for Erlang code
# - see sasl/systools reference manual page; grep "TEST"
-# OS_TYPE is FreeBSD, NetBSD, OpenBSD, Linux, SCO_SV, SunOS.
+# OS_TYPE is FreeBSD, NetBSD, OpenBSD, Linux, SCO_SV, SunOS.
OS_TYPE=${shell uname}
# MHOST is the host where this Makefile runs.
# Edit to reflect local environment.
# ifeq (${OS_TYPE},Linux)
# ERL_RUN_TOP=/usr/local/lib/erlang
-# Note* ERL_RUN_TOP can be determined by starting an
+# Note* ERL_RUN_TOP can be determined by starting an
# erlang shell and typing code:root_dir().
# ERL_TOP=a symbolic link to the actual source top, which changes from version to version
-# Note* ERL_TOP is the directory where the erlang
-# source files reside. Make sure to run ./configure there.
+# Note* ERL_TOP is the directory where the erlang
+# source files reside. Make sure to run ./configure there.
# TARGET=i686-pc-linux-gnu
# Note* Target can be found in $ERL_TOP/erts
# endif
LD=/usr/ccs/bin/ld
RANLIB=/usr/ccs/bin/ranlib
-CFLAGS+=-Wall -pedantic -ansi -O
+CFLAGS+=-Wall -pedantic -ansi -O
CORE=*.core
endif
# compliance with the License. You should have received a copy of the
# Erlang Public License along with this software. If not, it can be
# retrieved via the world wide web at http://www.erlang.org/.
-#
+#
# Software distributed under the License is distributed on an "AS IS"
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
# the License for the specific language governing rights and limitations
# under the License.
-#
+#
# The Initial Developer of the Original Code is Ericsson Utvecklings AB.
# Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
# AB. All Rights Reserved.''
-#
+#
# $Id: otp_subdir.mk,v 1.5 2004/07/12 15:12:23 jeinhorn Exp $
#
#
# for testing erlang files directly. The set up for a
-# this type of test would be
-# files to test reside in lib/<app_name>/src and the test files which are
+# this type of test would be
+# files to test reside in lib/<app_name>/src and the test files which are
# just plain erlang code reside in lib/<app_name>/test
#
# This color codes emitted while the tests run assume that you are using
echo $${MY_LRED:-$(LRED)}"$$d Test Failed"; \
fi; \
echo -n $(OFF)$(NO_COLOR); \
- done
+ done
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
# ----------------------------------------------------
ERL_FLAGS +=
-ERL_COMPILE_FLAGS += -I../include -I../../fslib/include -I../../system_status/include
+ERL_COMPILE_FLAGS += -I../include -I../../fslib/include -I../../system_status/include
# ----------------------------------------------------
# Targets
# ----------------------------------------------------
-all debug opt: $(EBIN) $(TARGET_FILES)
+all debug opt: $(EBIN) $(TARGET_FILES)
#$(EBIN)/rm_logger.beam: $(APP_NAME).hrl
include ../build/docs.mk
-e 's;%PFX%;$(PFX);' \
-e 's;%APP_NAME%;$(APP_NAME);' \
-e 's;%MODULES%;%MODULES%$(MODULES_STRING_LIST);' \
- $< > $<".tmp"
+ $< > $<".tmp"
sed -e 's/%MODULES%\(.*\),/\1/' \
- $<".tmp" > $@
+ $<".tmp" > $@
rm $<".tmp"
$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk
sed -e 's;%VSN%;$(VSN);' $< > $@
-$(WEB_TARGET): ../markup/*
- rm -rf $(WEB_TARGET)
- mkdir $(WEB_TARGET)
+$(WEB_TARGET): ../markup/*
+ rm -rf $(WEB_TARGET)
+ mkdir $(WEB_TARGET)
cp -r ../markup/ $(WEB_TARGET)
cp -r ../skins/ $(WEB_TARGET)
# ----------------------------------------------------
# Install Target
-# ----------------------------------------------------
+# ----------------------------------------------------
install: all $(WEB_TARGET)
# $(INSTALL_DIR) $(INSTALL_DST)/src
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%%
?DEFINE_ATTR(super).
-
+
%%%
%%% behavior callbacks
%%%
-
+
%%% super() -> SuperModule = atom()
%%% | none
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%%
%%% behavior callbacks
%%%
-
+
%%% super() -> SuperModule = atom()
%%% | none
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
?DEFINE_ATTR(serverTransport);
?DEFINE_ATTR(transportFactory);
?DEFINE_ATTR(protocolFactory).
-
+
%%%
%%% behavior callbacks
%%%
-
+
%%% super() -> SuperModule = atom()
%%% | none
%% much ado about nothing but
%% subclasses pass nil too
- transportFactory =
+ transportFactory =
case TransportFactory of
nil -> tTransportFactory:new();
_ -> TransportFactory
end,
-
- protocolFactory =
+
+ protocolFactory =
case ProtocolFactory of
nil -> tBinaryProtocolFactory:new();
_ -> ProtocolFactory
- end
+ end
}.
new(Handler, Processor, ServerTransport) ->
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%%
?DEFINE_ATTR(super).
-
+
%%%
%%% behavior callbacks
%%%
-
+
%%% super() -> SuperModule = atom()
%%% | none
?R0(Trans, effectful_close),
serve_loop(This).
-
+
serve_loop_loop(This, Prot) ->
- Next =
+ Next =
try
Handler = oop:get(This, handler),
Processor = oop:get(This, processor),
Val = apply(Processor, process, [Handler, Prot, Prot]), %% TODO(cpiro): make processor a gen_server instance
error_logger:info_msg("request processed: rv=~p", [Val]),
loop
- catch
+ catch
%% TODO(cpiro) case when is_record(...) to pick out our exception
%% records vs. normal erlang throws
E when is_record(E, tTransportException) ->
error_logger:info_msg("EXCEPTION: ~p", [F]),
close
end,
- case Next of
+ case Next of
loop -> serve_loop_loop(This, Prot);
close -> ok
end.
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%%
%%% behavior callbacks
%%%
-
+
%%% super() -> SuperModule = atom()
%%% | none
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
%%% behavior definition
%%%
-start(_Type, _StartArgs) ->
+start(_Type, _StartArgs) ->
io:format("starting thrift~n"),
thrift_logger:install(),
{ok, Sup} = thrift_app_sup:start_link(),
%%% Copyright (c) 2007- Facebook
%%% Distributed under the Thrift Software License
-%%%
+%%%
%%% See accompanying file LICENSE or visit the Thrift site at:
%%% http://developers.facebook.com/thrift/
version_mask = 0xffff0000
version_1 = 0x80010000;
-
+
getByte i b= 255 .&. (shiftR i (8*b))
getBytes i 0 = []
getBytes i n = (toEnum (getByte i (n-1)) :: Char):(getBytes i (n-1))
-
+
floatBits :: Double -> Word64
floatBits (D# d#) = W64# (unsafeCoerce# d#)
twrite tr s
writeBinary = writeString
writeMessageBegin (TBinaryProtocol tr) (n,t,s) = do writeI32 (TBinaryProtocol tr) (version_1 .|. (fromEnum t))
- writeString (TBinaryProtocol tr) n
+ writeString (TBinaryProtocol tr) n
writeI32 (TBinaryProtocol tr) s
writeMessageEnd (TBinaryProtocol tr) = return ()
writeStructBegin (TBinaryProtocol tr) s = return ()
if (ver .&. version_mask /= version_1) then
throwDyn (ProtocolExn PE_BAD_VERSION "Missing version identifier")
else do
- s <- readString (TBinaryProtocol tr)
+ s <- readString (TBinaryProtocol tr)
sz <- readI32 (TBinaryProtocol tr)
return (s,toEnum (ver .&. 0xFF) :: Message_type,fromIntegral sz :: Int)
readMessageEnd (TBinaryProtocol tr) = return ()
readSetEnd = readListEnd
pflush (TBinaryProtocol tr) = tflush tr
-
+
topen a = return a
tclose a = return a
tread a 0 = return []
- tread (TChannelTrans h) i = Prelude.catch
+ tread (TChannelTrans h) i = Prelude.catch
(do c <- hGetChar h
t <- tread (TChannelTrans h) (i-1)
return $ c:t)
if v then proc_loop hand proc ps
else return ()
-accept_loop accepter hand sock proc transgen iprotgen oprotgen =
+accept_loop accepter hand sock proc transgen iprotgen oprotgen =
do (h,hn,_) <- accepter sock
- let t = transgen h
+ let t = transgen h
let ip = iprotgen t
let op = oprotgen t
forkIO (handle (\e -> return ()) (proc_loop hand proc (ip,op)))
accept_loop accepter hand sock proc transgen iprotgen oprotgen
-
-run_threaded_server accepter listener hand proc port transgen iprotgen oprotgen =
+
+run_threaded_server accepter listener hand proc port transgen iprotgen oprotgen =
do sock <- listener
accept_loop accepter hand sock proc transgen iprotgen oprotgen
return ()
-
+
-- A basic threaded binary protocol socket server.
run_basic_server hand proc port = run_threaded_server accept (listenOn (PortNumber port)) hand proc port TChannelTrans TBinaryProtocol TBinaryProtocol
Just _ -> True
Nothing -> False
topen a = do h <- connectTo (host a) (PortNumber (port a))
- return $ (a{chan = Just h})
- tclose a = case chan a of
+ return $ (a{chan = Just h})
+ tclose a = case chan a of
Just h -> do hClose h
return $ a{chan=Nothing}
Nothing -> return a
tread a 0 = return []
- tread a n = case chan a of
+ tread a n = case chan a of
Just h -> handle (\e -> throwDyn (TransportExn "TSocket: Could not read." TE_UNKNOWN))
- (do c <- hGetChar h
+ (do c <- hGetChar h
l <- tread a (n-1)
return $ c:l)
Nothing -> return []
return ret
else do r <- treadAll a (len-rl)
return (ret++r)
-
-
- data T_type = T_STOP
- | T_VOID
+
+
+ data T_type = T_STOP
+ | T_VOID
| T_BOOL
| T_BYTE
- | T_I08
- | T_I16
- | T_I32
- | T_U64
- | T_I64
- | T_DOUBLE
- | T_STRING
- | T_UTF7
- | T_STRUCT
- | T_MAP
- | T_SET
- | T_LIST
- | T_UTF8
+ | T_I08
+ | T_I16
+ | T_I32
+ | T_U64
+ | T_I64
+ | T_DOUBLE
+ | T_STRING
+ | T_UTF7
+ | T_STRUCT
+ | T_MAP
+ | T_SET
+ | T_LIST
+ | T_UTF8
| T_UTF16
| T_UNKNOWN
deriving (Eq)
T_LIST -> 15
T_UTF8 -> 16
T_UTF16 -> 17
- T_UNKNOWN -> -1
- toEnum t = case t of
- 0 -> T_STOP
- 1 -> T_VOID
+ T_UNKNOWN -> -1
+ toEnum t = case t of
+ 0 -> T_STOP
+ 1 -> T_VOID
2 -> T_BOOL
3 -> T_BYTE
- 6-> T_I16
- 8 -> T_I32
- 9 -> T_U64
- 10 -> T_I64
- 4 -> T_DOUBLE
+ 6-> T_I16
+ 8 -> T_I32
+ 9 -> T_U64
+ 10 -> T_I64
+ 4 -> T_DOUBLE
11 -> T_STRING
12 -> T_STRUCT
- 13 -> T_MAP
- 14 -> T_SET
- 15 -> T_LIST
- 16 -> T_UTF8
+ 13 -> T_MAP
+ 14 -> T_SET
+ 15 -> T_LIST
+ 16 -> T_UTF8
17 -> T_UTF16
_ -> T_UNKNOWN
-
-
+
+
data Message_type = M_CALL
| M_REPLY
| M_EXCEPTION
| M_UNKNOWN
deriving Eq
instance Enum Message_type where
-
+
fromEnum t = case t of
M_CALL -> 1
M_REPLY -> 2
M_EXCEPTION -> 3
M_UNKNOWN -> -1
-
+
toEnum t = case t of
1 -> M_CALL
2 -> M_REPLY
3 -> M_EXCEPTION
_ -> M_UNKNOWN
-
-
-
-
+
+
+
+
class Protocol a where
pflush :: a -> IO ()
writeMessageBegin :: a -> ([Char],Message_type,Int) -> IO ()
T_UTF8 -> return ()
T_UTF16 -> return ()
T_UNKNOWN -> return ()
-
-
- data PE_type = PE_UNKNOWN
+
+
+ data PE_type = PE_UNKNOWN
| PE_INVALID_DATA
| PE_NEGATIVE_SIZE
| PE_SIZE_LIMIT
deriving (Eq, Data, Typeable)
data ProtocolExn = ProtocolExn PE_type [Char] deriving (Typeable, Data)
-
+
data AE_type = AE_UNKNOWN
| AE_UNKNOWN_METHOD
| AE_INVALID_MESSAGE_TYPE
| AE_BAD_SEQUENCE_ID
| AE_MISSING_RESULT
deriving (Eq, Data, Typeable)
-
+
instance Enum AE_type where
toEnum i = case i of
0 -> AE_UNKNOWN
AE_WRONG_METHOD_NAME -> 3
AE_BAD_SEQUENCE_ID -> 4
AE_MISSING_RESULT -> 5
-
+
data AppExn = AppExn {ae_type :: AE_type, ae_message :: [Char]} deriving (Typeable, Data)
-
+
readAppExnFields pt rec = do (n,ft,id) <- readFieldBegin pt
if ft == T_STOP then return rec
else
_ -> do skip pt ft
readFieldEnd pt
readAppExnFields pt rec
-
+
readAppExn pt = do readStructBegin pt
rec <- readAppExnFields pt (AppExn {ae_type = undefined, ae_message = undefined})
readStructEnd pt
return rec
-
-
+
+
writeAppExn pt ae = do writeStructBegin pt "TApplicationException"
if ae_message ae /= "" then
do writeFieldBegin pt ("message",T_STRING,1)
writeFieldStop pt
writeStructEnd pt
-
+
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
while (true) {
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1:
if (field.type == TType.STRING) {
message = iprot.readString();
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2:
if (field.type == TType.I32) {
type = iprot.readI32();
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
public TException(String message) {
super(message);
}
-
+
public TException(Throwable cause) {
super(cause);
}
public class TProcessorFactory {
private final TProcessor processor_;
-
+
public TProcessorFactory(TProcessor processor) {
processor_ = processor;
}
-
+
public TProcessor getProcessor(TTransport trans) {
return processor_;
}
protected int readLength_;
protected boolean checkReadLength_ = false;
-
+
/**
* Factory
*/
checkReadLength(len);
return trans_.readAll(buf, off, len);
}
-
+
public void setReadLength(int readLength) {
readLength_ = readLength;
checkReadLength_ = true;
}
}
}
-
+
}
*/
public class TList {
public TList() {}
-
+
public TList(byte t, int s) {
elemType = t;
size = s;
*/
public class TMap {
public TMap() {}
-
+
public TMap(byte k, byte v, int s) {
keyType = k;
valueType = v;
/**
* Transport
- */
+ */
protected TTransport trans_;
/**
protected TProtocol(TTransport trans) {
trans_ = trans;
}
-
+
/**
* Transport accessor
*/
public abstract void writeMessageBegin(TMessage message) throws TException;
public abstract void writeMessageEnd() throws TException;
-
+
public abstract void writeStructBegin(TStruct struct) throws TException;
public abstract void writeStructEnd() throws TException;
public abstract void readStructEnd() throws TException;
public abstract TField readFieldBegin() throws TException;
-
+
public abstract void readFieldEnd() throws TException;
-
+
public abstract TMap readMapBegin() throws TException;
public abstract void readMapEnd() throws TException;
public abstract short readI16() throws TException;
public abstract int readI32() throws TException;
-
+
public abstract long readI64() throws TException;
public abstract double readDouble() throws TException;
break;
}
case TType.SET:
- {
+ {
TSet set = prot.readSetBegin();
for (int i = 0; i < set.size; i++) {
skip(prot, set.elemType);
while (true)
{
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id)
if (field.type == TType.I16) {
this.key = iprot.readI16();
this.__isset.key = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
if (field.type == TType.STRING) {
this.name = iprot.readString();
this.__isset.name = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
this.type = new ThriftType();
this.type.read(iprot);
this.__isset.type = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
while (true)
{
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id)
if (field.type == TType.I32) {
this.ttype = iprot.readI32();
this.__isset.ttype = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
this.subtype1 = new SimpleType();
this.subtype1.read(iprot);
this.__isset.subtype1 = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
this.subtype2 = new SimpleType();
this.subtype2.read(iprot);
this.__isset.subtype2 = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
while (true)
{
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id)
if (field.type == TType.STRING) {
this.name = iprot.readString();
this.__isset.name = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
this.return_type = new ThriftType();
this.return_type.read(iprot);
this.__isset.return_type = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
iprot.readListEnd();
}
this.__isset.arguments = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
while (true)
{
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id)
if (field.type == TType.STRING) {
this.name = iprot.readString();
this.__isset.name = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
iprot.readListEnd();
}
this.__isset.methods = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
if (field.type == TType.BOOL) {
this.fully_reflected = iprot.readBool();
this.__isset.fully_reflected = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
while (true)
{
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id)
if (field.type == TType.I32) {
this.ttype = iprot.readI32();
this.__isset.ttype = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
if (field.type == TType.STRING) {
this.name = iprot.readString();
this.__isset.name = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
while (true)
{
field = iprot.readFieldBegin();
- if (field.type == TType.STOP) {
+ if (field.type == TType.STOP) {
break;
}
switch (field.id)
if (field.type == TType.BOOL) {
this.is_container = iprot.readBool();
this.__isset.is_container = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
this.simple_type = new SimpleType();
this.simple_type.read(iprot);
this.__isset.simple_type = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
this.container_type = new ContainerType();
this.container_type.read(iprot);
this.__isset.container_type = true;
- } else {
+ } else {
TProtocolUtil.skip(iprot, field.type);
}
break;
protected TServer(TProcessorFactory processorFactory,
TServerTransport serverTransport) {
this(processorFactory,
- serverTransport,
+ serverTransport,
new TTransportFactory(),
new TTransportFactory(),
new TBinaryProtocol.Factory(),
inputProtocolFactory_ = inputProtocolFactory;
outputProtocolFactory_ = outputProtocolFactory;
}
-
+
/**
* The run method fires up the server and gets things going.
*/
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
- TProtocolFactory outputProtocolFactory) {
- super(new TProcessorFactory(processor), serverTransport,
+ TProtocolFactory outputProtocolFactory) {
+ super(new TProcessorFactory(processor), serverTransport,
inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory);
}
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
- TProtocolFactory outputProtocolFactory) {
- super(processorFactory, serverTransport,
+ TProtocolFactory outputProtocolFactory) {
+ super(processorFactory, serverTransport,
inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory);
}
-
-
+
+
public void serve() {
stopped_ = false;
try {
*
* @param is Input stream to read from
* @param os Output stream to read from
- */
+ */
public TIOStreamTransport(InputStream is, OutputStream os) {
inputStream_ = is;
outputStream_ = os;
* @author Mark Slee <mcslee@facebook.com>
*/
public class TServerSocket extends TServerTransport {
-
+
/**
* Underlying serversocket object
*/
}
}
}
-
+
protected TSocket acceptImpl() throws TTransportException {
if (serverSocket_ == null) {
throw new TTransportException(TTransportException.NOT_OPEN, "No underlying server socket.");
* Wrapped Socket object
*/
private Socket socket_ = null;
-
+
/**
* Remote host
*/
-------
The library abstract classes, exceptions, and general use functions
are mostly jammed in Thrift.ml (an exception being
-TServer).
+TServer).
Generally, classes are used, however they are often put in their own
module along with other relevant types and functions. The classes
struct.
-enum format
+enum format
-----------
Enums are put in their own module along with
functions to_i and of_i which convert the ocaml types into ints. For
let vt = P.t_type_of_i
-let comp_int b n =
+let comp_int b n =
let s = ref 0l in
let sb = 32 - 8*n in
for i=0 to (n-1) do
object (self)
inherit P.t trans
val ibyte = String.create 8
- method writeBool b =
+ method writeBool b =
ibyte.[0] <- char_of_int (if b then 1 else 0);
trans#write ibyte 0 1
method writeByte i =
self#writeByte (tv t);
self#writeI32 s
method writeSetEnd = ()
- method readByte =
+ method readByte =
ignore (trans#readAll ibyte 0 1);
(comp_int ibyte 1)
method readI16 =
""
method readStructEnd = ()
method readFieldBegin =
- let t = (vt (self#readByte))
+ let t = (vt (self#readByte))
in
if t != P.T_STOP then
("",t,self#readI16)
method isOpen = opened
method opn = ()
method close = close_in i; opened <- false
- method read buf off len =
+ method read buf off len =
if opened then
- try
+ try
really_input i buf off len; len
with _ -> raise (T.E (T.UNKNOWN, ("TChannelTransport: Could not read "^(string_of_int len))))
- else
+ else
raise (T.E (T.NOT_OPEN, "TChannelTransport: Channel was closed"))
method write buf off len = output o buf off len
method flush = flush o
open Thrift
class virtual t
- (pf : Processor.t)
+ (pf : Processor.t)
(st : Transport.server_t)
(tf : Transport.factory)
(ipf : Protocol.factory)
Unix.listen s 256
method close =
match sock with
- Some s -> Unix.shutdown s Unix.SHUTDOWN_ALL; Unix.close s;
+ Some s -> Unix.shutdown s Unix.SHUTDOWN_ALL; Unix.close s;
sock <- None
| _ -> ()
method acceptImpl =
inherit T.t
val mutable chans = None
method isOpen = chans != None
- method opn =
+ method opn =
try
let addr = (let {Unix.h_addr_list=x} = Unix.gethostbyname host in x.(0)) in
chans <- Some(Unix.open_connection (Unix.ADDR_INET (addr,port)))
- with
+ with
Unix.Unix_error (e,fn,_) -> raise (T.E (T.NOT_OPEN, ("TSocket: Could not connect to "^host^":"^(string_of_int port)^" because: "^fn^":"^(Unix.error_message e))))
| _ -> raise (T.E (T.NOT_OPEN, ("TSocket: Could not connect to "^host^":"^(string_of_int port))))
- method close =
- match chans with
- None -> ()
- | Some(inc,out) -> (Unix.shutdown_connection inc;
- close_in inc;
+ method close =
+ match chans with
+ None -> ()
+ | Some(inc,out) -> (Unix.shutdown_connection inc;
+ close_in inc;
chans <- None)
method read buf off len = match chans with
None -> raise (T.E (T.NOT_OPEN, "TSocket: Socket not open"))
- | Some(i,o) ->
- try
+ | Some(i,o) ->
+ try
really_input i buf off len; len
with
Unix.Unix_error (e,fn,_) -> raise (T.E (T.UNKNOWN, ("TSocket: Could not read "^(string_of_int len)^" from "^host^":"^(string_of_int port)^" because: "^fn^":"^(Unix.error_message e))))
| _ -> raise (T.E (T.UNKNOWN, ("TSocket: Could not read "^(string_of_int len)^" from "^host^":"^(string_of_int port))))
- method write buf off len = match chans with
+ method write buf off len = match chans with
None -> raise (T.E (T.NOT_OPEN, "TSocket: Socket not open"))
| Some(i,o) -> output o buf off len
method flush = match chans with
None -> raise (T.E (T.NOT_OPEN, "TSocket: Socket not open"))
| Some(i,o) -> flush o
end
-
-
+
+
open Thrift
-class t
- (pf : Processor.t)
+class t
+ (pf : Processor.t)
(st : Transport.server_t)
(tf : Transport.factory)
(ipf : Protocol.factory)
st#listen;
while true do
let tr = tf#getTransport (st#accept) in
- ignore (Thread.create
- (fun _ ->
+ ignore (Thread.create
+ (fun _ ->
let ip = ipf#getProtocol tr in
let op = opf#getProtocol tr in
try
with _ -> ()) ())
done
end
-
+
exception Thrift_error;;
exception Field_empty of string;;
-class t_exn =
+class t_exn =
object
val mutable message = ""
method get_message = message
module Transport =
struct
- type exn_type =
+ type exn_type =
| UNKNOWN
| NOT_OPEN
| ALREADY_OPEN
method virtual close : unit
method virtual acceptImpl : t
end
-
+
end;;
module Protocol =
struct
- type t_type =
- | T_STOP
- | T_VOID
+ type t_type =
+ | T_STOP
+ | T_VOID
| T_BOOL
| T_BYTE
- | T_I08
- | T_I16
- | T_I32
- | T_U64
- | T_I64
- | T_DOUBLE
- | T_STRING
- | T_UTF7
- | T_STRUCT
- | T_MAP
- | T_SET
- | T_LIST
- | T_UTF8
+ | T_I08
+ | T_I16
+ | T_I32
+ | T_U64
+ | T_I64
+ | T_DOUBLE
+ | T_STRING
+ | T_UTF7
+ | T_STRUCT
+ | T_MAP
+ | T_SET
+ | T_LIST
+ | T_UTF8
| T_UTF16
let t_type_to_i = function
| T_LIST -> 15
| T_UTF8 -> 16
| T_UTF16 -> 17
-
+
let t_type_of_i = function
- 0 -> T_STOP
- | 1 -> T_VOID
+ 0 -> T_STOP
+ | 1 -> T_VOID
| 2 -> T_BOOL
| 3 -> T_BYTE
- | 6-> T_I16
- | 8 -> T_I32
- | 9 -> T_U64
- | 10 -> T_I64
- | 4 -> T_DOUBLE
+ | 6-> T_I16
+ | 8 -> T_I32
+ | 9 -> T_U64
+ | 10 -> T_I64
+ | 4 -> T_DOUBLE
| 11 -> T_STRING
| 12 -> T_STRUCT
- | 13 -> T_MAP
- | 14 -> T_SET
- | 15 -> T_LIST
- | 16 -> T_UTF8
+ | 13 -> T_MAP
+ | 14 -> T_SET
+ | 15 -> T_LIST
+ | 16 -> T_UTF8
| 17 -> T_UTF16
- | _ -> raise Thrift_error
+ | _ -> raise Thrift_error
type message_type =
| CALL
| REPLY -> 2
| EXCEPTION -> 3
- let message_type_of_i = function
+ let message_type_of_i = function
| 1 -> CALL
| 2 -> REPLY
| 3 -> EXCEPTION
method virtual readString : string
method virtual readBinary : string
(* skippage *)
- method skip typ =
+ method skip typ =
match typ with
| T_STOP -> ()
| T_VOID -> ()
| T_I16 -> ignore self#readI16
| T_I32 -> ignore self#readI32
| T_U64
- | T_I64 -> ignore self#readI64
+ | T_I64 -> ignore self#readI64
| T_DOUBLE -> ignore self#readDouble
| T_STRING -> ignore self#readString
| T_UTF7 -> ()
let (_,t,_) = self#readFieldBegin in
if t = T_STOP then
raise Break
- else
+ else
(self#skip t;
self#readFieldEnd)
done
| BAD_VERSION
exception E of exn_type * string;;
-
-end;;
+
+end;;
module Processor =
object
method virtual process : Protocol.t -> Protocol.t -> bool
end;;
-
+
class factory (processor : t) =
object
- val processor_ = processor
+ val processor_ = processor
method getProcessor (trans : Transport.t) = processor_
end;;
end
oprot#writeFieldStop;
oprot#writeStructEnd
end;;
-
+
let create typ msg =
let e = new t in
e#set_type typ;
e#set_message msg;
e
-
+
let read (iprot : Protocol.t) =
let msg = ref "" in
let typ = ref 0 in
ignore iprot#readStructBegin;
- (try
+ (try
while true do
let (name,ft,id) =iprot#readFieldBegin in
if ft = Protocol.T_STOP then
e#set_type (typ_of_i !typ);
e#set_message !msg;
e;;
-
+
exception E of t
end;;
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
my $classname = shift;
my $url = shift || 'http://localhost:9090';
my $debugHandler = shift;
-
+
my $out = IO::String->new;
binmode($out);
-
+
my $self = {
url => $url,
out => $out,
{
my $self = shift;
my $len = shift;
-
+
my $buf = $self->read($len);
-
+
if (!defined($buf)) {
die new Thrift::TException('TSocket: Could not read '.$len.' bytes from input buffer');
}
{
my $self = shift;
my $len = shift;
-
+
my $buf;
-
+
my $in = $self->{in};
if (!defined($in)) {
$ua->default_header('Accept' => 'application/x-thrift');
$ua->default_header('Content-Type' => 'application/x-thrift');
$ua->cookie_jar({}); # hash to remember cookies between redirects
-
+
my $out = $self->{out};
$out->setpos(0); # rewind
my $buf = join('', <$out>);
-
+
my $request = new HTTP::Request(POST => $self->{url}, undef, $buf);
my $response = $ua->request($request);
my $content_ref = $response->content_ref;
-
+
my $in = IO::String->new($content_ref);
binmode($in);
$self->{in} = $in;
$in->setpos(0); # rewind
-
+
# reset write buffer
$out = IO::String->new;
binmode($out);
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
size_t buffer_remaining;
size_t buffer_size;
- zval* p;
+ zval* p;
zval* t;
zval funcname;
};
if (! ce) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", obj_typename);
RETURN_NULL();
- }
+ }
object_and_properties_init(return_value, ce, NULL);
}
case T_STOP:
case T_VOID:
RETURN_NULL();
- return;
+ return;
case T_STRUCT: {
assert(structType);
createObject(structType, return_value);
RETURN_BOOL(c != 0);
}
//case T_I08: // same numeric value as T_BYTE
- case T_BYTE: {
+ case T_BYTE: {
uint8_t c;
transport.readBytes(&c, 1);
- RETURN_LONG(c);
+ RETURN_LONG(c);
}
case T_I16: {
uint16_t c;
efree(args);
RETURN_NULL();
}
-
+
char* structType = NULL;
if (argc >= 3) {
if (Z_TYPE_PP(args[2]) == IS_STRING) {
// Check for a negative
if ($isNeg) {
- $hi = ~$hi & (int)0xffffffff;
- $lo = ~$lo & (int)0xffffffff;
-
- if ($lo == (int)0xffffffff) {
- $hi++;
- $lo = 0;
- } else {
- $lo++;
- }
+ $hi = ~$hi & (int)0xffffffff;
+ $lo = ~$lo & (int)0xffffffff;
+
+ if ($lo == (int)0xffffffff) {
+ $hi++;
+ $lo = 0;
+ } else {
+ $lo++;
+ }
}
// Force 32bit words in excess of 2G to pe positive - we deal wigh sign
// explicitly below
if ($hi & (int)0x80000000) {
- $hi &= (int)0x7fffffff;
- $hi += 0x80000000;
+ $hi &= (int)0x7fffffff;
+ $hi += 0x80000000;
}
if ($lo & (int)0x80000000) {
- $lo &= (int)0x7fffffff;
- $lo += 0x80000000;
+ $lo &= (int)0x7fffffff;
+ $lo += 0x80000000;
}
$value = $hi * 4294967296 + $lo;
if ($isNeg) {
- $value = 0 - $value;
+ $value = 0 - $value;
}
} else {
oprot.writeFieldStop()
oprot.writeStructEnd()
- def __str__(self):
+ def __str__(self):
return str(self.__dict__)
- def __repr__(self):
+ def __repr__(self):
return repr(self.__dict__)
def __eq__(self, other):
oprot.writeFieldStop()
oprot.writeStructEnd()
- def __str__(self):
+ def __str__(self):
return str(self.__dict__)
- def __repr__(self):
+ def __repr__(self):
return repr(self.__dict__)
def __eq__(self, other):
oprot.writeFieldStop()
oprot.writeStructEnd()
- def __str__(self):
+ def __str__(self):
return str(self.__dict__)
- def __repr__(self):
+ def __repr__(self):
return repr(self.__dict__)
def __eq__(self, other):
oprot.writeFieldStop()
oprot.writeStructEnd()
- def __str__(self):
+ def __str__(self):
return str(self.__dict__)
- def __repr__(self):
+ def __repr__(self):
return repr(self.__dict__)
def __eq__(self, other):
oprot.writeFieldStop()
oprot.writeStructEnd()
- def __str__(self):
+ def __str__(self):
return str(self.__dict__)
- def __repr__(self):
+ def __repr__(self):
return repr(self.__dict__)
def __eq__(self, other):
oprot.writeFieldStop()
oprot.writeStructEnd()
- def __str__(self):
+ def __str__(self):
return str(self.__dict__)
- def __repr__(self):
+ def __repr__(self):
return repr(self.__dict__)
def __eq__(self, other):
self.serveClient(client)
except Exception, x:
print '%s, %s, %s' % (type(x), x, traceback.format_exc())
-
+
def serveClient(self, client):
"""Process input/output from a client for as long as possible"""
itrans = self.inputTransportFactory.getTransport(client)
t.start()
except Exception, x:
print '%s, %s, %s,' % (type(x), x, traceback.format_exc())
-
+
# Pump the socket for clients
self.serverTransport.listen()
while True:
def close(self):
self.__http.close()
self.__http = None
-
+
def isOpen(self):
return self.__http != None
self.handle = None
self._unix_socket = unix_socket
self._timeout = None
-
+
def setHandle(self, h):
self.handle = h
self._timeout = None
else:
self._timeout = ms/1000.0
-
+
if (self.handle != None):
self.handle.settimeout(self._timeout)
return [(socket.AF_UNIX, socket.SOCK_STREAM, None, None, self._unix_socket)]
else:
return socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE | socket.AI_ADDRCONFIG)
-
+
def open(self):
try:
res0 = self._resolveAddr()
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
Thrift Software License
-Copyright (c) 2006- Facebook, Inc.
+Copyright (c) 2006- Facebook, Inc.
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
writeByte(type)
writeI16(id)
end
-
+
def writeFieldStop()
writeByte(TType::STOP)
end
writeByte(vtype)
writeI32(size)
end
-
+
def writeListBegin(etype, size)
writeByte(etype)
writeI32(size)
end
-
+
def writeSetBegin(etype, size)
writeByte(etype)
writeI32(size)
end
-
+
def writeBool(bool)
if (bool)
writeByte(1)
def writeI32(i32)
trans.write([i32].pack('N'))
end
-
+
def writeI64(i64)
hi = i64 >> 32
lo = i64 & 0xffffffff
def writeDouble(dub)
trans.write([dub].pack('G'))
end
-
+
def writeString(str)
writeI32(str.length)
trans.write(str)
seqid = readI32()
return name, type, seqid
end
-
+
def readFieldBegin()
type = readByte()
if (type === TType::STOP)
id = readI16()
return nil, type, id
end
-
+
def readMapBegin()
ktype = readByte()
vtype = readByte()
etype = readByte()
size = readI32()
return etype, size
- end
-
+ end
+
def readBool()
byte = readByte()
return byte != 0
end
return val
end
-
+
def readI32()
dat = trans.readAll(4)
val, = dat.unpack('N')
end
class TProtocol
-
+
attr_reader :trans
def initialize(trans)
def writeMessageBegin(name, type, seqid); nil; end
def writeMessageEnd; nil; end
-
+
def writeStructBegin(name); nil; end
-
+
def writeStructEnd(); nil; end
-
+
def writeFieldBegin(name, type, id); nil; end
-
+
def writeFieldEnd(); nil; end
-
+
def writeFieldStop(); nil; end
def writeMapBegin(ktype, vtype, size); nil; end
-
+
def writeMapEnd(); nil; end
def writeListBegin(etype, size); nil; end
-
+
def writeListEnd(); nil; end
-
+
def writeSetBegin(etype, size); nil; end
def writeSetEnd(); nil; end
-
+
def writeBool(bool); nil; end
-
+
def writeByte(byte); nil; end
-
+
def writeI16(i16); nil; end
-
+
def writeI32(i32); nil; end
-
+
def writeI64(i64); nil; end
-
+
def writeDouble(dub); nil; end
-
+
def writeString(str); nil; end
-
+
def readMessageBegin(); nil; end
-
+
def readMessageEnd(); nil; end
-
+
def readStructBegin(); nil; end
-
+
def readStructEnd(); nil; end
-
+
def readFieldBegin(); nil; end
-
+
def readFieldEnd(); nil; end
-
+
def readMapBegin(); nil; end
-
+
def readMapEnd(); nil; end
-
+
def readListBegin(); nil; end
-
+
def readListEnd(); nil; end
def readSetBegin(); nil; end
-
+
def readSetEnd(); nil; end
-
+
def readBool(); nil; end
-
+
def readByte(); nil; end
def readI16(); nil; end
-
+
def readI32(); nil; end
-
+
def readI64(); nil; end
-
+
def readDouble(); nil; end
-
+
def readString(); nil; end
-
+
def write_field(name, type, fid, value)
writeFieldBegin(name, type, fid)
write_type(type, value)
writeFieldEnd
end
-
+
def write_type(type, value)
case type
when TType::BOOL
raise NotImplementedError
end
end
-
+
def read_type(type)
case type
when TType::BOOL
raise NotImplementedError
end
end
-
+
def skip(type)
if type === TType::STOP
nil
@transportFactory = transportFactory ? transportFactory : TTransportFactory.new()
@protocolFactory = protocolFactory ? protocolFactory : TBinaryProtocolFactory.new()
end
-
+
def serve(); nil; end
end
def ruby(*args)
command config('rubyprog'), *args
end
-
+
def make(task = nil)
command(*[config('makeprog'), task].compact)
end
def srcdirectory?(path)
File.dir?(srcfile(path))
end
-
+
def srcfile?(path)
File.file?(srcfile(path))
end
__send__ "exec_#{task}"
end
end
-
+
def run_metaconfigs
@config.load_script "#{@ardir}/metaconfig"
end
end
# picked up many entries from cvs-1.11.1/src/ignore.c
- JUNK_FILES = %w(
+ JUNK_FILES = %w(
core RCSLOG tags TAGS .make.state
.nse_depinfo #* .#* cvslog.* ,* .del-* *.olb
*~ *.old *.bak *.BAK *.orig *.rej _$* *$
}
/** This is how you would do a typedef doc */
-typedef i64 UserId
+typedef i64 UserId
/** And this is where you would document a struct */
struct Xtruct
1: map<Numberz, UserId> userMap,
/** And this is doc for field 2 */
- 2: list<Xtruct> xtructs
+ 2: list<Xtruct> xtructs
}
exception Xception {
1: i32 errorCode,
2: Xtruct struct_thing
}
-
+
/* C1 */
/** Doc */
/* C2 */
o.write(prot)
slow_version_binary = prot.trans.getvalue()
-
+
prot = TBinaryProtocol.TBinaryProtocolAccelerated(
TTransport.TMemoryBuffer(slow_version_binary))
c = o.__class__()
exception Goodbye {
1: i32 simple,
2: map<i32,i32> complex,
- 3: map<i32, map<i32,i32>> complexer,
+ 3: map<i32, map<i32,i32>> complexer,
}
service SmallService {
# Makefile for Thrift test project.
-#
+#
# Author:
# Mark Slee <mcslee@facebook.com>
$(THRIFT) --cpp ../ThriftTest.thrift
server-debug: stubs
- g++ -o TestServer $(DCFL) src/TestServer.cpp ./gen-cpp/ThriftTest.cpp ./gen-cpp/ThriftTest_types.cpp
+ g++ -o TestServer $(DCFL) src/TestServer.cpp ./gen-cpp/ThriftTest.cpp ./gen-cpp/ThriftTest_types.cpp
client-debug: stubs
g++ -o TestClient $(DCFL) src/TestClient.cpp ./gen-cpp/ThriftTest.cpp ./gen-cpp/ThriftTest_types.cpp
{
long long ret;
struct timeval tv;
-
+
gettimeofday(&tv, NULL);
ret = tv.tv_sec;
ret = ret*1000*1000 + tv.tv_usec;
shared_ptr<TTransport> transport;
shared_ptr<TSocket> socket(new TSocket(host, port));
-
+
if (framed) {
shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket));
framedSocket->setRead(frameInput);
uint64_t time_min = 0;
uint64_t time_max = 0;
uint64_t time_tot = 0;
-
+
int test = 0;
for (test = 0; test < numTests; ++test) {
printf("Connect failed: %s\n", ttx.what());
continue;
}
-
+
/**
* CONNECT TEST
*/
printf("Test #%d, connect %s:%d\n", test+1, host.c_str(), port);
uint64_t start = now();
-
+
/**
* VOID TEST
*/
} catch (TApplicationException tax) {
printf("%s\n", tax.what());
}
-
+
/**
* STRING TEST
*/
string s;
testClient.testString(s, "Test");
printf(" = \"%s\"\n", s.c_str());
-
+
/**
* BYTE TEST
*/
printf("testByte(1)");
uint8_t u8 = testClient.testByte(1);
printf(" = %d\n", (int)u8);
-
+
/**
* I32 TEST
*/
printf("testDouble(-5.2098523)");
double dub = testClient.testDouble(-5.2098523);
printf(" = %lf\n", dub);
-
+
/**
* STRUCT TEST
*/
(int)in.byte_thing,
in.i32_thing,
in.i64_thing);
-
+
/**
* NESTED STRUCT TEST
*/
(int)in.byte_thing,
in.i32_thing,
in.i64_thing,
- in2.i32_thing);
+ in2.i32_thing);
/**
* MAP TEST
printf("testClient.testException(\"Xception\") =>");
testClient.testException("Xception");
printf(" void\nFAILURE\n");
-
+
} catch(Xception& e) {
printf(" {%u, \"%s\"}\n", e.errorCode, e.message.c_str());
}
-
+
try {
printf("testClient.testException(\"success\") =>");
testClient.testException("success");
} catch(...) {
printf(" exception\nFAILURE\n");
}
-
+
/* test multi exception */
-
+
try {
printf("testClient.testMultiException(\"Xception\", \"test 1\") =>");
Xtruct result;
Xtruct result;
testClient.testMultiException(result, "Xception2", "test 2");
printf(" result\nFAILURE\n");
-
+
} catch(Xception2& e) {
printf(" {%u, {\"%s\"}}\n", e.errorCode, e.struct_thing.string_thing.c_str());
}
-
+
try {
printf("testClient.testMultiException(\"success\", \"test 3\") =>");
Xtruct result;
} catch(...) {
printf(" exception\nFAILURE\n");
}
-
+
uint64_t stop = now();
uint64_t tot = stop-start;
printf("Total time: %"PRIu64" us\n", stop-start);
-
+
time_tot += tot;
if (time_min == 0 || tot < time_min) {
time_min = tot;
void testInsanity(map<UserId, map<Numberz,Insanity> > &insane, const Insanity &argument) {
printf("testInsanity()\n");
-
+
Xtruct hello;
hello.string_thing = "Hello2";
hello.byte_thing = 2;
}
printf("}\n");
-
+
}
void testMulti(Xtruct &hello, const int8_t arg0, const int32_t arg1, const int64_t arg2, const std::map<int16_t, std::string> &arg3, const Numberz arg4, const UserId arg5) {
printf("testMulti()\n");
-
+
hello.string_thing = "Hello2";
hello.byte_thing = arg0;
hello.i32_thing = arg1;
return;
}
}
-
+
void testMultiException(Xtruct &result, const std::string &arg0, const std::string &arg1) throw(Xception, Xception2) {
printf("testMultiException(%s, %s)\n", arg0.c_str(), arg1.c_str());
"\t\tprotocol-type\t\ttype of protocol, \"binary\", \"ascii\", or \"xml\". Default is " << protocolType << endl <<
"\t\tworkers\t\tNumber of thread pools workers. Only valid for thread-pool server type. Default is " << workerCount << endl;
-
+
map<string, string> args;
-
+
for (int ix = 1; ix < argc; ix++) {
string arg(argv[ix]);
if (arg.compare(0,2, "--") == 0) {
}
if (!args["server-type"].empty()) {
- serverType = args["server-type"];
+ serverType = args["server-type"];
if (serverType == "simple") {
} else if (serverType == "thread-pool") {
} else if (serverType == "threaded") {
} else {
throw invalid_argument("Unknown protocol type "+protocolType);
}
- }
+ }
if (!args["workers"].empty()) {
workerCount = atoi(args["workers"].c_str());
threadPoolServer.serve();
} else if (serverType == "threaded") {
-
+
TThreadedServer threadedServer(testProcessor,
serverSocket,
transportFactory,
};
-// typedef hash_map<const char*, int, hash<const char*>, eqstr> count_map;
-typedef map<const char*, int, ltstr> count_map;
+// typedef hash_map<const char*, int, hash<const char*>, eqstr> count_map;
+typedef map<const char*, int, ltstr> count_map;
class Server : public ServiceIf {
public:
void run() {
- // Wait for all worker threads to start
+ // Wait for all worker threads to start
{Synchronized s(_monitor);
- while(_workerCount == 0) {
- _monitor.wait();
- }
+ while(_workerCount == 0) {
+ _monitor.wait();
+ }
}
_startTime = Util::currentTime();
case T_STRING: loopEchoString(); break;
default: cerr << "Unexpected loop type" << _loopType << endl; break;
}
-
+
_endTime = Util::currentTime();
_transport->close();
-
+
_done = true;
-
+
{Synchronized s(_monitor);
_workerCount--;
-
+
if (_workerCount == 0) {
-
- _monitor.notify();
+
+ _monitor.notify();
}
}
}
assert(result == arg);
}
}
-
+
void loopEchoI32() {
for (size_t ix = 0; ix < _loopCount; ix++) {
int32_t arg = 1;
assert(result == arg);
}
}
-
+
void loopEchoString() {
for (size_t ix = 0; ix < _loopCount; ix++) {
string arg = "hello";
assert(result == arg);
}
}
-
+
shared_ptr<TTransport> _transport;
shared_ptr<ServiceClient> _client;
Monitor& _monitor;
"\tlog-request Log all request to ./requestlog.tlog. Default is " << logRequests << endl <<
"\treplay-request Replay requests from log file (./requestlog.tlog) Default is " << replayRequests << endl <<
"\tworkers Number of thread pools workers. Only valid for thread-pool server type. Default is " << workerCount << endl;
-
-
+
+
map<string, string> args;
-
+
for (int ix = 1; ix < argc; ix++) {
string arg(argv[ix]);
string key = string(arg, 2, end - 2);
if (end != string::npos) {
- args[key] = string(arg, end + 1);
+ args[key] = string(arg, end + 1);
} else {
- args[key] = "true";
+ args[key] = "true";
}
} else {
throw invalid_argument("Unexcepted command line token: "+arg);
if (!args["server-type"].empty()) {
serverType = args["server-type"];
-
+
if (serverType == "simple") {
} else if (serverType == "thread-pool") {
} else {
- throw invalid_argument("Unknown server type "+serverType);
+ throw invalid_argument("Unknown server type "+serverType);
}
}
if (replayRequests) {
shared_ptr<Server> serviceHandler(new Server());
shared_ptr<ServiceProcessor> serviceProcessor(new ServiceProcessor(serviceHandler));
-
+
// Transports
shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
fileTransport->setChunkSize(2 * 1024 * 1024);
protocolFactory,
fileTransport);
- fileProcessor.process(0, true);
+ fileProcessor.process(0, true);
exit(0);
}
shared_ptr<TFileTransport> fileTransport(new TFileTransport(requestLogPath));
fileTransport->setChunkSize(2 * 1024 * 1024);
fileTransport->setMaxEventSize(1024 * 16);
-
- transportFactory =
+
+ transportFactory =
shared_ptr<TTransportFactory>(new TPipedTransportFactory(fileTransport));
}
shared_ptr<Thread> serverThread;
if (serverType == "simple") {
-
+
serverThread = threadFactory->newThread(shared_ptr<TServer>(new TSimpleServer(serviceProcessor, serverSocket, transportFactory, protocolFactory)));
-
+
} else if (serverType == "threaded") {
serverThread = threadFactory->newThread(shared_ptr<TServer>(new TThreadedServer(serviceProcessor, serverSocket, transportFactory, protocolFactory)));
-
+
} else if (serverType == "thread-pool") {
shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
threadManager->threadFactory(threadFactory);
- threadManager->start();
+ threadManager->start();
serverThread = threadFactory->newThread(shared_ptr<TServer>(new TThreadPoolServer(serviceProcessor, serverSocket, transportFactory, protocolFactory, threadManager)));
}
cerr << "Starting the server on port " << port << endl;
serverThread->start();
-
+
// If we aren't running clients, just wait forever for external clients
if (clientCount == 0) {
else {throw invalid_argument("Unknown service call "+callName);}
for (size_t ix = 0; ix < clientCount; ix++) {
-
+
shared_ptr<TSocket> socket(new TSocket("127.0.01", port));
shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket, 2048));
shared_ptr<TProtocol> protocol(new TBinaryProtocol(bufferedSocket));
shared_ptr<ServiceClient> serviceClient(new ServiceClient(protocol));
-
+
clientThreads.insert(threadFactory->newThread(shared_ptr<ClientThread>(new ClientThread(socket, serviceClient, monitor, threadCount, loopCount, loopType))));
}
-
+
for (std::set<shared_ptr<Thread> >::const_iterator thread = clientThreads.begin(); thread != clientThreads.end(); thread++) {
(*thread)->start();
}
long long time00;
long long time01;
-
+
{Synchronized s(monitor);
threadCount = clientCount;
-
+
cerr << "Launch "<< clientCount << " client threads" << endl;
-
+
time00 = Util::currentTime();
-
+
monitor.notifyAll();
-
+
while(threadCount > 0) {
- monitor.wait();
+ monitor.wait();
}
-
+
time01 = Util::currentTime();
}
-
+
long long firstTime = 9223372036854775807LL;
long long lastTime = 0;
double averageTime = 0;
long long minTime = 9223372036854775807LL;
long long maxTime = 0;
-
+
for (set<shared_ptr<Thread> >::iterator ix = clientThreads.begin(); ix != clientThreads.end(); ix++) {
-
+
shared_ptr<ClientThread> client = dynamic_pointer_cast<ClientThread>((*ix)->runnable());
-
+
long long delta = client->_endTime - client->_startTime;
-
+
assert(delta > 0);
if (client->_startTime < firstTime) {
- firstTime = client->_startTime;
+ firstTime = client->_startTime;
}
-
+
if (client->_endTime > lastTime) {
- lastTime = client->_endTime;
+ lastTime = client->_endTime;
}
-
+
if (delta < minTime) {
- minTime = delta;
+ minTime = delta;
}
-
+
if (delta > maxTime) {
- maxTime = delta;
+ maxTime = delta;
}
-
+
averageTime+= delta;
}
-
+
averageTime /= clientCount;
-
-
+
+
cout << "workers :" << workerCount << ", client : " << clientCount << ", loops : " << loopCount << ", rate : " << (clientCount * loopCount * 1000) / ((double)(time01 - time00)) << endl;
-
+
count_map count = serviceHandler->getCount();
count_map::iterator iter;
for (iter = count.begin(); iter != count.end(); ++iter) {
print =<< testSet ps (Set.fromList [1,2,3,4,5])
print =<< testStruct ps (Xtruct (Just "hi") (Just 4) (Just 5) Nothing)
tclose to
-
+
public static class TestHandler implements ThriftTest.Iface {
public TestHandler() {}
-
+
public void testVoid() {
System.out.print("testVoid()\n");
}
System.out.print("testDouble(" + thing + ")\n");
return thing;
}
-
+
public Xtruct testStruct(Xtruct thing) {
System.out.print("testStruct({" +
"\"" + thing.string_thing + "\", " +
thing.i64_thing + "})\n");
return thing;
}
-
+
public Xtruct2 testNest(Xtruct2 nest) {
Xtruct thing = nest.struct_thing;
System.out.print("testNest({" +
nest.i32_thing + "})\n");
return nest;
}
-
+
public AbstractMap<Integer,Integer> testMap(AbstractMap<Integer,Integer> thing) {
System.out.print("testMap({");
boolean first = true;
public AbstractMap<Long, AbstractMap<Integer,Insanity>> testInsanity(Insanity argument) {
System.out.print("testInsanity()\n");
-
+
Xtruct hello = new Xtruct();
hello.string_thing = "Hello2";
hello.byte_thing = 2;
public Xtruct testMulti(byte arg0, int arg1, long arg2, AbstractMap<Short,String> arg3, int arg4, long arg5) {
System.out.print("testMulti()\n");
-
+
Xtruct hello = new Xtruct();;
hello.string_thing = "Hello2";
hello.byte_thing = arg0;
x.struct_thing.string_thing = "This is an Xception2";
throw x;
}
-
+
Xtruct result = new Xtruct();
result.string_thing = arg1;
return result;
if (args.length > 1) {
port = Integer.valueOf(args[0]);
}
-
+
// Processor
TestHandler testHandler =
new TestHandler();
method testList x = p "testList(---)\n"; (sod x)
method testEnum x = p "testEnum(---)\n"; (sod x)
method testTypedef x = p "testTypedef(---)\n"; (sod x)
- method testMapMap x = p "testMapMap(%d)\n" (sod x);
+ method testMapMap x = p "testMapMap(%d)\n" (sod x);
let mm = Hashtbl.create 3 in
let pos = Hashtbl.create 7 in
let neg = Hashtbl.create 7 in
Hashtbl.add insane 1L firstmap;
Hashtbl.add insane 2L secondmap;
insane
- method testMulti a0 a1 a2 a3 a4 a5 =
+ method testMulti a0 a1 a2 a3 a4 a5 =
p "testMulti()\n";
let hello = new xtruct in
hello#set_string_thing "Hello2";
let proc = new ThriftTest.processor h in
let port = 9090 in
let pf = new TBinaryProtocol.factory in
-let server = new TThreadedServer.t
- proc
- (new TServerSocket.t port)
- (new Transport.factory)
- pf
- pf
+let server = new TThreadedServer.t
+ proc
+ (new TServerSocket.t port)
+ (new Transport.factory)
+ pf
+ pf
in
server#serve
-
-
+
+
# Makefile for Thrift test project.
-#
+#
# Author:
# Mark Slee <mcslee@facebook.com>
# Makefile for Thrift test project.
-#
+#
# Author:
# Mark Slee <mcslee@facebook.com>
serverproc = subprocess.Popen([sys.executable, "TestServer.py"])
try:
-
+
ret = subprocess.call([sys.executable, "TestClient.py"])
if ret != 0:
raise Exception("subprocess failed")
parser = OptionParser()
-
+
parser.add_option("--port", type="int", dest="port", default=9090)
parser.add_option("--host", type="string", dest="host", default='localhost')
parser.add_option("--framed-input", action="store_true", dest="framed_input")
(options, args) = parser.parse_args()
class AbstractTest(unittest.TestCase):
-
+
def setUp(self):
global options
-
+
socket = TSocket.TSocket(options.host, options.port)
-
+
# Frame or buffer depending upon args
if options.framed_input or options.framed_output:
self.transport = TTransport.TFramedTransport(socket, options.framed_input, options.framed_output)
self.transport = TTransport.TBufferedTransport(socket)
self.transport.open()
-
+
protocol = self.protocol_factory.getProtocol(self.transport)
self.client = ThriftTest.Client(protocol)
-
+
def tearDown(self):
# Close!
self.transport.close()
def testVoid(self):
self.client.testVoid()
-
+
def testString(self):
self.assertEqual(self.client.testString('Python'), 'Python')
#!/usr/bin/env python
-import sys, glob
+import sys, glob
sys.path.insert(0, './gen-py')
sys.path.insert(0, glob.glob('../../lib/py/build/lib.*')[0])
def testConnectTimeout(self):
starttime = time.time()
-
+
try:
leaky = []
for i in xrange(100):
def testWriteTimeout(self):
starttime = time.time()
-
+
try:
socket = TSocket.TSocket('localhost', self.port)
socket.setTimeout(10)
lsock = self.listen_sock.accept()
while True:
socket.write("hi" * 100)
-
+
except:
assert time.time() - starttime < 5.0
-
+
suite = unittest.TestSuite()
loader = unittest.TestLoader()
# Makefile for Thrift test project.
-#
+#
# Author:
# Mark Slee <mcslee@facebook.com>
assert_kind_of(Hello, hello)
assert_nil(hello.complexer)
-
+
assert_equal(hello.simple, 53)
assert_equal(hello.words, 'words')
def test_insane
insane = Thrift::Test::Insanity.new({
'userMap' => { Thrift::Test::Numberz::ONE => 44 },
- 'xtructs' => [get_struct,
+ 'xtructs' => [get_struct,
Thrift::Test::Xtruct.new({
'string_thing' => 'hi again',
'i32_thing' => 12
# Makefile for Thrift test project.
-#
+#
# Author:
# Mark Slee <mcslee@facebook.com>
shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
/*
- shared_ptr<ThreadManager> threadManager =
+ shared_ptr<ThreadManager> threadManager =
ThreadManager::newSimpleThreadManager(10);
shared_ptr<PosixThreadFactory> threadFactory =
shared_ptr<PosixThreadFactory>(new PosixThreadFactory());
threadManager->threadFactory(threadFactory);
threadManager->start();
-
+
shared_ptr<TServer> server =
shared_ptr<TServer>(new TThreadPoolServer(processor,
serverTransport,
(modify-syntax-entry ?\n "> b" thrift-mode-syntax-table)
thrift-mode-syntax-table)
"Syntax table for thrift-mode")
-
+
(defun thrift-mode ()
"Mode for editing Thrift files"
(interactive)
try {
transport->open();
-
+
client.ping();
printf("ping()\n");
-
+
int32_t sum = client.add(1,1);
printf("1+1=%d\n", sum);
work.num2 = 10;
int32_t diff = client.calculate(1, work);
printf("15-10=%d\n", diff);
-
+
// Note that C++ uses return by reference for complex types to avoid
// costly copy construction
SharedStruct ss;
public class JavaClient {
public static void main(String [] args) {
try {
-
- TTransport transport = new TSocket("localhost", 9090);
+
+ TTransport transport = new TSocket("localhost", 9090);
TProtocol protocol = new TBinaryProtocol(transport);
Calculator.Client client = new Calculator.Client(protocol);
} catch (InvalidOperation io) {
System.out.println("Invalid operation: " + io.why);
}
-
+
SharedStruct log = client.getStruct(1);
System.out.println("Check log: " + log.value);
transport.close();
-
+
} catch (TException x) {
x.printStackTrace();
}
$transport = new TBufferedTransport($socket, 1024, 1024);
$protocol = new TBinaryProtocol($transport);
$client = new CalculatorClient($protocol);
-
+
$transport->open();
-
+
$client->ping();
print "ping()\n";
-
+
$sum = $client->add(1,1);
print "1+1=$sum\n";
-
+
$work = new tutorial_Work();
-
+
$work->op = tutorial_Operation::DIVIDE;
$work->num1 = 1;
$work->num2 = 0;
} catch (tutorial_InvalidOperation $io) {
print "InvalidOperation: $io->why\n";
}
-
+
$work->op = tutorial_Operation::SUBTRACT;
$work->num1 = 15;
$work->num2 = 10;
$diff = $client->calculate(1, $work);
print "15-10=$diff\n";
-
+
$log = $client->getStruct(1);
print "Log: $log->value\n";
-
+
$transport->close();
-
+
} catch (TException $tx) {
print 'TException: '.$tx->getMessage()."\n";
}
print '1+1=%d' % (sum)
work = Work()
-
+
work.op = Operation.DIVIDE
work.num1 = 1
work.num2 = 0
print 'Whoa? You know how to divide by zero?'
except InvalidOperation, io:
print 'InvalidOperation: %s' % (io.__str__())
-
+
work.op = Operation.SUBTRACT
work.num1 = 15
work.num2 = 10
-
+
diff = client.calculate(1, work)
print '15-10=%d' % (diff)
class CalculatorHandler:
def __init__(self):
self.log = {}
-
+
def ping(self):
print 'ping()'
def calculate(self, logid, work):
print 'calculate(%d, %s)' % (logid, work.__str__())
-
+
if work.op == Operation.ADD:
val = work.num1 + work.num2
elif work.op == Operation.SUBTRACT:
def zip(self):
print 'zip()'
-
+
handler = CalculatorHandler()
processor = Calculator.Processor(handler)
transport = TSocket.TServerSocket(9090)
begin
port = ARGV[0] || 9090
-
+
transport = TBufferedTransport.new(TSocket.new('localhost', port))
protocol = TBinaryProtocol.new(transport)
client = Calculator::Client.new(protocol)
* and can optionally inherit from another service using the extends keyword.
*/
service Calculator extends shared.SharedService {
-
+
/**
* A method definition looks like C code. It has a return type, arguments,
* and optionally a list of exceptions that it may throw. Note that argument
Code Review / common / thrift.git / commitdiff
