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(); }