Synnefo » snf-ganeti » ganeti-local

.. _rapi-res-instances-instance_name-snapshot:

``/2/instances/[instance_name]/reinstall``

++++++++++++++++++++++++++++++++++++++++++++++

Snapshot an instance.

.. rapi_resource_details:: /2/instances/[instance_name]/snapshot

.. _rapi-res-instances-instance_name-snapshot+post:

``POST``

~~~~~~~~

Returns a job ID.

Body parameters:

``snapshot_name`` (string, required)

  Name of the snapshot.

def BlockdevSnapshot(disk, snapshot_name=None):

  elif disk.dev_type == constants.LD_LV and not snapshot_name:

  elif disk.dev_type == constants.DT_EXT:

    r_dev = _RecursiveFindBD(disk)

    if r_dev is not None:

      r_dev.Snapshot(snapshot_name)

    else:

      _Fail("Cannot find block device %s", disk)

  def Snapshot(self, snapshot_name):

    """Take a snapshot of the block device.

    """

    # Call the External Storage's setinfo script,

    # to set metadata for an existing Volume inside the External Storage

    _ExtStorageAction(constants.ES_ACTION_SNAPSHOT, self.unique_id,

                      self.ext_params, snapshot_name=snapshot_name)

                      size=None, grow=None, metadata=None,

                      snapshot_name=None):

                                      grow, metadata, snapshot_name)

                       snapshot_script=es_files[constants.ES_SCRIPT_SNAPSHOT],

                           size=None, grow=None, metadata=None,

                           snapshot_name=None):

  if snapshot_name is not None:

    result["VOL_SNAPSHOT_NAME"] = snapshot_name

def SnapshotInstance(opts, args):

  """Snapshot an instance.

  @param opts: the command line options selected by the user

  @type args: list

  @param args: should contain only one element, the name of the

      instance to be reinstalled

  @rtype: int

  @return: the desired exit code

  """

  instance_name  = args[0]

  inames = _ExpandMultiNames(_EXPAND_INSTANCES, [instance_name])

  if not inames:

    raise errors.OpPrereqError("Selection filter does not match any instances",

                               errors.ECODE_INVAL)

  multi_on = len(inames) > 1

  jex = JobExecutor(verbose=multi_on, opts=opts)

  for instance_name in inames:

    op = opcodes.OpInstanceSnapshot(instance_name=instance_name,

                                    disks=opts.disks)

    jex.QueueJob(instance_name, op)

  results = jex.WaitOrShow(not opts.submit_only)

  if compat.all(map(compat.fst, results)):

    return constants.EXIT_SUCCESS

  else:

    return constants.EXIT_FAILURE

  "snapshot": (

    SnapshotInstance, [ArgInstance(min=1,max=1)],

    [DISK_OPT, SUBMIT_OPT, DRY_RUN_OPT],

    "<instance>", "Snapshot an instance's disk(s)"),

  LUInstanceSnapshot, \

from ganeti.cmdlib.instance import GetItemFromContainer

class LUInstanceSnapshot(LogicalUnit):

  """Take a snapshot of the instance.

  """

  HPATH = "instance-snapshot"

  HTYPE = constants.HTYPE_INSTANCE

  REQ_BGL = False

  def ExpandNames(self):

    self._ExpandAndLockInstance()

  def BuildHooksEnv(self):

    """Build hooks env.

    This runs on master, primary and secondary nodes of the instance.

    """

    return BuildInstanceHookEnvByObject(self, self.instance)

  def BuildHooksNodes(self):

    """Build hooks nodes.

    """

    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)

    return (nl, nl)

  def CheckPrereq(self):

    """Check prerequisites.

    This checks that the instance is in the cluster and is not running.

    """

    instance = self.cfg.GetInstanceInfo(self.op.instance_name)

    assert instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    CheckNodeOnline(self, instance.primary_node, "Instance primary node"

                    " offline, cannot snapshot")

    self.snapshots = []

    for ident, params in self.op.disks:

      idx, disk = GetItemFromContainer(ident, 'disk', instance.disks)

      snapshot_name = params.get("snapshot_name", None)

      if not snapshot_name:

        raise errors.CheckPrereq("No snapshot_name passed for disk %s", ident)

      self.snapshots.append((idx, disk, snapshot_name))

    #if not instance.disk_template == constants.ST_EXT:

    #  raise errors.OpPrereqError("Instance '%s' disk templates is not 'ext'" %

    #                             self.op.instance_name,

    #                             errors.ECODE_INVAL)

    #CheckInstanceState(self, instance, INSTANCE_DOWN, msg="cannot reinstall")

    self.instance = instance

  def Exec(self, feedback_fn):

    """Take a snapshot of the instance the instance.

    """

    inst = self.instance

    node_uuid = inst.primary_node

    for idx, disk, snapshot_name in self.snapshots:

      self.cfg.SetDiskID(disk, node_uuid)

      feedback_fn("Taking a snapshot of instance...")

      result = self.rpc.call_blockdev_snapshot(node_uuid,

                                               (disk, inst),

                                               snapshot_name)

      result.Raise("Could not take a snapshot for instance %s disk %s"

                   " on node %s" % (inst, disk.uuid, inst.primary_node))

ES_ACTION_SNAPSHOT = "snapshot"

ES_SCRIPT_SNAPSHOT = ES_ACTION_SNAPSHOT

  ES_SCRIPT_VERIFY,

  ES_SCRIPT_SNAPSHOT

      result = self._lu.rpc.call_blockdev_snapshot(src_node,

                                                   (disk, instance),

                                                   None)

    "snapshot_script",

class OpInstanceSnapshot(OpCode):

  """Snapshot an instance."""

  OP_DSC_FIELD = "instance_name"

  OP_PARAMS = [

    _PInstanceName,

    ("disks", ht.NoDefault,

     ht.TListOf(ht.TItems([ht.TString,

                           ht.TDictOf(ht.TElemOf("snapshot_name"),

                                      ht.TMaybeString)

                          ])),

    "Disks to snapshot"),

    ]

  OP_RESULT = ht.TNone

  def SnapshotInstance(self, instance, disks, dry_run=False):

    """Snapshots disks on an instance.

    @type instance: str

    @param instance: instance whose disks to replace

    @type disks: list

    @param disks: list of tuples (idend, snapshot_name)

    @rtype: string

    @return: job id

    """

    body = {

      "disks": disks,

      }

    query = []

    _AppendDryRunIf(query, dry_run)

    return self._SendRequest(HTTP_POST,

                             ("/%s/instances/%s/snapshot" %

                              (GANETI_RAPI_VERSION, instance)), query, body)

    translate_fn("/2/instances/", instance_name, "/snapshot"):

      rlib2.R_2_instances_name_snapshot,

class R_2_instances_name_snapshot(baserlib.OpcodeResource):

  """/2/instances/[instance_name]/snapshot resource.

  Implements an instance snapshot.

  """

  POST_OPCODE = opcodes.OpInstanceSnapshot

  def GetPostOpInput(self):

    """Snapshot an instance.

    The URI takes os=name and nostartup=[0|1] optional

    parameters. By default, the instance will be started

    automatically.

    """

    return (self.request_body, {

        "instance_name": self.items[0],

        "dry_run": self.dryRun(),

      })

    ("snapshot_name", None, None),

    (disk, snapshot_name) = params

    cfbd = objects.Disk.FromDict(disk)

    return backend.BlockdevSnapshot(cfbd, snapshot_name)

  , ("OpInstanceSnapshot",

     [ pInstanceName

     , pInstSnaps

     ])

opSummaryVal OpInstanceSnapshot { opInstanceName = s } = Just s

  , ISnapParams(..)

  , pInstSnaps

-- | Disk snapshot definition.

$(buildObject "ISnapParams" "snapshot"

  [ optionalField $ simpleField C.idiskName [t| String |]])

-- | List of instance snaps.

pInstSnaps :: Field

pInstSnaps =

  renameField "instSnaps" $

  simpleField "disks" [t| SetParamsMods ISnapParams |]