def store_key(self, ctxt, key, **kwargs): """Stores (i.e., registers) a key with the key manager. """ if ctxt is None: raise exception.NotAuthorized() # generate UUID and ensure that it isn't in use key_id = uuidutils.generate_uuid() while key_id in self.keys: key_id = uuidutils.generate_uuid() self.keys[key_id] = key return key_id
def fetch_qcow2_image(context, timeout_secs, image_service, image_id, **kwargs): """Download flat image from the glance image server.""" LOG.debug("Downloading image: %s from glance image server as a flat vmdk" " file." % image_id) read_iter = image_service.download(context, image_id) read_handle = rw_util.GlanceFileRead(read_iter) file_size = int(kwargs.get('image_size')) tmp_directory=CONF.image_conversion_dir if tmp_directory is None: tmp_directory='/tmp' tmp_file_name = tmp_directory +"/"+ uuidutils.generate_uuid() fp = open(tmp_file_name, "wb") start_transfer(context, timeout_secs,read_handle, file_size, write_file_handle=fp) #convert the qcow2 to vmdk converted_file_name = _disk_qcow2_to_vmdk(tmp_file_name) if converted_file_name is not None and os.path.exists(converted_file_name): file_size = os.path.getsize(converted_file_name) read_file_handle_local = rw_util.HybridFileHandle(converted_file_name, "rb") write_handle = rw_util.VMwareHTTPWriteFile(kwargs.get('host'), kwargs.get('data_center_name'), kwargs.get('datastore_name'), kwargs.get('cookies'), kwargs.get('file_path'), file_size) start_transfer(context, timeout_secs, read_file_handle_local, file_size, write_file_handle=write_handle) os.remove(converted_file_name) LOG.info(_("Downloaded image: %s from glance image server.") % image_id)
def __init__(self, name, parents=None, uuid=None): self._name = str(name) # The state of this flow. self._state = states.PENDING # If this flow has a parent flow/s which need to be reverted if # this flow fails then please include them here to allow this child # to call the parents... if parents: self.parents = tuple(parents) else: self.parents = () # Any objects that want to listen when a wf/task starts/stops/completes # or errors should be registered here. This can be used to monitor # progress and record tasks finishing (so that it becomes possible to # store the result of a task in some persistent or semi-persistent # storage backend). self.notifier = utils.TransitionNotifier() self.task_notifier = utils.TransitionNotifier() # Ensure that modifications and/or multiple runs aren't happening # at the same time in the same flow at the same time. self._lock = threading.RLock() # Assign this flow a unique identifer. if uuid: self._id = str(uuid) else: self._id = uuidutils.generate_uuid()
def __init__(self, *args, **kwargs): self.db = kwargs.get('db') self.target_helper = self.get_target_helper(self.db) super(VIOSLVMISCSIDriver, self).__init__(*args, **kwargs) self.backend_name =\ self.configuration.safe_get('volume_backend_name') or 'LVM_iSCSI' self.protocol = 'viSCSI' self.target_name = self.configuration.safe_get('host') or uuidutils.generate_uuid()[8]
def _populate_encryption_types(volume_types, encryption): # TODO(joel-coffman): The database currently doesn't enforce uniqueness # for volume type names. default_encryption_types = { 'dm-crypt': { 'cipher': 'aes-xts-plain64', 'control_location': 'front-end', 'key_size': 512, # only half of key is used for cipher in XTS mode 'provider': 'nova.volume.encryptors.cryptsetup.CryptsetupEncryptor', }, 'LUKS': { 'cipher': 'aes-xts-plain64', 'control_location': 'front-end', 'key_size': 512, # only half of key is used for cipher in XTS mode 'provider': 'nova.volume.encryptors.luks.LuksEncryptor', }, } try: volume_types_insert = volume_types.insert() encryption_insert = encryption.insert() for key, values in default_encryption_types.iteritems(): current_time = timeutils.utcnow() volume_type = { 'id': uuidutils.generate_uuid(), 'name': key, 'created_at': current_time, 'updated_at': current_time, 'deleted': False, } volume_types_insert.execute(volume_type) values['id'] = uuidutils.generate_uuid() values['volume_type_id'] = volume_type['id'] values['created_at'] = timeutils.utcnow() values['updated_at'] = values['created_at'] values['deleted'] = False encryption_insert.execute(values) except Exception: LOG.error(_("Error populating default encryption types!"))
def __init__(self, task, uuid=None): assert isinstance(task, collections.Callable) self.task = task self.providers = {} self.runs_before = [] self.result = None if not uuid: self._id = uuidutils.generate_uuid() else: self._id = str(uuid)
def upload_image(context, timeout_secs, image_service, image_id, owner_id,volume, **kwargs): """Upload the vm's disk file to Glance image server.""" LOG.debug("Uploading image: %s to the Glance image server using HttpNfc" " export." % image_id) file_size = kwargs.get('vmdk_size') read_handle = rw_util.VMwareHTTPReadVmdk(kwargs.get('session'), kwargs.get('host'), kwargs.get('vm'), kwargs.get('vmdk_file_path'), file_size) # modified by liuling #Get vmdk to a temp file tmp_directory=CONF.image_conversion_dir if tmp_directory is None: tmp_directory='/tmp' tmp_file_name = tmp_directory +"/"+ uuidutils.generate_uuid() fp = open(tmp_file_name, "wb") nova_client = compute.API() start_transfer(context,timeout_secs, read_handle, file_size, write_file_handle=fp) #conver vmdk to qcow2 task_state = vcenter_task_states.CONVERTING nova_client.update_server_task_state(context,volume,task_state) converted_file_name = _disk_vmdk_to_qcow2(tmp_file_name) if converted_file_name is not None and os.path.exists(converted_file_name): file_size = os.path.getsize(converted_file_name) # The properties and other fields that we need to set for the image. # Important to set the 'size' to 0 here. Otherwise the glance client # uses the volume size which may not be image size after upload since # it is converted to a stream-optimized sparse disk image_metadata = {'disk_format': 'qcow2', 'is_public': 'false', 'name': kwargs.get('image_name'), 'status': 'active', 'container_format': 'bare', 'size': 0, 'properties': {'vmware_image_version': kwargs.get('image_version'), 'owner_id': owner_id}} read_file_handle_local = rw_util.HybridFileHandle(converted_file_name, "rb") start_transfer(context, timeout_secs, read_file_handle_local, file_size, image_service=image_service, image_id=image_id, image_meta=image_metadata,volume=volume,task_state=vcenter_task_states.UPLOADING) if os.path.exists(converted_file_name): os.remove(converted_file_name) LOG.info(_("Uploaded image: %s to the Glance image server.") % image_id)
def _generate_key_id(self): key_id = uuidutils.generate_uuid() while key_id in self.keys: key_id = uuidutils.generate_uuid() return key_id
def __init__(self, host): self.uuid = uuidutils.generate_uuid() self.host = host setattr(self, 'OS-EXT-SRV-ATTR:host', host)
def generate_request_id(): return 'req-%s' % uuidutils.generate_uuid()