def _send_notify(pushbulletapi, message): http_handler = HTTPSConnection("api.pushbullet.com") if not pushbulletapi: pushbulletapi = autosub.PUSHBULLETAPI mydata = {'type': 'note'.encode('utf-8'), 'title': 'Auto-Sub'.encode('utf-8'), 'body': message.encode('utf-8') } try: http_handler.request('POST', '/v2/pushes', body=json.dumps(mydata), headers={'Content-Type': 'application/json', 'Authorization': 'Bearer %s' % pushbulletapi}) except: log.error("Pushbullet: notification failed.") return False response = http_handler.getresponse() request_status = response.status if request_status == 200: log.info("Pushbullet: notification sent.") return True elif request_status == 401: log.error("Pushbullet: No valid access token provided") return False elif request_status == 403: log.error("Pushbullet: The access token is not valid for that request") return False else: log.error("Pushbullet: notification failed with error") return False
def test_no_content_length(self): # "The presence of a message-body in a request is signaled by the # inclusion of a Content-Length or Transfer-Encoding header field in # the request's message-headers." # # Send a message with neither header and no body. Even though # the request is of method POST, this should be OK because we set # request.process_request_body to False for our handler. if self.scheme == "https": c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT)) else: c = HTTPConnection('%s:%s' % (self.interface(), self.PORT)) c.request("POST", "/no_body") response = c.getresponse() self.body = response.fp.read() self.status = str(response.status) self.assertStatus(200) self.assertBody('Hello world!') # Now send a message that has no Content-Length, but does send a body. # Verify that CP times out the socket and responds # with 411 Length Required. if self.scheme == "https": c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT)) else: c = HTTPConnection('%s:%s' % (self.interface(), self.PORT)) c.request("POST", "/") response = c.getresponse() self.body = response.fp.read() self.status = str(response.status) self.assertStatus(411)
class CMSWeb (object): def __init__ (self): self.URL_CMSWEB_BASE='cmsweb.cern.ch' self.URL_PHEDEX_BLOCKREPLICAS='/phedex/datasvc/json/prod/blockreplicas' self.URL_DBS_DATASETS='/dbs/prod/global/DBSReader/datasets' self.URL_DBS_FILES='/dbs/prod/global/DBSReader/files' self.URL_DBS_RUNS='/dbs/prod/global/DBSReader/runs' self.URL_DBS_BLOCKS='/dbs/prod/global/DBSReader/blocks' self.conn = HTTPSConnection(self.URL_CMSWEB_BASE, cert_file='/tmp/x509up_u{0}'.format(getuid()), timeout=30) self.reply_cache = {} self.last_result = "" self.errors = 0 def __del__(self): self.conn.close () def get_cmsweb_data(self, url): self.last_result = url if url in self.reply_cache: return True, self.reply_cache[url] msg ="" try: self.conn.request('GET', url) msg = self.conn.getresponse() if msg.status!=200: self.errors = self.errors + 1 print 'Result: {0} {1}: {2}'.format(msg.status, msg.reason, url) return False, {} self.reply_cache[url]=json.loads(msg.read()) return True, self.reply_cache[url] except Exception, e: print "Error:", e, url self.errors = self.errors + 1 return False, {}
def notify(self, message, event, module=None): if not mylar.PROWL_ENABLED: return if module is None: module = '' module += '[NOTIFIER]' http_handler = HTTPSConnection("api.prowlapp.com") data = {'apikey': mylar.PROWL_KEYS, 'application': 'Mylar', 'event': event, 'description': message.encode("utf-8"), 'priority': mylar.PROWL_PRIORITY } http_handler.request("POST", "/publicapi/add", headers = {'Content-type': "application/x-www-form-urlencoded"}, body = urlencode(data)) response = http_handler.getresponse() request_status = response.status if request_status == 200: logger.info(module + ' Prowl notifications sent.') return True elif request_status == 401: logger.info(module + ' Prowl auth failed: %s' % response.reason) return False else: logger.info(module + ' Prowl notification failed.') return False
def send(token, title, **kwargs): """ Site: https://boxcar.io/ API: http://help.boxcar.io/knowledgebase/topics/48115-boxcar-api Desc: Best app for system administrators """ headers = { "Content-type": "application/x-www-form-urlencoded", "User-Agent": "DBMail/%s" % get_version(), } data = { "user_credentials": token, "notification[title]": from_unicode(title), "notification[sound]": "notifier-2" } for k, v in kwargs.items(): data['notification[%s]' % k] = from_unicode(v) http = HTTPSConnection(kwargs.pop("api_url", "new.boxcar.io")) http.request( "POST", "/api/notifications", headers=headers, body=urlencode(data)) response = http.getresponse() if response.status != 201: raise BoxcarError(response.reason) return True
def _send_notify(pushalotapi, message): http_handler = HTTPSConnection("pushalot.com") if not pushalotapi: pushalotapi = autosub.PUSHALOTAPI data = {'AuthorizationToken': pushalotapi, 'Title': "Auto-Sub", 'Body': message.encode('utf-8') } try: http_handler.request("POST", "/api/sendmessage", headers = {'Content-type': "application/x-www-form-urlencoded"}, body = urlencode(data)) except: log.error("Pushalot: notification failed.") return False response = http_handler.getresponse() request_status = response.status if request_status == 200: log.info("Pushalot: notification sent.") return True elif request_status == 410: log.error("Pushalot: Auth failed %s" % response.reason) return False else: log.error("Pushalot: notification failed.") return False
def USCWebGISGeocoder(address, locality, region, zipcode, apiKey): uscwebgisUrl = "/Services/Geocode/WebService/GeocoderWebServiceHttpNonParsed_V02_96.aspx?" queryParams = { 'zip' : zipcode, 'apiKey' : apiKey, 'version' : '2.96', 'format' : 'csv', } if not address is None: queryParams['streetAddress'] = address if not locality is None: queryParams['city'] = locality if not region is None: queryParams['state'] = region requestUrl = uscwebgisUrl + urlencode(queryParams) conn = HTTPSConnection('webgis.usc.edu') geocodeRequest = conn.request('GET', requestUrl) response = conn.getresponse() if response.status != 200: raise LocationNotFoundError('Status code was not 200') parsedData = response.read().split(',') if parsedData[2] != "200": raise LocationNotFoundError('results contained error') return (float(parsedData[3]) , float(parsedData[4]))
def _sendPushalot(self, pushalot_authorizationtoken=None, event=None, message=None, force=False): if not sickrage.srCore.srConfig.USE_PUSHALOT and not force: return False sickrage.srCore.srLogger.debug("Pushalot event: " + event) sickrage.srCore.srLogger.debug("Pushalot message: " + message) sickrage.srCore.srLogger.debug("Pushalot api: " + pushalot_authorizationtoken) http_handler = HTTPSConnection("pushalot.com") data = {'AuthorizationToken': pushalot_authorizationtoken, 'Title': event.encode('utf-8'), 'Body': message.encode('utf-8')} try: http_handler.request("POST", "/api/sendmessage", headers={'Content-type': "application/x-www-form-urlencoded"}, body=urlencode(data)) except (SSLError, HTTPException, socket.error): sickrage.srCore.srLogger.error("Pushalot notification failed.") return False response = http_handler.getresponse() request_status = response.status if request_status == 200: sickrage.srCore.srLogger.debug("Pushalot notifications sent.") return True elif request_status == 410: sickrage.srCore.srLogger.error("Pushalot auth failed: %s" % response.reason) return False else: sickrage.srCore.srLogger.error("Pushalot notification failed.") return False
def _load_token(cls): """ Загружает новый токен. @return: string """ logger.debug("loading token") logger.warning("looks like you do not have token in your settings_local.py yet") logger.warning("please get an auth code from %s", cls._get_auth_url()) logger.warning("it is better to set TOKEN variable on settings_local.py but you can just put in it here") logger.warning("see README for more information") auth_code = raw_input() logger.debug("auth code is %s", auth_code) connection = HTTPSConnection("oauth.yandex.ru") body = urlencode( { "grant_type": "authorization_code", "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, "code": auth_code, } ) connection.request("POST", "/token", body) response = connection.getresponse().read() result = json.loads(response) token = result["access_token"] logger.debug("token loaded: %s", token) return token
def signin(request): result = {'nav_dreamspark': 'active'} if request.method == 'POST': form = SigninForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] domain = form.cleaned_data['domain'] password = form.cleaned_data['password'] user = authenticate(username=username, domain=domain, password=password) if user: try: onthehub = HTTPSConnection('e5.onthehub.com') onthehub.request('GET', '/WebStore/Security/AuthenticateUser.aspx?account=' + DREAMSPARK_ACCOUNT + '&username='******'&key=' + DREAMSPARK_KEY + '&academic_statuses=' + ('students' if domain == '@nou.com.cn' else 'faculty,staff') + '&email=' + user.email + '&last_name=' + user.last_name + '&first_name=' + user.first_name) response = onthehub.getresponse() if response.status == 200: return HttpResponseRedirect(response.read()) else: result['error'] = '与 DreamSpark 通信异常,请稍后重试' except: result['error'] = '与 DreamSpark 通信超时,请稍后重试' else: result['error'] = '邮箱地址或密码错误,请重新输入' result.update(csrf(request)) return render_to_response('dreamspark/signin.html', result)
def assertions(self): # Write the cert to disk with open('https-forwarder-test-cert', 'w') as f: f.write(self.ext_inputs['ssl_cert']) ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2) ssl_context.verify_mode = ssl.CERT_REQUIRED ssl_context.load_verify_locations('https-forwarder-test-cert') for i in range(40): sleep(10) try: http = HTTPSConnection( self.outputs['ip_ip'], context=ssl_context) # If the certificate isn't the one we provided # this step will fail... http.request('GET', '/') text = http.getresponse().read() self.assertEqual( self.outputs['vm_name'], text.strip()) except (ssl.SSLError, AssertionError) as e: print('attempt {}/40: {}'.format(i, e)) else: break else: self.fail('tried too many times to get the page')
def oauth_callback(self, params): if 'code' not in params: return None conn = HTTPSConnection("accounts.google.com") body = tools.encode_params({ "grant_type":"authorization_code", "code":params['code'], "client_id":secrets.GMAIL_CLIENT_ID, "client_secret":secrets.GMAIL_CLIENT_SECRET, "redirect_uri":secrets.BASE_REDIRECT_URL + "gmail", }) headers = { "Content-Type":"application/x-www-form-urlencoded", } conn.request("POST", "/o/oauth2/token", body, headers) resp = conn.getresponse() try: self.token = json.loads(resp.read())['access_token'] self.is_auth = True except (KeyError, ValueError): return None conn.close() conn = HTTPSConnection("www.googleapis.com") conn.request("GET","/oauth2/v1/tokeninfo?alt=json&access_token="+self.token,"",{}) resp = conn.getresponse() self.username = json.loads(resp.read())['email']
def _request(self, method, target, params, headers=None): """ Send an HTTP request. Params: method(string): HTTP method (i.e. GET, POST, PUT, DELETE, HEAD) target(string): target path (i.e. /schedule/new) params(string): HTTP parameters headers(array): HTTP headers Returns: Response body if successful, None otherwise. """ try: if self._connection is None: self._connection = HTTPSConnection(self._url, self._port) self._connection.request(method, target, params, self._headers if headers is None else headers) except CannotSendRequest: self._connection = HTTPSConnection(self._url, self._port) self.login(self._user) self._request(method, target, params, self._headers) except ImproperConnectionState: self._connection = HTTPSConnection(self._url, self._port) self.login(self._user) self._request(method, target, params, self._headers) response = self._connection.getresponse() return response.read()
def notify(self, message, event): if not headphones.CONFIG.PUSHBULLET_ENABLED: return http_handler = HTTPSConnection("api.pushbullet.com") data = {"type": "note", "title": "Headphones", "body": message.encode("utf-8")} http_handler.request( "POST", "/v2/pushes", headers={ "Content-type": "application/json", "Authorization": "Basic %s" % base64.b64encode(headphones.CONFIG.PUSHBULLET_APIKEY + ":"), }, body=json.dumps(data), ) response = http_handler.getresponse() request_status = response.status logger.debug(u"PushBullet response status: %r" % request_status) logger.debug(u"PushBullet response headers: %r" % response.getheaders()) logger.debug(u"PushBullet response body: %r" % response.read()) if request_status == 200: logger.info(u"PushBullet notifications sent.") return True elif request_status >= 400 and request_status < 500: logger.info(u"PushBullet request failed: %s" % response.reason) return False else: logger.info(u"PushBullet notification failed serverside.") return False
def notify(self, message, event): if not headphones.PUSHBULLET_ENABLED: return http_handler = HTTPSConnection("api.pushbullet.com") data = {'device_iden': headphones.PUSHBULLET_DEVICEID, 'type': "note", 'title': "Headphones", 'body': message.encode("utf-8") } http_handler.request("POST", "/api/pushes", headers = {'Content-type': "application/x-www-form-urlencoded", 'Authorization' : 'Basic %s' % base64.b64encode(headphones.PUSHBULLET_APIKEY + ":") }, body = urlencode(data)) response = http_handler.getresponse() request_status = response.status logger.debug(u"PushBullet response status: %r" % request_status) logger.debug(u"PushBullet response headers: %r" % response.getheaders()) logger.debug(u"PushBullet response body: %r" % response.read()) if request_status == 200: logger.info(u"PushBullet notifications sent.") return True elif request_status >= 400 and request_status < 500: logger.info(u"PushBullet request failed: %s" % response.reason) return False else: logger.info(u"PushBullet notification failed serverside.") return False
def pushover(message, token, user, title="JCVI: Job Monitor", \ priority=0, timestamp=None): """ pushover.net python API <https://pushover.net/faq#library-python> """ assert -1 <= priority <= 2, \ "Priority should be an int() between -1 and 2" if timestamp == None: from time import time timestamp = int(time()) retry, expire = (300, 3600) if priority == 2 \ else (None, None) conn = HTTPSConnection("api.pushover.net:443") conn.request("POST", "/1/messages.json", urlencode({ "token": token, "user": user, "message": message, "title": title, "priority": priority, "timestamp": timestamp, "retry": retry, "expire": expire, }), { "Content-type": "application/x-www-form-urlencoded" }) conn.getresponse()
def notify(self, message="", data={}, listener=None): if self.isDisabled(): return http_handler = HTTPSConnection("api.prowlapp.com") data = { "apikey": self.conf("api_key"), "application": self.default_title, "description": toUnicode(message), "priority": self.conf("priority"), } http_handler.request( "POST", "/publicapi/add", headers={"Content-type": "application/x-www-form-urlencoded"}, body=tryUrlencode(data), ) response = http_handler.getresponse() request_status = response.status if request_status == 200: log.info("Prowl notifications sent.") return True elif request_status == 401: log.error("Prowl auth failed: %s", response.reason) return False else: log.error("Prowl notification failed.") return False
def _get_signin_token(self, creds): """ GET the generated Signin Token from the federation endpoint :param creds: credentials to pass to the federation endpoint :type creds: dict :return: signin token returned by the federation endpoint :rtype: str """ host = 'signin.aws.amazon.com' req_path = 'https://signin.aws.amazon.com/federation' \ '?Action=getSigninToken' \ '&Session=%s' % quote_plus(json.dumps(creds)) logger.debug('HTTPS GET request to %s: %s', host, req_path) conn = HTTPSConnection(host, 443) conn.request('GET', req_path) resp = conn.getresponse() logger.debug('Response: HTTP %s %s', resp.status, resp.reason) logger.debug('Headers: %s', resp.getheaders()) body = resp.read() logger.debug('Body: %s', body.strip()) if resp.status != 200: logger.critical('AWS Federation endpoint responded HTTP %s %s: %s', resp.status, resp.reason, body) raise RuntimeError('Error obtaining console signin credentials.') try: b = json.loads(body)['SigninToken'] except Exception: logger.critical( 'AWS Federation endpoint returned an invalid response: %s', body ) raise RuntimeError('Invalid response from AWS Federation endpoint.') return b
def notify(self, message, event): if not headphones.PUSHOVER_ENABLED: return http_handler = HTTPSConnection("api.pushover.net") data = {'token': self.application_token, 'user': headphones.PUSHOVER_KEYS, 'title': event, 'message': message.encode("utf-8"), 'priority': headphones.PUSHOVER_PRIORITY } http_handler.request("POST", "/1/messages.json", headers = {'Content-type': "application/x-www-form-urlencoded"}, body = urlencode(data)) response = http_handler.getresponse() request_status = response.status logger.debug(u"Pushover response status: %r" % request_status) logger.debug(u"Pushover response headers: %r" % response.getheaders()) logger.debug(u"Pushover response body: %r" % response.read()) if request_status == 200: logger.info(u"Pushover notifications sent.") return True elif request_status >= 400 and request_status < 500: logger.info(u"Pushover request failed: %s" % response.reason) return False else: logger.info(u"Pushover notification failed.") return False
def getRemoteDBModifiedTS(): """ Performs a HEAD request to get the Last-Modified date-time of a database dump file and parses it into a UNIX timestamp. """ debug_msg = 'Unable to get timestamp of remote database dump - {0}' logging.info("Getting timestamp of database dump at '%s'", HOST + PATH) try: # Removing the scheme from the URL conn = HTTPSConnection(HOST[8:], timeout=TIMEOUT) conn.request('HEAD', PATH) except gaierror as e: logging.debug( debug_msg.format( "Cannot connect to '%s', error: %s"), HOST + PATH, e) exit(1) rsp = conn.getresponse() if rsp.status != 200: logging.debug( debug_msg.format('Server responded with: %d %s'), rsp.status, rsp.reason) exit(1) last_modified = rsp.getheader('last-modified', None) if last_modified is None: logging.debug(debug_msg.format( 'Response doesnt include Last-Modified Header')) exit(1) last_m_dt = datetime.strptime( last_modified.split(', ')[1], '%d %b %Y %H:%M:%S %Z') return timegm(last_m_dt.timetuple())
def notify(self, message = '', data = {}, listener = None): http_handler = HTTPSConnection("api.pushover.net:443") data = { 'user': self.conf('user_key'), 'token': self.app_token, 'message': toUnicode(message), 'priority': self.conf('priority') } http_handler.request('POST', "/1/messages.json", headers = {'Content-type': 'application/x-www-form-urlencoded'}, body = tryUrlencode(data) ) response = http_handler.getresponse() request_status = response.status if request_status == 200: log.info('Pushover notifications sent.') return True elif request_status == 401: log.error('Pushover auth failed: %s', response.reason) return False else: log.error('Pushover notification failed.') return False
def notify(self, message, event): if not headphones.CONFIG.PROWL_ENABLED: return http_handler = HTTPSConnection("api.prowlapp.com") data = {'apikey': headphones.CONFIG.PROWL_KEYS, 'application': 'Headphones', 'event': event, 'description': message.encode("utf-8"), 'priority': headphones.CONFIG.PROWL_PRIORITY} http_handler.request("POST", "/publicapi/add", headers={ 'Content-type': "application/x-www-form-urlencoded"}, body=urlencode(data)) response = http_handler.getresponse() request_status = response.status if request_status == 200: logger.info(u"Prowl notifications sent.") return True elif request_status == 401: logger.info(u"Prowl auth failed: %s" % response.reason) return False else: logger.info(u"Prowl notification failed.") return False
def notify(self, message, event): if not mylar.PUSHOVER_ENABLED: return http_handler = HTTPSConnection("api.pushover.net:443") data = { "token": mylar.PUSHOVER_APIKEY, "user": mylar.PUSHOVER_USERKEY, "message": message.encode("utf-8"), "title": event, "priority": mylar.PUSHOVER_PRIORITY, } http_handler.request( "POST", "/1/messages.json", body=urlencode(data), headers={"Content-type": "application/x-www-form-urlencoded"}, ) response = http_handler.getresponse() request_status = response.status if request_status == 200: logger.info(u"Pushover notifications sent.") return True elif request_status == 401: logger.info(u"Pushover auth failed: %s" % response.reason) return False else: logger.info(u"Pushover notification failed.") return False
def notify(self, message, event, module=None): if not mylar.PUSHOVER_ENABLED: return if module is None: module = '' module += '[NOTIFIER]' http_handler = HTTPSConnection("api.pushover.net:443") data = {'token': mylar.PUSHOVER_APIKEY, 'user': mylar.PUSHOVER_USERKEY, 'message': message.encode("utf-8"), 'title': event, 'priority': mylar.PUSHOVER_PRIORITY } http_handler.request("POST", "/1/messages.json", body = urlencode(data), headers = {'Content-type': "application/x-www-form-urlencoded"} ) response = http_handler.getresponse() request_status = response.status if request_status == 200: logger.info(module + ' Pushover notifications sent.') return True elif request_status == 401: logger.info(module + 'Pushover auth failed: %s' % response.reason) return False else: logger.info(module + ' Pushover notification failed.') return False
def notify(self, message, event): if not mylar.PROWL_ENABLED: return http_handler = HTTPSConnection("api.prowlapp.com") data = { "apikey": mylar.PROWL_KEYS, "application": "Mylar", "event": event, "description": message.encode("utf-8"), "priority": mylar.PROWL_PRIORITY, } http_handler.request( "POST", "/publicapi/add", headers={"Content-type": "application/x-www-form-urlencoded"}, body=urlencode(data), ) response = http_handler.getresponse() request_status = response.status if request_status == 200: logger.info(u"Prowl notifications sent.") return True elif request_status == 401: logger.info(u"Prowl auth failed: %s" % response.reason) return False else: logger.info(u"Prowl notification failed.") return False
def send(hook_url, message, **kwargs): headers = { "Content-type": "application/json" } http_key = kwargs.pop("http_key", None) if not http_key and hasattr(settings, 'HTTP_KEY'): http_key = settings.HTTP_KEY headers["Authorization"] = "key={}".format(http_key) kwargs["msg"] = message up = urlparse(hook_url) if up.scheme == 'https': http = HTTPSConnection(up.netloc) else: http = HTTPConnection(up.netloc) http.request( "POST", up.path, headers=headers, body=dumps(kwargs)) response = http.getresponse() if response.status != 200: raise HTTPError(response.reason) return True
def notify(self, message = '', data = {}): if self.isDisabled(): return http_handler = HTTPSConnection('api.prowlapp.com') data = { 'apikey': self.conf('api_key'), 'application': self.default_title, 'description': toUnicode(message), 'priority': self.conf('priority'), } http_handler.request('POST', '/publicapi/add', headers = {'Content-type': 'application/x-www-form-urlencoded'}, body = urlencode(data) ) response = http_handler.getresponse() request_status = response.status if request_status == 200: log.info('Prowl notifications sent.') return True elif request_status == 401: log.error('Prowl auth failed: %s' % response.reason) return False else: log.error('Prowl notification failed.') return False
def _probe_geonode_wms(self, raw_url): url = urlsplit(raw_url) if url.scheme == 'https': conn = HTTPSConnection(url.hostname, url.port) else: conn = HTTPConnection(url.hostname, url.port) conn.request('GET', '/api/ows_endpoints/', '', {}) response = conn.getresponse() content = response.read() status = response.status content_type = response.getheader("Content-Type", "text/plain") # NEW-style OWS Enabled GeoNode if status == 200 and 'application/json' == content_type: try: _json_obj = json.loads(content) if 'data' in _json_obj: data = _json_obj['data'] for ows_endpoint in data: if 'OGC:OWS' == ows_endpoint['type']: return ows_endpoint['url'] + '?' + url.query except BaseException: pass # OLD-style not OWS Enabled GeoNode _url = "%s://%s/geoserver/ows" % (url.scheme, url.netloc) return _url
def request(self, method, endpoint, headers=None, **params): url = "https://api.pingdom.com/api/{version}/{endpoint}".format( **dict( username=self.username, password=self.password, version=self.version, endpoint=endpoint ) ) if headers is None: headers = dict() if 'Account-Email' not in headers: headers['Account-Email'] = self.account if 'App-Key' not in headers: headers['App-Key'] = self.apikey if 'Content-Type' not in headers: headers['Content-Type'] = 'application/json' if 'Authorization' not in headers: headers['Authorization'] = 'Basic %s' % base64.encodestring( "{username}:{password}".format(username=self.username, password=self.password) ) conn = HTTPSConnection('api.pingdom.com', context=ctx) conn.request( method, "/api/{version}/{endpoint}".format(version=self.version, endpoint=endpoint), headers=headers ) response = conn.getresponse() body = response.read() return json.loads(body)
def connect(self): """ Override the connect() function to intercept calls to certain host/ports. If no app at host/port has been registered for interception then a normal HTTPSConnection is made. """ if debuglevel: sys.stderr.write('connect: %s, %s\n' % (self.host, self.port,)) try: (app, script_name) = self.get_app(self.host, self.port) if app: if debuglevel: sys.stderr.write('INTERCEPTING call to %s:%s\n' % \ (self.host, self.port,)) self.sock = wsgi_fake_socket(app, self.host, self.port, script_name) else: HTTPSConnection.connect(self) except Exception, e: if debuglevel: # intercept & print out tracebacks traceback.print_exc() raise
def fetch_response(self, request): """Executes request and fetchs service response""" connection = HTTPSConnection(self.SERVER_URL) connection.request(request.method.upper(), request.to_url()) return connection.getresponse().read()