अपाचे थ्रिफ्ट आरपीसी सर्वर। दोस्तों C ++ और Java

हाय साथियों!
इस विषय में मैं अपने शिल्पों को थ्रिफ्ट को जल्दी से जल्दी कैसे करना है, इस पर निर्देश देना चाहता हूं।
थ्रिफ्ट सिस्टम घटकों के बीच इंटरप्रोसेस संचार के आयोजन के लिए एक तकनीक है। इसे फेसबुक के बाउल में कहीं विकसित किया गया था। यह बाइनरी प्रोटोकॉल पर RPC सेवाएं बनाने के लिए एक क्रॉस-लैंग्वेज फ्रेमवर्क है। इस समाधान के साथ, आप विभिन्न भाषाओं C #, C ++, Delphi, Erlang, Go, Java, PHP, Python, Ruby, आदि में "मित्र बना सकते हैं" घटक बना सकते हैं। सेवा और डेटा हस्ताक्षर का विवरण एक विशेष आईडीएल भाषा का उपयोग करके किया जाता है। प्रौद्योगिकी, संक्षेप में, COM के समान है, लेकिन घटक पंजीकरण के साथ इस बंधन के बिना। इसके अलावा, यह न भूलें कि COM एक विंडोज-ओनली तकनीक है, जबकि थ्रिफ्ट क्रॉस-प्लेटफॉर्म है।

सामान्य तौर पर, मैंने प्रयोग करने का निर्णय लिया, जावा से C ++ में कुछ लोड-कम्प्यूटेशनल तर्क निकालने की कोशिश की, इस उम्मीद में कि देशी C ++ कोड थोड़ा अधिक उत्पादक होगा, और एक के लिए थ्रिफ्ट RPC का प्रयास करें, इस उम्मीद में कि यह REST से तेज है।
जैसा कि यह होना चाहिए, कुछ तंबू और रेक थे!

और इसलिए, पहले आपको यह सब करने की आवश्यकता है:
1. हमने बूस्ट का समर्थन किया, क्योंकि सब कुछ इसके लिए बंधा हुआ है

$ sudo apt-get install libboost-dev libboost-test-dev libboost-program-options-dev libevent-dev automake libtool flex bison pkg-config g++ libssl-dev 

2. थ्रिफ्ट टारबॉल अपाचे डाउनलोड करें। softded.ru/thrift/0.9.0/thrift-0.9.0.tx.z
अनपैक, कॉन्फ़िगर करें और फिर इकट्ठा करें।

 $ ./configure $ make $ sudo make install 

यह सब प्रतीत होता है ... आप यहां तक ​​कि थ्रिफ्ट टारबॉल के साथ आने वाले ट्यूटोरियल से कोड उत्पन्न करने का प्रयास कर सकते हैं

 $ thrift --gen cpp tutorial.thrift 

थ्रिफ्ट कमांड C ++ रैपर उत्पन्न करेगा, और ध्यान से उन्हें जीन-सीपीपी डायरेक्टरी में डाल देगा। वही जावा, पीएचपी, आदि के लिए किया जा सकता है ...
हम उत्पन्न स्रोत को संकलित करने और संकलित करने का प्रयास करते हैं

 $ g++ -Wall -I/usr/local/include/thrift *.cpp -L/usr/local/lib -lthrift -o something 

ओह, प्राप्त करें: त्रुटि: 'uint32_t' एक प्रकार का नाम नहीं देता है
यह पता चला है कि uint32_t के साथ जुड़े थ्रू लाइब्रेरी में एक छोटा कॉकरोच है। इसका इलाज "#include <stdint.h>" को "Thrift.h", या (सबसे अच्छा) विशेष संकलक विकल्पों -DHAVE_NETINET_IN_H -DHAVE_INTTYRES_H को जोड़कर किया जाता है

अब यह इस तरह दिखता है:

 $ g++ -DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H -Wall -I/usr/local/include/thrift *.cpp -L/usr/local/lib -lthrift -o something 

यह सब, एक निष्पादन योग्य फ़ाइल जिसे कुछ कहा जाता है, दिखाई दिया।
हम शुरू करते हैं और प्राप्त करते हैं: साझा पुस्तकालयों को लोड करते समय त्रुटि: libthrift.so.0: साझा किए गए ऑब्जेक्ट फ़ाइल को नहीं खोल सकते: ऐसी कोई फ़ाइल या निर्देशिका नहीं
इस समस्या को हल करने के लिए कुछ सुरुचिपूर्ण तरीके हो सकते हैं, लेकिन मैंने इसे / usr / local / lib / / lib से थ्रिफ्ट फ़ाइलों की प्रतिलिपि बनाकर इसे हल किया

यह है, उदाहरण शुरू हुआ। तो, सब कुछ जगह में है, और सब कुछ काम करता है।

अब आप अपना RPC सर्वर लिख सकते हैं।
इसका कार्य एक कुंजी-मूल्य रिपॉजिटरी होना है। स्टोर लंबे (कई सौ हजार) बिट मास्क। उन्हें (और) जोड़ें, और ग्राहक को सूचकांकों की एक सरणी दें, जो इकाइयों को बाहर कर दिया। हां, रेडिस लगभग एक ही काम कर सकता है, लेकिन यह मुझे शोभा नहीं देता।

पूरा कोड यहाँ है: github.com/2anikulin/fast-hands.git

हम डेटा और सेवाओं के हस्ताक्षर का वर्णन थ्रिफ्ट परिभाषा फ़ाइल में करते हैं :

 namespace cpp fasthands namespace java fasthands namespace php fasthands namespace perl fasthands exception InvalidOperation { 1: i32 what, 2: string why } service FastHandsService { i32 put(1:i32 key, 2:binary value), binary get(1:i32 key), list <i32> bitAnd(1:list<i32> keys) throws (1:InvalidOperation ouch) } 

और रैपर तैयार करते हैं।
C ++ कार्यान्वयन
यह कोड RPC सर्वर बनाता और शुरू करता है

 #define PORT 9090 #define THREAD_POOL_SIZE 15 int main() { printf("FastHands Server started\n"); shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); shared_ptr<FastHandsHandler> handler(new FastHandsHandler()); shared_ptr<TProcessor> processor(new FastHandsServiceProcessor(handler)); shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(THREAD_POOL_SIZE); shared_ptr<PosixThreadFactory> threadFactory = shared_ptr<PosixThreadFactory>(new PosixThreadFactory()); threadManager->threadFactory(threadFactory); threadManager->start(); TNonblockingServer server(processor, protocolFactory, PORT, threadManager); server.serve(); printf("done.\n"); return 0; } 

FastHandsHandler वर्ग में - हमारी सभी लागू कार्यक्षमता कार्यान्वित की जाती है
यह हैडर फाइल है।

 class FastHandsHandler : virtual public FastHandsServiceIf { public: FastHandsHandler(); int32_t put(const int32_t key, const std::string& value); void get(std::string& _return, const int32_t key); void bitAnd(std::vector<int32_t> & _return, const std::vector<int32_t> & keys); private: void appendBitPositions(std::vector<int32_t> & positions, unsigned char bits, int offset); private: std::map<int32_t, std::string> m_store; }; 

हम इकट्ठा करने की कोशिश करते हैं, और हमें एक और त्रुटि मिलती है: c ++ अपाचे संदर्भ के लिए अपाचे :: थ्रिफ्ट :: सर्वर :: TNonblockedServer
तथ्य यह है कि, ट्यूटोरियल के विपरीत, मेरा सर्वर अतुल्यकालिक है और TNonblockingServer वर्ग का उपयोग करता है। निर्मित किए जाने वाले कोड के लिए, अतिरिक्त लाइब्रेरी जोड़ें -Lthriftnb -levent

यानी अब विधानसभा इस तरह दिखेगी:

 g++ -DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H -Wall -I/usr/local/include/thrift *.cpp -L/usr/local/lib -lthrift -lthriftnb -levent -o something 

अब सब ठीक है। कोड संकलित है, जुड़ा हुआ है, आउटपुट फ़ाइल को कुछ कहा जाता है
हम जावा के लिए रैपर उत्पन्न करते हैं, और हम ऐसे क्लाइंट लिखते हैं

 import fasthands.FastHandsService; import fasthands.InvalidOperation; import org.apache.thrift.TException; import org.apache.thrift.transport.TFramedTransport; import org.apache.thrift.transport.TTransport; import org.apache.thrift.transport.TSocket; import org.apache.thrift.transport.TTransportException; import org.apache.thrift.protocol.TBinaryProtocol; import org.apache.thrift.protocol.TProtocol; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.List; public class JavaClient { public static void main(String [] args) { TTransport transport = new TFramedTransport(new TSocket("localhost", 9090)); TProtocol protocol = new TBinaryProtocol(transport); final FastHandsService.Client client = new FastHandsService.Client(protocol); final List<Integer> filters = new ArrayList<Integer>(); try { transport.open(); int count = 12500; byte bt[] = new byte[count]; for (int i =0; i < count; i++) { bt[i] = (byte)0xFF; } for (int i = 0; i < 50; i++) { client.put(i, ByteBuffer.wrap(bt)) ; filters.add(i); } List<Integer> list = client.bitAnd(filters); System.out.println(list.size()); } catch (TTransportException e) { e.printStackTrace(); } catch (TException e) { e.printStackTrace(); } transport.close(); } } 

परिणाम क्या है?
एक दिलचस्प तकनीक, और नंगे सी ++ कोड के लिए परिवहन कार्यक्षमता को तेज करने का एक बुरा तरीका नहीं है। लेकिन मैं यह नहीं कहूंगा कि यह REST की तुलना में बहुत तेज है, बाइनरी डेटा भी http के माध्यम से खूबसूरती से प्रसारित होता है। जावा से C ++ में लिए गए कोड के प्रदर्शन के लिए, एक चमत्कार नहीं हुआ, यह 1.2 - 1.4 गुना तेज है, क्योंकि परिवहन स्तर के लिए क्रमांकन + व्यय।