def delete(conversation, hostname):
server = Server(hostname)
DroneD.delete(server.droned)
for app in list(server.apps):
app.shouldRunOn.discard(server)
for appinstance in list(server.appinstances):
AppInstance.delete(appinstance)
for appversion in list(AppVersion.objects):
appversion.services.applicableServers.discard(server)
for scab in list(server.scabs):
Scab.delete(scab)
Server.delete(server)
conversation.say("All serializable references to %s have been deleted" %
hostname)
if server.listed:
conversation.say(
"However this server is listed in my server list, you must remove it manually before restarting gov."
)
def getInstance(self, label):
"""get a reference to the application instance
I attempt to delegate to the original provider.
@param label: (string)
@return AppInstance()
@exception AssertionError
"""
label = str(label)
if AppInstance.exists(Server(config.HOSTNAME), App(self.name), label):
return AppInstance(Server(config.HOSTNAME), App(self.name), label)
raise AssertionError('no such application instance')
def construct(state):
server = Server(state['server'])
droned = server.droned
droned.port = state['port']
droned.apps = frozenset(App(name) for name in state.get('apps', []))
droned.currentFailure = state['currentFailure']
return droned
def ignoreServers(self, *hostnames):
"""ignore another DroneD
@param hostnames (iterable of droned.models.server.Server())
"""
for hostname in hostnames:
if Server.exists(hostname):
Server(hostname).connectFailure = 'ignored'
Server(hostname).stopPolling()
def addInstance(self, label):
"""add a new application instance optionally changing the version
I attempt to delegate to the original provider.
@param label: (string)
@return AppInstance()
"""
label = str(label)
return AppInstance(Server(config.HOSTNAME), App(self.name), label)
def joinEnvironmentalChatRoom(event):
"""determine if we should join a chatroom"""
chat = ChatRoom(config.ROMEO_ENV_NAME)
#make sure the drone can be managed by the room
username = config.ROMEO_ENV_NAME
jbserver = jconfig.JABBER_CHAT_SERVICE
jid = "%(username)s@%(jbserver)s" % locals()
Team('support').addMember(jid)
#get the conversation context set to some sane defaults
conversation = Conversation(jid)
#grant the room access to the server
if jconfig.JABBER_TRUST_ROOM:
conversation.grantAuthorization(notify=False)
#be vain assume all conversations revolve around ourself
context = {
'server': Server(config.HOSTNAME),
'subject': Server(config.HOSTNAME),
}
conversation.context.update(context)
#finally join the room
chat.join()
def delete(conversation, hostname):
server = Server(hostname)
DroneD.delete(server.droned)
for app in list(server.apps):
app.shouldRunOn.discard(server)
for appinstance in list(server.appinstances):
AppInstance.delete(appinstance)
for appversion in list(AppVersion.objects):
appversion.services.applicableServers.discard(server)
for scab in list(server.scabs):
Scab.delete(scab)
Server.delete(server)
conversation.say("All serializable references to %s have been deleted" % hostname)
if server.listed:
conversation.say("However this server is listed in my server list, you must remove it manually before restarting gov.")
def construct(state):
server = Server(state.pop('server'))
ap = None
try:
ap = AppProcess(server, state['pid'])
except:
return None
if ap.localInstall and ap.inode != state['inode']:
AppProcess.delete(ap)
return None
ap._created = state.pop('created')
#we know this is going throw an adapter
if IKittRemoteProcess.providedBy(ap.process.process):
#remaining attributes go into the remote process
ap.updateProcess(state) #this is only useful to remote processes
return ap
def construct(state):
server = Server(state['server'])
#we need to format the version correctly
appname = state['app']
version = AppVersion.makeAppVersion(appname, state['version'])
appinstance = AppInstance(server, App(appname), state['label'])
appinstance.appversion = version
pid = state.get('pid', 0)
inode = state.get('inode', 0)
from kitt.proc import isRunning
if pid and isRunning(pid):
appinstance.info.update({'pid': pid, 'inode': inode})
process = AppProcess(server, pid)
if process.inode == inode:
setattr(appinstance, '_process', process)
appinstance.updateInfo(state['info'])
appinstance.enabled = state.get('enabled', False)
appinstance.shouldBeRunning = state.get('shouldBeRunning', False)
x = appinstance.running #preload the process information
#attempt to get our instance into the last known state
return appinstance
def _first_scan(self):
for pid in listProcesses():
try:
AppProcess(Server(config.HOSTNAME), pid)
except InvalidProcess:
pass
def _scan(self):
for pid in listProcesses():
try:
AppProcess(Server(config.HOSTNAME), pid)
except InvalidProcess:
pass
except IOError:
pass #happens on linux when a pid dies
except:
err('process table scanning error')
#scan for crashed instances
for app in App.objects:
if not app.__class__.isValid(app): continue
for ai in app.localappinstances:
if not ai.__class__.isValid(ai): continue
if ai in self.tracking: continue
if not self.first_run: #avoid process table races
self.tracking.add(ai)
config.reactor.callLater(SERVICECONFIG.recovery_period,
self.tracking.discard, ai)
if not ai.enabled: continue #skip disabled
result = None
if ai.running and not ai.shouldBeRunning:
ai.shouldBeRunning = True
if ai.running: continue
manager = AppManager(ai.app.name)
if not manager.running:
continue #skip managers that are not running
if not manager.discover:
continue #app manager claims to be ok
#look for processes that we can assimilate
d = manager.model.findProcesses()
wfd = defer.waitForDeferred(d)
yield wfd
for (pid, result) in wfd.getResult():
d = manager.model.assimilateProcess(result)
wfd2 = defer.waitForDeferred(d)
yield wfd2
ai2 = wfd2.getResult()
if ai2 and isinstance(ai2, AppInstance) and ai2 is ai:
Event('instance-found').fire(instance=ai)
manager.log('Sucessfully assimilated PID %d' % ai2.pid)
if ai.running: continue #may have assimilated the app
if not ai.crashed: continue
if not ai.enabled:
continue #disabled instances are not actionable
if self.first_run: continue #avoid process table races
Event('instance-crashed').fire(instance=ai)
#cool off on eventing for a little while
#keep the process objects up to date
for process in AppProcess.objects:
try:
if not process.localInstall: continue
if not process.running:
AppProcess.delete(process)
except:
err('process book keeping error')
d = defer.Deferred()
config.reactor.callLater(0.01, d.callback, None)
wfd = defer.waitForDeferred(d)
yield wfd
wfd.getResult()
self.first_run = False
yield 'done'
def __setstate__(self, state): self.applicableServers = set( Server(hostname) for hostname in state['applicableServers'] ) self.provided = state['provided'] self.required = state['required']
def safe_process(pid):
try: #because processes can be invalid
return AppProcess(Server(config.HOSTNAME), pid)
except:
err('problem')
return None
def construct(state):
app = App(state['name'])
app.shouldRunOn = set( Server(hostname) for hostname in \
state['shouldRunOn'] )
return app