Vimer的程序世界 » 操作系统 http://www.vimer.cn Thu, 17 May 2012 11:40:36 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 最近的一些技术整理（20120405） http://www.vimer.cn/2012/04/%e6%9c%80%e8%bf%91%e7%9a%84%e4%b8%80%e4%ba%9b%e6%8a%80%e6%9c%af%e6%95%b4%e7%90%86%ef%bc%8820120405%ef%bc%89.html http://www.vimer.cn/2012/04/%e6%9c%80%e8%bf%91%e7%9a%84%e4%b8%80%e4%ba%9b%e6%8a%80%e6%9c%af%e6%95%b4%e7%90%86%ef%bc%8820120405%ef%bc%89.html#comments Thu, 05 Apr 2012 12:24:27 +0000 Dante http://www.vimer.cn/?p=2525 还是和往常一样，没啥主题，就是记录下这段时间遇到的技术问题，分享一下。

1. 在javascript中实现简单的模板替换

最近搞了一下js，最不习惯的就是字符串生成都要用字符串拼装或者join的方式，所以尝试一下看能否实现简单的模板替换，效果还不错。

1
2
3
4
5

function str_format(str, obj) {
    return str.replace(/\{\s*(\w+)\s*\}/g, function(_i, _1) {
        return obj[_1] != null ? obj[_1] : '';
    });
};

很多朋友会说性能差一些，可能确实如此，不过对我来说，相比编写的舒适来说，这点性能差别实在无足轻重了。

2. uwsgi报readv() faild

用uwsgi+nginx搭建的server，发现当用post请求时，会返回数据超时。查了一下uwsgi的error.log:

1

9825#0: *745262 readv() failed (104: Connection reset by peer) while reading upstream, client: 121.14.96.125

后来在网上搜了一下文档：
http://comments.gmane.org/gmane.comp.python.wsgi.uwsgi.general/1021

其解释说解决方案有两种：
在uwsgi执行参数上增加：

1
2

--pep333-input
--post-buffering 4096

试了一下，只有第二种有效，所以由于google了一下命令的具体含义：

post-buffering
打开http body缓冲, 如果HTTP body的大小超过指定的限制,那么就保存到磁盘上.

参考链接：
http://simple-is-better.com/news/301

OK，就是这样~

]]> http://www.vimer.cn/2012/04/%e6%9c%80%e8%bf%91%e7%9a%84%e4%b8%80%e4%ba%9b%e6%8a%80%e6%9c%af%e6%95%b4%e7%90%86%ef%bc%8820120405%ef%bc%89.html/feed 1 通过引用计数解决野指针的问题(C&C++) http://www.vimer.cn/2011/06/%e9%80%9a%e8%bf%87%e5%bc%95%e7%94%a8%e8%ae%a1%e6%95%b0%e8%a7%a3%e5%86%b3%e9%87%8e%e6%8c%87%e9%92%88%e7%9a%84%e9%97%ae%e9%a2%98cc.html http://www.vimer.cn/2011/06/%e9%80%9a%e8%bf%87%e5%bc%95%e7%94%a8%e8%ae%a1%e6%95%b0%e8%a7%a3%e5%86%b3%e9%87%8e%e6%8c%87%e9%92%88%e7%9a%84%e9%97%ae%e9%a2%98cc.html#comments Mon, 13 Jun 2011 11:44:43 +0000 Dante http://www.vimer.cn/?p=2207 C/C++代码中，野指针问题历来已久，当然，大家都知道new/delete要成对出现:

1
2
3

A *p = new A();
delete p;
p = NULL;

然而现实中却并不是总是如此简单，考虑如下例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class A
{
public:
    C() {}
    virtual ~C() {}
};
class B
{
public:
    B() {
        m_pA = NULL;
    }
    virtual ~B() {}
 
    void SetA(A* p)
    {
        m_pA = p;
    }
 
private:
    A* m_pA;
};
 
A* pA = new A();
B* pB = new B();
pB->SetA(pA);
 
delete pA;
pA = NULL;
//此时B中的m_pA已经无效，但是m_pA仍然不等于NULL，所以用 != NULL来判断不会有任何作用

简单来说，即pA被赋值为NULL，对B中的m_pA没有产生影响，那么怎么才能产生影响呢？
我们有两个做法：
第一种，在A的析构函数里面去B.SetA(NULL)，但是这个相当于A去操作了B的数据，这是不合理的。而且当外面的指针非常多的时候，也根本不可能实现。
第二种方法呢？是的，我们可以用二级指针。
考虑如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class A
{
public:
    C() {}
    virtual ~C() {}
};
class B
{
public:
    B() {
        m_ppA = NULL;
    }
    virtual ~B() {}
 
    void SetA(A** pp)
    {
        m_ppA = pp;
    }
 
private:
    A** m_ppA;
};
 
A** ppA = new (A*)();
 
(*ppA) = new A();
B* pB = new B();
 
pB->SetA(ppA);
 
delete (*ppA);
(*ppA) = NULL;
 
//这个时候，B中的m_ppA也会收到影响，即*m_ppA == NULL

这样确实可以解决野指针的问题，但是同时也引入了另一个问题，那就是ppA本身该什么时候释放呢？答案是：当最后一个引用ppA的类释放掉的时候。
最后一个，对，我们可以使用引用计数！
OK，正式放出我们的代码，其中使用了引用计数来确定当最后一个类释放掉的时候，ppA指针的内存被析构:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227

/*=============================================================================
#
#     FileName: ptr_proxy.h
#         Desc: 这个类的作用，就是为了解决互指指针，不知道对方已经析构的问题
#
#       Author: dantezhu
#        Email: zny2008@gmail.com
#     HomePage: http://www.vimer.cn
#
#      Created: 2011-06-13 15:24:12
#      Version: 0.0.1
#      History:
#               0.0.1 | dantezhu | 2011-06-13 15:24:12 | initialization
#
=============================================================================*/
 
#ifndef __PTR_PROXY_H__
#define __PTR_PROXY_H__
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <iostream>
#include <memory>
#include <sstream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;
 
template <typename T>
class ptr_proxy
{
public:
    ptr_proxy(const T* pobj=NULL) : m_ppobj(NULL), m_pcount(NULL)
    {
        if (pobj == NULL)
        {
            return;
        }
        init(pobj);
    }
 
    ptr_proxy(const ptr_proxy& rhs) // 拷贝构造函数
    {
        m_ppobj = rhs.m_ppobj; // 指向同一块内存
        m_pcount = rhs.m_pcount; // 使用同一个计数值
        add_count();
    }
 
    virtual ~ptr_proxy()
    {
        dec_count();
    }
 
    /**
     * @brief   如果指向的对象被释放了，一定要调用这个函数让他知道
     */
    void set2null()
    {
        if (m_ppobj)
        {
            (*m_ppobj) = NULL;
        }
    }
 
    /**
     * @brief   copy构造函数
     *
     * @param   rhs         被拷贝对象
     *
     * @return  自己的引用
     */
    ptr_proxy& operator=(const ptr_proxy& rhs)
    {
        if( m_ppobj == rhs.m_ppobj ) // 首先判断是否本来就指向同一内存块
            return *this; // 是则直接返回
 
        dec_count();
 
        m_ppobj = rhs.m_ppobj; // 指向同一块内存
        m_pcount = rhs.m_pcount; // 使用同一个计数值
        add_count();
 
        return *this; // 是则直接返回
    }
 
    ptr_proxy& operator=(const T* pobj)
    {
        if(m_ppobj && *m_ppobj == pobj) // 首先判断是否本来就指向同一内存块
            return *this; // 是则直接返回
        dec_count();
 
        init(pobj);
 
        return *this;
    }
 
    /**
     * @brief   获取内部关联的obj的指针
     *
     * @return
     */
    T* true_ptr()
    {
        if (m_ppobj)
        {
            return *m_ppobj;
        }
        else
        {
            return NULL;
        }
    }
 
    /**
     * @brief   获取内部关联的obj的指针
     *
     * @return
     */
    T* operator*()
    {
        return true_ptr();
    }
 
    /**
     * @brief   获取内部关联的obj的个数
     *
     * @return  个数
     */
    int count()
    {
        if (m_pcount != NULL)
        {
            return *m_pcount;
        }
        return 0;
    }
 
    /**
     * @brief   判断智能指针是否为空
     *
     * @return
     */
    bool is_null()
    {
        if (m_ppobj == NULL || (*m_ppobj) == NULL)
        {
            return true;
        }
        return false;
    }
 
protected:
    void init(const T* pobj)
    {
        m_ppobj = new (T*)();
        *m_ppobj = (T*)pobj;
        m_pcount = new int(); // 初始化计数值为 1
        *m_pcount = 1;
    }
 
    void add_count()
    {
        if (m_pcount == NULL)
        {
            return;
        }
        (*m_pcount) ++;
    }
 
    /**
     * @brief   计数减1
     */
    void dec_count()
    {
        if (m_pcount == NULL || m_ppobj == NULL)
        {
            return;
        }
 
        (*m_pcount)--; // 计数值减 1 ，因为该指针不再指向原来内存块了
        if( *m_pcount <= 0 ) // 已经没有别的指针指向原来内存块了
        {
            //我们不去主动析构对象
            //free_sptr(*m_ppobj);//把对象析构
            if (m_ppobj != NULL)
            {
                delete m_ppobj;
                m_ppobj = NULL;
            }
 
            if (m_pcount != NULL)
            {
                delete m_pcount;
                m_pcount = NULL;
            }
        }
    }
 
protected:
    T** m_ppobj;
    int* m_pcount;
};
 
template <typename T>
class IPtrProxy
{
public:
    IPtrProxy() {
        m_ptr_proxy = (T*)this;
    }
    virtual ~IPtrProxy() {
        m_ptr_proxy.set2null();
    }
 
    ptr_proxy<T>& get_ptr_proxy()
    {
        return m_ptr_proxy;
    }
 
protected:
    ptr_proxy<T> m_ptr_proxy;
};
 
#endif

我们来写段测试代码测试一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <iostream>
#include <memory>
#include <sstream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
 
#include "ptr_proxy.h"
 
using namespace std;
 
class A : public IPtrProxy<A>
{
public:
    A() {}
    virtual ~A() {}
};
 
class B : public IPtrProxy<B>
{
public:
    B() {}
    virtual ~B() {}
 
    void print()
    {
        printf("this is print\n");
    }
 
    void SetAPtr(const ptr_proxy<A>& pptr)
    {
        m_ptr_a = pptr;
    }
 
    void check()
    {
        if (m_ptr_a.is_null())
        {
            printf("is null\n");
        }
        else
        {
            printf("is not null\n");
        }
    }
 
    ptr_proxy<A> m_ptr_a;
};
 
int main(int argc, char **argv)
{
    A* a = new A();
    B* b = new B();
    b->SetAPtr(a->get_ptr_proxy());
    delete a;
    b->check();
 
    b->get_ptr_proxy().true_ptr()->print();
    delete b;
    return 0;
}

输出为:

is null
this is print

这个类最有效的使用场景是当出现大量互指指针时，那么指向对象的指针有效性判断就尤其重要，而这个类可以完美解决这个问题。

可能想的比较深的朋友会问，既然引用计数都已经用上了，那么为什么不直接通过引用计数来析构呢？
其实这几天我也在尝试，C++是否能引入完美的引用计数进行对象管理，而最终卡在一个地方，即：

如果，在类的构造函数里面，需要将引用计数对象构造出来，那么引用计数就会出现问题，如:

1
2
3
4
5
6
7
8
9

class A
{
public:
    A() {
        Count t(this);
    }
    virtual ~A() {}
};
Count c = new A();

这个时候就会出现问题，除非把Count构造的计数对象放到一个对象池中管理，但是又会增加对象查找的成本，所以最终放弃了这个想法。
另外一点就是，C/C++的指针在很多情况下是最方便的，过度的封装很可能会弄巧成拙，所以适度就好。

OK，惯例代码还是放到googlecode上：
http://code.google.com/p/vimercode/source/browse/#svn%2Ftrunk%2Fptr_proxy

目前代码使用中没有发现明显问题，欢迎大家交流~

]]> http://www.vimer.cn/2011/06/%e9%80%9a%e8%bf%87%e5%bc%95%e7%94%a8%e8%ae%a1%e6%95%b0%e8%a7%a3%e5%86%b3%e9%87%8e%e6%8c%87%e9%92%88%e7%9a%84%e9%97%ae%e9%a2%98cc.html/feed 12 最近遇到的问题整理(linux下创建线程内存泄漏,php的json_encode等) http://www.vimer.cn/2011/04/%e6%9c%80%e8%bf%91%e9%81%87%e5%88%b0%e7%9a%84%e9%97%ae%e9%a2%98%e6%95%b4%e7%90%86linux%e4%b8%8b%e5%88%9b%e5%bb%ba%e7%ba%bf%e7%a8%8b%e5%86%85%e5%ad%98%e6%b3%84%e6%bc%8fphp%e7%9a%84json_encode.html http://www.vimer.cn/2011/04/%e6%9c%80%e8%bf%91%e9%81%87%e5%88%b0%e7%9a%84%e9%97%ae%e9%a2%98%e6%95%b4%e7%90%86linux%e4%b8%8b%e5%88%9b%e5%bb%ba%e7%ba%bf%e7%a8%8b%e5%86%85%e5%ad%98%e6%b3%84%e6%bc%8fphp%e7%9a%84json_encode.html#comments Fri, 15 Apr 2011 12:30:37 +0000 Dante http://www.vimer.cn/?p=2170 这次还是把遇到的几个问题整理一下，希望再遇到的同学能轻松解决。另外最近博客的feeds延迟更新的原因也会一起说明一下。

1.linux下创建线程导致内存泄漏
今天在外网发布了一个server之后，用top发现virt的使用量一直在涨，而且一次涨8m。于是可以断定有内存泄漏了，经过排查，最终确定原因出在多线程的问题上:
代码如下:

1
2
3
4
5
6

pthread_t thread_id;
int ret=pthread_create(&thread_id, NULL, flush_thread_work, (void*)&m_sql_client);
if(ret!=0){
    APPSCORE_ERROR("Thread creation failed:%d",ret);
    return ret;
}

在flush_thread_work函数内部:

1
2
3
4
5

void* flush_thread_work(void* args)
{
    //....do something
    return NULL;
}

代码中启动了一个线程之后，主进程就继续执行，任由新线程自生自灭了（没有调用thread_join），而主进程每隔一段时间就会拉起这样一个线程来做一些数据落地的事情。

这样的写法实际上是会造成内存泄漏的.
Linux man page 里有已经说明了这个问题：

When a joinable thread terminates, its memory resources (thread descriptor and stack) are not deallocated until another thread performs pthread_join on it. Therefore, pthread_join must be called once for each joinable thread created to avoid memory leaks.

也就说线程执行完后如果不join的话，线程的资源会一直得不到释放而导致内存泄漏！

解决方法有两种:
a.在线程执行的函数内手工释放

1
2
3
4
5
6

void* flush_thread_work(void* args)
{
    //....do something
    pthread_detach(pthread_self());
    return NULL;
}

b.在线程启动时，设置线程的PTHREAD_CREATE_DETACHED属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14

pthread_attr_t attr;
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 
int ret=pthread_create(&thread_id, &attr, flush_thread_work, (void*)&m_sql_client);
if(ret!=0){
    //记住attr也要析构，否则又是一个内存泄漏
    pthread_attr_destroy (&attr);
    APPSCORE_ERROR("Thread creation failed:%d",ret);
    return ret;
} 
 
//记住attr也要析构，否则又是一个内存泄漏
pthread_attr_destroy (&attr);

这样问题就可以解决了。
参考资料:
解决了一个隐蔽的内存泄漏——pthread_create后没有detach导致内存持续增长

2.php的json_encode函数问题
在公司做了一个应用，是php与c++进行网络交互，所以选择了json这种比较通用的序列化格式，然而却遇到了比较奇怪的问题。
先来看如下代码(php):

1
2
3
4
5

$objs = array();
$objs[1] = 'a';
$objs[2] = 'b';
$objs[4] = 'd';
echo json_encode($objs)."\n";

输出的结果如下：

{"0":"a","1":"b","3":"d"}

这样是正常的，用jsoncpp也可以正确的解析出来，php自动将$objs当作一个关联数组来生成json数据了。
然而当把代码换成如下：

1
2
3
4
5
6

$objs = array();
$objs[0] = 'a';
$objs[1] = 'b';
$objs[2] = 'c';
$objs[3] = 'd';
echo json_encode($objs)."\n";

则输出结果如下:

["a","b","c","d"]

jsoncpp按照之前的解析方法是解析不出来的~
其实对php来说，这也是合理的，问题在于在php里面普通数组和关联数组都是array，而对c++来说，却存在vector和map之分，所以如果还是想要json_encode生成关联数组的格式，那么需要这样写:

1
2
3
4
5
6

$objs = array();
$objs[0] = 'a';
$objs[1] = 'b';
$objs[2] = 'c';
$objs[3] = 'd';
echo json_encode((object)$objs)."\n";

结果如下:

{"0":"a","1":"b","2":"c","3":"d"}

3.本博feed延迟不更新的原因
之前由于对feedsky的feed更新十分不满，所以参考网上的做法，建立了一个feed.vimer.cn，而本博所在的域名空间会自动根据域名创建一个子目录 - feed，修改这个目录下的.htaccess文件如下:

1
2
3
4
5

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule . http://feed.feedsky.com/vimer [L]
</IfModule>

那么当访问 feed.vimer.cn 时，会自动跳转到 http://feed.feedsky.com/vimer。
然而我忽略了一个问题，那就是wordpress默认的feed链接是 http://vimer.cn/feed/rss2，而/feed/rss2会被解析成子目录，从而自动跳转到 http://feed.feedsky.com/vimer ，所以feedsky就会不停的读 http://feed.feedsky.com/vimer 这个链接的feed，当然不会有任何新数据。。

所以最后还是把这种方式废弃掉了，看来真是冤枉了feedsky呀~~~

OK，最近的总结就这么多~

]]> http://www.vimer.cn/2011/04/%e6%9c%80%e8%bf%91%e9%81%87%e5%88%b0%e7%9a%84%e9%97%ae%e9%a2%98%e6%95%b4%e7%90%86linux%e4%b8%8b%e5%88%9b%e5%bb%ba%e7%ba%bf%e7%a8%8b%e5%86%85%e5%ad%98%e6%b3%84%e6%bc%8fphp%e7%9a%84json_encode.html/feed 16 有限状态机的C++实现(2)-bayonet开源网络服务器框架 http://www.vimer.cn/2011/02/%e6%9c%89%e9%99%90%e7%8a%b6%e6%80%81%e6%9c%ba%e7%9a%84%e5%ae%9e%e7%8e%b02-bayonet%e5%bc%80%e6%ba%90%e7%bd%91%e7%bb%9c%e6%9c%8d%e5%8a%a1%e5%99%a8%e6%a1%86%e6%9e%b6.html http://www.vimer.cn/2011/02/%e6%9c%89%e9%99%90%e7%8a%b6%e6%80%81%e6%9c%ba%e7%9a%84%e5%ae%9e%e7%8e%b02-bayonet%e5%bc%80%e6%ba%90%e7%bd%91%e7%bb%9c%e6%9c%8d%e5%8a%a1%e5%99%a8%e6%a1%86%e6%9e%b6.html#comments Fri, 18 Feb 2011 08:35:39 +0000 Dante http://www.vimer.cn/?p=1983 接着上一篇文章: 有限状态机的C++实现(1)-epoll状态机，我们今天来介绍更复杂和深入的部分。

为什么会在标题中提到bayonet这个开源项目呢？笔者本人一直想要写一套架构优美、功能完善的异步server框架，也看过很多朋友、同事实现的版本，虽然功能上基本能满足需求，但是架构上我却始终觉得是有瑕疵的，直到后来和同事讨论，发现可以让一个客户端请求的到来作为一个session，而之后的每一次与其他server的交互都可以看作是一次状态转化，才感觉架构比较合理了。

简单来说即，一个session从开始到介绍会经历两种状态机的变化：

  • 1.业务逻辑层面的状态变化，例如先验证登录态，再验证权限，再获取用户资料
  • 2.每一个与其他server交互的socket自身的状态变化，如recv、send、等，而socket的状态变化会触发逻辑层的状态变化。

按照这种思路，目前的代码开发已经完成了70%，即可以正常的进行一个session的开始和结束，主要还缺一些细节的代码，比如超时的检测及超时之后的处理，健全的统计之类。好了，我们来用vs看一下代码的整体类图（图压缩比较严重，请单击后查看）：

1

每个类的用处已经在途中简单说明了，这里就不再赘述，我们重点来看一下用这个框架来实现一个逻辑server时需要做哪些事情。
svr2目录下的main.cpp即实现了一个最简单的server，我们按部分来看其实现:
1.逻辑层状态的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class CAppFsmLogic1 : public CAppFsmBase
{
public:
    virtual ~CAppFsmLogic1 () {}
    virtual int HandleEntry(CActionInfoSet *pActionInfoSet, CAppActorBase* pAppActor)
    {
        static CActionFirst actionFirst;
        StActionInfoParam param;
        param.id = 1;
        param.ip = "127.0.0.1";
        param.port = 100;
        param.protoType = PROTO_TYPE_UDP;
        param.pAction = &actionFirst;
        param.actionType = ACTIONTYPE_SENDONLY;
        param.timeout_ms = 1000;
 
        CActionInfo * pActionInfo = new CActionInfo();
        pActionInfo->Init(param);
        pActionInfo->SetAppActor(pAppActor);
        pActionInfoSet->Add(pActionInfo);
        return 0;
    }
    virtual int HandleProcess(CActionInfoSet *pActionInfoSet, CAppActorBase* pAppActor)
    {
        trace_log("HandleProcess");
        set<CActionInfo*> &setAction = pActionInfoSet->GetActionSet();
        for(set<CActionInfo*>::iterator it = setAction.begin(); it != setAction.end(); ++it)
        {
            trace_log("error no:%d",(*it)->GetErrno());
        }
        return APP_FSM_RSP;//代表要回复客户端啦
    }
    virtual int HandleExit(CActionInfoSet *pActionInfoSet, CAppActorBase* pAppActor)
    {
        return 0;
    }
};

CAppFsmLogic1是一个逻辑层的状态:

  • 1.HandleEntry代表当这个状态第一次进入的时候要做的事情，其函数中创建了一个向其他server发包的action(CActionFirst的定义我们在后面介绍)。
  • 2.HandleProcess代表当这个状态的所有action都完成时需要做的事情，return APP_FSM_RSP;代表向客户端回包

看到这里大家应该很奇怪，对于每一个socket，判断收包长度以及受到包之后的解包在哪里完成呢？所以我们还需要定义action:
2.action的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#define APP_FSM_LOGIC1 2000
 
class CAppFsmLogic1;
class CActionFirst : public IAction
{
public:
    // 为发送打包
    int HandleEncodeSendBuf(
            IActor* pSocketActor,
            IActor* pAppActor,
            string & strSendBuf,
            int &len)
    {
        trace_log("send");
        strSendBuf="woainizhende111111";
        len = strSendBuf.size();
        return 0;
    }
 
    // 回应包完整性检查
    int HandleInput(
            IActor* pSocketActor,
            IActor* pAppActor,
            const char *buf,
            int len)
    {
        return len;
    }
 
    // 回应包解析
    int HandleDecodeRecvBuf(
            IActor* pSocketActor,
            IActor* pAppActor,
            const char *buf, 
            int len)
    {
        CAppActorBase * app_actor = new CAppActorBase();
        app_actor->AttachFrame(pSocketActor->GetFrame());
        app_actor->AttachCommu(pSocketActor);
        app_actor->ChangeState(APP_FSM_LOGIC1);
        trace_log("listen tcp HandleDecodeRecvBuf");
        return 0;
    }
};

每个函数的意义已经在代码中说明了，可以看出在HandleDecodeRecvBuf中创建逻辑层的actor: app_actor，并ChangeState为APP_FSM_LOGIC1。
最后就是main函数的实现了:
3.main函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int main(int argc, const char *argv[])
{
    CBayonetFrame srv;
    StFrameParam param;
    param.ip="0.0.0.0";
    param.port = 10001;
    param.bKeepcnt= true;
    //param.protoType = PROTO_TYPE_UDP;
    param.protoType = PROTO_TYPE_TCP;
    param.pAction = new CActionFirst();
 
    srv.Init(param);
    srv.RegFsm(APP_FSM_LOGIC1,new CAppFsmLogic1());
    srv.Process();
    return 0;
}

注释的部分是可以随时切换TCP还是UDP的。
当然作为一个server来说，这里还是太过简单了，比如信号的处理等都没有加上，但是笔者认为那是业务代码需要做的逻辑，所以并没有放到框架中。

OK，整个项目的结构就是这个样子了。
但是也不得不说点扫兴的话，由于笔者最近有另外一个项目需要投入大量的精力，所以该项目的更新可能会被延缓，这是我所不愿意看到的，所以很希望有志同道合的朋友能够加入到这个项目的开发中来，一起把这个事情做出来。

按照我当初的想法，压力测试框架fuload已经就绪了，等到bayonet完成，我们就用fuload来测试一下bayonet的性能究竟如何。

最后，附上bayonet的项目地址:
http://code.google.com/p/bayonet/
十分欢迎大家感兴趣的朋友与我联系。

]]> http://www.vimer.cn/2011/02/%e6%9c%89%e9%99%90%e7%8a%b6%e6%80%81%e6%9c%ba%e7%9a%84%e5%ae%9e%e7%8e%b02-bayonet%e5%bc%80%e6%ba%90%e7%bd%91%e7%bb%9c%e6%9c%8d%e5%8a%a1%e5%99%a8%e6%a1%86%e6%9e%b6.html/feed 4 有限状态机的C++实现(1)-epoll状态机 http://www.vimer.cn/2011/01/%e6%9c%89%e9%99%90%e7%8a%b6%e6%80%81%e6%9c%ba%e7%9a%84c%e5%ae%9e%e7%8e%b01-epoll%e7%8a%b6%e6%80%81%e6%9c%ba.html http://www.vimer.cn/2011/01/%e6%9c%89%e9%99%90%e7%8a%b6%e6%80%81%e6%9c%ba%e7%9a%84c%e5%ae%9e%e7%8e%b01-epoll%e7%8a%b6%e6%80%81%e6%9c%ba.html#comments Thu, 20 Jan 2011 03:55:03 +0000 Dante http://www.vimer.cn/?p=1965 之前公司的同事写了一个基于epoll的网络服务器，其中涉及到socket状态的转化(如等待接收，接收中，接收完成等)，以及socket之间的转化（如验证完ip权限之后，验证完登录态），可见是一个多层次的状态机。
但是在原来的实现中却并没有使用状态模式，导致整个逻辑非常复杂，状态之间的跳转也很难把握。本系列的文章将会通过状态模式来重构整套代码。

状态机模式本身这里就不做详细介绍了，读者可以google一下，笔者在仔细对比过《设计模式之禅》，《研磨设计模式》以及游戏中NPC状态机的实现之后，抽象了如下的一套接口.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

/*=============================================================================
#  Author:          dantezhu - http://www.vimer.cn
#  Email:           zny2008@gmail.com
#  FileName:        interfaces.h
#  Description:     公共接口
#  Version:         1.0
#  LastChange:      2011-01-19 23:24:33
#  History:         
=============================================================================*/
#ifndef _INTERFACES_H_
#define _INTERFACES_H_
#include <iostream>
#include <map>
using namespace std;
 
class IFsm;
 
class IActor
{
public:
    virtual ~IActor() {}
    virtual int AttachFsmMgr(map<int, IFsm*> *mapFsmMgr)=0;
    virtual int ChangeState(int destState)=0;
};
 
 
class IFsm
{
public:
    virtual ~IFsm() {}
    /**
     * @brief   在进入这个状态的时候，obj需要做的事情
     *
     * @param   obj
     *
     * @return  0           succ
     *          else        fail
     */
    virtual int Init(IActor* obj)=0;
 
    /**
     * @brief   执行这个状态该做的事情
     *
     * @param   obj
     *
     * @return  应该进入的另一个状态
     *          0           结束本次Process执行，不进入其他状态
     *          <0          结束整个请求（obj需要被后续删除）
     *          else        其他状态（可以返回自己，但是会造成循环，有点危险）
     *          
     */
    virtual int Process(IActor* obj)=0;
 
    /**
     * @brief   退出这个状态时需要做的事情
     *
     * @param   obj
     *
     * @return  0           succ
     *          else        fail
     */
    virtual int Fini(IActor* obj)=0;
};
 
#endif

IActor是整个状态转化所依附的实体，比如socket可以是recv状态，也可是send状态，那么socket就是一个IActor；而IFsm是状态类的抽象，其中的Init，Process，Fini几个函数都只有一个参数即IActor* obj，IFsm的具体实现类会根据情况来调用obj不同的函数（action）。
所以这里有两个问题:

  • 1.代码中可以看出IFsm是无状态的，即IFsm本身不会存储obj的任何数据，那么为什么不把IFsm的几个函数都定义成static类型呢？这里笔者思索了很久，最终的结论是由于语言的问题，如果是在python中，那么是可以直接传递类名来作为参数的，而在C++中，只能传递一个类的实例在作为参数，这就是原因。
  • 2.既然Process注释中说明返回的是下一个状态，那为什么不直接返回一个IFsm指针，而是返回数字呢，这里会在下面的代码中回答

定义了状态之后，我们还缺少一个状态管理器：

1

map<int, IFsm* > m_mapFsmMgr;

这个是定义在后面会介绍的world里的，之所以有这个管理器

  • 1.是因为C++不同于python，可以直接传递类名
  • 2.通过int来做映射能够更好的实现配置化

所以在状态机启动之前，一般需要有如下代码:

1
2
3

m_mapFsmMgr[1]=new CWaitSendFsm();
m_mapFsmMgr[2]=new CSendingFsm();
m_mapFsmMgr[3]=new CSendOverFsm();

那这里还有一个异议，即有的书上推荐将状态指针定义成CFsmMgr的static变量，当进行状态转化的时候，直接用这个指针即可。但是因为配置化以及底层逻辑与应用逻辑分离的原因，这里个人不建议用如下方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class CFsmMgr
{
public:
    CFsmMgr () {}
    virtual ~CFsmMgr () {}
 
public:
    static IFsm* WaitSendFsmObj;
    static IFsm* SendingFsmObj;
    static IFsm* SendOverFsmObj;
};
IFsm* CFsmMgr::WaitSendFsmObj = new CWaitSendFsm();
IFsm* CFsmMgr::SendingFsmObj = new CSendingFsm();
IFsm* CFsmMgr::SendOverFsmObj = new CSendOverFsm();

接下来是Actor的基类实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

class CBaseActor : public IActor
{
public:
    CBaseActor () {
        m_Fsm = NULL;
        m_mapFsmMgr = NULL;
    }
    virtual ~CBaseActor () {}
 
    int AttachFsmMgr(map<int, IFsm*> * mapFsmMgr)
    {
        m_mapFsmMgr = mapFsmMgr;
        return 0;
    }
 
    int ChangeState(int destState)
    {
        if (m_mapFsmMgr == NULL)
        {
            return -1;
        }
 
        if (0 == destState)
        {
            //此次处理结束
            return 0;
        }
        else if (destState < 0)
        {
            //需要关闭整个请求
            return destState;
        }
        IFsm * destFsm = NULL;
        destFsm = (*m_mapFsmMgr)[destState];
        int state = doChangeFsm(destFsm);
        return ChangeState(state);
    }
private:
    int doChangeFsm(IFsm* destFsm)
    {
        if (destFsm == NULL)
        {
            return 0;
        }
 
        if (m_Fsm != destFsm)
        {
            if (m_Fsm != NULL)
            {
                m_Fsm->Fini(this);
            }
            m_Fsm = destFsm;
            m_Fsm->Init(this);
        }
        return m_Fsm->Process(this);
    }
 
 
protected:
    IFsm* m_Fsm;
    map<int, IFsm*> *m_mapFsmMgr;
};

这个代码也是实现了Actor进行状态转化时的一些逻辑，对于状态转化的触发一般会有两种方式:

  • 1.外界调用ChangeState，即由外界触发-如epoll出发的recv事件导致socket的状态转化成recving
  • 2.状态在执行Process之后自行转化为其他状态-如recving状态在recv结束之后自动转化为recvover状态

所以基于第二点的原因，上面的代码中实现了递归调用的逻辑（这里在状态机的设计中需要注意环的出现）。
下面是一个继承自Actor基类的socketActor，实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class CSocketActor : public CBaseActor
{
public:
    CSocketActor () {}
    virtual ~CSocketActor () {}
 
    int HandleSend()
    {
        cout<<"sending"<<endl;
        if (rand() % 5 == 0)
        {
            //代表发送完了
            return 1;
        }
        return 0;
    }
    int HandleRecv()
    {
        cout<<"recving"<<endl;
        return 0;
    }
    int HandleError()
    {
        cout<<"error"<<endl;
        return 0;
    }
    int HandleTimeout()
    {
        cout<<"timeout"<<endl;
        return 0;
    }
};

再来看一下状态类的具体实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//waitsend sending sendover waitrecv recving recvover waitclose closing closeover error timeout
 
class CWaitSendFsm : public IFsm
{
public:
    CWaitSendFsm () {}
    virtual ~CWaitSendFsm () {}
    virtual int Init(IActor* obj)
    {
        cout<<"Init WaitSend"<<endl;
        return 0;
    }
    virtual int Process(IActor* obj)
    {
        cout<<"Process WaitSend"<<endl;
        return 0;
    }
    virtual int Fini(IActor* obj)
    {
        cout<<"Fini WaitSend"<<endl;
        return 0;
    }
};
class CSendingFsm : public IFsm
{
public:
    CSendingFsm () {}
    virtual ~CSendingFsm () {}
    virtual int Init(IActor* obj)
    {
        cout<<"Init Sending"<<endl;
        return 0;
    }
    virtual int Process(IActor* obj)
    {
        cout<<"Process Sending"<<endl;
        CSocketActor * chirdObj = (CSocketActor*) obj;
        int ret = chirdObj->HandleSend();
        if (ret == 1)
        {
            return 3;
        }
        return 0;
    }
    virtual int Fini(IActor* obj)
    {
        cout<<"Fini Sending"<<endl;
        return 0;
    }
};
class CSendOverFsm : public IFsm
{
public:
    CSendOverFsm () {}
    virtual ~CSendOverFsm () {}
    virtual int Init(IActor* obj)
    {
        cout<<"Init SendOver"<<endl;
        return 0;
    }
    virtual int Process(IActor* obj)
    {
        cout<<"Process SendOver"<<endl;
        return 0;
    }
    virtual int Fini(IActor* obj)
    {
        cout<<"Fini SendOver"<<endl;
        return 0;
    }
};

OK，这样一切准备工作就完成，暂时先不把真正的epoll引入进来，我们来模拟一个epoll环境（比较假，没有考虑状态的顺序，大家能明白就行）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

class CWorld
{
public:
    CWorld () {
        srand(time(NULL));
    }
    virtual ~CWorld () {}
 
    int Init()
    {
        int count = 10;
 
        m_mapFsmMgr[1]=new CWaitSendFsm();
        m_mapFsmMgr[2]=new CSendingFsm();
        m_mapFsmMgr[3]=new CSendOverFsm();
 
        for (int i = 0; i < count; i++)
        {
            IActor * actor = new CSocketActor();
            m_vecActors.push_back(actor);
 
            actor->AttachFsmMgr(&m_mapFsmMgr);
            actor->ChangeState(1);
        }
        return 0;
    }
    int Run()
    {
        while (true)
        {
            int state = 0;
            int val = rand() % 5;
            switch(val)
            {
                case 0:
                case 1:
                    state = 1;
                    break;
                case 2:
                    state = 2;
                    break;
                default:
                    state = 3;
                    break;
            }
            foreach (m_vecActors, it)
            {
                (*it)->ChangeState(state);   
            }
            sleep(1);
        }
        return 0;
    }
 
private:
    vector<IActor*> m_vecActors;
    map<int, IFsm* > m_mapFsmMgr;
};

main函数如下:

1
2
3
4
5
6
7
8

#include "fsm_achieve.h"
int main(int argc, const char *argv[])
{
    CWorld world;
    world.Init();
    world.Run();
    return 0;
}

执行结果如下（部分）:

Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Init WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend
Process WaitSend

这样，一个一层的状态机就实现出来了~后面的文章，我们会面向应用来讨论两层状态机的实现。
附:
代码下载

]]> http://www.vimer.cn/2011/01/%e6%9c%89%e9%99%90%e7%8a%b6%e6%80%81%e6%9c%ba%e7%9a%84c%e5%ae%9e%e7%8e%b01-epoll%e7%8a%b6%e6%80%81%e6%9c%ba.html/feed 18 最近遇到的几个C++问题(隐式转化，字节对齐) http://www.vimer.cn/2011/01/%e6%9c%80%e8%bf%91%e9%81%87%e5%88%b0%e7%9a%84%e5%87%a0%e4%b8%aac%e9%97%ae%e9%a2%98%e9%9a%90%e5%bc%8f%e8%bd%ac%e5%8c%96%ef%bc%8c%e5%ad%97%e8%8a%82%e5%af%b9%e9%bd%90.html http://www.vimer.cn/2011/01/%e6%9c%80%e8%bf%91%e9%81%87%e5%88%b0%e7%9a%84%e5%87%a0%e4%b8%aac%e9%97%ae%e9%a2%98%e9%9a%90%e5%bc%8f%e8%bd%ac%e5%8c%96%ef%bc%8c%e5%ad%97%e8%8a%82%e5%af%b9%e9%bd%90.html#comments Thu, 13 Jan 2011 10:28:30 +0000 Dante http://www.vimer.cn/?p=1947 最近遇到了几个C++问题，在这里总结一下，希望可以避免其他朋友犯同样的错误。
一.隐式转换引发的血案
我们直接来看一段代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;
 
void a(bool input)
{
    cout<<"I amd first"<<endl;
    cout<<input<<endl;
}
 
void a(const string &input)
{
    cout<<"I amd second"<<endl;
    cout<<input<<endl;
}
 
int main(int argc,char **argv)
{
    a("str");  // 是调用第二个a函数吗?
    a(string("str"));
    return 0;
}

运行结果会是啥呢？好吧，可能让你失望了，结果如下:

I amd first
1
I amd second
str

char*类型的"str"居然被隐式转化成了bool类型，我简单做了一下测试:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;
int main(int argc, const char *argv[])
{
    int a = 1;
    char * b = "wo";
    float c = 1.1;
 
    bool x;
    x = a;
    x = b;
    x = c;
    return 0;
}

int,char*,float确实都可以隐式转化成bool而不会有任何警告，导致出现问题很不容易发现，这里在重载函数的时候确实需要万分注意。

二.字节对齐引发的惨案
先来介绍一下背景，我这里有个server，会在运行时调用一个so，正常情况下都一切正常，但是在引用了一个第三方给的头文件之后，在调用so的一个函数的时候就会core掉。
百思不得其解之下，去看了一下那个第三方头文件的定义:

1
2
3
4
5
6
7

#ifndef HEADER_OPENAPILOG_PROTOCOL
#define HEADER_OPENAPILOG_PROTOCOL
#pragma pack(1)
 
//一些结构体定义
 
#endif

只调用了#pragma pack(1)却没有在文件结束时调用#pragma pack()！而我的主调server虽然重新编译了，但是so却没有重新编译，导致其共用的结构体一个做了字节对齐，一个没有做。
修改成如下即正常:

1
2
3
4
5
6
7
8

#ifndef HEADER_OPENAPILOG_PROTOCOL
#define HEADER_OPENAPILOG_PROTOCOL
#pragma pack(1)
 
//一些结构体定义
 
#pragma pack()
#endif

每个复杂的问题背后都有一个简单的原因，OK，就这样。

]]> http://www.vimer.cn/2011/01/%e6%9c%80%e8%bf%91%e9%81%87%e5%88%b0%e7%9a%84%e5%87%a0%e4%b8%aac%e9%97%ae%e9%a2%98%e9%9a%90%e5%bc%8f%e8%bd%ac%e5%8c%96%ef%bc%8c%e5%ad%97%e8%8a%82%e5%af%b9%e9%bd%90.html/feed 20 关于柔性服务的一些实践和思考 http://www.vimer.cn/2011/01/%e5%85%b3%e4%ba%8e%e6%9f%94%e6%80%a7%e6%9c%8d%e5%8a%a1%e7%9a%84%e4%b8%80%e4%ba%9b%e5%ae%9e%e8%b7%b5%e5%92%8c%e6%80%9d%e8%80%83.html http://www.vimer.cn/2011/01/%e5%85%b3%e4%ba%8e%e6%9f%94%e6%80%a7%e6%9c%8d%e5%8a%a1%e7%9a%84%e4%b8%80%e4%ba%9b%e5%ae%9e%e8%b7%b5%e5%92%8c%e6%80%9d%e8%80%83.html#comments Wed, 12 Jan 2011 12:39:06 +0000 Dante http://www.vimer.cn/?p=1938 最近花了大力气在做openapi的优化，使其尽量柔性可用，借此也有些想法想和大家分享一下。
柔性服务，google一下，在网上并没有这样一个标准的概念，所以应该是公司自己取的一个名字。但是这种概念，相信大家都应该很容易能明白，即:

最大程度的保证关键服务的可用性

通俗点来说，一个人不能走路了，他起码可以说话，不能说话了，起码可以点头，头都不能点了，起码得能活着，即心脏还在跳动。这就是柔性。
对应互联网服务来说就是要实现两点:

1.要尽可能成功返回关键数据
2.要尽可能正常接收请求，不能堵死

笔者总结了一下，只要CGI满足其中一个或几个特点，就可以考虑使用柔性服务:

1.在整个CGI的执行过程中，存在关键路径和非关键路径
2.CGI中存在循环调用接口，导致执行时间不确定

我们分上面两种特点来看:
对于第一种，我们举一个简单的例子，比如有一个CGI，做了两件事情分别是:

1.验证登录态
2.获取用户信息

很明显可以看出，验证登录态这个接口是关键路径，而获取用户信息这个接口是非关键的。所以按照柔性服务的定义，当获取用户信息接口失败时，起码还应该返回登录成功。
但是这个时候毕竟还是要区分出完全成功和部分成功的，所以我们可以定义返回码如下(目前腾讯社区开放平台的openapi就是如下定义):

ret==0:完全成功
0<ret<1000:部分成功
ret>=1000:完全失败

这样就很明白了，我们在调用获取个人信息接口失败是，返回ret=1即可。

但是这样是否足够了呢？
考虑一下，如果获取个人信息接口此时是超时，那么会导致整个CGI的返回变慢，从而导致接收进程挂死。此时虽然我们做了所谓的柔性服务，但是仍然是无法正常提供服务的。

怎么解决呢？我们需要一个能够动态调整超时时间的算法，当接口的响应时间远大于平常的平均值时，分配给接口的超时时间也要响应的调小。
伪编码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

EMA g_CGITimeoutMng;//超时时间管理
 
class CCGI 
{
    public:
        CCGI ()
        {
            m_TrueRet=0;
            g_CGITimeoutMng.start();
        }
        virtual ~CCGI ()
        {
            g_CGITimeoutMng.stop();
        }
 
        int HandleInput()
        {
            int ret = check_login(g_CGITimeoutMng.remainTime());
            if (ret!=0)
            {
                return 1000;
            }
            ret = get_profile(g_CGITimeoutMng.remainTime());
            if (ret!=0)
            {
                m_TrueRet++;
            }
            return m_TrueRet;
        }
    private:
        int m_TrueRet;//容错返回码
};

那这里的动态调整算法使用什么呢？目前使用的是EMA来估算出下一时间点应当分配的超时时间，EMA一开始是用于股票的，后来公司的某大牛将其引入进来动态计算超时时间，大家可以google一下EMA的定义。

现在看来问题是解决了，但是这里会有一个比较大的限制，即:

关键路径和非关键路径要有明确的分割，即不可以颠倒顺序，或者互相穿插

但是万一就是有出现不符合这种限制的情况，该怎么办呢？其实也是有解决方法的，之前我们是只定义了一个g_CGITimeoutMng，他负责分配CGI的总处理时间，但是我们还可以再定义一个g_InterfaceTimeoutMng1，来动态调整某个接口的超时时间。
一般情况下我们仅需要对非关键接口加上这种单独的调整，并且取g_CGITimeoutMng.remainTime()和g_InterfaceTimeoutMng1.remainTime()中的较小值。
示例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

EMA g_CGITimeoutMng;//超时时间管理
EMA g_InterfaceTimeoutMng1;//超时时间管理
class CCGI 
{
    public:
        CCGI ()
        {
            m_TrueRet=0;
            g_CGITimeoutMng.start();
        }
        virtual ~CCGI ()
        {
            g_CGITimeoutMng.stop();
        }
 
        int HandleInput()
        {
            int ret = check_login(g_CGITimeoutMng.remainTime());
            if (ret!=0)
            {
                return 1000;
            }
            g_InterfaceTimeoutMng1.start()
            timeout = g_CGITimeoutMng.remainTime()<g_InterfaceTimeoutMng1.remainTime()?g_CGITimeoutMng.remainTime():g_InterfaceTimeoutMng1.remainTime()
            ret = get_profile(timeout);
            g_InterfaceTimeoutMng1.stop();
            if (ret!=0)
            {
                m_TrueRet++;
            }
            ret = check_right(g_CGITimeoutMng.remainTime());
            if (ret!=0)
            {
                return 1001;
            }
            return m_TrueRet;
        }
    private:
        int m_TrueRet;//容错返回码
};

这样的话，基本就可以完美解决了。

再回来说一下第二种，即有循环调用的问题，其实要做柔性的主要原因也是因为如果不计算使用的时间而直接容错的话，会导致时间很长。
示例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

EMA g_CGITimeoutMng;//超时时间管理
 
class CCGI 
{
    public:
        CCGI ()
        {
            m_TrueRet=0;
            g_CGITimeoutMng.start();
        }
        virtual ~CCGI ()
        {
            g_CGITimeoutMng.stop();
        }
 
        int HandleInput()
        {
            int ret;
            for (i = 0; i < count; i++)
            {
                ret = get_somedata(g_CGITimeoutMng.remainTime());
                if (ret!=0)
                {
                    m_TrueRet++;
                    continue;
                }
                //做取到数据之后该做的事情
            }
            return m_TrueRet;
        }
    private:
        int m_TrueRet;//容错返回码
};

PS:

上面的代码在调用接口接口之前并没有判断g_CGITimeoutMng.remainTime()<=0，这是因为我们假定接口内部对timeout<=0都是直接返回错误的。如果不是这样的话，需要在调用接口前进行判断。

这样，服务才能做到真正的柔性可用。

]]> http://www.vimer.cn/2011/01/%e5%85%b3%e4%ba%8e%e6%9f%94%e6%80%a7%e6%9c%8d%e5%8a%a1%e7%9a%84%e4%b8%80%e4%ba%9b%e5%ae%9e%e8%b7%b5%e5%92%8c%e6%80%9d%e8%80%83.html/feed 4 C,C++中调用python脚本(2)-高级应用 http://www.vimer.cn/2010/12/cc%e4%b8%ad%e8%b0%83%e7%94%a8python%e8%84%9a%e6%9c%ac2-%e9%ab%98%e7%ba%a7%e5%ba%94%e7%94%a8.html http://www.vimer.cn/2010/12/cc%e4%b8%ad%e8%b0%83%e7%94%a8python%e8%84%9a%e6%9c%ac2-%e9%ab%98%e7%ba%a7%e5%ba%94%e7%94%a8.html#comments Tue, 14 Dec 2010 15:17:40 +0000 Dante http://www.vimer.cn/?p=1874 还是先说一下背景吧，之前有写过C,C++代码中调用python脚本，但也仅是停留在浅尝辄止的地步，这次由于在fuload中要实现调用python的脚本，所以继续深入了解了一下。
提前打好招呼，这篇文章有点长，但是信息量也比较大，如果感兴趣希望能耐心读下去。
另外，文章中的代码都可以直接到fuload项目下看到:
http://code.google.com/p/fuload/source/browse/#svn/trunk/src/slave/py_module
先来看一下so的cpp文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <python2.7/Python.h>
using namespace std;
 
#define PYMODULE_NAME   "fl_module"
#define PYFUNC_INIT     "fuload_handle_init"
#define PYFUNC_PROCESS  "fuload_handle_process"
#define PYFUNC_FINI     "fuload_handle_fini"
 
#define PYMODULE_PATH   "../py_module/"
 
PyObject * g_pModule = NULL;
PyObject * g_pInitFunc = NULL;
PyObject * g_pProcessFunc = NULL;
PyObject * g_pFiniFunc = NULL;
 
string log_python_exception()
{
    std::string strErrorMsg;
    if (!Py_IsInitialized())
    {
        strErrorMsg = "Python 运行环境没有初始化！";
        return strErrorMsg;
    }
 
    if (PyErr_Occurred() != NULL)
    {
        PyObject *type_obj, *value_obj, *traceback_obj;
        PyErr_Fetch(&type_obj, &value_obj, &traceback_obj);
        if (value_obj == NULL)
            return strErrorMsg;
 
        PyErr_NormalizeException(&type_obj, &value_obj, 0);
        if (PyString_Check(PyObject_Str(value_obj)))
        {
            strErrorMsg = PyString_AsString(PyObject_Str(value_obj));
        }
 
        if (traceback_obj != NULL)
        {
            strErrorMsg += "Traceback:";
 
            PyObject * pModuleName = PyString_FromString("traceback");
            PyObject * pTraceModule = PyImport_Import(pModuleName);
            Py_XDECREF(pModuleName);
            if (pTraceModule != NULL)
            {
                PyObject * pModuleDict = PyModule_GetDict(pTraceModule);
                if (pModuleDict != NULL)
                {
                    PyObject * pFunc = PyDict_GetItemString(pModuleDict,"format_exception");
                    if (pFunc != NULL)
                    {
                        PyObject * errList = PyObject_CallFunctionObjArgs(pFunc,type_obj,value_obj, traceback_obj,NULL);
                        if (errList != NULL)
                        {
                            int listSize = PyList_Size(errList);
                            for (int i=0;i < listSize;++i)
                            {
                                strErrorMsg += PyString_AsString(PyList_GetItem(errList,i));
                            }
                        }
                    }
                }
                Py_XDECREF(pTraceModule);
            }
        }
        Py_XDECREF(type_obj);
        Py_XDECREF(value_obj);
        Py_XDECREF(traceback_obj);
    }
    return strErrorMsg;
}
 
/**
 * @brief   清理python环境
 */
void clear_pyenv()
{
    Py_CLEAR(g_pModule);
    Py_CLEAR(g_pInitFunc);
    Py_CLEAR(g_pProcessFunc);
    Py_CLEAR(g_pFiniFunc);
    Py_Finalize();//调用Py_Finalize，这个跟Py_Initialize相对应的。
 
    g_pModule = NULL;
    g_pInitFunc = NULL;
    g_pProcessFunc = NULL;
    g_pFiniFunc = NULL;
}
 
 
/**
 * @brief   第一次进入so时，需要做的初始化工作，只会执行一次。
 *
 * @return  0               succ
 *          else            fail
 */
extern "C" int fuload_handle_init()
{
    Py_Initialize();//使用python之前，要调用Py_Initialize();这个函数进行初始化
    if (!Py_IsInitialized())
    {
        printf("init error\n");
        return -1001;
    }
    PyRun_SimpleString("import sys");
    PyRun_SimpleString("sys.path.append('./')");
    PyRun_SimpleString("sys.path.append('"PYMODULE_PATH"')");
 
    g_pModule =PyImport_ImportModule(PYMODULE_NAME);//这里是要调用的文件名
    if (!g_pModule) {
        printf("Cant open python file!\n");
        printf("%s\n",log_python_exception().c_str());
        clear_pyenv();
        return -1002;
    }
    g_pInitFunc = PyObject_GetAttrString(g_pModule, PYFUNC_INIT);//这里是要调用的函数名
    g_pProcessFunc = PyObject_GetAttrString(g_pModule, PYFUNC_PROCESS);//这里是要调用的函数名
    g_pFiniFunc = PyObject_GetAttrString(g_pModule, PYFUNC_FINI);//这里是要调用的函数名
    if (!g_pInitFunc || !g_pProcessFunc || !g_pFiniFunc)
    {
        printf("func name not find\n");
        clear_pyenv();
        return -1003;
    }
    PyObject *objResult =  PyObject_CallFunction(g_pInitFunc, NULL);//调用函数
    if (!objResult)
    {
        clear_pyenv();
        return -1004;
    }
    int ret = PyInt_AsLong(objResult);
 
    return ret;
}
 
/**
 * @brief   业务逻辑，每次进入
 *
 * @param   mapParams       将输入数据按照url方式解析之后的key-value结构
 *
 * @return  0               succ
 *          else            返回值,会用来做统计
 */
extern "C" int fuload_handle_process(map<string,string>& mapParams)
{
    if (!g_pProcessFunc)
    {
        return -1001;
    }
    PyObject * t_dict = PyDict_New();
    for(map<string, string>::iterator it = mapParams.begin(); it != mapParams.end(); ++it)
    {
        PyDict_SetItemString(t_dict,it->first.c_str(),Py_BuildValue("s", it->second.c_str()));
    }
    PyObject *objResult = PyObject_CallFunctionObjArgs(g_pProcessFunc,t_dict,NULL);
    if (!objResult)
    {
        printf("%s\n",log_python_exception().c_str());
        return -1002;
    }
    int ret = PyInt_AsLong(objResult);
 
    return ret;
}
 
/**
 * @brief   so结束时的收尾工作，只会调用一次。一般不用编写
 *
 * @return  0               succ
 *          else            fail
 */
extern "C" int fuload_handle_fini()
{
    PyObject *objResult =  PyObject_CallFunction(g_pFiniFunc, NULL);//调用函数
    if (!objResult)
    {
        clear_pyenv();
        return -1004;
    }
    int ret = PyInt_AsLong(objResult);
 
    clear_pyenv();
    return ret;
}
#ifdef FL_MODULE_MAIN
int main(int argc, const char *argv[])
{
    map<string,string> mapParams;
    mapParams["first"]="1";
    mapParams["second"]="2";
    fuload_handle_init();
    fuload_handle_process(mapParams);
    fuload_handle_fini();
    return 0;
}
#endif

然后看一下其调用的fl_module.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
#=============================================================================
#  Author:          dantezhu - http://www.vimer.cn
#  Email:           zny2008@gmail.com
#  FileName:        fl_module.py
#  Description:     给python用的module主文件
#  Version:         1.0
#  LastChange:      2010-12-13 18:45:10
#  History:         
#=============================================================================
'''
import urllib
 
def fuload_handle_init():
    print 'init'
    return 0
 
def fuload_handle_process(mapParams):
    print urllib.urlopen("http://www.vimer.cn").read()
    return 0
 
def fuload_handle_fini():
    print 'fini'
    return 0
if __name__ == '__main__':
    fuload_handle_process("")

代码逻辑都是比较简单的，就不详细解释了，只列出几个链接，大家有兴趣可以看一下：
PyObject的常用函数
将python类型转换成C类型
通过C类型生成python类型
Py_BuildValue的说明

OK，其实最郁闷的并不是在代码的编写上，而是在makefile的编写上。
由于一开始想先通过编译成可执行程序来测试，所以makefile如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

CXX = g++ 
 
TARGET = main
 
C_FLAGS += -g -Wall -pthread
LIB     = -L/usr/local/lib/ -lpython2.7 -ldl -lutil
INC     = -I. -I/usr/local/include/python2.7/
 
all: $(TARGET)
 
main:  main.o
    $(CXX) -o $@ $^  $(LIB) $(C_FLAGS)
 
.cpp.o:
    $(CXX) -c -o $*.o $(INC) $(C_FLAGS) $*.cpp
.cc.o:
    $(CXX) -c -o $*.o $(INC) $(C_FLAGS) $*.cc
 
 
clean:
    -rm -f *.o $(TARGET)

但是编译出来的程序在执行的时候会报如下错误:

ImportError: /usr/local/lib/python2.7/lib-dynload/_socket.so: undefined symbol: PyExc_ValueError

后来发现这个问题是有两种解决方案：
1.如果python在编译安装的时候，没有使用:

1

./configure --enable-shared

那么就会造成在/usr/local/lib/目录下只有libpython2.7.a而没有libpython2.7.so，这个时候需要给makefile加一个参数:

1

-export-dynamic

即makefile变成:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

CXX = g++ 
 
TARGET = main
 
C_FLAGS += -g -Wall -pthread -export-dynamic
LIB     = -L/usr/local/lib/ -lpython2.7 -ldl -lutil
INC     = -I. -I/usr/local/include/python2.7/
 
all: $(TARGET)
 
main:  main.o
    $(CXX) -o $@ $^  $(LIB) $(C_FLAGS)
 
.cpp.o:
    $(CXX) -c -o $*.o $(INC) $(C_FLAGS) $*.cpp
.cc.o:
    $(CXX) -c -o $*.o $(INC) $(C_FLAGS) $*.cc
 
 
clean:
    -rm -f *.o $(TARGET)

成功~
2.我们也可以在python编译安装的时候就加上

1

./configure --enable-shared

这样原来的makefile不用做任何更改也是可以用的。
用man看了一下:

-E
--export-dynamic
--no-export-dynamic
   When creating a dynamically linked executable, using the -E option or the
   --export-dynamic option causes the linker to add all symbols to the dynamic symbol
   table.  The dynamic symbol table is the set of symbols which are visible from dynamic
   objects at run time.
 
   If you do not use either of these options (or use the --no-export-dynamic option to
   restore the default behavior), the dynamic symbol table will normally contain only
   those symbols which are referenced by some dynamic object mentioned in the link.
 
   If you use "dlopen" to load a dynamic object which needs to refer back to the symbols
   defined by the program, rather than some other dynamic object, then you will probably
   need to use this option when linking the program itself.
 
   You can also use the dynamic list to control what symbols should be added to the
   dynamic symbol table if the output format supports it.  See the description of
   --dynamic-list.
 
   Note that this option is specific to ELF targeted ports.  PE targets support a similar
   function to export all symbols from a DLL or EXE; see the description of
   --export-all-symbols below.

OK，这样可执行程序就没有问题了，但是关键我们要实现的是编译一个so。
-------------------------------------我是分割线-----------------------------------
无论我们是否已经用

1

./configure --enable-shared

编译了python，为保险起见，都用如下makefile编译so：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

CC = gcc 
CXX = g++ 
CFLAGS  = -Wall -pipe -DDEBUG -D_NEW_LIC -g -D_GNU_SOURCE \
          -shared -D_REENTRANT -fPIC -pthread
 
LIB     = -L/usr/local/lib/ -lpython2.7 -ldl -lutil -Xlinker -export-dynamic
INC     = -I. -I/usr/local/include/python2.7/
 
OO  = main.o
 
TARGETS = libmodule.so
 
all: $(TARGETS)
 
$(TARGETS): $(OO)
    $(CXX) $(CFLAGS) $(INC) $(OO) -o $@ $(LIB)
 
 
.c.o:
    $(CC)  $(CFLAGS) -c $(INC) $<
    echo $@
 
.cpp.o:
    $(CXX) $(CFLAGS) -c $(INC) $<
    echo $@
 
%:%.c
    $(CC) $(CFLAGS) -o $@ $< $(OO)
    echo $@
 
clean:
    rm -f *.o
    rm -f $(TARGETS)

用如下代码加载so:

1
2
3
4
5

SoObj=dlopen((char*)moduleFile.c_str(),RTLD_LAZY);
if(SoObj==NULL)
{   
    return -1; 
}

会发现报如下错误:

/usr/local/lib/python2.7/lib-dynload/_socket.so: undefined symbol: forkptyTraceback:Traceback (most recent call last):
File "../py_module/fl_module.py", line 16, in <module>
import urllib
File "/usr/local/lib/python2.7/urllib.py", line 26, in <module>
import socket
File "/usr/local/lib/python2.7/socket.py", line 47, in <module>
import _socket
ImportError: /usr/local/lib/python2.7/lib-dynload/_socket.so: undefined symbol: forkpty

这里可真是苦了我了，在网上遍寻原因未果，后来终于突发奇想，原来是加载so的调用有问题，改成如下方式后正常:

1
2
3
4
5

SoObj=dlopen((char*)moduleFile.c_str(),RTLD_LAZY|RTLD_GLOBAL);
if(SoObj==NULL)
{   
    return -1; 
}

搜到的解释如下:

RTLD_LAZY:在dlopen返回前，对于动态库中存在的未定义的变量(如外部变量extern，也可以是函数)不执行解析，就是不解析这个变量的地址。
 
RTLD_NOW：与上面不同，他需要在dlopen返回前，解析出每个未定义变量的地址，如果解析不出来，在dlopen会返回NULL，错误为：
: undefined symbol: xxxx.......
 
RTLD_GLOBAL:它的含义是使得库中的解析的定义变量在随后的随后其它的链接库中变得可以使用。

OK，到此为止，我们的程序总算是调通了，文章很长，但是相信也是值得的.
这里再附赠一个函数，当调用python脚本失败，打印异常信息(参考自:http://www.cppblog.com/why/archive/2010/11/08/132999.html):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

string log_python_exception()
{
    std::string strErrorMsg;
    if (!Py_IsInitialized())
    {
        strErrorMsg = "Python 运行环境没有初始化！";
        return strErrorMsg;
    }
 
    if (PyErr_Occurred() != NULL)
    {
        PyObject *type_obj, *value_obj, *traceback_obj;
        PyErr_Fetch(&type_obj, &value_obj, &traceback_obj);
        if (value_obj == NULL)
            return strErrorMsg;
 
        PyErr_NormalizeException(&type_obj, &value_obj, 0);
        if (PyString_Check(PyObject_Str(value_obj)))
        {
            strErrorMsg = PyString_AsString(PyObject_Str(value_obj));
        }
 
        if (traceback_obj != NULL)
        {
            strErrorMsg += "Traceback:";
 
            PyObject * pModuleName = PyString_FromString("traceback");
            PyObject * pTraceModule = PyImport_Import(pModuleName);
            Py_XDECREF(pModuleName);
            if (pTraceModule != NULL)
            {
                PyObject * pModuleDict = PyModule_GetDict(pTraceModule);
                if (pModuleDict != NULL)
                {
                    PyObject * pFunc = PyDict_GetItemString(pModuleDict,"format_exception");
                    if (pFunc != NULL)
                    {
                        PyObject * errList = PyObject_CallFunctionObjArgs(pFunc,type_obj,value_obj, traceback_obj,NULL);
                        if (errList != NULL)
                        {
                            int listSize = PyList_Size(errList);
                            for (int i=0;i < listSize;++i)
                            {
                                strErrorMsg += PyString_AsString(PyList_GetItem(errList,i));
                            }
                        }
                    }
                }
                Py_XDECREF(pTraceModule);
            }
        }
        Py_XDECREF(type_obj);
        Py_XDECREF(value_obj);
        Py_XDECREF(traceback_obj);
    }
    return strErrorMsg;
}
]]> http://www.vimer.cn/2010/12/cc%e4%b8%ad%e8%b0%83%e7%94%a8python%e8%84%9a%e6%9c%ac2-%e9%ab%98%e7%ba%a7%e5%ba%94%e7%94%a8.html/feed 10 时间相关的一些前后台知识 http://www.vimer.cn/2010/12/%e6%97%b6%e9%97%b4%e7%9b%b8%e5%85%b3%e7%9a%84%e4%b8%80%e4%ba%9b%e5%89%8d%e5%90%8e%e5%8f%b0%e7%9f%a5%e8%af%86.html http://www.vimer.cn/2010/12/%e6%97%b6%e9%97%b4%e7%9b%b8%e5%85%b3%e7%9a%84%e4%b8%80%e4%ba%9b%e5%89%8d%e5%90%8e%e5%8f%b0%e7%9f%a5%e8%af%86.html#comments Sun, 12 Dec 2010 12:58:40 +0000 Dante http://www.vimer.cn/?p=1869 最近有很多时间相关的一些技术积累，主要分为三块，

  • 1.gettimeofday时间差不准的bug
  • 2.时间的字符串形式和时间戳形式的转化（C语言）
  • 3.提供时间日期选择的控件

一.gettimeofday时间不准的bug
先从第一个说起吧，前几天在fuload项目通过如下代码统计调用消耗的时间：

1
2
3
4
5
6

struct timeval stBegin;
struct timeval stEnd;
gettimeofday(&stBegin, NULL);
ret = process(swi);
gettimeofday(&stEnd, NULL);
time_ms = ((stEnd.tv_sec-stBegin.tv_sec)*1000000+(stEnd.tv_usec-stBegin.tv_usec))/1000;

按理说是很平常的写法，但是在实际的曲线图中，却发现每隔20分钟就会出现一个很大的波动，在网上苦询答案未果，最后突然想起来，既然是规律性的出现问题，是不是crontab中有每隔20分钟的调用导致的问题呢？最终在crontab中发现了这个：

1

*/20 * * * * /usr/sbin/ntpdate 172.23.32.142 172.24.18.141 172.18.70.180

原来每隔20分钟就会对时一次，难怪出现问题，果断注释后，恢复正常。

二.时间的字符串形式和时间戳形式的转化（C语言）
之前在博客里是有谢过C语言中，时间戳和字符串的转化函数的(时间time_t和string(char*)格式互转)，不过可定制话太低了，恰好之前在内部论坛看到同事分享的另一种做法，所以拿出来和大家分享一下。
linux下默认提供了两个时间转化的函数（python中的time模块下也有相同名称的定义）：

1
2
3
4
5
6
7
8
9
10
11

//时间转字符串
size_t strftime(
char *strDest, 
size_t maxsize, 
const char *format, 
const struct tm *timeptr );
 
//字符串转时间
char *strptime(const char *s,
const char *format,
struct tm *tm);

我在这里简单写了一个测试程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <stdio.h>
#include <time.h>
using namespace std;
int main(int argc, const char *argv[])
{
    struct tm *ptr;
    time_t lt; 
    char szData[128];
    lt=time(NULL);
    ptr=localtime(&lt);
    strftime(szData,sizeof(szData)-1,"%Y-%m-%d %H:%M:%S",ptr);
    printf("%s\n",szData);
 
    struct tm t_tm;
    strptime(szData,"%Y-%m-%d %H:%M:%S",&t_tm);
    printf("%u\n",mktime(&t_tm));
    return 0;
}

输出结果如下:

2010-12-12 20:42:21
1292157741

特别需要注意的第一点是：strftime的第二个参数如果小于实际要存放的长度的话，这个函数是不会自动在最后一个字符补上\0的。
参考:http://baike.baidu.com/view/1284677.htm

三.提供时间日期选择的控件
也是fuload项目中使用的一个控件，之前本来是直接使用了django后台的日期选择控件，后来发现精度要求达到分钟，所以不得不去寻找一款能同时选择日期和时间的控件，好在后来还是被我找到啦，截图如下:

1

插件名为:Timepicker Addon for jQuery UI Datepicker，是在jquery的datepicker基础上修改的，插件主页：http://trentrichardson.com/examples/timepicker/
使用时需要下载安装jQuery UI，这里简单列出一下用法：
在head中加入:

1
2
3
4
5
6
7
8
9
10
11

<style type="text/css">
    /* css for timepicker */
    .ui-timepicker-div .ui-widget-header{ margin-bottom: 8px; }
    .ui-timepicker-div dl{ text-align: left; }
    .ui-timepicker-div dl dt{ height: 25px; }
    .ui-timepicker-div dl dd{ margin: -25px 0 10px 65px; }
    .ui-timepicker-div td { font-size: 90%; }
</style>
<script type="text/javascript" src="/site_media/js/jquery-1.4.3.min.js"></script>
<script type="text/javascript" src="/site_media/js/jquery-ui-1.8.6.custom.min.js"></script>
<script type="text/javascript" src="/site_media/js/jquery-ui-timepicker-addon.js"></script>

并对你需要弹出选择框的元素进行绑定:

1
2
3
4

$(function() {
    $('#id_begintime').datetimepicker()
    $('#id_begintime').datetimepicker("option","dateFormat","yy-mm-dd");
}

但是需要注意一点的是，如果有多个元素需要绑定选择框是不能用如下方法的：

1
2
3
4
5
6
7

//错误写法！
$(function() {
    $('#id_begintime').datetimepicker()
    $('#id_begintime').datetimepicker("option","dateFormat","yy-mm-dd");
    $('#id_endtime').datetimepicker()
    $('#id_endtime').datetimepicker("option","dateFormat","yy-mm-dd");
}

而必须使用:

1
2
3
4

$(function() {
        $('#id_begintime,#id_endtime').datetimepicker({
            dateFormat:"yy-mm-dd"
        });

OK，就这样~

]]> http://www.vimer.cn/2010/12/%e6%97%b6%e9%97%b4%e7%9b%b8%e5%85%b3%e7%9a%84%e4%b8%80%e4%ba%9b%e5%89%8d%e5%90%8e%e5%8f%b0%e7%9f%a5%e8%af%86.html/feed 2 参考python来简写C代码 http://www.vimer.cn/2010/12/%e5%8f%82%e8%80%83python%e6%9d%a5%e7%ae%80%e5%86%99c%e4%bb%a3%e7%a0%81.html http://www.vimer.cn/2010/12/%e5%8f%82%e8%80%83python%e6%9d%a5%e7%ae%80%e5%86%99c%e4%bb%a3%e7%a0%81.html#comments Wed, 08 Dec 2010 06:48:27 +0000 Dante http://www.vimer.cn/?p=1865 由于python语法的简洁，所以在写c代码的时候，有时候也会想能不能把C代码写的更简练一点，这几天遇到一个，给大家分享一下。
比如我们要用C写一个判断语句，然后根据不同的值返回不同的内容。

1
2
3
4
5
6
7
8
9
10
11
12

if(1 == val)
{
    return "this is one";
}
else if(2 == val)
{
    return "this is two";
}
else if(3 == val)
{
    return "this is three";
}

如果判断的逻辑很多，代码就会显得很臃肿（文中的例子用switch也可以，但是也还是很难看），如果用python，就会这样写（为了和C类比，这里没有用字典）:

1
2
3
4
5
6

datas = [
(1,"this is one"),(2,"this is two"),(3,"this is three")
]
for v in datas:
    if v[0] == val:
        return v[1]

那在c里面是否能同样的方法实现呢，是可以的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

struct
{
    int key;
    string strdata;
}arr_datas[]={
    {1,"this is one"},
    {2,"this is two"},
    {3,"this is three"},
};
for (i = 0; i < 3; i++)
{
    if (arr_datas[i].key == val)
    {
        return arr_datas[i].strdata;
    }
}

附:
有人可能想到用stl的map，查找速度会快一些，不过想到定义一个map，然后调用一堆insert其实也挺麻烦的，而且例子中用的是int，但是并不是所有的类型都是可hash的，所以有些情况下map并不能胜任。

]]> http://www.vimer.cn/2010/12/%e5%8f%82%e8%80%83python%e6%9d%a5%e7%ae%80%e5%86%99c%e4%bb%a3%e7%a0%81.html/feed 31