def get_ip_neutron(instance_id):
     subnets = json.loads(misc.sh("neutron subnet-list -f json -c id -c ip_version"))
     subnet_id = None
     for subnet in subnets:
         if subnet['ip_version'] == 4:
             subnet_id = subnet['id']
             break
     if not subnet_id:
         raise Exception("no subnet with ip_version == 4")
     ports = json.loads(misc.sh("neutron port-list -f json -c fixed_ips -c device_id"))
     fixed_ips = None
     for port in ports:
         if port['device_id'] == instance_id:
             fixed_ips = port['fixed_ips'].split("\n")
             break
     if not fixed_ips:
         raise Exception("no fixed ip record found")
     ip = None
     for fixed_ip in fixed_ips:
         record = json.loads(fixed_ip)
         if record['subnet_id'] == subnet_id:
             ip = record['ip_address']
             break
     if not ip:
         raise Exception("no ip")
     return ip

def push_directory(path, remote, remote_dir):
    """
    local_temp_path=`mktemp`
    tar czf $local_temp_path $path
    ssh remote mkdir -p remote_dir
    remote_temp_path=`mktemp`
    scp $local_temp_path $remote_temp_path
    rm $local_temp_path
    tar xzf $remote_temp_path -C $remote_dir
    ssh remote:$remote_temp_path
    """
    fd, local_temp_path = tempfile.mkstemp(suffix='.tgz',
                                           prefix='rebuild_mondb-')
    os.close(fd)
    cmd = ' '.join(['tar', 'cz',
                    '-f', local_temp_path,
                    '-C', path,
                    '--', '.'])
    teuthology.sh(cmd)
    _, fname = os.path.split(local_temp_path)
    fd, remote_temp_path = tempfile.mkstemp(suffix='.tgz',
                                            prefix='rebuild_mondb-')
    os.close(fd)
    remote.put_file(local_temp_path, remote_temp_path)
    os.remove(local_temp_path)
    remote.run(args=['sudo',
                     'tar', 'xz',
                     '-C', remote_dir,
                     '-f', remote_temp_path])
    remote.run(args=['sudo', 'rm', '-fr', remote_temp_path])

    def create_security_group(self):
        """
        Create a security group that will be used by all teuthology
        created instances. This should not be necessary in most cases
        but some OpenStack providers enforce firewall restrictions even
        among instances created within the same tenant.
        """
        try:
            self.run("security group show teuthology")
            return
        except subprocess.CalledProcessError:
            pass
        # TODO(loic): this leaves the teuthology vm very exposed
        # it would be better to be very liberal for 192.168.0.0/16
        # and 172.16.0.0/12 and 10.0.0.0/8 and only allow 80/8081/22
        # for the rest.
        misc.sh(
            """
openstack security group create teuthology
openstack security group rule create --dst-port 1:65535 teuthology
openstack security group rule create --proto udp --dst-port 53 teuthology # dns
openstack security group rule create --proto udp --dst-port 111 teuthology # for nfs
openstack security group rule create --proto udp --dst-port 2049 teuthology # for nfs
openstack security group rule create --proto udp --dst-port 16000:65535 teuthology # for nfs
        """
        )

 def begin(self):
     misc.sh("""
     set -x
     pip install tox
     tox
     # tox -e py27-integration
     tox -e openstack-integration
     """)

 def image_create(self, name):
     """
     Upload an image into OpenStack with glance. The image has to be qcow2.
     """
     misc.sh("wget -c -O " + name + ".qcow2 " + self.image2url[name])
     misc.sh("glance image-create --property ownedby=teuthology " +
             " --disk-format=qcow2 --container-format=bare " +
             " --file " + name + ".qcow2 --name " + self.image_name(name))

    def test_floating_ip(self):
        if not self.can_create_floating_ips:
            pytest.skip('unable to create floating ips')

        expected = TeuthologyOpenStack.create_floating_ip()
        ip = TeuthologyOpenStack.get_unassociated_floating_ip()
        assert expected == ip
        ip_id = TeuthologyOpenStack.get_floating_ip_id(ip)
        misc.sh("openstack -q ip floating delete " + ip_id)

 def teardown(self):
     """
     Delete all instances run by the teuthology cluster and delete the
     instance running the teuthology cluster.
     """
     self.ssh("sudo /etc/init.d/teuthology stop || true")
     instance_id = self.get_instance_id(self.args.name)
     self.delete_floating_ip(instance_id)
     misc.sh("openstack server delete --wait " + self.args.name)

    def clobber(self):
        misc.sh(
            """
openstack server delete {name} --wait || true
openstack keypair delete {key_name} || true
        """.format(
                key_name=self.key_name, name=self.name
            )
        )

 def associate_floating_ip(name_or_id):
     """
     Associate a floating IP to the OpenStack instance
     or do nothing if no floating ip can be created.
     """
     ip = TeuthologyOpenStack.get_unassociated_floating_ip()
     if not ip:
         ip = TeuthologyOpenStack.create_floating_ip()
     if ip:
         misc.sh("openstack ip floating add " + ip + " " + name_or_id)

 def delete_floating_ip(instance_id):
     """
     Remove the floating ip from instance_id and delete it.
     """
     ip = TeuthologyOpenStack.get_floating_ip(instance_id)
     if not ip:
         return
     misc.sh("openstack ip floating remove " + ip + " " + instance_id)
     ip_id = TeuthologyOpenStack.get_floating_ip_id(ip)
     misc.sh("openstack ip floating delete " + ip_id)

 def verify_openstack(self):
     """
     Check there is a working connection to an OpenStack cluster
     and set the provider data member if it is among those we
     know already.
     """
     try:
         misc.sh("openstack server list")
     except subprocess.CalledProcessError:
         log.exception("openstack server list")
         raise Exception("verify openrc.sh has been sourced")
     self.set_provider()

 def create_floating_ip():
     pools = json.loads(misc.sh("openstack ip floating pool list -f json"))
     if not pools:
         return None
     pool = pools[0]['Name']
     try:
         ip = json.loads(misc.sh(
             "openstack ip floating create -f json '" + pool + "'"))
         return TeuthologyOpenStack.get_value(ip, 'ip')
     except subprocess.CalledProcessError:
         log.debug("create_floating_ip: not creating a floating ip")
         pass
     return None

    def setup_class(self):
        if 'OS_AUTH_URL' not in os.environ:
            pytest.skip('no OS_AUTH_URL environment variable')

        teuthology.log.setLevel(logging.DEBUG)
        set_config_attr(argparse.Namespace())

        ip = TeuthologyOpenStack.create_floating_ip()
        if ip:
            ip_id = TeuthologyOpenStack.get_floating_ip_id(ip)
            misc.sh("openstack -q ip floating delete " + ip_id)
            self.can_create_floating_ips = True
        else:
            self.can_create_floating_ips = False

    def setup(self):
        self.key_filename = tempfile.mktemp()
        self.key_name = 'teuthology-test'
        self.name = 'teuthology-test'
        self.clobber()
        misc.sh("""
openstack keypair create {key_name} > {key_filename}
chmod 600 {key_filename}
        """.format(key_filename=self.key_filename,
                   key_name=self.key_name))
        self.options = ['--key-name', self.key_name,
                        '--key-filename', self.key_filename,
                        '--name', self.name,
                        '--verbose']

    def flavor(self, hint, select):
        """
        Return the smallest flavor that satisfies the desired size.
        """
        flavors_string = misc.sh("openstack flavor list -f json")
        flavors = json.loads(flavors_string)
        found = []
        for flavor in flavors:
            if select and not re.match(select, flavor['Name']):
                continue
            if (flavor['RAM'] >= hint['ram'] and
                    flavor['VCPUs'] >= hint['cpus'] and
                    flavor['Disk'] >= hint['disk']):
                found.append(flavor)
        if not found:
            raise Exception("openstack flavor list: " + flavors_string +
                            " does not contain a flavor in which" +
                            " the desired " + str(hint) + " can fit")

        def sort_flavor(a, b):
            return (a['VCPUs'] - b['VCPUs'] or
                    a['RAM'] - b['RAM'] or
                    a['Disk'] - b['Disk'])
        sorted_flavor = sorted(found, cmp=sort_flavor)
        log.debug("sorted flavor = " + str(sorted_flavor))
        return sorted_flavor[0]['Name']

 def cache_token(self):
     if self.provider != 'ovh':
         return False
     if (OpenStack.token is None and
         os.environ.get('OS_AUTH_TYPE') == 'v2token' and
         'OS_TOKEN' in os.environ and
         'OS_TOKEN_EXPIRES' in os.environ):
         log.debug("get token from the environment of the parent process")
         OpenStack.token = os.environ['OS_TOKEN']
         OpenStack.token_expires = int(os.environ['OS_TOKEN_EXPIRES'])
     if (OpenStack.token_expires is not None and
         OpenStack.token_expires < time.time()):
         log.debug("token discarded because it has expired")
         OpenStack.token = None
     if OpenStack.token is None:
         if os.environ.get('OS_AUTH_TYPE') == 'v2token':
             del os.environ['OS_AUTH_TYPE']
         OpenStack.token = misc.sh("openstack -q token issue -c id -f value").strip()
         os.environ['OS_AUTH_TYPE'] = 'v2token'
         os.environ['OS_TOKEN'] = OpenStack.token
         OpenStack.token_expires = int(time.time() + OpenStack.token_cache_duration)
         os.environ['OS_TOKEN_EXPIRES'] = str(OpenStack.token_expires)
         log.info("caching OS_TOKEN and setting OS_AUTH_TYPE=v2token "
                  "during %s seconds" % OpenStack.token_cache_duration)
     return True

 def net_id(self, network):
     """
     Return the uuid of the network in OpenStack.
     """
     r = json.loads(misc.sh("openstack network show -f json " +
                            network))
     return self.get_value(r, 'id')

 def set_info(self):
     try:
         self.info = json.loads(
             misc.sh("openstack server show -f json " + self.name_or_id))
         enforce_json_dictionary(self.info)
     except CalledProcessError:
         self.info = None

 def image_exists(self, image):
     """
     Return true if the image exists in OpenStack.
     """
     found = misc.sh("openstack image list -f json --property name='" +
                     self.image_name(image) + "'")
     return len(json.loads(found)) > 0

 def create_cluster(self):
     """
     Create an OpenStack instance that runs the teuthology cluster
     and wait for it to come up.
     """
     user_data = self.get_user_data()
     if self.provider == 'rackspace':
         security_group = ''
     else:
         security_group = " --security-group teuthology"
     instance = misc.sh(
         "openstack server create " +
         " --image '" + self.image('ubuntu', '14.04') + "' " +
         " --flavor '" + self.flavor() + "' " +
         " " + self.net() +
         " --key-name " + self.args.key_name +
         " --user-data " + user_data +
         security_group +
         " --wait " + self.args.name +
         " -f json")
     instance_id = self.get_value(json.loads(instance), 'id')
     os.unlink(user_data)
     self.associate_floating_ip(instance_id)
     ip = self.get_floating_ip_or_ip(instance_id)
     return self.cloud_init_wait(ip)