Synnefo » snf-ganeti » ganeti-local

                           [socat_stderr_write_fd, dd_stderr_write_fd,

                            dd_pid_write_fd, exp_size_write_fd])

      try:

        def _ForwardSignal(signum, _):

          """Forwards signals to child process.

  """

class ArgGroup(_Argument):

  """Node group argument.

        opcodes.OpTestJqueue(notify_waitlock=True,

                             notify_exec=True,

                             log_messages=test_messages,

        ]

      expect_messages = [test_messages]

      expect_resultlen = 1

      return utils.UnescapeAndSplit(ips, sep=",")

  return None

def AddNetwork(opts, args):

  """Add a network to the cluster.

  else:

    tags = []

  SubmitOpCode(op, opts=opts)

    ToStdout("  type: %s", network_type)

    ToStdout("  size: %d", size)

    ToStdout("  free: %d (%.2f%%)", free_count,

    ToStdout("  usage map:")

    idx = 0

    for line in wrap(mapping, width=64):

                                                ["nic.ips", "nic.networks"],

                                                use_locking=False)

                                    for idx, (ip, net) in enumerate(value)

                                      if net == name)

      # Verify global configuration

      jobs.append([

        ])

      # Always depend on global verification

    """

    env = {

      }

    env.update(("NODE_TAGS_%s" % node.name, " ".join(node.GetTags()))

                                 target_node=self.op.target_node,

                                 allow_runtime_changes=allow_runtime_changes,

                                 ignore_ipolicy=self.op.ignore_ipolicy)]

    # TODO: Run iallocator in this opcode and pass correct placement options to

    # OpInstanceMigrate. Since other jobs can modify the cluster between

                                        for i in range(disk_count)])

    if template_name == constants.DT_PLAIN:

      def logical_id_fn(idx, _, disk):

        vg = disk.get(constants.IDISK_VG, vgname)

        return (vg, names[idx])

    elif template_name in (constants.DT_FILE, constants.DT_SHARED_FILE):

      logical_id_fn = \

        lambda _, disk_index, disk: (file_driver,

        if self.op.conflicts_check:

          _CheckForConflictingIp(self, nic.ip, self.pnode.name)

    # mirror node verification

    if self.op.disk_template in constants.DTS_INT_MIRROR:

      if self.op.snode == pnode.name:

                                        disks=[],

                                        mode=constants.REPLACE_DISK_CHG,

                                        early_release=self.op.early_release)]

    else:

      raise errors.ProgrammerError("No iallocator or remote node")

                                     " in cluster" % mac,

                                     errors.ECODE_NOTUNIQUE)

    elif new_net != old_net:

      def get_net_prefix(net):

        if net:

          uuid = self.cfg.LookupNetwork(net)

            nobj = self.cfg.GetNetwork(uuid)

            return nobj.mac_prefix

        return None

      new_prefix = get_net_prefix(new_net)

      old_prefix = get_net_prefix(old_net)

      if old_prefix != new_prefix:

      result = ial.out_text

    return result

# Network LUs

class LUNetworkAdd(LogicalUnit):

  """Logical unit for creating networks.

                                 self.op.network, errors.ECODE_EXISTS)

    if self.op.mac_prefix:

    # Check tag validity

    for tag in self.op.tags:

      objects.TaggableObject.ValidateTag(tag)

  def BuildHooksEnv(self):

    """Build hooks env.

      locking.LEVEL_NETWORK: [self.network_uuid],

      }

  def CheckPrereq(self):

    """Check prerequisites.

      raise errors.OpPrereqError("Cannot modify gateway and reserved ips"

                                 " at once", errors.ECODE_INVAL)

  def ExpandNames(self):

    self.network_uuid = self.cfg.LookupNetwork(self.op.network_name)

    self.network = self.cfg.GetNetwork(self.network_uuid)

      if self.op.mac_prefix == constants.VALUE_NONE:

        self.mac_prefix = None

      else:

        self.mac_prefix = self.op.mac_prefix

    if self.op.gateway6:

      else:

        self.network6 = self.op.network6

  def BuildHooksEnv(self):

    """Build hooks env.

        all_nodes = lu.cfg.GetAllNodesInfo()

        network_to_instances = dict((uuid, []) for uuid in self.wanted)

      for group in all_groups.values():

        if do_instances:

          group_nodes = [node.name for node in all_nodes.values() if

    return self.nq.OldStyleQuery(self)

class LUNetworkConnect(LogicalUnit):

  """Connect a network to a nodegroup

    nodes = self.cfg.GetNodeGroup(self.group_uuid).members

    return (nodes, nodes)

  def CheckPrereq(self):

    l = lambda value: ", ".join("%s: %s/%s" % (i[0], i[1], i[2])

                                   for i in value)

    nodes = self.cfg.GetNodeGroup(self.group_uuid).members

    return (nodes, nodes)

  def CheckPrereq(self):

    l = lambda value: ", ".join("%s: %s/%s" % (i[0], i[1], i[2])

                                   for i in value)

    raise errors.OpPrereqError("Unknown query resource '%s'" % name,

                               errors.ECODE_INVAL)

def _CheckForConflictingIp(lu, ip, node):

  """In case of conflicting ip raise error.

      ec_reserved.update(self._ec_reserved[ec_id])

    return ec_reserved

  def Generate(self, existing, generate_one_fn, ec_id):

    """Generate a new resource of this type

  return result

def _GenerateMACSuffix():

  """Generate one mac address

            if nobj.mac_prefix:

              prefix = nobj.mac_prefix

        suffix = view_func(*args, **kwargs)

      return wraps(view_func)(_decorator)

    return _get_mac_prefix

    return self._temporary_ips.Reserve(ec_id, ('reserve', address, net_uuid))

  @locking.ssynchronized(_config_lock, shared=1)

  def ReserveIp(self, net, address, ec_id):

    """Reserve a given IPv4 address for use by an instance.

          # Return all IP addresses to the respective address pools

          self._UnlockedCommitIp('release', net_uuid, nic.ip)

    del self._config_data.instances[instance_name]

    self._config_data.cluster.serial_no += 1

    self._WriteConfig()

    """

    return self._UnlockedGetGroupNetParams(net, node)

  @locking.ssynchronized(_config_lock, shared=1)

  def CheckIPInNodeGroup(self, ip, node):

    """Check for conflictig IP.

  SF_SIZE,

  SF_USED,

  SF_FREE,

  ])

VALID_STORAGE_TYPES = frozenset([ST_FILE, ST_LVM_PV, ST_LVM_VG])

  DT_FILE,

  DT_SHARED_FILE,

  DT_BLOCK,

  ])

FILE_DRIVER = frozenset([FD_LOOP, FD_BLKTAP])

  OS_SCRIPT_IMPORT,

  OS_SCRIPT_EXPORT,

  OS_SCRIPT_RENAME,

  ])

OS_API_FILE = "ganeti_api_version"

REBOOT_TYPES = frozenset([

  INSTANCE_REBOOT_SOFT,

  INSTANCE_REBOOT_HARD,

  ])

# instance reboot behaviors

REBOOT_BEHAVIORS = frozenset([

  INSTANCE_REBOOT_ALLOWED,

  ])

VTYPE_STRING = "string"

  OOB_POWER_OFF,

  OOB_POWER_CYCLE,

  OOB_POWER_STATUS,

  ])

OOB_POWER_STATUS_POWERED = "powered"

  HT_NIC_NE2K_PCI,

  HT_NIC_E1000,

  HT_NIC_NE2K_ISA,

  ])

HT_KVM_VALID_NIC_TYPES = frozenset([

  HT_NIC_RTL8139,

  HT_NIC_I8259ER,

  HT_NIC_PCNET,

  HT_NIC_E1000,

  ])

# Disk types

  HT_CACHE_DEFAULT,

  HT_CACHE_NONE,

  HT_CACHE_WTHROUGH,

  ])

HT_HVM_VALID_DISK_TYPES = frozenset([HT_DISK_PARAVIRTUAL, HT_DISK_IOEMU])

  HT_DISK_SCSI,

  HT_DISK_SD,

  HT_DISK_MTD,

  ])

# Mouse types:

  HT_BO_FLOPPY,

  HT_BO_CDROM,

  HT_BO_DISK,

  ])

# SPICE lossless image compression options

OPS_FINALIZED = frozenset([

  OP_STATUS_CANCELED,

  OP_STATUS_SUCCESS,

  ])

# OpCode priority

    constants.HV_REBOOT_BEHAVIOR:

      hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),

    constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK,

    }

  _MIGRATION_STATUS_RE = re.compile("Migration\s+status:\s+(\w+)",

      return env

    if nic.network:

      n = objects.Network.FromDict(nic.netinfo)

      _BuildNetworkEnv(nic.network, n.network, n.gateway,

        # VM) to one physical CPU, using format 'cpu = "C"'

        return "cpu = \"%s\"" % ",".join(map(str, all_cpu_mapping))

    else:

      def _GetCPUMap(vcpu):

        if vcpu[0] == constants.CPU_PINNING_ALL_VAL:

          cpu_map = constants.CPU_PINNING_ALL_XEN

      # second address is only used for writing

      "-u",

      ]

  def _GetMagicCommand(self):

   # Class '...' has no 'OP_ID' member

   "OP_ID": ht.TElemOf([opcodes.OpInstanceFailover.OP_ID,

                        opcodes.OpInstanceMigrate.OP_ID,

   })))

_NEVAC_MOVED = \

  # pylint: disable=E1101

  MODE = constants.IALLOCATOR_MODE_MULTI_ALLOC

  REQ_PARAMS = [

    ]

  _MASUCCESS = \

    ht.TListOf(ht.TAnd(ht.TIsLength(2),

  def GetRequest(self, cfg):

    return {

      }

from ganeti import errors

class AddressPool(object):

  """Address pool class, wrapping an objects.Network object

    self.Update()

  def _GetSize(self):

  @property

  def all_reservations(self):

    "ip",

    "netmask",

    "netdev",

    ]

    elif disk_template == constants.DT_RBD:

      result.append(FillDict(constants.DISK_LD_DEFAULTS[constants.LD_RBD], {

        }))

    return result

_PNetworkType = ("network_type", None, ht.TOr(ht.TNone, _CheckNetworkType),

                 "Network type")

def _CheckCIDRNetNotation(value):

  """Ensure a given cidr notation type is valid.

    return False

  return True

def _CheckCIDRAddrNotation(value):

  """Ensure a given cidr notation type is valid.

    return False

  return True

def _CheckCIDR6AddrNotation(value):

  """Ensure a given cidr notation type is valid.

    return False

  return True

def _CheckCIDR6NetNotation(value):

  """Ensure a given cidr notation type is valid.

    return False

  return True

class _AutoOpParamSlots(objectutils.AutoSlots):

  """Meta class for opcode definitions.

    _PSkipChecks,

    _PIgnoreErrors,

    _PVerbose,

    ]

  OP_RESULT = TJobIdListOnly

class OpClusterConfigQuery(OpCode):

  """Query cluster configuration values."""

  OP_PARAMS = [

    ]

  OP_RESULT = ht.TListOf(ht.TAny)

  OP_RESULT = ht.TStrictDict(True, True, {

    constants.JOB_IDS_KEY: _JOB_LIST,

    ALLOCATABLE_KEY: ht.TListOf(ht.TNonEmptyString),

    })

  def __getstate__(self):

  """Connect to an instance's console."""

  OP_DSC_FIELD = "instance_name"

  OP_PARAMS = [

    ]

  OP_RESULT = ht.TDict

  OP_PARAMS = [

    _PNetworkName,

    _PNetworkType,

     "IPv4 Subnet"),

    ("gateway", None, ht.TOr(ht.TNone, _CheckCIDRAddrNotation),

     "IPv4 Gateway"),

    ]

  OP_RESULT = ht.TNone

class OpNetworkRemove(OpCode):

  """Remove an existing network from the cluster.

     Must not be connected to any nodegroup.

    ]

  OP_RESULT = ht.TNone

class OpNetworkSetParams(OpCode):

  """Modify Network's parameters except for IPv4 subnet"""

  OP_DSC_FIELD = "network_name"

    ]

  OP_RESULT = ht.TNone

class OpNetworkConnect(OpCode):

  """Connect a Network to a specific Nodegroup with the defined netparams

     (mode, link). Nics in this Network will inherit those params.

    ]

  OP_RESULT = ht.TNone

class OpNetworkDisconnect(OpCode):

  """Disconnect a Network from a Nodegroup. Produce errors if NICs are

     present in the Network unless --no-conficts-check option is passed.

    ]

  OP_RESULT = ht.TNone

class OpNetworkQuery(OpCode):

  """Compute the list of networks."""

  OP_PARAMS = [

  # Add simple fields

  fields.extend([

    (_MakeField(name, title, kind, doc), NQ_CONFIG, flags, _GetItemAttr(name))

  # Add fields requiring live data

  fields.extend([

    (_MakeField(name, title, kind, doc), NQ_LIVE, 0,

     compat.partial(_GetLiveNodeField, nfield, kind))

  # Add timestamps

  fields.extend(_GetItemTimestampFields(NQ_CONFIG))

    (_MakeField("disk.size/%s" % i, "Disk/%s" % i, QFT_UNIT,

                "Disk size of %s disk" % utils.FormatOrdinal(i + 1)),

     IQ_CONFIG, 0, _GetInstDiskSize(i))

  return fields

                _VTToQFT[kind], "The \"%s\" hypervisor parameter" % name),

     IQ_CONFIG, 0, _GetInstHvParam(name))

    for name, kind in constants.HVS_PARAMETER_TYPES.items()

  # BE params

  def _GetInstBeParam(name):

                constants.BES_PARAMETER_TITLES.get(name, "be/%s" % name),

                _VTToQFT[kind], "The \"%s\" backend parameter" % name),

     IQ_CONFIG, 0, _GetInstBeParam(name))

  return fields

  # Add simple fields

  fields.extend([

    (_MakeField(name, title, kind, doc), IQ_CONFIG, flags, _GetItemAttr(name))

  # Fields requiring talking to the node

  fields.extend([

  fields.extend([

    (_MakeField(name, title, kind, doc), CQ_CONFIG, flags, _GetItemAttr(name))

    for (name, (title, kind, flags, doc)) in _CLUSTER_SIMPLE_FIELDS.items()

  # Version fields

  fields.extend([

    (_MakeField(name, title, kind, doc), None, 0, _StaticValue(value))

  # Add timestamps

  fields.extend(_GetItemTimestampFields(CQ_CONFIG))

  return _PrepareFieldList(fields, [

class NetworkQueryData:

                            "The external reservations"),

  }

def _GetNetworkStatsField(field, kind, ctx):

  """Gets the value of a "stats" field from L{NetworkQueryData}.

  fields.extend([

    (_MakeField(name, title, kind, doc),

     NETQ_CONFIG, 0, _GetItemAttr(name))

  def _GetLength(getter):

    return lambda ctx, network: len(getter(ctx)[network.uuid])

  fields.extend([

    (_MakeField("group_cnt", "NodeGroups", QFT_NUMBER, "Number of nodegroups"),

     NETQ_GROUP, 0, _GetLength(network_to_groups)),

     NETQ_GROUP, 0, _GetSortedList(network_to_groups)),

    ])

  fields.extend([

    (_MakeField(name, title, kind, doc), NETQ_STATS, 0,

    compat.partial(_GetNetworkStatsField, name, kind))

  return _PrepareFieldList(fields, [])

    _AppendIf(query, bulk, ("bulk", 1))

    networks = self._SendRequest(HTTP_GET, "/%s/networks" % GANETI_RAPI_VERSION,

    if bulk:

      return networks

    else:

    body = {

      "group_name": group_name,

      "network_mode": mode,

      }

    query = []

    """

    body = {

      }

    query = []

                             ("/%s/networks/%s/disconnect" %

                             (GANETI_RAPI_VERSION, network_name)), query, body)

  def ModifyNetwork(self, network, **kwargs):

    """Modifies a network.

                             ("/%s/networks/%s/tags" %

                              (GANETI_RAPI_VERSION, network)), query, None)

  def GetGroups(self, bulk=False):

    """Gets all node groups in the cluster.

    body = {

      "name": name,

      }

    return self._SendRequest(HTTP_POST, "/%s/groups" % GANETI_RAPI_VERSION,

              "free_count", "reserved_count",

              "map", "group_list", "inst_list",

              "external_reservations", "tags",

G_FIELDS = [

  "alloc_policy",

      "dry_run": self.dryRun(),

      })

class R_2_networks_name_connect(baserlib.OpcodeResource):

  """/2/networks/[network_name]/connect resource.

      "dry_run": self.dryRun(),

      })

class R_2_networks_name_disconnect(baserlib.OpcodeResource):

  """/2/networks/[network_name]/disconnect resource.

      "dry_run": self.dryRun(),

      })

class R_2_networks_name_modify(baserlib.OpcodeResource):

  """/2/networks/[network_name]/modify resource.

  """

  TAG_LEVEL = constants.TAG_NODEGROUP

class R_2_networks_name_tags(_R_Tags):

  """ /2/networks/[network_name]/tags resource.

    _set_wakeup_fd_fn = signal.set_wakeup_fd

  except AttributeError:

    # Not supported

    def _SetWakeupFd(self, _): # pylint: disable=R0201

      return -1

  else:

    def _SetWakeupFd(self, fd):

      return self._set_wakeup_fd_fn(fd)

  """

  AssertCommand([

    "bash", "-c",

    ])

LOG_HEADERS = {

  0: "- ",

  1: "* ",

  }

                  " the master node", ssconf_master_node, hostname)

  return False

def UpgradeNetworks(config_data):

  networks = config_data.get("networks", None)

  if not networks:

LOG_HEADERS = {

  0: "- ",

  1: "* ",

  }

OPTIONS = [

    "used": "Used",

    "mount": "Mount",

    "lvm": "LVM?",

    }

  fields = ["name", "size", "used", "mount", "lvm", "info"]