Synnefo » snf-ganeti » ganeti-local

    """Starts an import daemon.

    """

                                           None, None,

                                           objects.Instance.FromDict(instance),

                                           dest,

                                           _DecodeImportExportIO(dest,

                                                                 dest_args))

  @staticmethod

  def perspective_export_start(params):

    """Starts an export daemon.

    """

                                           host, port,

                                           objects.Instance.FromDict(instance),

                                           source,

                                  (prefix, utils.TimestampForFilename())))

  """Starts an import or export daemon.

  @param mode: Import/output mode

  @type host: string

  @param host: Remote host for export (None for import)

  @type port: int

  else:

    _Fail("Invalid mode %r", mode)

    _Fail("Cluster certificate can only be used for both key and CA")

  (cmd_env, cmd_prefix, cmd_suffix) = \

    _GetImportExportIoCommand(instance, mode, ieio, ieioargs)

    # Use server.pem

    key_path = constants.NODED_CERT_FILE

    cert_path = constants.NODED_CERT_FILE

  else:

    (_, key_path, cert_path) = _GetX509Filenames(constants.CRYPTO_KEYS_DIR,

  for i in [key_path, cert_path]:

    if not os.path.exists(i):

    pid_file = utils.PathJoin(status_dir, _IES_PID_FILE)

    ca_file = utils.PathJoin(status_dir, _IES_CA_FILE)

      # Use server.pem

      ca = utils.ReadFile(constants.NODED_CERT_FILE)

    utils.WriteFile(ca_file, data=ca, mode=0400)

    cmd = [

          timeouts = masterd.instance.ImportExportTimeouts(connect_timeout)

          (key_name, _, _) = self.x509_key_name

                                                     timeouts)

      finally:

        helper.Cleanup()

class _DiskImportExportBase(object):

  MODE_TEXT = None

               instance, timeouts, cbs, private=None):

    """Initializes this class.

    @param lu: Logical unit instance

    @type node_name: string

    @param node_name: Node name for import

    @type instance: L{objects.Instance}

    @param instance: Instance object

    @type timeouts: L{ImportExportTimeouts}

    self._lu = lu

    self.node_name = node_name

    self._instance = instance

    self._timeouts = timeouts

    self._cbs = cbs

class DiskImport(_DiskImportExportBase):

  MODE_TEXT = "import"

               dest, dest_args, timeouts, cbs, private=None):

    """Initializes this class.

    @param lu: Logical unit instance

    @type node_name: string

    @param node_name: Node name for import

    @type instance: L{objects.Instance}

    @param instance: Instance object

    @param dest: I/O destination

    @param private: Private data for callback functions

    """

                                   instance, timeouts, cbs, private)

    self._dest = dest

    self._dest_args = dest_args

    """Starts the import daemon.

    """

                                          self._dest, self._dest_args)

  def CheckListening(self):

class DiskExport(_DiskImportExportBase):

  MODE_TEXT = "export"

               dest_host, dest_port, instance, source, source_args,

               timeouts, cbs, private=None):

    """Initializes this class.

    @param lu: Logical unit instance

    @type node_name: string

    @param node_name: Node name for import

    @type dest_host: string

    @param dest_host: Destination host name or IP address

    @type dest_port: number

    @param private: Private data for callback functions

    """

                                   instance, timeouts, cbs, private)

    self._dest_host = dest_host

    self._dest_port = dest_port

    """Starts the export daemon.

    """

                                          self._dest_host, self._dest_port,

                                          self._instance, self._source,

                                          self._source_args)

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

    # Start export on source node

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

    ie.loop.Add(de)

           each transfer

  """

  timeouts = ImportExportTimeouts(constants.DISK_TRANSFER_CONNECT_TIMEOUT)

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

                                  src_node, None, dest_node, dest_ip)

        dtp = _DiskTransferPrivate(transfer, True)

                        transfer.dest_io, transfer.dest_ioargs,

                        timeouts, dest_cbs, private=dtp)

        ieloop.Add(di)

    return (fin_resu, dresults)

    """Inter-cluster instance export.

    @type disk_info: list

    @param disk_info: Per-disk destination information

    @type timeouts: L{ImportExportTimeouts}

    cbs = _RemoteExportCb(self._feedback_fn, len(instance.disks))

    ieloop = ImportExportLoop(self._lu)

    try:

      for idx, (dev, (host, port, _, _)) in enumerate(zip(instance.disks,

        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,

                              constants.IEIO_SCRIPT, (dev, idx),

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

    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):

                              constants.IEIO_SCRIPT, (dev, idx),

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

    ] + _TIMESTAMPS

class ConfdRequest(ConfigObject):

  """Object holding a confd request.

    """

    return self._SingleNodeCall(node, "x509_cert_remove", [name])

    """Starts a listener for an import.

    This is a single-node call.

    """

    return self._SingleNodeCall(node, "import_start",

                                 self._InstDict(instance), dest,

                                 _EncodeImportExportIO(dest, dest_args)])

                        instance, source, source_args):

    """Starts an export daemon.

    """

    return self._SingleNodeCall(node, "export_start",

                                 self._InstDict(instance), source,

                                 _EncodeImportExportIO(source, source_args)])