def delegate_request(self, req=None, event=None, instanceData=None, **kw): if instanceData.kind != 'container' or \ instanceData.get('token') is None: return container = self.compute.get_container(docker_client(), instanceData, by_agent=True) if container is None: log.info('Can not call [%s], container does not exists', instanceData.uuid) return inspect = self.compute.inspect(container) try: running = inspect['State']['Running'] if not running: log.error('Can not call [%s], container is not running', instanceData.uuid) return except KeyError: log.error('Can not call [%s], container is not running', instanceData.uuid) return progress = Progress(event, parent=req) exit_code, output, data = ns_exec(inspect['State']['Pid'], event) if exit_code == 0: return reply(event, data, parent=req) else: progress.update('Update failed', data={ 'exitCode': exit_code, 'output': output })
def delegate_request(self, req=None, event=None, instanceData=None, **kw): if instanceData.kind != 'container' or \ instanceData.get('token') is None: return container = self.compute.get_container_by_name(instanceData.uuid) if container is None: return inspect = self.compute.inspect(container) try: ip = inspect['NetworkSettings']['IPAddress'] running = inspect['State']['Running'] if not running: log.error('Can not call [%s], container is not running', instanceData.uuid) return except KeyError: log.error('Can not call [%s], container is not running', instanceData.uuid) return progress = Progress(event, parent=req) exit_code, output, data = container_exec(ip, instanceData.token, event) if exit_code == 0: return reply(event, data, parent=req) else: progress.update('Update failed', data={ 'exitCode': exit_code, 'output': output })
def execute(self, event): if not _should_handle(self, event): return if len(event.data.items) == 0: return utils.reply(event) item_names = [] for item in event.data.items: # For development, don't let the server kill your agent if item.name != 'pyagent' or Config.config_update_pyagent(): item_names.append(item.name) home = Config.home() env = dict(os.environ) env['CATTLE_ACCESS_KEY'] = Config.access_key() env['CATTLE_SECRET_KEY'] = Config.secret_key() env['CATTLE_CONFIG_URL'] = Config.config_url() env['CATTLE_HOME'] = home args = [Config.config_sh()] + item_names try: output = utils.get_command_output(args, cwd=home, env=env) return utils.reply(event, {'exitCode': 0, 'output': output}) except subprocess.CalledProcessError as e: Progress(event).update('Update Failed', data={ 'exitCode': e.returncode, 'output': e.output })
def delegate_request(self, req=None, event=None, instanceData=None, **kw): if instanceData.kind != 'container' or \ instanceData.get('token') is None: return container = self.compute.get_container(docker_client(), instanceData) if container is None: return inspect = self.compute.inspect(container) try: ip = inspect['NetworkSettings']['IPAddress'] running = inspect['State']['Running'] if not running: log.error('Can not call [%s], container is not running', instanceData.uuid) return except KeyError: log.error('Can not call [%s], container is not running', instanceData.uuid) return try: # Optimization for empty config.updates, should really find a # better way to do this if event.name == 'config.update' and len(event.data.items) == 0: return reply(event, None, parent=req) except: pass progress = Progress(event, parent=req) if DockerConfig.is_host_pidns(): exit_code, output, data = ns_exec(inspect['State']['Pid'], event) else: exit_code, output, data = container_exec(ip, instanceData.token, event) if exit_code == 0: return reply(event, data, parent=req) else: progress.update('Update failed', data={ 'exitCode': exit_code, 'output': output })
def delegate_request(self, req=None, event=None, instanceData=None, **kw): if instanceData.kind != 'container' or \ instanceData.get('token') is None: return container = self.compute.get_container_by_name(instanceData.uuid) if container is None: return inspect = self.compute.inspect(container) try: ip = inspect['NetworkSettings']['IPAddress'] running = inspect['State']['Running'] if not running: log.error('Can not call [%s], container is not running', instanceData.uuid) return except KeyError: log.error('Can not call [%s], container is not running', instanceData.uuid) return try: # Optimization for empty config.updates, should really find a # better way to do this if event.name == 'config.update' and len(event.data.items) == 0: return reply(event, None, parent=req) except: pass progress = Progress(event, parent=req) if DockerConfig.is_host_pidns(): exit_code, output, data = ns_exec(inspect['State']['Pid'], event) else: exit_code, output, data = container_exec(ip, instanceData.token, event) if exit_code == 0: return reply(event, data, parent=req) else: progress.update('Update failed', data={ 'exitCode': exit_code, 'output': output })
def volume_remove(self, req=None, volumeStoragePoolMap=None, **kw): volume = volumeStoragePoolMap.volume storage_pool = volumeStoragePoolMap.storagePool progress = Progress(req) return self._do( req=req, result=lambda: self._get_response_data(req, volumeStoragePoolMap), lock_obj=volume, action=lambda: self._do_volume_remove(volume, storage_pool, progress))
def snapshot_create(self, req=None, snapshot=None, **kw): progress = Progress(req) volume = snapshot.volume return self._do( req=req, check=lambda: self._is_snapshot_created(snapshot), result=lambda: self._get_response_data(req, snapshot), lock_obj=volume, action=lambda: self._do_snapshot_create(snapshot, progress) )
def image_activate(self, req=None, imageStoragePoolMap=None, **kw): image = imageStoragePoolMap.image storage_pool = imageStoragePoolMap.storagePool progress = Progress(req) return self._do( req=req, check=lambda: self._is_image_active(image, storage_pool), result=lambda: self._get_response_data(imageStoragePoolMap), lock_obj=image, action=lambda: self._do_image_activate(image, storage_pool, progress))
def instance_activate(self, req=None, instanceHostMap=None, **kw): instance = instanceHostMap.instance host = instanceHostMap.host progress = Progress(req) return self._do( req=req, check=lambda: self._is_instance_active(instance, host), result=lambda: self._get_response_data(instanceHostMap), lock_obj=instance, action=lambda: self._do_instance_activate(instance, host, progress) )
def instance_pull(self, req=None, instancePull=None): progress = Progress(req) with lock(self._image_pull_lock(instancePull)): result = self._do_instance_pull(instancePull, progress) if result is None: result = {} else: result = { 'fields': { 'dockerImage': result, }, } return self._reply(req, result)
def volume_remove(self, req=None, volumeStoragePoolMap=None, **kw): volume = volumeStoragePoolMap.volume storage_pool = volumeStoragePoolMap.storagePool progress = Progress(req) with lock(volume): if volume.deviceNumber == 0: get_compute().purge_state(docker_client(), volume.instance) if not self._is_volume_removed(volume, storage_pool): self._do_volume_remove(volume, storage_pool, progress) data = self._get_response_data(req, volumeStoragePoolMap) return self._reply(req, data)
def snapshot_remove(self, req=None, snapshotStoragePoolMap=None, **kw): snapshot = snapshotStoragePoolMap.snapshot storage_pool = snapshotStoragePoolMap.storagePool progress = Progress(req) volume = snapshot.volume return self._do( req=req, check=lambda: self._is_snapshot_removed(snapshot, storage_pool), result=lambda: self._get_response_data( req, snapshotStoragePoolMap), lock_obj=volume, action=lambda: self._do_snapshot_remove( snapshot, storage_pool, progress) )
def instance_remove(self, req=None, instanceHostMap=None, processData=None, **kw): instance, host = self.get_instance_host_from_map(instanceHostMap) progress = Progress(req) if instance is not None: instance.processData = processData return self._do( req=req, check=lambda: self._is_instance_removed(instance, host), result=lambda: {}, lock_obj=instance, action=lambda: self._do_instance_remove(instance, host, progress) )
def instance_activate(self, req=None, instanceHostMap=None, processData=None, **kw): instance, host = self.get_instance_host_from_map(instanceHostMap) progress = Progress(req) if instance is not None: instance.processData = processData return self._do( req=req, check=lambda: self._is_instance_active(instance, host), result=lambda: self._get_response_data(req, instanceHostMap), lock_obj=instance, action=lambda: self._do_instance_activate(instance, host, progress), post_check=False )
def instance_activate(self, req=None, instanceHostMap=None, processData=None, **kw): instance, host = \ BaseComputeDriver.get_instance_host_from_map(self, instanceHostMap) progress = Progress(req) client = docker_client() if instance is not None: instance.processData = processData with lock(instance): if self._is_instance_active(instance, host): self._record_state(client, instance) return self._reply( req, self._get_response_data(req, instanceHostMap)) self._do_instance_activate(instance, host, progress) data = self._get_response_data(req, instanceHostMap) return self._reply(req, data)