void
IcePy::ServantLocatorWrapper::finished(const Ice::Current& current, const Ice::ObjectPtr&,
const Ice::LocalObjectPtr& cookie)
{
AdoptThread adoptThread; // Ensure the current thread is able to call into Python.
CookiePtr c = CookiePtr::dynamicCast(cookie);
assert(c);
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(c->servant);
PyObjectHandle servantObj = wrapper->getObject();
PyObjectHandle res = PyObject_CallMethod(_locator, STRCAST("finished"), STRCAST("OOO"), c->current,
servantObj.get(), c->cookie);
if(PyErr_Occurred())
{
PyException ex; // Retrieve the exception before another Python API call clears it.
//
// A locator that calls sys.exit() will raise the SystemExit exception.
// This is normally caught by the interpreter, causing it to exit.
// However, we have no way to pass this exception to the interpreter,
// so we act on it directly.
//
ex.checkSystemExit();
PyObject* userExceptionType = lookupType("Ice.UserException");
if(PyObject_IsInstance(ex.ex.get(), userExceptionType))
{
throw ExceptionWriter(ex.ex);
}
ex.raise();
}
}
static PyObject*
communicatorFindAdminFacet(CommunicatorObject* self, PyObject* args)
{
PyObject* facetObj;
if(!PyArg_ParseTuple(args, STRCAST("O"), &facetObj))
{
return 0;
}
string facet;
if(!getStringArg(facetObj, "facet", facet))
{
return 0;
}
assert(self->communicator);
try
{
//
// The facet being found may not be implemented by a Python servant
// (e.g., it could be the Process or Properties facet), in which case
// we return None.
//
Ice::ObjectPtr obj = (*self->communicator)->findAdminFacet(facet);
if(obj)
{
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(obj);
if(wrapper)
{
return wrapper->getObject();
}
Ice::NativePropertiesAdminPtr props = Ice::NativePropertiesAdminPtr::dynamicCast(obj);
if(props)
{
return createNativePropertiesAdmin(props);
}
// If the facet isn't supported in Python, just return an Ice.Object.
PyTypeObject* objectType = reinterpret_cast<PyTypeObject*>(lookupType("Ice.Object"));
return objectType->tp_alloc(objectType, 0);
}
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
communicatorFindAllAdminFacets(CommunicatorObject* self)
{
assert(self->communicator);
Ice::FacetMap facetMap;
try
{
facetMap = (*self->communicator)->findAllAdminFacets();
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
PyObjectHandle result = PyDict_New();
if(!result.get())
{
return 0;
}
PyTypeObject* objectType = reinterpret_cast<PyTypeObject*>(lookupType("Ice.Object"));
PyObjectHandle plainObject = objectType->tp_alloc(objectType, 0);
for(Ice::FacetMap::const_iterator p = facetMap.begin(); p != facetMap.end(); ++p)
{
PyObjectHandle obj = plainObject;
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(p->second);
if(wrapper)
{
obj = wrapper->getObject();
}
else
{
Ice::NativePropertiesAdminPtr props = Ice::NativePropertiesAdminPtr::dynamicCast(p->second);
if(props)
{
obj = createNativePropertiesAdmin(props);
}
}
if(PyDict_SetItemString(result.get(), const_cast<char*>(p->first.c_str()), obj.get()) < 0)
{
return 0;
}
}
return result.release();
}
static PyObject*
adapterRemoveAllFacets(ObjectAdapterObject* self, PyObject* args)
{
PyObject* identityType = lookupType("Ice.Identity");
PyObject* id;
if(!PyArg_ParseTuple(args, STRCAST("O!"), identityType, &id))
{
return 0;
}
Ice::Identity ident;
if(!getIdentity(id, ident))
{
return 0;
}
assert(self->adapter);
Ice::FacetMap facetMap;
try
{
facetMap = (*self->adapter)->removeAllFacets(ident);
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
PyObjectHandle result = PyDict_New();
if(!result.get())
{
return 0;
}
for(Ice::FacetMap::iterator p = facetMap.begin(); p != facetMap.end(); ++p)
{
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(p->second);
assert(wrapper);
PyObjectHandle obj = wrapper->getObject();
if(PyDict_SetItemString(result.get(), const_cast<char*>(p->first.c_str()), obj.get()) < 0)
{
return 0;
}
}
return result.release();
}
static PyObject*
adapterRemoveFacet(ObjectAdapterObject* self, PyObject* args)
{
PyObject* identityType = lookupType("Ice.Identity");
PyObject* id;
PyObject* facetObj;
if(!PyArg_ParseTuple(args, STRCAST("O!O"), identityType, &id, &facetObj))
{
return 0;
}
Ice::Identity ident;
if(!getIdentity(id, ident))
{
return 0;
}
string facet;
if(!getStringArg(facetObj, "facet", facet))
{
return 0;
}
assert(self->adapter);
Ice::ObjectPtr obj;
try
{
obj = (*self->adapter)->removeFacet(ident, facet);
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
if(!obj)
{
Py_INCREF(Py_None);
return Py_None;
}
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(obj);
assert(wrapper);
return wrapper->getObject();
}
static PyObject*
communicatorRemoveAdminFacet(CommunicatorObject* self, PyObject* args)
{
PyObject* facetObj;
if(!PyArg_ParseTuple(args, STRCAST("O"), &facetObj))
{
return 0;
}
string facet;
if(!getStringArg(facetObj, "facet", facet))
{
return 0;
}
assert(self->communicator);
try
{
//
// The facet being removed may not be implemented by a Python servant
// (e.g., it could be the Process or Properties facet), in which case
// we return None.
//
Ice::ObjectPtr obj = (*self->communicator)->removeAdminFacet(facet);
assert(obj);
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(obj);
if(wrapper)
{
return wrapper->getObject();
}
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
adapterRemoveDefaultServant(ObjectAdapterObject* self, PyObject* args)
{
PyObject* categoryObj;
if(!PyArg_ParseTuple(args, STRCAST("O"), &categoryObj))
{
return 0;
}
string category;
if(!getStringArg(categoryObj, "category", category))
{
return 0;
}
assert(self->adapter);
Ice::ObjectPtr obj;
try
{
obj = (*self->adapter)->removeDefaultServant(category);
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
if(!obj)
{
Py_INCREF(Py_None);
return Py_None;
}
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(obj);
assert(wrapper);
return wrapper->getObject();
}
static PyObject*
adapterFindByProxy(ObjectAdapterObject* self, PyObject* args)
{
//
// We don't want to accept None here, so we can specify ProxyType and force
// the caller to supply a proxy object.
//
PyObject* proxy;
if(!PyArg_ParseTuple(args, STRCAST("O!"), &ProxyType, &proxy))
{
return 0;
}
Ice::ObjectPrx prx = getProxy(proxy);
assert(self->adapter);
Ice::ObjectPtr obj;
try
{
obj = (*self->adapter)->findByProxy(prx);
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return 0;
}
if(!obj)
{
Py_INCREF(Py_None);
return Py_None;
}
ServantWrapperPtr wrapper = ServantWrapperPtr::dynamicCast(obj);
assert(wrapper);
return wrapper->getObject();
}
