Synnefo » snf-ganeti » ganeti-local

OP_INSTANCE_SNAPSHOT

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

Takes a snapshot of instance's disk (must be ext template).

:directory: instance-snapshot

:env. vars:

:pre-execution: master node, primary and secondary nodes

:post-execution: master node, primary and secondary nodes

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

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

``/2/instances/[instance_name]/snapshot``

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

Takes snapshot of an instance's disk (must be ext template).

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

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

``PUT``

~~~~~~~

Returns a job ID.

Body parameters:

.. opcode_params:: OP_INSTANCE_SNAPSHOT

   :exclude: instance_name

Job result:

.. opcode_result:: OP_INSTANCE_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.OpPrereqError("No snapshot_name passed for disk %s", ident)

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

    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/%d %s"

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

    constants.IDISK_SNAPSHOT_NAME,

ES_ACTION_SNAPSHOT = "snapshot"

ES_SCRIPT_SNAPSHOT = ES_ACTION_SNAPSHOT

  ES_SCRIPT_VERIFY,

  ES_SCRIPT_SNAPSHOT

IDISK_SNAPSHOT_NAME = "snapshot_name"

  IDISK_SNAPSHOT_NAME: VTYPE_STRING,

      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.EmptyList,

     ht.TListOf(ht.TItems([ht.TOr(ht.TInt, ht.TString),

                           ht.TDictOf(ht.TElemOf([

                                      constants.IDISK_SNAPSHOT_NAME]),

                                      ht.TNonEmptyString)

                          ])),

    "Disks to snapshot"),

    ]

  OP_RESULT = ht.TNone

  def SnapshotInstance(self, instance, **kwargs):

    """Takes snapshot of instance's disks.

    More details for parameters can be found in the RAPI documentation.

    @type instance: string

    @param instance: Instance name

    @rtype: string

    @return: job id

    """

    body = kwargs

    return self._SendRequest(HTTP_PUT,

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

                              (GANETI_RAPI_VERSION, instance)), None, 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.

  """

  PUT_OPCODE = opcodes.OpInstanceSnapshot

  def GetPutOpInput(self):

    """Snapshot disks of an instance.

    """

    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)

SNAPSHOT

^^^^^^^^

| **snapshot**

| {\--disk=*ID*:snapshot_name=*VAL*

| [\--submit]

| {*instance*}

This only works for instances with ext disk template. It eventualla runs

the snapshot script of the corresponding extstorage provider.

The ``--disk 0:snapshot_name=snap1`` will take snapshot of the first disk

by exporting snapshot name (via VOL_SNAPSHOT_NAME) and disk related info

to the script environment. *ID* can be a disk index, name or UUID.

  , ("OpInstanceSnapshot",

     [ pInstanceName

     , pInstSnaps

     ])

opSummaryVal OpInstanceSnapshot { opInstanceName = s } = Just s

  , ISnapParams(..)

  , SetSnapParams(..)

  , pInstSnaps

-- | Disk snapshot definition.

$(buildObject "ISnapParams" "idisk"

  [ simpleField C.idiskSnapshotName [t| NonEmptyString |]])

-- | Instance snapshot params

data SetSnapParams a

  = SetSnapParamsEmpty

  | SetSnapParamsValid (NonEmpty (Int, a))

    deriving (Eq, Show)

readSetSnapParams :: (JSON a) => JSValue -> Text.JSON.Result (SetSnapParams a)

readSetSnapParams (JSArray []) = return SetSnapParamsEmpty

readSetSnapParams v =

  case readJSON v::Text.JSON.Result [(Int, JSValue)] of

    Text.JSON.Ok _ -> liftM SetSnapParamsValid $ readJSON v

    _ -> fail "Cannot parse snapshot params."

instance (JSON a) => JSON (SetSnapParams a) where

  showJSON SetSnapParamsEmpty = showJSON ()

  showJSON (SetSnapParamsValid v) = showJSON v

  readJSON = readSetSnapParams

-- | List of instance snaps.

pInstSnaps :: Field

pInstSnaps =

  renameField "instSnaps" $

  simpleField "disks" [t| SetSnapParams ISnapParams |]

instance Arbitrary ISnapParams where

  arbitrary = ISnapParams <$> genNameNE

instance (Arbitrary a) => Arbitrary (SetSnapParams a) where

  arbitrary = oneof [ pure SetSnapParamsEmpty

                    , SetSnapParamsValid <$> arbitrary

                    ]

        OpCodes.OpInstanceRemove <$> genFQDN <*> arbitrary <*>

          arbitrary <*> arbitrary

      "OP_INSTANCE_SNAPSHOT" ->

        OpCodes.OpInstanceSnapshot <$> genFQDN <*> arbitrary

  def testSnapshotInstance(self):

    self.rapi.AddResponse("23681")

    snap = [0, {"snapshot_name": "snap1"}]

    job_id = self.client.SnapshotInstance("inst7210", disks=[snap])

    self.assertEqual(job_id, 23681)

    self.assertItems(["inst7210"])

    self.assertHandler(rlib2.R_2_instances_name_snapshot)

    self.assertEqual(serializer.LoadJson(self.rapi.GetLastRequestData()),

                     {"disks": [snap]})