/
manager.py
138 lines (102 loc) · 2.74 KB
/
manager.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
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
import argparse
import hashlib
import logging
import os
import gc
import re
import time
import signal
import traceback
# import resource
import sys
import gevent.event
import gevent.socket as socket
import greenlet
# from dateutil.tz import tzutc
import gevent.greenlet
try:
import msgpack
except ImportError:
msgpack = None
import logging
log = logging.getLogger("server log")
from notifier import NotificationThread
from user import UserThread
from web import WebThread
class Manager(object):
"""
Manage
"""
def __init__(self):
self._complete = gevent.event.Event()
#1
self.notifier = NotificationThread(self)
self.user = UserThread(self)
self.web = WebThread(self)
self.vms = {}
self.ternimals = {}
def delete_cluster(self, fs_id):
"""
Note that the cluster will pop right back again if it's
still sending heartbeats.
"""
pass
# victim = self.clusters[fs_id]
# victim.stop()
# victim.done.wait()
# del self.clusters[fs_id]
#
# self._expunge(fs_id)
def stop(self):
log.info("%s stopping" % self.__class__.__name__)
#2
self.notifier.stop()
self.user.stop()
self.web.stop()
def _expunge(self, fsid):
pass
def _recover(self):
pass
def start(self):
log.info("%s starting" % self.__class__.__name__)
# Before we start listening to the outside world, recover
# our last known state from persistent storage
try:
self._recover()
except:
log.exception("Recovery failed")
os._exit(-1)
#3
self.notifier.start()
self.user.start()
self.web.start()
def join(self):
log.info("%s joining" % self.__class__.__name__)
#4
self.notifier.join()
self.user.join()
self.web.join()
def on_discovery(self, minion_id, heartbeat_data):
log.info("on_discovery: {0}/{1}".format(minion_id, heartbeat_data['fsid']))
def dump_stacks():
"""
This is for use in debugging, especially using manhole
"""
for ob in gc.get_objects():
if not isinstance(ob, greenlet.greenlet):
continue
if not ob:
continue
log.error(''.join(traceback.format_stack(ob.gr_frame)))
def main():
m = Manager()
m.start()
complete = gevent.event.Event()
def shutdown():
log.info("Signal handler: stopping")
complete.set()
gevent.signal(signal.SIGTERM, shutdown)
gevent.signal(signal.SIGINT, shutdown)
while not complete.is_set():
complete.wait(timeout=1)
main()