PyObject*
IcePy::getCommunicatorWrapper(const Ice::CommunicatorPtr& communicator)
{
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
assert(p != _communicatorMap.end());
CommunicatorObject* obj = reinterpret_cast<CommunicatorObject*>(p->second);
Py_INCREF(obj->wrapper);
return obj->wrapper;
}
PyObject*
IcePy::createCommunicator(const Ice::CommunicatorPtr& communicator)
{
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
if(p != _communicatorMap.end())
{
Py_INCREF(p->second);
return p->second;
}
CommunicatorObject* obj = communicatorNew(&CommunicatorType, 0, 0);
if(obj)
{
obj->communicator = new Ice::CommunicatorPtr(communicator);
}
return (PyObject*)obj;
}
PyObject*
IcePy::getCommunicatorWrapper(const Ice::CommunicatorPtr& communicator)
{
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
assert(p != _communicatorMap.end());
CommunicatorObject* obj = reinterpret_cast<CommunicatorObject*>(p->second);
if(obj->wrapper)
{
Py_INCREF(obj->wrapper);
return obj->wrapper;
}
else
{
//
// Communicator must have been destroyed already.
//
Py_INCREF(Py_None);
return Py_None;
}
}
ZEND_METHOD(Ice_Communicator, destroy)
{
CommunicatorInfoIPtr _this = Wrapper<CommunicatorInfoIPtr>::value(getThis() TSRMLS_CC);
assert(_this);
//
// Remove all registrations.
//
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_registeredCommunicatorsMutex);
for(vector<string>::iterator p = _this->ac->ids.begin(); p != _this->ac->ids.end(); ++p)
{
_registeredCommunicators.erase(*p);
}
_this->ac->ids.clear();
}
//
// We need to destroy any object factories installed by this request.
//
_this->destroyObjectFactories(TSRMLS_C);
Ice::CommunicatorPtr c = _this->getCommunicator();
assert(c);
CommunicatorMap* m = reinterpret_cast<CommunicatorMap*>(ICE_G(communicatorMap));
assert(m);
assert(m->find(c) != m->end());
m->erase(c);
try
{
c->destroy();
}
catch(const IceUtil::Exception& ex)
{
throwException(ex TSRMLS_CC);
RETURN_NULL();
}
}
static void
communicatorDealloc(CommunicatorObject* self)
{
if(self->communicator)
{
CommunicatorMap::iterator p = _communicatorMap.find(*self->communicator);
//
// find() can fail if an error occurred during communicator initialization.
//
if(p != _communicatorMap.end())
{
_communicatorMap.erase(p);
}
}
if(self->shutdownThread)
{
(*self->shutdownThread)->getThreadControl().join();
}
delete self->communicator;
delete self->shutdownMonitor;
delete self->shutdownThread;
Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
}
static int
communicatorInit(CommunicatorObject* self, PyObject* args, PyObject* /*kwds*/)
{
//
// The argument options are:
//
// Ice.initialize()
// Ice.initialize(args)
// Ice.initialize(initData)
// Ice.initialize(configFile)
// Ice.initialize(args, initData)
// Ice.initialize(args, configFile)
//
PyObject* arg1 = 0;
PyObject* arg2 = 0;
if(!PyArg_ParseTuple(args, STRCAST("|OO"), &arg1, &arg2))
{
return -1;
}
PyObject* argList = 0;
PyObject* initData = 0;
PyObject* configFile = 0;
if(arg1 == Py_None)
{
arg1 = 0;
}
if(arg2 == Py_None)
{
arg2 = 0;
}
PyObject* initDataType = lookupType("Ice.InitializationData");
if(arg1)
{
if(PyList_Check(arg1))
{
argList = arg1;
}
else if(PyObject_IsInstance(arg1, initDataType))
{
initData = arg1;
}
else if(checkString(arg1))
{
configFile = arg1;
}
else
{
PyErr_Format(PyExc_ValueError,
STRCAST("initialize expects an argument list, Ice.InitializationData or a configuration filename"));
return -1;
}
}
if(arg2)
{
if(PyList_Check(arg2))
{
if(argList)
{
PyErr_Format(PyExc_ValueError, STRCAST("unexpected list argument to initialize"));
return -1;
}
argList = arg2;
}
else if(PyObject_IsInstance(arg2, initDataType))
{
if(initData)
{
PyErr_Format(PyExc_ValueError, STRCAST("unexpected Ice.InitializationData argument to initialize"));
return -1;
}
initData = arg2;
}
else if(checkString(arg2))
{
if(configFile)
{
PyErr_Format(PyExc_ValueError, STRCAST("unexpected string argument to initialize"));
return -1;
}
configFile = arg2;
}
else
{
PyErr_Format(PyExc_ValueError,
STRCAST("initialize expects an argument list, Ice.InitializationData or a configuration filename"));
return -1;
}
}
if(initData && configFile)
{
PyErr_Format(PyExc_ValueError,
STRCAST("initialize accepts either Ice.InitializationData or a configuration filename"));
return -1;
}
Ice::StringSeq seq;
if(argList && !listToStringSeq(argList, seq))
{
return -1;
}
Ice::InitializationData data;
DispatcherPtr dispatcherWrapper;
try
{
if(initData)
{
PyObjectHandle properties = getAttr(initData, "properties", false);
PyObjectHandle logger = getAttr(initData, "logger", false);
PyObjectHandle threadHook = getAttr(initData, "threadHook", false);
PyObjectHandle threadStart = getAttr(initData, "threadStart", false);
PyObjectHandle threadStop = getAttr(initData, "threadStop", false);
PyObjectHandle batchRequestInterceptor = getAttr(initData, "batchRequestInterceptor", false);
PyObjectHandle dispatcher = getAttr(initData, "dispatcher", false);
if(properties.get())
{
//
// Get the properties implementation.
//
PyObjectHandle impl = getAttr(properties.get(), "_impl", false);
assert(impl.get());
data.properties = getProperties(impl.get());
}
if(logger.get())
{
data.logger = new LoggerWrapper(logger.get());
}
if(threadHook.get() || threadStart.get() || threadStop.get())
{
data.threadHook = new ThreadHook(threadHook.get(), threadStart.get(), threadStop.get());
}
if(dispatcher.get())
{
dispatcherWrapper = new Dispatcher(dispatcher.get());
data.dispatcher = dispatcherWrapper;
}
if(batchRequestInterceptor.get())
{
data.batchRequestInterceptor = new BatchRequestInterceptor(batchRequestInterceptor.get());
}
}
//
// We always supply our own implementation of ValueFactoryManager.
//
data.valueFactoryManager = new ValueFactoryManager;
if(!data.properties)
{
data.properties = Ice::createProperties();
}
if(configFile)
{
data.properties->load(getString(configFile));
}
if(argList)
{
data.properties = Ice::createProperties(seq, data.properties);
}
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return -1;
}
//
// Remaining command line options are passed to the communicator
// as an argument vector in case they contain plug-in properties.
//
int argc = static_cast<int>(seq.size());
char** argv = new char*[argc + 1];
int i = 0;
for(Ice::StringSeq::const_iterator s = seq.begin(); s != seq.end(); ++s, ++i)
{
argv[i] = strdup(s->c_str());
}
argv[argc] = 0;
data.compactIdResolver = new IdResolver;
Ice::CommunicatorPtr communicator;
try
{
AllowThreads allowThreads;
if(argList)
{
communicator = Ice::initialize(argc, argv, data);
}
else
{
communicator = Ice::initialize(data);
}
}
catch(const Ice::Exception& ex)
{
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
setPythonException(ex);
return -1;
}
//
// Replace the contents of the given argument list with the filtered arguments.
//
if(argList)
{
PyList_SetSlice(argList, 0, PyList_Size(argList), 0); // Clear the list.
for(i = 0; i < argc; ++i)
{
PyObjectHandle str = Py_BuildValue(STRCAST("s"), argv[i]);
PyList_Append(argList, str.get());
}
}
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
self->communicator = new Ice::CommunicatorPtr(communicator);
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
if(p != _communicatorMap.end())
{
_communicatorMap.erase(p);
}
_communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<PyObject*>(self)));
if(dispatcherWrapper)
{
self->dispatcher = new DispatcherPtr(dispatcherWrapper);
dispatcherWrapper->setCommunicator(communicator);
}
return 0;
}
static int
communicatorInit(CommunicatorObject* self, PyObject* args, PyObject* /*kwds*/)
{
PyObject* argList = 0;
PyObject* initData = 0;
if(!PyArg_ParseTuple(args, STRCAST("|OO"), &argList, &initData))
{
return -1;
}
if(argList == Py_None)
{
argList = 0;
}
if(initData == Py_None)
{
initData = 0;
}
PyObject* initDataType = lookupType("Ice.InitializationData");
if(argList && !initData)
{
if(PyObject_IsInstance(argList, initDataType))
{
initData = argList;
argList = 0;
}
else if(!PyList_Check(argList))
{
PyErr_Format(PyExc_ValueError, STRCAST("initialize expects an argument list or Ice.InitializationData"));
return -1;
}
}
else if(argList && initData)
{
if(!PyList_Check(argList) || !PyObject_IsInstance(initData, initDataType))
{
PyErr_Format(PyExc_ValueError, STRCAST("initialize expects an argument list and Ice.InitializationData"));
return -1;
}
}
Ice::StringSeq seq;
if(argList && !listToStringSeq(argList, seq))
{
return -1;
}
//
// Use the with-args or the without-args version of initialize()?
//
bool hasArgs = argList != 0;
Ice::InitializationData data;
if(initData)
{
PyObjectHandle properties = PyObject_GetAttrString(initData, STRCAST("properties"));
PyObjectHandle logger = PyObject_GetAttrString(initData, STRCAST("logger"));
PyObjectHandle threadHook = PyObject_GetAttrString(initData, STRCAST("threadHook"));
PyObjectHandle batchRequestInterceptor = PyObject_GetAttrString(initData, STRCAST("batchRequestInterceptor"));
PyErr_Clear(); // PyObject_GetAttrString sets an error on failure.
if(properties.get() && properties.get() != Py_None)
{
//
// Get the properties implementation.
//
PyObjectHandle impl = PyObject_GetAttrString(properties.get(), STRCAST("_impl"));
assert(impl.get());
data.properties = getProperties(impl.get());
}
if(logger.get() && logger.get() != Py_None)
{
data.logger = new LoggerWrapper(logger.get());
}
if(threadHook.get() && threadHook.get() != Py_None)
{
data.threadHook = new ThreadHook(threadHook.get());
}
if(batchRequestInterceptor.get() && batchRequestInterceptor.get() != Py_None)
{
data.batchRequestInterceptor = new BatchRequestInterceptor(batchRequestInterceptor.get());
}
}
//
// We always supply our own implementation of ValueFactoryManager.
//
data.valueFactoryManager = new ValueFactoryManager;
try
{
if(argList)
{
data.properties = Ice::createProperties(seq, data.properties);
}
else if(!data.properties)
{
data.properties = Ice::createProperties();
}
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return -1;
}
//
// Remaining command line options are passed to the communicator
// as an argument vector in case they contain plug-in properties.
//
int argc = static_cast<int>(seq.size());
char** argv = new char*[argc + 1];
int i = 0;
for(Ice::StringSeq::const_iterator s = seq.begin(); s != seq.end(); ++s, ++i)
{
argv[i] = strdup(s->c_str());
}
argv[argc] = 0;
data.compactIdResolver = new IdResolver;
Ice::CommunicatorPtr communicator;
try
{
AllowThreads allowThreads;
if(hasArgs)
{
communicator = Ice::initialize(argc, argv, data);
}
else
{
communicator = Ice::initialize(data);
}
}
catch(const Ice::Exception& ex)
{
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
setPythonException(ex);
return -1;
}
//
// Replace the contents of the given argument list with the filtered arguments.
//
if(argList)
{
PyList_SetSlice(argList, 0, PyList_Size(argList), 0); // Clear the list.
for(i = 0; i < argc; ++i)
{
PyObjectHandle str = Py_BuildValue(STRCAST("s"), argv[i]);
PyList_Append(argList, str.get());
}
}
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
self->communicator = new Ice::CommunicatorPtr(communicator);
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
if(p != _communicatorMap.end())
{
_communicatorMap.erase(p);
}
_communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<PyObject*>(self)));
return 0;
}
