def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.get_cluster_status(True, cmd_line_args.ClusterID) if capella_api_response.status_code == 200: # Cluster information was found print( "Status for cluster with ID " + cmd_line_args.ClusterID + " is " + capella_api_response.json()['status']) else: print("Failed to get status for cluster ID " + cmd_line_args.ClusterID) print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def get_db_users(pod, tenant, cluster_id, page=1, limit=100): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.get_db_users(tenant.id, tenant.project_id, cluster_id, page, limit) return json.loads(resp.content)
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.delete_project( cmd_line_args.projectID) if capella_api_response.status_code == 204: # Our project was created print("Deleted project with ID " + cmd_line_args.projectID) else: print("Failed to delete project with ID " + cmd_line_args.projectID) print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def destroy_cluster(cluster): capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.delete_cluster(cluster.id) if resp.status_code != 202: raise Exception("Deleting Capella Cluster Failed.") time.sleep(10) while True: resp = capella_api.get_cluster_internal(cluster.tenant.id, cluster.tenant.project_id, cluster.id) content = json.loads(resp.content) if content.get("data"): CapellaUtils.log.info( "Cluster status %s: %s" % (cluster.cluster_config.get("name"), content.get("data").get("status").get("state"))) if content.get("data").get("status").get( "state") == "destroying": time.sleep(5) continue elif content.get("message") == 'Not Found.': CapellaUtils.log.info("Cluster is destroyed.") cluster.tenant.clusters.pop(cluster.id) break
def create_cluster(pod, tenant, cluster_details, timeout=1800): end_time = time.time() + timeout while time.time() < end_time: subnet = CapellaUtils.get_next_cidr() + "/20" CapellaUtils.log.info("Trying with cidr: {}".format(subnet)) cluster_details["place"]["hosted"].update({"CIDR": subnet}) cluster_details.update({"projectId": tenant.project_id}) capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) capella_api_resp = capella_api.create_cluster(cluster_details) # Check resp code , 202 is success if capella_api_resp.status_code == 202: break else: CapellaUtils.log.critical("Create capella cluster failed.") CapellaUtils.log.critical("Capella API returned " + str(capella_api_resp.status_code)) CapellaUtils.log.critical(capella_api_resp.json()["message"]) cluster_id = capella_api_resp.headers['Location'].split("/")[-1] CapellaUtils.log.info("Cluster created with cluster ID: {}"\ .format(cluster_id)) CapellaUtils.wait_until_done(pod, tenant, cluster_id, "Creating Cluster {}".format( cluster_details.get("clusterName")), timeout=timeout) cluster_srv = CapellaUtils.get_cluster_srv(pod, tenant, cluster_id) CapellaUtils.allow_my_ip(pod, tenant, cluster_id) servers = CapellaUtils.get_nodes(pod, tenant, cluster_id) return cluster_id, cluster_srv, servers
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.get_cluster_info( False, cmd_line_args.ClusterID) if capella_api_response.status_code == 200: # Cluster information was found print("Got information for cluster ID " + cmd_line_args.ClusterID) print(json.dumps(capella_api_response.json(), indent=3)) else: print("Failed to get information for cluster ID " + cmd_line_args.ClusterID) print("Capella API returned " + str(capella_api_response.status_code)) else: print("Check Capella API is up.")
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') bucket_configuration = { "replicas": cmd_line_args.replicas, "name": cmd_line_args.name, "memoryQuota": cmd_line_args.memory_quota } # Create the bucket capella_api_response = cappella_api.create_cluster_bucket( cmd_line_args.cluster_id, bucket_configuration) # Check response code , 201 is success if capella_api_response.status_code == 201: print("Creating bucket ") else: print("Failed to create bucket ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"])
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.get_cluster_certificate( False, cmd_line_args.ClusterID) if capella_api_response.status_code == 200: # Cluster certificate was found print("Cluster certificate:\n" + capella_api_response.json()['certificate']) else: print("Failed to get certificate for cluster ID " + cmd_line_args.ClusterID) print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def get_all_buckets(cluster): capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.get_buckets(cluster.tenant.id, cluster.tenant.project_id, cluster.id) return resp
def main(CmdLineArgs): # This represents the new server service configuration new_server_service_configuration = { "servers": [{ "compute": "m5.xlarge", "size": 3, "services": ["data"], "storage": { "size": 300, "IOPS": 3000, "type": "GP3" } }] } cappella_api = CapellaAPI() if CmdLineArgs.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check API is up if cappella_api.api_status().status_code == 200: # Show the current cluster configuration # first we'll need to get the configuration capella_api_response = cappella_api.get_cluster_info( True, CmdLineArgs.ClusterID) #Then pass the bit we're interested in to the function that will display it if capella_api_response.status_code == 200: print('Current cluster configuration') show_cluster_server_configuration( capella_api_response.json()['servers']) # Now we will tell the API to change the configuration capella_api_response = cappella_api.update_cluster_servers( CmdLineArgs.ClusterID, new_server_service_configuration) # Check response code , 201 is success if capella_api_response.status_code == 202: # Got a response back print("Changing cluster to ") show_cluster_server_configuration( new_server_service_configuration['servers']) else: print("Failed to change the cluster configuration ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') cluster_configuration = { "environment": "hosted", "clusterName": cmd_line_args.clusterName, "description": "Example hosted cluster create from Public API", "projectId": cmd_line_args.projectID, "place": { "singleAZ": False, "hosted": { "provider": "aws", "CIDR": "10.199.0.0/20", "region": "us-east-2" } }, "servers": [ { "compute": "m5.xlarge", "size": 3, "services": ["data", "index", "search", "query"], "storage": { "size": 50, "IOPS": 3000, "type": "GP3" }, } ], "supportPackage": { "timezone": "GMT", "type": "DeveloperPro" }, "version": "latest", } # Create the cluster, indicate that this is a hosted cluster by calling with True # and pass the configuration capella_api_response = cappella_api.create_cluster(True, cluster_configuration) # Check response code , 202 is success if capella_api_response.status_code == 202: print("Creating cluster ") print("Check deployment status here: " + cappella_api.API_BASE_URL + capella_api_response.headers['Location'] + '/status') else: print("Failed to create cluster ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"])
def main(CmdLineArgs): cappella_api = CapellaAPI() if CmdLineArgs.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check the status of the API, response code = 200 is success if cappella_api.api_status().status_code == 200: # Work out the bucket ID # which is the base64 value of the bucket name bucketName_bytes = CmdLineArgs.bucketName.encode('ascii') base64_bytes = base64.b64encode(bucketName_bytes) bucketName_base64 = base64_bytes.decode('ascii') # Get the current cluster buckets capella_api_response = cappella_api.get_cluster_buckets( CmdLineArgs.ClusterID) # We got the buckets, now check that we have the one we want to update if capella_api_response.status_code == 200: cluster_buckets = capella_api_response.json() found_bucket = False for cluster_bucket in cluster_buckets: if cluster_bucket['name'] == CmdLineArgs.bucketName: cluster_bucket['memoryQuota'] = CmdLineArgs.MemoryQuota found_bucket = True # Now update the bucket capella_api_response = cappella_api.update_cluster_bucket( CmdLineArgs.ClusterID, bucketName_base64, cluster_bucket) # Did the update work? if capella_api_response.status_code == 202: print("Bucket memory quota is being updated ") else: print("Failed to update bucket ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) if not found_bucket: # We didn't find the bucket to update print("Unable to find " + CmdLineArgs.bucketName + " to update on this cluster") else: print("This cluster cannot be found") print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def create_project(pod, tenant, name): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.create_project(tenant.id, name) if resp.status_code != 201: raise Exception("Creating capella project failed: {}".format( resp.content)) project_id = json.loads(resp.content).get("id") tenant.project_id = project_id CapellaUtils.log.info("Project ID: {}".format(project_id))
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') capella_api_response = cappella_api.get_clusters() # Check response code , 200 is success if capella_api_response.status_code == 200: clusters_table_rows = [] # There could not be any clusters, lets check if that's the case if capella_api_response.json()['data'] == {}: cluster_entries = None print("No clusters found") else: cluster_entries = capella_api_response.json()['data']['items'] # Got a list of clusters, just double check that we do have entries cluster_table_heading = [ 'Environment', 'Name', 'Cluster ID', 'Cloud ID', 'Project ID' ] for cluster_entry in cluster_entries: cluster_environment = cluster_entry['environment'] cluster_id = cluster_entry['id'] cluster_name = cluster_entry['name'] project_id = cluster_entry['projectId'] # if the cluster is inVPC, then we will have a cloud ID if cluster_environment == 'inVpc': clusterCloudID = cluster_entry['cloudId'] else: clusterCloudID = 'N/A' # Put the completed row in the table clusters_table_rows.append([ cluster_environment, cluster_name, cluster_id, clusterCloudID, project_id ]) # Display the table, which uses pretty table to make things easier print('Capella Clusters ') print(pretty_table(cluster_table_heading, clusters_table_rows)) else: print("Failed to get list of clusters ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"])
def get_cluster_info(pod, tenant, cluster_id): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.get_cluster_info(cluster_id) if resp.status_code != 200: CapellaUtils.log.critical("LOG A BUG: Fetch Cluster API returns :\ {}".format(resp.status_code)) print(resp.content) time.sleep(5) return CapellaUtils.get_cluster_info(pod, tenant, cluster_id) return json.loads(resp.content)
def get_bucket_id(cluster, name): capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.get_buckets(cluster.tenant.id, cluster.tenant.project_id, cluster.id) content = json.loads(resp.content) bucket_id = None for bucket in content.get("buckets").get("data"): if bucket.get("data").get("name") == name: bucket_id = bucket.get("data").get("id") return bucket_id
def allow_my_ip(pod, tenant, cluster_id): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.allow_my_ip(tenant.id, tenant.project_id, cluster_id) if resp.status_code != 202: result = json.loads(resp.content) if result["errorType"] == "ErrAllowListsCreateDuplicateCIDR": CapellaUtils.log.warn("IP is already added: %s" % result["message"]) return CapellaUtils.log.critical(resp.content) raise Exception("Adding allowed IP failed.")
def update_bucket_settings(cluster, bucket_id, bucket_params): capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.update_bucket_settings(cluster.tenant.id, cluster.tenant.project_id, cluster.id, bucket_id, bucket_params) code = resp.status if 200 > code or code >= 300: CapellaUtils.log.critical("Bucket update failed: %s" % resp.content) return resp.status
def scale(cluster, new_config): capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) while True: resp = capella_api.update_cluster_servers(cluster.id, new_config) if resp.status_code != 202: result = json.loads(resp.content) if result["errorType"] == "ClusterModifySpecsInvalidState": CapellaUtils.wait_until_done( cluster.pod, cluster.tenant, cluster.id, "Wait for healthy cluster state") else: break
def flush_bucket(cluster, name): bucket_id = CapellaUtils.get_bucket_id(cluster, name) if bucket_id: capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.flush_bucket(cluster.tenant.id, cluster.tenant.project_id, cluster.id, bucket_id) if resp.status >= 200 and resp.status < 300: CapellaUtils.log.info("Bucket deleted successfully!") else: CapellaUtils.log.info(resp.content) else: CapellaUtils.log.info("Bucket not found.")
def delete_bucket(cluster, name): bucket_id = CapellaUtils.get_bucket_id(cluster, name) if bucket_id: capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.delete_bucket(cluster.tenant.id, cluster.tenant.project_id, cluster.id, bucket_id) if resp.status_code == 204: CapellaUtils.log.info("Bucket deleted successfully!") else: CapellaUtils.log.critical(resp.content) raise Exception("Bucket {} cannot be deleted".format(name)) else: CapellaUtils.log.info("Bucket not found.")
def get_nodes(pod, tenant, cluster_id): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.get_nodes(tenant.id, tenant.project_id, cluster_id) if resp.status_code != 200: CapellaUtils.log.critical( "LOG A BUG: Fetch Cluster Node API returns :\ {}".format(resp.status_code)) print(resp.content) time.sleep(5) return CapellaUtils.get_nodes(pod, tenant, cluster_id) CapellaUtils.log.info(json.loads(resp.content)) return [ server.get("data") for server in json.loads(resp.content).get("data") ]
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') cluster_allowlist_configuration = { "cidrBlock": cmd_line_args.CidrBlock, "ruleType": cmd_line_args.RuleType.lower(), } if cmd_line_args.RuleType.lower() == 'temporary': cluster_allowlist_configuration["duration"] = str( cmd_line_args.Duration) + "h0m0s" if cmd_line_args.RuleType.lower() == 'permanent': # If rule is permanent , Duration should not be given # Will look into seeing if arg parser can deal with this # For now, the check is here if cmd_line_args.Duration is not None: raise AllowlistRuleError( "Duration is not a permitted option for allow list when type is permanent" ) if cmd_line_args.Comment is not None: cluster_allowlist_configuration["comment"] = cmd_line_args.Comment # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.create_cluster_allowlist( cmd_line_args.ClusterID, cluster_allowlist_configuration) if capella_api_response.status_code == 202: print("Allow list is being created") else: print("Failed to create allowlist ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') cluster_configuration = { "cloudId": cmd_line_args.cloudID, "name": cmd_line_args.clusterName, "projectId": cmd_line_args.projectID, "servers": [ { "services": [ "data", "index", "query", "search" ], "size": 3, "aws": { "ebsSizeGib": 50, "instanceSize": "m5.xlarge" } } ], "version": "latest" } # Create the cluster, pass the configuration # and indicate that this cluster will run in the customers own cloud by calling with False capella_api_response = cappella_api.create_cluster(False, cluster_configuration) # Check response code , 201 is success if capella_api_response.status_code == 202: print("Creating cluster ") print("Check deployment status here: " + cappella_api.API_BASE_URL + capella_api_response.headers['Location'] + '/status') else: print("Failed to create cluster ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"])
def create_db_user(pod, tenant, cluster_id, user, pwd): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.create_db_user(tenant.id, tenant.project_id, cluster_id, user, pwd) if resp.status_code != 200: result = json.loads(resp.content) CapellaUtils.log.critical( "Add capella cluster user failed: (}".format(resp.status_code)) CapellaUtils.log.critical(result) if result["errorType"] == "ErrDataplaneUserNameExists": CapellaUtils.log.warn("User is already added: %s" % result["message"]) return CapellaUtils.create_db_user(pod, tenant, cluster_id, user, pwd) CapellaUtils.log.critical(json.loads(resp.content)) CapellaUtils.log.info(json.loads(resp.content)) return json.loads(resp.content)
def create_bucket(cluster, bucket_params): while True: state = CapellaUtils.get_cluster_state(cluster.pod, cluster.tenant, cluster.id) if state == "healthy": break time.sleep(1) capella_api = CapellaAPI(cluster.pod.url_public, cluster.tenant.api_secret_key, cluster.tenant.api_access_key, cluster.tenant.user, cluster.tenant.pwd) resp = capella_api.create_bucket(cluster.tenant.id, cluster.tenant.project_id, cluster.id, bucket_params) if resp.status_code in [200, 201, 202]: CapellaUtils.log.info("Bucket create successfully!") else: CapellaUtils.log.critical("Bucket creation failed: {}, {}".format( resp.status_code, resp.content)) raise Exception("Bucket creation failed")
def jobs(pod, tenant, cluster_id): capella_api = CapellaAPI(pod.url_public, tenant.api_secret_key, tenant.api_access_key, tenant.user, tenant.pwd) resp = capella_api.jobs(tenant.project_id, tenant.id, cluster_id) if resp.status_code != 200: CapellaUtils.log.critical("LOG A BUG: Internal API returns :\ {}".format(resp.status_code)) print(resp.content) time.sleep(5) return CapellaUtils.jobs(pod, tenant, cluster_id) try: content = json.loads(resp.content) except Exception as e: CapellaUtils.log.critical("LOG A BUG: Internal API returns :\ {}".format(resp.status_code)) print(resp.content) time.sleep(5) return CapellaUtils.jobs(pod, tenant, cluster_id) return content
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.get_cluster_buckets(cmd_line_args.ClusterID) # Check response code , 200 is success if capella_api_response.status_code == 200: bucket_table_rows = [] list_of_buckets = capella_api_response.json() # We should have a list of buckets, but just in case, check # Then we will build rows to show in a table if list_of_buckets is not None: # Check to see if we got any buckets back if len(list_of_buckets) > 0: for bucket in list_of_buckets: bucket_table_rows.append(bucket.values()) print('Buckets') print(pretty_table(list_of_buckets[0].keys(), bucket_table_rows)) else: print("No buckets found") else: print("No buckets found") else: print("Failed to get buckets ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def main(cmd_line_args): cappella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') cappella_api.set_logging_level('DEBUG') else: capella_logging('info') # Check Capella API status if cappella_api.api_status().status_code == 200: capella_api_response = cappella_api.get_projects() # Check response code , 200 is success if capella_api_response.status_code == 200: project_table_rows = [] list_of_projects = capella_api_response.json() for project in list_of_projects['data']: project_table_rows.append([ project['name'], maya.parse(project['createdAt']), project['id'] ]) # Table heading / rows for the output project_table_headings = ['Name', 'Created at', 'ID'] print('Projects') print(pretty_table(project_table_headings, project_table_rows)) else: print("Failed to get projects ") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")
def main(cmd_line_args): capella_api = CapellaAPI() if cmd_line_args.debug: capella_logging('debug') capella_api.set_logging_level('DEBUG') else: capella_logging('info') cluster_user_struct = { "password": cmd_line_args.Password, "username": cmd_line_args.UserName, } # Split up into the individual bits we need all_bucket_access = cmd_line_args.Access.strip() # Look at the access requested and then map to what the endpoint expects if all_bucket_access == 'r': cluster_user_struct['allBucketsAccess']="data_reader" elif all_bucket_access == 'w': cluster_user_struct['allBucketsAccess']="data_writer" else: raise UserBucketAccessListError('access not found') # Check Capella API status if capella_api.api_status().status_code == 200: capella_api_response = capella_api.create_cluster_user(False, cmd_line_args.ClusterID, cluster_user_struct) if capella_api_response.status_code == 201: print("Cluster user is being created") else: print("Failed to create user") print("Capella API returned " + str(capella_api_response.status_code)) print("Full error message") print(capella_api_response.json()["message"]) else: print("Check Capella API is up.")