Synnefo » snf-ganeti » ganeti-local

      disk_info = []

      for idx, disk_data in enumerate(self.op.target_node):

        try:

        except errors.GenericError, err:

          raise errors.OpPrereqError("Target info for disk %s: %s" % (idx, err),

                                     errors.ECODE_INVAL)

      assert len(disk_info) == len(self.op.target_node)

      self.dest_disk_info = disk_info

            OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_PEM,

                                            self.dest_x509_ca)

                                                     timeouts)

      finally:

        helper.Cleanup()

class _TransferInstCbBase(ImportExportCbBase):

  def __init__(self, lu, feedback_fn, instance, timeouts, src_node, src_cbs,

    """Initializes this class.

    """

    self.src_cbs = src_cbs

    self.dest_node = dest_node

    self.dest_ip = dest_ip

class _TransferInstSourceCb(_TransferInstCbBase):

    assert self.src_cbs

    assert dtp.src_export is None

    assert dtp.dest_import

    self.feedback_fn("%s is now listening, starting export" % dtp.data.name)

    # Start export on source node

                    self.dest_ip, ie.listen_port,

                    self.instance, dtp.data.src_io, dtp.data.src_ioargs,

                    self.timeouts, self.src_cbs, private=dtp)

class _DiskTransferPrivate(object):

    """Initializes this class.

    @type data: L{DiskTransfer}

    """

    self.data = data

    self.src_export = None

    self.dest_import = None

  def RecordResult(self, success):

    """Updates the status.

    self.success = self.success and success

def TransferInstanceData(lu, feedback_fn, src_node, dest_node, dest_ip,

                         instance, all_transfers):

  """Transfers an instance's data from one node to another.

  logging.debug("Source node %s, destination node %s, compression '%s'",

                src_node, dest_node, compress)

  timeouts = ImportExportTimeouts(constants.DISK_TRANSFER_CONNECT_TIMEOUT)

  src_cbs = _TransferInstSourceCb(lu, feedback_fn, instance, timeouts,

  dest_cbs = _TransferInstDestCb(lu, feedback_fn, instance, timeouts,

  all_dtp = []

  ieloop = ImportExportLoop(lu)

  try:

      if transfer:

        feedback_fn("Exporting %s from %s to %s" %

                    (transfer.name, src_node, dest_node))

        di = DiskImport(lu, dest_node, opts, instance,

                        transfer.dest_io, transfer.dest_ioargs,

    return (fin_resu, dresults)

    """Inter-cluster instance export.

    @type disk_info: list

    @param disk_info: Per-disk destination information

    @type timeouts: L{ImportExportTimeouts}

    @param timeouts: Timeouts for this import

    ieloop = ImportExportLoop(self._lu)

    try:

        self._feedback_fn("Sending disk %s to %s:%s" % (idx, host, port))

        finished_fn = compat.partial(self._TransferFinished, idx)

        ieloop.Add(DiskExport(self._lu, instance.primary_node,

    host = self._external_address

    disks = []

      disks.append(ComputeRemoteImportDiskInfo(self._cds, self._salt,

    assert len(disks) == self._disk_count

    assert self._daemon_port[idx] is None

    self._CheckAllListening()

  source_ca_pem = OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_PEM,

                                                  source_x509_ca)

  # Create crypto key

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

                                        constants.RIE_CERT_VALIDITY)

    x509_cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,

                                                x509_cert_pem)

    # Sign certificate

    signed_x509_cert_pem = \

      utils.SignX509Certificate(x509_cert, cds, utils.GenerateSecret(8))

    ieloop = ImportExportLoop(lu)

    try:

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

        ieloop.Add(DiskImport(lu, instance.primary_node, opts, instance,

                              constants.IEIO_SCRIPT, (dev, idx),

                              timeouts, cbs, private=(idx, )))

  return None

  """Returns the hashed text for import/export disk information.

  @type disk_index: number

  @param host: Hostname

  @type port: number

  @param port: Daemon port

  """

def CheckRemoteExportDiskInfo(cds, disk_index, disk_info):

  """

  try:

  except (TypeError, ValueError), err:

    raise errors.GenericError("Invalid data: %s" % err)

  if not utils.VerifySha1Hmac(cds, msg, hmac_digest, salt=hmac_salt):

    raise errors.GenericError("HMAC is wrong")

  return (utils.HostInfo.NormalizeName(host),

  """Computes the signed disk information for a remote import.

  @type cds: string

  @param host: Hostname

  @type port: number

  @param port: Daemon port

  """

  hmac_digest = utils.Sha1Hmac(cds, msg, salt=salt)

  def test(self):

    cds = "bbf46ea9a"

    salt = "ee5ad9"

    self.assertEqual(CheckRemoteExportDiskInfo(cds, 0, di),

    for i in range(1, 100):

      # Wrong disk index

    salt = "drK5oYiHWD"

    for host in [",", "...", "Hello World", "`", "!", "#", "\\"]:

      self.assertRaises(errors.OpPrereqError,

                        CheckRemoteExportDiskInfo, cds, 0, di)

    for port in [-1, 792825908, "HelloWorld!", "`#", "\\\"", "_?_"]:

      self.assertRaises(errors.OpPrereqError,

                        CheckRemoteExportDiskInfo, cds, 0, di)

    # No host/port

    self.assertRaises(errors.GenericError, CheckRemoteExportDiskInfo,

    # Wrong hash

    self.assertRaises(errors.GenericError, CheckRemoteExportDiskInfo,

class TestFormatProgress(unittest.TestCase):