Synnefo » snf-ganeti

                        self.cfg.GetNodeName(node_uuid), msg)

    # if this is a DRBD disk, return its port to the pool

      self.cfg.AddTcpUdpPort(root.logical_id[2])

  def _CreateNewNic(self, idx, params, private):

    """

    drbd_info = None

      # we change the snode then (otherwise we use the one passed in)

      if dev.logical_id[0] == instance.primary_node:

        snode_uuid = dev.logical_id[1]

          all_result = False

    # if this is a DRBD disk, return its port to the pool

      ports_to_release.add(device.logical_id[2])

  if all_result or ignore_failures:

      # gather the drbd ports for duplicate checks

      for (idx, dsk) in enumerate(instance.disks):

          tcp_port = dsk.logical_id[2]

          if tcp_port not in ports:

            ports[tcp_port] = []

  DT_EXT,

  ])

# drbd constants

DRBD_HMAC_ALG = "md5"

DRBD_DEFAULT_NET_PROTOCOL = "C"

FD_LOOP = "loop"

FD_BLKTAP = "blktap"

# disk access mode

DISK_RDONLY = "ro"

DISK_RDWR = "rw"

                         constants.DT_BLOCK, constants.DT_RBD,

                         constants.DT_EXT, constants.DT_SHARED_FILE]:

      result = [node_uuid]

      result = [self.logical_id[0], self.logical_id[1]]

      if node_uuid not in result:

        raise errors.ConfigurationError("DRBD device passed unknown node")

    if self.logical_id is None and self.physical_id is not None:

      return

      pnode_uuid, snode_uuid, port, pminor, sminor, secret = self.logical_id

      if target_node_uuid not in (pnode_uuid, snode_uuid):

        raise errors.ConfigurationError("DRBD device not knowing node %s" %

      obj.logical_id = tuple(obj.logical_id)

    if obj.physical_id and isinstance(obj.physical_id, list):

      obj.physical_id = tuple(obj.physical_id)

      # we need a tuple of length six here

      if len(obj.logical_id) < 6:

        obj.logical_id += (None,) * (6 - len(obj.logical_id))

    """

    if self.dev_type == constants.DT_PLAIN:

      val = "<LogicalVolume(/dev/%s/%s" % self.logical_id

      node_a, node_b, port, minor_a, minor_b = self.logical_id[:5]

      val = "<DRBD8("

      if self.physical_id is None:

    """

    def _Helper(nodes, device):

      """Recursively computes nodes given a top device."""

        nodea, nodeb = device.logical_id[:2]

        nodes.add(nodea)

        nodes.add(nodeb)

      if dev.dev_type == constants.DT_PLAIN:

        lvmap[node_uuid].append(dev.logical_id[0] + "/" + dev.logical_id[1])

        if dev.children:

          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[0])

          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[1])

        # Update the DRBD port assignments

        # This is a little bit hackish

        for dsk in instance_info.disks:

            port = my_config.AllocatePort()

            logical_id = list(dsk.logical_id)