def __init__(self, json_config=None): if json_config: self.config = from_file(profile_name=json_config.get("profile")) else: self.config = from_file() self._identity_client = IdentityClient(self.config) self._compute_client = ComputeClient(self.config) self._network_client = VirtualNetworkClient(self.config)
def __init__(self,tenancy_name): config = Config(tenancy_name) self.config = config.config self.compartment_id = self.config['tenancy'] self.fingerprint = self.config['fingerprint'] self.key_file = self.config["key_file"] self.admin_user_id = self.config["user"] self.identity = IdentityClient(self.config) self.users = list() self.list_users() self.compartments = list() self.availability_domains = list() self.store_compartments() self.list_availability_domains()
def __init__(self): config = {} try: signer = Config.signer self.identity = IdentityClient(config=config, signer=signer) self.compartment_id = Config.tenancy_id except Exception: config = Config.config self.identity = IdentityClient(config) self.compartment_id = config["tenancy"] self.compartments = list() self.availability_domain_list = list() self.update_ads()
def authenticate(self, profile=None, **kwargs): try: config = from_file(profile_name=profile) compartment_id = config["tenancy"] # Get the current user identity = IdentityClient(config) identity.get_user(config["user"]).data return OracleCredentials(config, compartment_id) except Exception as e: raise AuthenticationException(e)
def authenticate(self, profile=None, **kwargs): try: # Set logging level to error for libraries as otherwise generates a lot of warnings logging.getLogger('oci').setLevel(logging.ERROR) config = from_file(profile_name=profile) # Get the current user identity = IdentityClient(config) identity.get_user(config["user"]).data return OracleCredentials(config) except Exception as e: raise AuthenticationException(e)
def set_connect(self, secret_data): self.identity_client = IdentityClient(secret_data) self.database_client = DatabaseClient(secret_data) self.disk_client = BlockstorageClient(secret_data) self.compute_client = ComputeClient(secret_data) self.compute_management_client = ComputeManagementClient(secret_data) self.virtual_network_client = VirtualNetworkClient(secret_data) self.load_balancer_client = LoadBalancerClient(secret_data) self.network_load_balancer_client = NetworkLoadBalancerClient(secret_data)
def oracle_connect_service(service, credentials, region_name=None): try: if service == 'identity': return IdentityClient(credentials.config) else: print_exception('Service %s not supported' % service) return None except Exception as e: print_exception(e) return None
def handle(self, *args, **options): from oci.identity import IdentityClient config = oci.config.from_file() identity = IdentityClient(config) from oci.identity.models import CreateGroupDetails request = CreateGroupDetails() compartment_id = config["tenancy"] request.compartment_id = compartment_id request.name = "my-test-group" request.description = "Created with the Python SDK" group = identity.create_group(request) from oci.identity.models import CreateUserDetails request = CreateUserDetails() request.compartment_id = compartment_id request.name = "my-test-user" request.description = "Created with the Python SDK" user = identity.create_user(request) from oci.identity.models import AddUserToGroupDetails request = AddUserToGroupDetails() request.group_id = group.data.id request.user_id = user.data.id response = identity.add_user_to_group(request) print(response.status)
class Compartment: def __init__(self): config = {} try: signer = Config.signer self.identity = IdentityClient(config=config, signer=signer) self.compartment_id = Config.tenancy_id except Exception: config = Config.config self.identity = IdentityClient(config) self.compartment_id = config["tenancy"] self.compartments = list() self.availability_domain_list = list() self.update_ads() # send requests to list all compartments and its child def list_compartments(self): return oci.pagination.list_call_get_all_results( self.identity.list_compartments, self.compartment_id, compartment_id_in_subtree=True).data # Return compartment data and store in a list def store_compartments(self): for compartment in self.list_compartments(): self.compartments.append(compartment) def list_availability_domain(self): return self.identity.list_availability_domains( self.compartment_id).data def update_ads(self): for i in self.list_availability_domain(): self.availability_domain_list.append(i) def get_compartment_name(self, ids): return [i.name for i in self.compartments if i.id == ids][0] def get_compartment_id_list(self): return self.compartments
class IdentityFacade: def __init__(self, credentials: OracleCredentials): self._credentials = credentials self._client = IdentityClient(self._credentials.config) async def get_users(self): response = await run_concurrently(lambda: list_call_get_all_results( self._client.list_users, self._credentials.compartment_id)) return response.data async def get_user_api_keys(self, user_id): response = await run_concurrently(lambda: list_call_get_all_results( self._client.list_api_keys, user_id)) return response.data async def get_groups(self): response = await run_concurrently(lambda: list_call_get_all_results( self._client.list_groups, self._credentials.compartment_id)) return response.data async def get_group_users(self, group_id): response = await run_concurrently(lambda: list_call_get_all_results( self._client.list_user_group_memberships, self._credentials.compartment_id, group_id=group_id)) return response.data async def get_policies(self): response = await run_concurrently(lambda: list_call_get_all_results( self._client.list_policies, self._credentials.compartment_id)) return response.data async def get_authentication_policy(self): response = await run_concurrently( lambda: self._client.get_authentication_policy(self._credentials. compartment_id)) return response.data
import oci from oci.identity import IdentityClient from oci.core import VirtualNetworkClient, ComputeClient from app.oci_config import get_configuration, get_compartment_scope, get_vcn_scope config = get_configuration() identity_client = IdentityClient(config) compute_client = ComputeClient(config) network_client = VirtualNetworkClient(config) def get_oci_user(): user = identity_client.get_user(config["user"]).data return user def get_compute_instances_details(): try: response = compute_client.list_instances( compartment_id=get_compartment_scope()) return response.data except Exception as e: return {"problem encountered": e.__repr__()} def get_compute_instances_status(): try: response = {} instance_responses = compute_client.list_instances(
def __init__(self, credentials: OracleCredentials): self._credentials = credentials self._client = IdentityClient(self._credentials.config)
class IdentityFacade: def __init__(self, credentials: OracleCredentials): self._credentials = credentials self._client = IdentityClient(self._credentials.config) async def get_users(self): try: response = await run_concurrently( lambda: list_call_get_all_results( self._client.list_users, self._credentials.get_scope())) return response.data except Exception as e: print_exception(f'Failed to retrieve users: {e}') return [] async def get_user_api_keys(self, user_id): try: response = await run_concurrently( lambda: list_call_get_all_results(self._client.list_api_keys, user_id)) return response.data except Exception as e: print_exception(f'Failed to retrieve user api keys: {e}') return [] async def get_groups(self): try: response = await run_concurrently( lambda: list_call_get_all_results( self._client.list_groups, self._credentials.get_scope())) return response.data except Exception as e: print_exception(f'Failed to retrieve groups: {e}') return [] async def get_group_users(self, group_id): try: response = await run_concurrently( lambda: list_call_get_all_results( self._client.list_user_group_memberships, self._credentials.get_scope(), group_id=group_id)) return response.data except Exception as e: print_exception(f'Failed to retrieve group users: {e}') return [] async def get_policies(self): try: response = await run_concurrently( lambda: list_call_get_all_results( self._client.list_policies, self._credentials.get_scope())) return response.data except Exception as e: print_exception(f'Failed to retrieve policies: {e}') return None async def get_authentication_policy(self): try: response = await run_concurrently( lambda: self._client.get_authentication_policy( self._credentials.config['tenancy'])) return response.data except Exception as e: print_exception(f'Failed to retrieve authentication policy: {e}') return []
else: print("Running with: ") print("Username: {}".format(sys.argv[1])) print("") # # Main # print("") controlla_params() validate_config(config) print("Validate config OK") username = sys.argv[1] client = IdentityClient(config) # set user details details = CreateUserDetails(compartment_id=config.get("tenancy"), description="ocipy_created", name=username) client.create_user(details) print("User created !") print("")
def identity(self, region=None): try: return IdentityClient(self.config) except oci.exceptions.ClientError as err: print(err, file=sys.stderr) sys.exit(1)
class OciWrapper: def __init__(self, json_config=None): if json_config: self.config = from_file(profile_name=json_config.get("profile")) else: self.config = from_file() self._identity_client = IdentityClient(self.config) self._compute_client = ComputeClient(self.config) self._network_client = VirtualNetworkClient(self.config) def get_compartment_list(self): """ :return list of all compartments in a tenancy """ return self._identity_client.list_compartments( self.config.get('tenancy')).data def list_compartments(self): """ Provide a list of compartments :return JSON with compartment list """ d = self._identity_client.list_compartments( self.config.get('tenancy')).data return json.loads(str(d)) def get_compartment_id_from_name(self, compartment_name): return next((item for item in self.get_compartment_list() if item.name == compartment_name)).id def get_instance_id_from_name(self, compartment_id, instance_name): instance_ids = [] for item in self._compute_client.list_instances(compartment_id).data: if item.display_name == instance_name and item.lifecycle_state == "RUNNING" or item.lifecycle_state == "STOPPED": instance_ids.append(item.id) return instance_ids def get_instance_details(self, compartment_id, instance_id): # get running instance details # this assumes that only one istance with the given display name is running return next((item for item in self._compute_client.list_instances( compartment_id).data if item.id == instance_id)) def get_bv_id(self, compartment_id, instance_id): i_details = self.get_instance_details(compartment_id, instance_id) # get boot volume details _tmp = next( (item for item in self._compute_client.list_boot_volume_attachments( i_details.availability_domain, compartment_id).data if item.instance_id == instance_id)) boot_vol_attachment_id = _tmp.id logging.debug("Boot volume attachment OCID: %s", boot_vol_attachment_id) boot_vol_id = _tmp.boot_volume_id logging.debug("Boot volume OCID: %s", boot_vol_id) return boot_vol_id, boot_vol_attachment_id def detach_bv(self, bv_id): """ detach block volume """ logging.info("Detaching boot volume...") response = self._compute_client.detach_boot_volume(bv_id) get_instance_response = oci.wait_until( self._compute_client, self._compute_client.get_boot_volume_attachment(bv_id), 'lifecycle_state', 'DETACHED') logging.info("Boot volume detached") def launch_instance(self, instance_details): """ launch instance :return istance OCID """ try: logging.info("Starting new instance...") response = self._compute_client.launch_instance(instance_details) oci.wait_until(self._compute_client, self._compute_client.get_instance(response.data.id), 'lifecycle_state', 'RUNNING') logging.info("Instance started [%s]", response.data.id) return response.data.id except ServiceError as err: logging.error( 'unable to launch a new instance code %s - message %s' % (err.code, err.message)) def stop_instance(self, instance_id, detach_bv=False): """ stop instance """ logging.info("Stopping instance...") response = self._compute_client.instance_action(instance_id, "stop") get_instance_response = oci.wait_until( self._compute_client, self._compute_client.get_instance(instance_id), 'lifecycle_state', 'STOPPED') logging.info("Instance stopped") def terminate_instance(self, compartment_id, instance_id, preserve_bv=False): """ terminate the smaller instance :param compartment_id: compartment OCID :param instance_id: instance OCID :param preserve_bv: if True preserve the boot volume :return: """ logging.info("Terminating instance...") self._compute_client.terminate_instance( instance_id, preserve_boot_volume=preserve_bv) oci.wait_until(self._compute_client, self._compute_client.get_instance(instance_id), 'lifecycle_state', 'TERMINATED') logging.info("Instance terminated") def scale(self, new_shape, compartment_name=None, compartment_ocid=None, instance_name=None, instance_ocid=None): """ Scale-up function """ if not compartment_ocid: compartment_ocid = self.get_compartment_id_from_name( compartment_name) if not compartment_ocid: raise ValueError('unable to locate any compartment named: %s' % instance_name) if not instance_ocid: temp_instance_ids = self.get_instance_id_from_name( compartment_ocid, instance_name) if not temp_instance_ids or len(temp_instance_ids) < 1: raise ValueError('unable to locate any instance named: %s' % instance_name) elif len(temp_instance_ids) > 1: raise ValueError('name (%s) is used by multiple instances' % instance_name) else: instance_ocid = temp_instance_ids[0] logging.info("Scaling up instance: %s [%s]", instance_name, instance_ocid) old_instance_details = self.get_instance_details( compartment_ocid, instance_ocid) #get vnic details # TODO: Manage multiple vnics. This assumes that instance has a single vnic. vnic_id = next((item for item in self._compute_client.list_vnic_attachments( compartment_ocid).data if item.instance_id == instance_ocid)).vnic_id vnic_attachment_details = self._network_client.get_vnic(vnic_id).data logging.debug("vnic attachment details: %s", vnic_attachment_details) # TODO: manage Public floating IP # TODO: manage block volumes #stopping instance self.stop_instance(instance_ocid) #detach boot volume bv_ocid, bv_attachment_ocid = self.get_bv_id(compartment_ocid, instance_ocid) self.detach_bv(bv_attachment_ocid) #terminating the old instance self.terminate_instance(compartment_ocid, instance_ocid, True) instance_details = models.LaunchInstanceDetails( availability_domain=old_instance_details.availability_domain, compartment_id=old_instance_details.compartment_id, create_vnic_details=models.CreateVnicDetails( assign_public_ip=bool(vnic_attachment_details.public_ip), display_name=vnic_attachment_details.display_name, hostname_label=vnic_attachment_details.hostname_label, private_ip=vnic_attachment_details.private_ip, skip_source_dest_check=vnic_attachment_details. skip_source_dest_check, subnet_id=vnic_attachment_details.subnet_id, ), display_name=old_instance_details.display_name, extended_metadata=old_instance_details.extended_metadata, ipxe_script=old_instance_details.ipxe_script, metadata=old_instance_details.metadata, shape=new_shape, source_details=models.InstanceSourceViaBootVolumeDetails( source_type="bootVolume", boot_volume_id=bv_ocid)) new_instance_ocid = self.launch_instance(instance_details) return new_instance_ocid def _test(self, c_ocid, i_ocid): idet = self.get_instance_details(c_ocid, i_ocid) return idet
exit(1) if not os.path.exists('.oci/oci_api_key.pem'): logging.error("File .oci/oci_api_key.pem missing!") exit(1) if not os.path.exists('.oci/oci_api_key_public.pem'): logging.error("File .oci/oci_api_key_public.pem missing!") exit(1) logging.info("Loading configuration from .oci") config = from_file(file_location=".oci/config") logging.info("Validating configuration from .oci") validate_config(config) identity = IdentityClient(config) tenant_compartment_id = config["tenancy"] logging.info("Retrieving all compartments") compartments = getCompartmentRecurse(identity, tenant_compartment_id) logging.debug(compartments) if compartments.get(newCompartmentName) is not None: logging.error("Compartment already exists!") sendMail(newCompartmentOwner, "Subscription already exists", "Subscription %s already exists!" % newCompartmentName) exit(2) newCompartmentNameParts = newCompartmentName.split('-') newCompartmentParent = compartments[newCompartmentNameParts[1].lower()]
class Identity: def __init__(self,tenancy_name): config = Config(tenancy_name) self.config = config.config self.compartment_id = self.config['tenancy'] self.fingerprint = self.config['fingerprint'] self.key_file = self.config["key_file"] self.admin_user_id = self.config["user"] self.identity = IdentityClient(self.config) self.users = list() self.list_users() self.compartments = list() self.availability_domains = list() self.store_compartments() self.list_availability_domains() def list_availability_domains(self): for i in self.identity.list_availability_domains(self.compartment_id, retry_strategy=oci.retry.DEFAULT_RETRY_STRATEGY).data: self.availability_domains.append(i) def store_compartments(self): for compartment in self.list_compartments(): self.compartments.append(compartment) def get_compartment_path_name(self, compartment_id): temp = "" id = compartment_id while id != self.compartment_id: compartment = self.get_compartment_details(id) temp = compartment.name + "/" + temp id = compartment.compartment_id return temp def get_compartment_details(self, compartment_id): return [compartment for compartment in self.compartments if compartment.id == compartment_id][0] #List all compartments def list_compartments(self): return oci.pagination.list_call_get_all_results(self.identity.list_compartments,self.compartment_id,compartment_id_in_subtree=True, retry_strategy=oci.retry.DEFAULT_RETRY_STRATEGY).data # List all users with pagination def list_users(self): users = self.identity.list_users(self.compartment_id) for user in users.data: self.users.append(user) while users.has_next_page: users = self.identity.list_users(self.compartment_id,page = users.next_page) for user in users.data: self.users.append(user) return self.users # Get local Users with User class logic def get_local_users(self): local_users = list() for user in self.users: user_obj = User(user) if user_obj.is_user_local(): local_users.append(user) return local_users # Invalid users are the ones who is not local and not service users. # Fetch it from the User class logic def get_invalid_users(self): invalid_users = list() for user in self.users: user_obj = User(user) if not user_obj.is_user_valid(): invalid_users.append(user) return invalid_users # Get service users from User class def get_service_users(self): service_users = list() for user in self.users: user_obj = User(user) if user_obj.is_user_service(): service_users.append(user) return service_users