Example #1
0
    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
            })
Example #2
0
    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
            })
Example #3
0
    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
            })
Example #4
0
    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
                            })
Example #5
0
    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
                                   })
Example #6
0
    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
                            })
Example #7
0
    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
            })
Example #8
0
    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))
Example #9
0
    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)
        )
Example #10
0
    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))
Example #11
0
    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)
        )
Example #12
0
 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)
Example #13
0
    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)
Example #14
0
    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)
        )
Example #15
0
    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)
        )
Example #16
0
    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
        )
Example #17
0
    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)