#!/usr/bin/python3

  import os

  import fmf

  import shlex

  import signal

  import socket

  import tempfile

  import functools

  IDENTITY = """

  Df9PUWMYZ3HRwwdsYovSOkT53fG6guy+vElUEDkrpZYczROZ6GUcx70=

  -----END RSA PRIVATE KEY-----

  """

  AUTH_KEY = ("AAAAB3NzaC1yc2EAAAADAQABAAABAQDUOtNJdBEXyKxBB898rdT54ULjMGuO6v4jLX"

              "mRsdRhR5Id/lKNc9hsdioPWUePgYlqML2iSV72vKQoVhkyYkpcsjr3zvBny9+5xej3"

              "+TBLoEMAm2hmllKPmxYJDU8jQJ7wJuRrOVOnk0iSNF+FcY/yaQ0owSF02Nphx47j2K"

              "Wc0IjGGlt4fl0fmHJuZBA2afN/4IYIIsEWZziDewVtaEjWV3InMRLllfdqGMllhFR+"

              "ed2hQz9PN2QcapmEvUR4UCy/mJXrke5htyFyHi8ECfyMMyYeHwbWLFQIve4CWix9qt"

              "ksvKjcetnxT+WWrutdr3c9cfIj/c0v/Zg/c4zETxtp")

  DEF_USER = "root"

  DEF_PASSWD = "foobar"

  DEF_HOST = "127.0.0.3"

  USER_DATA = """#cloud-config

  users:

    - default

      {0}:{1}

    expire: False

  """.format(DEF_USER, DEF_PASSWD, AUTH_KEY)

  EMPTY_INVENTORY = {}

  LOG_FILE = "default_provisioners.log"

      """

  def which(executable, default=None):

      return default

  def inv_list(subjects):

          if self.path != path or self.tree is None:

              FmfMetadataTree.path = path

              try:

              except Exception:

                  """Fmf initialization failed. Do not try initialize further for this path.

                  """

      return value

  def start_qemu(image, cloudinit, portrange=(2222, 5555)):

      for _ in range(10):

          port = random.randint(*portrange)

              sock.close()

      else:

          raise RuntimeError("unable to find free local port to map SSH to")

      # Log all traffic received from the guest to a file.

      log_file = "{0}.guest.log".format(os.path.basename(image))

      log_guest = get_artifact_path(log_file)

      param_net_nic_model = str(fmf_get(['qemu', 'net_nic', 'model'], 'virtio'))

      # Use -cpu host and -smp by default.

      # virtio-rng-pci: https://wiki.qemu.org/Features/VirtIORNG

      qemu_cmd = ["/usr/bin/qemu-system-x86_64",

                  "-cpu", "host", "-smp", get_qemu_smp_arg(),

                  "-m", param_m, image, "-enable-kvm", "-snapshot", "-cdrom", cloudinit,

                  "-device", "virtio-rng-pci", "-rtc", "base=utc",

                  "-device", "isa-serial,chardev=pts2", "-chardev", "file,id=pts2,path=" + log_guest,

                  "-display", "none"]

      qemu_cmd += AdditionalDrives.generate()

      if diagnose:

          qemu_cmd += ["-vnc", DEF_HOST + ":1,to=4095"]

      qemu_proc = subprocess.Popen(qemu_cmd, stdout=open(log_qemu, 'a'), stderr=subprocess.STDOUT)

      time.sleep(5)

      if qemu_proc and diagnose:

          logger.info("qemu-kvm is running with VNC server. PID: {}".format(qemu_proc.pid))

          logger.info("netstat -ltpn4 | grep {0} # to find VNC server port".format(qemu_proc.pid))

      return qemu_proc, port, log_guest

      if not image.endswith((".qcow2", ".qcow2c")):

          logger.info("Return empty inventory for image: %s.", image)

          return EMPTY_INVENTORY

      null = open(os.devnull, 'w')

      try:

          tty = os.open("/dev/tty", os.O_WRONLY)

          os.dup2(tty, 2)

      except OSError:

          tty = None

      # A directory for temporary stuff

      directory = tempfile.mkdtemp(prefix="inventory-cloud")

      identity = os.path.join(directory, "identity")

      userdata = os.path.join(directory, "user-data")

      with open(userdata, 'w') as f:

          f.write(USER_DATA)

      # Create our cloud init so we can log in

      cloudinit = os.path.join(directory, "cloud-init.iso")

      subprocess.check_call(["/usr/bin/genisoimage", "-input-charset", "utf-8",

                             "-volid", "cidata", "-joliet", "-rock", "-quiet",

                             "-output", cloudinit, userdata, metadata], stdout=null)

      logger.info("Launching virtual machine for {0}".format(image))

      # And launch the actual VM

      proc = None  # for failure detection

      cpe = None  # for exception scoping

      log = None

      if proc is None:

          raise RuntimeError("Could not launch VM for qcow2 image"

                             " '{0}':{1}".format(image, cpe.output))

      for _ in range(0, 30):

          try:

              # The variables

                  "ansible_ssh_private_key_file": identity,

                  "ansible_ssh_common_args": "-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no"

              }

              # Write out a handy inventory file, for our use and for debugging

              inventory = os.path.join(directory, "inventory")

              write_debug_inventory(inventory, {image: variables})

              # Wait for ssh to come up

              ping = [

                  ansible_bin,

          except OSError:

              output = ""

          raise RuntimeError("Could not access VM launched from qcow2 image: {0}{1}".format(image,  output))

      # Process of our parent

      ppid = os.getppid()

      child = os.fork()

      if child:

          # Need to figure out what python interpreter to use

          # Update inventory file

          write_debug_inventory(inventory, {image: variables})

          return variables

      # Daemonize and watch the processes

      os.chdir("/")

      os.setsid()

      os.umask(0)

      if tty is None:

          tty = null.fileno()

      # Duplicate standard input to standard output and standard error.

      os.dup2(null.fileno(), 0)

      os.dup2(tty, 1)

      os.dup2(tty, 2)

      # alternatively, lock on a file

      lock_file = os.environ.get("LOCK_ON_FILE", None)

      ssh_cmd = ("ssh -p {port} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -i {identity} {user}@{host}"

      logger.info("Wait until parent for provision-script (ansible-playbook) dies or qemu.")

      while True:

          time.sleep(3)

          if lock_file:

              if not os.path.exists(lock_file):

                  logger.error("Lock file is gone.")

      sys.exit(0)

  if __name__ == '__main__':

      ret = -1

      try:

          main(sys.argv)

          ret = 0

      except RuntimeError as ex:

          logger.error("{0}".format(ex))

      except Exception:

          # Backtrace stack goes to log file. If TEST_DEBUG == 1, it goes to stderr too.

          logger.error("Fatal error in provision script.", exc_info=True)

      sys.exit(ret)