static pgint32 CPyStreamWrapper_Tell_Threaded (CPyStreamWrapper *wrapper) { PyObject* result; pgint32 retval = 0; #ifdef WITH_THREAD PyThreadState* oldstate; #endif if (!wrapper->tell) return -1; #ifdef WITH_THREAD PyEval_AcquireThread (wrapper->thread); oldstate = PyThreadState_Swap (wrapper->thread); #endif result = PyObject_CallFunction (wrapper->tell, NULL); if (!result) { PyErr_Print (); retval = -1; goto end; } retval = PyInt_AsLong (result); Py_DECREF (result); end: #ifdef WITH_THREAD PyThreadState_Swap (oldstate); PyEval_ReleaseThread (wrapper->thread); #endif return retval; }
void MPyEmbed_CBPostFrame(void) { int i; if (!PythonAvailable) { return; } PyThread_acquire_lock(threaddatalock, WAIT_LOCK); for (i = 0; i < THREADS; i++) { if (VALID(threaddata[i])) { PyObject *cb = threaddata[i].postframe; PyThreadState *ts = threaddata[i].mainstate; PyObject *rv; PyThread_release_lock(threaddatalock); ts->thread_id = PyThread_get_thread_ident(); PyEval_AcquireThread(ts); if (cb != NULL && PyCallable_Check(cb)) { rv = PyObject_CallObject(cb, NULL); Py_XDECREF(rv); if (rv == NULL) { PyErr_Print(); } } PyEval_ReleaseThread(ts); PyThread_acquire_lock(threaddatalock, WAIT_LOCK); } } PyThread_release_lock(threaddatalock); }
// Asuming we have a valid thread state, acquire the Python lock. void PyXPCOM_InterpreterLock_Acquire() { ThreadData *pData = (ThreadData *)PR_GetThreadPrivate(tlsIndex); NS_ABORT_IF_FALSE(pData, "Have no thread data for this thread!"); PyThreadState *thisThreadState = pData->ts; PyEval_AcquireThread(thisThreadState); }
static int _pyobj_write_threaded (SDL_RWops *ops, const void* ptr, int size, int num) { _RWWrapper *wrapper = (_RWWrapper *) ops->hidden.unknown.data1; PyObject *result; int retval; PyThreadState* oldstate; if (!wrapper->write) return -1; PyEval_AcquireThread (wrapper->thread); oldstate = PyThreadState_Swap (wrapper->thread); #ifdef IS_PYTHON_3 result = PyObject_CallFunction (wrapper->write, "y#", ptr, size * num); #else result = PyObject_CallFunction (wrapper->write, "s#", ptr, size * num); #endif if (!result) { PyErr_Print (); retval = -1; goto end; } Py_DECREF (result); retval = num; end: PyThreadState_Swap (oldstate); PyEval_ReleaseThread (wrapper->thread); return retval; }
SCPyModule::~SCPyModule() { //PYLOCK; PyEval_AcquireThread(tstate); FILE* f = fopen("refs.txt", "w"); _Py_PrintReferences(f); /* Disable signal handling */ PyOS_FiniInterrupts(); PyInterpreterState_Clear(interp); /* Delete current thread */ PyThreadState_Swap(NULL); PyInterpreterState_Delete(interp); /* Sundry finalizers */ PyMethod_Fini(); PyFrame_Fini(); PyCFunction_Fini(); PyTuple_Fini(); PyList_Fini(); PySet_Fini(); PyString_Fini(); PyInt_Fini(); PyFloat_Fini(); PyGrammar_RemoveAccelerators(&_PyParser_Grammar); _Py_PrintReferenceAddresses(f); fclose(f); }
static void clRunPython(char* cmd) { #define BSZ 2048 char pyBuf[BSZ]; //clprintf (CL_LOG_SEV_INFO, "clRunPython called with [%s]", cmd); //clOsalMutexLock(&pyMutex); PyThreadState *tstate; //PyObject *result; snprintf(pyBuf,BSZ,"safplus.Callback(\"\"\"%s\"\"\")\n",cmd); //clprintf (CL_LOG_SEV_INFO, "clRunPython requesting python lock [%s]", cmd); /* interp is your reference to an interpreter object. */ tstate = PyThreadState_New(thePythonInterpreter); PyEval_AcquireThread(tstate); //clprintf(CL_LOG_SEV_INFO,"Stage 1. Passing to Python layer: %s",pyBuf); int ret = PyRun_SimpleString(pyBuf); //clprintf (CL_LOG_SEV_INFO, "clRunPython requesting release of python lock [%s]", cmd); PyEval_ReleaseThread(tstate); if (ret != 0) clprintf(CL_LOG_SEV_ERROR,"Ran: %s. There was an error.",pyBuf); PyThreadState_Delete(tstate); }
static bRC freePlugin(bpContext *ctx) { struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; if (!p_ctx) { return bRC_Error; } /* * Stop any sub interpreter started per plugin instance. */ PyEval_AcquireThread(p_ctx->interpreter); /* * Do python cleanup calls. */ if (p_ctx->bpContext) { Py_DECREF(p_ctx->bpContext); } if (p_ctx->pModule) { Py_DECREF(p_ctx->pModule); } Py_EndInterpreter(p_ctx->interpreter); PyEval_ReleaseLock(); free(p_ctx); ctx->pContext = NULL; return bRC_OK; }
static void t_bootstrap(void *boot_raw) { struct bootstate *boot = (struct bootstate *) boot_raw; PyThreadState *tstate; PyObject *res; tstate = PyThreadState_New(boot->interp); PyEval_AcquireThread(tstate); res = PyEval_CallObjectWithKeywords( boot->func, boot->args, boot->keyw); Py_DECREF(boot->func); Py_DECREF(boot->args); Py_XDECREF(boot->keyw); PyMem_DEL(boot_raw); if (res == NULL) { if (PyErr_ExceptionMatches(PyExc_SystemExit)) PyErr_Clear(); else { PySys_WriteStderr("Unhandled exception in thread:\n"); PyErr_PrintEx(0); } } else Py_DECREF(res); PyThreadState_Clear(tstate); PyThreadState_DeleteCurrent(); PyThread_exit_thread(); }
static int CPyStreamWrapper_Close_Threaded (CPyStreamWrapper *wrapper) { PyObject *result; int retval = 1; #ifdef WITH_THREAD PyThreadState* oldstate; #endif if (!wrapper->close) return -1; #ifdef WITH_THREAD PyEval_AcquireThread (wrapper->thread); oldstate = PyThreadState_Swap (wrapper->thread); #endif if (wrapper->close) { result = PyObject_CallFunction (wrapper->close, NULL); if (!result) { PyErr_Print (); retval = 0; } Py_XDECREF (result); } #ifdef WITH_THREAD PyThreadState_Swap (oldstate); PyEval_ReleaseThread (wrapper->thread); #endif return retval; }
/** * z_policy_thread_destroy: * @self: this * * Destructor of ZPolicyThread. * The embedded Python thread context (self->thread) will be cleared and * deleted also, and if this thread was the last one running in the * interpreter instance, that will be stopped, too. */ void z_policy_thread_destroy(ZPolicyThread *self) { /* acquires the interpreter lock */ if (self->policy->main_thread != self) { /* we are one of the secondary threads */ z_python_lock(); PyThreadState_Swap(self->thread); PyThreadState_Clear(self->thread); PyThreadState_Swap(NULL); PyThreadState_Delete(self->thread); z_python_unlock(); z_policy_unref(self->policy); } else { /* we must be freed at last, when the policy is being destroyed */ g_assert(self->policy->ref_cnt == 1); /* we are the main thread, destroy the interpreter */ z_policy_purge(self->policy); PyEval_AcquireThread(self->thread); Py_EndInterpreter(self->thread); z_python_unlock(); } g_mutex_free(self->startable_lock); g_cond_free(self->startable_signal); g_free(self); }
static int CPyStreamWrapper_Seek_Threaded (CPyStreamWrapper *wrapper, pgint32 offset, int whence) { PyObject* result; int retval = 1; #ifdef WITH_THREAD PyThreadState* oldstate; #endif if (!wrapper->seek) return 0; #ifdef WITH_THREAD PyEval_AcquireThread (wrapper->thread); oldstate = PyThreadState_Swap (wrapper->thread); #endif result = PyObject_CallFunction (wrapper->seek, "li", offset, whence); if (!result) { PyErr_Print(); retval = 0; goto end; } Py_DECREF (result); end: #ifdef WITH_THREAD PyThreadState_Swap (oldstate); PyEval_ReleaseThread (wrapper->thread); #endif return retval; }
// Asuming we have a valid thread state, acquire the Python lock. void PyWinInterpreterLock_Acquire() { ThreadData *pData = (ThreadData *)TlsGetValue(dwTlsIndex); PyThreadState *thisThreadState = pData->ts; PyEval_AcquireThread(thisThreadState); #ifdef TRACE_THREADSTATE InterlockedIncrement(&numAcquires); #endif /* TRACE_THREADSTATE */ }
STDAPI DllUnregisterServer() { int rc, pyrc; if (gPythoncom == 0) startUp(); PyEval_AcquireThread(thisthread); rc = callSimpleEntryPoint("DllUnregisterServer", &pyrc); PyEval_ReleaseThread(thisthread); return rc==0 ? pyrc : SELFREG_E_CLASS; }
int MPyEmbed_Repl(void) { if (!PythonAvailable) { return 0; } mainstate->thread_id = PyThread_get_thread_ident(); PyEval_AcquireThread(mainstate); PyRun_AnyFile(stdin, "<stdin>"); PyEval_ReleaseThread(mainstate); return 1; }
/** * z_python_destroy: * * This function deinitializes the Python interpreter, it should be called * at program teardown. * * Returns TRUE if deinitialization was successful. **/ gboolean z_python_destroy(void) { if (initial_thread) { PyEval_AcquireThread(initial_thread); Py_Finalize(); } return TRUE; }
void clPyGlueTerminate() { clRunPython("eoApp.Stop()"); clOsalCondBroadcast (&event); clOsalMutexLock(&pyMutex); quit=1; PyEval_AcquireThread(thrdState); Py_Finalize(); clOsalMutexUnlock(&pyMutex); }
static bRC handlePluginEvent(bpContext *ctx, bDirEvent *event, void *value) { struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; bRC retval = bRC_Error; PyEval_AcquireThread(p_ctx->interpreter); retval = PyHandlePluginEvent(ctx, event, value); PyEval_ReleaseThread(p_ctx->interpreter); return retval; }
static bRC setPluginValue(bpContext *ctx, pDirVariable var, void *value) { struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; bRC retval = bRC_Error; PyEval_AcquireThread(p_ctx->interpreter); retval = PySetPluginValue(ctx, var, value); PyEval_ReleaseThread(p_ctx->interpreter); return retval; }
void IvrPython::onDTMFEvent(int detectedKey) { dtmfKey.set(detectedKey); // wake up waiting functions... if (onDTMFCallback == NULL) { DBG("IvrPython::onDTMFEvent, but script did not set onDTMF callback!\n"); return; } DBG("IvrPython::onDTMFEvent(): calling onDTMFCallback key is %d...\n", detectedKey); #ifndef IVR_PERL PyThreadState *tstate; /* interp is your reference to an interpreter object. */ tstate = PyThreadState_New(mainInterpreterThreadState->interp); PyEval_AcquireThread(tstate); /* Perform Python actions here. */ PyObject *arglist = Py_BuildValue("(i)", detectedKey); PyObject *result = PyEval_CallObject(onDTMFCallback, arglist); Py_DECREF(arglist); if (result == NULL) { DBG("Calling IVR" SCRIPT_TYPE "onDTMF failed.\n"); PyErr_Print(); //return ; } else { Py_DECREF(result); } /* Release the thread. No Python API allowed beyond this point. */ PyEval_ReleaseThread(tstate); /* You can either delete the thread state, or save it until you need it the next time. */ PyThreadState_Delete(tstate); #else //IVR_PERL DBG("IvrPython::onDTMFEvent(): calling onDTMFCallback func is %s...\n", onDTMFCallback); PERL_SET_CONTEXT(my_perl_interp); DBG("context is %ld\n", (long) Perl_get_context()); dSP ; ENTER ; SAVETMPS ; PUSHMARK(SP) ; XPUSHs(sv_2mortal(newSViv(detectedKey))); PUTBACK ; call_pv(onDTMFCallback, G_DISCARD); FREETMPS ; LEAVE ; #endif //IVR_PERL DBG("IvrPython::onDTMFEvent done...\n"); }
/* * Do actual I/O. Bareos calls this after startBackupFile * or after startRestoreFile to do the actual file * input or output. */ static bRC pluginIO(bpContext *ctx, struct io_pkt *io) { #ifdef HAVE_PYTHON struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; PyEval_AcquireThread(p_ctx->interpreter); /* * Do python calls. */ PyEval_ReleaseThread(p_ctx->interpreter); #endif return bRC_OK; }
/* * Handle an event that was generated in Bareos */ static bRC handlePluginEvent(bpContext *ctx, bsdEvent *event, void *value) { #ifdef HAVE_PYTHON struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; PyEval_AcquireThread(p_ctx->interpreter); /* * Do python calls. */ PyEval_ReleaseThread(p_ctx->interpreter); #endif return bRC_OK; }
/* * Set a plugin value (none defined) */ static bRC setPluginValue(bpContext *ctx, psdVariable var, void *value) { #ifdef HAVE_PYTHON struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; PyEval_AcquireThread(p_ctx->interpreter); /* * Do python calls. */ PyEval_ReleaseThread(p_ctx->interpreter); #endif return bRC_OK; }
/* * Called when starting to backup a file. Here the plugin must * return the "stat" packet for the directory/file and provide * certain information so that Bareos knows what the file is. * The plugin can create "Virtual" files by giving them a * name that is not normally found on the file system. */ static bRC startBackupFile(bpContext *ctx, struct save_pkt *sp) { #ifdef HAVE_PYTHON struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; PyEval_AcquireThread(p_ctx->interpreter); /* * Do python calls. */ PyEval_ReleaseThread(p_ctx->interpreter); #endif return bRC_OK; }
/* * Called after the file has been restored. This can be used to * set directory permissions, ... */ static bRC setFileAttributes(bpContext *ctx, struct restore_pkt *rp) { #ifdef HAVE_PYTHON struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; PyEval_AcquireThread(p_ctx->interpreter); /* * Do python calls. */ PyEval_ReleaseThread(p_ctx->interpreter); #endif return bRC_OK; }
/* When using Incremental dump, all previous dumps are necessary */ static bRC checkFile(bpContext *ctx, char *fname) { #ifdef HAVE_PYTHON struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext; PyEval_AcquireThread(p_ctx->interpreter); /* * Do python calls. */ PyEval_ReleaseThread(p_ctx->interpreter); #endif return bRC_OK; }
int MPyEmbed_Run(char *file) { FILE *fp; if (!PythonAvailable) { return 0; } fp = fopen(file, "r"); if (!fp) { perror("fopen"); return 0; } mainstate->thread_id = PyThread_get_thread_ident(); PyEval_AcquireThread(mainstate); PyRun_SimpleFile(fp, file); PyEval_ReleaseThread(mainstate); fclose(fp); return 1; }
/* * Class: jep_InvocationHandler * Method: invoke * Signature: (Ljava/lang/String;JJ[Ljava/lang/Object;[Ljava/lang/Class;Ljava/lang/Class;)Ljava/lang/Object; */ JNIEXPORT jobject JNICALL Java_jep_InvocationHandler_invoke (JNIEnv *env, jclass clazz, jstring jname, jlong _jepThread, jlong _target, jobjectArray args, jintArray types, jint returnType) { JepThread *jepThread; jobject ret; const char *cname; PyObject *target; PyObject *callable; target = (PyObject *) (intptr_t) _target; ret = NULL; callable = NULL; jepThread = (JepThread *) (intptr_t) _jepThread; if (!jepThread) { THROW_JEP(env, "Couldn't get thread objects."); return NULL; } PyEval_AcquireThread(jepThread->tstate); // now get the callable object cname = jstring2char(env, jname); // python docs say this returns a new ref. they lie like dogs. callable = PyObject_GetAttrString(target, (char *) cname); release_utf_char(env, jname, cname); if (process_py_exception(env, 0) || !callable) { goto EXIT; } ret = pyembed_invoke(env, callable, args, types); EXIT: PyEval_ReleaseThread(jepThread->tstate); return ret; }
void IvrPython::onMediaQueueEmpty() { isMediaQueueEmpty.set(true); DBG("executiong MQE callback...\n"); if (onMediaQueueEmptyCallback == NULL) { DBG("IvrPython::onMediaQueueEmpty, but script did not set onMediaQueueEmpty callback.\n"); return; } #ifndef IVR_PERL PyThreadState *tstate; /* interp is your reference to an interpreter object. */ tstate = PyThreadState_New(mainInterpreterThreadState->interp); PyEval_AcquireThread(tstate); /* Perform Python actions here. */ PyObject *arglist = Py_BuildValue("()"); PyObject *result = PyEval_CallObject(onMediaQueueEmptyCallback, arglist); Py_DECREF(arglist); if (result == NULL) { DBG("Calling IVR" SCRIPT_TYPE "onMediaQueueEmpty failed.\n"); // PyErr_Print(); //return ; } else { Py_DECREF(result); } /* Release the thread. No Python API allowed beyond this point. */ PyEval_ReleaseThread(tstate); /* You can either delete the thread state, or save it until you need it the next time. */ PyThreadState_Delete(tstate); #else //IVR_PERL PERL_SET_CONTEXT(my_perl_interp); DBG("context is %ld\n", (long) Perl_get_context()); dSP ; PUSHMARK(SP) ; call_pv(onMediaQueueEmptyCallback, G_DISCARD|G_NOARGS) ; #endif //IVR_PERL DBG("IvrPython::onMediaQueueEmpty done.\n"); }
/* * Class: jep_python_PyPointer * Method: decref * Signature: (JJ)V */ JNIEXPORT void JNICALL Java_jep_python_PyPointer_decref (JNIEnv *env, jobject obj, jlong tstate, jlong pyobj) { JepThread *jepThread; PyObject *pyObject; jepThread = (JepThread *) tstate; if (!jepThread) { THROW_JEP(env, "Couldn't get thread objects."); return; } pyObject = (PyObject*) pyobj; PyEval_AcquireThread(jepThread->tstate); Py_DECREF(pyObject); PyEval_ReleaseThread(jepThread->tstate); }
static void clRunPython(char* cmd) { #define BSZ 2048 char pyBuf[BSZ]; clprintf (CL_LOG_SEV_INFO, "clRunPython called with [%s]", cmd); //clOsalMutexLock(&pyMutex); thrdState = PyThreadState_Get(); #if 0 if (quit) { clprintf(CL_LOG_SEV_INFO,"Python has quit, so not running: %s",cmd); //clOsalMutexUnlock(&pyMutex); return; } #endif #if 0 PyEval_AcquireLock(); PyThreadState_Swap(thrdState); #endif snprintf(pyBuf,BSZ,"clCmdFromAsp(\"\"\"%s\"\"\")\n",cmd); clprintf (CL_LOG_SEV_INFO, "clRunPython requesting python lock [%s]", cmd); PyEval_AcquireThread(thrdState); clprintf(CL_LOG_SEV_INFO,"Stage 1. Passing to Python layer: %s",pyBuf); int ret = PyRun_SimpleString(pyBuf); clprintf (CL_LOG_SEV_INFO, "clRunPython requesting release of python lock [%s]", cmd); PyEval_ReleaseThread(thrdState); if (ret != 0) clprintf(CL_LOG_SEV_ERROR,"Ran: %s. There was an error.",pyBuf); #if 0 PyThreadState_Swap(NULL); PyEval_ReleaseLock(); #endif //clprintf (CL_LOG_SEV_INFO, "clRunPython unlocking mutex [%s]", cmd); //clOsalMutexUnlock(&pyMutex); //clprintf (CL_LOG_SEV_INFO, "clRunPython unlocked mutex [%s]", cmd); }