def ui_command_create(self, name, file_or_dev, size=None, buffered=None, sparse=None): ''' Creates a FileIO storage object. If I{file_or_dev} is a path to a regular file to be used as backend, then the I{size} parameter is mandatory. Else, if I{file_or_dev} is a path to a block device, the size parameter B{must} be ommited. If present, I{size} is the size of the file to be used, I{file} the path to the file or I{dev} the path to a block device. The I{buffered} parameter is a boolean stating whether or not to enable buffered mode. It is enabled by default (asynchronous mode). The I{sparse} parameter is only applicable when creating a new backing file. It is a boolean stating if the created file should be created as a sparse file (the default), or fully initialized. SIZE SYNTAX =========== - If size is an int, it represents a number of bytes. - If size is a string, the following units can be used: - B{B} or no unit present for bytes - B{k}, B{K}, B{kB}, B{KB} for kB (kilobytes) - B{m}, B{M}, B{mB}, B{MB} for MB (megabytes) - B{g}, B{G}, B{gB}, B{GB} for GB (gigabytes) - B{t}, B{T}, B{tB}, B{TB} for TB (terabytes) ''' self.assert_root() self.assert_available_so_name(name) self.shell.log.debug("Using params size=%s buffered=%s" " sparse=%s" % (size, buffered, sparse)) sparse = self.ui_eval_param(sparse, 'bool', True) backstore = FileIOBackstore(self.next_hba_index(), mode='create') is_dev = get_block_type(file_or_dev) is not None \ or is_disk_partition(file_or_dev) if size is None and is_dev: backstore = FileIOBackstore(self.next_hba_index(), mode='create') try: so = FileIOStorageObject( backstore, name, file_or_dev, buffered_mode=self.prm_buffered(buffered)) except Exception, exception: backstore.delete() raise exception self.shell.log.info("Created fileio %s with size %s." % (name, size)) self.shell.log.info("Note: block backstore preferred for " " best results.") ui_so = UIStorageObject(so, self) return self.new_node(ui_so)
def ui_command_create(self, name, file_or_dev, size=None, generate_wwn=None, buffered=None, sparse=None): ''' Creates a FileIO storage object. If I{file_or_dev} is a path to a regular file to be used as backend, then the I{size} parameter is mandatory. Else, if I{file_or_dev} is a path to a block device, the size parameter B{must} be ommited. If present, I{size} is the size of the file to be used, I{file} the path to the file or I{dev} the path to a block device. The optional I{generate_wwn} parameter is a boolean specifying whether or not we should generate a T10 wwn Serial for the unit (by default, yes). The I{buffered} parameter is a boolean stating whether or not to enable buffered mode. It is enabled by default (asynchronous mode). The I{sparse} parameter is only applicable when creating a new backing file. It is a boolean stating if the created file should be created as a sparse file (the default), or fully initialized. SIZE SYNTAX =========== - If size is an int, it represents a number of bytes. - If size is a string, the following units can be used: - B{B} or no unit present for bytes - B{k}, B{K}, B{kB}, B{KB} for kB (kilobytes) - B{m}, B{M}, B{mB}, B{MB} for MB (megabytes) - B{g}, B{G}, B{gB}, B{GB} for GB (gigabytes) - B{t}, B{T}, B{tB}, B{TB} for TB (terabytes) ''' self.assert_root() self.assert_available_so_name(name) self.shell.log.debug("Using params size=%s generate_wwn=%s buffered=%s" " sparse=%s" % (size, generate_wwn, buffered, sparse)) sparse = self.ui_eval_param(sparse, 'bool', True) backstore = FileIOBackstore(self.next_hba_index(), mode='create') is_dev = get_block_type(file_or_dev) is not None \ or is_disk_partition(file_or_dev) if size is None and is_dev: backstore = FileIOBackstore(self.next_hba_index(), mode='create') try: so = FileIOStorageObject( backstore, name, file_or_dev, gen_wwn=self.prm_gen_wwn(generate_wwn), buffered_mode=self.prm_buffered(buffered)) except Exception, exception: backstore.delete() raise exception self.shell.log.info("Created fileio %s with size %s." % (name, size)) self.shell.log.info("Note: block backstore preferred for " " best results.") ui_so = UIStorageObject(so, self) return self.new_node(ui_so)
def ui_command_create(self, name, file_or_dev, size=None, buffered=None): ''' Creates a FileIO storage object. If I{file_or_dev} is a path to a regular file to be used as backend, then the I{size} parameter is mandatory. Else, if I{file_or_dev} is a path to a block device, the size parameter B{must} be ommited. If present, I{size} is the size of the file to be used, I{file} the path to the file or I{dev} the path to a block device. The I{buffered} parameter is a boolean stating whether or not to enable buffered mode. It is disabled by default (synchronous mode). SIZE SYNTAX =========== - If size is an int, it represents a number of bytes. - If size is a string, the following units can be used: - B{B} or no unit present for bytes - B{k}, B{K}, B{kB}, B{KB} for kB (kilobytes) - B{m}, B{M}, B{mB}, B{MB} for MB (megabytes) - B{g}, B{G}, B{gB}, B{GB} for GB (gigabytes) - B{t}, B{T}, B{tB}, B{TB} for TB (terabytes) ''' self.assert_root() self.shell.log.debug('Using params size=%s buffered=%s' % (size, buffered)) is_dev = get_block_type(file_or_dev) is not None \ or is_disk_partition(file_or_dev) if size is None and is_dev: so = FileIOStorageObject(self.rtsnode, name, file_or_dev, buffered_mode=self.prm_buffered(buffered)) self.shell.log.info("Created fileio %s with size %s." % (name, size)) ui_so = UIStorageObjectLegacy(so, self) return self.new_node(ui_so) elif size is not None and not is_dev: so = FileIOStorageObject(self.rtsnode, name, file_or_dev, size, buffered_mode=self.prm_buffered(buffered)) self.shell.log.info("Created fileio storage object %s." % name) ui_so = UIStorageObjectLegacy(so, self) return self.new_node(ui_so) else: self.shell.log.error( "For fileio, you must either specify both a " + "file and a size, or just a device path.")
def ui_command_create(self, name, file_or_dev, size=None, generate_wwn=None, buffered=None): ''' Creates a FileIO storage object. If I{file_or_dev} is a path to a regular file to be used as backend, then the I{size} parameter is mandatory. Else, if I{file_or_dev} is a path to a block device, the size parameter B{must} be ommited. If present, I{size} is the size of the file to be used, I{file} the path to the file or I{dev} the path to a block device. The optional I{generate_wwn} parameter is a boolean specifying whether or not we should generate a T10 wwn Serial for the unit (by default, yes). The I{buffered} parameter is a boolean stating whether or not to enable buffered mode. It is disabled by default (synchronous mode). SIZE SYNTAX =========== - If size is an int, it represents a number of bytes. - If size is a string, the following units can be used: - B{B} or no unit present for bytes - B{k}, B{K}, B{kB}, B{KB} for kB (kilobytes) - B{m}, B{M}, B{mB}, B{MB} for MB (megabytes) - B{g}, B{G}, B{gB}, B{GB} for GB (gigabytes) - B{t}, B{T}, B{tB}, B{TB} for TB (terabytes) ''' self.assert_root() self.shell.log.debug('Using params size=%s generate_wwn=%s buffered=%s' % (size, generate_wwn, buffered)) is_dev = get_block_type(file_or_dev) is not None \ or is_disk_partition(file_or_dev) if size is None and is_dev: so = FileIOStorageObject(self.rtsnode, name, file_or_dev, gen_wwn=self.prm_gen_wwn(generate_wwn), buffered_mode=self.prm_buffered(buffered)) self.shell.log.info("Created fileio %s with size %s." % (name, size)) ui_so = UIStorageObjectLegacy(so, self) return self.new_node(ui_so) elif size is not None and not is_dev: so = FileIOStorageObject(self.rtsnode, name, file_or_dev, size, gen_wwn=self.prm_gen_wwn(generate_wwn), buffered_mode=self.prm_buffered(buffered)) self.shell.log.info("Created fileio storage object %s." % name) ui_so = UIStorageObjectLegacy(so, self) return self.new_node(ui_so) else: self.shell.log.error("For fileio, you must either specify both a " + "file and a size, or just a device path.")
def ui_command_create(self, name, dev): ''' Creates a PSCSI storage object, with supplied name and SCSI device. The SCSI device I{dev} can either be a path name to the device, in which case it is recommended to use the /dev/disk/by-id hierarchy to have consistent naming should your physical SCSI system be modified, or an SCSI device ID in the H:C:T:L format, which is not recommended as SCSI IDs may vary in time. ''' self.assert_root() if get_block_type(dev) is not None or is_disk_partition(dev): self.shell.log.info("Note: block backstore recommended for " "SCSI block devices") so = PSCSIStorageObject(name, dev) ui_so = UIPSCSIStorageObject(so, self) self.ui_set_model_alias(so) self.shell.log.info("Created pscsi storage object %s using %s" % (name, dev)) return self.new_node(ui_so)
def ui_command_create(self, name, dev): ''' Creates a PSCSI storage object, with supplied name and SCSI device. The SCSI device I{dev} can either be a path name to the device, in which case it is recommended to use the /dev/disk/by-id hierarchy to have consistent naming should your physical SCSI system be modified, or an SCSI device ID in the H:C:T:L format, which is not recommended as SCSI IDs may vary in time. ''' self.assert_root() self.assert_available_so_name(name) backstore = PSCSIBackstore(self.next_hba_index(), mode='create') if get_block_type(dev) is not None or is_disk_partition(dev): self.shell.log.info("Note: block backstore recommended for " "SCSI block devices") try: so = PSCSIStorageObject(backstore, name, dev) except Exception, exception: backstore.delete() raise exception
def ui_command_create(self, name, file_or_dev, size=None, write_back=None, sparse=None): ''' Creates a FileIO storage object. If I{file_or_dev} is a path to a regular file to be used as backend, then the I{size} parameter is mandatory. Else, if I{file_or_dev} is a path to a block device, the size parameter B{must} be ommited. If present, I{size} is the size of the file to be used, I{file} the path to the file or I{dev} the path to a block device. The I{write_back} parameter is a boolean controlling write caching. It is enabled by default. The I{sparse} parameter is only applicable when creating a new backing file. It is a boolean stating if the created file should be created as a sparse file (the default), or fully initialized. SIZE SYNTAX =========== - If size is an int, it represents a number of bytes. - If size is a string, the following units can be used: - B{B} or no unit present for bytes - B{k}, B{K}, B{kB}, B{KB} for kB (kilobytes) - B{m}, B{M}, B{mB}, B{MB} for MB (megabytes) - B{g}, B{G}, B{gB}, B{GB} for GB (gigabytes) - B{t}, B{T}, B{tB}, B{TB} for TB (terabytes) ''' self.assert_root() sparse = self.ui_eval_param(sparse, 'bool', True) write_back = self.ui_eval_param(write_back, 'bool', True) self.shell.log.debug("Using params size=%s write_back=%s sparse=%s" % (size, write_back, sparse)) is_dev = get_block_type(file_or_dev) is not None \ or is_disk_partition(file_or_dev) # can't use is_dev_in_use() on files so just check against other # storage object paths if file_or_dev in (so.udev_path for so in RTSRoot().storage_objects): raise ExecutionError("storage object for %s already exists" % file_or_dev) if is_dev: if size: self.shell.log.info("Block device, size parameter ignored") size = None self.shell.log.info("Note: block backstore preferred for best results") else: # use given file size only if backing file does not exist if os.path.isfile(file_or_dev): new_size = os.path.getsize(file_or_dev) if size: self.shell.log.info("%s exists, using its size (%s bytes) instead" % (file_or_dev, new_size)) size = new_size else: # create file and extend to given file size if not size: raise ExecutionError("Attempting to create file for new" + " fileio backstore, need a size") size = human_to_bytes(size) self._create_file(file_or_dev, size, sparse) so = FileIOStorageObject( name, file_or_dev, size, write_back=write_back) ui_so = UIFileioStorageObject(so, self) self.ui_set_model_alias(so) self.shell.log.info("Created fileio %s with size %s" % (name, size)) return self.new_node(ui_so)
def ui_command_create(self, name, file_or_dev, size=None, buffered=None, sparse=None): ''' Creates a FileIO storage object. If I{file_or_dev} is a path to a regular file to be used as backend, then the I{size} parameter is mandatory. Else, if I{file_or_dev} is a path to a block device, the size parameter B{must} be ommited. If present, I{size} is the size of the file to be used, I{file} the path to the file or I{dev} the path to a block device. The I{buffered} parameter is a boolean stating whether or not to enable buffered mode. It is enabled by default (asynchronous mode). The I{sparse} parameter is only applicable when creating a new backing file. It is a boolean stating if the created file should be created as a sparse file (the default), or fully initialized. SIZE SYNTAX =========== - If size is an int, it represents a number of bytes. - If size is a string, the following units can be used: - B{B} or no unit present for bytes - B{k}, B{K}, B{kB}, B{KB} for kB (kilobytes) - B{m}, B{M}, B{mB}, B{MB} for MB (megabytes) - B{g}, B{G}, B{gB}, B{GB} for GB (gigabytes) - B{t}, B{T}, B{tB}, B{TB} for TB (terabytes) ''' self.assert_root() self.assert_available_so_name(name) self.shell.log.debug("Using params size=%s buffered=%s sparse=%s" % (size, buffered, sparse)) sparse = self.ui_eval_param(sparse, 'bool', True) backstore = FileIOBackstore(self.next_hba_index(), mode='create') is_dev = get_block_type(file_or_dev) is not None \ or is_disk_partition(file_or_dev) if is_dev: if size: self.shell.log.info("Block device, size parameter ignored") size = None self.shell.log.info("Note: block backstore preferred for best results") else: # use given file size only if backing file does not exist if os.path.isfile(file_or_dev): new_size = str(os.path.getsize(file_or_dev)) if size: self.shell.log.info("%s exists, using its size (%s bytes) instead" % (file_or_dev, new_size)) size = new_size else: # create file and extend to given file size if not size: raise ExecutionError("Attempting to create file for new" + " fileio backstore, need a size") self._create_file(file_or_dev, human_to_bytes(size), sparse) try: so = FileIOStorageObject( backstore, name, file_or_dev, size, buffered_mode=self.prm_buffered(buffered)) except Exception, exception: backstore.delete() raise exception