Synnefo » snf-ganeti

    greeting = self._Recv()

    if not greeting[self._FIRST_MESSAGE_KEY]:

      self._connected = False

                                   " server greeting")

    # Let's put the monitor in command mode using the qmp_capabilities

    constants.HV_VNC_BIND_ADDRESS:

      (False, lambda x: (netutils.IP4Address.IsValid(x) or

                         utils.IsNormAbsPath(x)),

       " pathname", None, None),

    constants.HV_VNC_TLS: hv_base.NO_CHECK,

    constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK,

    constants.HV_KVM_SPICE_IP_VERSION:

      (False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or

                         x in constants.VALID_IP_VERSIONS),

       None, None),

    constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,

    constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:

    result = utils.RunCmd([pathutils.KVM_IFUP, tap], env=env)

    if result.failed:

                                   (tap, result.fail_reason, result.output))

  @staticmethod

          else:

            vnc_arg = "%s:%d" % (vnc_bind_address, display)

        else:

          vnc_arg = "none"

        # Only allow tls and other option when not binding to a file, for now.

        # have that kind of IP addresses, throw an exception

        if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:

          if not addresses[spice_ip_version]:

                                         " for %s" % (spice_ip_version,

                                                      spice_bind))

        elif addresses[constants.IP6_VERSION]:

          spice_ip_version = constants.IP6_VERSION

        else:

                                       " for %s" % (spice_bind))

        spice_address = addresses[spice_ip_version][0]

        # Enable the spice agent communication channel between the host and the

        # agent.

        kvm_cmd.extend(["-device", "virtio-serial-pci"])

        kvm_cmd.extend(["-chardev", "spicevmc,id=spicechannel0,name=vdagent"])

      logging.info("KVM: SPICE will listen on port %s", instance.network_port)

              utils.ShellQuote(self._InstanceMonitor(instance_name))))

    result = utils.RunCmd(socat)

    if result.failed:

      raise errors.HypervisorError(msg)

    return result

        # IP of that family

        if (netutils.IP4Address.IsValid(spice_bind) and

            spice_ip_version != constants.IP4_VERSION):

                                       " the specified IP version is %s" %

                                       (spice_bind, spice_ip_version))

        if (netutils.IP6Address.IsValid(spice_bind) and

            spice_ip_version != constants.IP6_VERSION):

                                       " the specified IP version is %s" %

                                       (spice_bind, spice_ip_version))

    else:

      # error if any of them is set without it.

      for param in _SPICE_ADDITIONAL_PARAMS:

        if hvparams[param]:

                                       (param, constants.HV_KVM_SPICE_BIND))

  @classmethod

    if spice_bind:

      # only one of VNC and SPICE can be used currently.

      if hvparams[constants.HV_VNC_BIND_ADDRESS]:

                                     " only one of them can be used at a"

      # check that KVM supports SPICE

      kvmhelp = cls._GetKVMOutput(kvm_path, cls._KVMOPT_HELP)

      if not cls._SPICE_RE.search(kvmhelp):

      # if spice_bind is not an IP address, it must be a valid interface

      if not bound_to_addr and not netutils.IsValidInterface(spice_bind):

                                     " a valid IP address or interface name" %

                                     constants.HV_KVM_SPICE_BIND)