def bootVM(image, flavor, keyname, hostname, desc, min_count=1, max_count=1): nova = nvclient.Client(username=os.environ['OS_USERNAME'], project_id=os.environ['OS_TENANT_NAME'], api_key=os.environ['OS_PASSWORD'], auth_url=os.environ['OS_AUTH_URL'], insecure=True) image = nova.images.find(id=image) flavor = nova.flavors.find(name=flavor) # réseau privé sur Cloud OMC / IMA net_id="67a3e2c9-424a-463a-8a73-cccde3de4443" nics = [{"net-id": net_id, "v4-fixed-ip": ''}] instance = nova.servers.create(name=hostname, image=image, flavor=flavor, meta=desc, min_count=min_count, max_count=max_count, nics=nics, key_name=keyname) return instance
def test_auth_system_defining_url(self, mock_iter_entry_points): """Test the auth_system defining an url.""" class MockEntrypoint(pkg_resources.EntryPoint): def load(self): return FakePlugin class FakePlugin(auth_plugin.BaseAuthPlugin): def get_auth_url(self): return "http://faked/v2.0" mock_iter_entry_points.side_effect = lambda _t: [ MockEntrypoint("fake", "fake", ["FakePlugin"]) ] auth_plugin.discover_auth_systems() plugin = auth_plugin.load_plugin("fake") cs = client.Client("username", "password", "project_id", auth_system="fakewithauthurl", auth_plugin=plugin) self.assertEquals(cs.client.auth_url, "http://faked/v2.0")
def createKeypair(self, keypair_name, cloud): user, password, tenant, url = self.authenCloud(configfile,cloud) nova_client = client.Client(user, password, tenant, url) if not os.path.exists("./ssh"): os.makedirs("./ssh") private_key_filename = "./ssh/id_TUD" public_key_filename = "./ssh/id_TUD.pub" home = expanduser("~") keypair = nova_client.keypairs.create(name=keypair_name) # Create a file for writing that can only be read and written by owner fprivate = os.open(private_key_filename, os.O_WRONLY | os.O_CREAT, 0o600) fpublic = os.open(public_key_filename, os.O_WRONLY | os.O_CREAT, 0o600) with os.fdopen(fprivate, 'w') as f: f.write(keypair.private_key) with os.fdopen(fpublic, 'w') as f: f.write(keypair.public_key) dst = home + "/.ssh/" shutil.copy(private_key_filename, dst) shutil.copy(public_key_filename, dst) private_key = home + "/.ssh/id_TUD" call(["ssh-add", private_key])
def delete_handle(message): novaDao = DRNovaDao() logger = logging.getLogger("NovaHandler") url = message['Request']['url'].split('/') server_id = url[len(url) - 1] cf = ConfigParser.ConfigParser() cf.read("/home/eshufan/projects/drcontroller/drcontroller/conf/set.conf") try: drc_id = novaDao.get_by_primary_instance_uuid( server_id).secondary_instance_uuid except: return logger.info('Delete shadow VM ' + drc_id + ' for ' + server_id + ' in dr site') if (drc_id != None): drc_ncred = {} drc_ncred['auth_url'] = cf.get("drc", "auth_url") drc_ncred['username'] = cf.get("drc", "user") drc_ncred['api_key'] = cf.get("drc", "password") drc_ncred['project_id'] = cf.get("drc", "tenant_name") drc_nova = novaclient.Client(**drc_ncred) drc_nova.servers.delete(drc_id) novaDao.delete_by_primary_instance_uuid(server_id)
def __init__(self, name, conf, os_auth_info): BaseClient.__init__(self, name, conf, os_auth_info) self.handle = client.Client( os_auth_info["username"], os_auth_info["password"], os_auth_info["tenant_name"], os_auth_info["auth_url"], insecure=True, service_type="compute") # Maybe the client doesn't prefer ssh route self.ssh_info = conf.get("ssh", None) servers = [] try: servers.extend(self.handle.servers.list()) except NotFound: logging.warn("No servers present for client %s" % name) self.pattern = re.compile("^" + os_auth_info["username"] + "-[0-9]{3}") for inst in servers: if not self.pattern.match(inst.name): continue instance = Instance(inst, self.ssh_info) instanceId = instance.get_id() self.id2inst[instanceId] = instance vols = [] try: vols.extend(self.handle.volumes.get_server_volumes(instanceId)) except NotFound: logging.warn("No volume attached for instance %s(%s)" % (instance.get_name(), instance.get_id())) volumes = self.id2vols[instanceId] = [] for vol in vols: volumes.append(Volume(instance, vol))
def novaclient(context): compat_catalog = { # TODO(gbasava): Check this... 'access': {'serviceCatalog': context.service_catalog or []} 'access': [] } sc = service_catalog.ServiceCatalog(compat_catalog) if CONF.nova_endpoint_template: url = CONF.nova_endpoint_template % context.to_dict() else: info = CONF.nova_catalog_info service_type, service_name, endpoint_type = info.split(':') # extract the region if set in configuration if CONF.os_region_name: attr = 'region' filter_value = CONF.os_region_name else: attr = None filter_value = None url = sc.url_for(attr=attr, filter_value=filter_value, service_type=service_type, service_name=service_name, endpoint_type=endpoint_type) LOG.debug(_('Novaclient connection created using URL: %s') % url) c = nova_client.Client(context.user_id, context.auth_token, project_id=context.project_id, auth_url=url, insecure=CONF.nova_api_insecure) # noauth extracts user_id:tenant_id from auth_token c.client.auth_token = context.auth_token or '%s:%s' % (context.user_id, context.project_id) c.client.management_url = url return c
def main(): argument_spec = openstack_argument_spec() argument_spec.update(dict( ip_address = dict(required=True), instance_name = dict(required=True), state = dict(default='present', choices=['absent', 'present']) )) module = AnsibleModule(argument_spec=argument_spec) if not HAVE_DEPS: module.fail_json(msg='python-novaclient, python-keystoneclient, and either python-neutronclient or python-quantumclient are required') try: nova = nova_client.Client(module.params['login_username'], module.params['login_password'], module.params['login_tenant_name'], module.params['auth_url'], service_type='compute') except Exception as e: module.fail_json( msg = " Error in authenticating to nova: %s" % e.message) neutron = _get_neutron_client(module, module.params) state, floating_ip_id = _get_floating_ip_id(module, neutron) if module.params['state'] == 'present': if state == 'attached': module.exit_json(changed = False, result = 'attached', public_ip=module.params['ip_address']) server_info, server_obj = _get_server_state(module, nova) if not server_info: module.fail_json(msg = " The instance name provided cannot be found") port_id = _get_port_id(neutron, module, server_info['id']) if not port_id: module.fail_json(msg = "Cannot find a port for this instance, maybe fixed ip is not assigned") _update_floating_ip(neutron, module, port_id, floating_ip_id) if module.params['state'] == 'absent': if state == 'detached': module.exit_json(changed = False, result = 'detached') if state == 'attached': _update_floating_ip(neutron, module, None, floating_ip_id) module.exit_json(changed = True, result = "detached")
def novaclient(cred): if cred.get("token", None) and cred.get("tenant_id", None): token = cred["token"] tenant_id = cred["tenant_id"] else: # Create scoped token for admin. unscoped_token = token_create(cred['username'], cred['password']) tenants = tenant_list_for_token(unscoped_token.id) tenant_id = tenants[0].id token = token_create(cred['username'], cred['password'], tenant_id) # Get service catalog catalog = service_catalog.ServiceCatalog(token) s_catalog = catalog.catalog.serviceCatalog management_url = url_for(s_catalog, 'compute') c = nova_client.Client(cred['username'], token.id, tenant_id, management_url) c.client.auth_token = token.id c.client.management_url = management_url return c
def client_conn(type_): if type_ == 'nova': client = client_nova.Client(username=AUTH_USER, insecure=True, api_key=AUTH_PASSWORD, project_id=AUTH_TENANT_NAME, auth_url=AUTH_URL, region_name=AUTH_REGION) elif type_ == 'keystone': client = client_keystone.Client(username=AUTH_USER, insecure=True, password=AUTH_PASSWORD, tenant_name=AUTH_TENANT_NAME, auth_url=AUTH_URL) elif type_ == 'cinder': client = client_cinder.Client(username=AUTH_USER, insecure=True, api_key=AUTH_PASSWORD, project_id=AUTH_TENANT_NAME, auth_url=AUTH_URL, region_name=AUTH_REGION, service_type='volume') return client
def main(): module = AnsibleModule( argument_spec = dict( login_username = dict(default='admin'), login_password = dict(required=True), login_tenant_name = dict(required='True'), auth_url = dict(default='http://127.0.0.1:35357/v2.0/'), instance_name = dict(required=True), snapshot_name = dict(required=True), state = dict(default='present', choices=['absent', 'present']), wait_snapshot = dict(default='yes'), wait_for = dict(default='7200') ), ) nova = nova_client.Client(module.params['login_username'], module.params['login_password'], module.params['login_tenant_name'], module.params['auth_url'], service_type='compute') try: nova.authenticate() except exc.Unauthorized, e: module.fail_json(msg = "Invalid OpenStack Nova credentials.: %s" % e.message)
def main(): config = ConfigParser.ConfigParser() config.read('settings.ini') server_config = yaml.load(open('provision.cfg').read()) nova = client.Client(config.get('provision', 'username'), config.get('provision', 'password'), None, ENDPOINT, region_name=config.get('provision', 'region'), http_log_debug=1) idrsa = open(config.get('provision', 'idrsa')).readlines()[0] vm_password = config.get('provision', 'vm_password') # Provision any un-provisioned hosts provision(nova, server_config) wait_all_built(nova) tag_hosts(nova, server_config) set_password(nova, vm_password) print_server_ip(nova) add_ssh_key_all_hosts(nova, vm_password, idrsa)
def setUp(self): super(AkandaFunctionalBase, self).setUp() self.config = self._get_config() self.ak_cfg = mock.patch.object(akanda_client.cfg, 'CONF').start() self.ak_cfg.alive_timeout = 10 self.ak_client = akanda_client self.novaclient = _novaclient.Client( self.config['os_username'], self.config['os_password'], self.config['os_tenant_name'], auth_url=self.config['os_auth_url'], auth_system='keystone', ) self.neutronclient = _neutronclient.Client( username=self.config['os_username'], password=self.config['os_password'], tenant_name=self.config['os_tenant_name'], auth_url=self.config['os_auth_url'], auth_strategy='keystone', ) self._management_address = None
def __init__(self, image_name, image_path): """ Constructor to create a Connection and an Image Instance. :param image_name: The name of the image to be created. :param image_path: The path of the image for creation. """ logging.basicConfig(filename='openstack.log', level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' , datefmt='%m/%d/%Y %I:%M:%S %p') logging.info('Establishing Connection.') # Establishing Connections -------------------- try: # Connections with keystoneClient(identity API) -------------------- creds = get_keystone_creds() self.keystone = ksclient.Client(**creds) # Connections with novaClient(compute API) -------------------- creds = get_nova_creds() self.nova = nvclient.Client(**creds) except: logging.error('Connection not Established.') raise # Creating IMAGE instance -------------------- try: logging.info('Creating Image.') self.is_image_present = False image = self.create(image_name, image_path) self.image = image except: logging.error('Image not Created.') main.delete() raise
def novaclient(request): """ insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False) cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', None) LOG.debug('novaclient connection created using token "%s" and url "%s"' % (request.user.token.id, base.url_for(request, 'compute'))) c = nova_client.Client(request.user.username, request.user.token.id, project_id=request.user.tenant_id, auth_url=base.url_for(request, 'compute'), insecure=insecure, cacert=cacert, http_log_debug=settings.DEBUG) c.client.auth_token = request.user.token.id c.client.management_url = base.url_for(request, 'compute') return c """ c = nova_client.Client(username=request.get("username"), api_key=request.get("password"), project_id=request.get("tenant_name"), auth_url=request.get("auth_url"), http_log_debug=False) return c
def test_authenticate_success(self): cs = client.Client("username", "password", "project_id", "auth_url", no_cache=True) management_url = 'https://servers.api.rackspacecloud.com/v1.1/443470' auth_response = httplib2.Response({ 'status': 204, 'x-server-management-url': management_url, 'x-auth-token': '1b751d74-de0c-46ae-84f0-915744b582d1', }) mock_request = mock.Mock(return_value=(auth_response, None)) @mock.patch.object(httplib2.Http, "request", mock_request) def test_auth_call(): cs.client.authenticate() headers = { 'Accept': 'application/json', 'X-Auth-User': '******', 'X-Auth-Key': 'password', 'X-Auth-Project-Id': 'project_id', 'User-Agent': cs.client.USER_AGENT } mock_request.assert_called_with(cs.client.auth_url, 'GET', headers=headers) self.assertEqual(cs.client.management_url, auth_response['x-server-management-url']) self.assertEqual(cs.client.auth_token, auth_response['x-auth-token']) test_auth_call()
def main(args): credentials = getOsCredentialsFromEnvironment() nt = client.Client(credentials['USERNAME'], credentials['PASSWORD'], credentials['TENANT_NAME'], credentials['AUTH_URL'], service_type="compute") inventory = {} inventory['_meta'] = {'hostvars': {}} for server in nt.servers.list(): groups = getAnsibleHostGroupsFromServer(nt, server) if len(groups) > 0: for group in groups: addServerToHostGroup(group, server, inventory) else: addServerToHostGroup('unassigned-group', server, inventory) host_vars = getAnsibleHostVarsFromServer(nt, server) if host_vars: addServerHostVarsToHostVars(host_vars, server, inventory) dumpInventoryAsJson(inventory)
def create_server(): # testing environment if 'True' == utils.get_config('mode', 'testing'): LOG.info('Now launching a private instance') # producting environment else: # TODO diy rest? import novaclient.v1_1.client as nvclient creds = get_nova_creds() nova = nvclient.Client(**creds) image = nova.images.find(name="cirros-0.3.2-x86_64") flavor = nova.flavors.find(name="m1.tiny") nics = [{'net-id': '80963cd2-0f29-433c-bb33-c4e25ad8719b'}] instance = nova.servers.create(name="bryant", image=image, flavor=flavor, nics=nics) LOG.info('Now launched a private instance') instance.add_floating_ip(get_floating_ip()) LOG.info('Now adding floating ip to the private instance')
def verify(self, node, subject, **kwargs): try: CN = subject.CN OU = subject.OU keystone = k.Client(token=self._get_token(), auth_url=self.ADMIN_AUTH_URL, tenant_name=self.admin_tenant, timeout=self.timeout) tenants = keystone.tenants.list() conn = n.Client(self.admin_user, self.admin_pass, self.admin_tenant, self.ADMIN_AUTH_URL, service_type="compute", timeout=self.timeout) for server in conn.servers.list(True, search_opts={'all_tenants': True}): if self.strict_check: # Perform strict check by hostname and ID if server.name != CN: continue if server.id == OU: tenant = filter(lambda t: t.id == server.tenant_id, tenants) if tenant: name = tenant[0].name LOG.info("Tenant [%s] matched for server %s" % (name, node)) return name except Exception, e: LOG.error(e) return None
def main(): argument_spec = openstack_argument_spec() argument_spec.update( dict(ip_address=dict(required=True), instance_name=dict(required=True), state=dict(default='present', choices=['absent', 'present']))) module = AnsibleModule(argument_spec=argument_spec) if not HAVE_DEPS: module.fail_json( msg= 'python-novaclient, python-keystoneclient, and either python-neutronclient or python-quantumclient are required' ) try: nova = nova_client.Client(module.params['login_username'], module.params['login_password'], module.params['login_tenant_name'], module.params['auth_url'], service_type='compute') except Exception, e: module.fail_json(msg=" Error in authenticating to nova: %s" % e.message)
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from nova import flags from novaclient.v1_1 import client FLAGS = flags.FLAGS NOVA_CLIENT = client.Client(FLAGS.keystone_username, FLAGS.keystone_password, FLAGS.keystone_tenant_name, FLAGS.keystone_auth_url, service_type="compute") def is_running(floating_ip_uuid, **kwargs): return not is_terminated(floating_ip_uuid) def is_terminated(floating_ip_uuid): # TODO(lzyeval): handle error # NOTE(yaguang): handle exception when floating ip is released by user # we can not get info from novaclient try: floating_ip = NOVA_CLIENT.floating_ips.get(floating_ip_uuid) except Exception:
def setUp(self): super(ITestCase, self).setUp() self.common_config = cfg.ITConfig().common_config self.vanilla_config = cfg.ITConfig().vanilla_config self.vanilla_two_config = cfg.ITConfig().vanilla_two_config self.hdp_config = cfg.ITConfig().hdp_config self.mapr_config = cfg.ITConfig().mapr_config self.mapr4_1_config = cfg.ITConfig().mapr4_1_config self.mapr4_2_config = cfg.ITConfig().mapr4_2_config telnetlib.Telnet(self.common_config.SAHARA_HOST, self.common_config.SAHARA_PORT) keystone = keystone_client.Client( username=self.common_config.OS_USERNAME, password=self.common_config.OS_PASSWORD, tenant_name=self.common_config.OS_TENANT_NAME, auth_url=self.common_config.OS_AUTH_URL) keystone.management_url = self.common_config.OS_AUTH_URL self.common_config.OS_TENANT_ID = [ tenant.id for tenant in keystone.tenants.list() if tenant.name == self.common_config.OS_TENANT_NAME ][0] self.sahara = sahara_client.Client( version=self.common_config.SAHARA_API_VERSION, username=self.common_config.OS_USERNAME, api_key=self.common_config.OS_PASSWORD, project_name=self.common_config.OS_TENANT_NAME, auth_url=self.common_config.OS_AUTH_URL, sahara_url='http://%s:%s/v%s/%s' % (self.common_config.SAHARA_HOST, self.common_config.SAHARA_PORT, self.common_config.SAHARA_API_VERSION, self.common_config.OS_TENANT_ID)) self.nova = nova_client.Client( username=self.common_config.OS_USERNAME, api_key=self.common_config.OS_PASSWORD, project_id=self.common_config.OS_TENANT_NAME, auth_url=self.common_config.OS_AUTH_URL) self.neutron = neutron_client.Client( username=self.common_config.OS_USERNAME, password=self.common_config.OS_PASSWORD, tenant_name=self.common_config.OS_TENANT_NAME, auth_url=self.common_config.OS_AUTH_URL) if not self.common_config.FLAVOR_ID: self.flavor_id = self.nova.flavors.create(name='i-test-flavor-%s' % str(uuid.uuid4())[:8], ram=1024, vcpus=1, disk=10, ephemeral=10).id else: self.flavor_id = self.common_config.FLAVOR_ID if not self.common_config.PATH_TO_SSH_KEY: self.common_config.USER_KEYPAIR_ID += str(uuid.uuid4())[:8] self.private_key = self.nova.keypairs.create( self.common_config.USER_KEYPAIR_ID).private_key else: self.private_key = open(self.common_config.PATH_TO_SSH_KEY).read()
os_user_name = config.get('OPENSTACK', 'os_user_name') os_password = config.get('OPENSTACK', 'os_password') os_tenant_name = config.get('OPENSTACK', 'os_tenant_name') os_auth_url = config.get('OPENSTACK', 'os_auth_url') os_region_name = config.get('OPENSTACK', 'os_region_name') from neutronclient.v2_0 import client as neutronclient nc = neutronclient.Client(username=os_user_name, password=os_password, tenant_name=os_tenant_name, auth_url=os_auth_url) from novaclient.v1_1 import client as novaclient novac = novaclient.Client(os_user_name, os_password, os_tenant_name, os_auth_url ) from keystoneclient.v2_0 import client keystone = client.Client(username=os_user_name, password=os_password, tenant_name=os_tenant_name, auth_url=os_auth_url ) glance_endpoint = keystone.service_catalog.get_endpoints('image').get('image')[0].get('internalURL') ## HACKITY HACK HACK HACK if ( glance_endpoint.endswith('/v2') or glance_endpoint.endswith('/v1') ) : glance_endpoint = glance_endpoint.rsplit('/', 1)[0] print "Found a glance endpoint at {}".format(glance_endpoint)
def main(): argument_spec = openstack_argument_spec() argument_spec.update( dict( name=dict(required=True), image_id=dict(default=None), image_name=dict(default=None), image_exclude=dict(default='(deprecated)'), flavor_id=dict(default=1), flavor_ram=dict(default=None, type='int'), flavor_include=dict(default=None), key_name=dict(default=None), security_groups=dict(default='default'), nics=dict(default=None, type='list'), meta=dict(default=None, type='dict'), wait=dict(default='yes', choices=['yes', 'no']), wait_for=dict(default=180), state=dict(default='present', choices=['absent', 'present']), user_data=dict(default=None), config_drive=dict(default=False, type='bool'), auto_floating_ip=dict(default=False, type='bool'), floating_ips=dict(default=None, type='list'), floating_ip_pools=dict(default=None, type='list'), scheduler_hints=dict(default=None, type='dict'), )) module = AnsibleModule( argument_spec=argument_spec, mutually_exclusive=[ ['auto_floating_ip', 'floating_ips'], ['auto_floating_ip', 'floating_ip_pools'], ['floating_ips', 'floating_ip_pools'], ['image_id', 'image_name'], ['flavor_id', 'flavor_ram'], ], ) if not HAS_NOVACLIENT: module.fail_json(msg='python-novaclient is required for this module') nova = nova_client.Client(module.params['login_username'], module.params['login_password'], module.params['login_tenant_name'], module.params['auth_url'], region_name=module.params['region_name'], service_type='compute') try: nova.authenticate() except exceptions.Unauthorized as e: module.fail_json(msg="Invalid OpenStack Nova credentials.: %s" % e.message) except exceptions.AuthorizationFailure as e: module.fail_json(msg="Unable to authorize user: %s" % e.message) if module.params['state'] == 'present': if not module.params['image_id'] and not module.params['image_name']: module.fail_json( msg= "Parameter 'image_id' or `image_name` is required if state == 'present'" ) else: _get_server_state(module, nova) _create_server(module, nova) if module.params['state'] == 'absent': _get_server_state(module, nova) _delete_server(module, nova)
''' INSTANCE_NAME = 'fiva' NETWORK_NAME='route-66' SUBNET_CIDR='10.2.33.0/24' INSTANCE_COUNT = 3 kcreds = get_keystone_creds() print "Connecting to keystone" keystone = keystoneclient.Client(**kcreds) tokenlen=len(keystone.auth_token) print keystone.auth_token[0:20] + "..." + keystone.auth_token[tokenlen-20:tokenlen] ncreds = get_nova_creds() nova = novaclient.Client(**ncreds) flavors = nova.flavors.list(is_public=True) print flavors images = nova.images.list(detailed=False) print images # get networks from quantum print "Find or create network..." network_url = keystone.service_catalog.url_for(service_type='network') neutron = neutronclient.Client(endpoint_url=network_url, token=keystone.auth_token) networks = neutron.list_networks()['networks'] print "Networks: " print [(nw['name'],nw['id'])for nw in networks]
def snapshot_image_on_provider(self, builder, provider, credentials, target, template, parameters): self.log.info('snapshot_image_on_provider() called in Rackspace') self.builder = builder self.active_image = self.builder.provider_image # TODO: This is a convenience variable for refactoring - rename self.new_image_id = builder.provider_image.identifier # TODO: so is this self.target = target # Template must be defined for snapshots self.tdlobj = oz.TDL.TDL(xmlstring=str(template), rootpw_required=True) # Create a name combining the TDL name and the UUID for use when tagging Rackspace Images self.longname = self.tdlobj.name + "-" + self.new_image_id self.log.debug("Being asked to push for provider %s" % provider) self.log.debug( "distro: %s - update: %s - arch: %s" % (self.tdlobj.distro, self.tdlobj.update, self.tdlobj.arch)) self.rackspace_decode_credentials(credentials) self.log.debug("acting as Rackspace user: %s" % (str(self.rackspace_username))) self.status = "PUSHING" self.percent_complete = 0 region = provider auth_url = 'https://identity.api.rackspacecloud.com/v2.0/' rackspace_client = client.Client(self.rackspace_username, self.rackspace_password, self.rackspace_account_number, auth_url, service_type="compute", region_name=region) rackspace_client.authenticate() mypub = open("/etc/oz/id_rsa-icicle-gen.pub") server_files = {"/root/.ssh/authorized_keys": mypub} # Now launch it self.activity("Launching Rackspace JEOS image") rackspace_image_id = self.rackspace_jeos_amis[region][ self.tdlobj.distro][self.tdlobj.update][self.tdlobj.arch]['img_id'] instance_type = '512MB Standard Instance' image = rackspace_client.images.find(id=rackspace_image_id) small = rackspace_client.flavors.find(name=instance_type) self.log.debug("Starting build server %s with instance_type %s" % (rackspace_image_id, instance_type)) reservation_name = 'imagefactory-snapshot-%s' % self.active_image.identifier reservation = rackspace_client.servers.create(reservation_name, image, small, files=server_files) if not reservation: self.status = "FAILED" raise ImageFactoryException( "run_instances did not result in the expected single instance - stopping" ) self.instance = reservation self.wait_for_rackspace_instance_start(self.instance) # From this point on we must be sure to terminate the instance when we are done # so wrap in a try/finally # Accidentally running a 64 bit instance doing nothing costs 56 USD week try: while self.instance.accessIPv4 == '': self.log.debug("Waiting to get public IP address") sleep(1) self.instance.get() guestaddr = self.instance.accessIPv4 self.guest = oz.Fedora.FedoraGuest(self.tdlobj, self.oz_config, None, "virtio", True, "virtio", True) # Ugly ATM because failed access always triggers an exception self.wait_for_rackspace_ssh_access(guestaddr) # There are a handful of additional boot tasks after SSH starts running # Give them an additional 20 seconds for good measure self.log.debug("Waiting 60 seconds for remaining boot tasks") sleep(60) self.activity("Customizing running Rackspace JEOS instance") self.log.debug( "Stopping cron and killing any updatedb process that may be running" ) # updatedb interacts poorly with the bundle step - make sure it isn't running self.guest.guest_execute_command(guestaddr, "/sbin/service crond stop") self.guest.guest_execute_command( guestaddr, "killall -9 updatedb || /bin/true") self.log.debug("Done") # Not all JEOS images contain this - redoing it if already present is harmless self.log.info("Creating cloud-info file indicating target (%s)" % self.target) self.guest.guest_execute_command( guestaddr, 'echo CLOUD_TYPE=\\\"%s\\\" > /etc/sysconfig/cloud-info' % self.target) self.log.debug("Customizing guest: %s" % guestaddr) self.guest.mkdir_p(self.guest.icicle_tmp) self.guest.do_customize(guestaddr) self.log.debug("Customization step complete") self.log.debug("Generating ICICLE from customized guest") self.output_descriptor = self.guest.do_icicle(guestaddr) self.log.debug("ICICLE generation complete") self.log.debug( "Re-de-activate firstboot just in case it has been revived during customize" ) self.guest.guest_execute_command( guestaddr, "[ -f /etc/init.d/firstboot ] && /sbin/chkconfig firstboot off || /bin/true" ) self.log.debug("De-activation complete") image_name = str(self.longname) #image_desc = "%s - %s" % (asctime(localtime()), self.tdlobj.description) self.log.debug( "Creating a snapshot of our running Rackspace instance") #TODO: give proper name?? new_image_id = self.instance.create_image(image_name) new_image = rackspace_client.images.find(id=new_image_id) while True: new_image.get() self.log.info("Saving image: %d percent complete" % new_image.progress) if new_image.progress == 100: break else: sleep(20) self.builder.provider_image.icicle = self.output_descriptor self.builder.provider_image.identifier_on_provider = new_image_id self.builder.provider_image.provider_account_identifier = self.rackspace_account_number except Exception as e: self.log.warning( "Exception while executing commands on guest: %s" % e) finally: self.terminate_instance(self.instance)
import os,sys import time nombre1="servidor_web" nombre2="servidor_mysql" def get_nova_creds(): d = {} d['username'] = os.environ['OS_USERNAME'] d['api_key'] = os.environ['OS_PASSWORD'] d['auth_url'] = os.environ['OS_AUTH_URL'] d['project_id'] = os.environ['OS_TENANT_NAME'] d['region_name']=os.environ['OS_REGION_NAME'] return d # Me conecto al cloud nova = client.Client(**get_nova_creds()) #secgroup = nova.security_groups.find(name="default") #nova.security_group_rules.delete(secgroup.id,ip_protocol="tcp",from_port="3128",to_port="3128",cidr="0.0.0.0/0") for nomserver in [nombre1,nombre2]: server=nova.servers.find(name=nomserver) # Selecciono la ip flotente ip_flotante = server.networks.items()[0][1][1] # elimino la instancia server.delete() nova.floating_ips.delete(nova.floating_ips.find(ip=ip_flotante)) print "Delete %s" % nomserver
def openstack_launch(constellation_name, machine_name, constellation_directory, user_data, nova_creds): ''' Launches an openstack instance. Creates a unique keypair, security group, and floating ip and assigns them to the instance ''' #nova_creds = get_nova_creds() nova = nvclient.Client(**nova_creds) #create keypair keypair_name = "key-%s-%s" % (machine_name, constellation_name) keypair = nova.keypairs.create(name=keypair_name) private_key = keypair.private_key path = os.path.join(constellation_directory, "%s.pem" % keypair_name) with open(path, 'w') as key_file: key_file.write(private_key) os.chmod(path, 0600) #create security group security_group_name = "security_" + constellation_name security_group = nova.security_groups.create( name=security_group_name, description="Security group for " + constellation_name) nova.security_group_rules.create(security_group.id, "TCP", 22, 22, "0.0.0.0/0") nova.security_group_rules.create(security_group.id, "TCP", 80, 80, "0.0.0.0/0") nova.security_group_rules.create(security_group.id, "ICMP", -1, -1, "0.0.0.0/0") #create instance instance_name = machine_name + "-" + constellation_name #image = nova.images.find(name="cirros-0.3.1-x86_64-uec") #flavor = nova.flavors.find(name="m1.tiny") image = nova.images.find(name="ubuntu12.04") flavor = nova.flavors.find(name="ubuntu") instance = nova.servers.create(name=instance_name, image=image, flavor=flavor, security_groups=[security_group.name], key_name=keypair_name, userdata=user_data) status = instance.status while status == 'BUILD': time.sleep(5) instance = nova.servers.get(instance.id) status = instance.status print("status: %s" % status) #assign_floating_ip instance = nova.servers.get(instance.id) flag = 0 for floating_ip in nova.floating_ips.list(): if floating_ip.instance_id is None: instance.add_floating_ip(floating_ip) flag = 1 break if not flag: floating_ip = nova.floating_ips.create() instance.add_floating_ip(floating_ip) log("floating ip %s" % floating_ip) return floating_ip.ip, instance_name, keypair_name, security_group_name
'--nova-url', help='url for nova auth', default='http://openstack.eqiad1.wikimediacloud.org:35357/v2.0') argparser.add_argument('--nova-project', help='project for nova auth', default='admin') argparser.add_argument( 'instanceid', help='instance id to migrate', ) argparser.add_argument( 'destination', help='destination host, e.g. labvirt1005', ) args = argparser.parse_args() sshargs = [ "ssh", "-i", "/root/.ssh/compute-hosts-key", "nova@%s.eqiad.wmnet" % args.destination, "true" ] r = subprocess.call(sshargs) if r: print("Remote execution failed; this whole enterprise is doomed.") exit(1) novaclient = client.Client(args.nova_user, args.nova_pass, args.nova_project, args.nova_url) instance = NovaInstance(novaclient, args.instanceid) instance.migrate(args.destination)
def __init__(self, username, project_id, auth_url, region_name=None, password=None, os_auth_plugin=None, **kwargs): ''' Set up nova credentials ''' if not HAS_NOVA: return None self.kwargs = kwargs.copy() self.kwargs['username'] = username self.kwargs['project_id'] = project_id self.kwargs['auth_url'] = auth_url self.kwargs['region_name'] = region_name self.kwargs['service_type'] = 'compute' if os_auth_plugin is not None: novaclient.auth_plugin.discover_auth_systems() auth_plugin = novaclient.auth_plugin.load_plugin(os_auth_plugin) self.kwargs['auth_plugin'] = auth_plugin self.kwargs['auth_system'] = os_auth_plugin if not self.kwargs.get('api_key', None): self.kwargs['api_key'] = password extensions = [] if 'extensions' in kwargs: exts = [] for key, item in self.kwargs['extensions'].items(): mod = __import__(item.replace('-', '_')) exts.append(novaclient.extension.Extension(key, mod)) self.kwargs['extensions'] = exts self.kwargs = sanatize_novaclient(self.kwargs) if not hasattr(client.Client, '__exit__'): raise SaltCloudSystemExit( "Newer version of novaclient required for __exit__.") with client.Client(**self.kwargs) as conn: try: conn.client.authenticate() except novaclient.exceptions.AmbiguousEndpoints: raise SaltCloudSystemExit( "Nova provider requires a 'region_name' to be specified") self.kwargs['auth_token'] = conn.client.auth_token self.catalog = \ conn.client.service_catalog.catalog['access']['serviceCatalog'] if region_name is not None: servers_endpoints = get_entry(self.catalog, 'type', 'compute')['endpoints'] self.kwargs['bypass_url'] = get_entry(servers_endpoints, 'region', region_name)['publicURL'] self.compute_conn = client.Client(**self.kwargs) if region_name is not None: servers_endpoints = get_entry(self.catalog, 'type', 'volume')['endpoints'] self.kwargs['bypass_url'] = get_entry(servers_endpoints, 'region', region_name)['publicURL'] self.kwargs['service_type'] = 'volume' self.volume_conn = client.Client(**self.kwargs)
def test_ambiguous_endpoints(self): cs = client.Client("username", "password", "project_id", "auth_url/v2.0", service_type='compute') resp = { "access": { "token": { "expires": "12345", "id": "FAKE_ID", "tenant": { "id": "FAKE_TENANT_ID", } }, "serviceCatalog": [ { "adminURL": "http://*****:*****@mock.patch.object(requests, "request", mock_request) def test_auth_call(): self.assertRaises(exceptions.AmbiguousEndpoints, cs.client.authenticate) test_auth_call()