def __init__(self, **kwargs): """Initialize a new client for the Nozzle v2.0 API.""" super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) ##self.version = '1.0' ##self.action_prefix = "/v%s" % self.version self.format = 'json' self.retries = 0 self.retry_interval = 1
class Client(object): """Client for the nozzle v2.0 API. :param string username: Username for authentication. (optional) :param string password: Password for authentication. (optional) :param string token: Token for authentication. (optional) :param string tenant_name: Tenant name. (optional) :param string auth_url: Keystone service endpoint for authorization. :param string region_name: Name of a region to select when choosing an endpoint from the service catalog. """ loadbalancers_path = "/loadbalancers" loadbalancer_path = "/loadbalancers/%s" def create_loadbalancer(self, body=None): """Create a new loadbalancer for a tenant.""" return self.post(self.loadbalancers_path, body=body) def update_loadbalancer(self, loadbalancer, body=None): """Update a loadbalancer.""" return self.put(self.loadbalancer_path % (loadbalancer), body=body) def delete_loadbalancer(self, loadbalancer): """Delete a loadbalancer.""" return self.delete(self.loadbalancer_path % (loadbalancer)) def list_loadbalancers(self, **_params): """Fetches a list of loadbalancers for a tenant.""" return self.get(self.loadbalancers_path, params=_params) def list_loadbalancer_domains(self, **_params): """Fetches all domains binding to load balancers.""" return self.get(self.loadbalancer_path % ('domains'), params=_params) def show_loadbalancer(self, loadbalancer): """Fetches information of a certain load balancer.""" return self.get(self.loadbalancer_path % (loadbalancer)) def create_for_instance(self, body=None): """create a new load balancer for instance.""" return self.post("/%s/create_for_instance" % (self.loadbalancers_path), body=body) def delete_for_instance(self, instance_uuid): """Delete and update loadbalancer for instance.""" return self.delete('/%s/delete_for_instance/%s' % ( self.loadbalancers_path, instance_uuid)) def __init__(self, **kwargs): """Initialize a new client for the Nozzle v2.0 API.""" super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) ##self.version = '1.0' ##self.action_prefix = "/v%s" % self.version self.format = 'json' self.retries = 0 self.retry_interval = 1 def content_type(self, format=None): """ Returns the mime-type for either 'xml' or 'json'. Defaults to the currently set format """ if not format: format = self.format return "application/%s" % (format) def serialize(self, data): """ Serializes a dictionary with a single key (which can contain any structure) into either xml or json """ if data is None: return None elif type(data) is dict: return Serializer().serialize(data, self.content_type()) else: raise Exception("unable to serialize object of type = '%s'" % type(data)) def deserialize(self, data, status_code): """ Deserializes a an xml or json string into a dictionary """ if status_code == 204: return data return Serializer().deserialize(data, self.content_type()) def get_status_code(self, response): """ Returns the integer status code from the response, which can be either a Webob.Response (used in testing) or httplib.Response """ if hasattr(response, 'status_int'): return response.status_int else: return response.status def handle_fault_response(self, status_code, response_body): # Create exception with HTTP status code and message error_message = response_body ##_logger.debug("Error message: %s", error_message) # Add deserialized error message to exception arguments try: des_error_body = Serializer().deserialize(error_message, self.content_type()) except: des_error_body = {'message': error_message} # Raise the appropriate exception raise Exception(des_error_body) def do_request(self, method, action, body=None, headers=None, params=None): ##action = self.action_prefix + action if params: action += '?' + urllib.urlencode(params, doseq=1) if body: body = self.serialize(body) self.httpclient.content_type = self.content_type() resp, replybody = self.httpclient.do_request(action, method, body=body) status_code = self.get_status_code(resp) if status_code in (httplib.OK, httplib.CREATED, httplib.ACCEPTED, httplib.NO_CONTENT): return self.deserialize(replybody, status_code) else: self.handle_fault_response(status_code, replybody) def delete(self, action, body=None, headers=None, params=None): return self.do_request("DELETE", action, body=body, headers=headers, params=params) def get(self, action, body=None, headers=None, params=None): return self.do_request("GET", action, body=body, headers=headers, params=params) def post(self, action, body=None, headers=None, params=None): return self.do_request("POST", action, body=body, headers=headers, params=params) def put(self, action, body=None, headers=None, params=None): return self.do_request("PUT", action, body=body, headers=headers, params=params)