def execute_sync_action(self, hostname, compute): log.msg("Syncing started: '%s' (%s)" % (hostname, str(compute)), system='sync') curtime = datetime.now().isoformat() syncaction = SyncAction(compute) deferred = syncaction.execute(DetachedProtocol(), object()) self.outstanding_requests[str(compute)] = [deferred, curtime, 0, defer.Deferred()] deferred.addCallback(self.handle_success, 'synchronization', hostname, compute, 'suspicious') deferred.addErrback(self.handle_remote_error, hostname, compute, 'suspicious') deferred.addErrback(self.handle_error, 'Synchronization', hostname, compute, 'suspicious') return deferred
def execute_sync_action(self, hostname, compute): log.msg("Syncing started: '%s' (%s)" % (hostname, str(compute)), system='sync') curtime = datetime.now().isoformat() syncaction = SyncAction(compute) deferred = syncaction.execute(DetachedProtocol(), object()) self.outstanding_requests[str(compute)] = [ deferred, curtime, 0, defer.Deferred() ] deferred.addCallback(self.handle_success, 'synchronization', hostname, compute, 'suspicious') deferred.addErrback(self.handle_remote_error, hostname, compute, 'suspicious') deferred.addErrback(self.handle_error, 'Synchronization', hostname, compute, 'suspicious') return deferred
def execute(self, cmd, args): yield BaseHostRequestAction.execute(self, cmd, args) hostname = yield db.get(self.context, 'hostname') # Acceptance of a new HN should trigger its syncing uuid = yield register_machine(hostname, mgt_stack=ISaltInstalled) cmd.write('Host %s accepted. Syncing shortly...\n' % hostname) log.msg('Host %s accepted. Syncing in 5 seconds...' % hostname, system='action-accept') yield async_sleep(5) compute = yield get_machine_by_uuid(uuid) assert compute is not None, 'Machine not found after accept: %s' % uuid log.msg('Syncing NOW...', system='action-accept') syncaction = SyncAction(compute) syncaction._do_not_enqueue = False args = argparse.Namespace() args.full = True yield syncaction.execute(DetachedProtocol(), args)
def _sync_vms_transact(self, remote_vms): local_vms = [i for i in self.context.listcontent() if IVirtualCompute.providedBy(i)] remote_uuids = set(i['uuid'] for i in remote_vms) local_uuids = set(i.__name__ for i in local_vms) root = db.get_root()['oms_root'] machines = root['machines'] for vm_uuid in remote_uuids.difference(local_uuids): remote_vm = [rvm for rvm in remote_vms if rvm['uuid'] == vm_uuid][0] existing_machine = follow_symlinks(machines['by-name'][remote_vm['name']]) if existing_machine: # XXX: this VM is a nested VM, for now let's hack it this way new_compute = Symlink(existing_machine.__name__, existing_machine) self.context._add(new_compute) else: log.msg('Adding virtual compute %s...' % vm_uuid, system='v12n-sync', logLevel=logging.WARNING) new_compute = Compute(unicode(remote_vm['name']), unicode(remote_vm['state'])) new_compute.__name__ = vm_uuid new_compute.template = unicode(remote_vm['template']) alsoProvides(new_compute, IVirtualCompute) alsoProvides(new_compute, IDeployed) # for now let's force new synced computes to not have salt installed # XXX: not sure if removing a parent interface will remove the child also noLongerProvides(new_compute, IManageable) self.context.add(new_compute) for vm_uuid in remote_uuids.intersection(local_uuids): noLongerProvides(self.context[vm_uuid], IUndeployed) alsoProvides(self.context[vm_uuid], IDeployed) for vm_uuid in local_uuids.difference(remote_uuids): if IDeploying.providedBy(self.context[vm_uuid]): log.msg("Don't delete undeployed VM while in IDeploying state", system='v12n') continue noLongerProvides(self.context[vm_uuid], IDeployed) alsoProvides(self.context[vm_uuid], IUndeployed) self.context[vm_uuid].state = u'inactive' if get_config().getboolean('sync', 'delete_on_sync'): log.msg("Deleting compute %s" % vm_uuid, system='v12n-sync', logLevel=logging.WARNING) compute = self.context[vm_uuid] del self.context[vm_uuid] handle(compute, ModelDeletedEvent(self.context)) # TODO: eliminate cross-import between compute and v12ncontainer from opennode.knot.backend.compute import ICompute from opennode.knot.backend.syncaction import SyncAction # sync each vm for compute in self.context.listcontent(): if not IVirtualCompute.providedBy(compute): continue log.msg('Attempting to sync %s' % compute, system='sync-vms') if not ICompute.providedBy(compute.__parent__.__parent__): log.msg('Inconsistent data: %s, Compute is expected. Attempting to fix %s' % (compute.__parent__.__parent__, compute), system='sync-vms', logLevel=logging.WARNING) compute.__parent__ = self.context log.msg('Fixing %s %s' % (compute, 'successful!' if ICompute.providedBy(compute.__parent__.__parent__) else 'failed!'), system='sync-vms', logLevel=logging.WARNING) if not ICompute.providedBy(compute.__parent__.__parent__): return action = SyncAction(compute) matching = [rvm for rvm in remote_vms if rvm['uuid'] == compute.__name__] if not matching: continue remote_vm = matching[0] # todo delegate all this into the action itself default_console = action._default_console() action._sync_consoles() action.sync_owner_transact(remote_vm) action.sync_vm(remote_vm) action.create_default_console(default_console)