def zebra_alert_handler(socket, address): try: fileobj = socket.makefile() while True: line = fileobj.readline() if not line: break fileobj.write(line) fileobj.flush() raw_msg = line.strip() message_split = raw_msg.split(':') if message_split[0] == 'ALERT' or message_split[0] == 'ERROR CONDITION': #it's an alert/error, is_cleared=False elif message_split[0] == 'ALERT CLEARED' or message_split[0] == 'ERROR CLEARED': is_cleared=True else: is_cleared=True condition = message_split[1].split('[')[0].strip().lower() printer_uri = identify_printer(address, printers) res = Resource(celeryconfig.SERVER_HOST) auth_params = {'username':celeryconfig.ZPRINTER_USERNAME, 'api_key': celeryconfig.ZPRINTER_API_KEY} #r = res.get('/api/zebra_status/', params_dict=auth_params) new_instance = dict() new_instance['printer'] = printer_uri new_instance['event_date'] = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.000") new_instance['status'] = condition new_instance['is_cleared'] = is_cleared res.post('api/zebra_status/', simplejson.dumps(new_instance), headers={'Content-Type': 'application/json'}, params_dict=auth_params) except Exception, ex: logging.error("Unknown exception, gobbling up: %s", ex)
def post_authenticated_data(data, url, username, password, headers=None): """ Post basic authenticated data, using restkit """ auth = BasicAuth(username, password) r = Resource(url, filters=[auth, ]) if headers is not None: return (r.post(payload=data, headers=headers).body_string(), None) return (r.post(payload=data).body_string(), None)
def post_authenticated_data(data, url, username, password, headers=None): """ Post basic authenticated data, using restkit """ auth = BasicAuth(username, password) r = Resource(url, filters=[ auth, ]) if headers is not None: return (r.post(payload=data, headers=headers).body_string(), None) return (r.post(payload=data).body_string(), None)
def post_unauthenticated_data(data, url): """ Post basic unauthenticated data, using restkit instead of the post_data method. """ r = Resource(url, filters=[]) return r.post(payload=data).body_string(), None
def _post_payload(host, path, data, **kwargs): """generic function to handle posting data :rtype : return body of page :param host: host to send data to :param path: path to interact with :param data: data to send :param kwargs: additional keyword args """ if "http://" not in host: host = "http://{0}".format(host) res = Resource(host) payload = "jsonParameters={0}".format(json.dumps(data)) for key, value in kwargs.items(): payload += '&{0}={1}'.format(key, json.dumps(value)) headers = {"Content-Type": "application/json"} # print "path is %s" % path page = res.post(path=path, payload=payload, headers=headers) body = page.body_string() if body: body = json.loads(body) if isinstance(body, dict) and "ERROR" in body: raise HelixException(body["ERROR"]) # test what was returned, see if any exceptions need to be raise # if not body: # raise HelixException("body for path {0} is empty".format(path)) # else: # print "BODY IS EMPTY FOR ", path # print "BODY is %s." % body return body
class Query(object): def __init__(self, url=GITHUB_URL, params=None, payload=None, headers=None, filters=None, access_token=None): self.url = url self.params = params or dict() self.payload = payload or dict() self.headers = headers or {'Content-Type': 'application/json'} filters = filters or list() self.resource = Resource( url, pool=ConnectionPool(factory=Connection), filters=filters, ) if access_token is not None: self.params["access_token"] = access_token def concat_path(self, *args): for path in args: self.resource.update_uri(path) def do_GET(self, path=None, params=None): params = params or self.params response = self.resource.get(path, self.headers, params) return self.parse_response(response.body_string()) def do_POST(self, path=None, payload=None, params=None): payload = payload or self.payload params = params or self.params response = self.resource.post(path, json.dumps(payload), self.headers, params) return self.parse_response(response.body_string()) def do_DELETE(self, path=None, params=None): params = params or self.params response = self.resource.delete(path, self.headers, params) return self.parse_response(response.body_string()) def do_PATCH(self, path=None, payload=None, params=None): payload = payload or self.payload params = params or self.params response = self.resource.request("PATCH", path, json.dumps(payload), self.headers, params) return self.parse_response(response.body_string()) def parse_response(self, response): try: return json.loads(response) except: return response def __repr__(self): return "uri:<{0}>".format(self.resource.uri) def __str__(self): return self.resource.uri
def _post_payload(self, path, data, **kwargs): """generic function to handle posting data :rtype : return body of page :param path: path to interact with :param data: data to send :param kwargs: additional keyword args """ res = Resource(self.host) payload = "jsonParameters={0}".format(json.dumps(data)) for key, value in kwargs.items(): payload += '&{0}={1}'.format(key, json.dumps(value)) headers = {"Content-Type": "application/json"} # print "path is %s" % path page = res.post(path=path, payload=payload, headers=headers) body = page.body_string() if body: body = json.loads(body) if isinstance(body, dict) and "ERROR" in body: raise HelixException(body["ERROR"]) # test what was returned, see if any exceptions need to be raise # if not body: # raise HelixException("body for path {0} is empty".format(path)) # else: # print "BODY IS EMPTY FOR ", path # print "BODY is %s." % body return body
def _run(self, action, headers=None, **kwargs): """ Requests API """ res = Resource(self.HOST) payload = kwargs payload.update({'action': action, 'api_token': self.api_token}) response = res.post(payload=payload, headers=headers) if response.status_int != 200: raise POEditorException( status='fail', error_code=response.status_int, message=response.status ) data = json.loads(response.body_string().decode('utf-8')) if 'response' not in data: raise POEditorException( status='fail', error_code=-1, message=u'"response" key is not present' ) if 'status' in data['response'] and \ data['response']['status'] != self.SUCCESS_CODE: raise POEditorException( error_code=data['response'].get('code'), status=data['response']['status'], message=data['response'].get('message') ) return data
def collect_from_zigbee(target, stream_id, device=DEFAULT_SERIAL_DEVICE, baud_rate=DEFAULT_BAUD_RATE): """Synchronously read from the serial port to target target can either be the URL of a couchdb server or a restkit resource instance. """ from xbee import ZigBee if not hasattr(target, "post"): target = Resource(target) serial_device = serial.Serial(device, baud_rate) headers = {"Content-Type": "application/json"} if stream_id is None: stream_prefix = "" else: stream_prefix = stream_id + "_" try: xbee = ZigBee(serial_device, escaped=True) # Continuously read and print packets while True: try: response = xbee.wait_read_frame() now = datetime.datetime.utcnow() timestamp = now.replace(microsecond=0).isoformat() + "Z" logging.debug(response) samples = response.get("samples", []) for sample in samples: for sensor_id, sensor_value in sample.iteritems(): target.post( headers=headers, payload=json.dumps( { # TODO: use a mapping mechanism instead of stream_id # prefix "datastream_id": stream_prefix + sensor_id, "value": sensor_value, "timestamp": timestamp, } ), ) except KeyboardInterrupt: break finally: serial_device.close()
def create_token(self, user, password): serverurl = "https://api.github.com" auth = BasicAuth(user, password) authreqdata = {"scopes": ["repo"], "note": "admin script"} resource = Resource('https://api.github.com/authorizations', pool=self.pool, filters=[auth]) response = resource.post(headers={"Content-Type": "application/json"}, payload=json.dumps(authreqdata)) self.token = json.loads(response.body_string())['token']
def create_pull_request(self, user, repo, to_user, base_branch, branch, title="", body=""): if not title: title = "Robot pull request. Please review." resource = Resource("https://api.github.com/repos/%s/%s/pulls" % (to_user, repo)) pulldata = {"title": title, "body": body, "head": "%s:%s" % (user, branch), "base": base_branch} response = resource.post(headers=self.headers, payload=json.dumps(pulldata)) return json.loads(response.body_string())
def _post(self, url, payload=None): auth = BasicAuth(self.login, self.password) res = Resource(url, filters=[auth]) headers = {'content-type': 'application/x-www-form-urlencoded'} r = res.post(payload=payload, headers=headers) if r.status_int == 204: # No content return None if r['Content-Type'].startswith('application/json'): return json.loads(r.body_string()) else: return r.body_string()
def get_printer_heartbeat(): """ Task to actively monitor the printer's status (vs. waiting to get alerts) """ if len(printer_dict.keys()) == 0: get_printers() msg_text = """^XA^HH^XZ""" for k,v in printer_dict.items(): print_host = v['ip_address'] print_port = v['port'] printer_uri = v['resource_uri'] info = do_send(print_host, print_port, msg_text, recv=True) #prepare the rest resource for sending info to server res = Resource(celeryconfig.SERVER_HOST, manager=manager) auth_params = {'username':celeryconfig.ZPRINTER_USERNAME, 'api_key': celeryconfig.ZPRINTER_API_KEY} new_instance = dict() new_instance['printer'] = printer_uri new_instance['event_date'] = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.000") new_instance['status'] = 'printer uptime heartbeat' if info is None or info == False: #failed to reach printer or receive data new_instance['is_cleared'] = False elif isinstance(info, str): #it's a string with info if info.count('ZPL MODE') > 0: #we got diagnostic info from printer new_instance['is_cleared'] = True else: #something else, error new_instance['is_cleared'] = False try: res.post('api/zebra_status/', simplejson.dumps(new_instance), headers={'Content-Type': 'application/json'}, params_dict=auth_params) except Exception, ex: logging.error("Error trying to post heartbeat to host %s" % ex)
def submit(self): """ Performs an order (HTTP POST) on the gateway """ if self.total_amount_cur == None: total_amount_cur = "" else: total_amount_cur = self.total_amount_cur values = { 'StoreId': self.store_id, 'Langue': self.langue, 'OfferURL': self.offer_url, 'UpdateURL': self.update_url, 'CartId': self.cart_id, 'Mode': self.mode, 'Count': self.count, 'Desc': self.desc, 'Qty': self.qty, 'ItmesPrices': self.items_price, 'AmountTX': self.amount_tx, 'ShippingCharge': self.shipping_charge, 'ShippingWeight': self.shipping_weight, 'TotalmountTx': self.total_amount_tx, 'TotalamountCur': total_amount_cur, 'SymbolCur': self.symbol_cur, 'MultiPayment': self.multi_payment, 'BuyerName': self.buyer_name, 'Address': self.address, 'City': self.city, 'State': self.state, 'Country': self.country, 'Postcode': self.postcode, 'Tel': self.phone, 'Email': self.email, 'Checksum': self._checksum(), } data = _unicode_urlencode(values) res = Resource(self.get_endpoint()) r = res.post(payload=data, headers={'Content-Type': 'application/x-www-form-urlencoded'}) return r
def create_pull_request(self, user, repo, to_user, base_branch, branch, title="", body=""): if not title: title = "Robot pull request. Please review." resource = Resource("https://api.github.com/repos/%s/%s/pulls" % (to_user, repo)) pulldata = { "title": title, "body": body, "head": "%s:%s" % (user, branch), "base": base_branch } response = resource.post(headers=self.headers, payload=json.dumps(pulldata)) return json.loads(response.body_string())
def createTask(server_base_url, user, password, project, task_summary): auth = BasicAuth(user, password) resource_name = "issue" complete_url = "%s/rest/api/latest/%s/" % (server_base_url, resource_name) resource = Resource(complete_url, filters=[auth]) try: data = { "fields": { "project": { "key": project }, "summary": task_summary, "issuetype": { "name": "Task" } } } response = resource.post(headers={'Content-Type': 'application/json'}, payload=json.dumps(data)) except Exception, ex: print "EXCEPTION: %s " % ex.msg return None
def create_ticket(host_url, auth, ticket_fields): """ Takes all of the necessary information about the server and ticket and submits a POST request to the jira server's Rest API to create a ticket. :param host_url: The url of the jira server. :param auth: Credentials to the account the ticket will be created as. :param ticket_fields: a dictionary containing all of the information/data necessary to create the ticket :return: jira_issue: The json of the response from the server. This can be used to get information about the created ticekt later on. """ # Constructing the URL to POST to complete_url = "%s/rest/api/2/issue/" % host_url # Create the resource using restkit resource = Resource(complete_url, filters=[auth]) post_headers = {'Content-Type': 'application/json'} # Try POSTing to Jira Rest API. If failure, exit and print error message. try: data = { "fields": { "project": { "key": ticket_fields['project'] }, "summary": ticket_fields['summary'], "issuetype": { "name": ticket_fields['issue_type'] } } } response = resource.post(headers=post_headers, payload=json.dumps(data)) except Exception, ex: print("EXCEPTION: %s " % ex.message) return None
msg.replace("\n", "") commitList.append([commit["id"], msg]) issueMessage = "# %s is now failing!#\n\n" % jobName issueMessage += "Someone broke jenkins!\n\n" issueMessage += "## Guilty Commits ##\n" for commit in commitList: issueMessage += "* [%s](%s/commit/%s)\n" % (commit[1], githubUrl, commit[0]) issueMessage += "\n\n## Jenkins Reference ##\n" issueMessage += "Build URL: %s\n" % failingBuild["url"] issueMessage += "\n\nThanks, \nJenkins :cop:\n\n\n" issueMessage += "DMWMJENKINSMAGIC: %s!%s!%s" % (jobName, repo, lastBuild) resource = Resource("https://api.github.com/repos/dmwm/%s/issues" % repo, pool=pool) issueInfo = {"title": issueTitle, "body": issueMessage, "labels": ["JenkinsFail"]} response = resource.post(headers=headers, payload=json.dumps(issueInfo)) repos = json.loads(response.body_string()) # print issueMessage sys.exit(0) { "actions": [ { "parameters": [ {"name": "WMAGENT_VERSION", "value": ""}, {"name": "SCRAM_ARCH", "value": "slc5_amd64_gcc461"}, {"name": "branch", "value": "master"}, {"name": "pathToTest", "value": "test/python"}, {"name": "unused", "value": ""},
def _post_request(url_path, payload): auth = BasicAuth('breyten','0116ffc25e28b40c883b6ae8a46a9bd49373e7c5') res = Resource('http://toevalofniet.com', filters=[auth]) headers = ({'Accepted': 'application/json', 'Content‐Type': 'application/json'}) result = res.post(path='/api/1.0/' + url_path + '/', payload=payload, headers=headers) return result
class StoreClient(object): def __init__(self, endpoint, name, **kwargs): if endpoint.endswith('/'): endpoint = endpoint.rstrip('/') if 'pool' not in kwargs: kwargs['pool'] = ConnectionPool(factory=Connection) self.json_default = kwargs.get('json_default', json_util.default) self.json_object_hook = kwargs.get('json_object_hook', json_util.object_hook) self.resource = Resource(endpoint, **kwargs) self.name = name def create_store(self, store): response = self.resource.post("/stores/%s" % store) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def get_stores(self): response = self.resource.get("/stores") if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def create_branch(self, store, branch, parent=None): path = _build_path(store, "branch", branch) params = _build_params(parent=parent) response = self.resource.post(path, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def get_branch(self, store, branch): path = _build_path(store, "branch", branch) response = self.resource.get(path) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def merge(self, store, source, target='master', author=None, committer=None): path = _build_path(store, "merge", source) params = _build_params(target=target, author=author, committer=committer) response = self.resource.post(path, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def get(self, store, key=None, shallow=False, branch='master', commit_sha=None): path = _entry_path(store, key) params = _build_params(shallow=shallow, branch=branch, commit_sha=commit_sha) response = self.resource.get(path, params_dict=params) if response.status_int == 200: response_body = response.body_string() return json.loads(response_body, object_hook=self.json_object_hook) def put(self, store, key, value, flatten_keys=True, branch='master', author=None, committer=None): path = _entry_path(store, key) payload = json.dumps(value, default=self.json_default) flatten_keys = 1 if flatten_keys else 0 params = _build_params(flatten_keys=flatten_keys, branch=branch, author=author, committer=committer) headers = {'Content-Type': 'application/json'} response = self.resource.put(path, headers=headers, payload=payload, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def delete(self, store, key, branch='master', author=None, committer=None): path = _entry_path(store, key) params = _build_params(branch=branch, author=author, committer=committer) response = self.resource.delete(path, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def keys(self, store, key=None, pattern=None, depth=None, filter_by=None, branch='master', commit_sha=None): path = _build_path(store, "keys", key) params = _build_params(pattern=pattern, depth=depth, filter_by=filter_by, branch=branch, commit_sha=commit_sha) response = self.resource.get(path, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def entries(self, store, key=None, pattern=None, depth=None, branch='master', commit_sha=None): path = _build_path(store, "entries", key) params = _build_params(pattern=pattern, depth=depth, branch=branch, commit_sha=commit_sha) response = self.resource.get(path, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook) def trees(self, store, key=None, pattern=None, depth=None, object_depth=None, branch='master', commit_sha=None): path = _build_path(store, "trees", key) params = _build_params(pattern=pattern, depth=depth, object_depth=object_depth, branch=branch, commit_sha=commit_sha) response = self.resource.get(path, params_dict=params) if response.status_int == 200: return json.loads(response.body_string(), object_hook=self.json_object_hook)
from socketpool import ConnectionPool import getpass pool = ConnectionPool(factory=Connection) serverurl="https://api.github.com" print 'Enter your username:'******'https://api.github.com/authorizations', pool=pool, filters=[auth]) response = resource.post(headers={ "Content-Type": "application/json" }, payload=json.dumps(authreqdata)) token = json.loads(response.body_string())['token'] """ Once you have a token, you can pass that in the Authorization header You can store this in a cache and throw away the user/password This is just an example query. See http://developer.github.com/v3/ for more about the url structure """ #token = '94038d59a46c5ea1aa4f11626a83cde3e8794668' resource = Resource('https://api.github.com/user/repos', pool=pool) headers = {'Content-Type' : 'application/json' } headers['Authorization'] = 'token %s' % token response = resource.get(headers = headers) repos = json.loads(response.body_string()) for each in repos: print each['clone_url']
def update_pull_request(self, user, repo, number, data): resource = Resource("https://api.github.com/repos/%s/%s/pulls/%s" % (user, repo, number)) res = resource.post(headers=self.headers, payload=json.dumps(data)) return json.loads(res.body_string())
class Client(object): """Derek client.""" def __init__(self, username, password, host=DEFAULT_HOST, port=DEFAULT_PORT): """Constructor.""" auth = BasicAuth(username, password) self.resource = Resource("http://%s:%d" % (host, port), filters=[auth]) def post(self, path, payload=None): """Do POST request to Derek.""" if payload is None: payload = {} headers = {"content-type": "application/x-www-form-urlencoded"} resp = self.resource.post(path=path, payload=dict2qs(payload), headers=headers) return resp def postjson(self, path, payload=None): """Do POST request to Derek and expect JSON in response.""" if payload is None: payload = {} headers = {"accept": "application/json", "content-type": "application/x-www-form-urlencoded"} resp = self.resource.post(path=path, payload=dict2qs(payload), headers=headers) return json.loads(resp.body_string()) def getjson(self, path, params=None): """Do GET request to Derek and expect JSON in response.""" if params is None: params = {} headers = {"accept": "application/json"} resp = self.resource.get(path=path, headers=headers, **params) return json.loads(resp.body_string()) def download(self, path, out): """Download file.""" resp = self.resource.get(path=path) with resp.body_stream() as body: with open(out, "wb") as handle: for block in body: handle.write(block) def upload(self, path, filepath): """Upload file to server.""" with open(filepath) as pfile: self.resource.post(path=path, payload=pfile) def branch(self, branch_id): """Return Branch object.""" return Branch(self, branch_id) def slice(self, slice_id): """Return Slice object.""" return Slice(self, slice_id) def user(self, username): """Return User object.""" return User(self, username) def repo(self, repo_id): """Return repository object.""" return Repo(self, repo_id)
class Query(object): def __init__(self, url=GITHUB_URL, params=None, payload=None, headers=None, filters=None, access_token=None): self.url = url self.params = params or dict() self.payload = payload or dict() self.headers = headers or {'Content-Type':'application/json'} filters = filters or list() self.resource = Resource( url, pool=ConnectionPool(factory=Connection), filters=filters, ) if access_token is not None: self.params["access_token"] = access_token def concat_path(self, *args): for path in args: self.resource.update_uri(path) def do_GET(self, path=None, params=None): params = params or self.params response = self.resource.get( path, self.headers, params) return self.parse_response(response.body_string()) def do_POST(self, path=None, payload=None, params=None): payload = payload or self.payload params = params or self.params response = self.resource.post( path, json.dumps(payload), self.headers, params) return self.parse_response(response.body_string()) def do_DELETE(self, path=None, params=None): params = params or self.params response = self.resource.delete( path, self.headers, params) return self.parse_response(response.body_string()) def do_PATCH(self, path=None, payload=None, params=None): payload = payload or self.payload params = params or self.params response = self.resource.request( "PATCH", path, json.dumps(payload), self.headers, params) return self.parse_response(response.body_string()) def parse_response(self, response): try: return json.loads(response) except: return response def __repr__(self): return u"uri:<{0}>".format(self.resource.uri) def __str__(self): return self.resource.uri
def save_base(self, raw=False, cls=None, origin=None, force_insert=False, force_update=False, using=None, update_fields=None): """ Does the heavy-lifting involved in saving. Subclasses shouldn't need to override this method. It's separate from save() in order to hide the need for overrides of save() to pass around internal-only parameters ('raw', 'cls', and 'origin'). """ assert not (force_insert and force_update) record_exists = False if cls is None: cls = self.__class__ meta = cls._meta if not meta.proxy: origin = cls else: meta = cls._meta if origin and not getattr(meta, "auto_created", False): signals.pre_save.send(sender=origin, instance=self, raw=raw) model_name = str(meta) # If we are in a raw save, save the object exactly as presented. # That means that we don't try to be smart about saving attributes # that might have come from the parent class - we just save the # attributes we have been given to the class we have been given. # We also go through this process to defer the save of proxy objects # to their actual underlying model. if not raw or meta.proxy: if meta.proxy: org = cls else: org = None for parent, field in meta.parents.items(): # At this point, parent's primary key field may be unknown # (for example, from administration form which doesn't fill # this field). If so, fill it. if field and getattr( self, parent._meta.pk.attname) is None and getattr( self, field.attname) is not None: setattr(self, parent._meta.pk.attname, getattr(self, field.attname)) self.save_base(cls=parent, origin=org, using=using) if field: setattr(self, field.attname, self._get_pk_val(parent._meta)) if meta.proxy: return if not meta.proxy: pk_val = self._get_pk_val(meta) pk_is_set = pk_val is not None get_args = {} get_args[ROA_ARGS_NAMES_MAPPING.get('FORMAT', 'format')] = ROA_FORMAT get_args.update(ROA_CUSTOM_ARGS) # Construct Json payload serializer = self.get_serializer(self) payload = self.get_renderer().render(serializer.data) # Add serializer content_type headers = get_roa_headers() headers.update(self.get_serializer_content_type()) # check if resource use custom primary key if not meta.pk.attname in ['pk', 'id']: # consider it might be inserting so check it first # @todo: try to improve this block to check if custom pripary key is not None first resource = Resource(self.get_resource_url_detail(), filters=ROA_FILTERS, **ROA_SSL_ARGS) try: response = resource.get(payload=None, headers=headers, **get_args) except ResourceNotFound: # since such resource does not exist, it's actually creating pk_is_set = False except RequestFailed: pk_is_set = False if force_update or pk_is_set and not self.pk is None: record_exists = True resource = Resource(self.get_resource_url_detail(), filters=ROA_FILTERS, **ROA_SSL_ARGS) try: logger.debug( u"""Modifying : "%s" through %s with payload "%s" and GET args "%s" """ % (force_unicode(self), force_unicode(resource.uri), force_unicode(payload), force_unicode(get_args))) response = resource.put(payload=payload, headers=headers, **get_args) except RequestFailed as e: raise ROAException(e) else: record_exists = False resource = Resource(self.get_resource_url_list(), filters=ROA_FILTERS, **ROA_SSL_ARGS) try: logger.debug( u"""Creating : "%s" through %s with payload "%s" and GET args "%s" """ % (force_unicode(self), force_unicode(resource.uri), force_unicode(payload), force_unicode(get_args))) response = resource.post(payload=payload, headers=headers, **get_args) except RequestFailed as e: raise ROAException(e) response = force_unicode( response.body_string()).encode(DEFAULT_CHARSET) data = self.get_parser().parse(StringIO(response)) serializer = self.get_serializer(data=data) if not serializer.is_valid(): raise ROAException( u'Invalid deserialization for %s model: %s' % (self, serializer.errors)) obj = self.__class__(**serializer.initial_data) try: self.pk = int(obj.pk) except ValueError: self.pk = obj.pk self = obj if origin: signals.post_save.send(sender=origin, instance=self, created=(not record_exists), raw=raw)
class WWWcomm: def __init__(self, MIDpass, configPath, baseURL, uploadPath, RCstatusPath, MIDname=None): # self.baseURL = defaultConfig.baseURL # self.password = defaultConfig # obtain base configuration self.MIDpass = MIDpass self.baseURL = baseURL self.configPath = configPath self.resource = Resource(baseURL, timeout=60) # self.upResource = Resource("http://isadoredev1.exotericanalytics.com:5050") self.uploadPath = uploadPath self.RCstatusPath = RCstatusPath self.MIDname = MIDname def getConfig(self): params_dict = {"mid_pass": self.MIDpass, "ts": "blah"} if self.MIDname: params_dict["mid_name"] = self.MIDname output = self.resource.get(path=self.configPath, params_dict=params_dict, verify=False) logging.debug("WWW reply status code: " + str(output.status_int) + ".") if output.status_int != 200: raise MIDconfigDownloadError(output) return json.loads(output.body_string()) def RC_cmd_status(self, control_id, fetched_p): """ """ # TODO: check output for errors, don't just rely upon exceptions try: if fetched_p: output = self.resource.put(path=self.RCstatusPath + str(control_id), params_dict={ "fetched": 1, "MID_pass": self.MIDpass }, verify=False) else: output = self.resource.put(path=self.RCstatusPath + str(control_id), params_dict={ "fetched": 0, "MID_pass": self.MIDpass }, verify=False) if output.status_int != 204: raise MID_RCstatusError( "Failed to inform WWW of successful RC command: " + str(control_id) + ". Received response status int: " + str(output.status_int)) except Exception as e: raise MID_RCstatusError( "Failed to inform WWW of unsuccessful RC command: " + str(control_id) + ". This is the result of exception: " + str(e)) def uploadData(self, paramString): # output = self.upResource.get(path=self.uploadPath, # params_dict={"data":paramString}) # NOTE: can remove verify param once we upgrade Python to 2.7.9+ output = self.resource.post(path=self.uploadPath, params_dict={"data": paramString}, verify=False) output.skip_body() # to release the connection return output def uploadReading(self, passwd, readingTime, cmds, errors): payload = { "mid_pass": passwd, "datetime": readingTime.isoformat(), "data": json.dumps( reduce(lambda x, y: x + y.to_JSON_WWW_data(readingTime), cmds, [])), "errors": [] } # TODO: deal with requests-specific exceptions. in particular, the timeout exception. for now, letting MID.py deal with it. # NOTE: can remove verify param once we upgrade Python to 2.7.9+ logging.debug(payload["data"]) r = requests.post(self.baseURL + self.uploadPath, data=payload, timeout=60.0, verify=False)
def save_base(self, raw=False, cls=None, origin=None, force_insert=False, force_update=False, using=None, update_fields=None): """ Does the heavy-lifting involved in saving. Subclasses shouldn't need to override this method. It's separate from save() in order to hide the need for overrides of save() to pass around internal-only parameters ('raw', 'cls', and 'origin'). """ assert not (force_insert and force_update) record_exists = False if cls is None: cls = self.__class__ meta = cls._meta if not meta.proxy: origin = cls else: meta = cls._meta if origin and not getattr(meta, "auto_created", False): signals.pre_save.send(sender=origin, instance=self, raw=raw) model_name = str(meta) # If we are in a raw save, save the object exactly as presented. # That means that we don't try to be smart about saving attributes # that might have come from the parent class - we just save the # attributes we have been given to the class we have been given. # We also go through this process to defer the save of proxy objects # to their actual underlying model. if not raw or meta.proxy: if meta.proxy: org = cls else: org = None for parent, field in meta.parents.items(): # At this point, parent's primary key field may be unknown # (for example, from administration form which doesn't fill # this field). If so, fill it. if field and getattr(self, parent._meta.pk.attname) is None and getattr(self, field.attname) is not None: setattr(self, parent._meta.pk.attname, getattr(self, field.attname)) self.save_base(cls=parent, origin=org, using=using) if field: setattr(self, field.attname, self._get_pk_val(parent._meta)) if meta.proxy: return if not meta.proxy: pk_val = self._get_pk_val(meta) pk_is_set = pk_val is not None get_args = {'format': ROA_FORMAT} get_args.update(ROA_CUSTOM_ARGS) # Construct Json payload serializer = self.get_serializer(self) payload = self.get_renderer().render(serializer.data) # Add serializer content_type headers = get_roa_headers() headers.update(self.get_serializer_content_type()) # check if resource use custom primary key if not meta.pk.attname in ['pk', 'id']: # consider it might be inserting so check it first # @todo: try to improve this block to check if custom pripary key is not None first resource = Resource(self.get_resource_url_detail(), headers=headers, filters=ROA_FILTERS) try: response = resource.get(payload=None, **get_args) except ResourceNotFound: # since such resource does not exist, it's actually creating pk_is_set = False except RequestFailed: pk_is_set = False if force_update or pk_is_set and not self.pk is None: record_exists = True resource = Resource(self.get_resource_url_detail(), filters=ROA_FILTERS) try: logger.debug(u"""Modifying : "%s" through %s with payload "%s" and GET args "%s" """ % ( force_unicode(self), force_unicode(resource.uri), force_unicode(payload), force_unicode(get_args))) response = resource.put(payload=payload, headers=headers, **get_args) except RequestFailed as e: raise ROAException(e) else: record_exists = False resource = Resource(self.get_resource_url_list(), filters=ROA_FILTERS) try: logger.debug(u"""Creating : "%s" through %s with payload "%s" and GET args "%s" """ % ( force_unicode(self), force_unicode(resource.uri), force_unicode(payload), force_unicode(get_args))) response = resource.post(payload=payload, headers=headers, **get_args) except RequestFailed as e: raise ROAException(e) response = force_unicode(response.body_string()).encode(DEFAULT_CHARSET) data = self.get_parser().parse(StringIO(response)) serializer = self.get_serializer(data=data) if not serializer.is_valid(): raise ROAException(u'Invalid deserialization for {} model: {}'.format(self, serializer.errors)) try: self.pk = int(serializer.object.pk) except ValueError: self.pk = serializer.object.pk self = serializer.object if origin: signals.post_save.send(sender=origin, instance=self, created=(not record_exists), raw=raw)
def save_base(self, raw=False, cls=None, origin=None, force_insert=False, force_update=False, using=None): """ Does the heavy-lifting involved in saving. Subclasses shouldn't need to override this method. It's separate from save() in order to hide the need for overrides of save() to pass around internal-only parameters ('raw', 'cls', and 'origin'). """ assert not (force_insert and force_update) if cls is None: cls = self.__class__ meta = cls._meta if not meta.proxy: origin = cls else: meta = cls._meta if origin and not getattr(meta, "auto_created", False): signals.pre_save.send(sender=origin, instance=self, raw=raw) # If we are in a raw save, save the object exactly as presented. # That means that we don't try to be smart about saving attributes # that might have come from the parent class - we just save the # attributes we have been given to the class we have been given. # We also go through this process to defer the save of proxy objects # to their actual underlying model. if not raw or meta.proxy: if meta.proxy: org = cls else: org = None for parent, field in meta.parents.items(): # At this point, parent's primary key field may be unknown # (for example, from administration form which doesn't fill # this field). If so, fill it. if field and getattr(self, parent._meta.pk.attname) is None \ and getattr(self, field.attname) is not None: setattr(self, parent._meta.pk.attname, getattr(self, field.attname)) self.save_base(cls=parent, origin=org) if field: setattr(self, field.attname, self._get_pk_val(parent._meta)) if meta.proxy: return if not meta.proxy: pk_val = self._get_pk_val(meta) pk_set = pk_val is not None get_args = {'format': ROA_FORMAT} get_args.update(getattr(settings, "ROA_CUSTOM_ARGS", {})) serializer = serializers.get_serializer(ROA_FORMAT) if hasattr(serializer, 'serialize_object'): payload = serializer().serialize_object(self) else: payload = {} for field in meta.local_fields: # Handle FK fields if isinstance(field, models.ForeignKey): field_attr = getattr(self, field.name) if field_attr is None: payload[field.attname] = None else: payload[field.attname] = field_attr.pk # Handle all other fields else: payload[field.name] = field.value_to_string(self) # Handle M2M relations in case of update if force_update or pk_set and not self.pk is None: for field in meta.many_to_many: # First try to get ids from var set in query's add/remove/clear if hasattr(self, '%s_updated_ids' % field.attname): field_pks = getattr(self, '%s_updated_ids' % field.attname) else: field_pks = [obj.pk for obj in field.value_from_object(self)] payload[field.attname] = ','.join(smart_unicode(pk) for pk in field_pks) if force_update or pk_set and not self.pk is None: record_exists = True resource = Resource(self.get_resource_url_detail(), headers=ROA_HEADERS, filters=ROA_FILTERS) try: logger.debug(u"""Modifying : "%s" through %s with payload "%s" and GET args "%s" """ % ( force_unicode(self), force_unicode(resource.uri), force_unicode(payload), force_unicode(get_args))) response = resource.put(payload=payload, **get_args) except RequestFailed, e: raise ROAException(e) else: record_exists = False resource = Resource(self.get_resource_url_list(), headers=ROA_HEADERS, filters=ROA_FILTERS) try: logger.debug(u"""Creating : "%s" through %s with payload "%s" and GET args "%s" """ % ( force_unicode(self), force_unicode(resource.uri), force_unicode(payload), force_unicode(get_args))) response = resource.post(payload=payload, **get_args) except RequestFailed, e: raise ROAException(e)