def test_tenant_list(self, mock_get, mock_post): client = ContainerPlatformClient( username="******", password="******", api_host="127.0.0.1", api_port=8080, use_ssl=True, ) # Makes POST Request: https://127.0.0.1:8080/api/v1/login client.create_session() # Makes GET Request: https://127.0.0.1:8080/api/v1/tenant tenants = client.tenant.list() # Test that json response is saved in each Tenant object self.assertIsNotNone(client.tenant.list()[0].json) # Test TenantList subscriptable access and Tenant property setters self.assertEqual(tenants[0].id, "/api/v1/tenant/1") self.assertEqual(tenants[0].status, "ready") self.assertEqual(tenants[0].name, "Site Admin") self.assertEqual(tenants[0].description, "Site Admin Tenant for BlueData clusters") # Test TenantList iterators self.assertEqual( [tenant.id for tenant in client.tenant.list()], ["/api/v1/tenant/1", "/api/v1/tenant/2"], )
def test_get_k8shosts(self, mock_get, mock_post): client = ContainerPlatformClient( username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=True) # Makes POST Request: https://127.0.0.1:8080/api/v1/login client.create_session() # Makes GET Request: https://127.0.0.1:8080/api/v2/worker/k8shost/ workers = client.k8s_worker.list() # Test that json response is saved in each WorkerK8s object assert client.k8s_worker.list()[0].json is not None # Test WorkerK8sList subscriptable access and property setters assert workers[0].worker_id == 4 assert workers[0].status == WorkerK8sStatus.unlicensed.name assert workers[0].hostname == 'ip-10-1-0-238.eu-west-2.compute.internal' assert workers[0].ipaddr == '10.1.0.238' assert workers[0].href == '/api/v2/worker/k8shost/4' # Test WorkerK8sList iterators assert [ worker.worker_id for worker in client.k8s_worker.list() ] == [ 4, 5 ]
def test_epic_tenant_list(self, mock_post): client = ContainerPlatformClient( username="******", password="******", api_host="127.0.0.1", api_port=8080, use_ssl=True, ) client.create_session() client.config.auth( { "external_identity_server": { "bind_pwd": "5ambaPwd@", "user_attribute": "sAMAccountName", "bind_type": "search_bind", "bind_dn": "cn=Administrator,CN=Users,DC=samdom,DC=example,DC=com", "host": "1.1.1.1", "security_protocol": "ldaps", "base_dn": "CN=Users,DC=samdom,DC=example,DC=com", "verify_peer": False, "type": "Active Directory", "port": 636, } } )
def test_get_users(self, mock_get, mock_post): client = ContainerPlatformClient( username="******", password="******", api_host="127.0.0.1", api_port=8080, use_ssl=True, ) # Makes POST Request: https://127.0.0.1:8080/api/v1/login client.create_session() # Makes GET Request: https://127.0.0.1:8080/api/v1/user users = client.user.list() # Test that json response is saved in each WorkerK8s object assert users[0].json is not None # Test UserList subscriptable access and property setters assert users[0].is_service_account is False assert users[0].is_siteadmin is False assert users[0].default_tenant == "" assert users[0].is_external is False assert users[0].is_group_added_user is False assert users[0].name == "csnow" assert users[0].description == "chris" assert users[0]._links == {"self": {"href": "/api/v1/user/16"}}
def test_auth_ssl(self, mock_post): client = ContainerPlatformClient(username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=True) client.create_session()
def get_client(): client = ContainerPlatformClient( username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=True) client.create_session() return client
def test_create_from_env_var_factory_method_with_missing_env_values(self): try: ContainerPlatformClient.create_from_env() except ContainerPlatformClientException as expected: self.assertEqual( expected.message, "Required env var 'HPECP_PASSWORD' not found.", )
def test_create_from_env_var_factory_method_with_type_error(self): try: ContainerPlatformClient.create_from_env() except ContainerPlatformClientException as expected: self.assertEqual( expected.message, "invalid literal for int() with base 10: 'not_an_int'", )
def test_create_session(self, mock_post): client = ContainerPlatformClient(username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=False) self.assertIsInstance(client.create_session(), ContainerPlatformClient)
def test_auth_ssl(self, mock_post): client = ContainerPlatformClient( username="******", password="******", api_host="127.0.0.1", api_port=8080, use_ssl=True, ) client.create_session()
def test_auth_ssl_with_error(self, mock_post): client = ContainerPlatformClient(username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=True) with self.assertRaises(requests.exceptions.HTTPError): client.create_session()
def get_client(): client = ContainerPlatformClient( username="******", password="******", api_host="127.0.0.1", api_port=8080, use_ssl=True, ) client.create_session() return client
def mock_get_client(): client = ContainerPlatformClient( username="", password="", api_host="", api_port=9090, use_ssl=True, verify_ssl=True, warn_ssl=True, ) client.session_id = "ABC" client.k8s_worker.get = mock_k8s_worker_get client.k8s_worker.create_with_ssh_key = mock_create_with_ssh_key return client
def test_create_from_config_file_factory_method(self): file_data = dedent("""[default] api_host = 127.0.0.1 api_port = 8080 use_ssl = True verify_ssl = False warn_ssl = True username = admin password = admin123""") tmp = tempfile.NamedTemporaryFile(delete=True) try: tmp.write(file_data.encode('utf-8')) tmp.flush() client = ContainerPlatformClient.create_from_config_file( config_file=tmp.name) self.assertEqual(client.username, 'admin') self.assertEqual(client.password, 'admin123') self.assertEqual(client.api_host, '127.0.0.1') self.assertEqual(client.api_port, 8080) self.assertEqual(client.use_ssl, True) self.assertEqual(client.verify_ssl, False) self.assertEqual(client.warn_ssl, True) finally: tmp.close()
def get_client(start_session=True): """Retrieve a reference to an authenticated client object.""" client = ContainerPlatformClient.create_from_config_file( config_file=get_config_file(), profile=get_profile(), ) if start_session: client.create_session() return client
def get_client(): """Utility function to retrieve an authenticated client object""" try: client = ContainerPlatformClient.create_from_config_file( config_file=HPECP_CONFIG_FILE, profile=PROFILE) client.create_session() return client except APIException as e: print(e.message) sys.exit(1)
def test_create_from_env_var_factory_method_with_falses(self): client = ContainerPlatformClient.create_from_env() self.assertEqual(client.username, "test_username") self.assertEqual(client.password, "test_password") self.assertEqual(client.api_host, "test_apihost") self.assertEqual(client.api_port, 8080) self.assertEqual(client.use_ssl, False) self.assertEqual(client.verify_ssl, False) self.assertEqual(client.warn_ssl, False)
def test_create_session_chained(self, mock_post): client = ContainerPlatformClient( username="******", password="******", api_host="127.0.0.1", api_port=8080, use_ssl=False, ).create_session() self.assertIsInstance(client, ContainerPlatformClient)
def version(debug=False): """Display version information.""" print("HPECP Version: " + ContainerPlatformClient.version()) if debug: print("HPECP Bin Path: " + os.path.dirname(os.path.abspath(__file__))) print("HPECP Lib Path: " + os.path.dirname(os.path.abspath(hpecp.__file__))) print("Python Version: " + sys.version.replace("\n", "")) print("Python Exe Path: " + sys.executable) print("Python Path: " + os.pathsep.join(sys.path)) print("System Path: " + os.environ.get("PATH", ""))
#!/usr/bin/env python3 from hpecp import ContainerPlatformClient import time client = ContainerPlatformClient(username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=True, verify_ssl='/certs/hpecp-ca-cert.pem') client.create_session() license = client.license.get_license() print(license) print(client.license.delete_license(license['Licenses'][0]['LicenseKey'])) time.sleep(5) license = client.license.get_license() print(license)
def configure_cli(): controller_api_host = None controller_api_port = None controller_use_ssl = None controller_verify_ssl = None controller_warn_ssl = None controller_username = None controller_password = None config_path = os.path.join(os.path.expanduser("~"), ".hpecp.conf",) if os.path.exists(config_path): config_reader = ContainerPlatformClient.create_from_config_file() controller_api_host = config_reader.api_host controller_api_port = config_reader.api_port controller_use_ssl = config_reader.use_ssl controller_verify_ssl = config_reader.verify_ssl controller_warn_ssl = config_reader.warn_ssl controller_username = config_reader.username controller_password = config_reader.password sys.stdout.write("Controller API Host [{}]: ".format(controller_api_host)) tmp = input() if tmp != "": controller_api_host = tmp sys.stdout.write("Controller API Port [{}]: ".format(controller_api_port)) tmp = input() if tmp != "": controller_api_port = tmp sys.stdout.write( "Controller uses ssl (True|False) [{}]: ".format(controller_use_ssl) ) tmp = input() if tmp != "": controller_use_ssl = tmp sys.stdout.write( "Controller verify ssl (True|False) [{}]: ".format( controller_verify_ssl ) ) tmp = input() if tmp != "": controller_verify_ssl = tmp sys.stdout.write( "Controller warn ssl (True|False) [{}]: ".format(controller_warn_ssl) ) tmp = input() if tmp != "": controller_warn_ssl = tmp sys.stdout.write("Controller Username [{}]: ".format(controller_username)) tmp = input() if tmp != "": controller_username = tmp sys.stdout.write("Controller Password [{}]: ".format(controller_password)) tmp = input() if tmp != "": controller_password = tmp config = configparser.ConfigParser() config["default"] = OrderedDict() config["default"]["api_host"] = controller_api_host config["default"]["api_port"] = str(controller_api_port) config["default"]["use_ssl"] = str(controller_use_ssl) config["default"]["verify_ssl"] = str(controller_verify_ssl) config["default"]["warn_ssl"] = str(controller_warn_ssl) config["default"]["username"] = controller_username config["default"]["password"] = controller_password with open(config_path, "w",) as config_file: config.write(config_file)
try: with open('./generated/output.json') as f: j = json.load(f) except: print(80 * "*") print("ERROR: Can't parse: './generated/output.json'") print(80 * "*") sys.exit(1) controller_public_ip = j["controller_public_ip"]["value"] ad_server_private_ip = j["ad_server_private_ip"]["value"] client = ContainerPlatformClient(username='******', password='******', api_host=controller_public_ip, api_port=8080, use_ssl=True, verify_ssl=False) client.create_session() print("*" * 80) print("Current License:\n" + str(client.license.get_license())) print("*" * 80) print("Platform ID: " + client.license.get_platform_id()) print("*" * 80) lic = input("Paste License Text: ") with open('./generated/LICENSE', 'w') as out_file: out_file.write(lic)
#!/usr/bin/env python3 from hpecp import ContainerPlatformClient import os os.environ["LOG_LEVEL"] = "INFO" # Disable the SSL warnings - don't do this on productions! import urllib3 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) client = ContainerPlatformClient(username='******', password='******', api_host='127.0.0.1', api_port=8080, use_ssl=True, verify_ssl=False) client.create_session() host = client.worker.get_gateways()[0] print("Gateway: {} | {} | {} | {}".format( host['_links']['self']['href'], host['ip'], host['purpose'], host['state'] ))