RCFProto
 All Classes Functions Typedefs
ClientStub.hpp
1 
2 //******************************************************************************
3 // RCF - Remote Call Framework
4 //
5 // Copyright (c) 2005 - 2013, Delta V Software. All rights reserved.
6 // http://www.deltavsoft.com
7 //
8 // RCF is distributed under dual licenses - closed source or GPL.
9 // Consult your particular license for conditions of use.
10 //
11 // If you have not purchased a commercial license, you are using RCF
12 // under GPL terms.
13 //
14 // Version: 2.0
15 // Contact: support <at> deltavsoft.com
16 //
17 //******************************************************************************
18 
19 #ifndef INCLUDE_RCF_CLIENTSTUB_HPP
20 #define INCLUDE_RCF_CLIENTSTUB_HPP
21 
22 #include <string>
23 #include <vector>
24 #include <memory>
25 
26 #include <boost/scoped_ptr.hpp>
27 #include <boost/any.hpp>
28 #include <boost/shared_ptr.hpp>
29 #include <boost/enable_shared_from_this.hpp>
30 
31 #include <RCF/ClientProgress.hpp>
32 #include <RCF/Filter.hpp>
33 #include <RCF/ClientTransport.hpp>
34 #include <RCF/Endpoint.hpp>
35 #include <RCF/Enums.hpp>
36 #include <RCF/Export.hpp>
37 #include <RCF/GetInterfaceName.hpp>
38 #include <RCF/MethodInvocation.hpp>
39 #include <RCF/OverlappedAmi.hpp>
40 #include <RCF/SerializationProtocol_Base.hpp>
41 #include <RCF/RecursionLimiter.hpp>
42 #include <RCF/SerializationProtocol.hpp>
43 #include <RCF/Token.hpp>
44 
45 #if RCF_FEATURE_FILETRANSFER==1
46 #include <RCF/FileStream.hpp>
47 #include <RCF/FileDownload.hpp>
48 #include <RCF/FileUpload.hpp>
49 #endif
50 
51 namespace RCF {
52 
53  template<typename T>
54  class FutureImpl;
55 
56  struct Void;
57 
58  class CallOptions;
59 
60  class ConnectionResetGuard;
61 
62  class I_Parameters;
63 
65  RCF_EXPORT void setDefaultSslImplementation(SslImplementation sslImplementation);
66 
68  RCF_EXPORT SslImplementation getDefaultSslImplementation();
69 
70  RCF_EXPORT void setDefaultConnectTimeoutMs(unsigned int connectTimeoutMs);
71  RCF_EXPORT unsigned int getDefaultConnectTimeoutMs();
72 
73  RCF_EXPORT void setDefaultRemoteCallTimeoutMs(unsigned int remoteCallTimeoutMs);
74  RCF_EXPORT unsigned int getDefaultRemoteCallTimeoutMs();
75 
76  RCF_EXPORT void setDefaultNativeWstringSerialization(bool enable);
77  RCF_EXPORT bool getDefaultNativeWstringSerialization();
78 
79  class ClientStub;
80 
81  typedef boost::shared_ptr<ClientStub> ClientStubPtr;
82 
83  typedef Token FileTransferToken;
84 
85  class ClientProgress;
86  typedef boost::shared_ptr<ClientProgress> ClientProgressPtr;
87 
88  class ClientTransport;
89  typedef std::auto_ptr<ClientTransport> ClientTransportAutoPtr;
90 
91  class I_RcfClient;
92  typedef boost::shared_ptr<I_RcfClient> RcfClientPtr;
93 
94  class I_Future;
95  class IpClientTransport;
96 
97  template<typename T>
98  class FutureImpl;
99 
100  class FileTransferProgress;
101 
102  class OpenSslEncryptionFilter;
103 
104  class SspiFilter;
105 
106  typedef boost::function1<void, const FileTransferProgress &> FileProgressCb;
107 
108  template<
109  typename R,
110  typename A1,
111  typename A2,
112  typename A3,
113  typename A4,
114  typename A5,
115  typename A6,
116  typename A7,
117  typename A8,
118  typename A9,
119  typename A10,
120  typename A11,
121  typename A12,
122  typename A13,
123  typename A14,
124  typename A15>
125  class AllocateClientParameters;
126 
127  template<
128  typename R,
129  typename A1,
130  typename A2,
131  typename A3,
132  typename A4,
133  typename A5,
134  typename A6,
135  typename A7,
136  typename A8,
137  typename A9,
138  typename A10,
139  typename A11,
140  typename A12,
141  typename A13,
142  typename A14,
143  typename A15>
144  class ClientParameters;
145 
146  class OverlappedAmi;
147  typedef boost::shared_ptr<OverlappedAmi> OverlappedAmiPtr;
148 
149  class InProcessTransport;
150 
151  class RCF_EXPORT CurrentClientStubSentry
152  {
153  public:
154  CurrentClientStubSentry(ClientStub & clientStub);
155  ~CurrentClientStubSentry();
156  };
157 
158  class RCF_EXPORT ClientStub :
159  public ClientTransportCallback,
160  public boost::enable_shared_from_this<ClientStub>
161  {
162  public:
163  ClientStub(const std::string &interfaceName);
164  ClientStub(const std::string &interfaceName, const std::string &objectName);
165  ClientStub(const ClientStub &rhs);
166  ~ClientStub();
167 
168  ClientStub &operator=(const ClientStub &rhs);
169 
170  void setEndpoint(const Endpoint &endpoint);
171  void setEndpoint(EndpointPtr endpointPtr);
172  EndpointPtr getEndpoint() const;
173  Token getTargetToken() const;
174  void setTargetToken(Token token);
175  const std::string & getTargetName() const;
176  void setTargetName(const std::string &targetName);
177  void setInterfaceName(const std::string & interfaceName);
178  const std::string & getInterfaceName();
179  RemoteCallSemantics getRemoteCallSemantics() const;
180  void setRemoteCallSemantics(RemoteCallSemantics defaultCallingSemantics);
181 
182  // Deprecated - use getRemoteCallSemantics()/setRemoteCallSemantics instead.
183  RemoteCallSemantics getDefaultCallingSemantics() const;
184  void setDefaultCallingSemantics(RemoteCallSemantics defaultCallingSemantics);
185 
186  void setSerializationProtocol(SerializationProtocol protocol);
187  SerializationProtocol getSerializationProtocol() const;
188 
189  void setMarshalingProtocol(MarshalingProtocol protocol);
190  MarshalingProtocol getMarshalingProtocol() const;
191 
192  bool getNativeWstringSerialization();
193  void setNativeWstringSerialization(bool enable);
194 
195  void setEnableSfPointerTracking(bool enable);
196  bool getEnableSfPointerTracking() const;
197 
198  void setTransport(ClientTransportAutoPtr transport);
199 
200  ClientTransport& getTransport();
201  IpClientTransport & getIpTransport();
202 
203  ClientTransportAutoPtr releaseTransport();
204 
205  void instantiateTransport();
206  void connect();
207  void connectAsync(boost::function0<void> onCompletion);
208  void wait(boost::function0<void> onCompletion, boost::uint32_t timeoutMs);
209  void disconnect();
210  bool isConnected();
211  void setConnected(bool connected);
212 
213  void setMessageFilters(const std::vector<FilterPtr> &filters);
214  void setMessageFilters();
215  void setMessageFilters(FilterPtr filterPtr);
216 
217  const std::vector<FilterPtr> &
218  getMessageFilters();
219 
220 
221  // Synchronous transport filter requests.
222  void requestTransportFilters(const std::vector<FilterPtr> &filters);
223  void requestTransportFilters(FilterPtr filterPtr);
224  void requestTransportFilters();
225 
226  void clearTransportFilters();
227 
228  // Asynchronous transport filter requests.
229  void requestTransportFiltersAsync(
230  const std::vector<FilterPtr> &filters,
231  boost::function0<void> onCompletion);
232 
233  void requestTransportFiltersAsync(
234  FilterPtr filterPtr,
235  boost::function0<void> onCompletion);
236 
237  void setRemoteCallTimeoutMs(unsigned int remoteCallTimeoutMs);
238  unsigned int getRemoteCallTimeoutMs() const;
239 
240  void setConnectTimeoutMs(unsigned int connectTimeoutMs);
241  unsigned int getConnectTimeoutMs() const;
242 
243  void setAutoReconnect(bool autoReconnect);
244  bool getAutoReconnect() const;
245 
246  void setAutoVersioning(bool autoVersioning);
247  bool getAutoVersioning() const;
248 
249  void setRuntimeVersion(boost::uint32_t version);
250  boost::uint32_t getRuntimeVersion() const;
251 
252  void setArchiveVersion(boost::uint32_t version);
253  boost::uint32_t getArchiveVersion() const;
254 
255  void setClientProgressPtr(ClientProgressPtr clientProgressPtr);
256 
257  ClientProgressPtr
258  getClientProgressPtr() const;
259 
260  typedef ClientProgress::ProgressCallback RemoteCallProgressCallback;
261 
262  void setRemoteCallProgressCallback(
263  RemoteCallProgressCallback cb,
264  boost::uint32_t callbackIntervalMs);
265 
266  void setTries(std::size_t tries);
267  std::size_t getTries() const;
268 
269  void setUserData(boost::any userData);
270  boost::any getUserData();
271 
272  //**********************************************************************
273  // These functions involve network calls.
274 
275  // Synchronous versions.
276 
277  void createRemoteObject(const std::string &objectName = "");
278  void deleteRemoteObject();
279 
280  void createRemoteSessionObject(const std::string &objectName = "");
281  void deleteRemoteSessionObject();
282 
283 #if RCF_FEATURE_FILETRANSFER==1
284  void setFileProgressCallback(FileProgressCb fileProgressCb);
285  void setFileProgressCallback() { setFileProgressCallback( FileProgressCb() ); }
286 
287  void uploadFiles(
288  const std::string & whichFile,
289  std::string & uploadId,
290  boost::uint32_t chunkSize,
291  boost::uint32_t transferRateBps,
292  boost::uint32_t sessionLocalId);
293 
294  void uploadFiles(
295  const FileManifest & whichFile,
296  std::string & uploadId,
297  boost::uint32_t chunkSize,
298  boost::uint32_t transferRateBps,
299  boost::uint32_t sessionLocalId);
300 
301  void downloadFiles(
302  const std::string & downloadLocation,
303  FileManifest & manifest,
304  boost::uint32_t chunkSize,
305  boost::uint32_t transferRateBps,
306  boost::uint32_t sessionLocalId);
307 
308  boost::uint32_t addUploadStream(FileUpload fileStream);
309  void processUploadStreams();
310 
311  boost::uint32_t addDownloadStream(FileDownload fileStream);
312 
313  // For testing.
314  void setTransferWindowS(boost::uint32_t transferWindowS);
315  boost::uint32_t getTransferWindowS();
316 #endif
317 
318  FutureImpl<Void> ping();
319  FutureImpl<Void> ping(const CallOptions & callOptions);
320 
321  //**********************************************************************
322 
323  void setPingBackIntervalMs(int pingBackIntervalMs);
324  int getPingBackIntervalMs();
325 
326  std::size_t getPingBackCount();
327  boost::uint32_t getPingBackTimeStamp();
328 
329  void clearParameters();
330 
331  SerializationProtocolIn & getSpIn();
332  SerializationProtocolOut & getSpOut();
333 
334  std::auto_ptr<Exception> getAsyncException();
335  void setAsyncException(std::auto_ptr<Exception>);
336  bool hasAsyncException();
337 
338  boost::uint32_t generatePollingTimeout(boost::uint32_t timeoutMs);
339  void onPollingTimeout();
340  void onUiMessage();
341 
342  friend class CallOptions;
343 
344  private:
345 
346  template<typename T>
347  friend class FutureImpl;
348 
349  template<
350  typename R,
351  typename A1,
352  typename A2,
353  typename A3,
354  typename A4,
355  typename A5,
356  typename A6,
357  typename A7,
358  typename A8,
359  typename A9,
360  typename A10,
361  typename A11,
362  typename A12,
363  typename A13,
364  typename A14,
365  typename A15>
366  friend class AllocateClientParameters;
367 
368  template<
369  typename R,
370  typename A1,
371  typename A2,
372  typename A3,
373  typename A4,
374  typename A5,
375  typename A6,
376  typename A7,
377  typename A8,
378  typename A9,
379  typename A10,
380  typename A11,
381  typename A12,
382  typename A13,
383  typename A14,
384  typename A15>
385  friend class ClientParameters;
386 
387  friend class InProcessTransport;
388 
389  Token mToken;
390  RemoteCallSemantics mDefaultCallingSemantics;
391  SerializationProtocol mProtocol;
392  MarshalingProtocol mMarshalingProtocol;
393  std::string mEndpointName;
394  std::string mObjectName;
395  std::string mInterfaceName;
396 
397  unsigned int mRemoteCallTimeoutMs;
398  unsigned int mConnectTimeoutMs;
399  bool mAutoReconnect;
400  bool mConnected;
401  std::size_t mTries;
402 
403  EndpointPtr mEndpoint;
404  ClientTransportAutoPtr mTransport;
405 
406  VectorFilter mMessageFilters;
407 
408  ClientProgressPtr mClientProgressPtr;
409 
410  bool mAutoVersioning;
411  boost::uint32_t mRuntimeVersion;
412  boost::uint32_t mArchiveVersion;
413 
414  bool mUseNativeWstringSerialization;
415  bool mEnableSfPointerTracking;
416 
417  std::vector<I_Future *> mFutures;
418  boost::any mUserData;
419 
420  MethodInvocationRequest mRequest;
421  SerializationProtocolIn mIn;
422  SerializationProtocolOut mOut;
423 
424  bool mAsync;
425  OverlappedAmi::AsyncOpType mAsyncOpType;
426  boost::function0<void> mAsyncCallback;
427  std::auto_ptr<Exception> mAsyncException;
428  unsigned int mEndTimeMs;
429  bool mRetry;
430  RemoteCallSemantics mRcs;
431  ByteBuffer mEncodedByteBuffer;
432  std::vector<ByteBuffer> mEncodedByteBuffers;
433 
434  std::vector<char> mRetValVec;
435  std::vector<char> mParametersVec;
436  I_Parameters * mpParameters;
437 
438  boost::uint32_t mPingBackIntervalMs;
439  boost::uint32_t mPingBackTimeStamp;
440  std::size_t mPingBackCount;
441 
442  boost::uint32_t mNextTimerCallbackMs;
443  boost::uint32_t mNextPingBackCheckMs;
444  boost::uint32_t mPingBackCheckIntervalMs;
445  boost::uint32_t mTimerIntervalMs;
446 
447  MutexPtr mSignalledMutexPtr;
448  ConditionPtr mSignalledConditionPtr;
449  LockPtr mSignalledLockPtr;
450 
451  bool mSignalled;
452 
453  Mutex mSubRcfClientMutex;
454  RcfClientPtr mSubRcfClientPtr;
455 
456  bool mBatchMode;
457  ReallocBufferPtr mBatchBufferPtr;
458  ReallocBuffer mBatchBufferTemp;
459  boost::uint32_t mBatchMaxMessageLength;
460  boost::uint32_t mBatchCount;
461  boost::uint32_t mBatchMessageCount;
462 
463  // Set to true if we need to set the transport protocol without disconnecting.
464  bool mSetTransportProtocol;
465 
466  void enrol(
467  I_Future *pFuture);
468 
469  void init(
470  const std::string & interfaceName,
471  int fnId,
472  RCF::RemoteCallSemantics rcs);
473 
474  void beginCall();
475 
476  void beginSend();
477 
478  void beginReceive();
479 
480  void call(
481  RCF::RemoteCallSemantics rcs);
482 
483  void onConnectCompleted(
484  bool alreadyConnected = false);
485 
486  void onRequestTransportFiltersCompleted();
487 
488  void doBatching();
489 
490  void onSendCompleted();
491 
492  void onReceiveCompleted();
493 
494  void onTimerExpired();
495 
496  void onError(
497  const std::exception &e);
498 
499  void setAsyncCallback(
500  boost::function0<void> callback);
501 
502  void onException(
503  const Exception & e);
504 
505  void scheduleAmiNotification();
506 
507  void createFilterSequence(std::vector<FilterPtr> & filters);
508 
509 
510  public:
511 
512  std::vector<char> & getRetValVec() { return mRetValVec; }
513 
514  // Batching
515 
516  void enableBatching();
517  void disableBatching(bool flush = true);
518  void flushBatch(unsigned int timeoutMs = 0);
519 
520  void setMaxBatchMessageLength(boost::uint32_t maxBatchMessageLength);
521  boost::uint32_t getMaxBatchMessageLength();
522 
523  boost::uint32_t getBatchesSent();
524  boost::uint32_t getMessagesInCurrentBatch();
525 
526  // Async
527 
528  void setAsync(bool async);
529  bool getAsync();
530 
531  bool ready();
532  void waitForReady(boost::uint32_t timeoutMs = 0);
533  void cancel();
534 
535  void setSubRcfClientPtr(RcfClientPtr clientStubPtr);
536  RcfClientPtr getSubRcfClientPtr();
537 
538  // User data
539 
540  void setRequestUserData(const std::string & userData);
541  std::string getRequestUserData();
542 
543  void setResponseUserData(const std::string & userData);
544  std::string getResponseUserData();
545 
546 #if RCF_FEATURE_FILETRANSFER==1
547  FileProgressCb mFileProgressCb;
548 
549  std::vector<FileUpload> mUploadStreams;
550  std::vector<FileDownload> mDownloadStreams;
551 #endif
552 
553  boost::uint32_t mTransferWindowS;
554 
555  RecursionState<int, int> mRecursionState;
556 
557  std::string mCurrentCallDesc;
558  bool mCallInProgress;
559 
560  public:
561 
562  void setHttpProxy(const std::string & httpProxy);
563  std::string getHttpProxy();
564 
565  void setHttpProxyPort(int httpProxyPort);
566  int getHttpProxyPort();
567 
568  void setTransportProtocol(TransportProtocol protocol);
569  TransportProtocol getTransportProtocol();
570 
571  TransportType getTransportType();
572 
573  void setUsername(const tstring & username);
574  tstring getUsername();
575 
576  void setPassword(const tstring & password);
577  tstring getPassword();
578 
579  void setKerberosSpn(const tstring & kerberosSpn);
580  tstring getKerberosSpn();
581 
582  void setEnableCompression(bool enableCompression);
583  bool getEnableCompression();
584 
585  void setCertificate(CertificatePtr certificatePtr);
586  CertificatePtr getCertificate();
587 
588  void setCaCertificate(CertificatePtr certificatePtr);
589  CertificatePtr getCaCertificate();
590 
591  void setOpenSslCipherSuite(const std::string & cipherSuite);
592  std::string getOpenSslCipherSuite() const;
593 
594  void setEnableSchannelCertificateValidation(const tstring & peerName);
595  tstring getEnableSchannelCertificateValidation() const;
596 
597  typedef boost::function<bool(Certificate *)> CertificateValidationCb;
598  void setCertificateValidationCallback(CertificateValidationCb certificateValidationCb);
599  const CertificateValidationCb & getCertificateValidationCallback() const;
600 
601  void setSslImplementation(SslImplementation sslImplementation);
602  SslImplementation getSslImplementation() const;
603 
604 #ifdef BOOST_WINDOWS
605  void setWindowsImpersonationToken(HANDLE hToken);
606  HANDLE getWindowsImpersonationToken() const;
607  private:
608  std::auto_ptr<HANDLE> mWindowsImpersonationToken;
609 #endif
610 
611  private:
612  std::string mHttpProxy;
613  int mHttpProxyPort;
614  TransportProtocol mTransportProtocol;
615  tstring mUsername;
616  tstring mPassword;
617  tstring mKerberosSpn;
618  bool mEnableCompression;
619 
620  CertificatePtr mCertificatePtr;
621  CertificatePtr mCaCertificatePtr;
622  CertificateValidationCb mCertificateValidationCb;
623  tstring mSchannelCertificateValidation;
624 
625  std::string mOpenSslCipherSuite;
626 
627  SslImplementation mSslImplementation;
628  };
629 
630  class CallOptions
631  {
632  public:
633  CallOptions() :
634  mAsync(false),
635  mRcsSpecified(false),
636  mRcs(Twoway),
637  mCallback()
638  {}
639 
640  CallOptions(RemoteCallSemantics rcs) :
641  mAsync(false),
642  mRcsSpecified(true),
643  mRcs(rcs),
644  mCallback()
645  {}
646 
647  CallOptions(RemoteCallSemantics rcs, const boost::function0<void> & callback) :
648  mAsync(true),
649  mRcsSpecified(true),
650  mRcs(rcs),
651  mCallback(callback)
652  {}
653 
654  CallOptions(boost::function0<void> callback) :
655  mAsync(true),
656  mRcsSpecified(false),
657  mRcs(Twoway),
658  mCallback(callback)
659  {}
660 
661  RemoteCallSemantics apply(ClientStub &clientStub) const
662  {
663  clientStub.setAsync(mAsync);
664  clientStub.setAsyncCallback(mCallback);
665  return mRcsSpecified ? mRcs : clientStub.getRemoteCallSemantics();
666  }
667 
668  private:
669  bool mAsync;
670  bool mRcsSpecified;
671  RemoteCallSemantics mRcs;
672  boost::function0<void> mCallback;
673  };
674 
675  class RCF_EXPORT AsyncTwoway : public CallOptions
676  {
677  public:
678  AsyncTwoway(const boost::function0<void> & callback) :
679  CallOptions(RCF::Twoway, callback)
680  {}
681  };
682 
683  class RCF_EXPORT AsyncOneway : public CallOptions
684  {
685  public:
686  AsyncOneway(const boost::function0<void> & callback) :
687  CallOptions(RCF::Oneway, callback)
688  {}
689  };
690 
691  class RestoreClientTransportGuard
692  {
693  public:
694 
695  RestoreClientTransportGuard(ClientStub &client, ClientStub &clientTemp) :
696  mClient(client),
697  mClientTemp(clientTemp)
698  {}
699 
700  ~RestoreClientTransportGuard()
701  {
702  RCF_DTOR_BEGIN
703  mClient.setTransport(mClientTemp.releaseTransport());
704  RCF_DTOR_END
705  }
706 
707  private:
708  ClientStub &mClient;
709  ClientStub &mClientTemp;
710  };
711 
712 
713 } // namespace RCF
714 
715 #endif // ! INCLUDE_RCF_CLIENTSTUB_HPP
Generated by   doxygen 1.8.3.1