Synnefo » snf-ganeti » ganeti-local

    for attr_name in self._OP_REQP:

      attr_val = getattr(op, attr_name, None)

      if attr_val is None:

    if self.REQ_CLUSTER:

      if not cfg.IsCluster():

      if self.REQ_MASTER:

        master = sstore.GetMasterNode()

        if master != socket.gethostname():

  def CheckPrereq(self):

    """Check prerequisites for this LU.

  """

  if nodes is not None and not isinstance(nodes, list):

  if nodes:

    wanted_nodes = []

    for name in nodes:

      node = lu.cfg.GetNodeInfo(lu.cfg.ExpandNodeName(name))

      if node is None:

    wanted_nodes.append(node)

    return wanted_nodes

  all_fields = static_fields | dynamic_fields

  if not all_fields.issuperset(selected):

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

                         "-f", "/root/.ssh/id_dsa",

                         "-q", "-N", ""])

  if result.failed:

  f = open('/root/.ssh/id_dsa.pub', 'r')

  try:

                         "-keyout", constants.SSL_CERT_FILE,

                         "-out", constants.SSL_CERT_FILE, "-batch"])

  if result.failed:

  os.chmod(constants.SSL_CERT_FILE, 0400)

  result = utils.RunCmd([constants.NODE_INITD_SCRIPT, "restart"])

  if result.failed:

class LUInitCluster(LogicalUnit):

    """

    if config.ConfigWriter.IsCluster():

    hostname_local = socket.gethostname()

    self.hostname = hostname = utils.LookupHostname(hostname_local)

    if not hostname:

    self.clustername = clustername = utils.LookupHostname(self.op.cluster_name)

    if not clustername:

    result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", hostname['ip']])

    if result.failed:

    secondary_ip = getattr(self.op, "secondary_ip", None)

    if secondary_ip and not utils.IsValidIP(secondary_ip):

    if secondary_ip and secondary_ip != hostname['ip']:

      result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", secondary_ip])

      if result.failed:

    self.secondary_ip = secondary_ip

    # checks presence of the volume group given

    vgstatus = _HasValidVG(utils.ListVolumeGroups(), self.op.vg_name)

    if vgstatus:

    if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$",

                    self.op.mac_prefix):

    if self.op.hypervisor_type not in hypervisor.VALID_HTYPES:

    result = utils.RunCmd(["ip", "link", "show", "dev", self.op.master_netdev])

    if result.failed:

  def Exec(self, feedback_fn):

    """Initialize the cluster.

    nodelist = self.cfg.GetNodeList()

    if len(nodelist) != 1 or nodelist[0] != master:

    instancelist = self.cfg.GetInstanceList()

    if instancelist:

  def Exec(self, feedback_fn):

    """Destroys the cluster.

      logger.ToStderr("Can't get any data from node %s" % node)

      retries += 1

      if retries >= 10:

      time.sleep(6)

      continue

    retries = 0

    node_list = self.cfg.GetNodeList()

    node_data = rpc.call_os_diagnose(node_list)

    if node_data == False:

    return node_data

    masternode = self.sstore.GetMasterNode()

    if node.name == masternode:

    for instance_name in instance_list:

      instance = self.cfg.GetInstanceInfo(instance_name)

      if node.name == instance.primary_node:

      if node.name in instance.secondary_nodes:

    self.op.node_name = node.name

    self.node = node

        elif field in self.dynamic_fields:

          val = live_data[node.name].get(field, "?")

        else:

        val = str(val)

        node_output.append(val)

      output.append(node_output)

            else:

              val = '-'

          else:

          node_output.append(str(val))

        output.append(node_output)

    dns_data = utils.LookupHostname(node_name)

    if not dns_data:

    node = dns_data['hostname']

    primary_ip = self.op.primary_ip = dns_data['ip']

    if secondary_ip is None:

      secondary_ip = primary_ip

    if not utils.IsValidIP(secondary_ip):

    self.op.secondary_ip = secondary_ip

    node_list = cfg.GetNodeList()

    if node in node_list:

    for existing_node_name in node_list:

      existing_node = cfg.GetNodeInfo(existing_node_name)

          existing_node.secondary_ip == primary_ip or

          existing_node.primary_ip == secondary_ip or

          existing_node.secondary_ip == secondary_ip):

    # check that the type of the node (single versus dual homed) is the

    # same as for the master

    newbie_singlehomed = secondary_ip == primary_ip

    if master_singlehomed != newbie_singlehomed:

      if master_singlehomed:

      else:

    # checks reachablity

    command = ["fping", "-q", primary_ip]

    result = utils.RunCmd(command)

    if result.failed:

    if not newbie_singlehomed:

      # check reachability from my secondary ip to newbie's secondary ip

      command = ["fping", "-S%s" % myself.secondary_ip, "-q", secondary_ip]

      result = utils.RunCmd(command)

      if result.failed:

    self.new_node = objects.Node(name=node,

                                 primary_ip=primary_ip,

    # set up inter-node password and certificate and restarts the node daemon

    gntpass = self.sstore.GetNodeDaemonPassword()

    if not re.match('^[a-zA-Z0-9.]{1,64}$', gntpass):

    f = open(constants.SSL_CERT_FILE)

    try:

      gntpem = f.read(8192)

    # cert doesn't contain this, the here-document will be correctly

    # parsed by the shell sequence below

    if re.search('^!EOF\.', gntpem, re.MULTILINE):

    if not gntpem.endswith("\n"):

    logger.Info("copy cluster pass to %s and starting the node daemon" % node)

    # remove first the root's known_hosts file

    result = ssh.SSHCall(node, 'root', mycommand, batch=False, ask_key=True)

    if result.failed:

    # check connectivity

    time.sleep(4)

        logger.Info("communication to node %s fine, sw version %s match" %

                    (node, result))

      else:

    else:

    # setup ssh on node

    logger.Info("copy ssh key to node %s" % node)

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

    if not result:

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

    _UpdateEtcHosts(new_node.name, new_node.primary_ip)

      result = ssh.SSHCall(node, "root",

                           "fping -S 127.0.0.1 -q %s" % new_node.secondary_ip)

      if result.failed:

    # Distribute updated /etc/hosts and known_hosts to all nodes,

    # including the node just added

    self.old_master = self.sstore.GetMasterNode()

    if self.old_master == self.new_master:

  def Exec(self, feedback_fn):

    """Failover the master node.

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

    """

    disks_ok, disks_info = _AssembleInstanceDisks(self.instance, self.cfg)

    if not disks_ok:

    return disks_info

def _StartInstanceDisks(cfg, instance, force):

  disks_ok, dummy = _AssembleInstanceDisks(instance, cfg,

                                           ignore_secondaries=force)

  if not disks_ok:

    if force is not None and not force:

      logger.Error("If the message above refers to a secondary node,"

                   " you can retry the operation using '--force'.")

class LUDeactivateInstanceDisks(NoHooksLU):

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

  def Exec(self, feedback_fn):

    ins_l = rpc.call_instance_list([instance.primary_node])

    ins_l = ins_l[instance.primary_node]

    if not type(ins_l) is list:

    if self.instance.name in ins_l:

    _ShutdownInstanceDisks(instance, self.cfg)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    # check bridges existance

    brlist = [nic.bridge for nic in instance.nics]

    if not rpc.call_bridges_exist(instance.primary_node, brlist):

    self.instance = instance

    self.op.instance_name = instance.name

    nodeinfo = rpc.call_node_info([node_current], self.cfg.GetVGName())

    if not nodeinfo:

    freememory = nodeinfo[node_current]['memory_free']

    memory = instance.memory

    if memory > freememory:

    _StartInstanceDisks(self.cfg, instance, force)

    if not rpc.call_instance_start(node_current, instance, extra_args):

      _ShutdownInstanceDisks(instance, self.cfg)

    self.cfg.MarkInstanceUp(instance.name)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

  def Exec(self, feedback_fn):

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    if instance.disk_template == constants.DT_DISKLESS:

    if instance.status != "down":

    remote_info = rpc.call_instance_info(instance.primary_node, instance.name)

    if remote_info:

    self.op.os_type = getattr(self.op, "os_type", None)

    if self.op.os_type is not None:

      pnode = self.cfg.GetNodeInfo(

        self.cfg.ExpandNodeName(instance.primary_node))

      if pnode is None:

      os_obj = rpc.call_os_get([pnode.name], self.op.os_type)[pnode.name]

      if not isinstance(os_obj, objects.OS):

    self.instance = instance

    try:

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

      if not rpc.call_instance_os_add(inst.primary_node, inst, "sda", "sdb"):

    finally:

      _ShutdownInstanceDisks(inst, self.cfg)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

  def Exec(self, feedback_fn):

                (instance.name, instance.primary_node))

    if not rpc.call_instance_shutdown(instance.primary_node, instance):

    logger.Info("removing block devices for instance %s" % instance.name)

        elif field == "mac":

          val = instance.nics[0].mac

        else:

        val = str(val)

        iout.append(val)

      output.append(iout)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    # check memory requirements on the secondary node

    target_node = instance.secondary_nodes[0]

    nodeinfo = rpc.call_node_info([target_node], self.cfg.GetVGName())

    info = nodeinfo.get(target_node, None)

    if not info:

    if instance.memory > info['memory_free']:

    # check bridge existance

    brlist = [nic.bridge for nic in instance.nics]

    if not rpc.call_bridges_exist(instance.primary_node, brlist):

    self.instance = instance

      # for remote_raid1, these are md over drbd

      if not _CheckDiskConsistency(self.cfg, dev, target_node, False):

        if not self.op.ignore_consistency:

    feedback_fn("* checking target node resource availability")

    nodeinfo = rpc.call_node_info([target_node], self.cfg.GetVGName())

    if not nodeinfo:

    free_memory = int(nodeinfo[target_node]['memory_free'])

    memory = instance.memory

    if memory > free_memory:

    feedback_fn("* shutting down instance on source node")

    logger.Info("Shutting down instance %s on node %s" %

    feedback_fn("* deactivating the instance's disks on source node")

    if not _ShutdownInstanceDisks(instance, self.cfg, ignore_primary=True):

    instance.primary_node = target_node

    # distribute new instance config to the other nodes

                                             ignore_secondaries=True)

    if not disks_ok:

      _ShutdownInstanceDisks(instance, self.cfg)

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

    if not rpc.call_instance_start(target_node, instance, None):

def _GetInstanceInfoText(instance):

  return "originstname+%s" % instance.name

    """

    if self.op.mode not in (constants.INSTANCE_CREATE,

                            constants.INSTANCE_IMPORT):

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

      src_node = getattr(self.op, "src_node", None)

      src_path = getattr(self.op, "src_path", None)

      if src_node is None or src_path is None:

      src_node_full = self.cfg.ExpandNodeName(src_node)

      if src_node_full is None:

      self.op.src_node = src_node = src_node_full

      if not os.path.isabs(src_path):

      export_info = rpc.call_export_info(src_node, src_path)

      if not export_info:

      if not export_info.has_section(constants.INISECT_EXP):

      ei_version = export_info.get(constants.INISECT_EXP, 'version')

      if (int(ei_version) != constants.EXPORT_VERSION):

      if int(export_info.get(constants.INISECT_INS, 'disk_count')) > 1:

      # FIXME: are the old os-es, disk sizes, etc. useful?

      self.op.os_type = export_info.get(constants.INISECT_EXP, 'os')

      self.src_image = diskimage

    else: # INSTANCE_CREATE

      if getattr(self.op, "os_type", None) is None:

    # check primary node

    pnode = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.pnode))

    if pnode is None:

    self.op.pnode = pnode.name

    self.pnode = pnode

    self.secondaries = []

    # disk template and mirror node verification

    if self.op.disk_template not in constants.DISK_TEMPLATES:

    if self.op.disk_template == constants.DT_REMOTE_RAID1:

      if getattr(self.op, "snode", None) is None:

      snode_name = self.cfg.ExpandNodeName(self.op.snode)

      if snode_name is None:

      elif snode_name == pnode.name:

      self.secondaries.append(snode_name)

    # Check lv size requirements

    }

    if self.op.disk_template not in req_size_dict:

    req_size = req_size_dict[self.op.disk_template]

    for node in nodenames:

      info = nodeinfo.get(node, None)

      if not info:

      if req_size > info['vg_free']:

    # os verification

    os_obj = rpc.call_os_get([pnode.name], self.op.os_type)[pnode.name]

    if not isinstance(os_obj, objects.OS):

    # instance verification

    hostname1 = utils.LookupHostname(self.op.instance_name)

    if not hostname1:

    self.op.instance_name = instance_name = hostname1['hostname']

    instance_list = self.cfg.GetInstanceList()

    if instance_name in instance_list:

    ip = getattr(self.op, "ip", None)

    if ip is None or ip.lower() == "none":

      inst_ip = hostname1['ip']

    else:

      if not utils.IsValidIP(ip):

      inst_ip = ip

    self.inst_ip = inst_ip

    command = ["fping", "-q", hostname1['ip']]

    result = utils.RunCmd(command)

    if not result.failed:

    # bridge verification

    bridge = getattr(self.op, "bridge", None)

      self.op.bridge = bridge

    if not rpc.call_bridges_exist(self.pnode.name, [self.op.bridge]):

    if self.op.start:

      self.instance_status = 'up'

    feedback_fn("* creating instance disks...")

    if not _CreateDisks(self.cfg, iobj):

      _RemoveDisks(iobj, self.cfg)

    feedback_fn("adding instance %s to cluster config" % instance)

    if disk_abort:

      _RemoveDisks(iobj, self.cfg)

      self.cfg.RemoveInstance(iobj.name)

    feedback_fn("creating os for instance %s on node %s" %

                (instance, pnode_name))

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

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

        if not rpc.call_instance_os_add(pnode_name, iobj, "sda", "sdb"):

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

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

        src_image = self.src_image

        if not rpc.call_instance_os_import(pnode_name, iobj, "sda", "sdb",

                                                src_node, src_image):

      else:

        # also checked in the prereq part

    if self.op.start:

      logger.Info("starting instance %s on node %s" % (instance, pnode_name))

      feedback_fn("* starting instance...")

      if not rpc.call_instance_start(pnode_name, iobj, None):

class LUConnectConsole(NoHooksLU):

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

  def Exec(self, feedback_fn):

    node_insts = rpc.call_instance_list([node])[node]

    if node_insts is False:

    if instance.name not in node_insts:

    logger.Debug("connecting to console of %s on %s" % (instance.name, node))

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

    remote_node = self.cfg.ExpandNodeName(self.op.remote_node)

    if remote_node is None:

    self.remote_node = remote_node

    if remote_node == instance.primary_node:

    if instance.disk_template != constants.DT_REMOTE_RAID1:

    for disk in instance.disks:

      if disk.iv_name == self.op.disk_name:

        break

    else:

    if len(disk.children) > 1:

    self.disk = disk

  def Exec(self, feedback_fn):

    #HARDCODE

    if not _CreateBlockDevOnSecondary(self.cfg, remote_node, new_drbd, False,

                                      _GetInstanceInfoText(instance)):

    logger.Info("adding new mirror component on primary")

    #HARDCODE

      # remove secondary dev

      self.cfg.SetDiskID(new_drbd, remote_node)

      rpc.call_blockdev_remove(remote_node, new_drbd)

    # the device exists now

    # call the primary node to add the mirror to md

      self.cfg.SetDiskID(new_drbd, instance.primary_node)

      if not rpc.call_blockdev_remove(instance.primary_node, new_drbd):

        logger.Error("Can't rollback on primary")

    disk.children.append(new_drbd)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

    if instance.disk_template != constants.DT_REMOTE_RAID1:

    for disk in instance.disks:

      if disk.iv_name == self.op.disk_name:

        break

    else:

    for child in disk.children:

      if child.dev_type == "drbd" and child.logical_id[2] == self.op.disk_id:

        break

    else:

    if len(disk.children) < 2:

    self.disk = disk

    self.child = child

    if self.child.logical_id[0] == instance.primary_node:

    self.cfg.SetDiskID(disk, instance.primary_node)

    if not rpc.call_blockdev_removechild(instance.primary_node,

                                              disk, child):

    for node in child.logical_id[:2]:

      self.cfg.SetDiskID(child, node)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.instance = instance

    if instance.disk_template != constants.DT_REMOTE_RAID1:

    if len(instance.secondary_nodes) != 1:

    remote_node = getattr(self.op, "remote_node", None)

    if remote_node is None:

    else:

      remote_node = self.cfg.ExpandNodeName(remote_node)

      if remote_node is None:

    if remote_node == instance.primary_node:

    self.op.remote_node = remote_node

  def Exec(self, feedback_fn):

      #HARDCODE

      if not _CreateBlockDevOnSecondary(cfg, remote_node, new_drbd, False,

                                        _GetInstanceInfoText(instance)):

      logger.Info("adding new mirror component on primary")

      #HARDCODE

        cfg.SetDiskID(new_drbd, instance.primary_node)

        if not rpc.call_blockdev_remove(instance.primary_node, new_drbd):

          logger.Error("Can't rollback on primary")

      dev.children.append(new_drbd)

      cfg.AddInstance(instance)

      cfg.SetDiskID(dev, instance.primary_node)

      is_degr = rpc.call_blockdev_find(instance.primary_node, dev)[5]

      if is_degr:

      cfg.SetDiskID(new_drbd, instance.primary_node)

      is_degr = rpc.call_blockdev_find(instance.primary_node, new_drbd)[5]

      if is_degr:

    for name in iv_names:

      dev, child, new_drbd = iv_names[name]

    """

    if not isinstance(self.op.instances, list):

    if self.op.instances:

      self.wanted_instances = []

      names = self.op.instances

      for name in names:

        instance = self.cfg.GetInstanceInfo(self.cfg.ExpandInstanceName(name))

        if instance is None:

      self.wanted_instances.append(instance)

    else:

      self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name

    self.ip = getattr(self.op, "ip", None)

    self.bridge = getattr(self.op, "bridge", None)

    if [self.mem, self.vcpus, self.ip, self.bridge].count(None) == 4:

    if self.mem is not None:

      try:

        self.mem = int(self.mem)

      except ValueError, err:

    if self.vcpus is not None:

      try:

        self.vcpus = int(self.vcpus)

      except ValueError, err:

    if self.ip is not None:

      self.do_ip = True

      if self.ip.lower() == "none":

        self.ip = None

      else:

        if not utils.IsValidIP(self.ip):

    else:

      self.do_ip = False

    self.do_bridge = (self.bridge is not None)

    instance = self.cfg.GetInstanceInfo(

      self.cfg.ExpandInstanceName(self.op.instance_name))

    if instance is None:

    self.op.instance_name = instance.name

    self.instance = instance

    return

    instance_name = self.cfg.ExpandInstanceName(self.op.instance_name)

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

    if self.instance is None:

    # node verification

    dst_node_short = self.cfg.ExpandNodeName(self.op.target_node)

    self.dst_node = self.cfg.GetNodeInfo(dst_node_short)

    if self.dst_node is None:

    self.op.target_node = self.dst_node.name

  def Exec(self, feedback_fn):

    elif self.op.kind == constants.TAG_NODE:

      name = self.cfg.ExpandNodeName(self.op.name)

      if name is None:

      self.op.name = name

      self.target = self.cfg.GetNodeInfo(name)

    elif self.op.kind == constants.TAG_INSTANCE:

      name = self.cfg.ExpandInstanceName(name)

      if name is None:

      self.op.name = name

      self.target = self.cfg.GetInstanceInfo(name)

    else:

class LUGetTags(TagsLU):

    try:

      self.target.AddTag(self.op.tag)

    except errors.TagError, err:

    try:

      self.cfg.Update(self.target)

    except errors.ConfigurationError:

class LUDelTag(TagsLU):

    TagsLU.CheckPrereq(self)

    objects.TaggableObject.ValidateTag(self.op.tag)

    if self.op.tag not in self.target.GetTags():

  def Exec(self, feedback_fn):

    """Remove the tag from the object.

    try:

      self.cfg.Update(self.target)

    except errors.ConfigurationError: