zeroc-ice 3.6b1

data/ext/ice/cpp/src/Ice/ReplyStatus.h

@@ -0,0 +1,29 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_REPLY_STATUS_H
+#define ICE_REPLY_STATUS_H
+
+#include <Ice/Config.h>
+
+namespace IceInternal
+{
+
+static const Ice::Byte replyOK = 0;
+static const Ice::Byte replyUserException = 1;
+static const Ice::Byte replyObjectNotExist = 2;
+static const Ice::Byte replyFacetNotExist = 3;
+static const Ice::Byte replyOperationNotExist = 4;
+static const Ice::Byte replyUnknownLocalException = 5;
+static const Ice::Byte replyUnknownUserException = 6;
+static const Ice::Byte replyUnknownException = 7;
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/RequestHandler.cpp

@@ -0,0 +1,40 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/RequestHandler.h>
+#include <Ice/Reference.h>
+
+using namespace std;
+using namespace IceInternal;
+
+IceUtil::Shared* IceInternal::upCast(RequestHandler* p) { return p; }
+IceUtil::Shared* IceInternal::upCast(CancellationHandler* p) { return p; }
+
+RetryException::RetryException(const Ice::LocalException& ex)
+{
+    _ex.reset(ex.ice_clone());
+}
+
+RetryException::RetryException(const RetryException& ex)
+{
+    _ex.reset(ex.get()->ice_clone());
+}
+
+const Ice::LocalException*
+RetryException::get() const
+{
+    assert(_ex.get());
+    return _ex.get();
+}
+
+RequestHandler::RequestHandler(const ReferencePtr& reference) :
+    _reference(reference),
+    _response(reference->getMode() == Reference::ModeTwoway)
+{
+}

data/ext/ice/cpp/src/Ice/RequestHandler.h

@@ -0,0 +1,90 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_REQUEST_HANDLER_H
+#define ICE_REQUEST_HANDLER_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/UniquePtr.h>
+
+#include <Ice/RequestHandlerF.h>
+#include <Ice/ReferenceF.h>
+#include <Ice/OutgoingAsyncF.h>
+#include <Ice/ProxyF.h>
+#include <Ice/ConnectionIF.h>
+
+namespace Ice
+{
+
+class LocalException;
+
+};
+
+namespace IceInternal
+{
+
+class BasicStream;
+
+class OutgoingBase;
+
+//
+// An exception wrapper, which is used to notify that the request
+// handler should be cleared and the invocation retried.
+//
+class RetryException
+{
+public:
+
+    RetryException(const Ice::LocalException&);
+    RetryException(const RetryException&);
+
+    const Ice::LocalException* get() const;
+
+private:
+
+    IceUtil::UniquePtr<Ice::LocalException> _ex;
+};
+
+class CancellationHandler : virtual public IceUtil::Shared
+{
+public:
+
+    virtual void requestCanceled(OutgoingBase*, const Ice::LocalException&) = 0;
+    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&) = 0;
+};
+
+class RequestHandler : public CancellationHandler
+{
+public:
+
+    virtual RequestHandlerPtr connect(const Ice::ObjectPrx&) = 0;
+    virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&) = 0;
+
+    virtual void prepareBatchRequest(BasicStream*) = 0;
+    virtual void finishBatchRequest(BasicStream*) = 0;
+    virtual void abortBatchRequest() = 0;
+
+    virtual bool sendRequest(OutgoingBase*) = 0;
+    virtual AsyncStatus sendAsyncRequest(const OutgoingAsyncBasePtr&) = 0;
+
+    const ReferencePtr& getReference() const { return _reference; } // Inlined for performances.
+
+    virtual Ice::ConnectionIPtr getConnection() = 0;
+    virtual Ice::ConnectionIPtr waitForConnection() = 0;
+
+protected:
+
+    RequestHandler(const ReferencePtr&);
+    const ReferencePtr _reference;
+    const bool _response;
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/RequestHandlerFactory.cpp

@@ -0,0 +1,70 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/RequestHandlerFactory.h>
+#include <Ice/CollocatedRequestHandler.h>
+#include <Ice/ConnectRequestHandler.h>
+#include <Ice/CollocatedRequestHandler.h>
+#include <Ice/Reference.h>
+#include <Ice/ObjectAdapterFactory.h>
+#include <Ice/Instance.h>
+
+using namespace std;
+using namespace IceInternal;
+
+RequestHandlerFactory::RequestHandlerFactory(const InstancePtr& instance) : _instance(instance)
+{
+}
+
+RequestHandlerPtr 
+IceInternal::RequestHandlerFactory::getRequestHandler(const ReferencePtr& ref, const Ice::ObjectPrx& proxy)
+{
+    if(ref->getCollocationOptimized())
+    {
+        Ice::ObjectAdapterPtr adapter = _instance->objectAdapterFactory()->findObjectAdapter(proxy);
+        if(adapter)
+        {
+            return new CollocatedRequestHandler(ref, adapter);
+        }
+    }
+
+    if(ref->getCacheConnection())
+    {
+        Lock sync(*this);
+        
+        map<ReferencePtr, RequestHandlerPtr>::iterator p = _handlers.find(ref);
+        if(p != _handlers.end())
+        {
+            return p->second;
+        }
+        
+        RequestHandlerPtr handler = new ConnectRequestHandler(ref, proxy);
+        _handlers.insert(make_pair(ref, handler));
+        return handler;
+    }
+    else
+    {
+        return new ConnectRequestHandler(ref, proxy);
+    }
+}
+
+void 
+IceInternal::RequestHandlerFactory::removeRequestHandler(const ReferencePtr& ref, const RequestHandlerPtr& handler)
+{
+    if(ref->getCacheConnection())
+    {
+        Lock sync(*this);
+        map<ReferencePtr, RequestHandlerPtr>::iterator p = _handlers.find(ref);
+        if(p != _handlers.end() && p->second.get() == handler.get())
+        {
+            _handlers.erase(p);
+        }
+    }
+}
+

data/ext/ice/cpp/src/Ice/RequestHandlerFactory.h

@@ -0,0 +1,41 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_REQUEST_HANDLER_FACTORY_H
+#define ICE_REQUEST_HANDLER_FACTORY_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Mutex.h>
+
+#include <Ice/RequestHandlerF.h>
+#include <Ice/ProxyF.h>
+#include <Ice/ReferenceF.h>
+#include <Ice/InstanceF.h>
+
+namespace IceInternal
+{
+
+class RequestHandlerFactory : public IceUtil::Shared, private IceUtil::Mutex
+{
+public:
+
+    RequestHandlerFactory(const InstancePtr&);
+    
+    RequestHandlerPtr getRequestHandler(const ReferencePtr&, const Ice::ObjectPrx&);
+    void removeRequestHandler(const ReferencePtr&, const RequestHandlerPtr&);
+
+private:
+
+    const InstancePtr _instance;
+    std::map<ReferencePtr, RequestHandlerPtr> _handlers;
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/ResponseHandler.cpp

@@ -0,0 +1,20 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/ResponseHandler.h>
+
+using namespace std;
+using namespace IceInternal;
+
+IceUtil::Shared* IceInternal::upCast(ResponseHandler* obj) { return obj; }
+
+ResponseHandler::~ResponseHandler()
+{
+}
+

data/ext/ice/cpp/src/Ice/ResponseHandler.h

@@ -0,0 +1,39 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_RESPONSE_HANDLER_H
+#define ICE_RESPONSE_HANDLER_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Handle.h>
+
+#include <Ice/Config.h>
+#include <Ice/LocalException.h>
+#include <Ice/ResponseHandlerF.h>
+
+namespace IceInternal
+{
+
+class BasicStream;
+
+class ResponseHandler : virtual public ::IceUtil::Shared
+{
+public:
+    
+    virtual ~ResponseHandler();
+    
+    virtual void sendResponse(Ice::Int, BasicStream*, Ice::Byte, bool) = 0;
+    virtual void sendNoResponse() = 0;
+    virtual bool systemException(Ice::Int, const Ice::SystemException&, bool) = 0;
+    virtual void invokeException(Ice::Int, const Ice::LocalException&, int, bool) = 0;
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/RetryQueue.cpp

@@ -0,0 +1,154 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <Ice/RetryQueue.h>
+#include <Ice/OutgoingAsync.h>
+#include <Ice/LocalException.h>
+#include <Ice/Instance.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceUtil::Shared* IceInternal::upCast(RetryQueue* p) { return p; }
+
+IceInternal::RetryTask::RetryTask(const RetryQueuePtr& queue, const ProxyOutgoingAsyncBasePtr& outAsync) :
+    _queue(queue), _outAsync(outAsync)
+{
+}
+
+void
+IceInternal::RetryTask::runTimerTask()
+{
+    _outAsync->retry(); // Retry again the invocation.
+
+    //
+    // NOTE: this must be called last, destroy() blocks until all task
+    // are removed to prevent the client thread pool to be destroyed
+    // (we still need the client thread pool at this point to call
+    // exception callbacks with CommunicatorDestroyedException).
+    //
+    _queue->remove(this);
+}
+
+void 
+IceInternal::RetryTask::requestCanceled(OutgoingBase*, const Ice::LocalException&)
+{
+    assert(false);
+}
+
+void
+IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const Ice::LocalException& ex)
+{
+    if(_queue->cancel(this))
+    {
+        if(_outAsync->completed(ex))
+        {
+            _outAsync->invokeCompletedAsync();
+        }
+    }
+}
+
+void
+IceInternal::RetryTask::destroy()
+{
+    try
+    {
+        _outAsync->abort(CommunicatorDestroyedException(__FILE__, __LINE__));
+    }
+    catch(const CommunicatorDestroyedException&)
+    {
+        // Abort can throw if there's no callback, ignore.
+    }
+}
+
+bool
+IceInternal::RetryTask::operator<(const RetryTask& rhs) const
+{
+    return this < &rhs;
+}
+
+IceInternal::RetryQueue::RetryQueue(const InstancePtr& instance) : _instance(instance)
+{
+}
+
+void
+IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
+{
+    Lock sync(*this);
+    if(!_instance)
+    {
+        throw CommunicatorDestroyedException(__FILE__, __LINE__);
+    }
+    RetryTaskPtr task = new RetryTask(this, out);
+    out->cancelable(task); // This will throw if the request is canceled.
+    try
+    {
+        _instance->timer()->schedule(task, IceUtil::Time::milliSeconds(interval));
+    }
+    catch(const IceUtil::IllegalArgumentException&) // Expected if the communicator destroyed the timer.
+    {
+        throw CommunicatorDestroyedException(__FILE__, __LINE__);
+    }
+    _requests.insert(task);
+}
+
+void
+IceInternal::RetryQueue::destroy()
+{
+    Lock sync(*this);
+    assert(_instance);
+
+    set<RetryTaskPtr>::const_iterator p = _requests.begin();
+    while(p != _requests.end())
+    {
+        if(_instance->timer()->cancel(*p))
+        {
+            (*p)->destroy();
+            _requests.erase(p++);
+        }
+        else
+        {
+            ++p;
+        }
+    }
+
+    _instance = 0;
+    while(!_requests.empty())
+    {
+        wait();
+    }
+}
+
+void
+IceInternal::RetryQueue::remove(const RetryTaskPtr& task)
+{
+    Lock sync(*this);
+    assert(_requests.find(task) != _requests.end());
+    _requests.erase(task);
+    if(!_instance && _requests.empty())
+    {
+        notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+    }
+}
+
+bool
+IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
+{
+    Lock sync(*this);
+    if(_requests.erase(task) > 0)
+    {
+        if(!_instance && _requests.empty())
+        {
+            notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+        }
+        return _instance->timer()->cancel(task);
+    }
+    return false;
+}