Synnefo » snf-ganeti » ganeti-local

      self._old_instance_name = export_info.get(constants.INISECT_INS, "name")

    else:

      self._old_instance_name = None

      if self.op.instance_name == self._old_instance_name:

      else:

        if self.op.mode == constants.INSTANCE_IMPORT:

          feedback_fn("* running the instance OS import scripts...")

          transfers = []

          for idx, image in enumerate(self.src_images):

            if not image:

              continue

            # FIXME: pass debug option from opcode to backend

            dt = masterd.instance.DiskTransfer("disk/%s" % idx,

                                               constants.IEIO_FILE, (image, ),

                                               constants.IEIO_SCRIPT,

                                               (iobj.disks[idx], idx),

                                               None)

            transfers.append(dt)

          import_result = \

            masterd.instance.TransferInstanceData(self, feedback_fn,

                                                  self.op.src_node, pnode_name,

                                                  self.pnode.secondary_ip,

                                                  iobj, transfers)

          if not compat.all(import_result):

            self.LogWarning("Some disks for instance %s on node %s were not"

                            " imported successfully" % (instance, pnode_name))

          rename_from = self._old_instance_name

        elif self.op.mode == constants.INSTANCE_REMOTE_IMPORT:

          feedback_fn("* preparing remote import...")

          # The source cluster will stop the instance before attempting to make

          # a connection. In some cases stopping an instance can take a long

          # time, hence the shutdown timeout is added to the connection

          # timeout.

          connect_timeout = (constants.RIE_CONNECT_TIMEOUT +

                             self.op.source_shutdown_timeout)

          timeouts = masterd.instance.ImportExportTimeouts(connect_timeout)

          assert iobj.primary_node == self.pnode.name

          disk_results = \

            masterd.instance.RemoteImport(self, feedback_fn, iobj, self.pnode,

                                          self.source_x509_ca,

                                          self._cds, timeouts)

          if not compat.all(disk_results):

            # TODO: Should the instance still be started, even if some disks

            # failed to import (valid for local imports, too)?

            self.LogWarning("Some disks for instance %s on node %s were not"

                            " imported successfully" % (instance, pnode_name))

          rename_from = self.source_instance_name

        else:

          # also checked in the prereq part

          raise errors.ProgrammerError("Unknown OS initialization mode '%s'"

                                       % self.op.mode)

                                                   rename_from,