bool PythonInterpreter::runScript(const char* filename, const char* shortName) {
    PyEval_RestoreThread(state);

    PyObject* script = PyFile_FromString(const_cast<char*>(filename),
        const_cast<char*>("r"));
    if (script) {
        PyObject* ans = PyRun_File(PyFile_AsFile(script),
            const_cast<char*>(shortName),
            Py_file_input, mainNamespace, mainNamespace);
        Py_DECREF(script);

        if (ans) {
            Py_DECREF(ans);
            state = PyEval_SaveThread();
            return true;
        } else {
            PyErr_Print();
            state = PyEval_SaveThread();
            return false;
        }
    } else {
        state = PyEval_SaveThread();
        return false;
    }
}

static void *
rpmtsCallback(const void * hd, const rpmCallbackType what,
		         const rpm_loff_t amount, const rpm_loff_t total,
	                 const void * pkgKey, rpmCallbackData data)
{
    Header h = (Header) hd;
    struct rpmtsCallbackType_s * cbInfo = data;
    PyObject * pkgObj = (PyObject *) pkgKey;
    PyObject * args, * result;
    static FD_t fd;

    if (cbInfo->cb == Py_None) return NULL;

    /* Synthesize a python object for callback (if necessary). */
    if (pkgObj == NULL) {
	if (h) {
	    pkgObj = Py_BuildValue("s", headerGetString(h, RPMTAG_NAME));
	} else {
	    pkgObj = Py_None;
	    Py_INCREF(pkgObj);
	}
    } else
	Py_INCREF(pkgObj);

    PyEval_RestoreThread(cbInfo->_save);

    args = Py_BuildValue("(iLLOO)", what, amount, total, pkgObj, cbInfo->data);
    result = PyEval_CallObject(cbInfo->cb, args);
    Py_DECREF(args);
    Py_DECREF(pkgObj);

    if (!result) {
	die(cbInfo->cb);
    }

    if (what == RPMCALLBACK_INST_OPEN_FILE) {
	int fdno;

        if (!PyArg_Parse(result, "i", &fdno)) {
	    die(cbInfo->cb);
	}
	Py_DECREF(result);
	cbInfo->_save = PyEval_SaveThread();

	fd = fdDup(fdno);
	fcntl(Fileno(fd), F_SETFD, FD_CLOEXEC);

	return fd;
    } else
    if (what == RPMCALLBACK_INST_CLOSE_FILE) {
	Fclose (fd);
    }

    Py_DECREF(result);
    cbInfo->_save = PyEval_SaveThread();

    return NULL;
}

//---------------------------------------------------------
// Pass messages into the Python interpreter main thread,
// which is expected to implement an event loop around calls
// to tart_wait() to retrieve these messages.
//
void Tart::do_postMessage(QString msg) {
    // qDebug() << QThread::currentThreadId() << "Tart: do_postMessage(" << msg << ")";

    QByteArray bytes = msg.toUtf8();

    // PyGILState_STATE gil_state = PyGILState_Ensure();
    PyEval_RestoreThread(tart_pystate);

    // qDebug() << "tart_wait bytes" << bytes.size();
    PyObject * arglist = Py_BuildValue("(s#)", bytes.constData(), bytes.size());
    // ran out of memory: fail!
    if (arglist == NULL) {
        qDebug() << "Py_BuildValue() returned NULL!";
        // should probably do something more significant here
        tart_pystate = PyEval_SaveThread();
        // PyGILState_Release(gil_state);
        return;
    } else {
        // qDebug() << "postMessage() built" << arglist;
    }

    // call the callback to send message to Python
    PyObject * result = PyObject_CallObject(event_callback, arglist);
    Py_DECREF(arglist);

    // qDebug() << "callback returned" << result;

    // TODO handle exceptions from the call, either by exiting the event
    // loop (maybe only during development?) or by dumping a traceback,
    // setting a flag, and continuing on.
    bool is_SystemExit = false;

    if (result == NULL) {   // exception during call
        // qDebug() << "exception during event delivery";

        // see http://computer-programming-forum.com/56-python/a81eae52ca74e6c1.htm
        // Calling PyErr_Print() will actually terminate the process if
        // SystemExit is the exception!
        if (PyErr_ExceptionMatches(PyExc_SystemExit))
            is_SystemExit = true;
        else
            PyErr_Print();
    }
    else
        Py_DECREF(result);

    // PyGILState_Release(gil_state);
    tart_pystate = PyEval_SaveThread();

    if (is_SystemExit) {
        qDebug() << "do_post: SystemExit from delivery";
        m_thread->exit(3);
    }

    // qDebug() << QThread::currentThreadId() << "Tart: do_postMessage done";
    return;
}

//---------------------------------------------------------
// Pass push messages into the Python interpreter main thread,
// if it has implemented an onPushReceived() method.
//
void Tart::pushReceived(const QString & id, const QByteArray & bytes, bool wantsAck) {
    qDebug() << QThread::currentThreadId() << "Tart: pushReceived" << id << wantsAck << bytes.size();

    // FIXME: this should probably be checked inside the tart_pystate context
    // where the GIL is held, not outside.
    // Ignore data if no callback has been registered.
    if (!push_callback)
        return;

    PyEval_RestoreThread(tart_pystate);

    PyObject * arglist = Py_BuildValue("(sy#i)",
        id.toUtf8().constData(),
        bytes.constData(), bytes.size(),
        wantsAck
        );
    // ran out of memory: fail!
    if (arglist == NULL) {
        qDebug() << "Py_BuildValue() returned NULL!";
        // should probably do something more significant here
        tart_pystate = PyEval_SaveThread();
        return;
    }

    // call the callback to send message to Python
    PyObject * result = PyObject_CallObject(push_callback, arglist);
    Py_DECREF(arglist);

    // TODO handle exceptions from the call, either by exiting the event
    // loop (maybe only during development?) or by dumping a traceback,
    // setting a flag, and continuing on.
    bool is_SystemExit = false;

    if (result == NULL) {   // exception during call
        // see http://computer-programming-forum.com/56-python/a81eae52ca74e6c1.htm
        // Calling PyErr_Print() will actually terminate the process if
        // SystemExit is the exception!
        if (PyErr_ExceptionMatches(PyExc_SystemExit))
            is_SystemExit = true;
        else
            PyErr_Print();
    }
    else
        Py_DECREF(result);

    tart_pystate = PyEval_SaveThread();

    if (is_SystemExit) {
        qDebug() << "do_post: SystemExit from delivery";
        m_thread->exit(3);
    }

    return;
}

void call_event_hook_callback(void * event)
    {
    // qDebug() << QThread::currentThreadId() << "call_event_hook_callback: begin";

    // PyGILState_STATE gil_state = PyGILState_Ensure();
    PyEval_RestoreThread(tart_pystate);

    PyObject * arglist = Py_BuildValue("(i)", event);
    // ran out of memory: fail!
    if (arglist == NULL)
        {
        qDebug() << "Py_BuildValue() returned NULL!";
        // should probably do something more significant here

        // PyGILState_Release(gil_state);
        tart_pystate = PyEval_SaveThread();
        return;
        }

    // call the callback to send message to Python
    PyObject * result = PyObject_CallObject(event_hook_callback, arglist);
    Py_DECREF(arglist);

    // TODO handle exceptions from the call, either by exiting the event
    // loop (maybe only during development?) or by dumping a traceback,
    // setting a flag, and continuing on.
    bool is_SystemExit = false;

    if (result == NULL)     // exception during call
        {
        // see http://computer-programming-forum.com/56-python/a81eae52ca74e6c1.htm
        // Calling PyErr_Print() will actually terminate the process if
        // SystemExit is the exception!
        if (PyErr_ExceptionMatches(PyExc_SystemExit))
            is_SystemExit = true;
        else
            PyErr_Print();
        }
    else
        Py_DECREF(result);

    // PyGILState_Release(gil_state);
    tart_pystate = PyEval_SaveThread();

    if (is_SystemExit)
        {
        qDebug() << "event_hook: SystemExit";
        QThread::currentThread()->exit(3);
        }

    // qDebug() << QThread::currentThreadId() << "call_event_hook_callback: end";

    return;
    }

PythonLoader::PythonLoader(QObject *parent) : QObject(parent)
{

    if (!Py_IsInitialized())
    {
        QString sysPath = QCoreApplication::applicationDirPath();
        QString programPath = sysPath + "/thirdparty/Python/bin/python3";
        wchar_t* programName = new wchar_t[programPath.length() + 1];
        programPath.toWCharArray(programName);
        programName[programPath.length()] = 0;

        Py_SetProgramName(programName);
        wprintf(L"python prefix path: %S\n", Py_GetPrefix());
        wprintf(L"python full path: %S\n", Py_GetProgramFullPath());
        Py_Initialize();
        QStringList paths = {sysPath+"/thirdparty/Python/lib/python3.4", sysPath+"/thirdparty/Python/lib/python3.4/plat-linux",
                             sysPath+"/thirdparty/Python/lib/python3.4/lib-dynload", sysPath+"/thirdparty/Python/lib/python3.4/site-packages",
                            sysPath, sysPath+"/thirdparty/Python/lib", sysPath+"/thirdparty/Python/bin"};
        QString wholePath = paths.join(":");
        PySys_SetPath(wholePath.toStdWString().c_str());

        getSipAPI();
        PyEval_InitThreads();
        PyEval_SaveThread();
    }
}

static int
rpmts_SolveCallback(rpmts ts, rpmds ds, const void * data)
{
    struct rpmtsCallbackType_s * cbInfo = (struct rpmtsCallbackType_s *) data;
    PyObject * args, * result;
    int res = 1;

    if (cbInfo->tso == NULL) return res;
    if (cbInfo->cb == Py_None) return res;

    PyEval_RestoreThread(cbInfo->_save);

    args = Py_BuildValue("(Oissi)", cbInfo->tso,
		rpmdsTagN(ds), rpmdsN(ds), rpmdsEVR(ds), rpmdsFlags(ds));
    result = PyEval_CallObject(cbInfo->cb, args);
    Py_DECREF(args);

    if (!result) {
	die(cbInfo->cb);
    } else {
	if (PyInt_Check(result))
	    res = PyInt_AsLong(result);
	Py_DECREF(result);
    }

    cbInfo->_save = PyEval_SaveThread();

    return res;
}

static PyObject *
nis_cat (PyObject *self, PyObject *args, PyObject *kwdict)
{
	char *domain = NULL;
	char *map;
	struct ypall_callback cb;
	struct ypcallback_data data;
	PyObject *dict;
	int err;
	static char *kwlist[] = {"map", "domain", NULL};

	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s|s:cat",
				         kwlist, &map, &domain))
		return NULL;
	if (!domain && ((err = yp_get_default_domain(&domain)) != 0))
		return nis_error(err);
	dict = PyDict_New ();
	if (dict == NULL)
		return NULL;
	cb.foreach = (foreachfunc)nis_foreach;
	data.dict = dict;
	map = nis_mapname (map, &data.fix);
	cb.data = (char *)&data;
	data.state = PyEval_SaveThread();
	err = yp_all (domain, map, &cb);
	PyEval_RestoreThread(data.state);
	if (err != 0) {
		Py_DECREF(dict);
		return nis_error(err);
	}
	return dict;
}

// 초기화
CDummyClientManager::CDummyClientManager(void)
{
	g_dummyClientManager = this;

	m_highestIndex = 0;
	m_curIndex = 0;	
	m_maxLimitIndex = 999999;	

	// 파이썬 초기화
	Py_Initialize();
	PyEval_InitThreads();
	mainThreadState = PyEval_SaveThread();
	PyGILState_STATE gilState;

	gilState = PyGILState_Ensure();

	PyImport_AddModule("pythonCallbackModule");
	Py_InitModule("pythonCallbackModule", modules);

	PyRun_SimpleString("import sys\n");
	PyRun_SimpleString("sys.path.append('.\\Python')\n");
	
	PyGILState_Release( gilState );

	// 메인 스크립트 로드
	CString log = ( SetMainScript() == false ) ? L"mainscript 로드 실패" : L"mainscript 로드 성공";	
	CtesttoolDlg* dlg = (CtesttoolDlg*)AfxGetApp()->m_pMainWnd;
	dlg->addMainLog( log );
	dlg->showMainLog();
}

void
BeginAllowThreads(PyThreadState **state)
{
    assert(state);
    assert(*state == NULL);
    (*state) = PyEval_SaveThread();
}

void
QPythonPriv::leave()
{
    assert(state == NULL);
    state = PyEval_SaveThread();
    mutex.unlock();
}

 void redo()
 { 
     if (!done_ && PyEval_ThreadsInitialized()) { 
         save_ = PyEval_SaveThread(); 
         done_ = true; 
     } 
 }

int main(int argc, char* argv[])
{
    PyEval_InitThreads();
    Py_Initialize();
    PyObject* sysPath = PySys_GetObject((char*) "path");
    PyList_Append(sysPath, PyString_FromString("."));

    PyThreadState* save = PyEval_SaveThread();

    pthread_t tid1, tid2;
    char* tname1 = "worker1";
    char* tname2 = "worker2";
    pthread_create(&tid1, NULL, &run_python_function, &tname1);
    pthread_create(&tid2, NULL, &run_python_function, &tname2);

    for (int i = 0; i < 5; i++)
    {
        printf("main thread is running\n");
        sleep(1);
    }

    stop_event = 1;
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    printf("finish\n");

    PyEval_RestoreThread(save);
    Py_Finalize();

    pthread_exit(NULL);

    return 0;
}

static PyObject * p_loop_or_dispatch (int dispatch, PyObject *self, PyObject *args)
{
  pcap_t * ppcap;
  thread_state ts;
  int cnt;
  int rv;
  int release_thread;
  if (!PyArg_ParseTuple(args, "liOOii", &ppcap, &cnt, &ts.pycallback, &ts.user, &ts.use_bytearray, &release_thread)) return NULL;
  Py_INCREF(ts.user);

  ts.ppcap = ppcap;
  ts.exception = 0;
  ts.release_thread = release_thread;
  if (release_thread) ts.ts = PyEval_SaveThread();

  if (dispatch)
    rv = pcap_loop(ppcap, cnt, ld_callback, (u_char *)&ts);
  else
    rv = pcap_dispatch(ppcap, cnt, ld_callback, (u_char *)&ts);

  if (release_thread) PyEval_RestoreThread(ts.ts);

  Py_DECREF(ts.user);

  if (ts.exception) return NULL;

  return Py_BuildValue("i", rv);
}

// Device.get_file {{{
static PyObject *
Device_get_file(Device *self, PyObject *args) {
    PyObject *stream, *callback = NULL, *errs;
    ProgressCallback cb;
    unsigned long fileid;
    int ret;

    ENSURE_DEV(NULL); ENSURE_STORAGE(NULL);


    if (!PyArg_ParseTuple(args, "kO|O", &fileid, &stream, &callback)) return NULL; 
    errs = PyList_New(0);
    if (errs == NULL) { PyErr_NoMemory(); return NULL; }
    if (callback == NULL || !PyCallable_Check(callback)) callback = NULL;

    cb.obj = callback; cb.extra = stream;
    Py_XINCREF(callback); Py_INCREF(stream);
    cb.state = PyEval_SaveThread();
    ret = LIBMTP_Get_File_To_Handler(self->device, (uint32_t)fileid, data_to_python, &cb, report_progress, &cb);
    PyEval_RestoreThread(cb.state);
    Py_XDECREF(callback); Py_DECREF(stream);

    if (ret != 0) { 
        dump_errorstack(self->device, errs);
    }
    Py_XDECREF(PyObject_CallMethod(stream, "flush", NULL));
    return Py_BuildValue("ON", (ret == 0) ? Py_True : Py_False, errs);

} // }}}

void init_python(int argc, char** argv) {
  Py_Initialize();

  PySys_SetArgvEx(argc, argv, 0);

  set_gl_sys_path();

  PyEval_InitThreads();
  PyEval_SaveThread(); // release the GIL

  {
    python_thread_guard py_thread_guard;
    try {
      gl = boost::python::import("graphlab");
      image_class = python::import("graphlab.data_structures.image").attr("Image");
      gc = python::import("gc");
    } catch (python::error_already_set const& e) {
      std::string error_string = parse_python_error();
      std::cerr << error_string << std::endl;
      throw(error_string);
    } catch (...) {
      throw(std::string("Unknown error when import graphlab"));
    }
  }
}

// Device.put_file {{{
static PyObject *
Device_put_file(Device *self, PyObject *args) {
    PyObject *stream, *callback = NULL, *errs, *fo = NULL;
    ProgressCallback cb;
    unsigned long parent_id, storage_id;
    unsigned long long filesize;
    int ret;
    char *name;
    LIBMTP_file_t f;

    ENSURE_DEV(NULL); ENSURE_STORAGE(NULL);

    if (!PyArg_ParseTuple(args, "kksOK|O", &storage_id, &parent_id, &name, &stream, &filesize, &callback)) return NULL; 
    errs = PyList_New(0);
    if (errs == NULL) { PyErr_NoMemory(); return NULL; }
    if (callback == NULL || !PyCallable_Check(callback)) callback = NULL;

    cb.obj = callback; cb.extra = stream;
    f.parent_id = (uint32_t)parent_id; f.storage_id = (uint32_t)storage_id; f.item_id = 0; f.filename = name; f.filetype = LIBMTP_FILETYPE_UNKNOWN; f.filesize = (uint64_t)filesize;
    Py_XINCREF(callback); Py_INCREF(stream);
    cb.state = PyEval_SaveThread();
    ret = LIBMTP_Send_File_From_Handler(self->device, data_from_python, &cb, &f, report_progress, &cb);
    PyEval_RestoreThread(cb.state);
    Py_XDECREF(callback); Py_DECREF(stream);

    if (ret != 0) dump_errorstack(self->device, errs);
    else fo = file_metadata(self->device, errs, f.item_id, storage_id);
    if (fo == NULL) { fo = Py_None; Py_INCREF(fo); }

    return Py_BuildValue("NN", fo, errs);

} // }}}

PyObject *
py_guestfs_close (PyObject *self, PyObject *args)
{
  PyThreadState *py_save = NULL;
  PyObject *py_g;
  guestfs_h *g;
  size_t i, len;
  PyObject **callbacks;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_close", &py_g))
    return NULL;
  g = get_handle (py_g);

  /* As in the OCaml bindings, there is a hard to solve case where the
   * caller can delete a callback from within the callback, resulting
   * in a double-free here.  XXX
   */
  callbacks = get_all_event_callbacks (g, &len);

  if (PyEval_ThreadsInitialized ())
    py_save = PyEval_SaveThread ();
  guestfs_close (g);
  if (PyEval_ThreadsInitialized ())
    PyEval_RestoreThread (py_save);

  for (i = 0; i < len; ++i)
    Py_XDECREF (callbacks[i]);
  free (callbacks);

  Py_INCREF (Py_None);
  return Py_None;
}

void AllowThreads(PCRITICAL_SECTION cs, std::function<void()> action)
{
    PyThreadState* _save = nullptr;
    try
    {
        // Py_BEGIN_ALLOW_THREADS
        _save = PyEval_SaveThread();
        if (cs)
        {
            ::EnterCriticalSection(cs);
        }

        action();

        if (cs)
        {
            ::LeaveCriticalSection(cs);
        }
        // Py_END_ALLOW_THREADS
        PyEval_RestoreThread(_save);
    }
    catch (std::exception&)
    {
        if (cs)
        {
            ::LeaveCriticalSection(cs);
        }
        if (_save)
        {
            PyEval_RestoreThread(_save);
        }
        throw;
    }
}

void embed_init_python(void)
{
    FENTER;

#ifndef PYTHON_SO_LIB
#error "Python version needs passing in with -DPYTHON_SO_VERSION=libpython<ver>.so"
#else
#define PY_SO_LIB xstr(PYTHON_SO_LIB)
#endif

    void *ret = dlopen(PY_SO_LIB, RTLD_LAZY | RTLD_GLOBAL);
    if (!ret) {
        fprintf(stderr, "Failed to find python lib %s (%s)\n", PY_SO_LIB, dlerror());
    }

    // Don't initialise python if already running
    if (gtstate)
        return;

    Py_SetProgramName(progname);
    Py_Initialize();                    /* Initialize the interpreter */
    PySys_SetArgvEx(1, argv, 0);
    PyEval_InitThreads();               /* Create (and acquire) the interpreter lock */

    /* Swap out and return current thread state and release the GIL */
    gtstate = PyEval_SaveThread();
    FEXIT;
}