Chinaunix首页 | 论坛 | 博客

timespace的CU博客

首页　| 　博文目录　| 　关于我

timespace

  • 博客访问： 178868
  • 博文数量： 13
  • 博客积分： 10
  • 博客等级： 民兵
  • 技术积分： 832
  • 用 户 组： 普通用户
  • 注册时间： 2010-12-16 22:43
个人简介

最近关注Python，Linux，LLVM

文章分类

全部博文（13）

文章存档

2014年（13）

我的朋友
最近访客
推荐博文
相关博文
浅析Python调用外部代码的三种方式（下篇）

分类： Python/Ruby

2014-03-03 10:18:25

（承接中篇）

C扩展的后半部分，包括特殊成员函数/类型定义与对象构造析构/模块定义与初始化

点击(此处)折叠或打开（inotifymodule.c）

  1. PyDoc_STRVAR(pyinotify_fileno_doc,
  2. "fileno() -> int\n\
  3. \n\
  4. Return the inotify file descriptor.");

  6. static PyObject*
  7. pyinotify_fileno(pyinotify *self)
  8. {
  9.     if (self->fd < 0)
  10.         return pyinotify_err_closed();
  11.     return PyLong_FromLong(self->fd);
  12. }

  14. static PyObject *
  15. new_pyinotify_object(PyTypeObject *type, int flags, int fd)
  16. {
  17.         pyinotify *self;

  19.         self = (pyinotify *)type->tp_alloc(type, 0);
  20.         if (self == NULL)
  21.                 return NULL;

  23.         if (fd == -1) {
  24.                 Py_BEGIN_ALLOW_THREADS
  25.                 self->fd = inotify_init1(flags);
  26.                 Py_END_ALLOW_THREADS
  27.         } else {
  28.                 self->fd = fd;
  29.         }
  30.         if (self->fd < 0) {
  31.                 Py_DECREF(self);
  32.                 PyErr_SetFromErrno(PyExc_OSError);
  33.                 return NULL;
  34.         }

  36.         return (PyObject *)self;
  37. }

  39. PyDoc_STRVAR(pyinotify_fromfd_doc,
  40. "fromfd(fd) -> inotify object. \n\
  41. \n\
  42. Create an inotify object from a given fd.");

  44. static PyObject*
  45. pyinotify_fromfd(PyObject *cls, PyObject *args)
  46. {
  47.     int fd;

  49.     if (!PyArg_ParseTuple(args, "i:fromfd", &fd))
  50.         return NULL;

  52.     return new_pyinotify_object((PyTypeObject*)cls, 0, fd);
  53. }

  55. static PyMethodDef pyinotify_methods[] = {
  56.         {"add_watch", (PyCFunction)pyinotify_add_watch,
  57.          METH_VARARGS, pyinotify_add_watch_doc},
  58.         {"rm_watch", (PyCFunction)pyinotify_rm_watch,
  59.          METH_VARARGS, pyinotify_rm_watch_doc},
  60.         {"read", (PyCFunction)pyinotify_read,
  61.          METH_VARARGS, pyinotify_read_doc},
  62.         {"read_events", (PyCFunction)pyinotify_read_events,
  63.          METH_VARARGS, pyinotify_read_events_doc},
  64.     {"fromfd", (PyCFunction)pyinotify_fromfd,
  65.      METH_VARARGS | METH_CLASS, pyinotify_fromfd_doc},
  66.     {"fileno", (PyCFunction)pyinotify_fileno,
  67.          METH_NOARGS, pyinotify_fileno_doc},
  68.         {"close", (PyCFunction)pyinotify_close,
  69.          METH_NOARGS, pyinotify_close_doc},
  70.         {NULL} /* Sentinel */
  71. };

  73. static PyGetSetDef pyepoll_getsetlist[] = {
  74.     {"closed", (getter)pyinotify_get_closed, NULL,
  75.      "True if the inotify instance is closed"},
  76.     {NULL},
  77. };

  79. static PyObject *
  80. pyinotify_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  81. {
  82.         int flags = 0;
  83.         static char *kwlist[] = {"flags", NULL};

  85.         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|i:inotify", kwlist,
  86.                                 &flags))
  87.                 return NULL;
  88.         
  89.     return new_pyinotify_object((PyTypeObject*)type, flags, -1);
  90. }

  92. static void
  93. pyinotify_dealloc(pyinotify* self)
  94. {
  95.         (void)pyinotify_internal_close(self);
  96.         Py_TYPE(self)->tp_free((PyObject*)self);
  97. }

  99. PyDoc_STRVAR(pyinotify_doc,
  100. "inotify object.\n\
  101. \n\
  102. The inotify API provides a mechanism for monitoring filesystem\n\
  103. events. Inotify can be used to monitor individual files, or to\n\
  104. monitor directories. When a directory is monitored, inotify will\n\
  105. return events for the directory itself, and for files inside the\n\
  106. directory.");

  108. static PyTypeObject pyinotify_type = {
  109.         PyVarObject_HEAD_INIT(NULL, 0)
  110.         "inotify.inotify", /* tp_name */
  111.         sizeof(pyinotify), /* tp_basicsize */
  112.         0, /* tp_itemsize */
  113.         (destructor)pyinotify_dealloc, /* tp_dealloc */
  114.         0, /* tp_print */
  115.         0, /* tp_getattr */
  116.         0, /* tp_setattr */
  117.         0, /* tp_reserved */
  118.         0, /* tp_repr */
  119.         0, /* tp_as_number */
  120.         0, /* tp_as_sequence */
  121.         0, /* tp_as_mapping */
  122.         0, /* tp_hash */
  123.         0, /* tp_call */
  124.         0, /* tp_str */
  125.         0, /* tp_getattro */
  126.         0, /* tp_setattro */
  127.         0, /* tp_as_buffer */
  128.         Py_TPFLAGS_DEFAULT |
  129.                 Py_TPFLAGS_BASETYPE, /* tp_flags */
  130.         pyinotify_doc, /* tp_doc */
  131.         0, /* tp_traverse */
  132.         0, /* tp_clear */
  133.         0, /* tp_richcompare */
  134.         0, /* tp_weaklistoffset */
  135.         0, /* tp_iter */
  136.         0, /* tp_iternext */
  137.         pyinotify_methods, /* tp_methods */
  138.         0, /* tp_members */
  139.         pyepoll_getsetlist, /* tp_getset */
  140.         0, /* tp_base */
  141.         0, /* tp_dict */
  142.         0, /* tp_descr_get */
  143.         0, /* tp_descr_set */
  144.         0, /* tp_dictoffset */
  145.         0, /* tp_init */
  146.         0, /* tp_alloc */
  147.         pyinotify_new, /* tp_new */
  148. };

  150. static PyModuleDef inotifymodule = {
  151.         PyModuleDef_HEAD_INIT,
  152.         "inotify",
  153.         "inotify - monitoring filesystem events",
  154.         -1,
  155.         NULL, NULL, NULL, NULL, NULL
  156. };

  158. PyMODINIT_FUNC
  159. PyInit_inotify(void)
  160. {
  161.         PyObject* m;

  163.         if (PyType_Ready(&pyinotify_type) < 0)
  164.                 return NULL;

  166.         m = PyModule_Create(&inotifymodule);
  167.         if (m == NULL)
  168.                 return NULL;

  170.         Py_INCREF(&pyinotify_type);
  171.         PyModule_AddObject(m, "inotify", (PyObject *)&pyinotify_type);

  173.         /* Supported events suitable for MASK parameter of INOTIFY_ADD_WATCH. */
  174.         PyModule_AddIntMacro(m, IN_ACCESS);
  175.         PyModule_AddIntMacro(m, IN_MODIFY);
  176.         PyModule_AddIntMacro(m, IN_ATTRIB);
  177.         PyModule_AddIntMacro(m, IN_CLOSE_WRITE);
  178.         PyModule_AddIntMacro(m, IN_CLOSE_NOWRITE);
  179.         PyModule_AddIntMacro(m, IN_CLOSE);
  180.         PyModule_AddIntMacro(m, IN_OPEN);
  181.         PyModule_AddIntMacro(m, IN_MOVED_FROM);
  182.         PyModule_AddIntMacro(m, IN_MOVED_TO);
  183.         PyModule_AddIntMacro(m, IN_MOVE);
  184.         PyModule_AddIntMacro(m, IN_CREATE);
  185.         PyModule_AddIntMacro(m, IN_DELETE);
  186.         PyModule_AddIntMacro(m, IN_DELETE_SELF);
  187.         PyModule_AddIntMacro(m, IN_MOVE_SELF);

  189.         /* Events sent by the kernel. */
  190.         PyModule_AddIntMacro(m, IN_UNMOUNT);
  191.         PyModule_AddIntMacro(m, IN_Q_OVERFLOW);
  192.         PyModule_AddIntMacro(m, IN_IGNORED);

  194.         /* Helper events. */
  195.         PyModule_AddIntMacro(m, IN_CLOSE);
  196.         PyModule_AddIntMacro(m, IN_MOVE);

  198.         /* Special flags. */
  199.         PyModule_AddIntMacro(m, IN_ONLYDIR);
  200.         PyModule_AddIntMacro(m, IN_DONT_FOLLOW);
  201.         PyModule_AddIntMacro(m, IN_EXCL_UNLINK);
  202.         PyModule_AddIntMacro(m, IN_MASK_ADD);
  203.         PyModule_AddIntMacro(m, IN_ISDIR);
  204.         PyModule_AddIntMacro(m, IN_ONESHOT);

  206.         /* All events which a program can wait on. */
  207.         PyModule_AddIntMacro(m, IN_ALL_EVENTS);
  208.  
  209.         /* supported flags for INOTIFY_INIT1. */
  210.         PyModule_AddIntMacro(m, IN_NONBLOCK);
  211.         PyModule_AddIntMacro(m, IN_CLOEXEC);

  213.         return m;
  214. }
这部分可以看作一个模板，大多C扩展都是这个框架
行1～12：特殊成员函数fileno，直接返回file descriptor，这基本是Python标准库的惯例了，所有封装file descriptor的类型都提供这个方法。
行39～53：特殊成员函数fromfd，根据已有fd，构造一个inotify对象，也是标准库的一个惯例。
行55～71：类型定义之一，成员函数定义表，Python就是通过该结构动态查找到对应的C函数，进而调用之。
行73～77：类型定义之一，属性定义表，inotify只定义了一个closed只读属性，判断fd是否关闭。
行79～90：类型对象的构造，相当于object.__new__，分配内存并提供必要的初始化，对象的reference count自动加1。
行92～97：类型对象的析构，与构造相反，清理一些外部资源（fd），释放内存，当对象的reference count为0时，就会调用该方法。
行99～148：类型定义最高层入口，索引一切类型信息，上面成员函数表/属性定义/对象构造析构函数都是其中的条目。
行150～156：模块定义，通常模块只是内部类型的容器，本身功能不多，从参数就可以看出来。
行158～215：模块初始化，这是整个模块内唯一的非静态函数，解释器加载模块的唯一入口。此处基本执行顺序就是初始化类型定义，初始化模块，然后模块载入类型定义，并添加了很多模块层的常量。

3. C扩展的编译 & 安装 & 测试。Python 3.3有一个比较有用的特性virtual environments，能以普通用户权限创建一个轻量级的虚拟环境，编译安装测试第三方模块很方便，不用自己再折腾环境变量和符号链接了，用法见，下面的测试就是基于Python 3.3的虚拟环境。

第一步，准备setup.py，供编译安装用，本文只用了几个参数，所以极其简单，其实setup.py支持很复杂的定制，大家可以查文档。

点击(此处)折叠或打开(setup.py)

  1. from distutils.core import setup, Extension
  2. setup(name="inotify", version="1.0",
  3.       ext_modules=[
  4.          Extension("inotify", ["inotifymodule.c"]),
  5.       ])

第二步，编译&安装：
  1. (py3) bash-4.2 $python setup.py build
  2. running build
  3. running build_ext
  4. building 'inotify' extension
  5. gcc -pthread -Wno-unused-result -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m32 -march=i686 -mtune=atom -fasynchronous-unwind-tables -D_GNU_SOURCE -fPIC -fwrapv -fPIC -I/home/lgr/venv/py3/include -I/usr/include/python3.3m -c inotifymodule.c -o build/temp.linux-i686-3.3/inotifymodule.o
  6. gcc -pthread -shared -Wl,-z,relro build/temp.linux-i686-3.3/inotifymodule.o -L/usr/lib -lpython3.3m -o build/lib.linux-i686-3.3/inotify.cpython-33m.so
  7. (py3) bash-4.2 $python setup.py install
  8. running install
  9. running build
  10. running build_ext
  11. running install_lib
  12. copying build/lib.linux-i686-3.3/inotify.cpython-33m.so -> /home/lgr/venv/py3/lib/python3.3/site-packages
  13. running install_egg_info
  14. Removing /home/lgr/venv/py3/lib/python3.3/site-packages/inotify-1.0-py3.3.egg-info
  15. Writing /home/lgr/venv/py3/lib/python3.3/site-packages/inotify-1.0-py3.3.egg-info
第三步，测试，用本节开始的notify3.py，监控的事件和第五节一致，即编译第四节C代码过程中目录的变化：
  1. (py3) bash-4.2 $python notify3.py .
  2. 17:16:34,668 file(.) IN_ISDIR IN_OPEN
  3. 17:16:34,668 file(.) IN_CLOSE_NOWRITE IN_ISDIR
  4. 17:16:34,668 file(Makefile) IN_OPEN
  5. 17:16:34,668 file(Makefile) IN_ACCESS
  6. 17:16:34,668 file(Makefile) IN_CLOSE_NOWRITE
  7. 17:16:34,676 file(notify1.c) IN_OPEN
  8. 17:16:34,676 file(notify1.c) IN_ACCESS
  9. 17:16:34,676 file(notify1.c) IN_CLOSE_NOWRITE
  10. 17:16:34,712 file(notify1) IN_CREATE
  11. 17:16:34,712 file(notify1) IN_OPEN
  12. 17:16:34,716 file(notify1) IN_CLOSE_WRITE
  13. 17:16:34,722 file(notify1) IN_OPEN
  14. 17:16:34,722 file(notify1) IN_MODIFY
  15. ......
  16. 17:16:34,723 file(notify1) IN_MODIFY
  17. 17:16:34,723 file(notify1) IN_ACCESS
  18. 17:16:34,723 file(notify1) IN_MODIFY
  19. 17:16:34,723 file(notify1) IN_CLOSE_WRITE
  20. 17:16:34,723 file(notify1) IN_ATTRIB
  21. 17:16:37,148 file(.) IN_ISDIR IN_OPEN
  22. 17:16:37,148 file(.) IN_CLOSE_NOWRITE IN_ISDIR
  23. 17:16:37,148 file(Makefile) IN_OPEN
  24. 17:16:37,148 file(Makefile) IN_ACCESS
  25. 17:16:37,148 file(Makefile) IN_CLOSE_NOWRITE
  26. 17:16:37,149 file(notify1) IN_DELETE

七. 终章

   从产生想法，到编码实现，然后调试修改，最后写blog，差不多用了一周，终于完成，如释重负啊。本人比较喜欢APUE & UNPv1 & UNPv2讲述技术问题的方式，先引入简单的概念，然后给一个示例，并附上完整源码，接着分析相关的代码行，穿插讲解理论和隐藏细节，最后编译运行，同时观察输出并验证前面的理论与猜测，如果后面章节出现更高级的工具，重新实现前面章节的那个示例，循环往复，读者对概念的认识会比较深刻。但大师的境界往往是我等凡人可望不可即的，只能成此拙文一篇，错漏之处在所难免，欢迎大家批评指正。

最后附上所有代码文件压缩包C代码，Makefile，Python代码

（全文完）
阅读(2669) | 评论(0) | 转发(1) |
0

上一篇：浅析Python调用外部代码的三种方式（中篇）

下一篇：Mac OS X编译UNIX环境高级编程（第二版）源码

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6