Synnefo » snf-ganeti

            if params[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED]

  if brlist:

    result = lu.rpc.call_bridges_exist(target_node, brlist)

def _CheckInstanceBridgesExist(lu, instance, node=None):

    """

    master = self.cfg.GetMasterNode()

    result = self.rpc.call_node_stop_master(master, False)

    priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)

    utils.CreateBackup(priv_key)

    utils.CreateBackup(pub_key)

        ntype = "regular"

      feedback_fn("* Verifying node %s (%s)" % (node, ntype))

      if msg:

        feedback_fn("  - ERROR: while contacting node %s: %s" % (node, msg))

        bad = True

        for node_name in hooks_results:

          show_node_header = True

          res = hooks_results[node_name]

          if msg:

            if res.offline:

              # no need to warn or set fail return value

      node_res = node_lvs[node]

      if node_res.offline:

        continue

      if msg:

        logging.warning("Error enumerating LVs on node %s: %s", node, msg)

        res_nodes[node] = msg

    # shutdown the master IP

    master = self.cfg.GetMasterNode()

    result = self.rpc.call_node_stop_master(master, False)

    try:

      cluster = self.cfg.GetClusterInfo()

      result = self.rpc.call_upload_file(node_list,

                                         constants.SSH_KNOWN_HOSTS_FILE)

      for to_node, to_result in result.iteritems():

         if msg:

           msg = ("Copy of file %s to node %s failed: %s" %

                   (constants.SSH_KNOWN_HOSTS_FILE, to_node, msg))

    finally:

      result = self.rpc.call_node_start_master(master, False)

      if msg:

        self.LogWarning("Could not re-enable the master role on"

                        " the master, please restart manually: %s", msg)

    if self.op.vg_name:

      vglist = self.rpc.call_vg_list(node_list)

      for node in node_list:

        if msg:

          # ignoring down node

          self.LogWarning("Error while gathering data on node %s"

    if os.path.exists(fname):

      result = lu.rpc.call_upload_file(dist_nodes, fname)

      for to_node, to_result in result.items():

         if msg:

           msg = ("Copy of file %s to node %s failed: %s" %

                   (fname, to_node, msg))

    done = True

    cumul_degraded = False

    rstats = lu.rpc.call_blockdev_getmirrorstatus(node, instance.disks)

    if msg:

      lu.LogWarning("Can't get any data from node %s: %s", node, msg)

      retries += 1

  result = True

  if on_primary or dev.AssembleOnSecondary():

    rstats = lu.rpc.call_blockdev_find(node, dev)

    if msg:

      lu.LogWarning("Can't find disk on node %s: %s", node, msg)

      result = False

    # level), so that nodes with a non-responding node daemon don't

    # make all OSes invalid

    good_nodes = [node_name for node_name in rlist

    for node_name, nr in rlist.items():

        continue

      for name, path, status, diagnose in nr.payload:

        if name not in all_os:

    self.context.RemoveNode(node.name)

    result = self.rpc.call_node_leave_cluster(node.name)

    if msg:

      self.LogWarning("Errors encountered on the remote node while leaving"

                      " the cluster: %s", msg)

                                          self.cfg.GetHypervisorType())

      for name in nodenames:

        nodeinfo = node_data[name]

          nodeinfo = nodeinfo.payload

          fn = utils.TryConvert

          live_data[name] = {

      nresult = volumes[node]

      if nresult.offline:

        continue

      if msg:

        self.LogWarning("Can't compute volume data on node %s: %s", node, msg)

        continue

    # check connectivity

    result = self.rpc.call_version([node])[node]

    if constants.PROTOCOL_VERSION == result.payload:

      logging.info("Communication to node %s fine, sw version %s match",

                   node, result.payload)

    result = self.rpc.call_node_add(node, keyarray[0], keyarray[1],

                                    keyarray[2],

                                    keyarray[3], keyarray[4], keyarray[5])

    # Add node to our /etc/hosts, and add key to known_hosts

    if self.cfg.GetClusterInfo().modify_etc_hosts:

    if new_node.secondary_ip != new_node.primary_ip:

      result = self.rpc.call_node_has_ip_address(new_node.name,

                                                 new_node.secondary_ip)

      if not result.payload:

        raise errors.OpExecError("Node claims it doesn't have the secondary ip"

                                 " you gave (%s). Please fix and re-run this"

    result = self.rpc.call_node_verify(node_verify_list, node_verify_param,

                                       self.cfg.GetClusterName())

    for verifier in node_verify_list:

      nl_payload = result[verifier].payload['nodelist']

      if nl_payload:

        for failed in nl_payload:

      result.append(("master_candidate", str(self.op.master_candidate)))

      if self.op.master_candidate == False:

        rrc = self.rpc.call_node_demote_from_mc(node.name)

        if msg:

          self.LogWarning("Node failed to demote itself: %s" % msg)

    """

    result = self.rpc.call_node_powercycle(self.op.node_name,

                                           self.cfg.GetHypervisorType())

    return result.payload

    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(node_disk, node)

      result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, False)

      if msg:

        lu.proc.LogWarning("Could not prepare block device %s on node %s"

                           " (is_primary=False, pass=1): %s",

        continue

      lu.cfg.SetDiskID(node_disk, node)

      result = lu.rpc.call_blockdev_assemble(node, node_disk, iname, True)

      if msg:

        lu.proc.LogWarning("Could not prepare block device %s on node %s"

                           " (is_primary=True, pass=2): %s",

  """

  pnode = instance.primary_node

  if instance.name in ins_l.payload:

    raise errors.OpExecError("Instance is running, can't shutdown"

    for node, top_disk in disk.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(top_disk, node)

      result = lu.rpc.call_blockdev_shutdown(node, top_disk)

      if msg:

        lu.LogWarning("Could not shutdown block device %s on node %s: %s",

                      disk.iv_name, node, msg)

  """

  nodeinfo = lu.rpc.call_node_info([node], lu.cfg.GetVGName(), hypervisor_name)

  free_mem = nodeinfo[node].payload.get('memory_free', None)

  if not isinstance(free_mem, int):

    raise errors.OpPrereqError("Can't compute free memory on node %s, result"

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                              instance.name,

                                              instance.hypervisor)

    if not remote_info.payload: # not running already

      _CheckNodeFreeMemory(self, instance.primary_node,

                           "starting instance %s" % instance.name,

    result = self.rpc.call_instance_start(node_current, instance,

                                          self.hvparams, self.beparams)

    if msg:

      _ShutdownInstanceDisks(self, instance)

      raise errors.OpExecError("Could not start instance: %s" % msg)

        self.cfg.SetDiskID(disk, node_current)

      result = self.rpc.call_instance_reboot(node_current, instance,

                                             reboot_type)

    else:

      result = self.rpc.call_instance_shutdown(node_current, instance)

      _ShutdownInstanceDisks(self, instance)

      _StartInstanceDisks(self, instance, ignore_secondaries)

      result = self.rpc.call_instance_start(node_current, instance, None, None)

      if msg:

        _ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Could not start instance for"

    node_current = instance.primary_node

    self.cfg.MarkInstanceDown(instance.name)

    result = self.rpc.call_instance_shutdown(node_current, instance)

    if msg:

      self.proc.LogWarning("Could not shutdown instance: %s" % msg)

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                              instance.name,

                                              instance.hypervisor)

    if remote_info.payload:

      raise errors.OpPrereqError("Instance '%s' is running on the node %s" %

                                 (self.op.instance_name,

        raise errors.OpPrereqError("Primary node '%s' is unknown" %

                                   self.op.pnode)

      result = self.rpc.call_os_get(pnode.name, self.op.os_type)

    self.instance = instance

    try:

      feedback_fn("Running the instance OS create scripts...")

      result = self.rpc.call_instance_os_add(inst.primary_node, inst, True)

    finally:

      _ShutdownInstanceDisks(self, inst)

    remote_info = self.rpc.call_instance_info(instance.primary_node,

                                              instance.name,

                                              instance.hypervisor)

    if remote_info.payload:

      raise errors.OpPrereqError("Instance '%s' is running on the node %s" %

                                 (self.op.instance_name,

      result = self.rpc.call_file_storage_dir_rename(inst.primary_node,

                                                     old_file_storage_dir,

                                                     new_file_storage_dir)

    _StartInstanceDisks(self, inst, None)

    try:

      result = self.rpc.call_instance_run_rename(inst.primary_node, inst,

                                                 old_name)

      if msg:

        msg = ("Could not run OS rename script for instance %s on node %s"

               " (but the instance has been renamed in Ganeti): %s" %

                 instance.name, instance.primary_node)

    result = self.rpc.call_instance_shutdown(instance.primary_node, instance)

    if msg:

      if self.op.ignore_failures:

        feedback_fn("Warning: can't shutdown instance: %s" % msg)

        if result.offline:

          # offline nodes will be in both lists

          off_nodes.append(name)

          bad_nodes.append(name)

        else:

          if result.payload:

                 instance.name, source_node)

    result = self.rpc.call_instance_shutdown(source_node, instance)

    if msg:

      if self.op.ignore_consistency:

        self.proc.LogWarning("Could not shutdown instance %s on node %s."

      feedback_fn("* starting the instance on the target node")

      result = self.rpc.call_instance_start(target_node, instance, None, None)

      if msg:

        _ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Could not start instance %s on node %s: %s" %

      _CheckNodeNotDrained(self, target_node)

      result = self.rpc.call_instance_migratable(instance.primary_node,

                                                 instance)

    self.instance = instance

                                            self.instance.disks)

      min_percent = 100

      for node, nres in result.items():

        node_done, node_percent = nres.payload

        all_done = all_done and node_done

        if node_percent is not None:

    result = self.rpc.call_blockdev_close(node, self.instance.name,

                                          self.instance.disks)

  def _GoStandalone(self):

    """Disconnect from the network.

    result = self.rpc.call_drbd_disconnect_net(self.all_nodes, self.nodes_ip,

                                               self.instance.disks)

    for node, nres in result.items():

  def _GoReconnect(self, multimaster):

    """Reconnect to the network.

                                           self.instance.disks,

                                           self.instance.name, multimaster)

    for node, nres in result.items():

  def _ExecCleanup(self):

    """Try to cleanup after a failed migration.

                     " a bad state)")

    ins_l = self.rpc.call_instance_list(self.all_nodes, [instance.hypervisor])

    for node, result in ins_l.items():

    runningon_source = instance.name in ins_l[source_node].payload

    runningon_target = instance.name in ins_l[target_node].payload

                                                    instance,

                                                    migration_info,

                                                    False)

    if abort_msg:

      logging.error("Aborting migration failed on target node %s: %s" %

                    (target_node, abort_msg))

    # First get the migration information from the remote node

    result = self.rpc.call_migration_info(source_node, instance)

    if msg:

      log_err = ("Failed fetching source migration information from %s: %s" %

                 (source_node, msg))

                                           migration_info,

                                           self.nodes_ip[target_node])

    if msg:

      logging.error("Instance pre-migration failed, trying to revert"

                    " disk status: %s", msg)

    result = self.rpc.call_instance_migrate(source_node, instance,

                                            self.nodes_ip[target_node],

                                            self.op.live)

    if msg:

      logging.error("Instance migration failed, trying to revert"

                    " disk status: %s", msg)

                                              instance,

                                              migration_info,

                                              True)

    if msg:

      logging.error("Instance migration succeeded, but finalization failed:"

                    " %s" % msg)

  lu.cfg.SetDiskID(device, node)

  result = lu.rpc.call_blockdev_create(node, device, device.size,

                                       instance.name, force_open, info)

  if device.physical_id is None:

    device.physical_id = result.payload

    file_storage_dir = os.path.dirname(instance.disks[0].logical_id[1])

    result = lu.rpc.call_file_storage_dir_create(pnode, file_storage_dir)

  # Note: this needs to be kept in sync with adding of disks in

  # LUSetInstanceParams

  for device in instance.disks:

    for node, disk in device.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(disk, node)

      if msg:

        lu.LogWarning("Could not remove block device %s on node %s,"

                      " continuing anyway: %s", device.iv_name, node, msg)

    file_storage_dir = os.path.dirname(instance.disks[0].logical_id[1])

    result = lu.rpc.call_file_storage_dir_remove(instance.primary_node,

                                                 file_storage_dir)

    if msg:

      lu.LogWarning("Could not remove directory '%s' on node %s: %s",

                    file_storage_dir, instance.primary_node, msg)

    info = hvinfo[node]

    if info.offline:

      continue

class LUCreateInstance(LogicalUnit):

        exp_list = self.rpc.call_export_list(locked_nodes)

        found = False

        for node in exp_list:

            continue

          if src_path in exp_list[node].payload:

            found = True

      _CheckNodeOnline(self, src_node)

      result = self.rpc.call_export_info(src_node, src_path)

      export_info = objects.SerializableConfigParser.Loads(str(result.payload))

      if not export_info.has_section(constants.INISECT_EXP):

                                         self.op.hypervisor)

      for node in nodenames:

        info = nodeinfo[node]

        info = info.payload

        vg_free = info.get('vg_free', None)

        if not isinstance(vg_free, int):

    # os verification

    result = self.rpc.call_os_get(pnode.name, self.op.os_type)

    _CheckNicsBridgesExist(self, self.nics, self.pnode.name)

      if self.op.mode == constants.INSTANCE_CREATE:

        feedback_fn("* running the instance OS create scripts...")

        result = self.rpc.call_instance_os_add(pnode_name, iobj, False)

      elif self.op.mode == constants.INSTANCE_IMPORT:

        feedback_fn("* running the instance OS import scripts...")

        import_result = self.rpc.call_instance_os_import(pnode_name, iobj,

                                                         src_node, src_images,

                                                         cluster_name)

        if msg:

          self.LogWarning("Error while importing the disk images for instance"

                          " %s on node %s: %s" % (instance, pnode_name, msg))

      logging.info("Starting instance %s on node %s", instance, pnode_name)

      feedback_fn("* starting instance...")

      result = self.rpc.call_instance_start(pnode_name, iobj, None, None)

class LUConnectConsole(NoHooksLU):

    node_insts = self.rpc.call_instance_list([node],

                                             [instance.hypervisor])[node]

    if instance.name not in node_insts.payload:

      raise errors.OpExecError("Instance %s is not running." % instance.name)

      raise errors.OpExecError("Can't list volume groups on the nodes")

    for node in oth_node, tgt_node:

      res = results[node]

      if my_vg not in res.payload:

        raise errors.OpExecError("Volume group '%s' not found on %s" %

                                 (my_vg, node))

        info("checking disk/%d on %s" % (idx, node))

        cfg.SetDiskID(dev, node)

        result = self.rpc.call_blockdev_find(node, dev)

        if not msg and not result.payload:

          msg = "disk not found"

        if msg:

    for dev, old_lvs, new_lvs in iv_names.itervalues():

      info("detaching %s drbd from local storage" % dev.iv_name)

      result = self.rpc.call_blockdev_removechildren(tgt_node, dev, old_lvs)

      #dev.children = []

      #cfg.Update(instance)

      rlist = []

      for to_ren in old_lvs:

        result = self.rpc.call_blockdev_find(tgt_node, to_ren)

          # device exists

          rlist.append((to_ren, ren_fn(to_ren, temp_suffix)))

      info("renaming the old LVs on the target node")

      result = self.rpc.call_blockdev_rename(tgt_node, rlist)

      # now we rename the new LVs to the old LVs

      info("renaming the new LVs on the target node")

      rlist = [(new, old.physical_id) for old, new in zip(old_lvs, new_lvs)]

      result = self.rpc.call_blockdev_rename(tgt_node, rlist)

      for old, new in zip(old_lvs, new_lvs):

        new.logical_id = old.logical_id

      # now that the new lvs have the old name, we can add them to the device

      info("adding new mirror component on %s" % tgt_node)

      result = self.rpc.call_blockdev_addchildren(tgt_node, dev, new_lvs)

      if msg:

        for new_lv in new_lvs:

                    hint="cleanup manually the unused logical volumes")

        raise errors.OpExecError("Can't add local storage to drbd: %s" % msg)

    for name, (dev, old_lvs, new_lvs) in iv_names.iteritems():

      cfg.SetDiskID(dev, instance.primary_node)

      result = self.rpc.call_blockdev_find(instance.primary_node, dev)

      if not msg and not result.payload:

        msg = "disk not found"

      if msg:

      info("remove logical volumes for %s" % name)

      for lv in old_lvs:

        cfg.SetDiskID(lv, tgt_node)

        if msg:

          warning("Can't remove old LV: %s" % msg,

                  hint="manually remove unused LVs")

    results = self.rpc.call_vg_list([pri_node, new_node])

    for node in pri_node, new_node:

      res = results[node]

      if my_vg not in res.payload:

        raise errors.OpExecError("Volume group '%s' not found on %s" %

                                 (my_vg, node))

      info("checking disk/%d on %s" % (idx, pri_node))

      cfg.SetDiskID(dev, pri_node)

      result = self.rpc.call_blockdev_find(pri_node, dev)

      if not msg and not result.payload:

        msg = "disk not found"

      if msg:

      # we have new devices, shutdown the drbd on the old secondary

      info("shutting down drbd for disk/%d on old node" % idx)

      cfg.SetDiskID(dev, old_node)

      if msg:

        warning("Failed to shutdown drbd for disk/%d on old node: %s" %

                (idx, msg),

    result = self.rpc.call_drbd_disconnect_net([pri_node], nodes_ip,

                                               instance.disks)[pri_node]

    if msg:

      # detaches didn't succeed (unlikely)

      self.cfg.ReleaseDRBDMinors(instance.name)

                                           instance.disks, instance.name,

                                           False)

    for to_node, to_result in result.items():

      if msg:

        warning("can't attach drbd disks on node %s: %s", to_node, msg,

                hint="please do a gnt-instance info to see the"

    for idx, (dev, old_lvs, _) in iv_names.iteritems():

      cfg.SetDiskID(dev, pri_node)

      result = self.rpc.call_blockdev_find(pri_node, dev)

      if not msg and not result.payload:

        msg = "disk not found"

      if msg:

      info("remove logical volumes for disk/%d" % idx)

      for lv in old_lvs:

        cfg.SetDiskID(lv, old_node)

        if msg:

          warning("Can't remove LV on old secondary: %s", msg,

                  hint="Cleanup stale volumes by hand")

                                       instance.hypervisor)

    for node in nodenames:

      info = nodeinfo[node]

      vg_free = info.payload.get('vg_free', None)

      if not isinstance(vg_free, int):

        raise errors.OpPrereqError("Can't compute free disk space on"

    for node in instance.all_nodes:

      self.cfg.SetDiskID(disk, node)

      result = self.rpc.call_blockdev_grow(node, disk, self.op.amount)

    disk.RecordGrow(self.op.amount)

    self.cfg.Update(instance)

    if self.op.wait_for_sync:

      if dev_pstatus.offline:

        dev_pstatus = None

      else:

        dev_pstatus = dev_pstatus.payload

    else:

      dev_pstatus = None

      if dev_sstatus.offline:

        dev_sstatus = None

      else:

        dev_sstatus = dev_sstatus.payload

    else:

      dev_sstatus = None

        remote_info = self.rpc.call_instance_info(instance.primary_node,

                                                  instance.name,

                                                  instance.hypervisor)

        remote_info = remote_info.payload

        if remote_info and "state" in remote_info:

          remote_state = "up"

      nodeinfo = self.rpc.call_node_info(mem_check_list, self.cfg.GetVGName(),

                                         instance.hypervisor)

      pninfo = nodeinfo[pnode]

      if msg:

        # Assume the primary node is unreachable and go ahead

        self.warn.append("Can't get info from primary node %s: %s" %

      elif not isinstance(pninfo.payload.get('memory_free', None), int):

        self.warn.append("Node data from primary node %s doesn't contain"

                         " free memory information" % pnode)

        self.warn.append("Can't get instance runtime information: %s" %

      else:

        if instance_info.payload:

          current_mem = int(instance_info.payload['memory'])

        for node, nres in nodeinfo.items():

          if node not in instance.secondary_nodes:

            continue

          if msg:

            self.warn.append("Can't get info from secondary node %s: %s" %

                             (node, msg))

      if new_nic_mode == constants.NIC_MODE_BRIDGED:

        nic_bridge = new_filled_nic_params[constants.NIC_LINK]

        if msg:

          msg = "Error checking bridges on node %s: %s" % (pnode, msg)

          if self.force:

                                     " an instance")

        ins_l = self.rpc.call_instance_list([pnode], [instance.hypervisor])

        ins_l = ins_l[pnode]

        if msg:

          raise errors.OpPrereqError("Can't contact node %s: %s" %

                                     (pnode, msg))

        device_idx = len(instance.disks)

        for node, disk in device.ComputeNodeTree(instance.primary_node):

          self.cfg.SetDiskID(disk, node)

          if msg:

            self.LogWarning("Could not remove disk/%d on node %s: %s,"

                            " continuing anyway", device_idx, node, msg)

    rpcresult = self.rpc.call_export_list(self.nodes)

    result = {}

    for node in rpcresult:

        result[node] = False

      else:

        result[node] = rpcresult[node].payload

    if self.op.shutdown:

      # shutdown the instance, but not the disks

      result = self.rpc.call_instance_shutdown(src_node, instance)

    vgname = self.cfg.GetVGName()

      for disk in instance.disks:

        # result.payload will be a snapshot of an lvm leaf of the one we passed

        result = self.rpc.call_blockdev_snapshot(src_node, disk)

        if msg:

          self.LogWarning("Could not snapshot block device %s on node %s: %s",

                          disk.logical_id[1], src_node, msg)

    finally:

      if self.op.shutdown and instance.admin_up:

        result = self.rpc.call_instance_start(src_node, instance, None, None)

        if msg:

          _ShutdownInstanceDisks(self, instance)

          raise errors.OpExecError("Could not start instance: %s" % msg)

      if dev:

        result = self.rpc.call_snapshot_export(src_node, dev, dst_node.name,

                                               instance, cluster_name, idx)

        if msg:

          self.LogWarning("Could not export block device %s from node %s to"

                          " node %s: %s", dev.logical_id[1], src_node,

                          dst_node.name, msg)

        if msg:

          self.LogWarning("Could not remove snapshot block device %s from node"

                          " %s: %s", dev.logical_id[1], src_node, msg)

    result = self.rpc.call_finalize_export(dst_node.name, instance, snap_disks)

    if msg:

      self.LogWarning("Could not finalize export for instance %s"

                      " on node %s: %s", instance.name, dst_node.name, msg)

    if nodelist:

      exportlist = self.rpc.call_export_list(nodelist)

      for node in exportlist:

          continue

        if iname in exportlist[node].payload:

          if msg:

            self.LogWarning("Could not remove older export for instance %s"

                            " on node %s: %s", iname, node, msg)

    exportlist = self.rpc.call_export_list(locked_nodes)

    found = False

    for node in exportlist:

      if msg:

        self.LogWarning("Failed to query node %s (continuing): %s", node, msg)

        continue

      if instance_name in exportlist[node].payload:

        found = True

        result = self.rpc.call_export_remove(node, instance_name)

        if msg:

          logging.error("Could not remove export for instance %s"

                        " on node %s: %s", instance_name, node, msg)

    if self.op.on_nodes:

      result = self.rpc.call_test_delay(self.op.on_nodes, self.op.duration)

      for node, node_result in result.items():

class IAllocator(object):

        }

      if not ninfo.offline:

        remote_info = nresult.payload

        for attr in ['memory_total', 'memory_free', 'memory_dom0',

                     'vg_size', 'vg_free', 'cpu_total']:

    data = self.in_text

    result = call_fn(self.lu.cfg.GetMasterNode(), name, self.in_text)

    self.out_text = result.payload

    if validate:

      offline, as opposed to actual failure; offline=True will always

      imply failed=True, in order to allow simpler checking if

      the user doesn't care about the exact failure mode

  """

  def __init__(self, data=None, failed=False, offline=False,

    self.node = node

    if offline:

      self.failed = True

      self.data = self.payload = None

    elif failed:

      self.data = self.payload = None

    else:

      self.data = data

      if not isinstance(self.data, (tuple, list)):

      elif len(data) != 2:

      elif not self.data[0]:

      else:

        # finally success

        self.payload = data[1]

  @staticmethod

    else:

      return "No error information"

    """If the result has failed, raise an OpExecError.

    This is used so that LU code doesn't have to check for each

    result, but instead can call this function.

    """

  def RemoteFailMsg(self):

    """Check if the remote procedure failed.

    @return: the fail_msg attribute

    """

class Client: