def setUp(self): self.token_file_contents = '123TOKEN' self.response = MagicMock() self.session_get = 'ecsminion.util.token_request.requests.Session.get' self.token_request = TokenRequest(username='******', password='******', ecs_endpoint='https://localhost', token_endpoint='https://localhost', verify_ssl=False, token_filename='ecstoken.tkn', token_location='/tmp', request_timeout=5.0, cache_token=True)
class WhenTestingTokenRequest(unittest.TestCase): def setUp(self): self.token_file_contents = '123TOKEN' self.response = MagicMock() self.session_get = 'ecsminion.util.token_request.requests.Session.get' self.token_request = TokenRequest(username='******', password='******', ecs_endpoint='https://localhost', token_endpoint='https://localhost', verify_ssl=False, token_filename='ecstoken.tkn', token_location='/tmp', request_timeout=5.0, cache_token=True) def test_should_get_existing_token(self): with patch('os.path.isfile', return_value=True),\ patch('__builtin__.open', mock_open(read_data='123TOKEN'), create=True): self.assertEqual(self.token_request._get_existing_token(), self.token_file_contents) def test_should_not_get_existing_token(self): with patch('os.path.isfile', return_value=False): self.assertEqual(self.token_request._get_existing_token(), None) def test_get_new_token_should_throw_ecsminionexception_500(self): self.response.status_code = httplib.INTERNAL_SERVER_ERROR self.requests = MagicMock(return_value=self.response) self.requests.get.side_effect = [self.response] with patch(self.session_get, self.requests): with self.assertRaises(ECSMinionException): self.token_request.get_new_token() def test_get_new_token_should_throw_ecsminionexception_401(self): self.response.status_code = httplib.UNAUTHORIZED self.requests = MagicMock(return_value=self.response) self.requests.get.side_effect = [self.response] with patch(self.session_get, self.requests): with self.assertRaises(ECSMinionException): self.token_request.get_new_token()
def __init__(self, username=None, password=None, token=None, ecs_endpoint=None, token_endpoint=None, verify_ssl=False, token_filename='ecsminion.tkn', token_location='/tmp', request_timeout=15.0, cache_token=True): """ Creates the ECSMinion class that the client will directly work with :param username: The username to fetch a token :param password: The password to fetch a token :param token: Supply a valid token to use instead of username/password :param ecs_endpoint: The URL where ECS is located :param token_endpoint: The URL where the ECS login is located :param verify_ssl: Verify SSL certificates :param token_filename: The name of the cached token filename :param token_location: By default this is stored in /tmp :param request_timeout: How long to wait for ECS to respond :param cache_token: Whether to cache the token, by default this is true you should only switch this to false when you want to directly fetch a token for a user """ self.username = username self.password = password self.token = token self.ecs_endpoint = ecs_endpoint.rstrip('/') self.token_endpoint = token_endpoint.rstrip('/') self.verify_ssl = verify_ssl self.token_filename = token_filename self.token_location = token_location self.request_timeout = request_timeout self.cache_token = cache_token self._session = requests.Session() self._token_request = TokenRequest( username=self.username, password=self.password, ecs_endpoint=self.ecs_endpoint, token_endpoint=self.token_endpoint, verify_ssl=self.verify_ssl, token_filename=self.token_filename, token_location=self.token_location, request_timeout=self.request_timeout, cache_token=self.cache_token) self.token_file = os.path.join( self.token_location, self.token_filename) # API -> Authentication self.authentication = Authentication(self) # API -> Billing self.billing = Billing(self) # API -> Configuration self.certificate = Certificate(self) self.configuration_properties = ConfigurationProperties(self) self.licensing = Licensing(self) # API -> Geo Replication self.replication_group = ReplicationGroup(self) self.temp_failed_zone = TemporaryFailedZone(self) # API -> Monitoring self.capacity = Capacity(self) self.dashboard = Dashboard(self) self.events = Events(self) # API -> Monitoring self.namespace = Namespace(self) # API -> Provisioning self.base_url = BaseUrl(self) self.bucket = Bucket(self) self.data_store = DataStore(self) self.node = Node(self) self.storage_pool = StoragePool(self) self.virtual_data_center = VirtualDataCenter(self) # API -> Support self.call_home = CallHome(self) # API -> User Management self.authentication_provider = AuthenticationProvider(self) self.secret_key = SecretKey(self) self.secret_key_self_service = SecretKeySelfService(self) self.management_object = ManagementUser(self) self.user_object = ObjectUser(self) # API -> Undocumented self.user_info = UserInfo(self)
class ECSMinion(object): def __init__(self, username=None, password=None, token=None, ecs_endpoint=None, token_endpoint=None, verify_ssl=False, token_filename='ecsminion.tkn', token_location='/tmp', request_timeout=15.0, cache_token=True): """ Creates the ECSMinion class that the client will directly work with :param username: The username to fetch a token :param password: The password to fetch a token :param token: Supply a valid token to use instead of username/password :param ecs_endpoint: The URL where ECS is located :param token_endpoint: The URL where the ECS login is located :param verify_ssl: Verify SSL certificates :param token_filename: The name of the cached token filename :param token_location: By default this is stored in /tmp :param request_timeout: How long to wait for ECS to respond :param cache_token: Whether to cache the token, by default this is true you should only switch this to false when you want to directly fetch a token for a user """ self.username = username self.password = password self.token = token self.ecs_endpoint = ecs_endpoint.rstrip('/') self.token_endpoint = token_endpoint.rstrip('/') self.verify_ssl = verify_ssl self.token_filename = token_filename self.token_location = token_location self.request_timeout = request_timeout self.cache_token = cache_token self._session = requests.Session() self._token_request = TokenRequest( username=self.username, password=self.password, ecs_endpoint=self.ecs_endpoint, token_endpoint=self.token_endpoint, verify_ssl=self.verify_ssl, token_filename=self.token_filename, token_location=self.token_location, request_timeout=self.request_timeout, cache_token=self.cache_token) self.token_file = os.path.join( self.token_location, self.token_filename) # API -> Authentication self.authentication = Authentication(self) # API -> Billing self.billing = Billing(self) # API -> Configuration self.certificate = Certificate(self) self.configuration_properties = ConfigurationProperties(self) self.licensing = Licensing(self) # API -> Geo Replication self.replication_group = ReplicationGroup(self) self.temp_failed_zone = TemporaryFailedZone(self) # API -> Monitoring self.capacity = Capacity(self) self.dashboard = Dashboard(self) self.events = Events(self) # API -> Monitoring self.namespace = Namespace(self) # API -> Provisioning self.base_url = BaseUrl(self) self.bucket = Bucket(self) self.data_store = DataStore(self) self.node = Node(self) self.storage_pool = StoragePool(self) self.virtual_data_center = VirtualDataCenter(self) # API -> Support self.call_home = CallHome(self) # API -> User Management self.authentication_provider = AuthenticationProvider(self) self.secret_key = SecretKey(self) self.secret_key_self_service = SecretKeySelfService(self) self.management_object = ManagementUser(self) self.user_object = ObjectUser(self) # API -> Undocumented self.user_info = UserInfo(self) def get_token(self): """ Get a token directly back, typically you want to set the cache_token param for ecsminion to false for this call. :return: A valid token or an ecsminion exception """ return self._token_request.get_new_token() def remove_cached_token(self): """ Remove the cached token file, this is useful if you switch users and want to use a different token """ if os.path.isfile(self.token_file): log.debug("Removing cached token '{0}'".format(self.token_file)) os.remove(self.token_file) def _fetch_headers(self): token = self.token if self.token else self._token_request.get_token() return {'Accept': 'application/json', 'Content-Type': 'application/json', 'x-sds-auth-token': token} def _construct_url(self, path): url = '{0}/{1}'.format(self.ecs_endpoint, path) log.debug('Constructed URL as: {0}'.format(url)) return url def get(self, url, params=None): return self._request(url, params=params) def post(self, url, json_payload='{}'): return self._request(url, json_payload, http_verb='POST') def put(self, url, json_payload='{}'): return self._request(url, json_payload, http_verb='PUT') def delete(self, url, params=None): return self._request(url, params=params, http_verb='DELETE') def _request(self, url, json_payload='{}', http_verb='GET', params=None): json_payload = json.dumps(json_payload) try: if http_verb == "PUT": req = self._session.put( self._construct_url(url), verify=self.verify_ssl, headers=self._fetch_headers(), timeout=self.request_timeout, data=json_payload) elif http_verb == 'POST': req = self._session.post( self._construct_url(url), verify=self.verify_ssl, headers=self._fetch_headers(), timeout=self.request_timeout, data=json_payload) elif http_verb == 'DELETE': # Need to follow up - if 'accept' is in the headers # delete calls are not working because ECS 2.0 is returning # XML even is JSON is specified headers = self._fetch_headers() del headers['Accept'] req = self._session.delete( self._construct_url(url), verify=self.verify_ssl, headers=headers, timeout=self.request_timeout, params=params) else: # Default to GET req = self._session.get( self._construct_url(url), verify=self.verify_ssl, headers=self._fetch_headers(), timeout=self.request_timeout, params=params) if req.status_code != 200: log.error("Status code NOT OK") raise ECSMinionException( http_status_code=req.status_code, ecs_message=req.text) return req.json() except requests.ConnectionError as conn_err: msg = 'Connection error: {0}'.format(conn_err.args) log.error(msg) raise ECSMinionException(message=msg) except requests.HTTPError as http_err: msg = 'HTTP error: {0}'.format(http_err.args) log.error(msg) raise ECSMinionException(message=msg) except requests.RequestException as req_err: msg = 'Request error: {0}'.format(req_err.args) log.error(msg) raise ECSMinionException(message=msg) except ValueError: return
def __init__(self, username=None, password=None, token=None, ecs_endpoint=None, token_endpoint=None, verify_ssl=False, token_filename='ecsminion.tkn', token_location='/tmp', request_timeout=15.0, cache_token=True): """ Creates the ECSMinion class that the client will directly work with :param username: The username to fetch a token :param password: The password to fetch a token :param token: Supply a valid token to use instead of username/password :param ecs_endpoint: The URL where ECS is located :param token_endpoint: The URL where the ECS login is located :param verify_ssl: Verify SSL certificates :param token_filename: The name of the cached token filename :param token_location: By default this is stored in /tmp :param request_timeout: How long to wait for ECS to respond :param cache_token: Whether to cache the token, by default this is true you should only switch this to false when you want to directly fetch a token for a user """ self.username = username self.password = password self.token = token self.ecs_endpoint = ecs_endpoint.rstrip('/') self.token_endpoint = token_endpoint.rstrip('/') self.verify_ssl = verify_ssl self.token_filename = token_filename self.token_location = token_location self.request_timeout = request_timeout self.cache_token = cache_token self._session = requests.Session() self._token_request = TokenRequest( username=self.username, password=self.password, ecs_endpoint=self.ecs_endpoint, token_endpoint=self.token_endpoint, verify_ssl=self.verify_ssl, token_filename=self.token_filename, token_location=self.token_location, request_timeout=self.request_timeout, cache_token=self.cache_token) self.token_file = os.path.join(self.token_location, self.token_filename) # API -> Authentication self.authentication = Authentication(self) # API -> Billing self.billing = Billing(self) # API -> Configuration self.certificate = Certificate(self) self.configuration_properties = ConfigurationProperties(self) self.licensing = Licensing(self) # API -> Geo Replication self.replication_group = ReplicationGroup(self) self.temp_failed_zone = TemporaryFailedZone(self) # API -> Monitoring self.capacity = Capacity(self) self.dashboard = Dashboard(self) self.events = Events(self) # API -> Monitoring self.namespace = Namespace(self) # API -> Provisioning self.base_url = BaseUrl(self) self.bucket = Bucket(self) self.data_store = DataStore(self) self.node = Node(self) self.storage_pool = StoragePool(self) self.virtual_data_center = VirtualDataCenter(self) # API -> Support self.call_home = CallHome(self) # API -> User Management self.authentication_provider = AuthenticationProvider(self) self.secret_key = SecretKey(self) self.secret_key_self_service = SecretKeySelfService(self) self.management_object = ManagementUser(self) self.user_object = ObjectUser(self) # API -> Undocumented self.user_info = UserInfo(self)
class ECSMinion(object): def __init__(self, username=None, password=None, token=None, ecs_endpoint=None, token_endpoint=None, verify_ssl=False, token_filename='ecsminion.tkn', token_location='/tmp', request_timeout=15.0, cache_token=True): """ Creates the ECSMinion class that the client will directly work with :param username: The username to fetch a token :param password: The password to fetch a token :param token: Supply a valid token to use instead of username/password :param ecs_endpoint: The URL where ECS is located :param token_endpoint: The URL where the ECS login is located :param verify_ssl: Verify SSL certificates :param token_filename: The name of the cached token filename :param token_location: By default this is stored in /tmp :param request_timeout: How long to wait for ECS to respond :param cache_token: Whether to cache the token, by default this is true you should only switch this to false when you want to directly fetch a token for a user """ self.username = username self.password = password self.token = token self.ecs_endpoint = ecs_endpoint.rstrip('/') self.token_endpoint = token_endpoint.rstrip('/') self.verify_ssl = verify_ssl self.token_filename = token_filename self.token_location = token_location self.request_timeout = request_timeout self.cache_token = cache_token self._session = requests.Session() self._token_request = TokenRequest( username=self.username, password=self.password, ecs_endpoint=self.ecs_endpoint, token_endpoint=self.token_endpoint, verify_ssl=self.verify_ssl, token_filename=self.token_filename, token_location=self.token_location, request_timeout=self.request_timeout, cache_token=self.cache_token) self.token_file = os.path.join(self.token_location, self.token_filename) # API -> Authentication self.authentication = Authentication(self) # API -> Billing self.billing = Billing(self) # API -> Configuration self.certificate = Certificate(self) self.configuration_properties = ConfigurationProperties(self) self.licensing = Licensing(self) # API -> Geo Replication self.replication_group = ReplicationGroup(self) self.temp_failed_zone = TemporaryFailedZone(self) # API -> Monitoring self.capacity = Capacity(self) self.dashboard = Dashboard(self) self.events = Events(self) # API -> Monitoring self.namespace = Namespace(self) # API -> Provisioning self.base_url = BaseUrl(self) self.bucket = Bucket(self) self.data_store = DataStore(self) self.node = Node(self) self.storage_pool = StoragePool(self) self.virtual_data_center = VirtualDataCenter(self) # API -> Support self.call_home = CallHome(self) # API -> User Management self.authentication_provider = AuthenticationProvider(self) self.secret_key = SecretKey(self) self.secret_key_self_service = SecretKeySelfService(self) self.management_object = ManagementUser(self) self.user_object = ObjectUser(self) # API -> Undocumented self.user_info = UserInfo(self) def get_token(self): """ Get a token directly back, typically you want to set the cache_token param for ecsminion to false for this call. :return: A valid token or an ecsminion exception """ return self._token_request.get_new_token() def remove_cached_token(self): """ Remove the cached token file, this is useful if you switch users and want to use a different token """ if os.path.isfile(self.token_file): log.debug("Removing cached token '{0}'".format(self.token_file)) os.remove(self.token_file) def _fetch_headers(self): token = self.token if self.token else self._token_request.get_token() return { 'Accept': 'application/json', 'Content-Type': 'application/json', 'x-sds-auth-token': token } def _construct_url(self, path): url = '{0}/{1}'.format(self.ecs_endpoint, path) log.debug('Constructed URL as: {0}'.format(url)) return url def get(self, url, params=None): return self._request(url, params=params) def post(self, url, json_payload='{}'): return self._request(url, json_payload, http_verb='POST') def put(self, url, json_payload='{}'): return self._request(url, json_payload, http_verb='PUT') def delete(self, url, params=None): return self._request(url, params=params, http_verb='DELETE') def _request(self, url, json_payload='{}', http_verb='GET', params=None): json_payload = json.dumps(json_payload) try: if http_verb == "PUT": req = self._session.put(self._construct_url(url), verify=self.verify_ssl, headers=self._fetch_headers(), timeout=self.request_timeout, data=json_payload) elif http_verb == 'POST': req = self._session.post(self._construct_url(url), verify=self.verify_ssl, headers=self._fetch_headers(), timeout=self.request_timeout, data=json_payload) elif http_verb == 'DELETE': # Need to follow up - if 'accept' is in the headers # delete calls are not working because ECS 2.0 is returning # XML even is JSON is specified headers = self._fetch_headers() del headers['Accept'] req = self._session.delete(self._construct_url(url), verify=self.verify_ssl, headers=headers, timeout=self.request_timeout, params=params) else: # Default to GET req = self._session.get(self._construct_url(url), verify=self.verify_ssl, headers=self._fetch_headers(), timeout=self.request_timeout, params=params) if req.status_code != 200: log.error("Status code NOT OK") raise ECSMinionException(http_status_code=req.status_code, ecs_message=req.text) return req.json() except requests.ConnectionError as conn_err: msg = 'Connection error: {0}'.format(conn_err.args) log.error(msg) raise ECSMinionException(message=msg) except requests.HTTPError as http_err: msg = 'HTTP error: {0}'.format(http_err.args) log.error(msg) raise ECSMinionException(message=msg) except requests.RequestException as req_err: msg = 'Request error: {0}'.format(req_err.args) log.error(msg) raise ECSMinionException(message=msg) except ValueError: return