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:
self.shell.log.info("Note: block backstore recommended for "
"SCSI block devices")
so = PSCSIStorageObject(name, dev)
ui_so = UIPSCSIStorageObject(so, self)
self.setup_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()
if get_block_type(dev) is not None:
self.shell.log.info("Note: block backstore recommended for "
"SCSI block devices")
so = PSCSIStorageObject(name, dev)
ui_so = UIPSCSIStorageObject(so, self)
self.setup_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, 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))
file_or_dev = os.path.expanduser(file_or_dev)
# can't use is_dev_in_use() on files so just check against other
# storage object paths
if os.path.exists(file_or_dev):
for so in RTSRoot().storage_objects:
if so.udev_path and os.path.samefile(file_or_dev, so.udev_path):
raise ExecutionError("storage object for %s already exists: %s" % \
(file_or_dev, so.name))
if get_block_type(file_or_dev) is not None:
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
elif os.path.exists(file_or_dev):
raise ExecutionError("Path %s exists but is not a file" % file_or_dev)
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.setup_model_alias(so)
self.shell.log.info("Created fileio %s with size %s"
% (name, so.size))
return self.new_node(ui_so)
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))
file_or_dev = os.path.expanduser(file_or_dev)
# can't use is_dev_in_use() on files so just check against other
# storage object paths
if os.path.exists(file_or_dev):
for so in RTSRoot().storage_objects:
if so.udev_path and os.path.samefile(file_or_dev, so.udev_path):
raise ExecutionError("storage object for %s already exists: %s" % \
(file_or_dev, so.name))
if get_block_type(file_or_dev) is not None:
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
elif os.path.exists(file_or_dev):
raise ExecutionError("Path %s exists but is not a file" % file_or_dev)
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.setup_model_alias(so)
self.shell.log.info("Created fileio %s with size %s"
% (name, so.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
