class NESClient(object): ''' classdocs ''' def __init__(self, appId, servId): ''' Constructor ''' self.ip="pre.3rd.services.telefonica.es" self.port="444" self.protocol="https" self.path="/services/BA/REST/UCSS/UCSSServer/" self.appId = appId self.servId = servId self.headers = {'appId' : self.appId, 'servId' : self.servId} def set_connection(self): self.base_url= self.protocol + "://" + self.ip +":"+ str(self.port) + self.path self.conn = Connection(self.base_url, username='******', password='******') def create_subscription(self, json_data): response = self.conn.request_post("nes/subscriptions/",body=json_data, headers=self.headers) print "create_subscription" return response['headers']['status'], response['headers']['location'], response['body'] def delete_subscription(self, correlators_list): response = self.conn.request_delete("nes/subscriptions?correlators="+correlators_list, headers=self.headers) print "delete_subscription" return response['headers']['status'], response['body']
def _delete_VM(attributes): conn = Connection(attributes["cm_nova_url"], username="", password="") tenant_id, x_auth_token = _get_keystone_tokens(attributes) vm = _get_VM(attributes) vm_id = vm['id'] resp = conn.request_delete("/" + tenant_id +"/servers/" + vm_id, args={}, headers={'content-type':'application/json', 'accept':'application/json', 'x-auth-token':x_auth_token}) return _get_status(attributes)
if len(sys.argv) != 2: print "You must provide a URL" sys.exit(1) url_re = re.compile( r'^https?://' # http:// or https:// r'(?:(?:[A-Z0-9-]+\.)+[A-Z]{2,6}|' #domain... r'localhost|' #localhost... r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip r'(?::\d+)?' # optional port r'(?:/?|/\S+)$', re.IGNORECASE) # check we have a valid url if not url_re.match(sys.argv[1]): print "You must provide a valid URL" sys.exit(1) # print a message as it may take time for the responce to return print "Deleteing resoure at %s" % sys.argv[1] # make the request try: conn = Connection(sys.argv[1]) # otherwise we should just print the response response = conn.request_delete("/") except socket.error: print "We couldn't connect to %s" % sys.argv[1] sys.exit(1) print "Response was %s" % response['headers'].status
class Client(object): version = "0.002001" def __init__(self, server, search="/search", index="/index", debug=False, username=False, password=False): self.server = server self.search = search self.index = index self.debug = debug self.un = username self.pw = password # docs: # http://code.google.com/p/python-rest-client/wiki/Using_Connection self.ua = Connection(server) # interrogate server resp = self.ua.request_get("/") # pprint.pprint(resp) paths = json.loads(resp["body"]) self.searcher = Connection(paths["search"]) self.indexer = Connection(paths["index"], username=username, password=password) self.commit_uri = paths["commit"] self.rollback_uri = paths["rollback"] self.fields = paths["fields"] self.facets = paths["facets"] def __str__(self): return unicode(self).encode("utf-8") def __unicode__(self): return pprint.pformat(vars(self)) def _put_doc(self, doc, uri=None, content_type=None): # print "adding to index: %s" % doc body_buf = "" if isinstance(doc, Doc): # print "doc isa Dezi.Doc\n" body_buf = doc.as_string() if uri == None: uri = doc.uri if content_type == None: content_type = doc.mime_type elif os.path.isfile(doc): f = open(doc, "r") body_buf = f.read() if uri == None: uri = doc else: # print "doc isa string\n" body_buf = doc if uri == None: raise Exception("uri required") server_uri = "/" + uri if self.debug: print("uri=" + server_uri) print("body=%s" % body_buf) resp = self.indexer.request_post(server_uri, body=body_buf, headers={"Content-Type": content_type}) # pprint.pprint(resp) return Dezi.Response(resp) def add(self, doc, uri=None, content_type=None): return self._put_doc(doc, uri, content_type) def update(self, doc, uri=None, content_type=None): return self._put_doc(doc, uri, content_type) def delete(self, uri): resp = self.indexer.request_delete(uri) return Dezi.Response(resp) def commit(self): ua = Connection(self.commit_uri, username=self.un, password=self.pw) resp = ua.request_post("/") return Dezi.Response(resp) def rollback(self): ua = Connection(self.rollback_uri, username=self.un, password=self.pw) resp = ua.request_post("/") return Dezi.Response(resp) def get(self, **my_args): if "q" not in my_args: raise Exception("'q' param required") resp = self.searcher.request_get("/", args=my_args) # pprint.pprint(resp) r = Dezi.Response(resp) if r.is_success == False: self.last_response = r return False else: return r
class RestClientEngine(object): __metaclass__ = Singleton def __init__(self, conn=None): if not conn: self.conn = Connection(GENERAL_PARAMETERS['base_url'], username=GENERAL_PARAMETERS['username'], password=GENERAL_PARAMETERS['password']) else: self.conn = conn def executeRequest(self, identifier, body=None, query_parameter=None, **kwargs): """ Execute a Http request using pre configured configurations. :param identifier Identifier of the configuration block of the request. :param body Body content of the request. Default None. :param query_parameter Query parameters of URL. apis/apiServ?param1=value1&... Default None. :param kwargs You can include in it pathVariables and extra headers. :return Dictionary with the body response and headers that contains status code too. :raises NotFoundException if a parameter is not present in config or in method call. """ rel_url = self.buildUrl(identifier, kwargs) headers = self.buildHeaders(identifier, kwargs) if identifier in REQUESTS: if REQUESTS[identifier]['method'] in ('get', 'post', 'put', 'delete'): if REQUESTS[identifier]['method'] == 'get': return self.conn.request_get(rel_url, headers=headers, args=query_parameter) elif REQUESTS[identifier]['method'] == 'post': return self.conn.request_post(rel_url, headers=headers, body=body) elif REQUESTS[identifier]['method'] == 'put': return self.conn.request_put(rel_url, headers=headers, body=body) elif REQUESTS[identifier]['method'] == 'delete': return self.conn.request_delete(rel_url, headers=headers) else: raise NotFoundException('method not found') else: raise NotFoundException('method not found') def buildHeaders(self, identifier, kwargs): result = {} if 'headers' in GENERAL_PARAMETERS: for key, value in GENERAL_PARAMETERS['headers'].items(): result[key] = value if identifier in REQUESTS: if 'headers' in REQUESTS[identifier]: for key, value in REQUESTS[identifier]['headers'].items(): result[key] = value else: raise NotFoundException('Request identifier not found exception.') if 'headers' in kwargs: for key, value in kwargs['headers'].items(): result[key] = value if GENERAL_PARAMETERS['username'] and GENERAL_PARAMETERS['password']: result['Authorization'] = ''.join([ 'Basic ', base64.b64encode(':'.join([ GENERAL_PARAMETERS['username'], GENERAL_PARAMETERS['password'] ])) ]) return result def buildUrl(self, identifier, kwargs): if identifier in REQUESTS: relative_url = REQUESTS[identifier]['relative_url'] else: raise NotFoundException('Request identifier not found exception.') parameters = self.getParameterFromConfigFile(relative_url) replaced_relative_url = self.replaceParameters(relative_url, parameters, kwargs) return replaced_relative_url def getParameterFromConfigFile(self, relative_url): return re.findall('{(?P<parameter>[a-zA-Z%0-9_-]+)}', relative_url) def replaceParameters(self, relative_url, parameters, kwargs): result = relative_url for parameter in parameters: if parameter in kwargs: result = result.replace(''.join(['{', parameter, '}']), kwargs[parameter], 1) else: raise NotFoundException(''.join( ['Parameter ', parameter, ' not found for build the url'])) return result
class AdflyApiExample(): #FROM EXAMPLE ## BASE_HOST = 'https://api.adf.ly' ## # TODO: Replace this with your secret key. ## SECRET_KEY = '4c8fa05a-d826-4c06-86e4-59b86bf4868c' ## # TODO: Replace this with your public key. ## PUBLIC_KEY = '2ba3f6ce601d043c177eb2a83eb34f5f' ## # TODO: Replace this with your user id. ## USER_ID = 2 ## AUTH_TYPE = dict(basic=1, hmac=2) BASE_HOST = 'https://api.adf.ly' SECRET_KEY = 'YOUR SECRET KEY' PUBLIC_KEY = 'YOUR PUBLIC KEY' USER_ID = 'YOUR USER ID' AUTH_TYPE = dict(basic=1, hmac=2) def __init__(self): # In this example we use rest client provided by # http://code.google.com/p/python-rest-client/ # Of course you are free to use any other client. self._connection = Connection(self.BASE_HOST) def get_groups(self, page=1): response = self._connection.request_get('/v1/urlGroups', args=self._get_params( dict(_page=page), self.AUTH_TYPE['hmac'])) return json.loads(response['body']) def expand(self, urls, hashes=[]): params = dict() if type(urls) == list: for i, url in enumerate(urls): params['url[%d]' % i] = url elif type(urls) == str: params['url'] = urls if type(hashes) == list: for i, hashval in enumerate(hashes): params['hash[%d]' % i] = hashval elif type(hashes) == str: params['hash'] = hashes response = self._connection.request_get('/v1/expand', args=self._get_params( params, self.AUTH_TYPE['basic'])) return json.loads(response['body']) def shorten(self, urls, domain=None, advert_type=None, group_id=None): params = dict() if domain: params['domain'] = domain if advert_type: params['advert_type'] = advert_type if group_id: params['group_id'] = group_id if type(urls) == list: for i, url in enumerate(urls): params['url[%d]' % i] = url elif type(urls) == str: params['url'] = urls response = self._connection.request_post('/v1/shorten', args=self._get_params( params, self.AUTH_TYPE['basic'])) return json.loads(response['body']) def get_urls(self, page=1, search_str=None): response = self._connection.request_get('/v1/urls', args=self._get_params( dict(_page=page, q=search_str), self.AUTH_TYPE['hmac'])) return json.loads(response['body']) def update_url(self, url_id, **kwargs): params = dict() allowed_kwargs = [ 'url', 'advert_type', 'title', 'group_id', 'fb_description', 'fb_image' ] for k, v in kwargs.items(): if k in allowed_kwargs: params[k] = v response = self._connection.request_put('/v1/urls/%d' % url_id, args=self._get_params( params, self.AUTH_TYPE['hmac'])) return json.loads(response['body']) def delete_url(self, url_id): response = self._connection.request_delete('/v1/urls/%d' % url_id, args=self._get_params( dict(), self.AUTH_TYPE['hmac'])) return json.loads(response['body']) def _get_params(self, params={}, auth_type=None): """Populates request parameters with required parameters, such as _user_id, _api_key, etc. """ auth_type = auth_type or self.AUTH_TYPE['basic'] params['_user_id'] = self.USER_ID params['_api_key'] = self.PUBLIC_KEY if self.AUTH_TYPE['basic'] == auth_type: pass elif self.AUTH_TYPE['hmac'] == auth_type: # Get current unix timestamp (UTC time). params['_timestamp'] = int(time.time()) params['_hash'] = self._do_hmac(params) else: raise RuntimeError return params def _do_hmac(self, params): if type(params) != dict: raise RuntimeError # Get parameter names. keys = params.keys() # Sort them using byte ordering. # So 'param[10]' comes before 'param[2]'. keys.sort() queryParts = [] # Url encode query string. The encoding should be performed # per RFC 1738 (http://www.faqs.org/rfcs/rfc1738) # which implies that spaces are encoded as plus (+) signs. for key in keys: quoted_key = urllib.quote_plus(str(key)) if params[key] is None: params[key] = '' quoted_value = urllib.quote_plus(str(params[key])) queryParts.append('%s=%s' % (quoted_key, quoted_value)) return hmac.new(self.SECRET_KEY, '&'.join(queryParts), hashlib.sha256).hexdigest()