/
containerManager.py
178 lines (132 loc) · 5.38 KB
/
containerManager.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
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
#!/usr/bin/python
import os
#os.environ["PYRO_LOGFILE"]="rmdocker.log"
#os.environ["PYRO_LOGLEVEL"]="DEBUG"
import Pyro4
import socket
import time
import json
import logging
import __init__
from configure import Configure
from liveContainerManager import LiveContainerManager
from hostStatusUpdateRequest import ContainerAction, HostUpdate,ContainerUpdate
from hostStatusUpdateResponse import ContainerCommand,HostResponse,ContainerResponse
__init__._check_every_thing_("slave")
log=logging.getLogger("RMDocker.ContainerManager")
class ContainerManager:
def __init__(self):
self.configure = Configure()
liveContainers = {}
self.cgroups={}
self.host = None
self.isRunning = False
self.lastCurrent = 0
##manager live contianers and update parameters
self.liveContainerManager = None
##default heatbeat interval(s)
self.heartbeatInterval = 5
##remote name server proxy
self.remoteNameServer = None
##remote name server host address
self.remoteNameServerHost = ""
##remote name server host port
self.remoteNameServerPort = 0000
##remote name server object ID
self.remoteNameServerID = "container.master"
def initialize(self):
##initialize current time
self.lastCurrent = self.currentTime()
##initialize host name
self.host = socket.gethostname()
if self.configure.initialize() is False:
log.error("initialize configure error")
return False
if self.configure.get("heartbeatInterval") is not None:
self.heartbeatInterval = int(self.configure.get("heartbeatInterval"))
##These configurations are strictly required
self.remoteNameServerID = self.configure.get("nameserverID")
if self.remoteNameServerID is None:
log.error("initialize remote name server error")
return False
self.remoteNameServerHost= self.configure.get("nameserverHost")
if self.remoteNameServerHost is None:
log.error("initialize remote host error")
return False
self.remoteNameServerPort= self.configure.get("nameserverPort")
if self.remoteNameServerPort is None:
log.error("initialize remote port error")
return False
if self.liveContainerManager is None:
self.liveContainerManager = LiveContainerManager(self.configure,self.host)
uri = "PYRONAME:"+self.remoteNameServerID+"@"+self.remoteNameServerHost+":"+self.remoteNameServerPort
log.info("uri: %s",uri)
try:
self.remoteNameServer = Pyro4.Proxy(uri)
except Exception as error:
log.error("error when try to connect proxy %s",error)
return False
return True
def register(self):
try:
isSuccess = self.remoteNameServer.register(self.host)
except Exception as error:
log.error("error while register %s",error)
return False
log.info("register without exception")
if isSuccess:
self.isRunning = True
log.info("register successfully")
return True
else:
log.info("register failed")
return False
def statusUpdate(self, hostUpdate):
dict_hostUpdate=HostUpdate._class_to_dict_(hostUpdate)
dict_hostResponse=None
try:
dict_hostResponse = self.remoteNameServer.statusUpdate(dict_hostUpdate)
except Exception as error:
log.error("exception at status Update:",error)
pass
if dict_hostResponse is None:
return None
hostResponse = HostResponse._dict_to_class_(dict_hostResponse)
log.info("response from host: %s",hostResponse.getHost())
if hostResponse.getHost() != self.host:
log.error("wrong host during update")
return None
return hostResponse
def currentTime(self):
return int(round(time.time()*1000))
##main loop of container manager that hearbeat woth master, execute
##command from master
def serviceLoop(self):
##initilaze required data structure
log.info("initializing")
if self.initialize() is False:
return
log.info("registerring")
##inform master and register itself
if self.register() is False:
return
log.info("looping")
while True:
if self.isRunning == False:
log.error("host is not running")
break
if (self.currentTime() - self.lastCurrent) / 1000 < self.heartbeatInterval:
##We do not want to burn cpu cycles so we sleep here
time.sleep(self.heartbeatInterval/2)
continue
self.lastCurrent = self.currentTime()
##update live and dead container
hostUpdate = self.liveContainerManager.updateLiveContainers()
##send heartbeat and process respond
hostResponse=self.statusUpdate(hostUpdate)
self.liveContainerManager.liveContainerProcess(hostResponse)
log.info("break from loop")
if __name__=="__main__":
print ("start contaienrManager")
containerManager = ContainerManager()
containerManager.serviceLoop()