def test_grant_password_request_with_login_hint(self): requests = FakeRequests() session = MockSession() with patch("oauth2_client.credentials_manager.requests", new=requests), patch( "cloudfoundry_client.client.requests", new=requests ): requests.Session.return_value = session self._mock_info_calls(requests) requests.post.return_value = MockResponse( "%s/oauth/token" % self.AUTHORIZATION_ENDPOINT, status_code=HTTPStatus.OK.value, text=json.dumps(dict(access_token="access-token", refresh_token="refresh-token")), ) client = CloudFoundryClient( self.TARGET_ENDPOINT, login_hint=quote(json.dumps(dict(origin="uaa"), separators=(",", ":"))) ) client.init_with_user_credentials("somebody", "p@s$w0rd") self.assertEqual("Bearer access-token", session.headers.get("Authorization")) requests.post.assert_called_with( requests.post.return_value.url, data=dict( grant_type="password", username="******", scope="", password="******", login_hint="%7B%22origin%22%3A%22uaa%22%7D", ), headers=dict(Accept="application/json", Authorization="Basic Y2Y6"), proxies=dict(http="", https=""), verify=True, )
def cf_get_client(username, password, endpoint, http_proxy="", https_proxy=""): target_endpoint = endpoint proxy = dict(http=http_proxy, https=https_proxy) client = CloudFoundryClient(target_endpoint, proxy=proxy) client.init_with_user_credentials(username, password) return client
def test_grant_password_request_with_token_format_opaque(self): requests = FakeRequests() session = MockSession() with patch('oauth2_client.credentials_manager.requests', new=requests), \ patch('cloudfoundry_client.client.requests', new=requests): requests.Session.return_value = session requests.get.return_value = MockResponse( '%s/v2/info' % TARGET_ENDPOINT, status_code=OK, text=json.dumps( dict(api_version='2.1', authorization_endpoint=TARGET_ENDPOINT))) requests.post.return_value = MockResponse( '%s/oauth/token' % TARGET_ENDPOINT, status_code=OK, text=json.dumps( dict(access_token='access-token', refresh_token='refresh-token'))) client = CloudFoundryClient(TARGET_ENDPOINT, token_format='opaque') client.init_with_user_credentials('somebody', 'p@s$w0rd') self.assertEqual('Bearer access-token', session.headers.get('Authorization')) requests.post.assert_called_with(requests.post.return_value.url, data=dict(grant_type='password', username='******', scope='', password='******', token_format='opaque'), headers=dict( Accept='application/json', Authorization='Basic Y2Y6'), proxies=dict(http='', https=''), verify=True)
def test_grant_password_request_with_login_hint(self): requests = FakeRequests() session = MockSession() with patch('oauth2_client.credentials_manager.requests', new=requests), \ patch('cloudfoundry_client.client.requests', new=requests): requests.Session.return_value = session self._mock_info_calls(requests) requests.post.return_value = MockResponse( '%s/oauth/token' % self.AUTHORIZATION_ENDPOINT, status_code=HTTPStatus.OK.value, text=json.dumps( dict(access_token='access-token', refresh_token='refresh-token'))) client = CloudFoundryClient(self.TARGET_ENDPOINT, login_hint=quote( json.dumps(dict(origin='uaa'), separators=(',', ':')))) client.init_with_user_credentials('somebody', 'p@s$w0rd') self.assertEqual('Bearer access-token', session.headers.get('Authorization')) requests.post.assert_called_with( requests.post.return_value.url, data=dict(grant_type='password', username='******', scope='', password='******', login_hint='%7B%22origin%22%3A%22uaa%22%7D'), headers=dict(Accept='application/json', Authorization='Basic Y2Y6'), proxies=dict(http='', https=''), verify=True)
def build_client_from_configuration(): global _client if _client is None: _init_logging() cfg = ConfigParser() cfg.read(get_resource('test.properties')) proxy = None try: http = cfg.get('proxy', 'http') https = cfg.get('proxy', 'https') proxy = dict(http=http, https=https) except (NoSectionError, NoOptionError): pass skip_verification = False try: skip_verification_str = cfg.get('service', 'skip_ssl_verification') skip_verification = skip_verification_str.lower() == 'true' except (NoSectionError, NoOptionError): pass client = CloudFoundryClient(cfg.get('service', 'target_endpoint'), proxy=proxy, skip_verification=skip_verification) client.init_with_user_credentials(cfg.get('authentification', 'login'), cfg.get('authentification', 'password')) client.org_guid = cfg.get('test_data', 'org_guid') client.space_guid = cfg.get('test_data', 'space_guid') client.app_guid = cfg.get('test_data', 'app_guid') client.log_app_guid = cfg.get('test_data', 'log_app_guid') client.service_guid = cfg.get('test_data', 'service_guid') client.service_name = cfg.get('test_data', 'service_name') client.plan_guid = cfg.get('test_data', 'plan_guid') client.creation_parameters = eval(cfg.get('test_data', 'creation_parameters')) client.update_parameters = eval(cfg.get('test_data', 'update_parameters')) _client = client return _client
def build_client_from_configuration(): global _client if _client is None: _init_logging() cfg = ConfigParser() cfg.read(get_resource('test.properties')) proxy = None try: http = cfg.get('proxy', 'http') https = cfg.get('proxy', 'https') proxy = dict(http=http, https=https) except (NoSectionError, NoOptionError): pass skip_verification = False try: skip_verification_str = cfg.get('service', 'skip_ssl_verification') skip_verification = skip_verification_str.lower() == 'true' except (NoSectionError, NoOptionError): pass client = CloudFoundryClient(cfg.get('service', 'target_endpoint'), proxy=proxy, skip_verification=skip_verification) client.init_with_user_credentials(cfg.get('authentification', 'login'), cfg.get('authentification', 'password')) client.org_guid = cfg.get('test_data', 'org_guid') client.space_guid = cfg.get('test_data', 'space_guid') client.app_guid = cfg.get('test_data', 'app_guid') client.log_app_guid = cfg.get('test_data', 'log_app_guid') client.service_guid = cfg.get('test_data', 'service_guid') client.service_name = cfg.get('test_data', 'service_name') client.plan_guid = cfg.get('test_data', 'plan_guid') client.creation_parameters = eval(cfg.get('test_data', 'creation_parameters')) client.update_parameters = eval(cfg.get('test_data', 'update_parameters')) _client = client return _client
def connect_to_cloud(endpoint_credentials): """ Connect to cloud foundry target api using the credentials """ client_cf = None try: logging.info(': Using API Endpoint: %s', endpoint_credentials[0]) proxy = { 'http': 'http://cis-india-pitc-bangalorez.proxy.corporate.ge.com:80', 'https': 'http://cis-india-pitc-bangalorez.proxy.corporate.ge.com:80' } client_cf = CloudFoundryClient(target_endpoint=endpoint_credentials[0], proxy=proxy, skip_verification=True) client_cf.init_with_user_credentials(endpoint_credentials[1], endpoint_credentials[2]) logging.info(': %s user logged into CloudFoundry', endpoint_credentials[1]) except (ConnectionResetError, ConnectionRefusedError, ConnectionAbortedError, OAuthError) as error_x: logging.info('In Except block of method cloud_connect:::: %s', error_x) exit_program() return client_cf
def loginCF(config): #cf login cf_endpoint = config.get('pcf_conf', 'endpoint') cf_user = config.get('pcf_conf', 'user') cf_passwd = config.get('pcf_conf', 'password') proxy = dict(http = os.environ.get('HTTP_PROXY', ''), https = os.environ.get('HTTPS_PROXY', '')) client = CloudFoundryClient(cf_endpoint, proxy = proxy, skip_verification = True) client.init_with_user_credentials(cf_user, cf_passwd) return client, client.service_information
def __init__(self, target_endpoint, username, password, organization_name, space_name): client = CloudFoundryClient(target_endpoint, skip_verification=False) client.init_with_user_credentials(username, password) self.client = client self.target_endpoint = target_endpoint self.organization_name = organization_name self.space_name = space_name self.space_guid = self.get_space_guid(self.organization_name, self.space_name)
def build_client_from_configuration(previous_configuration=None): dir_conf = os.path.join(os.path.expanduser("~")) if not os.path.isdir(dir_conf): if os.path.exists(dir_conf): raise IOError("%s exists but is not a directory") os.mkdir(dir_conf) config_file = os.path.join(dir_conf, ".cf_client_python.json") if not os.path.isfile(config_file): target_endpoint = _read_value_from_user( "Please enter a target endpoint", "Url must starts with http:// or https://", lambda s: s.startswith("http://") or s.startswith("https://"), default="" if previous_configuration is None else previous_configuration.get("target_endpoint", ""), ) skip_ssl_verification = _read_value_from_user( "Skip ssl verification (true/false)", "Enter either true or false", lambda s: s == "true" or s == "false", default="false" if previous_configuration is None else json.dumps(previous_configuration.get("skip_ssl_verification", False)), ) login = _read_value_from_user("Please enter your login") password = _read_value_from_user("Please enter your password") client = CloudFoundryClient(target_endpoint, skip_verification=(skip_ssl_verification == "true")) client.init_with_user_credentials(login, password) with open(config_file, "w") as f: f.write( json.dumps( dict( target_endpoint=target_endpoint, skip_ssl_verification=(skip_ssl_verification == "true"), refresh_token=client.refresh_token, ), indent=2, ) ) return client else: try: configuration = None with open(config_file, "r") as f: configuration = json.load(f) client = CloudFoundryClient( configuration["target_endpoint"], skip_verification=configuration["skip_ssl_verification"] ) client.init_with_token(configuration["refresh_token"]) return client except Exception as ex: if type(ex) == ConnectionError: raise else: _logger.exception("Could not restore configuration. Cleaning and recreating") os.remove(config_file) return build_client_from_configuration(configuration)
def get_cf_client(config): # "why is this a function, and the rest of these are static?" # good question. The __init__ on this immediately probes the # api endpoint, which means we need to stub it for testing. # and having to add that stub to every test that _might_ # `import extensions` would be bonkers. As a function, we should # only need to stub when we're actually thinking about CF logger.debug("getting cf client") client = CloudFoundryClient(config.CF_API_ENDPOINT) client.init_with_user_credentials(config.CF_USERNAME, config.CF_PASSWORD) return client
def dbname_get_cf_info(postgres_certification, cf_user, cf_passwd): client = CloudFoundryClient(cf_endpoint, proxy = proxy, skip_verification = True) client.init_with_user_credentials(cf_user, cf_passwd) sql_dbnames = 'SELECT datname FROM pg_database WHERE datistemplate = false;' conn = psycopg2.connect(postgres_certification) cur = conn.cursor() cur.execute(sql_dbnames) dbnames = cur.fetchall() conn.commit() for i in dbnames: if i[0] != 'template0' and i[0] != 'template1' and i[0] != 'postgres': getServiceInfo(client, i[0])
def build_client_from_configuration(previous_configuration=None): dir_conf = os.path.join(os.path.expanduser('~')) if not os.path.isdir(dir_conf): if os.path.exists(dir_conf): raise IOError('%s exists but is not a directory') os.mkdir(dir_conf) config_file = os.path.join(dir_conf, '.cf_client_python.json') if not os.path.isfile(config_file): target_endpoint = _read_value_from_user( 'Please enter a target endpoint', 'Url must starts with http:// or https://', lambda s: s.startswith('http://') or s.startswith('https://'), default='' if previous_configuration is None else previous_configuration.get('target_endpoint', '')) skip_ssl_verification = _read_value_from_user( 'Skip ssl verification (true/false)', 'Enter either true or false', lambda s: s == 'true' or s == 'false', default='false' if previous_configuration is None else json.dumps( previous_configuration.get('skip_ssl_verification', False))) login = _read_value_from_user('Please enter your login') password = _read_value_from_user('Please enter your password') client = CloudFoundryClient( target_endpoint, skip_verification=(skip_ssl_verification == 'true')) client.init_with_user_credentials(login, password) with open(config_file, 'w') as f: f.write( json.dumps(dict( target_endpoint=target_endpoint, skip_ssl_verification=(skip_ssl_verification == 'true'), refresh_token=client.refresh_token), indent=2)) return client else: try: configuration = None with open(config_file, 'r') as f: configuration = json.load(f) client = CloudFoundryClient( configuration['target_endpoint'], skip_verification=configuration['skip_ssl_verification']) client.init_with_token(configuration['refresh_token']) return client except Exception as ex: if type(ex) == ConnectionError: raise else: _logger.exception( "Could not restore configuration. Cleaning and recreating") os.remove(config_file) return build_client_from_configuration(configuration)
def connect_to_cloud(endpoint_credentials): """ Connect to cloud foundry target api using the credentials """ client_cf = None logging.info(': Using API Endpoint: %s', endpoint_credentials[0]) proxy = {'http': 'http://cis-india-pitc-bangalorez.proxy.corporate.ge.com:80', 'https': 'http://cis-india-pitc-bangalorez.proxy.corporate.ge.com:80'} client_cf = CloudFoundryClient(target_endpoint=endpoint_credentials[0], proxy=proxy, skip_verification=True) client_cf.init_with_user_credentials(endpoint_credentials[1], endpoint_credentials[2]) logging.info(': %s user logged into CloudFoundry', endpoint_credentials[1]) return client_cf
def get_cloudfoundry_client(self): if self.client is None: proxy = dict(http=os.environ.get('HTTP_PROXY', ''), https=os.environ.get('HTTPS_PROXY', '')) client = CloudFoundryClient(self.api_url, proxy=proxy) try: client.init_with_user_credentials(self.username, self.password) self.client = client except BaseException as e: msg = 'Failed to authenticate: {}, waiting 5 minutes and exiting'.format( str(e)) logging.error(msg) # The sleep is added to avoid automatically banning the user for too many failed login attempts time.sleep(5 * 60) return self.client
def build_client_from_configuration( previous_configuration: dict = None) -> CloudFoundryClient: config_file = get_config_file() if not os.path.isfile(config_file): target_endpoint = _read_value_from_user( "Please enter a target endpoint", "Url must starts with http:// or https://", lambda s: s.startswith("http://") or s.startswith("https://"), default="" if previous_configuration is None else previous_configuration.get("target_endpoint", ""), ) verify = _read_value_from_user( "Verify ssl (true/false)", "Enter either true or false", lambda s: s == "true" or s == "false", default="true" if previous_configuration is None else json.dumps( previous_configuration.get("verify", True)), ) login = _read_value_from_user("Please enter your login") password = _read_value_from_user("Please enter your password") client = CloudFoundryClient(target_endpoint, verify=(verify == "true")) client.init_with_user_credentials(login, password) with open(config_file, "w") as f: f.write( json.dumps(dict(target_endpoint=target_endpoint, verify=(verify == "true"), refresh_token=client.refresh_token), indent=2)) return client else: try: configuration = None with open(config_file, "r") as f: configuration = json.load(f) client = CloudFoundryClient(configuration["target_endpoint"], verify=configuration["verify"]) client.init_with_token(configuration["refresh_token"]) return client except Exception as ex: if type(ex) == ConnectionError: raise else: _logger.exception( "Could not restore configuration. Cleaning and recreating") os.remove(config_file) return build_client_from_configuration(configuration)
def build_client_from_configuration(previous_configuration=None): dir_conf = os.path.join(os.path.expanduser('~')) if not os.path.isdir(dir_conf): if os.path.exists(dir_conf): raise IOError('%s exists but is not a directory') os.mkdir(dir_conf) config_file = os.path.join(dir_conf, '.cf_client_python.json') if not os.path.isfile(config_file): target_endpoint = _read_value_from_user('Please enter a target endpoint', 'Url must starts with http:// or https://', lambda s: s.startswith('http://') or s.startswith('https://'), default='' if previous_configuration is None else previous_configuration.get('target_endpoint', '')) skip_ssl_verification = _read_value_from_user('Skip ssl verification (true/false)', 'Enter either true or false', lambda s: s == 'true' or s == 'false', default='false' if previous_configuration is None else json.dumps( previous_configuration.get('skip_ssl_verification', False))) login = _read_value_from_user('Please enter your login') password = _read_value_from_user('Please enter your password') client = CloudFoundryClient(target_endpoint, skip_verification=(skip_ssl_verification == 'true')) client.init_with_user_credentials(login, password) with open(config_file, 'w') as f: f.write(json.dumps(dict(target_endpoint=target_endpoint, skip_ssl_verification=(skip_ssl_verification == 'true'), refresh_token=client.refresh_token), indent=2)) return client else: try: configuration = None with open(config_file, 'r') as f: configuration = json.load(f) client = CloudFoundryClient(configuration['target_endpoint'], skip_verification=configuration['skip_ssl_verification']) client.init_with_token(configuration['refresh_token']) return client except Exception, ex: if type(ex) == ConnectionError: raise else: _logger.exception("Could not restore configuration. Cleaning and recreating") os.remove(config_file) return build_client_from_configuration(configuration)
def build_client_from_configuration( previous_configuration: dict = None) -> CloudFoundryClient: config_file = get_config_file() if not os.path.isfile(config_file): target_endpoint = _read_value_from_user( 'Please enter a target endpoint', 'Url must starts with http:// or https://', lambda s: s.startswith('http://') or s.startswith('https://'), default='' if previous_configuration is None else previous_configuration.get('target_endpoint', '')) verify = _read_value_from_user( 'Verify ssl (true/false)', 'Enter either true or false', lambda s: s == 'true' or s == 'false', default='true' if previous_configuration is None else json.dumps( previous_configuration.get('verify', True))) login = _read_value_from_user('Please enter your login') password = _read_value_from_user('Please enter your password') client = CloudFoundryClient(target_endpoint, verify=(verify == 'true')) client.init_with_user_credentials(login, password) with open(config_file, 'w') as f: f.write( json.dumps(dict(target_endpoint=target_endpoint, verify=(verify == 'true'), refresh_token=client.refresh_token), indent=2)) return client else: try: configuration = None with open(config_file, 'r') as f: configuration = json.load(f) client = CloudFoundryClient(configuration['target_endpoint'], verify=configuration['verify']) client.init_with_token(configuration['refresh_token']) return client except Exception as ex: if type(ex) == ConnectionError: raise else: _logger.exception( "Could not restore configuration. Cleaning and recreating") os.remove(config_file) return build_client_from_configuration(configuration)
def build_client_from_configuration(): global _client if _client is None: _init_logging() cfg = ConfigParser() cfg.read(get_resource("test.properties")) proxy = None try: http = cfg.get("proxy", "http") https = cfg.get("proxy", "https") proxy = dict(http=http, https=https) except (NoSectionError, NoOptionError): pass skip_verification = False try: skip_verification_str = cfg.get("service", "skip_ssl_verification") skip_verification = skip_verification_str.lower() == "true" except (NoSectionError, NoOptionError): pass client = CloudFoundryClient(cfg.get("service", "target_endpoint"), proxy=proxy, skip_verification=skip_verification) client.init_with_user_credentials( cfg.get("authentification", "login"), cfg.get("authentification", "password")) client.org_guid = cfg.get("test_data", "org_guid") client.space_guid = cfg.get("test_data", "space_guid") client.app_guid = cfg.get("test_data", "app_guid") client.log_app_guid = cfg.get("test_data", "log_app_guid") client.service_guid = cfg.get("test_data", "service_guid") client.service_name = cfg.get("test_data", "service_name") client.plan_guid = cfg.get("test_data", "plan_guid") client.creation_parameters = eval( cfg.get("test_data", "creation_parameters")) client.update_parameters = eval( cfg.get("test_data", "update_parameters")) _client = client return _client
#! /usr/bin/env python3 import os from cloudfoundry_client.client import CloudFoundryClient target_endpoint = 'https://api.dev.cfdev.sh' proxy = dict(http=os.environ.get('HTTP_PROXY', ''), https=os.environ.get('HTTPS_PROXY', '')) # print('1') client = CloudFoundryClient(target_endpoint, verify=False) # print('1.5') # init with user credentials client.init_with_user_credentials('user', 'pass') # print('2') # init with refresh token (that will retrieve a fresh access token) # client.init_with_token('refresh-token') # init with access and refresh token (if the above method is not convenient) #client.refresh_token = 'refresh-token' #client._access_token = 'access-token' # print('3') print('#--- organization ---#') for organization in client.v2.organizations: print(organization['metadata']['guid']) print('#--- ---#')
import os from cloudfoundry_client.client import CloudFoundryClient target_endpoint = 'https://somewhere.org' proxy = dict(http=os.environ.get('HTTP_PROXY', ''), https=os.environ.get('HTTPS_PROXY', '')) client = CloudFoundryClient(target_endpoint, proxy=proxy, skip_verification=True) client.init_with_user_credentials('login', 'password') for organization in client.organizations: print organization['metadata']['guid']
def deploy_cf(self, mtar, api, org, space, user, password): """ Deploy mtar archive Parameters ---------- mtar : str Path to the mtar archive mta_builder : str Mtar builder jar location api : str Cloud Foundry api url org : str Cloud Foundry org to deploy to. space : str Cloud Foundry space to deploy to. user : str Cloud Foudry user to deploy with. password : str Cloud Foundry user password to deploy with. """ if not os.path.isabs(mtar): file_name = os.path.basename(mtar) mtar = os.path.join(os.getcwd(), file_name) if os.path.exists(mtar): # Verifying required data is provided if api == None or org == None or space == None or user == None or password == None: logger.error('Missing cl arguments. Minimal mtar, api, org, space, user, password required.') exit(1) # Setup cloud foundry client for validating org and space availability proxy = dict(http=os.environ.get('HTTP_PROXY', ''), https=os.environ.get('HTTPS_PROXY', '')) client = CloudFoundryClient(api, proxy=proxy, verify=False) # Login to api validating login credentials provided # CF Client does not properly allow for handling raised exception. It exits beforehand so try / except does not do much. Left now for reference. try: client.init_with_user_credentials(user, password) except BaseException as ex: error_message = '' if type(ex).__name__ == 'OAuthError' or type(ex).__name__ == 'oauth2_client.credentials_manager.OAuthError': # Credentials are not correct log accordingly error_message = 'Provided username or password incorrect.' else: error_message = 'Error {} occured while trying to authenticate with user {} against api {}.'.format(type(ex).__name__, user, api) logger.error(error_message) exit(1) # Get org and space guid org_guid = None space_guid = None for organization in client.v2.organizations.list(**{'name': [org]}): org_guid = organization['metadata']['guid'] for org_space in organization.spaces(**{'name': [space]}): # perform a GET on spaces_url attribute space_guid = org_space['metadata']['guid'] if org_guid == None: logger.error('Provided orgnization {} is not available on the provided api url {}.'.format(org, api)) exit(1) if space_guid == None: logger.error('Provided space {} is not available in the provided organization {}.'.format(space, org)) exit(1) logger.info('Start deployment of: {}'.format(mtar)) # Populate cli arguments for cf login cf_cli_args = ['cf', 'login'] # Api cf_cli_args.extend(['-a', api]) # Username cf_cli_args.extend(['-u', user]) # Password cf_cli_args.extend(['-p', password]) # Organization cf_cli_args.extend(['-o', org]) # Space cf_cli_args.extend(['-s', space]) # Call cf cli to login to correct api / org / space proc = subprocess.Popen(cf_cli_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (out, err) = proc.communicate() result = out.decode('utf-8') if err == b'' and out.decode('utf-8').find('FAILED') == -1: # Login via cf cli is succesfull # Populate cli deploy arguments cf_cli_args = ['cf', 'deploy', mtar, '-f'] # @TODO: We are forcing deployment using the -f argument. Check if this can cause unwanted behaviour. proc = subprocess.Popen(cf_cli_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) process_failed = False err=None for line in proc.stdout: line_decoded = line.decode() if process_failed and err == None: err=line_decoded if line_decoded.find('FAILED') > -1: process_failed = True logger.info('CF_OUTPUT: {}'.format(line_decoded)) if process_failed: logger.error('Deployment not succesfull. Error: {}'.format(err)) else: logger.info('Deployment operation was succesfull. Please check output for other issues.') else: logger.error('Deployment not succesfull. Error: {}'.format(result)) logger.info('MTAR Deployment process done') else: logger.error('Deployment could not be started as deployment file not found: {}'.format(mtar))
exit() cf_user = os.getenv('CF_USER', None) if not cf_user: print('You need to set the CF_USER environment variable') exit() cf_pass = os.getenv('CF_PASS', None) if not cf_pass: print('You need to set the CF_PASS environment variable') exit() client = CloudFoundryClient(cf_api, skip_verification=True) client.init_with_user_credentials(cf_user, cf_pass) for organization in client.organizations: for space in organization.spaces(): space_name = space['entity']['name'] if space_name != argv[1]: continue for app in space.apps(): app_name = app['entity']['name'] if app_name != argv[2]: continue
class Cloudfoundry(object): ROBOT_LIBRARY_SCOPE = "GLOBAL" def __init__(self, target_endpoint, skip_verification, login, password, organization_name, space_name, application_name, service_broker_endpoint, service_broker_name, service_broker_auth_user, service_broker_auth_password, instance_name, default_create_instance_parameters): Cloudfoundry._check_parameters(default_create_instance_parameters) self.proxies = dict(http=os.environ.get('HTTP_PROXY', ''), https=os.environ.get('HTTPS_PROXY', '')) self.client = CloudFoundryClient(target_endpoint, skip_verification=skip_verification, proxy=self.proxies) self.client.init_with_user_credentials(login, password) organization = self.client.organizations.get_first( name=organization_name) if organization is None: raise AssertionError('Unknown organization %s' % organization_name) space = self.client.spaces.get_first( organization_guid=organization['metadata']['guid'], name=space_name) if space is None: raise AssertionError('Unknown space %s' % space_name) self.space_guid = space['metadata']['guid'] application = self.client.apps.get_first(space_guid=self.space_guid, name=application_name) if application is None: raise AssertionError('Unknown application %s in space %s' % (application_name, space_name)) self.application_guid = application['metadata']['guid'] self.service_broker_name = service_broker_name self.service_broker_endpoint = service_broker_endpoint self.service_broker_auth_user = service_broker_auth_user self.service_broker_auth_password = service_broker_auth_password self.instance_name = instance_name self.default_create_instance_parameters = default_create_instance_parameters self.instance_guid = None self.binding_guid = None self.broker_guid = None for service_broker in self.client.service_brokers.list( space_guid=self.space_guid): if service_broker['entity']['name'] == self.service_broker_name \ and service_broker['entity']['broker_url'] == self.service_broker_endpoint: self.broker_guid = service_broker['metadata']['guid'] self.plan_guid = None self._set_plan_from_broker() def clean_all_service_data(self): logging.info('clean_all_service_data - %s - %s - %s', self.space_guid, self.instance_name, self.application_guid) instance = self.client.service_instances.get_first( space_guid=self.space_guid, name=self.instance_name) if instance is not None: logging.info('clean_all_service_data instance got - %s', instance['metadata']['guid']) cleaned = False while not cleaned: for binding in self.client.service_bindings.list( service_instance_guid=instance['metadata']['guid']): logging.info('clean_all_service_data binding - %s', binding['metadata']['guid']) self.client.service_bindings.remove( binding['metadata']['guid']) logging.info('clean_all_service_data - binding deleted') try: self.client.service_instances.remove( instance['metadata']['guid']) cleaned = True except InvalidStatusCode, ex: if ex.status_code == httplib.BAD_REQUEST and type(ex.body) == dict and \ ex.body['error_code'] == 'CF-AssociationNotEmpty': logging.debug( 'some binding appeared in the meantime. looping again' ) pass elif ex.status_code == httplib.BAD_GATEWAY and type(ex.body) == dict and \ " can't be deleted during forced enrollment" in ex.body['description']: logging.info( '%s is in forced mode. Updating it as standard' % instance['metadata']['guid']) parameters = dict() parameters['auto-enrollment'] = 'standard' parameters[ 'secret'] = self.service_broker_auth_password self.client.service_instances.update( instance['metadata']['guid'], parameters=parameters) else: raise logging.info('clean_all_service_data - instance deleted') self.instance_guid = None self.binding_guid = None
class PCFClass: def __init__(self): self.__spaces = [] self.__apps = [] self.__scaler_conf = {} api_endpoint = os.getenv("api_endpoint") username = os.getenv("user") password = os.getenv("password") proxy = dict(http=os.environ.get('HTTP_PROXY', ''), https=os.environ.get('HTTPS_PROXY', '')) print("Connecting to Api:{}".format(api_endpoint)) self.__client = CloudFoundryClient(api_endpoint, proxy=proxy, verify=False) print("Authenticating") self.__client.init_with_user_credentials(username, password) print("Initializing PCF spaces") self.get_spaces() print("Initializing PCF apps") self.get_apps() self.init_scaling_confs() def get_apps(self): self.__apps.clear() for item in self.__client.v2.apps: self.__apps.append(item["entity"]) return self.__apps def get_spaces(self): self.__spaces.clear() for item in self.__client.v2.spaces: self.__spaces.append(item["entity"]) return self.__spaces def get_space(self, space_name): for item in self.__spaces: if item["name"] == space_name: return item def get_space_guid(self, space_name): for space in self.__spaces: if space_name == space["name"]: return space["apps_url"].split("/")[3] def get_app_guid(self, space_name, app_name): space_guid = self.get_space_guid(space_name) for app in self.__apps: if app_name == app["name"] and app["space_guid"] == space_guid: return app["service_bindings_url"].split("/")[3] def get_org_guid(self, org_name): org = self.get_org(org_name)[0] return org["spaces_url"].split("/")[-2] def get_org(self, org_name): org_list = [] query = {} if org_name is not None: query["name"] = org_name for org in self.__client.v2.organizations.list(**query): org_list.append(org["entity"]) return org_list def apps(self, space_name=None, app_name=None): space_guid = None app_list = [] if space_name: space_guid = self.get_space_guid(space_name) for item in self.__apps: if not app_name or item["name"] == app_name: if not space_name or item["space_guid"] == space_guid: app_list.append(item) return app_list def services(self): service_list = [] for item in self.__client.v2.services: service_list.append(item) return service_list def service_keys(self): service_keys = [] for item in self.__client.v2.service_keys: service_keys.append(item) return service_keys def get_buildpack(self, space_name, app_name): app_summary = self.app_summary(app_name,space_name) buildpack = { "name": app_summary["buildpack"], "buildpack_guid": app_summary["detected_buildpack_guid"], "type": app_summary["detected_buildpack"] } return buildpack def get_buildpacks(self): buildpacks = [] for item in self.__client.v2.buildpacks: buildpacks.append(item["entity"]) return buildpacks def space_service_instances(self, space_name, service_name): service_instances = [] space_guid = self.get_space_guid(space_name) query = { 'space_guid': space_guid } if service_name is not None: query['name'] = service_name for item in self.__client.v2.service_instances.list(**query): service_instances.append(item['entity']) return service_instances def app_service_bindings(self, space_name, app_name, service_name): service_bindings = [] service_guid = self.get_service_guid(space_name, app_name, service_name) app_guid = self.get_app_guid(space_name, app_name) query = { 'app_guid': app_guid } if service_guid is not None: query['service_instance_guid'] = service_guid for item in self.__client.v2.service_bindings.list(**query): service_bindings.append(item["entity"]) return service_bindings def remove_app_service_binding(self, space_name, app_name, service_name): service_guid = self.get_service_binding_id(space_name, app_name, service_name) self.__client.v2.service_bindings.remove(service_guid) def remove_space_service_instances(self, space_name, service_name): print("service name {}".format(service_name)) service_guid = self.space_service_instances(space_name, service_name)[0]['service_bindings_url'].split("/")[-2] print("Received service guid {}".format(service_guid)) self.__client.v2.service_instances.remove(service_guid) def get_service_guid(self, space_name, app_name, service_name): app_summary = self.app_summary(app_name, space_name) for service in app_summary["services"]: if service_name == service["name"]: return service["guid"] def get_service_binding_id(self, space_name, app_name, service_name): service_guid = self.get_service_guid(space_name, app_name, service_name) app_guid = self.get_app_guid(space_name, app_name) query = { 'app_guid': app_guid, 'service_instance_guid': service_guid } for item in self.__client.v2.service_bindings.list(**query): return item["entity"]["service_binding_parameters_url"].split("/")[-2] def app_stats(self, app_name, space_name): space_guid = self.get_space_guid(space_name) for item in self.__client.v2.apps.list(**{'name': app_name, 'space_guid': space_guid}): return item.stats() def app_summary(self, app_name, space_name): space_guid = self.get_space_guid(space_name) for item in self.__client.v2.apps.list(**{'name': app_name, 'space_guid': space_guid}): return item.summary() def get_url(self, url): return self.__client.get(url) def init_scaling_confs(self): for space in self.__spaces: scale_service_binding = self.space_service_instances(space["name"], "autoscale") if len(scale_service_binding) != 0: dashboard_url = (scale_service_binding[0]["dashboard_url"]) \ .replace("dashboard", "api") + "/bindings" try: response = self.get_url(dashboard_url) self.__scaler_conf[space["name"]] = json.loads(response.content)["resources"] except Exception as err: self.__scaler_conf[space["name"]] = None print('Exception occurred auto scale service url:', err) def get_scaling_conf(self, space_name, app_name): if space_name not in self.__scaler_conf: return {"max_instances": 0, "enabled": "false"} else: for item in self.__scaler_conf[space_name] or []: if item["app_name"] == app_name: return item return {"max_instances": 0, "enabled": "false"}
def cf_connection(cf_user, cf_passwd): client = CloudFoundryClient(cf_endpoint, proxy = proxy, skip_verification = True) client.init_with_user_credentials(cf_user, cf_passwd)
def run(self): """ Regenerate our datapoints by querying all the /info endpoints """ global matrix, spaces, scanning client = CloudFoundryClient(self._auth.get('gate'), skip_verification=True) client.init_with_user_credentials(self._auth.get('user'), self._auth.get('pass')) for organization in client.organizations: org_name = organization['entity']['name'] for space in organization.spaces(): space_name = space['entity']['name'] if space_name not in spaces: spaces[space_name] = 0 for app in space.apps(): name = app['entity']['name'] if name.split('-')[-1] not in spaces: continue app_name = '-'.join(app['entity']['name'].split('-')[:-1]) route = app.summary()['routes'] if not len(route): continue domain = route[0]['domain']['name'] host = route[0]['host'] url = 'http://{}.{}/info'.format(host, domain) response = requests.get(url) try: if app_name not in matrix: matrix[app_name] = {} urls[app_name] = {} urls[app_name][space_name] = url matrix[app_name][space_name] = response.json() spaces[space_name] += 1 except Exception as e: pass if scanning: return scanning = True while True: time.sleep(SLEEP_INTERVAL) count = 0 immutable_matrix = list(matrix) for app in immutable_matrix: immutable_spaces = list(spaces) for space in immutable_spaces: if space in urls[app]: url = urls[app][space] response = requests.get(url) if 'gateway-test' in url: print(url, response) count += 1 try: json = response.json() except Exception as e: json = { 'branch': 'ERROR', 'version': str(response.status_code) } matrix[app][space] = json print('Finished pass, scanned "{}" urls'.format(count))
servicesTotalName = namespace_prefix + 'total-services' spacesName = namespace_prefix + 'spaces' orgName = namespace_prefix + 'orgs' appsName = namespace_prefix + 'apps' appServicesName = namespace_prefix + 'appservices' servicesName = namespace_prefix + 'services' orgTotalName = namespace_prefix + 'total-orgs ' spacesTotalName = namespace_prefix + 'total-spaces ' servicesBindingsName = namespace_prefix + 'service-bindings' servicesBindingsTotalName = namespace_prefix + 'total-service-bindings' servicesInstancesName = namespace_prefix + 'service-instances' servicesInstancesTotalName = namespace_prefix + 'total-service-instances' # Login can also use a token client = CloudFoundryClient(cloud_controller, proxy=proxy, verify=verify_ssl) client.init_with_user_credentials(username, password) # Netcat dependency in the container def sendMetric(metric): entireMetric = metric + '| nc -q0 ' + proxy_host + ' ' + proxy_port if debug==True: print(entireMetric) os.popen(entireMetric) # List all organizations orgs = client.v2.organizations orgCounter = 0 for org in orgs: orgGUID = org['metadata']['guid'] orgName = org['entity']['name']
cfg.read(get_resource('test.properties')) proxy = None try: http = cfg.get('proxy', 'http') https = cfg.get('proxy', 'https') proxy = dict(http=http, https=https) except (ConfigParser.NoSectionError, ConfigParser.NoOptionError), _: pass skip_verification = False try: skip_verification_str = cfg.get('service', 'skip_ssl_verification') skip_verification = skip_verification_str.lower() == 'true' except (ConfigParser.NoSectionError, ConfigParser.NoOptionError), _: pass client = CloudFoundryClient(cfg.get('service', 'target_endpoint'), proxy=proxy, skip_verification=skip_verification) client.init_with_user_credentials(cfg.get('authentification', 'login'), cfg.get('authentification', 'password')) client.org_guid = cfg.get('test_data', 'org_guid') client.space_guid = cfg.get('test_data', 'space_guid') client.app_guid = cfg.get('test_data', 'app_guid') client.log_app_guid = cfg.get('test_data', 'log_app_guid') client.service_guid = cfg.get('test_data', 'service_guid') client.service_name = cfg.get('test_data', 'service_name') client.plan_guid = cfg.get('test_data', 'plan_guid') client.creation_parameters = eval(cfg.get('test_data', 'creation_parameters')) client.update_parameters = eval(cfg.get('test_data', 'update_parameters')) _client = client return _client