zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_THREAD_POOL_H
 #define ICE_THREAD_POOL_H
@@ -23,7 +18,7 @@
 #include <Ice/PropertiesF.h>
 #include <Ice/EventHandler.h>
 #include <Ice/Selector.h>
-#include <Ice/BasicStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/ObserverHelper.h>
 
 #include <set>
@@ -35,12 +30,12 @@ namespace IceInternal
 class ThreadPoolCurrent;
 
 class ThreadPoolWorkQueue;
-typedef IceUtil::Handle<ThreadPoolWorkQueue> ThreadPoolWorkQueuePtr;
+ICE_DEFINE_PTR(ThreadPoolWorkQueuePtr, ThreadPoolWorkQueue);
 
-class ThreadPoolWorkItem : virtual public IceUtil::Shared
+class ThreadPoolWorkItem : public virtual IceUtil::Shared
 {
 public:
-    
+
     virtual void execute(ThreadPoolCurrent&) = 0;
 };
 typedef IceUtil::Handle<ThreadPoolWorkItem> ThreadPoolWorkItemPtr;
@@ -51,8 +46,8 @@ public:
 
     DispatchWorkItem();
     DispatchWorkItem(const Ice::ConnectionPtr& connection);
- 
-    const Ice::ConnectionPtr& 
+
+    const Ice::ConnectionPtr&
     getConnection()
     {
         return _connection;
@@ -66,18 +61,18 @@ private:
 };
 typedef IceUtil::Handle<DispatchWorkItem> DispatchWorkItemPtr;
 
-class ThreadPool : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex>
+class ThreadPool : public IceUtil::Shared, private IceUtil::Monitor<IceUtil::Mutex>
 {
     class EventHandlerThread : public IceUtil::Thread
     {
     public:
-        
+
         EventHandlerThread(const ThreadPoolPtr&, const std::string&);
         virtual void run();
 
         void updateObserver();
         void setState(Ice::Instrumentation::ThreadState);
-        
+
     private:
 
         ThreadPoolPtr _pool;
@@ -106,6 +101,7 @@ public:
         update(handler, status, SocketOperationNone);
     }
     bool finish(const EventHandlerPtr&, bool);
+    void ready(const EventHandlerPtr&, SocketOperation, bool);
 
     void dispatchFromThisThread(const DispatchWorkItemPtr&);
     void dispatch(const DispatchWorkItemPtr&);
@@ -114,13 +110,17 @@ public:
 
     std::string prefix() const;
 
+#ifdef ICE_SWIFT
+    dispatch_queue_t getDispatchQueue() const ICE_NOEXCEPT;
+#endif
+
 private:
 
     void run(const EventHandlerThreadPtr&);
 
     bool ioCompleted(ThreadPoolCurrent&);
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startMessage(ThreadPoolCurrent&);
     void finishMessage(ThreadPoolCurrent&);
 #else
@@ -131,7 +131,15 @@ private:
     std::string nextThreadId();
 
     const InstancePtr _instance;
+#ifdef ICE_SWIFT
+    const dispatch_queue_t _dispatchQueue;
+#else // Ice for Swift does not support a dispatcher
+#   ifdef ICE_CPP11_MAPPING
+    std::function<void(std::function<void()>, const std::shared_ptr<Ice::Connection>&)> _dispatcher;
+#   else
     const Ice::DispatcherPtr _dispatcher;
+#   endif
+#endif
     ThreadPoolWorkQueuePtr _workQueue;
     bool _destroyed;
     const std::string _prefix;
@@ -140,6 +148,7 @@ private:
 
     friend class EventHandlerThread;
     friend class ThreadPoolCurrent;
+    friend class ThreadPoolWorkQueue;
 
     const int _size; // Number of threads that are pre-created.
     const int _sizeIO; // Maximum number of threads that can concurrently perform IO.
@@ -154,11 +163,10 @@ private:
 
     std::set<EventHandlerThreadPtr> _threads; // All threads, running or not.
     int _inUse; // Number of threads that are currently in use.
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     int _inUseIO; // Number of threads that are currently performing IO.
     std::vector<std::pair<EventHandler*, SocketOperation> > _handlers;
     std::vector<std::pair<EventHandler*, SocketOperation> >::const_iterator _nextHandler;
-    std::set<EventHandler*> _pendingHandlers;
 #endif
 
     bool _promote;
@@ -171,14 +179,14 @@ public:
     ThreadPoolCurrent(const InstancePtr&, const ThreadPoolPtr&, const ThreadPool::EventHandlerThreadPtr&);
 
     SocketOperation operation;
-    BasicStream stream; // A per-thread stream to be used by event handlers for optimization.
+    Ice::InputStream stream; // A per-thread stream to be used by event handlers for optimization.
 
     bool ioCompleted() const
     {
         return _threadPool->ioCompleted(const_cast<ThreadPoolCurrent&>(*this));
     }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startMessage()
     {
         return _threadPool->startMessage(const_cast<ThreadPoolCurrent&>(*this));
@@ -206,7 +214,7 @@ private:
     ThreadPool::EventHandlerThreadPtr _thread;
     EventHandlerPtr _handler;
     bool _ioCompleted;
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     bool _leader;
 #else
     DWORD _count;
@@ -215,17 +223,16 @@ private:
     friend class ThreadPool;
 };
 
-class ThreadPoolWorkQueue : public EventHandler, public IceUtil::Mutex
+class ThreadPoolWorkQueue : public EventHandler
 {
 public:
 
-    ThreadPoolWorkQueue(const InstancePtr&, Selector&);
-    ~ThreadPoolWorkQueue();
+    ThreadPoolWorkQueue(ThreadPool&);
 
     void destroy();
     void queue(const ThreadPoolWorkItemPtr&);
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startAsync(SocketOperation);
     bool finishAsync(SocketOperation);
 #endif
@@ -234,19 +241,11 @@ public:
     virtual void finished(ThreadPoolCurrent&, bool);
     virtual std::string toString() const;
     virtual NativeInfoPtr getNativeInfo();
-    virtual void postMessage();
 
 private:
 
-    const InstancePtr _instance;
-    Selector& _selector;
+    ThreadPool& _threadPool;
     bool _destroyed;
-#ifdef ICE_USE_IOCP
-    AsyncInfo _info;
-#elif !defined(ICE_OS_WINRT)
-    SOCKET _fdIntrRead;
-    SOCKET _fdIntrWrite;
-#endif
     std::list<ThreadPoolWorkItemPtr> _workItems;
 };
 
@@ -257,10 +256,10 @@ private:
 //
 // An instance of the IOScope subclass must be created within the synchronization
 // of the event handler. It takes care of calling startMessage/finishMessage for
-// the IOCP implementation and ensures that finishMessage isn't called multiple 
+// the IOCP implementation and ensures that finishMessage isn't called multiple
 // times.
 //
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
 template<class T> class ThreadPoolMessage
 {
 public:
@@ -290,7 +289,7 @@ public:
         }
 
     private:
-        
+
         ThreadPoolMessage<T>& _message;
     };
     friend class IOScope;
@@ -309,7 +308,7 @@ private:
     ThreadPoolCurrent& _current;
 };
 
-#else 
+#else
 
 template<class T> class ThreadPoolMessage
 {
@@ -321,7 +320,7 @@ public:
 
         IOScope(ThreadPoolMessage& message) : _message(message)
         {
-            // This must be called with the handler locked. 
+            // This must be called with the handler locked.
             _finish = _message._current.startMessage();
         }
 
@@ -329,7 +328,7 @@ public:
         {
             if(_finish)
             {
-                // This must be called with the handler locked. 
+                // This must be called with the handler locked.
                 _message._current.finishMessage();
             }
         }
@@ -344,7 +343,7 @@ public:
         {
             //
             // Call finishMessage once IO is completed only if serialization is not enabled.
-            // Otherwise, finishMessage will be called when the event handler is done with 
+            // Otherwise, finishMessage will be called when the event handler is done with
             // the message (it will be called from ~ThreadPoolMessage below).
             //
             assert(_finish);
@@ -358,22 +357,22 @@ public:
     private:
 
         ThreadPoolMessage& _message;
-        bool _finish;        
+        bool _finish;
     };
     friend class IOScope;
-    
-    ThreadPoolMessage(ThreadPoolCurrent& current, const T& mutex) : 
+
+    ThreadPoolMessage(ThreadPoolCurrent& current, const T& mutex) :
         _current(current), _mutex(mutex), _finish(false)
     {
     }
-            
+
     ~ThreadPoolMessage()
     {
         if(_finish)
         {
             //
             // A ThreadPoolMessage instance must be created outside the synchronization
-            // of the event handler. We need to lock the event handler here to call 
+            // of the event handler. We need to lock the event handler here to call
             // finishMessage.
             //
 #if defined(__MINGW32__)
@@ -386,7 +385,7 @@ public:
     }
 
 private:
-    
+
     ThreadPoolCurrent& _current;
     const T& _mutex;
     bool _finish;
@@ -395,5 +394,4 @@ private:
 
 };
 
-
 #endif

data/ext/ice/cpp/src/{IceUtil → Ice}/Timer.cpp

@@ -1,17 +1,19 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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 <IceUtil/Timer.h>
 #include <IceUtil/Exception.h>
+#include <Ice/ConsoleUtil.h>
 
 using namespace std;
 using namespace IceUtil;
+using namespace IceInternal;
+
+TimerTask::~TimerTask()
+{
+    // Out of line to avoid weak vtable
+}
 
 Timer::Timer() :
     Thread("IceUtil timer thread"),
@@ -75,7 +77,7 @@ Timer::schedule(const TimerTaskPtr& task, const IceUtil::Time& delay)
     bool inserted = _tasks.insert(make_pair(task, time)).second;
     if(!inserted)
     {
-        throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
+        throw IllegalArgumentException(__FILE__, __LINE__, "task is already scheduled");
     }
     _tokens.insert(Token(time, IceUtil::Time(), task));
 
@@ -96,7 +98,7 @@ Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
 
     IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
     const Token token(now + delay, delay, task);
-    if(delay > IceUtil::Time() && token.scheduledTime < now) 
+    if(delay > IceUtil::Time() && token.scheduledTime < now)
     {
         throw IllegalArgumentException(__FILE__, __LINE__, "invalid delay");
     }
@@ -104,10 +106,10 @@ Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
     bool inserted = _tasks.insert(make_pair(task, token.scheduledTime)).second;
     if(!inserted)
     {
-        throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
+        throw IllegalArgumentException(__FILE__, __LINE__, "task is already scheduled");
     }
-    _tokens.insert(token); 
-   
+    _tokens.insert(token);
+
     if(_wakeUpTime == IceUtil::Time() || token.scheduledTime < _wakeUpTime)
     {
         _monitor.notify();
@@ -168,12 +170,12 @@ Timer::run()
                     _monitor.wait();
                 }
             }
-            
+
             if(_destroyed)
             {
                 break;
             }
-            
+
             while(!_tokens.empty() && !_destroyed)
             {
                 const IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
@@ -188,22 +190,22 @@ Timer::run()
                     }
                     break;
                 }
-                
+
                 _wakeUpTime = first.scheduledTime;
-                try 
+                try
                 {
                     _monitor.timedWait(first.scheduledTime - now);
-                } 
+                }
                 catch(const IceUtil::InvalidTimeoutException&)
                 {
                     IceUtil::Time timeout = (first.scheduledTime - now) / 2;
                     while(timeout > IceUtil::Time())
                     {
-                        try 
+                        try
                         {
                             _monitor.timedWait(timeout);
                             break;
-                        } 
+                        }
                         catch(const IceUtil::InvalidTimeoutException&)
                         {
                             timeout = timeout / 2;
@@ -216,7 +218,7 @@ Timer::run()
             {
                 break;
             }
-        }     
+        }
 
         if(token.task)
         {
@@ -226,19 +228,29 @@ Timer::run()
             }
             catch(const IceUtil::Exception& e)
             {
-                cerr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what();
+                consoleErr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what();
 #ifdef __GNUC__
-                cerr << "\n" << e.ice_stackTrace();
+                consoleErr << "\n" << e.ice_stackTrace();
 #endif
-                cerr << endl;
-            } 
+                consoleErr << endl;
+            }
             catch(const std::exception& e)
             {
-                cerr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what() << endl;
-            } 
+                consoleErr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what() << endl;
+            }
             catch(...)
             {
-                cerr << "IceUtil::Timer::run(): uncaught exception" << endl;
+                consoleErr << "IceUtil::Timer::run(): uncaught exception" << endl;
+            }
+
+            if(token.delay == IceUtil::Time())
+            {
+                //
+                // If thisthe task is not a repeated task, clear the task reference now rather than
+                // in the synchronization block above. Clearing the task reference might end up
+                // calling user code which could trigger a deadlock. See also issue #352.
+                //
+                token.task = ICE_NULLPTR;
             }
         }
     }

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/TraceLevels.h>
 #include <Ice/Properties.h>
@@ -14,7 +9,7 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-ICE_API IceUtil::Shared* IceInternal::upCast(TraceLevels* p) { return p; }
+IceUtil::Shared* IceInternal::upCast(TraceLevels* p) { return p; }
 
 IceInternal::TraceLevels::TraceLevels(const PropertiesPtr& properties) :
     network(0),