").append(m.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,e||[a.responseText,b,a])}),this},m.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){m.fn[b]=function(a){return this.on(b,a)}}),m.expr.filters.animated=function(a){return m.grep(m.timers,function(b){return a===b.elem}).length};var cd=a.document.documentElement;function dd(a){return m.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}m.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=m.css(a,"position"),l=m(a),n={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=m.css(a,"top"),i=m.css(a,"left"),j=("absolute"===k||"fixed"===k)&&m.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),m.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(n.top=b.top-h.top+g),null!=b.left&&(n.left=b.left-h.left+e),"using"in b?b.using.call(a,n):l.css(n)}},m.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){m.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,m.contains(b,e)?(typeof e.getBoundingClientRect!==K&&(d=e.getBoundingClientRect()),c=dd(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===m.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),m.nodeName(a[0],"html")||(c=a.offset()),c.top+=m.css(a[0],"borderTopWidth",!0),c.left+=m.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-m.css(d,"marginTop",!0),left:b.left-c.left-m.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||cd;while(a&&!m.nodeName(a,"html")&&"static"===m.css(a,"position"))a=a.offsetParent;return a||cd})}}),m.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);m.fn[a]=function(d){return V(this,function(a,d,e){var f=dd(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?m(f).scrollLeft():e,c?e:m(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),m.each(["top","left"],function(a,b){m.cssHooks[b]=Lb(k.pixelPosition,function(a,c){return c?(c=Jb(a,b),Hb.test(c)?m(a).position()[b]+"px":c):void 0})}),m.each({Height:"height",Width:"width"},function(a,b){m.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){m.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return V(this,function(b,c,d){var e;return m.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?m.css(b,c,g):m.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),m.fn.size=function(){return this.length},m.fn.andSelf=m.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return m});var ed=a.jQuery,fd=a.$;return m.noConflict=function(b){return a.$===m&&(a.$=fd),b&&a.jQuery===m&&(a.jQuery=ed),m},typeof b===K&&(a.jQuery=a.$=m),m});
5 |
--------------------------------------------------------------------------------
/src/tpl/about.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
about
6 |
7 |
8 |
9 |
12 |
13 |
14 |
--------------------------------------------------------------------------------
/src/tpl/error.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
error
6 |
7 |
8 |
9 |
ERROR: {{ message }}
10 |
11 |
12 |
--------------------------------------------------------------------------------
/src/tpl/history.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
publish
6 |
7 |
8 |
9 |
12 |
13 | {% if len(pub_list) > 0 %}
14 |
15 |
16 |
17 | vid |
18 | config version |
19 | game version |
20 | desc |
21 | target servers |
22 | status |
23 | pub time |
24 | |
25 |
26 |
27 |
28 | {% for pub_item in pub_list %}
29 |
30 | {{ pub_item['pub_node_id'] }} |
31 | {{ pub_item['config_version'] }} |
32 | {{ pub_item['game_version'] }} |
33 | {{ pub_item['description'] }} |
34 | {{ pub_item['servers'] }} |
35 | {{ pub_item['status'] }} |
36 | {{ pub_item['pub_time'] }} |
37 |
38 | {% if pub_item['status'] != 'deprecated' %}
39 | {% if pub_item['status'] != 'pub_success' %}
40 | publish
41 | deprecated
42 | {% end %}
43 | {% end %}
44 | |
45 |
46 | {% end %}
47 |
48 |
49 | {% if prev or next %}
50 |
54 | {% end %}
55 | {% end %}
56 |
57 |
58 |
59 |
--------------------------------------------------------------------------------
/src/tpl/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
index
6 |
7 |
8 |
9 |
10 |
22 |
23 |
24 |
46 |
47 |
48 |
49 |
51 |
52 |
53 |
--------------------------------------------------------------------------------
/src/tpl/login.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
login
6 |
7 |
8 |
9 |
35 |
36 |
37 |
--------------------------------------------------------------------------------
/src/tpl/publish.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
publish
6 |
7 |
8 |
9 |
14 |
15 |
16 |
42 |
48 |
49 |
50 |
--------------------------------------------------------------------------------
/test/dev_init_servers.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import time
6 | import json
7 |
8 | import kazoo
9 | from kazoo.client import KazooClient
10 |
11 | def test_init_servers(server_id, host = '127.0.0.1', port = 2181):
12 | zookeeper = KazooClient('%s:%s' % (host, port,))
13 | zookeeper.start()
14 |
15 | try:
16 | node = '/test/server_list'
17 | if zookeeper.exists(node) is None:
18 | zookeeper.create(node, json.dumps({'update_time' : time.time()}), makepath = True)
19 | except kazoo.exceptions.NodeExistsError:
20 | pass
21 |
22 | try:
23 | node = '/test/server_list/s%s' % server_id
24 | zookeeper.delete(node)
25 | zookeeper.create(node, json.dumps({
26 | 'update_time' : time.time(),
27 | 'server_name' : 's%s' % server_id,
28 | 'server_id' : server_id,
29 | }), makepath = True)
30 | except kazoo.exceptions.NodeExistsError:
31 | pass
32 |
33 | if __name__ == '__main__':
34 | os.environ['TZ'] = 'Asia/Shanghai'
35 | time.tzset()
36 |
37 | if len(sys.argv) >= 2:
38 | test_init_servers(str(sys.argv[1]))
39 | else:
40 | print 'You must usage like %s name' % (sys.argv[0], )
--------------------------------------------------------------------------------
/test/mock_pub.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import json
6 | import time
7 | import logging
8 | import subprocess
9 |
10 | import kazoo
11 | from kazoo.client import KazooClient
12 |
13 | logging.basicConfig(
14 | level = logging.INFO,
15 | stream = sys.stdout,
16 | datefmt = "%Y-%m-%d %H:%M:%S",
17 | format = "[%(levelname)s %(asctime)s %(filename)s %(lineno)s] %(message)s"
18 | )
19 |
20 | LOG = logging.getLogger(__name__)
21 |
22 | class mock_pub(object):
23 |
24 | _root_node = ''
25 | _server_list = {}
26 | _zookeeper = None
27 | _shell_path = ''
28 |
29 | def __init__(self, host = '127.0.0.1', port = 2181, root_node = '/test', shell_path = './'):
30 | self._zookeeper = KazooClient('%s:%s' % (host, port,))
31 | self._root_node = root_node
32 | self._shell_path = shell_path
33 |
34 | def run(self):
35 | self._zookeeper.start()
36 | self.init()
37 |
38 | def init(self):
39 | pub_node = '%s/to_pub_notice' % self._root_node
40 | default_node_value = json.dumps({'update_time' : time.time()})
41 |
42 | try:
43 | if self._zookeeper.exists(pub_node) is None:
44 | self._zookeeper.create(pub_node, default_node_value, makepath = True)
45 | except kazoo.exceptions.NodeExistsError:
46 | pass
47 |
48 | @self._zookeeper.ChildrenWatch('%s/server_list' % (self._root_node, ))
49 | def server(server_list):
50 | for server_node in server_list:
51 | result = self.init_server(server_node)
52 | LOG.info('refresh server list %s' % json.dumps(result))
53 |
54 | @self._zookeeper.ChildrenWatch('%s/to_pub_notice' % (self._root_node, ))
55 | def to_pub_node(pub_node_list):
56 | for pub_node_id in pub_node_list:
57 | LOG.info('watch_pub children %s/to_pub_notice/%s' % (self._root_node, pub_node_id, ))
58 | self.to_pub(pub_node_id)
59 |
60 | return self
61 |
62 | def init_server(self, server_node):
63 | server_detail = self._zookeeper.get('%s/server_list/%s' % (self._root_node, server_node, ))
64 | if 0 == len(server_detail[0]):
65 | self._server_list[server_node] = {'server_id' : 0, 'server_name' : '', 'update_time' : 0}
66 | else:
67 | self._server_list[server_node] = json.loads(server_detail[0])
68 |
69 | return self._server_list[server_node]
70 |
71 | def to_pub(self, pub_node_id):
72 |
73 | @self._zookeeper.DataWatch('%s/to_pub_notice/%s' % (self._root_node, pub_node_id, ))
74 | def to_zip_execute(data, stat, event):
75 | if event is not None and event.type == 'DELETED':
76 | return
77 |
78 | if 0 == len(data):
79 | return
80 |
81 | LOG.info('watch_pub execute %s/to_pub_notice/%s %s' % (self._root_node, pub_node_id, data, ))
82 |
83 | node_detail = json.loads(data)
84 | if node_detail.get('status', None) == 'ok' or \
85 | node_detail.get('status', None) == 'failed' or \
86 | node_detail.get('servers', None) is None:
87 | return
88 |
89 | all_pub_finished = True
90 |
91 | for server_index in self._server_list:
92 | if 0 == self._server_list[server_index]['server_id'] or \
93 | str(self._server_list[server_index]['server_id']) not in node_detail['servers']:
94 | continue
95 |
96 | node_value = {
97 | 'update_time' : time.time()
98 | }
99 |
100 | if self.pub_execute(node_detail['config_version'], node_detail['game_version'], self._server_list[server_index]['server_id']) is True:
101 | LOG.info('pub node %s/to_pub_result/%s/s%s pub success' % (self._root_node, pub_node_id, self._server_list[server_index]['server_id'] ))
102 | node_value['status'] = 'ok'
103 | else:
104 | LOG.info('pub node %s/to_pub_result/%s/s%s pub failed' % (self._root_node, pub_node_id, self._server_list[server_index]['server_id'] ))
105 | node_value['status'] = 'failed'
106 | all_pub_finished = False
107 |
108 | pub_server_node = '%s/to_pub_result/%s/s%s' % (self._root_node, pub_node_id, self._server_list[server_index]['server_id'], )
109 |
110 | try:
111 | if self._zookeeper.exists(pub_server_node) is None:
112 | self._zookeeper.create(pub_server_node, json.dumps(node_value), makepath = True)
113 | else:
114 | self._zookeeper.set(pub_server_node, json.dumps(node_value))
115 | except kazoo.exceptions.NodeExistsError:
116 | pass
117 |
118 | if all_pub_finished:
119 | node_detail['status'] = 'ok'
120 | node_detail['finish_time'] = time.time()
121 | self._zookeeper.set('%s/to_pub_notice/%s' % (self._root_node, pub_node_id, ), json.dumps(node_detail))
122 |
123 | def pub_execute(self, config_version, game_version, server_id):
124 | '''
125 | to execute shell to zip resource
126 | '''
127 |
128 | LOG.info('start to execute shell %s/pub.sh %s %s %s' % (self._shell_path, config_version, game_version, server_id, ))
129 | result = subprocess.call('%s/pub.sh %s %s %s > /dev/null 2>&1' % (self._shell_path, config_version, game_version, server_id, ), shell = True)
130 |
131 | return True if result == 0 else False
132 |
133 | if __name__ == '__main__':
134 | os.environ['TZ'] = 'Asia/Shanghai'
135 | time.tzset()
136 |
137 | m = mock_pub(
138 | sys.argv[1] if len(sys.argv) >= 2 else '127.0.0.1',
139 | sys.argv[2] if len(sys.argv) >= 3 else '2181',
140 | sys.argv[3] if len(sys.argv) >= 4 else '/test',
141 | os.path.dirname(sys.argv[0])
142 | )
143 | m.run()
144 |
145 | try:
146 | while True:
147 | time.sleep(1)
148 | except KeyboardInterrupt:
149 | pass
--------------------------------------------------------------------------------
/test/mock_syc.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import json
6 | import time
7 | import logging
8 | import subprocess
9 |
10 | import kazoo
11 | from kazoo.client import KazooClient
12 |
13 | logging.basicConfig(
14 | level = logging.INFO,
15 | stream = sys.stdout,
16 | datefmt = "%Y-%m-%d %H:%M:%S",
17 | format = "[%(levelname)s %(asctime)s %(filename)s %(lineno)s] %(message)s"
18 | )
19 |
20 | LOG = logging.getLogger(__name__)
21 |
22 | class mock_syc(object):
23 |
24 | _root_node = ''
25 | _server_list = {}
26 | _zookeeper = None
27 | _shell_path = ''
28 |
29 | def __init__(self, host = '127.0.0.1', port = 2181, root_node = '/test', shell_path = './'):
30 | self._zookeeper = KazooClient('%s:%s' % (host, port,))
31 | self._root_node = root_node
32 | self._shell_path = shell_path
33 |
34 | def run(self):
35 | self._zookeeper.start()
36 | self.init()
37 |
38 | def init(self):
39 | syc_node = '%s/to_syc_notice' % self._root_node
40 | default_node_value = json.dumps({'update_time' : time.time()})
41 |
42 | try:
43 | if self._zookeeper.exists(syc_node) is None:
44 | self._zookeeper.create(syc_node, default_node_value, makepath = True)
45 | except kazoo.exceptions.NodeExistsError:
46 | pass
47 |
48 | @self._zookeeper.ChildrenWatch('%s/server_list' % (self._root_node, ))
49 | def server(server_list):
50 | for server_node in server_list:
51 | result = self.init_server(server_node)
52 | LOG.info('refresh server list %s' % json.dumps(result))
53 |
54 | @self._zookeeper.ChildrenWatch('%s/to_syc_notice' % (self._root_node, ))
55 | def to_syc_node(syc_node_list):
56 | for syc_node_id in syc_node_list:
57 | LOG.info('watch_syc children %s/to_syc_notice/%s' % (self._root_node, syc_node_id, ))
58 | self.to_syc(syc_node_id)
59 |
60 | return self
61 |
62 | def init_server(self, server_node):
63 | server_detail = self._zookeeper.get('%s/server_list/%s' % (self._root_node, server_node, ))
64 | if 0 == len(server_detail[0]):
65 | self._server_list[server_node] = {'server_id' : 0, 'server_name':'', 'update_time' : 0}
66 | else:
67 | self._server_list[server_node] = json.loads(server_detail[0])
68 |
69 | return self._server_list[server_node]
70 |
71 | def to_syc(self, syc_node_id):
72 |
73 | @self._zookeeper.DataWatch('%s/to_syc_notice/%s' % (self._root_node, syc_node_id, ))
74 | def to_zip_execute(data, stat, event):
75 | if event is not None and event.type == 'DELETED':
76 | return
77 |
78 | if 0 == len(data):
79 | return
80 |
81 | LOG.info('watch_syc execute %s/to_syc_notice/%s %s' % (self._root_node, syc_node_id, data, ))
82 |
83 | node_detail = json.loads(data)
84 | if node_detail.get('status', None) == 'ok' or \
85 | node_detail.get('status', None) == 'failed' or \
86 | node_detail.get('servers', None) is None:
87 | return
88 |
89 | all_syc_finished = True
90 |
91 | for server_index in self._server_list:
92 | if 0 == self._server_list[server_index]['server_id'] or \
93 | str(self._server_list[server_index]['server_id']) not in node_detail['servers']:
94 | continue
95 |
96 | node_value = {
97 | 'update_time' : time.time()
98 | }
99 |
100 | if self.syc_execute(node_detail['config_version'], node_detail['game_version'], self._server_list[server_index]['server_id']) is True:
101 | LOG.info('syc node %s/to_syc_result/%s/s%s syc success' % (self._root_node, syc_node_id, self._server_list[server_index]['server_id'] ))
102 | node_value['status'] = 'ok'
103 | else:
104 | LOG.info('syc node %s/to_syc_result/%s/s%s syc failed' % (self._root_node, syc_node_id, self._server_list[server_index]['server_id'] ))
105 | node_value['status'] = 'failed'
106 | all_syc_finished = False
107 |
108 | syc_server_node = '%s/to_syc_result/%s/s%s' % (self._root_node, syc_node_id, self._server_list[server_index]['server_id'], )
109 |
110 | try:
111 | if self._zookeeper.exists(syc_server_node) is None:
112 | self._zookeeper.create(syc_server_node, json.dumps(node_value), makepath = True)
113 | else:
114 | self._zookeeper.set(syc_server_node, json.dumps(node_value))
115 | except kazoo.exceptions.NodeExistsError:
116 | pass
117 |
118 | if all_syc_finished:
119 | node_detail['status'] = 'ok'
120 | node_detail['finish_time'] = time.time()
121 | self._zookeeper.set('%s/to_syc_notice/%s' % (self._root_node, syc_node_id, ), json.dumps(node_detail))
122 |
123 | def syc_execute(self, config_version, game_version, server_id):
124 | '''
125 | to execute shell to zip resource
126 | '''
127 |
128 | LOG.info('start to execute shell %s/syc.sh %s %s %s' % (self._shell_path, config_version, game_version, server_id, ))
129 | result = subprocess.call('%s/syc.sh %s %s %s > /dev/null 2>&1' % (self._shell_path, config_version, game_version, server_id, ), shell = True)
130 |
131 | return True if result == 0 else False
132 |
133 | if __name__ == '__main__':
134 | os.environ['TZ'] = 'Asia/Shanghai'
135 | time.tzset()
136 |
137 | m = mock_syc(
138 | sys.argv[1] if len(sys.argv) >= 2 else '127.0.0.1',
139 | sys.argv[2] if len(sys.argv) >= 3 else '2181',
140 | sys.argv[3] if len(sys.argv) >= 4 else '/test',
141 | os.path.dirname(sys.argv[0])
142 | )
143 | m.run()
144 |
145 | try:
146 | while True:
147 | time.sleep(1)
148 | except KeyboardInterrupt:
149 | pass
--------------------------------------------------------------------------------
/test/mock_zip.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import json
6 | import time
7 | import logging
8 | import subprocess
9 |
10 | import kazoo
11 | from kazoo.client import KazooClient
12 |
13 | logging.basicConfig(
14 | level = logging.INFO,
15 | stream = sys.stdout,
16 | datefmt = "%Y-%m-%d %H:%M:%S",
17 | format = "[%(levelname)s %(asctime)s %(filename)s %(lineno)s] %(message)s"
18 | )
19 |
20 | LOG = logging.getLogger(__name__)
21 |
22 | class mock_zip(object):
23 |
24 | _root_node = ''
25 | _zookeeper = None
26 | _shell_path = ''
27 |
28 | def __init__(self, host = '127.0.0.1', port = 2181, root_node = '/test', shell_path = './'):
29 | self._zookeeper = KazooClient('%s:%s' % (host, port,))
30 | self._root_node = root_node
31 | self._shell_path = shell_path
32 |
33 | def run(self):
34 | self._zookeeper.start()
35 | self.init()
36 |
37 | def init(self):
38 | zip_node = '%s/to_zip_notice' % self._root_node
39 | default_node_value = json.dumps({'update_time' : time.time()})
40 |
41 | try:
42 | if self._zookeeper.exists(zip_node) is None:
43 | self._zookeeper.create(zip_node, default_node_value, makepath = True)
44 | except kazoo.exceptions.NodeExistsError:
45 | pass
46 |
47 | @self._zookeeper.ChildrenWatch('%s/to_zip_notice' % (self._root_node, ))
48 | def to_zip_node(zip_node_list):
49 | for zip_node_id in zip_node_list:
50 | LOG.info('watch_zip children %s/to_zip_notice/%s' % (self._root_node, zip_node_id, ))
51 | self.to_zip(zip_node_id)
52 |
53 | return self
54 |
55 | def to_zip(self, zip_node_id):
56 |
57 | @self._zookeeper.DataWatch('%s/to_zip_notice/%s' % (self._root_node, zip_node_id, ))
58 | def to_zip_execute(data, stat, event):
59 | if event is not None and event.type == 'DELETED':
60 | return
61 |
62 | if 0 == len(data):
63 | return
64 |
65 | LOG.info('watch_zip execute %s/to_zip_notice/%s %s' % (self._root_node, zip_node_id, data, ))
66 |
67 | node_detail = json.loads(data)
68 | if node_detail.get('config_version', None) is None or \
69 | node_detail.get('game_version', None) is None or \
70 | node_detail.get('status', None) == 'ok' or \
71 | node_detail.get('status', None) == 'failed':
72 | return
73 |
74 | if self.zip_execute(node_detail['config_version'], node_detail['game_version']) is True:
75 | LOG.info('zip node %s/to_zip_notice/%s zip success' % (self._root_node, zip_node_id, ))
76 | node_detail['status'] = 'ok'
77 | node_detail['finish_time'] = time.time()
78 | self._zookeeper.set('%s/to_zip_notice/%s' % (self._root_node, zip_node_id, ), json.dumps(node_detail))
79 | self._zookeeper.set('%s/to_zip_result/%s' % (self._root_node, zip_node_id, ), json.dumps({
80 | 'update_time' : time.time(),
81 | 'status' : 'ok'
82 | }))
83 | else:
84 | LOG.info('zip node %s/to_zip_notice/%s zip failed' % (self._root_node, zip_node_id, ))
85 | self._zookeeper.set('%s/to_zip_result/%s' % (self._root_node, zip_node_id, ), json.dumps({
86 | 'update_time' : time.time(),
87 | 'status' : 'failed'
88 | }))
89 |
90 | def zip_execute(self, config_version, game_version):
91 | '''
92 | to execute shell to zip resource
93 | '''
94 | LOG.info('start to execute shell %s/zip.sh %s %s' % (self._shell_path, config_version, game_version, ))
95 | result = subprocess.call('%s/zip.sh %s %s > /dev/null 2>&1' % (self._shell_path, config_version, game_version, ), shell = True)
96 |
97 | return True if result == 0 else False
98 |
99 | if __name__ == '__main__':
100 | os.environ['TZ'] = 'Asia/Shanghai'
101 | time.tzset()
102 |
103 | m = mock_zip(
104 | sys.argv[1] if len(sys.argv) >= 2 else '127.0.0.1',
105 | sys.argv[2] if len(sys.argv) >= 3 else '2181',
106 | sys.argv[3] if len(sys.argv) >= 4 else '/test',
107 | os.path.dirname(sys.argv[0])
108 | )
109 | m.run()
110 |
111 | try:
112 | while True:
113 | time.sleep(1)
114 | except KeyboardInterrupt:
115 | pass
--------------------------------------------------------------------------------
/test/pub.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | #
3 | # exit 0 for success other for failed
4 | #
5 | #
6 |
7 | if [ $# -ne 3 ] ; then
8 | echo "Error params"
9 | exit 1
10 | fi
11 |
12 | CONFIG_VERSION=$1
13 | GAME_VERSION=$2
14 | SERVER_ID=$3
15 |
16 | echo "got config_version=${CONFIG_VERSION} game_version=${GAME_VERSION} target_server=${SERVER_ID}"
17 |
18 | exit 0
19 |
--------------------------------------------------------------------------------
/test/single_pub.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | #coding=utf-8
3 |
4 | import os
5 | import sys
6 | import json
7 | import time
8 | import logging
9 | import subprocess
10 |
11 | import kazoo
12 | from kazoo.client import KazooClient
13 |
14 | logging.basicConfig(
15 | level = logging.INFO,
16 | stream = sys.stdout,
17 | datefmt = "%Y-%m-%d %H:%M:%S",
18 | format = "[%(levelname)s %(asctime)s %(filename)s %(lineno)s] %(message)s"
19 | )
20 |
21 | LOG = logging.getLogger(__name__)
22 |
23 | class mock_pub(object):
24 |
25 | _server_id = '1' #str
26 | _root_node = ''
27 | _zookeeper = None
28 | _shell_path = ''
29 |
30 | def __init__(self, host = '127.0.0.1', port = 2181, root_node = '/test', shell_path = './'):
31 | self._zookeeper = KazooClient('%s:%s' % (host, port,))
32 | self._root_node = root_node
33 | self._shell_path = shell_path
34 |
35 | def run(self):
36 | self._zookeeper.start()
37 | self.init()
38 |
39 | def init(self):
40 |
41 | #初始服务器节点
42 | self.init_server()
43 |
44 | #创建to_pub_notice节点
45 | self.init_pub_notice()
46 |
47 | #监控to_pub_notice发布Children-list
48 | @self._zookeeper.ChildrenWatch('%s/to_pub_notice' % (self._root_node, ))
49 | def to_pub_node(pub_node_list):
50 | for pub_node_id in pub_node_list:
51 | LOG.info('watch_pub children %s/to_pub_notice/%s' % (self._root_node, pub_node_id, ))
52 | self.to_pub(pub_node_id)
53 |
54 | return self
55 |
56 | def init_pub_notice(self):
57 | pub_node = '%s/to_pub_notice' % self._root_node
58 | default_node_value = json.dumps({'update_time' : time.time()})
59 |
60 | try:
61 | if self._zookeeper.exists(pub_node) is None:
62 | self._zookeeper.create(pub_node, default_node_value, makepath = True)
63 | except kazoo.exceptions.NodeExistsError:
64 | pass
65 |
66 | def init_server(self):
67 | try:
68 | node = '/test/server_list'
69 | if self._zookeeper.exists(node) is None:
70 | self._zookeeper.create(node, json.dumps({'update_time' : time.time()}), makepath = True)
71 | except kazoo.exceptions.NodeExistsError:
72 | pass
73 |
74 | def update_server(self):
75 | try:
76 | node = '/test/server_list/s%s' % self._server_id
77 | if self._zookeeper.exists(node) is None:
78 | self._zookeeper.create(node, json.dumps({
79 | 'update_time' : time.time(),
80 | 'server_name' : 's%s' % self._server_id,
81 | 'server_id' : self._server_id,
82 | }), makepath = True)
83 | else:
84 | self._zookeeper.set(node, json.dumps({
85 | 'update_time' : time.time(),
86 | 'server_name' : 's%s' % self._server_id,
87 | 'server_id' : self._server_id,
88 | }))
89 | except kazoo.exceptions.NodeExistsError:
90 | LOG.error('update server list node error')
91 | pass
92 |
93 | def to_pub(self, pub_node_id):
94 | #Children-Value
95 | @self._zookeeper.DataWatch('%s/to_pub_notice/%s' % (self._root_node, pub_node_id, ))
96 | def to_zip_execute(data, stat, event):
97 | if event is not None and event.type == 'DELETED':
98 | return
99 |
100 | if 0 == len(data):
101 | return
102 |
103 | node_detail = json.loads(data)
104 | if node_detail.get('status', None) == 'ok' or \
105 | node_detail.get('status', None) == 'failed' or \
106 | node_detail.get('servers', None) is None:
107 | return
108 |
109 | if 0 == len(self._server_id) or \
110 | str(self._server_id) not in node_detail['servers']:
111 | return
112 |
113 | LOG.info('watch_pub execute %s/to_pub_notice/%s %s' % (self._root_node, pub_node_id, data, ))
114 |
115 | node_value = {
116 | 'update_time' : time.time()
117 | }
118 |
119 | if self.pub_execute(node_detail['config_version'], node_detail['game_version']) is True:
120 | LOG.info('pub node %s/to_pub_result/%s/s%s pub success' % (self._root_node, pub_node_id, self._server_id, ))
121 | node_value['status'] = 'ok'
122 | else:
123 | LOG.info('pub node %s/to_pub_result/%s/s%s pub failed' % (self._root_node, pub_node_id, self._server_id, ))
124 | node_value['status'] = 'failed'
125 |
126 | pub_server_node = '%s/to_pub_result/%s/s%s' % (self._root_node, pub_node_id, self._server_id, )
127 |
128 | try:
129 | if self._zookeeper.exists(pub_server_node) is None:
130 | self._zookeeper.create(pub_server_node, json.dumps(node_value), makepath = True)
131 | else:
132 | self._zookeeper.set(pub_server_node, json.dumps(node_value))
133 | except kazoo.exceptions.NodeExistsError:
134 | pass
135 |
136 |
137 |
138 | def pub_execute(self, config_version, game_version):
139 | '''
140 | to execute shell to zip resource
141 | '''
142 |
143 | LOG.info('start to execute shell %s/pub.sh %s %s %s' % (self._shell_path, config_version, game_version, self._server_id, ))
144 | result = subprocess.call('%s/pub.sh %s %s %s > /dev/null 2>&1' % (self._shell_path, config_version, game_version, self._server_id, ), shell = True)
145 |
146 | return True if result == 0 else False
147 |
148 | if __name__ == '__main__':
149 | os.environ['TZ'] = 'Asia/Shanghai'
150 | time.tzset()
151 |
152 | m = mock_pub(
153 | sys.argv[1] if len(sys.argv) >= 2 else '127.0.0.1',
154 | sys.argv[2] if len(sys.argv) >= 3 else '2181',
155 | sys.argv[3] if len(sys.argv) >= 4 else '/test',
156 | os.path.dirname(sys.argv[0])
157 | )
158 | m.run()
159 |
160 | try:
161 | while True:
162 | m.update_server()
163 | time.sleep(3)
164 | except KeyboardInterrupt:
165 | pass
--------------------------------------------------------------------------------
/test/single_syc.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import json
6 | import time
7 | import logging
8 | import subprocess
9 |
10 | import kazoo
11 | from kazoo.client import KazooClient
12 |
13 | logging.basicConfig(
14 | level = logging.INFO,
15 | stream = sys.stdout,
16 | datefmt = "%Y-%m-%d %H:%M:%S",
17 | format = "[%(levelname)s %(asctime)s %(filename)s %(lineno)s] %(message)s"
18 | )
19 |
20 | LOG = logging.getLogger(__name__)
21 |
22 | class mock_syc(object):
23 |
24 | _server_id = ''
25 | _root_node = ''
26 | _zookeeper = None
27 | _shell_path = ''
28 |
29 | def __init__(self, host = '127.0.0.1', port = 2181, root_node = '/test', shell_path = './'):
30 | self._zookeeper = KazooClient('%s:%s' % (host, port,))
31 | self._root_node = root_node
32 | self._shell_path = shell_path
33 |
34 | def run(self):
35 | self._zookeeper.start()
36 | self.init()
37 |
38 | def init(self):
39 | syc_node = '%s/to_syc_notice' % self._root_node
40 | default_node_value = json.dumps({'update_time' : time.time()})
41 |
42 | try:
43 | if self._zookeeper.exists(syc_node) is None:
44 | self._zookeeper.create(syc_node, default_node_value, makepath = True)
45 | except kazoo.exceptions.NodeExistsError:
46 | pass
47 |
48 | @self._zookeeper.ChildrenWatch('%s/to_syc_notice' % (self._root_node, ))
49 | def to_syc_node(syc_node_list):
50 | for syc_node_id in syc_node_list:
51 | LOG.info('watch_syc children %s/to_syc_notice/%s' % (self._root_node, syc_node_id, ))
52 | self.to_syc(syc_node_id)
53 |
54 | return self
55 |
56 | def to_syc(self, syc_node_id):
57 |
58 | @self._zookeeper.DataWatch('%s/to_syc_notice/%s' % (self._root_node, syc_node_id, ))
59 | def to_zip_execute(data, stat, event):
60 | if event is not None and event.type == 'DELETED':
61 | return
62 |
63 | if 0 == len(data):
64 | return
65 |
66 | node_detail = json.loads(data)
67 | if node_detail.get('status', None) == 'ok' or \
68 | node_detail.get('status', None) == 'failed' or \
69 | node_detail.get('servers', None) is None:
70 | return
71 |
72 | if 0 == len(self._server_id) or \
73 | str(self._server_id) not in node_detail['servers']:
74 | return
75 |
76 | LOG.info('watch_syc execute %s/to_syc_notice/%s %s' % (self._root_node, syc_node_id, data, ))
77 |
78 | node_value = {
79 | 'update_time' : time.time()
80 | }
81 |
82 | if self.syc_execute(node_detail['config_version'], node_detail['game_version']) is True:
83 | LOG.info('syc node %s/to_syc_result/%s/s%s syc success' % (self._root_node, syc_node_id, self._server_id, ))
84 | node_value['status'] = 'ok'
85 | else:
86 | LOG.info('syc node %s/to_syc_result/%s/s%s syc failed' % (self._root_node, syc_node_id, self._server_id, ))
87 | node_value['status'] = 'failed'
88 |
89 | syc_server_node = '%s/to_syc_result/%s/s%s' % (self._root_node, syc_node_id, self._server_id, )
90 |
91 | try:
92 | if self._zookeeper.exists(syc_server_node) is None:
93 | self._zookeeper.create(syc_server_node, json.dumps(node_value), makepath = True)
94 | else:
95 | self._zookeeper.set(syc_server_node, json.dumps(node_value))
96 | except kazoo.exceptions.NodeExistsError:
97 | pass
98 |
99 |
100 | def syc_execute(self, config_version, game_version):
101 | '''
102 | to execute shell to zip resource
103 | '''
104 |
105 | LOG.info('start to execute shell %s/syc.sh %s %s %s' % (self._shell_path, config_version, game_version, self._server_id, ))
106 | result = subprocess.call('%s/syc.sh %s %s %s > /dev/null 2>&1' % (self._shell_path, config_version, game_version, self._server_id, ), shell = True)
107 |
108 | return True if result == 0 else False
109 |
110 | if __name__ == '__main__':
111 | os.environ['TZ'] = 'Asia/Shanghai'
112 | time.tzset()
113 |
114 | m = mock_syc(
115 | sys.argv[1] if len(sys.argv) >= 2 else '127.0.0.1',
116 | sys.argv[2] if len(sys.argv) >= 3 else '2181',
117 | sys.argv[3] if len(sys.argv) >= 4 else '/test',
118 | os.path.dirname(sys.argv[0])
119 | )
120 | m.run()
121 |
122 | try:
123 | while True:
124 | time.sleep(3)
125 | except KeyboardInterrupt:
126 | pass
--------------------------------------------------------------------------------
/test/syc.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | #
3 | # exit 0 for success other for failed
4 | #
5 | #
6 |
7 | if [ $# -ne 3 ] ; then
8 | echo "Error params"
9 | exit 1
10 | fi
11 |
12 | CONFIG_VERSION=$1
13 | GAME_VERSION=$2
14 | SERVER_ID=$3
15 |
16 | echo "got config_version=${CONFIG_VERSION} game_version=${GAME_VERSION} target_server=${SERVER_ID}"
17 |
18 | exit 0
19 |
--------------------------------------------------------------------------------
/test/test_init_servers.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import time
6 | import json
7 |
8 | import kazoo
9 | from kazoo.client import KazooClient
10 |
11 | def test_init_servers(num, host = '127.0.0.1', port = 2181):
12 | zookeeper = KazooClient('%s:%s' % (host, port,))
13 | zookeeper.start()
14 |
15 | try:
16 | node = '/test/server_list'
17 | if zookeeper.exists(node) is None:
18 | zookeeper.create(node, json.dumps({'update_time' : time.time()}), makepath = True)
19 | except kazoo.exceptions.NodeExistsError:
20 | pass
21 |
22 | v = 1
23 | while v <= num:
24 | try:
25 | node = '/test/server_list/s%s' % v
26 | if zookeeper.exists(node) is None:
27 | zookeeper.create(node, json.dumps({
28 | 'update_time' : time.time(),
29 | 'server_name' : 's%s' % v,
30 | 'server_id' : v,
31 | }), makepath = True)
32 | except kazoo.exceptions.NodeExistsError:
33 | pass
34 | v += 1
35 |
36 | if __name__ == '__main__':
37 | os.environ['TZ'] = 'Asia/Shanghai'
38 | time.tzset()
39 |
40 | if len(sys.argv) >= 2:
41 | test_init_servers(int(sys.argv[1]))
42 | else:
43 | print 'You must usage like %s num' % (sys.argv[0], )
--------------------------------------------------------------------------------
/test/test_pub_response.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import time
6 | import json
7 |
8 | import kazoo
9 | from kazoo.client import KazooClient
10 |
11 | def test_pub_response(pub_node, server_list, host = '127.0.0.1', port = 2181):
12 | zookeeper = KazooClient('%s:%s' % (host, port,))
13 | zookeeper.start()
14 |
15 | for s in server_list:
16 | if isinstance(s, int) is True:
17 | continue
18 |
19 | try:
20 | node = '/test/to_pub_result/%s/%s' % (pub_node, s, )
21 | if zookeeper.exists(node) is None:
22 | zookeeper.create(node, json.dumps({
23 | 'update_time' : time.time(),
24 | 'status' : 'ok'
25 | }), makepath = True)
26 | except kazoo.exceptions.NodeExistsError:
27 | pass
28 |
29 | if __name__ == '__main__':
30 | os.environ['TZ'] = 'Asia/Shanghai'
31 | time.tzset()
32 |
33 | if len(sys.argv) > 2:
34 | test_pub_response(sys.argv[1], sys.argv[2:])
35 | else:
36 | print 'You must usage like %s v{pub_id} s{server_id}' % (sys.argv[0], )
--------------------------------------------------------------------------------
/test/test_syc_response.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import time
6 | import json
7 |
8 | import kazoo
9 | from kazoo.client import KazooClient
10 |
11 | def test_syc_response(pub_node, server_list, host = '127.0.0.1', port = 2181):
12 | zookeeper = KazooClient('%s:%s' % (host, port,))
13 | zookeeper.start()
14 |
15 | for s in server_list:
16 | if isinstance(s, int) is True:
17 | continue
18 |
19 | try:
20 | node = '/test/to_syc_result/%s/%s' % (pub_node, s, )
21 | if zookeeper.exists(node) is None:
22 | zookeeper.create(node, json.dumps({
23 | 'update_time' : time.time(),
24 | 'status' : 'ok'
25 | }), makepath = True)
26 | except kazoo.exceptions.NodeExistsError:
27 | pass
28 |
29 | if __name__ == '__main__':
30 | os.environ['TZ'] = 'Asia/Shanghai'
31 | time.tzset()
32 |
33 | if len(sys.argv) > 2:
34 | test_syc_response(sys.argv[1], sys.argv[2:])
35 | else:
36 | print 'You must usage like %s v{pub_id} s{server_id}' % (sys.argv[0], )
--------------------------------------------------------------------------------
/test/test_zip_response.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import sys
5 | import time
6 | import json
7 |
8 | from kazoo.client import KazooClient
9 |
10 | def test_zip_response(pub_node, host = '127.0.0.1', port = 2181):
11 | zookeeper = KazooClient('%s:%s' % (host, port,))
12 | zookeeper.start()
13 |
14 | node_value = {
15 | 'status' : 'ok',
16 | 'update_time' : time.time(),
17 | }
18 |
19 | if zookeeper.exists('/test/to_zip_result/%s' % pub_node) is not None:
20 | zookeeper.set('/test/to_zip_result/%s' % pub_node, json.dumps(node_value))
21 | else:
22 | print 'Not found node `/test/to_zip_result/%s`' % pub_node
23 |
24 | if __name__ == '__main__':
25 | os.environ['TZ'] = 'Asia/Shanghai'
26 | time.tzset()
27 |
28 | if len(sys.argv) >= 2:
29 | test_zip_response(sys.argv[1])
30 | else:
31 | print 'You must usage like %s v{pub_id}' % (sys.argv[0], )
--------------------------------------------------------------------------------
/test/zip.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | #
3 | # exit 0 for success other for failed
4 | #
5 | #
6 |
7 | if [ $# -ne 2 ] ; then
8 | echo "Error params"
9 | exit 1
10 | fi
11 |
12 | CONFIG_VERSION=$1
13 | GAME_VERSION=$2
14 |
15 | echo "got config_version=${CONFIG_VERSION} game_version=${GAME_VERSION}"
16 |
17 | exit 0
18 |
--------------------------------------------------------------------------------