Python StoragePoolModel.get_storagepool方法代码示例

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def _create_volume_with_file(self, cb, params):
        pool_name = params.pop('pool')
        dir_path = StoragePoolModel(
            conn=self.conn, objstore=self.objstore).lookup(pool_name)['path']
        file_path = os.path.join(dir_path, params['name'])
        if os.path.exists(file_path):
            raise InvalidParameter('KCHVOL0001E', {'name': params['name']})

        upload_file = params['file']
        f_len = upload_file.fp.length
        try:
            size = 0
            with open(file_path, 'wb') as f:
                while True:
                    data = upload_file.file.read(READ_CHUNK_SIZE)
                    if not data:
                        break
                    size += len(data)
                    f.write(data)
                    cb('%s/%s' % (size, f_len))
        except Exception as e:
            raise OperationFailed('KCHVOL0007E',
                                  {'name': params['name'],
                                   'pool': pool_name,
                                   'err': e.message})

        # Refresh to make sure volume can be found in following lookup
        StoragePoolModel.get_storagepool(pool_name, self.conn).refresh(0)
        cb('OK', True)

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def _create_volume_with_capacity(self, cb, params):
        pool_name = params.pop('pool')
        vol_xml = """
        <volume>
          <name>%(name)s</name>
          <allocation unit="MiB">%(allocation)s</allocation>
          <capacity unit="MiB">%(capacity)s</capacity>
          <source>
          </source>
          <target>
            <format type='%(format)s'/>
          </target>
        </volume>
        """
        params.setdefault('allocation', 0)
        params.setdefault('format', 'qcow2')

        name = params['name']
        vol_id = '%s:%s' % (pool_name, name)
        try:
            pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
            xml = vol_xml % params
        except KeyError, item:
            raise MissingParameter("KCHVOL0004E", {'item': str(item),
                                                   'volume': name})

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
 def get_list(self, pool):
     pool = StoragePoolModel.get_storagepool(pool, self.conn)
     if not pool.isActive():
         err = "Unable to list volumes in inactive storagepool %s"
         raise InvalidOperation(err % pool.name())
     try:
         pool.refresh(0)
         return pool.listVolumes()
     except libvirt.libvirtError as e:
         raise OperationFailed(e.get_error_message())

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
 def get_list(self, pool_name):
     pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
     if not pool.isActive():
         raise InvalidOperation("KCHVOL0006E", {'pool': pool_name})
     try:
         pool.refresh(0)
         return sorted(map(lambda x: x.decode('utf-8'), pool.listVolumes()))
     except libvirt.libvirtError as e:
         raise OperationFailed("KCHVOL0008E",
                               {'pool': pool_name,
                                'err': e.get_error_message()})

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
 def get_storagevolume(poolname, name, conn):
     pool = StoragePoolModel.get_storagepool(poolname, conn)
     if not pool.isActive():
         raise InvalidOperation("KCHVOL0006E", {'name': pool})
     try:
         return pool.storageVolLookupByName(name.encode("utf-8"))
     except libvirt.libvirtError as e:
         if e.get_error_code() == libvirt.VIR_ERR_NO_STORAGE_VOL:
             raise NotFoundError("KCHVOL0002E", {'name': name,
                                                 'pool': poolname})
         else:
             raise

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
 def _get_storagevolume(self, pool, name):
     pool = StoragePoolModel.get_storagepool(pool, self.conn)
     if not pool.isActive():
         err = "Unable to list volumes in inactive storagepool %s"
         raise InvalidOperation(err % pool.name())
     try:
         return pool.storageVolLookupByName(name)
     except libvirt.libvirtError as e:
         if e.get_error_code() == libvirt.VIR_ERR_NO_STORAGE_VOL:
             raise NotFoundError("Storage Volume '%s' not found" % name)
         else:
             raise

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def _clone_task(self, cb, params):
        """Asynchronous function which performs the clone operation.

        This function copies all the data inside the original volume into the
        new one.

        Arguments:
        cb -- A callback function to signal the Task's progress.
        params -- A dict with the following values:
            "pool": The name of the original pool.
            "name": The name of the original volume.
            "new_pool": The name of the destination pool.
            "new_name": The name of the new volume.
        """
        orig_pool_name = params['pool']
        orig_vol_name = params['name']
        new_pool_name = params['new_pool']
        new_vol_name = params['new_name']

        try:
            cb('setting up volume cloning')
            orig_vir_vol = StorageVolumeModel.get_storagevolume(orig_pool_name,
                                                                orig_vol_name,
                                                                self.conn)
            orig_vol = self.lookup(orig_pool_name, orig_vol_name)
            new_vir_pool = StoragePoolModel.get_storagepool(new_pool_name,
                                                            self.conn)

            cb('building volume XML')
            root_elem = E.volume()
            root_elem.append(E.name(new_vol_name))
            root_elem.append(E.capacity(unicode(orig_vol['capacity']),
                                        unit='bytes'))
            target_elem = E.target()
            target_elem.append(E.format(type=orig_vol['format']))
            root_elem.append(target_elem)
            new_vol_xml = ET.tostring(root_elem, encoding='utf-8',
                                      pretty_print=True)

            cb('cloning volume')
            new_vir_pool.createXMLFrom(new_vol_xml, orig_vir_vol, 0)
        except (InvalidOperation, NotFoundError, libvirt.libvirtError), e:
            raise OperationFailed('KCHVOL0023E',
                                  {'name': orig_vol_name,
                                   'pool': orig_pool_name,
                                   'err': e.get_error_message()})

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def get_list(self):
        iso_volumes = []
        conn = self.conn.get()
        pools = conn.listStoragePools()
        pools += conn.listDefinedStoragePools()

        for pool_name in pools:
            try:
                pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
                pool.refresh(0)
                volumes = pool.listVolumes()
            except InvalidOperation:
                # Skip inactive pools
                continue

            for volume in volumes:
                res = self.storagevolume.lookup(pool_name, volume)
                if res['format'] == 'iso':
                    res['name'] = '%s' % volume
                    iso_volumes.append(res)
        return iso_volumes

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def get_list(self):
        iso_volumes = []
        conn = self.conn.get()
        pools = conn.listStoragePools()
        pools += conn.listDefinedStoragePools()

        for pool_name in pools:
            try:
                pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
                pool.refresh(0)
                volumes = pool.listVolumes()
            except Exception, e:
                # Skip inactive pools
                kimchi_log.debug("Shallow scan: skipping pool %s because of "
                                 "error: %s", (pool_name, e.message))
                continue

            for volume in volumes:
                res = self.storagevolume.lookup(pool_name, volume)
                if res['format'] == 'iso':
                    res['name'] = '%s' % volume
                    iso_volumes.append(res)

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def create(self, pool, params):
        vol_xml = """
        <volume>
          <name>%(name)s</name>
          <allocation unit="MiB">%(allocation)s</allocation>
          <capacity unit="MiB">%(capacity)s</capacity>
          <source>
          </source>
          <target>
            <format type='%(format)s'/>
          </target>
        </volume>
        """
        params.setdefault('allocation', 0)
        params.setdefault('format', 'qcow2')

        try:
            pool = StoragePoolModel.get_storagepool(pool, self.conn)
            name = params['name']
            xml = vol_xml % params
        except KeyError, key:
            raise MissingParameter(key)

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
    def _create_volume_with_url(self, cb, params):
        pool_name = params['pool']
        name = params['name']
        url = params['url']

        pool_model = StoragePoolModel(conn=self.conn,
                                      objstore=self.objstore)
        pool = pool_model.lookup(pool_name)

        if pool['type'] in ['dir', 'netfs']:
            file_path = os.path.join(pool['path'], name)
        else:
            file_path = tempfile.mkstemp(prefix=name)[1]

        with contextlib.closing(urllib2.urlopen(url)) as response:
            with open(file_path, 'w') as volume_file:
                remote_size = response.info().getheader('Content-Length', '-')
                downloaded_size = 0

                try:
                    while True:
                        chunk_data = response.read(READ_CHUNK_SIZE)
                        if not chunk_data:
                            break

                        volume_file.write(chunk_data)
                        downloaded_size += len(chunk_data)
                        cb('%s/%s' % (downloaded_size, remote_size))
                except (IOError, libvirt.libvirtError) as e:
                    if os.path.isfile(file_path):
                        os.remove(file_path)

                    raise OperationFailed('KCHVOL0007E', {'name': name,
                                                          'pool': pool_name,
                                                          'err': e.message})

        if pool['type'] in ['dir', 'netfs']:
            virt_pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
            virt_pool.refresh(0)
        else:
            def _stream_handler(stream, nbytes, fd):
                return fd.read(nbytes)

            virt_stream = virt_vol = None

            try:
                task = self.create(pool_name, {'name': name,
                                               'format': 'raw',
                                               'capacity': downloaded_size,
                                               'allocation': downloaded_size})
                self.task.wait(task['id'])
                virt_vol = StorageVolumeModel.get_storagevolume(pool_name,
                                                                name,
                                                                self.conn)

                virt_stream = self.conn.get().newStream(0)
                virt_vol.upload(virt_stream, 0, downloaded_size, 0)

                with open(file_path) as fd:
                    virt_stream.sendAll(_stream_handler, fd)

                virt_stream.finish()
            except (IOError, libvirt.libvirtError) as e:
                try:
                    if virt_stream:
                        virt_stream.abort()
                    if virt_vol:
                        virt_vol.delete(0)
                except libvirt.libvirtError, virt_e:
                    kimchi_log.error(virt_e.message)
                finally:
                    raise OperationFailed('KCHVOL0007E', {'name': name,
                                                          'pool': pool_name,
                                                          'err': e.message})
            finally:

# 需要导入模块: from kimchi.model.storagepools import StoragePoolModel [as 别名]
# 或者: from kimchi.model.storagepools.StoragePoolModel import get_storagepool [as 别名]
                    while True:
                        chunk_data = response.read(READ_CHUNK_SIZE)
                        if not chunk_data:
                            break

                        volume_file.write(chunk_data)
                        downloaded_size += len(chunk_data)
                        cb('%s/%s' % (downloaded_size, remote_size))
                except Exception, e:
                    if os.path.isfile(file_path):
                        os.remove(file_path)
                    raise OperationFailed('KCHVOL0007E', {'name': name,
                                                          'pool': pool_name,
                                                          'err': e.message})

        StoragePoolModel.get_storagepool(pool_name, self.conn).refresh(0)
        cb('OK', True)

    def get_list(self, pool_name):
        pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
        if not pool.isActive():
            raise InvalidOperation("KCHVOL0006E", {'pool': pool_name})
        try:
            pool.refresh(0)
            return sorted(map(lambda x: x.decode('utf-8'), pool.listVolumes()))
        except libvirt.libvirtError as e:
            raise OperationFailed("KCHVOL0008E",
                                  {'pool': pool_name,
                                   'err': e.get_error_message()})