Synnefo » snf-ganeti » ganeti-local

  @type vcpus: string

  @param vcpus: the count of VCPUs the instance has

  @type nics: list

  @type disk_template: string

  @param disk_template: the disk template of the instance

  @type disks: list

  @type bep: dict

  @param bep: the backend parameters for the instance

  @type hvp: dict

  }

  if nics:

    nic_count = len(nics)

      if ip is None:

        ip = ""

      env["INSTANCE_NIC%d_IP" % idx] = ip

      env["INSTANCE_NIC%d_MAC" % idx] = mac

      env["INSTANCE_NIC%d_MODE" % idx] = mode

  if disks:

    disk_count = len(disks)

      env["INSTANCE_DISK%d_SIZE" % idx] = size

      env["INSTANCE_DISK%d_MODE" % idx] = mode

  else:

  if nic.network:

    nobj = lu.cfg.GetNetwork(nic.network)

    netinfo = objects.Network.ToDict(nobj)

def _NICListToTuple(lu, nics):

    "vcpus": bep[constants.BE_VCPUS],

    "nics": _NICListToTuple(lu, instance.nics),

    "disk_template": instance.disk_template,

    "bep": bep,

    "hvp": hvp,

    "hypervisor_name": instance.hypervisor,

  dev_data = objects.Disk(dev_type=constants.LD_LV, size=size,

                          logical_id=(vgnames[0], names[0]),

                          params={})

  dev_meta = objects.Disk(dev_type=constants.LD_LV,

                          size=constants.DRBD_META_SIZE,

                          logical_id=(vgnames[1], names[1]),

                          params={})

  drbd_dev = objects.Disk(dev_type=constants.LD_DRBD8, size=size,

                          logical_id=(primary, secondary, port,

                                      p_minor, s_minor,

                                      shared_secret),

                          children=[dev_data, dev_meta],

                          iv_name=iv_name, params={})

  return drbd_dev

                                      "disk/%d" % disk_index,

                                      minors[idx * 2], minors[idx * 2 + 1])

      disk_dev.mode = disk[constants.IDISK_MODE]

      disks.append(disk_dev)

  else:

    if secondary_nodes:

      size = disk[constants.IDISK_SIZE]

      feedback_fn("* disk %s, size %s" %

                  (disk_index, utils.FormatUnit(size, "h")))

  return disks

    check_params = cluster.SimpleFillNIC(nicparams)

    objects.NIC.CheckParameterSyntax(check_params)

    net_uuid = cfg.LookupNetwork(net)

  return nics

                                 op.disk_template), errors.ECODE_INVAL)

    data_vg = disk.get(constants.IDISK_VG, default_vg)

    new_disk = {

      constants.IDISK_SIZE: size,

      constants.IDISK_MODE: mode,

      constants.IDISK_VG: data_vg,

      }

    if constants.IDISK_METAVG in disk:

      vcpus=self.be_full[constants.BE_VCPUS],

      nics=_NICListToTuple(self, self.nics),

      disk_template=self.op.disk_template,

      bep=self.be_full,

      hvp=self.hv_full,

      hypervisor_name=self.op.hypervisor,

    # create a fake disk info for _GenerateDiskTemplate

    disk_info = [{constants.IDISK_SIZE: d.size, constants.IDISK_MODE: d.mode,

                 for d in instance.disks]

    new_disks = _GenerateDiskTemplate(self, self.op.disk_template,

                                      instance.name, pnode, [snode],

    old_disks = _AnnotateDiskParams(instance, instance.disks, self.cfg)

    new_disks = [d.children[0] for d in instance.disks]

    for parent, child in zip(old_disks, new_disks):

      child.size = parent.size

      child.mode = parent.mode

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

    # NOTE: this must be done right before the call to cfg.Update!

    mac = params[constants.INIC_MAC]

    ip = params.get(constants.INIC_IP, None)

    net = params.get(constants.INIC_NETWORK, None)

    net_uuid = self.cfg.LookupNetwork(net)

    #TODO: not private.filled?? can a nic have no nicparams??

    nicparams = private.filled

    return (nobj, [

      ("nic.%d" % idx,