Пример #1
0
def _get_client(project_id):

    user = settings.KEYSTONE_USER
    password = settings.KEYSTONE_PASSWORD

    auth_url = settings.OPENSTACK_KEYSTONE_URL

    keystone = ksclient.Client(
        auth_url=auth_url,
        username=user,
        password=password,
        tenant_name=project_id)

    token = keystone.auth_ref['token']['id']

    for catalog in keystone.auth_ref['serviceCatalog']:
        if catalog['name'] == 'glance':
            for endpoint in catalog['endpoints']:
                epoint = endpoint['publicURL']

    c = client.Client("1",
                      endpoint=epoint,
                      token=token)

    return c
Пример #2
0
def glance(context):
    if glanceclient is None:
        return None

    return glanceclient.Client('1',
                               service_type='image',
                               session=context.session)
def authenticate():
    """
    This function returns authenticated nova and glance objects
    """
    try:
        auth = v3.Password(
            username=os.environ['OS_USERNAME'],
            password=os.environ['OS_PASSWORD'],
            auth_url=os.environ['OS_AUTH_URL'],
            project_name=os.environ['OS_TENANT_NAME'],
            user_domain_name='Default',
            project_domain_name='Default',
        )
    except Exception as e:
        print('Auth token failed. ' + str(e))
        sys.exit(2)

    try:
        sess = session.Session(auth=auth)
    except:
        print('session failed.')
        sys.exit(3)

    try:
        glance = glance_client.Client('2', session=sess)
    except:
        print('glance failed')
        sys.exit(4)
    return glance
    def test_do_details(self):
        class Image():
            id = 'test'
            filters = {}
            limit = 18
            marker = False
            sort_key = 'test'
            kwarg = 'name'
            sort_dir = 'test'
            name = 'test'
            disk_format = 'ovi'
            container_format = 'ovi'
            size = 1024
            is_public = True
            protected = False
            status = 'active'
            min_ram = 512
            min_disk = 512
            properties = {}
            created_at = '12.12.12'

        args = Image()
        gc = client.Client('1', 'http://is.invalid')
        with mock.patch.object(gc.images, 'list') as mocked_list:
            mocked_list.return_value = [Image(), Image()]
            actual = test_shell.do_details(gc, args)
Пример #5
0
 def setUpClass(cls):
     super(ImageTestCase, cls).setUpClass()
     glance_endpoint = cls.service_catalog.url_for(service_type='image')
     cls.glance = gclient.Client('1', endpoint=glance_endpoint,
                                 session=cls.keystone_client.session)
     cls.image_title = 'New Image ' + str(time.time())
     cls.image = cls.upload_image(cls.image_title)
Пример #6
0
    def __init__(self,
                 ks_session,
                 network_ks_session=None,
                 nova_api=None,
                 nova_version=NOVA_VERSION,
                 neutron_api=None,
                 glance_api=None,
                 glance_version=GLANCE_VERSION):

        # This is the keystone session that we use for spawning instances,
        # aka our "service tenant" user.
        self._ks_session = ks_session

        # And this is the keystone session that we use for finding the network
        # that we are going to plumb into, aka the "end user".
        if network_ks_session is not None:
            self._network_ks_session = network_ks_session
        else:
            self._network_ks_session = ks_session

        # Yes, we really want both of these to use the "service tenant".
        self._nova_api = nova_api or nova_client.Client(
            nova_version, session=self._ks_session)
        self._neutron_api = neutron_api or neutron_client.Client(
            NEUTRON_VERSION, session=self._ks_session)
        self._glance_api = glance_api or glance_client.Client(
            glance_version, session=self._ks_session)
    def test_do_update_dry_run_false(self):
        class Image():
            fields = ['id=test_updated',
                      'status=active',
                      'is_public=True',
                      'name=new_name',
                      'protected=False',
                      'is_public=True']
            dry_run = False
            id = 'test'
            verbose = True
            is_public = True
            protected = False
            status = 'active'
            size = 1024
            min_ram = 512
            min_disk = 512
            properties = {'property': 'test'}
            created_at = '12.09.2013'

        args = Image()
        gc = client.Client('1', 'http://is.invalid')
        with mock.patch.object(gc.images, 'update') as mocked_update:
            mocked_update.return_value = Image()
            actual = test_shell.do_update(gc, args)
            self.assertEqual(0, actual)
Пример #8
0
    def __init__(self, testcase, template_file, distribution, arch, jeos_type,
            stack_paramstr, stackname=DEFAULT_STACKNAME):

        self.testcase = testcase
        self.stackname = stackname
        self.template_file = template_file
        self.distribution = distribution
        self.stack_paramstr = stack_paramstr

        self.stack_id_re = re.compile("^arn:openstack:heat::[0-9a-z]{32}:" +
                                      "stacks/" + self.stackname + "/[0-9]*$")

        self.creds = dict(username=os.environ['OS_USERNAME'],
                          password=os.environ['OS_PASSWORD'],
                          tenant=os.environ['OS_TENANT_NAME'],
                          auth_url=os.environ['OS_AUTH_URL'],
                          strategy=os.environ['OS_AUTH_STRATEGY'])
        self.dbusername = '******'

        self.testcase.assertEqual(os.environ['OS_AUTH_STRATEGY'],
                                  'keystone',
                                  'keystone authentication required')

        self.glanceclient = glance_client.Client(host="0.0.0.0", port=9292,
            use_ssl=False, auth_tok=None, creds=self.creds)

        self.prepare_jeos(distribution, arch, jeos_type)

        self.novaclient = nova_client.Client(self.creds['username'],
            self.creds['password'], self.creds['tenant'],
            self.creds['auth_url'], service_type='compute')

        self.heatclient = self._create_heat_client()
Пример #9
0
def gen_os_clients(self):
    try:
        output = {}
        # Grab handles to each client type
        keystone = kclient.Client(session=self.os['sess'])
        output['keystone'] = {}
        output['keystone']['client'] = keystone

        glance = gclient.Client(2, session=self.os['sess'])
        output['glance'] = {}
        output['glance']['client'] = glance

        nova = nclient.Client(2, session=self.os['sess'])
        output['nova'] = {}
        output['nova']['client'] = nova

        neutron = neuclient.Client(2, session=self.os['sess'])
        output['neutron'] = {}
        output['neutron']['client'] = neutron

        return 1, output

    except:
        logging.error("return_keystone_sess: Issue getting Openstack \
                       session object")
        return 0, {}
Пример #10
0
def volume_from_image(image_id, creds, glance_url, volume_size=None):
    k = keystone_client.Client(username=creds['username'],
                               password=creds['password'],
                               tenant_name=creds['tenant'],
                               auth_url=creds['auth_url'])
    if not k.authenticate():
        raise Exception("Could not authenticate into keystone")

    glance = glance_client.Client("1", endpoint=glance_url, token=k.auth_token)
    cinder = cinder_client.Client('1', creds['username'], creds['password'],
                                  creds['tenant'], creds['auth_url'])
    try:
        image = glance.images.get(image_id)
    except:
        raise Exception("Could not find Glance image with id" % (image_id))

    # Unclear if this is strictly needed
    # If size is not explicitly set then set it based on the image size
    # TODO: Check if we even have to set a size when pulling from an image
    if not volume_size:
        # Gigabytes rounded up
        volume_size = int(image.size / (1024 * 1024 * 1024) + 1)

    print "Starting asyncronous copying to Cinder"
    volume = cinder.volumes.create(volume_size,
                                   display_name=image.name,
                                   imageRef=image.id)
    while (volume.status != 'available'):
        print "Waiting for volume to be ready ... current status (%s)" % (
            volume.status)
        sleep(5)
        volume = cinder.volumes.get(volume.id)
        if (volume.status == 'error'):
            raise Exception('Error converting image to volume')
    return volume
Пример #11
0
    def run(self, args):
        # Here is the core of the plugin.
        # After doing your verifications, escape by doing:
        # self.exit(return_code, 'return_message', *performance_data)
        perfdata = []

        try:
            # Get a keystone token
            keystone = keystone_client.Client(
                username=args['username'],
                tenant_name=args['tenant'],
                password=args['password'],
                auth_url=args['auth_url'],
            )

            # Auth with glance
            start_time = datetime.datetime.now()
            client = glance_client.Client(
                auth_url=args['auth_url'],
                username=args['username'],
                tenant=args['tenant'],
                endpoint=args['endpoint'],
                host=args.get('host'),
                token=keystone.auth_token,
            )
            end_time = datetime.datetime.now()
            perfdata.append(
                PerfData('auth_time',
                         ((end_time - start_time).total_seconds() / 1000),
                         min_='0',
                         unit='ms'))
        except Exception as e:
            self.exit(STATES.UNKNOWN, str(e))

        # Get the images
        images = [image for image in client.images.list()]

        # Get the image count
        image_count = len(images)
        perfdata.append(
            PerfData('image_count', image_count, min_=(args.get('req_count'))))

        # Check the count of images
        if args.get('req_count') and image_count < args.get('req_count'):
            self.exit(
                STATES.CRITICAL, 'Not enough images (%s < %s)' %
                (image_count, args.get('req_count')), *perfdata)

        # Check the required images
        missing_images = []
        if args.get('req_images'):
            for image in args.get('req_images'):
                if image not in images:
                    missing_images.append(image)
            if len(missing_images) > 0:
                self.exit(STATES.CRITICAL,
                          'Images: %s are missing' % ' '.join(missing_images),
                          *perfdata)

        self.exit(STATES.OK, 'OK - %s images found' % image_count, *perfdata)
Пример #12
0
def glance_upload(
        image_filename=None,
        image_url=None,
        creds={
            'auth_url': None,
            'password': None,
            'strategy': 'noauth',
            'tenant': None,
            'username': None
        },
        glance_url=None,
        token=None,
        name='Factory Test Image',
        disk_format='raw'):

    k = keystone_client.Client(username=creds['username'],
                               password=creds['password'],
                               tenant_name=creds['tenant'],
                               auth_url=creds['auth_url'])

    if (k.authenticate()):
        #Connect to glance to upload the image
        glance = glance_client.Client("1",
                                      endpoint=glance_url,
                                      token=k.auth_token)
        image_meta = {
            'container_format': 'bare',
            'disk_format': disk_format,
            'is_public': True,
            'min_disk': 0,
            'min_ram': 0,
            'name': name,
            'properties': {
                'distro': 'rhel'
            }
        }
        try:
            image = glance.images.create(name=name)
            if image_filename:
                image_data = open(image_filename, "r")
                image_meta['data'] = image_data
                print "Uploading to Glance"
                image.update(**image_meta)
            elif image_url:
                image_meta['copy_from'] = image_url
                image.update(**image_meta)
                print "Waiting for Glance to finish creating image from URL: %s" % (
                    image_url)
                while (image.status != 'active'):
                    if image.status == 'killed':
                        raise Exception(
                            "Glance error while waiting for image to generate from URL"
                        )
                    print '.',
                    sys.stdout.flush()
                    sleep(10)
                    image = glance.images.get(image.id)
            return image
        except Exception, e:
            raise
Пример #13
0
 def mock_glance(self):
     glance_patcher = mock.patch('glanceclient.client.Client')
     with mock.patch('glanceclient.v2.schemas.Controller'):
         glance = mock.create_autospec(glanceclient.Client(endpoint='v2'))
         glance_patcher.start().return_value = glance
     self.addCleanup(glance_patcher.stop)
     return glance
Пример #14
0
def create_client(keystone_client, os_region_name, cacert):
    image_api_url = keystone_client.service_catalog.url_for(
        service_type='image', region_name=os_region_name)
    return glance_client_pkg.Client(GLANCE_VERSION,
                                    endpoint=image_api_url,
                                    token=keystone_client.auth_token,
                                    cacert=cacert)
Пример #15
0
def server_create():
    if not request.json:
        abort(400)
    test_id = request.args.get('test_id')
    db = Session()
    sess = _create_session(int(test_id))
    nova = nova_cli.Client(session=sess, version='2.1')
    glance = glance_cli.Client('2', session=sess)
    neutron = neutron_cli.Client(session=sess)
    flavor = nova.flavors.find(name=request.json['flavor'])
    image = list(
        glance.images.list(filters={"name": request.json['image']}))[0]
    network = neutron.find_resource('network', request.json['network'])
    server = nova.servers.create(name=request.json['name'],
                                 flavor=flavor.id,
                                 image=image.id,
                                 network=network['id'])
    if server:
        server_dao = _server_dao_create(
            db,
            server,
            test_id,
            image=_image_dao_create(db, image, test_id, True),
            flavor=_flavor_dao_create(db, flavor, test_id, True),
            network=_network_dao_create(db, network, test_id, True))
        _create_test_log(db, test_id, 'Server CREATE %s' % repr(server_dao))
        db.commit()
        return jsonify(_os_server_to_json(server)), 201
    else:
        abort(401)
Пример #16
0
def list(host=None,
         last_changed=None,
         availability_zone=None,
         column=None,
         aggregate=None,
         status=None,
         sort_by=None,
         project=None,
         allocation_home=None,
         exclude_availability_zone=None,
         exclude_host=None,
         exclude_aggregate=None):
    """List all nova instances with given parameters."""
    session = get_session()
    nova = nova_client.Client(2, session=session)
    glance = glance_client.Client(2, session=session)
    keystone = keystone_client.Client(session=session)
    allocation = allocation_client.Client(1, session=session)
    instances = _list_instances(nova, glance, keystone, allocation, aggregate,
                                availability_zone, host, status, project,
                                allocation_home, exclude_availability_zone,
                                exclude_host, exclude_aggregate)
    # INSTAN = instances
    # embed()
    if not column:
        sort_by = 'OS-EXT-SRV-ATTR:host'
    _render_table_instances(instances, column, sort_by)
Пример #17
0
def server_rebuild():
    test_id = request.args.get('test_id')
    if not request.json:
        abort(401)
    server_name = request.json['server']
    image_name = request.json['image']
    sess = _create_session(int(test_id))
    nova = nova_cli.Client('2.1', session=sess)
    servers = nova.servers.list(search_opts={"name": server_name})
    glance = glance_cli.Client('2', session=sess)
    images = list(glance.images.list(filters={"name": image_name}))
    if servers and len(servers) and images and len(images):
        server = servers[0]
        image = images[0]
        db = Session()
        image_dao = _image_dao_create(db, image, test_id, True)
        server_dao = db.query(OSServer).filter(
            OSServer.uid == server.id).first()
        if not server_dao:
            abort(404)
        server_dao.image = image_dao
        server.rebuild(image)
        db.add(server_dao)
        db.commit()
        return jsonify(success=True)
    else:
        abort(401)
Пример #18
0
def stat(host=None,
         last_changed=None,
         availability_zone=None,
         aggregate=None,
         status=None,
         project=None,
         allocation_home=None,
         exclude_availability_zone=None,
         exclude_host=None,
         exclude_aggregate=None,
         detail=None):
    """Gather statistic of all nova instances with given parameters."""
    session = get_session()
    nova = nova_client.Client(2, session=session)
    glance = glance_client.Client(2, session=session)
    keystone = keystone_client.Client(session=session)
    allocation = allocation_client.Client(1, session=session)
    instances = _list_instances(nova, glance, keystone, allocation, aggregate,
                                availability_zone, host, status, project,
                                allocation_home, exclude_availability_zone,
                                exclude_host, exclude_aggregate)
    # Summary table
    table = PrettyTable(['Name', 'Value'])
    data = {'instances': 0, 'vcpus': 0, 'ram': 0}
    table.align = 'l'
    projects_counter = Counter()
    # Detail table
    dt = PrettyTable(['Project', 'Instances', 'vCPUs', 'RAM'])
    projects = defaultdict(lambda: defaultdict(int))
    dt.align = 'l'
    for ins in instances:
        project_name = ins._info['project'].name
        projects[project_name]['instances'] += 1
        data['instances'] += 1
        projects_counter[ins._info['project'].name] += 1
        if not ins._info['flavor']['vcpus']:
            continue
        data['vcpus'] += int(ins._info['flavor']['vcpus'])
        data['ram'] += int(ins._info['flavor']['ram'])
        projects[project_name]['vcpus'] += int(ins._info['flavor']['vcpus'])
        projects[project_name]['ram'] += int(ins._info['flavor']['ram'])

    data['common'] = ',\n'.join('%s: %d' % (k, v)
                                for k, v in projects_counter.most_common(3))
    # Convert the data to bytes for humanization
    data['ram'] = data['ram'] * 1024 * 1024
    table.add_row(['Total instances', data['instances']])
    table.add_row(['vCPUs used', data['vcpus']])
    table.add_row(['RAM used', humanize.naturalsize(data['ram'], binary=True)])
    table.add_row(['Total projects affected', len(projects_counter.keys())])
    table.add_row(['Top projects affected', data['common']])
    click.echo(table)

    if detail:
        for name, p in projects.items():
            dt.add_row([
                name, p['instances'], p['vcpus'],
                humanize.naturalsize(p['ram'] * 1024 * 1024, binary=True)
            ])
        click.echo(dt)
    def test_do_add_without_dry_run(self):
        gc = client.Client('1', 'http://is.invalid')

        class FakeImage():
            fields = ['name=test',
                      'status=active',
                      'is_public=True',
                      'id=test',
                      'protected=False',
                      'min_disk=10',
                      'container_format=ovi',
                      'status=active',
                      'size=256',
                      'location=test',
                      'checksum=1024',
                      'owner=test_user']
            dry_run = False
            id = 'test'
            verbose = False

        test_args = FakeImage()
        with mock.patch.object(gc.images, 'create') as mocked_create:
            mocked_create.return_value = FakeImage()
            actual = test_shell.do_add(gc, test_args)
            self.assertEqual(0, actual)
Пример #20
0
Файл: auth.py Проект: CCI-MOC/ui
def loginTenant(request, tenant_name):
    """
	Create keystone, nova, and glance clients for tenant; on tenant selection
	"""

    username = request.session['username']
    password = request.session['password']
    auth_url = 'https://engage1.massopencloud.org:5000/v3/'

    print 'lucas-test-auth-loginTenant'

    unscoped_auth = v3.Password(auth_url=auth_url,
                                username=username,
                                password=password,
                                user_domain_name="Default",
                                unscoped=True)
    unscoped_sess = session.Session(auth=unscoped_auth)
    unscoped_token = unscoped_sess.get_token()
    auth = v3.Token(auth_url=auth_url, token=unscoped_token)
    sess = session.Session(auth=auth)
    #scoped_token=sess.get_token()
    keystone = ksclient.Client(session=sess)
    # keystone = ksclient.Client(auth_url = 'https://engage1.massopencloud.org:5000/v2.0/', username = username,
    # 	password = password, tenant_name = tenant_name)
    print 'lucas-test-auth-loginTenant-succesfully'
    # nova = nvclient.Client('2', auth_url = 'https://engage1.massopencloud.org:5000/v2.0/',
    # 	username = username,
    # 	api_key = password,
    # 	project_id = tenant_name)
    nova = nvclient.Client('2', session=sess)
    glance = glclient.Client('2', session=sess)
    return {'keystone': keystone, 'nova': nova, 'glance': glance}
    def test_show(self):
        class Image():
            fields = ['id=test_updated',
                      'status=active',
                      'is_public=True',
                      'name=new_name',
                      'protected=False']
            id = 'test_show'
            name = 'fake_image'
            is_public = False
            protected = False
            status = 'active'
            size = '1024'
            min_ram = 512
            min_disk = 10
            properties = {'a': 'b', 'c': 'd'}
            created_at = '04.03.2013'
            owner = 'test'
            updated_at = '04.03.2013'

        gc = client.Client('1', 'http://is.invalid')
        with mock.patch.object(gc.images, 'get') as mocked_get:
            mocked_get.return_value = Image()
            actual = test_shell.do_show(gc, Image())
            self.assertEqual(0, actual)
def connect(config):
    # The Glance client is not able to query Keystone
    # for the endpoint, neither authenticate itself
    ksclient = keystone.Client(username=config['username'],
                               tenant_name=config['tenant'],
                               password=config['password'],
                               auth_url=config['auth_url'])

    endpoint = ksclient.service_catalog.url_for(
                   service_type='image',
                   endpoint_type=config['endpoint_type']
               )

    # Strip version from the last component of endpoint if present
    # Get rid of trailing '/' if present
    if endpoint.endswith('/'):
        endpoint = endpoint[:-1]
    url_bits = endpoint.split('/')
    # regex to match 'v1' or 'v2.0' etc
    if re.match('v\d+\.?\d*', url_bits[-1]):
        endpoint = '/'.join(url_bits[:-1])

    client = glance.Client('2',
                           endpoint=endpoint,
                           token=ksclient.auth_token)

    config['util'] = OpenstackUtils(client)
Пример #23
0
    def wrapper(self, *args, **kwargs):
        """Wrapper around methods calls.

        :param image_href: href that describes the location of an image
        """

        if self.client:
            return func(self, *args, **kwargs)

        image_href = kwargs.get('image_href')
        (image_id, self.glance_host,
         self.glance_port, use_ssl) = service_utils.parse_image_ref(image_href)

        if use_ssl:
            scheme = 'https'
        else:
            scheme = 'http'
        params = {}
        params['insecure'] = CONF.glance.glance_api_insecure
        if CONF.glance.auth_strategy == 'keystone':
            params['token'] = self.context.auth_token
        endpoint = '%s://%s:%s' % (scheme, self.glance_host, self.glance_port)
        self.client = client.Client(self.version,
                                    endpoint, **params)
        return func(self, *args, **kwargs)
Пример #24
0
    def get_glance_client(cls, region, service_name=None, endpoint=None,
                          endpoint_type='publicURL', insecure=False,
                          cacert=None):
        """Create glance client object.

        :param region: The region of the service
        :param service_name: The name of the glance service in the catalog
        :param endpoint: The endpoint of the service
        :param endpoint_type: The endpoint_type of the service
        :param insecure: Turn off certificate validation
        :param cacert: CA Cert file path
        :return: a Glance Client object.
        :raises Exception: if the client cannot be created
        """
        ksession = keystone.KeystoneSession()
        if not cls.glance_client:
            kwargs = {'region_name': region,
                      'session': ksession.get_session(),
                      'interface': endpoint_type}
            if service_name:
                kwargs['service_name'] = service_name
            if endpoint:
                kwargs['endpoint'] = endpoint
                if endpoint.startswith("https"):
                    kwargs['insecure'] = insecure
                    kwargs['cacert'] = cacert
            try:
                cls.glance_client = glance_client.Client(
                    GLANCE_VERSION, **kwargs)
            except Exception:
                with excutils.save_and_reraise_exception():
                    LOG.exception("Error creating Glance client.")
        return cls.glance_client
Пример #25
0
    def connect(self, config):
        ksclient = keystone.Client(username=config['username'],
                                   tenant_name=config['tenant'],
                                   password=config['password'],
                                   auth_url=config['auth_url'])

        compute_endpoint = ksclient.service_catalog.url_for(
                               service_type='compute',
                               endpoint_type=config['endpoint_type']
                           )

        image_endpoint = ksclient.service_catalog.url_for(
                             service_type='image',
                             endpoint_type=config['endpoint_type']
                         )

        nova_client = nova.Client('1.1',
                                  username=config['username'],
                                  auth_url=config['auth_url'],
                                  api_key='',
                                  project_id=config['tenant'],
                                  bypass_url=compute_endpoint,
                                  auth_token=ksclient.auth_token)

        glance_client = glance.Client('1',
                                      endpoint=image_endpoint,
                                      token=ksclient.auth_token)

        return nova_client, glance_client
Пример #26
0
 def glance(self, context, version=1):
     """Instantiate a new glanceclient.Client object."""
     params = {}
     params['token'] = context.auth_token
     params['identity_headers'] = self.generate_identity_headers(context)
     endpoint = CONF.glance_url
     return glance.Client(str(version), endpoint, **params)
Пример #27
0
    def wrapper(self, *args, **kwargs):
        """Wrapper around methods calls.

        :param image_href: href that describes the location of an image
        """

        if self.client:
            return func(self, *args, **kwargs)

        global _GLANCE_SESSION
        if not _GLANCE_SESSION:
            _GLANCE_SESSION = keystone.get_session('glance')

        # NOTE(pas-ha) glanceclient uses Adapter-based SessionClient,
        # so we can pass session and auth separately, makes things easier
        service_auth = keystone.get_auth('glance')

        self.endpoint = keystone.get_endpoint('glance',
                                              session=_GLANCE_SESSION,
                                              auth=service_auth)

        user_auth = None
        # NOTE(pas-ha) our ContextHook removes context.auth_token in noauth
        # case, so when ironic is in noauth but glance is not, we will not
        # enter the next if-block and use auth from [glance] config section
        if self.context.auth_token:
            user_auth = keystone.get_service_auth(self.context, self.endpoint,
                                                  service_auth)
        self.client = client.Client(2,
                                    session=_GLANCE_SESSION,
                                    auth=user_auth or service_auth,
                                    endpoint_override=self.endpoint,
                                    global_request_id=self.context.global_id)
        return func(self, *args, **kwargs)
Пример #28
0
    def setUp(self):
        super(ApiTestCase, self).setUp()

        neutron_patcher = mock.patch('neutronclient.v2_0.client.Client',
                                     autospec=True)
        self.neutron = neutron_patcher.start().return_value
        self.addCleanup(neutron_patcher.stop)

        nova_patcher = mock.patch('novaclient.client.Client')
        self.nova = mock.create_autospec(self.NOVACLIENT_SPEC_OBJ)
        self.novaclient_getter = nova_patcher.start()
        self.novaclient_getter.return_value = self.nova
        self.addCleanup(nova_patcher.stop)

        glance_patcher = mock.patch('glanceclient.client.Client')
        self.glance = mock.create_autospec(glanceclient.Client(endpoint='/v1'))
        glance_patcher.start().return_value = self.glance
        self.addCleanup(glance_patcher.stop)

        cinder_patcher = mock.patch('cinderclient.client.Client')
        self.cinder = mock.create_autospec(cinderclient.Client('1'))
        cinder_patcher.start().return_value = self.cinder
        self.addCleanup(cinder_patcher.stop)

        db_api_patcher = mock.patch('ec2api.db.api.IMPL',
                                    autospec=ec2api.db.sqlalchemy.api)
        self.db_api = db_api_patcher.start()
        self.addCleanup(db_api_patcher.stop)

        isotime_patcher = mock.patch('oslo_utils.timeutils.isotime')
        self.isotime = isotime_patcher.start()
        self.addCleanup(isotime_patcher.stop)

        self._conf = self.useFixture(config_fixture.Config())
        self.configure(fatal_exception_format_errors=True)
Пример #29
0
    def do_setup(self, context):
        """Any initialization the destination driver does while starting."""
        super(OpenStackDestinationDriver, self).do_setup(context)
        auth_url = self.configuration.auth_url
        if auth_url is None:
            raise ValueError(_("Cannot authenticate without an auth_url"))
        username = self.configuration.username
        password = self.configuration.password
        tenant_name = self.configuration.tenant_name
        project_id = self.configuration.project_id
        user_domain_name = self.configuration.user_domain_name
        nova_api_version = self.configuration.nova_api_version
        cinder_api_version = self.configuration.cinder_api_version
        glance_api_version = self.configuration.glance_api_version
        keystone_version = self.configuration.keystone_version

        if keystone_version == 'v3':
            auth = v3.Password(auth_url=auth_url, username=username,
                               password=password, project_id=project_id,
                               user_domain_name=user_domain_name)
            sess = v3_session.Session(auth=auth)
        elif keystone_version == 'v2':
            auth = v2.Password(auth_url, username=username,
                               password=password, tenant_name=tenant_name)
            sess = v2_session.Session(auth=auth)

        self.nova = nova_client.Client(nova_api_version, session=sess)
        self.cinder = cinder_client.Client(cinder_api_version, session=sess)
        self.glance = glance_client.Client(glance_api_version, session=sess)
        self._initialized = True
Пример #30
0
 def glance(self):
     if "image" not in self._clients:
         con = self.context
         endpoint_type = self._get_client_option('glance', 'endpoint_type')
         endpoint = self.url_for(service_type='image',
                                 endpoint_type=endpoint_type,
                                 region_name=cfg.CONF.region_name)
         # Rackspace service catalog includes a tenant scoped glance
         # endpoint so we have to munge the url a bit
         glance_url = urlparse.urlparse(endpoint)
         # remove the tenant and following from the url
         endpoint = "%s://%s" % (glance_url.scheme, glance_url.hostname)
         args = {
             'auth_url': con.auth_url,
             'service_type': 'image',
             'project_id': con.tenant,
             'token': self.auth_token,
             'endpoint_type': endpoint_type,
             'ca_file': self._get_client_option('glance', 'ca_file'),
             'cert_file': self._get_client_option('glance', 'cert_file'),
             'key_file': self._get_client_option('glance', 'key_file'),
             'insecure': self._get_client_option('glance', 'insecure')
         }
         client = glanceclient.Client('2', endpoint, **args)
         self._clients["image"] = client
     return self._clients["image"]