def _set_flavor(attributes, vm_id, current_flavor, new_flavor): vm_status = _get_status(attributes) conn = Connection(attributes["cm_nova_url"], username="", password="") tenant_id, x_auth_token = _get_keystone_tokens(attributes) if (vm_status == 'ACTIVE' and current_flavor != new_flavor): body = '{"resize": {"flavorRef":"'+ new_flavor + '"}}' headers = {"Content-type": "application/json", "x-auth-token": x_auth_token.encode()} uri = tenant_id + "/servers/" + vm_id + "/action" resp = conn.request_post(uri, body=body, headers=headers) status = resp[u'headers']['status'] if status == '200' or status == '304' or status == '202': return _get_flavor(attributes, vm_id) else: log.error("Bad HTTP return code: %s" % status) elif (vm_status == 'RESIZE'): log.error("Wait for VM resizing before confirming action") elif (vm_status == 'VERIFY_RESIZE'): body = '{"confirmResize": null}' headers = {"Content-type": "application/json", "x-auth-token": x_auth_token.encode()} uri = tenant_id + "/servers/" + vm_id + "/action" resp = conn.request_post(uri, body=body, headers=headers) status = resp[u'headers']['status'] if status == '200' or status == '304' or status == '202': return _get_flavor(attributes, vm_id) else: log.error("_set_flavor: Bad HTTP return code: %s" % status) else: log.error("Wrong VM state or wring destination flavor")
class LocalClient(object): ''' classdocs ''' def __init__(self): ''' Constructor ''' self.ip="localhost" self.port="81" self.protocol="http" self.path="/nes_server" def set_connection(self): self.base_url= self.protocol + "://" + self.ip +":"+ str(self.port) + self.path self.conn = Connection(self.base_url) def create_subscription(self, json_data): response = self.conn.request_post("/subs.json") response['headers']['location']="http://212.179.159.77/nesphase2/nes/subscriptions/1234567891321" return response['headers']['status'],response['headers']['location'], response['body'] def delete_subscription(self, correlators_list): return 200, "{}"
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 _resume(attributes): ''' Pauses a VM. @param attributes: the dictionary of the attributes that will be used to pause a virtual machine @type attributes: dict ''' vm = _get_VM(attributes) if _get_status(attributes) == "PAUSED": conn = Connection(attributes["cm_nova_url"], username="", password="") tenant_id, x_auth_token = _get_keystone_tokens(attributes) body = '{"unpause": null}' headers = {"Content-type": "application/json", "x-auth-token": x_auth_token.encode()} uri = tenant_id + "/servers/" + vm['id'] + "/action" resp = conn.request_post(uri, body=body, headers=headers) status = resp[u'headers']['status'] if status == '200' or status == '304' or status == '202': log.info("VM is unpaused and status is %s" % _get_status(attributes)) else: log.error("_resume: Bad HTTP return code: %s" % status) else: raise ResourceException("The VM must be paused") return _get_status(attributes)
def handle(self, request, data): print "++++++++++++ ////////////// data = %s" % data uri = request.get_full_path() match = re.search('/project/ipsec/([^/]+)/preaddlink/', uri) vpn_id = match.group(1) print "++++++++++++ ////////////// RBA RBA vpn_id = %s" % vpn_id self.p_tk = request.user.token.id try: messages.success( request, _("Link in process of establishement... Pushing low level network configuration..." )) pgsplit = re.split(r'\.', str(data['p_gw'])) self.p_site = pgsplit[0] + '.' + pgsplit[1] egsplit = re.split(r'\.', str(data['e_gw'])) self.e_site = egsplit[0] + '.' + egsplit[1] print "++++++ data to plugin : vpn=%s, psite=%s, pgw=%s, pnets=%s, ptk=%s, esite=%s, egw=%s, enets=%s, etk=%s, bw=%s" % ( vpn_id, self.p_site, data['p_gw'], data['p_nets'], self.p_tk, self.e_site, data['e_gw'], data['e_nets'], self.e_tk, data['bw']) # should use a modular client below once it supports complex jsons: #api.elasticnet.elasticnet_add_link(request, vpn_id, self.p_site, str(data['p_gw']) , str(data['p_nets']), self.p_tk, self.e_site, str(data['e_gw']) , str(data['e_nets']), self.e_tk, str(data['bw'])) if str(request.user.username).startswith("acme"): o = urlparse.urlparse(url_for(request, "ipsecvpn")) else: o = urlparse.urlparse(url_for(request, "vpn")) conn0 = Connection("http://" + str(o.hostname) + ":9797", "ericsson", "ericsson") uri0 = "/v1.0/tenants/acme/networks/" + str(vpn_id) + "/links.json" LOG.debug("http://" + str(o.hostname) + ":9797") LOG.debug(uri0) header = {} header["Content-Type"] = "application/json" jsonbody='{"sites": [{"id":"'+str(self.p_site)+'", "gateway":"'+ str(data['p_gw']) +'", "network":"'+ str(data['p_nets']) +'", "token_id":"'+str(self.p_tk)+ '"}, {"id":"' \ + str(self.e_site)+'", "gateway":"'+ str(data['e_gw']) +'", "network":"'+ str(data['e_nets']) +'", "token_id":"'+str(self.e_tk)+ '"}], "qos":{"bandwidth":"' \ + str(data['bw'])+'", "eir":"'+ str(data['eir'])+ '", "cbs":"'+ str(data['cbs'])+ '", "pbs":"'+ str(data['pbs'])+ '"}}' print "+++ ewan result json body =%s" % jsonbody result = conn0.request_post(uri0, body=jsonbody, headers=header) print "+++ ewan result body =%s" % result["body"] body = json.loads(result["body"]) print "+++ewan body=%s" % body linkid = str(body['link']['id']) print "+++ewan linkid=%s" % linkid messages.success(request, _("Link added successfully.")) shortcuts.redirect("horizon:project:ipsec:index") return True except Exception as e: msg = _( 'Failed to authorize Link from remote Enterprise Site crendentials : %s' ) % e.message LOG.info(msg) return shortcuts.redirect("horizon:project:ipsec:index")
def handle(self, request, data): print "++++++++++++ ////////////// data = %s" % data uri = request.get_full_path() match = re.search('/project/vpns/([^/]+)/autoburst/', uri) vpn_id = match.group(1) print "++++++++++++ ////////////// RBA RBA vpn_id = %s" % vpn_id self.p_tk = request.user.token.id try: messages.success( request, _("AutoBurst is enabled on the remote VMs using this elastic wan..." )) pgsplit = re.split(r'\.', str(data['p_gw'])) self.p_site = pgsplit[0] + '.' + pgsplit[1] egsplit = re.split(r'\.', str(data['e_gw'])) self.e_site = egsplit[0] + '.' + egsplit[1] # should use a modular client below once it supports complex jsons: #api.elasticnet.elasticnet_add_link(request, vpn_id, self.p_site, str(data['p_gw']) , str(data['p_nets']), self.p_tk, self.e_site, str(data['e_gw']) , str(data['e_nets']), self.e_tk, str(data['bw'])) if str(request.user.username).startswith("acme"): o = urlparse.urlparse(url_for(request, "ipsecvpn")) else: o = urlparse.urlparse(url_for(request, "vpn")) conn0 = Connection("http://" + str(o.hostname) + ":9797", "ericsson", "ericsson") uri0 = "/v1.0/tenants/acme/networks/" + str(vpn_id) + "/links.json" LOG.debug("http://" + str(o.hostname) + ":9797") LOG.debug(uri0) bw = None header = {} header["Content-Type"] = "application/json" jsonbody='{"sites": [{"id":"'+str(self.p_site)+'", "gateway":"'+ str(data['p_gw']) +'", "network":"'+ str(data['p_nets']) +'", "token_id":"'+str(self.p_tk)+ '"}, {"id":"' \ + str(self.e_site)+'", "gateway":"'+ str(data['e_gw']) +'", "network":"'+ str(data['e_nets']) +'", "token_id":"'+str(self.e_tk)+ '"}], "qos":{"bandwidth":"' \ + str(bw)+'"}, "usecase":{"action":"autoburst", "vmuuid":"' \ + str(data['e_servers'])+'", "vmtenantid":"'+str(self.vmtenantid)+'", "vmsla":"'+str(data['sla'])+'"}}' print "+++ ewan result json body =%s" % jsonbody result = conn0.request_post(uri0, body=jsonbody, headers=header) print "+++ ewan result body =%s" % result["body"] body = json.loads(result["body"]) print "+++ewan body=%s" % body linkid = str(body['link']['id']) print "+++ewan linkid=%s" % linkid messages.success(request, _("Link added successfully.")) shortcuts.redirect("horizon:project:vpns:index") return True except Exception as e: msg = _( 'Failed to authorize Link from remote Enterprise Site crendentials : %s' ) % e.message LOG.info(msg) return shortcuts.redirect("horizon:project:vpns:index")
def _get_keystone_tokens(attributes): conn = Connection(attributes["cm_keystone_url"]) body = '{"auth": {"tenantName":"'+ attributes["cm_tenant_name"] + '", "passwordCredentials":{"username": "******"cm_username"] + '", "password": "******"cm_password"] + '"}}}' resp = conn.request_post("/tokens", body=body, headers={'Content-type':'application/json'}) status = resp[u'headers']['status'] if status == '200' or status == '304': data = json.loads(resp['body']) tenant_id = data['access']['token']['tenant']['id'] x_auth_token = data['access']['token']['id'] return tenant_id, x_auth_token else: log.error("_get_keystone_tokens: Bad HTTP return code: %s" % status)
class DiffsClient(object): _logger = logging.getLogger('DiffsClient') _logger.addHandler(logging.StreamHandler(sys.stderr)) def __init__(self, agent_url, verbose=False): self._logger.setLevel(logging.DEBUG if verbose else logging.NOTSET) if not agent_url.endswith('/'): agent_url += '/' self.agent_url = agent_url base_url = urljoin(agent_url, 'rest') self._conn = Connection(base_url) self._conn = Connection(self.get_session_url()) def get_session_url(self): url = '/diffs/sessions' response = self._post(url) return response['headers']['location'] def get_diffs(self, pair_key, range_start, range_end): url = '/?pairKey={0}&range-start={1}&range-end={2}'.format( pair_key, range_start.strftime(DATETIME_FORMAT), range_end.strftime(DATETIME_FORMAT)) response = self._get(url) return json.loads(response['body']) def get_diffs_zoomed(self, range_start, range_end, bucketing): "A dictionary of pair keys mapped to lists of bucketed diffs" url = '/zoom?range-start={0}&range-end={1}&bucketing={2}'.format( range_start.strftime(DATETIME_FORMAT), range_end.strftime(DATETIME_FORMAT), bucketing) response = self._get(url) return json.loads(response['body']) def _get(self, url): self._logger.debug("GET %s", self._rebuild_url(url)) response = self._conn.request_get(url) self._logger.debug(response) return response def _post(self, url): self._logger.debug("POST %s", self._rebuild_url(url)) response = self._conn.request_post(url) self._logger.debug(response) return response def _rebuild_url(self, url): return self._conn.url.geturl() + url def __repr__(self): return "DiffsClient(%s)" % repr(self.agent_url)
def _create_VM(res_id, attributes, dict_vm): conn_nova = Connection(attributes["cm_nova_url"], username="", password="") tenant_id, x_auth_token = _get_keystone_tokens(attributes) body = '{"server": {"name":"'+ dict_vm['name'].encode() + '", "imageRef":"' + dict_vm['image'].encode() + '", "key_name": "' + dict_vm['key'].encode() + '", "user_data":"' + dict_vm['user-data'] + '", "flavorRef":"' + dict_vm['flavor'] + '", "max_count": 1, "min_count": 1, "security_groups": [{"name": "default"}]}}' headers = {"Content-type": "application/json", "x-auth-token": x_auth_token.encode()} uri = tenant_id + "/servers" resp = conn_nova.request_post(uri, body=body, headers=headers) status = resp[u'headers']['status'] if status == '200' or status == '304': data = json.loads(resp['body']) return _get_status(attributes) else: log.error("_create_VM: Bad HTTP return code: %s" % status)
def handle(self, request, data): print "++++++++++++ ////////////// data = %s"%data uri = request.get_full_path() match = re.search('/project/vpns/([^/]+)/autoburst/', uri) vpn_id = match.group(1) print "++++++++++++ ////////////// RBA RBA vpn_id = %s"%vpn_id self.p_tk=request.user.token.id try: messages.success(request, _("AutoBurst is enabled on the remote VMs using this elastic wan...")) pgsplit=re.split(r'\.',str(data['p_gw'])) self.p_site=pgsplit[0]+'.'+pgsplit[1] egsplit=re.split(r'\.',str(data['e_gw'])) self.e_site=egsplit[0]+'.'+egsplit[1] # should use a modular client below once it supports complex jsons: #api.elasticnet.elasticnet_add_link(request, vpn_id, self.p_site, str(data['p_gw']) , str(data['p_nets']), self.p_tk, self.e_site, str(data['e_gw']) , str(data['e_nets']), self.e_tk, str(data['bw'])) if str(request.user.username).startswith("acme"): o = urlparse.urlparse(url_for(request, "ipsecvpn")) else: o = urlparse.urlparse(url_for(request, "vpn")) conn0 = Connection("http://"+str(o.hostname)+":9797", "ericsson", "ericsson") uri0 = "/v1.0/tenants/acme/networks/"+str(vpn_id)+"/links.json" LOG.debug("http://"+str(o.hostname)+":9797") LOG.debug(uri0) bw=None header = {} header["Content-Type"]= "application/json" jsonbody='{"sites": [{"id":"'+str(self.p_site)+'", "gateway":"'+ str(data['p_gw']) +'", "network":"'+ str(data['p_nets']) +'", "token_id":"'+str(self.p_tk)+ '"}, {"id":"' \ + str(self.e_site)+'", "gateway":"'+ str(data['e_gw']) +'", "network":"'+ str(data['e_nets']) +'", "token_id":"'+str(self.e_tk)+ '"}], "qos":{"bandwidth":"' \ + str(bw)+'"}, "usecase":{"action":"autoburst", "vmuuid":"' \ + str(data['e_servers'])+'", "vmtenantid":"'+str(self.vmtenantid)+'", "vmsla":"'+str(data['sla'])+'"}}' print "+++ ewan result json body =%s"%jsonbody result=conn0.request_post(uri0, body=jsonbody, headers=header) print "+++ ewan result body =%s"%result["body"] body=json.loads(result["body"]) print "+++ewan body=%s"%body linkid=str(body['link']['id']) print "+++ewan linkid=%s"%linkid messages.success(request, _("Link added successfully.")) shortcuts.redirect("horizon:project:vpns:index") return True except Exception as e: msg = _('Failed to authorize Link from remote Enterprise Site crendentials : %s') % e.message LOG.info(msg) return shortcuts.redirect("horizon:project:vpns:index")
def handle(self, request, data): print "++++++++++++ ////////////// data = %s"%data uri = request.get_full_path() match = re.search('/project/ipsec/([^/]+)/preaddlink/', uri) vpn_id = match.group(1) print "++++++++++++ ////////////// RBA RBA vpn_id = %s"%vpn_id self.p_tk=request.user.token.id try: messages.success(request, _("Link in process of establishement... Pushing low level network configuration...")) pgsplit=re.split(r'\.',str(data['p_gw'])) self.p_site=pgsplit[0]+'.'+pgsplit[1] egsplit=re.split(r'\.',str(data['e_gw'])) self.e_site=egsplit[0]+'.'+egsplit[1] print "++++++ data to plugin : vpn=%s, psite=%s, pgw=%s, pnets=%s, ptk=%s, esite=%s, egw=%s, enets=%s, etk=%s, bw=%s"%(vpn_id, self.p_site, data['p_gw'] , data['p_nets'], self.p_tk, self.e_site, data['e_gw'] , data['e_nets'], self.e_tk, data['bw']) # should use a modular client below once it supports complex jsons: #api.elasticnet.elasticnet_add_link(request, vpn_id, self.p_site, str(data['p_gw']) , str(data['p_nets']), self.p_tk, self.e_site, str(data['e_gw']) , str(data['e_nets']), self.e_tk, str(data['bw'])) if str(request.user.username).startswith("acme"): o = urlparse.urlparse(url_for(request, "ipsecvpn")) else: o = urlparse.urlparse(url_for(request, "vpn")) conn0 = Connection("http://"+str(o.hostname)+":9797", "ericsson", "ericsson") uri0 = "/v1.0/tenants/acme/networks/"+str(vpn_id)+"/links.json" LOG.debug("http://"+str(o.hostname)+":9797") LOG.debug(uri0) header = {} header["Content-Type"]= "application/json" jsonbody='{"sites": [{"id":"'+str(self.p_site)+'", "gateway":"'+ str(data['p_gw']) +'", "network":"'+ str(data['p_nets']) +'", "token_id":"'+str(self.p_tk)+ '"}, {"id":"' \ + str(self.e_site)+'", "gateway":"'+ str(data['e_gw']) +'", "network":"'+ str(data['e_nets']) +'", "token_id":"'+str(self.e_tk)+ '"}], "qos":{"bandwidth":"' \ + str(data['bw'])+'", "eir":"'+ str(data['eir'])+ '", "cbs":"'+ str(data['cbs'])+ '", "pbs":"'+ str(data['pbs'])+ '"}}' print "+++ ewan result json body =%s"%jsonbody result=conn0.request_post(uri0, body=jsonbody, headers=header) print "+++ ewan result body =%s"%result["body"] body=json.loads(result["body"]) print "+++ewan body=%s"%body linkid=str(body['link']['id']) print "+++ewan linkid=%s"%linkid messages.success(request, _("Link added successfully.")) shortcuts.redirect("horizon:project:ipsec:index") return True except Exception as e: msg = _('Failed to authorize Link from remote Enterprise Site crendentials : %s') % e.message LOG.info(msg) return shortcuts.redirect("horizon:project:ipsec:index")
def sendPost(serviceId, instanceId, monitoringEndpoint, kpiName, value): timestamp = time.mktime(datetime.now().timetuple()) #UTC-Seconds timestamp = long(timestamp) conn = Connection(monitoringEndpoint) response = conn.request_post("/data/" + serviceId , args={"serviceId":serviceId, "instanceid":instanceId, "kpiName":kpiName, "value":value, "timestamp":timestamp}) print "Response: ", response status = response.get('headers').get('status') if status not in ["200", 200, "204", 204]: print >> sys.stderr, "Call failed, status:", status return False print "Call successful" return True
class Chemcaster(object): def __init__(self, username='******',password='******'): self._conn = Connection(CHEMCASTER_ENDPOINT, username, password) def post(self, body): resp = self._conn.request_post("structures",body=body ) status= resp.get('headers').get('status') if status not in ["200", 200, "204", 204]: print resp if status in ["422", 422]: resp['body'] foo=xml.dom.minidom.parseString(resp['body']) for e in foo.getElementsByTagName('error'): print e.firstChild.wholeText raise FailError return resp
class Server: def __init__(self, root_url="http://led-o-matic.appspot.com"): self.root_url = root_url self.conn = Connection(self.root_url) self.name = "" def getPinStatus(self, pins_name, pin_id): request = self.name + '/' + pins_name + '/' + pin_id response = self.conn.request_get(request) return response['body'] def login(self, name): self.name = name response = self.conn.request_post('/' + name) return self.root_url + '/' + self.name + response['body']
def sendPost(serviceId, instanceId, monitoringEndpoint, kpiName, value): timestamp = time.mktime(datetime.now().timetuple()) #UTC-Seconds timestamp = long(timestamp) conn = Connection(monitoringEndpoint) response = conn.request_post("/data/" + serviceId, args={ "serviceId": serviceId, "instanceid": instanceId, "kpiName": kpiName, "value": value, "timestamp": timestamp }) print "Response: ", response status = response.get('headers').get('status') if status not in ["200", 200, "204", 204]: print >> sys.stderr, "Call failed, status:", status return False print "Call successful" return True
class Odl: """Connect to ODL and do REST transactions.""" def __init__(self, base_url): """Connect to ODL.""" self.conn = Connection(base_url, username=v.username, password=v.password) self.log = logging.getLogger('ODL') def clean_up(self): """Clean up ODL configuration.""" params = {'node_id': v.rt1_node_id, 'name': v.auto_tunnel_name} self.post_remove_lsp(params) def read_file(self, filename, params=None): """Return the file contents after substituting the params if any.""" f = open(filename, 'r') contents = f.read() f.close() if params: contents = Template(contents) contents = contents.substitute(params) return contents def get(self, path): """Request REST GET transaction with timeout.""" return timeout(self, self.request, ('GET', path, {})) def post(self, path, body): """Request REST POST transaction with timeout.""" return timeout(self, self.request, ('POST', path, body)) def put(self, path, body): """Request REST PUT transaction with timeout.""" return timeout(self, self.request, ('PUT', path, body)) def request(self, operation, path, body): """Request REST transactions.""" self.log.info("%s : %s", operation, path) if body != {}: self.log.debug("Body : %s", json.dumps(json.loads(body), indent=2)) headers = {'content-type':'application/json', 'accept':'application/json'} if operation == 'GET': response = self.conn.request_get(path, args={}, headers=headers) elif operation == 'POST': response = self.conn.request_post(path, args={}, body=body, headers=headers) elif operation == 'PUT': response = self.conn.request_put(path, args={}, body=body, headers=headers) status = int(response['headers']['status']) self.log.info("Response : %s %s", status, httplib.responses[status]) response_body = json.loads(response['body']) self.log.debug("Response Body : %s\n", json.dumps(response_body, indent=2)) return status, response_body def get_pcep_topology(self, params=None): """Return the content of PCEP topology response.""" return self.get("/operational/network-topology:network-topology/topology/pcep-topology") def post_add_lsp(self, params=None): """Add LSP and return the content of the response.""" self.node_id = params['node_id'] # Required for auto undo if params.has_key('sid'): body = self.read_file(v.add_lsp_sr_file, params) elif params.has_key('sid2'): body = self.read_file(v.add_lsp_sr2_file, params) elif params.has_key('sid3'): body = self.read_file(v.add_lsp_sr3_file, params) else: body = self.read_file(v.add_lsp_file, params) return self.post("/operations/network-topology-pcep:add-lsp", body) def post_update_lsp(self, params=None): """Update LSP and return the content of the response.""" if params.has_key('sid'): body = self.read_file(v.update_lsp_sr_file, params) elif params.has_key('sid2'): body = self.read_file(v.update_lsp_sr2_file, params) elif params.has_key('sid3'): body = self.read_file(v.update_lsp_sr3_file, params) else: body = self.read_file(v.update_lsp_file, params) return self.post("/operations/network-topology-pcep:update-lsp", body) def post_remove_lsp(self, params=None): """Remove LSP and return the content of the response.""" if params is None: # Auto undo params = {} move_attr_to_params(self, params, 'node_id') if params.has_key("node_id"): body = self.read_file(v.remove_lsp_file, params) return self.post("/operations/network-topology-pcep:remove-lsp", body) def post_add_label(self, params=None): """Add label and return the content of the response.""" if params.has_key('in_label') and params.has_key('out_label'): body = self.read_file(v.add_label_dwnld_in_out_file, params) elif params.has_key('in_label'): body = self.read_file(v.add_label_dwnld_in_file, params) elif params.has_key('out_label'): body = self.read_file(v.add_label_dwnld_out_file, params) elif params.has_key('node_label'): body = self.read_file(v.add_label_map_node_file, params) elif params.has_key('adj_label'): body = self.read_file(v.add_label_map_adj_file, params) else: body = self.read_file(v.add_label_db_sync_end_file, params) return self.post("/operations/network-topology-pcep:add-label", body) def post_remove_label(self, params=None): """Remove label and return the content of the response.""" body = self.read_file(v.remove_label_file, params) return self.post("/operations/network-topology-pcep:remove-label", body)
class RedmineRESTAPIWrapper(object): def __init__(self, settings): self.api_key = settings.redmine_api_key self.conn = Connection(settings.redmine_url) def request_put(self, path, payload): return self.conn.request_put(path, args= [ ('key', self.api_key) ], body=json.dumps(payload), headers={'content-type':'application/json', 'accept':'application/json'}) def request_post(self, path, payload): return self.conn.request_post(path, args= [ ('key', self.api_key) ], body=json.dumps(payload), headers={'content-type':'application/json', 'accept':'application/json'}) def request_get(self, path, payload): return self.conn.request_get(path, args= [ ('key', self.api_key) ] + payload, headers={'content-type':'application/json', 'accept':'application/json'}) def put_items_with_payload(self, url, payload_name, items, payload): if not isinstance(items, set): items = set([items]) for i in items: resp = self.request_put("/{}/".format(url)+str(i)+".json", { payload_name: payload}) status = resp[u'headers']['status'] print 'Item {} '.format(url), i, ', http status code: ', status if int(status) != 200: print resp def put_issues_with_payload(self, issues, payload): return self.put_items_with_payload("issues", "issue", issues, payload) def put_versions_with_payload(self, versions, payload): return self.put_items_with_payload("versions", "version", versions, payload) def post_time_entries_with_payload(self, payload): resp = self.request_post("/time_entries.json", {'time_entry': payload}) status = resp[u'headers']['status'] print 'Issue ', payload['issue_id'], ', http status code: ', status def get_items_as_json(self, endpoint, payload): resp = self.request_get("/"+endpoint+".json", payload) status = resp[u'headers']['status'] return resp[u'body'] def get_time_entries(self, payload): return self.get_items_as_json('time_entries', payload) def get_projects(self, payload): return self.get_items_as_json('projects', payload) def set_projects_parent(self, projects, parent_id): return self.put_items_with_payload("projects", "project", projects, { 'parent_id': parent_id}) def add_issues_to_milestone(self, issues, version_id, milestone_name): self.put_issues_with_payload(issues, {'notes': 'Issue added to milestone: '+milestone_name, 'fixed_version_id': version_id}) def add_issues_on_sprint(self, issues, sprint_id, sprint_name): self.put_issues_with_payload(issues, {'notes': 'Issue added to sprint "'+sprint_name+'" from REST API', 'easy_sprint_id': sprint_id}) def set_issues_status(self, issues, status_id): self.put_issues_with_payload(issues, {'status_id': status_id}) def set_issues_status_and_assigned(self, issues, status_id, assigned_id): self.put_issues_with_payload(issues, {'status_id': status_id, 'assigned_to_id': assigned_id}) def set_issues_assigned(self, issues, assigned_id): self.put_issues_with_payload(issues, {'assigned_to_id': assigned_id}) def set_parent_issue(self, issues, parent_id): self.put_issues_with_payload(issues,{'parent_issue_id': parent_id}) def add_notes_on_issues(self, issues, notes): self.put_issues_with_payload(issues,{'notes': notes}) def add_update_on_commit(self, issue, repo_name, branch_name, commit_hash, commit_msg): notes = "Repo <b>%s</b> branch <b>%s</b> commit <b>%s</b>: %s" % (repo_name, branch_name, commit_hash, commit_msg) return self.add_notes_on_issues(set([issue]), notes) def add_update_on_commit_from_line(self, line, repo_name, branch_name): (commit_hash, commit_msg) =line.split(' ',1) match = re.search("\#(\d+)", commit_msg) if match: issue = match.group(1) resp =self.add_update_on_commit(issue,repo_name, branch_name, commit_hash, commit_msg) def add_issues_to_milestone_1(self, issues): self.add_issues_to_milestone(issues, 61, "Milestone 1") def close_issues(self, issues): self.set_issues_status(issues, settings.statuses['closed']) def get_items_as_json_full(self, endpoint, params = None, process_cb = None): (offset, limit, read, total) = (0, 25, 0, 65535) if params is None: params = [] result = [] while read<total: _params = params + [('limit', limit), ('offset', offset)] resp = json.loads(self.get_items_as_json(endpoint, _params)) # add_to_list(resp["time_entries"], label) result += resp[endpoint] if process_cb is not None: process_cb(resp[endpoint]) total = resp["total_count"] read += limit if (limit+offset < total) else total - offset offset += limit return result
from restful_lib import Connection from bitcoinrpc.authproxy import AuthServiceProxy # get bitcoin rpc config bitcoinrpc = coinrpc("../../bitcoin-0.10.2/bitcoin/bitcoin.conf").rpccon() # get litecoin rpc config litecoinrpc = coinrpc("../../litcoin-xxx/bitcoin/bitcoin.conf").rpccon() # make a new bitcoin address to receive the shifted funds newaddress = bitcoinrpc.getnewaddress() # connect to shapeshift API base_url = "https://shapeshift.io" conn = Connection(base_url) # change litecoin to bitcoin post_data = {"withdrawal":newaddress, "pair":"ltc_btc"} btc_shift = conn.request_post("/shift/", post_data) for item in btc_shift: if item == "body": response = json.loads(btc_shift[item]) for key, value in response.iteritems(): if key == "deposit": depositaddr = value # send to deposit address litecoinrpc.sendtoaddress(depositaddr, 10)
from restful_lib import Connection from bitcoinrpc.authproxy import AuthServiceProxy # get bitcoin rpc config bitcoinrpc = coinrpc("../../bitcoin-0.10.2/bitcoin/bitcoin.conf").rpccon() # get litecoin rpc config litecoinrpc = coinrpc("../../litcoin-xxx/bitcoin/bitcoin.conf").rpccon() # make a new bitcoin address to receive the shifted funds newaddress = bitcoinrpc.getnewaddress() # connect to shapeshift API base_url = "https://shapeshift.io" conn = Connection(base_url) # change litecoin to bitcoin post_data = {"withdrawal": newaddress, "pair": "ltc_btc"} btc_shift = conn.request_post("/shift/", post_data) for item in btc_shift: if item == "body": response = json.loads(btc_shift[item]) for key, value in response.iteritems(): if key == "deposit": depositaddr = value # send to deposit address litecoinrpc.sendtoaddress(depositaddr, 10)
class Account(object): """A vcast account. This class handles communication with Vcast FAUCET PVR Server """ def __init__(self, username, password): """Set up a REST connection to Vcast Server Returns id_usr user id or raises exception""" self.username = username self.password = password url = 'http://www.vcast.it/faucetpvr/api/1.0/server_rest.php' self.connection = Connection(url) self.connection.add_rest_credentials(username, password) c = self.connection.request_get('/faucetid') if c['body'] == 'Access Denied': raise Exception('Wrong credentials') self.id_usr = simplejson.loads(c['body'])['id_usr'] def get_channels(self): """Return channels. The function returns channel as a list of dictionaries. Each element of the list is a dictionary with two keys, - type, whose value is a string that can be "video" or "audio"; - name, whose value is a string. """ try: reply = self.connection.request_get('/channels') return simplejson.loads(reply['body']) except: print reply def get_recordings(self): """Return recordings. The function returns recordings as a list of dictionaries. Each element has the following keys whose value is a unicode string (type: unicode). - id_rec - title - channel - channel_type (can be 'audio' or 'video') - format - from_time - rec_time - to_time - retention - repeat - faucetacc (ignore it) """ try: reply = self.connection.request_get('/recordings') return simplejson.loads(reply['body']) except: print reply def get_download_urls(self): """Return the urls of avaible recordings""" feed = self.connection.request_get('/feed')['body'] feed = re.sub(r'\\(.)', r'\1', feed)[13:-3] f = feedparser.parse(feed) urls = [] for i in f.entries: # print i['enclosures'][0]['href'] urls.append(i['enclosures'][0]['href']) return urls def new_recording(self, recording): """Invia al server una nuova programmazione""" json = recording.toJson() print json a = self.connection.request_post('/recordings', body=json) print a def delete_recording(self, id): repl = self.connection.request_get('/delete_recording', args={'id_rec':str(id)}) print repl
class Store(): def __init__(self, base_store_url, username=None, password=None): """ Base URL for the store should be pretty self-explanatory. E.g. something like "http://api.talis.com/stores/store_name" Only needs to enter the username/password if this class is going to tinker with things.""" if base_store_url.endswith('/'): base_store_url = base_store_url[:-1] self.base_store_url = base_store_url # Split the given URL if base_store_url: self.conn = Connection(base_store_url, username=username, password=password) def does_snapshot_exist(self, snapshot_filename): # Test to see if snapshot exists: snapshot_path = SNAPSHOT_TEMPLATE % snapshot_filename response = self.conn.request(snapshot_path, method = "HEAD") if response.get('headers') and response.get('headers').get('status'): status = response.get('headers').get('status') if status in ['200', '204']: return True elif status.startswith('4'): return False # else: raise Error? return False def schedule_reset_data(self, label, at_time=None): """Will request that the store is emptied, and label the request. If a time is given as an ISO8601 formatted string, this will be the scheduled time for the snapshot. Otherwise, it will use the current time.""" if not at_time: at_time=datetime.utcnow().isoformat().split('.')[0] snapshot_request = RESET_STORE_TEMPLATE % (label, at_time) return self.conn.request_post(JOB_REQUESTS, body = snapshot_request, headers={'Content-Type':'application/rdf+xml'}) def schedule_snapshot_data(self, label, at_time=None): """Will request a snapshot be made of the store. If a time is given as an ISO8601 formatted string, this will be the scheduled time for the snapshot. Otherwise, it will use the current time.""" if not at_time: at_time=datetime.utcnow().isoformat().split('.')[0] snapshot_request = SNAPSHOT_STORE_TEMPLATE % (label, at_time) return self.conn.request_post(JOB_REQUESTS, body = snapshot_request, headers={'Content-Type':'application/rdf+xml'}) def schedule_snapshot_restore(self, label, snapshot_filename, at_time=None): """Will request that the store is restored from a snapshot. If a time is given as an ISO8601 formatted string, this will be the scheduled time for the recovery. Otherwise, it will use the current time.""" if not at_time: at_time=datetime.utcnow().isoformat().split('.')[0] # Test to see if snapshot exists: snapshot_path = SNAPSHOT_TEMPLATE % snapshot_filename if self.does_snapshot_exist(snapshot_filename): snapshot_uri = "%s%s" % (self.base_store_url, snapshot_path) snapshot_request = SNAPSHOT_RESTORE_TEMPLATE % (label, snapshot_uri, at_time) return self.conn.request_post(JOB_REQUESTS, body = snapshot_request, headers={'Content-Type':'application/rdf+xml'}) def submit_rdfxml(self, rdf_text): """Puts the given RDF/XML into the Talis Store""" return self._put_rdf(rdf_text, mimetype="application/rdf+xml") def _put_rdf(self, rdf_text, mimetype="application/rdf+xml"): """Placeholder for allowing other serialisation types to be put into a Talis store, whether the conversion takes place here, or if the Talis store starts to accept other formats.""" if rdf_text: request_headers = {} if mimetype not in ['application/rdf+xml']: raise RDFFormatException("%s is not an allowed RDF serialisation format" % mimetype) request_headers['Content-Type'] = mimetype return self.conn.request_post(META_ENDPOINT, body=rdf_text, headers=request_headers) def _query_sparql_service(self, query, args={}): """Low-level SPARQL query - returns the message and response headers from the server. You may be looking for Store.sparql instead of this.""" passed_args = {'query':query} passed_args.update(args) return self.conn.request_get(SPARQL_ENDPOINT, args=passed_args, headers={'Content-type':'application/x-www-form-urlencoded'}) def _query_search_service(self, query, args={}): """Low-level content box query - returns the message and response headers from the server. You may be looking for Store.search instead of this.""" passed_args = {'query':query} passed_args.update(args) return self.conn.request_get(CONTENT_ENDPOINT, args=passed_args, headers={'Content-type':'application/x-www-form-urlencoded'} ) def _list_snapshots(self, passed_args={}): return self.conn.request_get(SNAPSHOTS, args=passed_args, headers={}) ############################################################################## # Convenience Functions ############################################################################## def submit_rdfxml_from_url(self, url_to_file, headers={"Accept":"application/rdf+xml"}): """Convenience method - downloads the file from a given url, and then pushes that into the meta store. Currently, it doesn't put it through a parse-> reserialise step, so that it could handle more than rdf/xml on the way it but it is a future possibility.""" import_rdf_connection = Connection(url_to_file) response = import_rdf_connection.request_get("", headers=headers) if response.get('headers') and response.get('headers').get('status') in ['200', '204']: request_headers = {} # Lowercase all response header fields, to make matching easier. # According to HTTP spec, they should be case-insensitive response_headers = response['headers'] for header in response_headers: response_headers[header.lower()] = response_headers[header] # Set the body content body = response.get('body').encode('UTF-8') # Get the response mimetype rdf_type = response_headers.get('content-type', None) return self._put_rdf(body, mimetype=rdf_type) def sparql(self, query, args={}): """Performs a SPARQL query and simply returns the body of the response if successful - if there is an issue, such as a code 404 or 500, this method will return False. Use the _query_sparql_service method to get hold of the complete response in this case.""" response = self._query_sparql_service(query, args) headers = response.get('headers') status = headers.get('status', headers.get('Status')) if status in ['200', 200, '204', 204]: return response.get('body').encode('UTF-8') else: return False def search(self, query, args={}): """Performs a search query and simply returns the body of the response if successful - if there is an issue, such as a code 404 or 500, this method will return False. Use the _query_search_service method to get hold of the complete response in this case.""" response = self._query_search_service(query, args) headers = response.get('headers') status = headers.get('status', headers.get('Status')) if status in ['200', 200, '204', 204]: parsed_atom = Atom_Search_Results(response.get('body').encode('UTF-8')) return parsed_atom.get_item_list() else: return False
def rollback(self): ua = Connection(self.rollback_uri, username=self.un, password=self.pw) resp = ua.request_post("/") 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)
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 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 AdflyApi(): BASE_HOST = 'https://api.adf.ly' # TODO: Replace this with your secret key. SECRET_KEY = setting.SECRET_KEY # TODO: Replace this with your public key. PUBLIC_KEY = setting.PUBLIC_KEY # TODO: Replace this with your user id. USER_ID = setting.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 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_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()
class Store(): def __init__(self, base_store_url, username=None, password=None): """ Base URL for the store should be pretty self-explanatory. E.g. something like "http://api.talis.com/stores/store_name" Only needs to enter the username/password if this class is going to tinker with things.""" if base_store_url.endswith('/'): base_store_url = base_store_url[:-1] self.base_store_url = base_store_url # Split the given URL if base_store_url: self.conn = Connection(base_store_url, username=username, password=password) def does_snapshot_exist(self, snapshot_filename): # Test to see if snapshot exists: snapshot_path = SNAPSHOT_TEMPLATE % snapshot_filename response = self.conn.request(snapshot_path, method="HEAD") if response.get('headers') and response.get('headers').get('status'): status = response.get('headers').get('status') if status in ['200', '204']: return True elif status.startswith('4'): return False # else: raise Error? return False def schedule_reset_data(self, label, at_time=None): """Will request that the store is emptied, and label the request. If a time is given as an ISO8601 formatted string, this will be the scheduled time for the snapshot. Otherwise, it will use the current time.""" if not at_time: at_time = datetime.utcnow().isoformat().split('.')[0] snapshot_request = RESET_STORE_TEMPLATE % (label, at_time) return self.conn.request_post( JOB_REQUESTS, body=snapshot_request, headers={'Content-Type': 'application/rdf+xml'}) def schedule_snapshot_data(self, label, at_time=None): """Will request a snapshot be made of the store. If a time is given as an ISO8601 formatted string, this will be the scheduled time for the snapshot. Otherwise, it will use the current time.""" if not at_time: at_time = datetime.utcnow().isoformat().split('.')[0] snapshot_request = SNAPSHOT_STORE_TEMPLATE % (label, at_time) return self.conn.request_post( JOB_REQUESTS, body=snapshot_request, headers={'Content-Type': 'application/rdf+xml'}) def schedule_snapshot_restore(self, label, snapshot_filename, at_time=None): """Will request that the store is restored from a snapshot. If a time is given as an ISO8601 formatted string, this will be the scheduled time for the recovery. Otherwise, it will use the current time.""" if not at_time: at_time = datetime.utcnow().isoformat().split('.')[0] # Test to see if snapshot exists: snapshot_path = SNAPSHOT_TEMPLATE % snapshot_filename if self.does_snapshot_exist(snapshot_filename): snapshot_uri = "%s%s" % (self.base_store_url, snapshot_path) snapshot_request = SNAPSHOT_RESTORE_TEMPLATE % ( label, snapshot_uri, at_time) return self.conn.request_post( JOB_REQUESTS, body=snapshot_request, headers={'Content-Type': 'application/rdf+xml'}) def submit_rdfxml(self, rdf_text): """Puts the given RDF/XML into the Talis Store""" return self._put_rdf(rdf_text, mimetype="application/rdf+xml") def _put_rdf(self, rdf_text, mimetype="application/rdf+xml"): """Placeholder for allowing other serialisation types to be put into a Talis store, whether the conversion takes place here, or if the Talis store starts to accept other formats.""" if rdf_text: request_headers = {} if mimetype not in ['application/rdf+xml']: raise RDFFormatException( "%s is not an allowed RDF serialisation format" % mimetype) request_headers['Content-Type'] = mimetype return self.conn.request_post(META_ENDPOINT, body=rdf_text, headers=request_headers) def _query_sparql_service(self, query, args={}): """Low-level SPARQL query - returns the message and response headers from the server. You may be looking for Store.sparql instead of this.""" passed_args = {'query': query} passed_args.update(args) return self.conn.request_get( SPARQL_ENDPOINT, args=passed_args, headers={'Content-type': 'application/x-www-form-urlencoded'}) def _query_search_service(self, query, args={}): """Low-level content box query - returns the message and response headers from the server. You may be looking for Store.search instead of this.""" passed_args = {'query': query} passed_args.update(args) return self.conn.request_get( CONTENT_ENDPOINT, args=passed_args, headers={'Content-type': 'application/x-www-form-urlencoded'}) def _list_snapshots(self, passed_args={}): return self.conn.request_get(SNAPSHOTS, args=passed_args, headers={}) ############################################################################## # Convenience Functions ############################################################################## def submit_rdfxml_from_url(self, url_to_file, headers={"Accept": "application/rdf+xml"}): """Convenience method - downloads the file from a given url, and then pushes that into the meta store. Currently, it doesn't put it through a parse-> reserialise step, so that it could handle more than rdf/xml on the way it but it is a future possibility.""" import_rdf_connection = Connection(url_to_file) response = import_rdf_connection.request_get("", headers=headers) if response.get('headers') and response.get('headers').get( 'status') in ['200', '204']: request_headers = {} # Lowercase all response header fields, to make matching easier. # According to HTTP spec, they should be case-insensitive response_headers = response['headers'] for header in response_headers: response_headers[header.lower()] = response_headers[header] # Set the body content body = response.get('body').encode('UTF-8') # Get the response mimetype rdf_type = response_headers.get('content-type', None) return self._put_rdf(body, mimetype=rdf_type) def sparql(self, query, args={}): """Performs a SPARQL query and simply returns the body of the response if successful - if there is an issue, such as a code 404 or 500, this method will return False. Use the _query_sparql_service method to get hold of the complete response in this case.""" response = self._query_sparql_service(query, args) headers = response.get('headers') status = headers.get('status', headers.get('Status')) if status in ['200', 200, '204', 204]: return response.get('body').encode('UTF-8') else: return False def search(self, query, args={}): """Performs a search query and simply returns the body of the response if successful - if there is an issue, such as a code 404 or 500, this method will return False. Use the _query_search_service method to get hold of the complete response in this case.""" response = self._query_search_service(query, args) headers = response.get('headers') status = headers.get('status', headers.get('Status')) if status in ['200', 200, '204', 204]: parsed_atom = Atom_Search_Results( response.get('body').encode('UTF-8')) return parsed_atom.get_item_list() else: return False
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()