class ComputeClientRoutes(TestCase):
def setUp(self):
self.server = ServerThread(app)
self.server.start()
self.oci_config = get_oci_config()
self.compute_cli = ComputeClient(
config=self.oci_config["config"],
service_endpoint="http://localhost:12000")
self.compute_cli_composite_op = ComputeClientCompositeOperations(
self.compute_cli)
self.test_instance = create_instance(
self.oci_config["compartment_id"],
self.compute_cli_composite_op,
"dummy-instance",
)
def test_terminate_instance(self):
response: Response = self.compute_cli.terminate_instance(
self.test_instance.id)
self.assertEqual(response.status, 204)
sleep(5)
with self.assertRaises(ServiceError) as e:
self.compute_cli.get_instance(self.test_instance.id)
self.assertEqual(e.exception.status, 404)
def test_terminate_non_existent_instance(self):
with self.assertRaises(ServiceError) as e:
self.compute_cli.get_instance("non_existent_instance")
self.assertEqual(e.exception.status, 404)
def tearDown(self):
self.server.shutdown()
def __init__(self):
config = {}
try:
signer = Config.signer
self.compute_client = ComputeClient(config=config, signer=signer)
except Exception:
config = Config.config
self.compute_client = ComputeClient(config)
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_instances(client: ComputeClient = None,
compartment_id: str = None) -> List[OCIInstance]:
"""Return a complete, unfiltered list of instances in the compartment."""
instances = []
instances_raw = client.list_instances(compartment_id=compartment_id)
instances.extend(instances_raw.data)
while instances_raw.has_next_page:
instances_raw = client.list_instances(compartment_id=compartment_id,
page=instances_raw.next_page)
instances.extend(instances_raw.data)
return instances
class Instance:
def __init__(self):
config = {}
try:
signer = Config.signer
self.compute_client = ComputeClient(config=config, signer=signer)
except Exception:
config = Config.config
self.compute_client = ComputeClient(config)
# Request to list all volume attachments
def list_volume_attachments(self, compartment_id):
try:
return list_call_get_all_results(
self.compute_client.list_volume_attachments,
compartment_id).data
except ServiceError as identifier:
print(identifier)
# logger.error(identifier.message)
exit()
def list_boot_volume_attachments(self, ad, compartment_id):
return list_call_get_all_results(
self.compute_client.list_boot_volume_attachments, ad,
compartment_id).data
def get_instance_details(self, instance_id):
try:
instance_data = self.compute_client.get_instance(instance_id).data
except Exception as e:
if (e.status == 404):
print(f"Instance Id {instance_id} is incorrect; Status: 404")
# logger.error(f"Instance Id {instance_id} is incorrect; Status: 404")
else:
print(
f"Not authorized for {instance_id}; Status: {str(e.status)}"
)
# logger.error(f"Not authorized for {instance_id}; Status: {str(e.status)}")
raise
return instance_data
# gets the instance tag and caches the instance tags to reduce number of request
def get_instance_tags(self, instance_id):
instance_details = self.compute_client.get_instance(instance_id).data
tags = dict()
tags["defined_tags"] = instance_details.defined_tags
tags["freeform_tags"] = instance_details.freeform_tags
return tags
def performChangeCompartment():
global compute_client
global work_request_client
global availability_domain
try:
# read oci config
config = oci.config.from_file()
# create ComputeClient() with configuration
compute_client = ComputeClient(config)
# create WorkRequestClient() with configuration
work_request_client = WorkRequestClient(config)
response = getInstanceResponse()
availability_domain = response.data.availability_domain
source_compartment_id = response.data.compartment_id
if source_compartment_id == target_compartment_id:
errorExit(" Source and target compartment ids are same !")
# List instance info before move
info(' ')
info(' Instance info before compartment move : ')
info(' ETag : ' + response.headers['etag'])
printInstanceInfo(source_compartment_id)
# create ChangeInstanceCompartmentDetails() with compartment_id
compartment_details = ChangeInstanceCompartmentDetails()
compartment_details.compartment_id = target_compartment_id
info(' ')
info(' Moving Instance to target compartment ...')
# call change_instance_compartment() on ComputeClient
response = compute_client.change_instance_compartment(
instance_id,
compartment_details,
if_match=if_match,
opc_retry_token=opc_retry_token)
# List instance info after move
waitForMoveCompletion(response)
info(' ')
info(' Instance info after compartment move : ')
if 'etag' in response.headers.keys():
info(' ETag : ' + response.headers['etag'])
printInstanceInfo(target_compartment_id)
successExit()
except Exception:
info(' Unexpected error ')
raise
class ComputeClientRoutes(TestCase):
def setUp(self):
self.server = ServerThread(app)
self.server.start()
self.oci_config = get_oci_config()
self.compute_cli = ComputeClient(
config=self.oci_config["config"],
service_endpoint="http://localhost:12000")
self.compute_cli_composite_op = ComputeClientCompositeOperations(
self.compute_cli)
self.test_instance = create_instance(
self.oci_config["compartment_id"],
self.compute_cli_composite_op,
"dummy-instance",
)
def test_list_instances_without_params(self):
response: Response = self.compute_cli.list_instances(
self.oci_config["compartment_id"])
self.assertEqual(response.status, 200)
self.assertIsInstance(response.data, list)
self.assertEqual(len(response.data), 1)
def test_list_instances_with_params(self):
response: Response = self.compute_cli.list_instances(
self.oci_config["compartment_id"], display_name="dummy-instance")
self.assertEqual(response.status, 200)
self.assertIsInstance(response.data, list)
self.assertEqual(len(response.data), 1)
instances: List[Instance] = response.data
test_instance = instances[0]
self.assertEqual(test_instance.display_name,
self.test_instance.display_name)
response: Response = self.compute_cli.list_instances(
self.oci_config["compartment_id"], display_name="oopsss")
self.assertEqual(response.status, 200)
self.assertIsInstance(response.data, list)
self.assertEqual(len(response.data), 0)
def tearDown(self):
terminate_instance(self.test_instance.id, self.compute_cli)
self.server.shutdown()
def setUp(self):
self.server = ServerThread(app)
self.server.start()
self.oci_config = get_oci_config()
self.compute_cli = ComputeClient(
config=self.oci_config["config"],
service_endpoint="http://localhost:12000")
self.compute_cli_composite_op = ComputeClientCompositeOperations(
self.compute_cli)
self.test_instance = create_instance(
self.oci_config["compartment_id"],
self.compute_cli_composite_op,
"dummy-instance",
)
def compute(self):
try:
return ComputeClient(self.config)
except oci.exceptions.ClientError as err:
print(err, file=sys.stderr)
sys.exit(1)
def run_job(self):
self.status = SUCCESS
self.log_callback.info('Creating image.')
self.request_credentials([self.account])
credentials = self.credentials[self.account]
config = {
'user': self.oci_user_id,
'key_content': credentials['signing_key'],
'fingerprint': credentials['fingerprint'],
'tenancy': self.tenancy,
'region': self.region
}
compute_client = ComputeClient(config)
compute_composite_client = ComputeClientCompositeOperations(
compute_client)
object_name = self.status_msg['object_name']
namespace = self.status_msg['namespace']
self.cloud_image_name = self.status_msg['cloud_image_name']
image_source_details = ImageSourceViaObjectStorageTupleDetails(
bucket_name=self.bucket,
namespace_name=namespace,
object_name=object_name,
source_image_type=self.image_type,
operating_system=self.operating_system,
operating_system_version=self.operating_system_version)
image_details = CreateImageDetails(
compartment_id=self.compartment_id,
display_name=self.cloud_image_name,
image_source_details=image_source_details,
launch_mode=self.launch_mode)
retry_strategy = RetryStrategyBuilder(
max_attempts=self.max_oci_attempts,
service_error_retry_config={
'service_error_retry_config': {
400: ['LimitExceeded']
}
}).get_retry_strategy()
response = compute_composite_client.create_image_and_wait_for_state(
create_image_details=image_details,
wait_for_states=[Image.LIFECYCLE_STATE_AVAILABLE],
operation_kwargs={'retry_strategy': retry_strategy},
waiter_kwargs={'max_wait_seconds': self.max_oci_wait_seconds})
self.status_msg['image_id'] = response.data.id
self.log_callback.info(
'Created image has ID: {0}.'.format(object_name))
def cleanup_image(self, credentials, image_id):
self.log_callback.info(
'Cleaning up image: {0} in region: {1}.'.format(
self.cloud_image_name,
self.region
)
)
config = {
'user': self.oci_user_id,
'key_content': credentials['signing_key'],
'fingerprint': credentials['fingerprint'],
'tenancy': self.tenancy,
'region': self.region
}
compute_client = ComputeClient(config)
compute_composite_client = ComputeClientCompositeOperations(
compute_client
)
retry_strategy = RetryStrategyBuilder(
max_attempts=self.max_oci_attempts,
service_error_retry_config={
'service_error_retry_config': {400: ['LimitExceeded']}
}
).get_retry_strategy()
try:
compute_composite_client.delete_image_and_wait_for_state(
image_id=image_id,
wait_for_states=[
Image.LIFECYCLE_STATE_DELETED
],
operation_kwargs={'retry_strategy': retry_strategy},
waiter_kwargs={'max_wait_seconds': self.max_oci_wait_seconds}
)
except Exception as error:
msg = 'Failed to cleanup image: {0}'.format(error)
self.add_error_msg(msg)
self.log_callback.warning(msg)
class ComputeClientRoutes(TestCase):
def setUp(self):
self.server = ServerThread(app)
self.server.start()
self.oci_config = get_oci_config()
self.compute_cli = ComputeClient(
config=self.oci_config["config"],
service_endpoint="http://localhost:12000")
self.compute_cli_composite_op = ComputeClientCompositeOperations(
self.compute_cli)
self.test_instance = create_instance(
self.oci_config["compartment_id"],
self.compute_cli_composite_op,
"dummy-instance",
)
def test_perform_action(self):
response: Response = self.compute_cli.list_instances(
self.oci_config["compartment_id"], display_name="dummy-instance")
instances: List[Instance] = response.data
test_instance = instances[0]
for action in list(InstanceAction.__members__.keys()):
response: Response = self.compute_cli.instance_action(
test_instance.id, action=action)
assert response.status == 200
assert response.data
assert response.data.id == test_instance.id
def test_perform_action_on_nonexistent_instance(self):
with self.assertRaises(ServiceError) as e:
self.compute_cli.instance_action("non_existent_instance",
action="RESET")
self.assertEqual(e.exception.status, 404)
def test_perform_invalid_action(self):
with self.assertRaises(ServiceError) as e:
self.compute_cli.instance_action("dummy-instance",
action="CRAZY_DUDE")
self.assertEqual(e.exception.status, 404)
def tearDown(self):
terminate_instance(self.test_instance.id, self.compute_cli)
self.server.shutdown()
class Instance:
def __init__(self):
config = {}
try:
signer = Config.signer
self.compute_client = ComputeClient(config=config, signer=signer)
except Exception:
config = Config.config
self.compute_client = ComputeClient(config)
# Request to list all volume attachments
def list_volume_attachments(self, compartment_id):
try:
return list_call_get_all_results(
self.compute_client.list_volume_attachments,
compartment_id,
retry_strategy=oci.retry.DEFAULT_RETRY_STRATEGY,
).data
except ServiceError as identifier:
logging.error(traceback.format_exc())
logging.error(identifier + " " + compartment_id)
exit()
def get_instance_details(self, instance_id):
try:
instance_data = self.compute_client.get_instance(
instance_id, retry_strategy=oci.retry.DEFAULT_RETRY_STRATEGY
).data
except Exception as e:
if e.status == 404:
logging.error(f"Instance Id {instance_id} is incorrect; Status: 404")
else:
logging.error(
f"Not authorized for {instance_id}; Status: {str(e.status)}"
)
raise
return instance_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(
print("Usage: stop_instance.py ocid")
sys.exit(-1)
else:
print("Running with: ")
print("Instance OCID: {}".format(sys.argv[1]))
print("")
#
# Main
#
print("")
controlla_params()
validate_config(config)
print("Validate config OK")
ocid = sys.argv[1]
client = ComputeClient(config)
print('Stopping instance...')
client.instance_action(ocid, 'STOP')
print("Instance to be stopped !")
print("")
def terminate_instance(instance_id: str, compute_client: ComputeClient) -> None:
compute_client.terminate_instance(instance_id)
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
'the AD where the pool will be spun up (the pool in this example only spans a single AD)',
required=True)
parser.add_argument('--subnet-id', help='the ', required=True)
parser.add_argument('--image-id',
help='the image ID to use for instances',
required=True)
args = parser.parse_args()
# create the compute management client
compute_management_client = ComputeManagementClient(config)
# create the compute client
compute_client = ComputeClient(config)
launch_details = InstanceConfigurationLaunchInstanceDetails(
compartment_id=args.compartment_id,
display_name="some instance name",
shape="VM.Standard2.1",
source_details=InstanceConfigurationInstanceSourceViaImageDetails(
image_id=args.image_id),
create_vnic_details=InstanceConfigurationCreateVnicDetails())
instance_details = ComputeInstanceDetails(launch_details=launch_details,
block_volumes=[
_create_block_volume_details(
args.compartment_id,
args.availability_domain)
])
exit() if len(sys.argv) != 3: printUsage() action = sys.argv[1].upper() instancePrefix = sys.argv[2] print action if action != "-START" and action != "-STOP" and action !="-LIST": printUsage config = from_file() compute = ComputeClient(config) instances =[] state = "RUNNING" checkpoint_compartment="ocid1.compartment.oc1..aaaaaaaaowoexmvnos6b7e6csjshxkim4nu2fhte3cyttyp6cg5alwmf4csq" frontline_compartment = "ocid1.tenancy.oc1..aaaaaaaago6llvabe46trovlahpyfeakbovwbogudjprbts3gxwstplxtyxq" # response = compute.list_instances(compartment_id=frontline_compartment) response = compute.list_instances(compartment_id=checkpoint_compartment) for instance in response.data: if fnmatch(instance.display_name, instancePrefix): if action == "-LIST" : print instance.display_name.ljust(32) + " " + instance.lifecycle_state print instance if action == "-STOP" and instance.lifecycle_state == "RUNNING": print "stopping instance" ,instance.display_name state = "STOPPED" instances.append(instance)