cinder.volume.drivers.dell_emc.vnx.taskflows
Module¶AddMirrorImageTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Add the secondary image to MirrorView.
Reversion strategy: Remove the secondary image.
execute
(mirror, mirror_name, secondary_lun_id, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, mirror, mirror_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
AttachSnapTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Attaches the snapshot to the SMP created before.
Reversion strategy: Detach the SMP.
execute
(client, smp_name, snap_name, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, smp_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
CopySnapshotTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Task to copy a volume snapshot/consistency group snapshot.
Reversion Strategy: Delete the copied snapshot/cgsnapshot
execute
(client, snap_name, new_snap_name, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, snap_name, new_snap_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
CreateCGSnapshotTask
(provides='new_cg_snap_name', *args, **kwargs)¶Bases: taskflow.task.Task
Task to create a CG snapshot.
execute
(client, cg_snap_name, cg_name, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(client, cg_snap_name, cg_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
CreateConsistencyGroupTask
(lun_id_key_template, num_of_members, *args, **kwargs)¶Bases: taskflow.task.Task
Task to create a consistency group.
execute
(client, new_cg_name, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
CreateLunTask
(name=None, provides=('new_lun_id', 'new_lun_wwn'), inject=None)¶Bases: taskflow.task.Task
Creates a new lun task.
Reversion strategy: Delete the lun.
execute
(client, pool_name, lun_name, lun_size, provision, tier, ignore_thresholds=False, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, lun_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
CreateMirrorTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Creates a MirrorView with primary lun for replication.
Reversion strategy: Destroy the created MirrorView.
execute
(mirror, mirror_name, primary_lun_id, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, mirror, mirror_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
CreateSMPTask
(name=None, provides='smp_id', inject=None)¶Bases: taskflow.task.Task
Creates a snap mount point (SMP) for the source snapshot.
Reversion strategy: Delete the SMP.
execute
(client, smp_name, base_lun_name, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, smp_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
CreateSnapshotTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Creates a snapshot of a volume.
Reversion Strategy: Delete the created snapshot.
execute
(client, snap_name, lun_id, keep_for=None, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, snap_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
ExtendSMPTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Extend the SMP if needed.
If the SMP is thin and the new size is larger than the old one, then extend it.
execute
(client, smp_name, lun_size, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
MigrateLunTask
(name=None, provides=None, inject=None, rebind=None)¶Bases: taskflow.task.Task
Starts a migration between two LUNs/SMPs.
Reversion strategy: Cleanup the migration session
execute
(client, src_id, dst_id, async_migrate, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, src_id, dst_id, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
ModifySnapshotTask
(name=None, provides=None, requires=None, auto_extract=True, rebind=None, inject=None, ignore_list=None, revert_rebind=None, revert_requires=None)¶Bases: taskflow.task.Task
Task to modify a Snapshot to allow ReadWrite on it.
execute
(client, snap_name, keep_for=None, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
revert
(result, client, snap_name, *args, **kwargs)¶Revert this atom.
This method should undo any side-effects caused by previous execution
of the atom using the result of the execute()
method and
information on the failure which triggered reversion of the flow the
atom is contained in (if applicable).
Parameters: |
|
---|
WaitMigrationsTask
(src_id_template, dst_id_template, dst_wwn_template, num_of_members, *args, **kwargs)¶Bases: taskflow.task.Task
Task to wait migrations to be completed.
execute
(client, *args, **kwargs)¶Activate a given atom which will perform some operation and return.
This method can be used to perform an action on a given set of input
requirements (passed in via *args
and **kwargs
) to accomplish
some type of operation. This operation may provide some named
outputs/results as a result of it executing for later reverting (or for
other atoms to depend on).
NOTE(harlowja): the result (if any) that is returned should be persistable so that it can be passed back into this atom if reverting is triggered (especially in the case where reverting happens in a different python process or on a remote machine) and so that the result can be transmitted to other atoms (which may be local or remote).
Parameters: |
|
---|
create_cg_from_cg_snapshot
(client, cg_name, src_cg_name, cg_snap_name, src_cg_snap_name, pool_name, lun_sizes, lun_names, src_lun_names, specs_list, copy_snap=True)¶create_cloned_cg
(client, cg_name, src_cg_name, pool_name, lun_sizes, lun_names, src_lun_names, specs_list)¶create_cloned_volume
(client, snap_name, lun_id, lun_name, lun_size, base_lun_name, pool_name, provision, tier, async_migrate=False)¶create_mirror_view
(mirror_view, mirror_name, primary_lun_id, pool_name, lun_name, lun_size, provision, tier)¶create_volume_from_snapshot
(client, src_snap_name, lun_name, lun_size, base_lun_name, pool_name, provision, tier, new_snap_name=None)¶fast_create_cloned_volume
(client, snap_name, lun_id, lun_name, base_lun_name)¶fast_create_volume_from_snapshot
(client, snap_name, new_snap_name, lun_name, base_lun_name, pool_name)¶run_migration_taskflow
(client, lun_id, lun_name, lun_size, pool_name, provision, tier, rate=None)¶Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.