def _check(self, instance):
addr, username, password, timeout, include_content, headers, response_time, tags, disable_ssl_validation, ssl_expire = self._load_conf(instance)
content = ''
start = time.time()
service_checks = []
resp = None
try:
self.log.debug("Connecting to %s" % addr)
if disable_ssl_validation and urlparse(addr)[0] == "https":
self.warning("Skipping SSL certificate validation for %s based on configuration" % addr)
h = Http(timeout=timeout, disable_ssl_certificate_validation=disable_ssl_validation)
if username is not None and password is not None:
h.add_credentials(username, password)
resp, content = h.request(addr, "GET", headers=headers)
except socket.timeout, e:
length = int((time.time() - start) * 1000)
self.log.info("%s is DOWN, error: %s. Connection failed after %s ms" % (addr, str(e), length))
service_checks.append((
self.SC_STATUS,
Status.DOWN,
"%s. Connection failed after %s ms" % (str(e), length)
))
def create_item():
USER = credentials['USER']
PASSWORD = credentials['PASSWORD']
http = Http('.cache')
http.add_credentials(USER, PASSWORD)
url = 'http://survey.houseofkoffler.com/jsonapi/node/article'
headers = {
'Content-type': 'application/vnd.api+json',
'Accept': 'application/vnd.api+json'
}
post_data = {
"data": {
"type": "node--article",
"attributes": {
"title": "My custom title",
"body": {
"value": "Custom value",
"format": "plain_text"
}
}
}
}
resp, content = http.request(uri=url,
method='POST',
headers=headers,
body=json.dumps(post_data))
print(resp)
def get_data(*args):
#TODO Pass in a timeout value here
from httplib2 import Http
from urllib import urlencode
req = Http(timeout=10)
if (Prefs['authrequired']):
req.add_credentials(Prefs['username'], Prefs['password'])
results = []
for item in args:
u = item[0]
data = item[1]
print data
try:
if data:
headers = {'Content-type': 'application/x-www-form-urlencoded'}
resp, content = req.request(u, "POST", headers=headers, body=urlencode(data))
print resp, content
else:
resp, content = req.request(u, "GET", data)
soup = BeautifulSoup(content)
results.append(soup)
except:
raise
return results
def build_http_connection(config, timeout=120, disable_ssl_validation=False):
"""
:config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
"proxy_type": http,http_no_tunnel,sock4,sock5,
"proxy_rdns": 0 or 1,
}
:return: Http2.Http object
"""
proxy_type_to_code = {
"http": socks.PROXY_TYPE_HTTP,
"http_no_tunnel": socks.PROXY_TYPE_HTTP_NO_TUNNEL,
"socks4": socks.PROXY_TYPE_SOCKS4,
"socks5": socks.PROXY_TYPE_SOCKS5,
}
if config.get("proxy_type") in proxy_type_to_code:
proxy_type = proxy_type_to_code[config["proxy_type"]]
else:
proxy_type = socks.PROXY_TYPE_HTTP
rdns = scu.is_true(config.get("proxy_rdns"))
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(
proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"],
proxy_rdns=rdns,
)
else:
proxy_info = ProxyInfo(
proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_rdns=rdns,
)
if proxy_info:
http = Http(
proxy_info=proxy_info,
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation,
)
else:
http = Http(timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def get_current_events(feed_url_or_path, files):
"""Retrieves data from iCal iCal feed and returns an ics.Calendar object
containing the parsed data.
Returns the parsed Calendar object or None if an error occurs.
"""
events_end = datetime.now()
if config.get('ICAL_DAYS_TO_SYNC', 0) == 0:
# default to 1 year ahead
events_end += DEFAULT_TIMEDELTA
else:
# add on a number of days
events_end += timedelta(days=config['ICAL_DAYS_TO_SYNC'])
try:
if files:
cal = events(file=feed_url_or_path, end=events_end)
else:
# directly configure http connection object to set ssl and authentication parameters
http_conn = Http(disable_ssl_certificate_validation=not config.get('ICAL_FEED_VERIFY_SSL_CERT', True))
if config.get('ICAL_FEED_USER') and config.get('ICAL_FEED_PASS'):
# credentials used for every connection
http_conn.add_credentials(name=config.get('ICAL_FEED_USER'), password=config.get('ICAL_FEED_PASS'))
cal = events(feed_url_or_path, start=datetime.now()-timedelta(days=config.get('PAST_DAYS_TO_SYNC', 0)), end=events_end, http=http_conn)
except Exception as e:
logger.error('> Error retrieving iCal data ({})'.format(e))
return None
return cal
def api_get(url, acnt, params=None):
#does a simple get request to the api.
http = Http(disable_ssl_certificate_validation=True)
http.add_credentials(acnt['user'], acnt['pass'])
headers = { 'Content-type': 'application/json', }
resp, content = http.request(url, "GET", headers=headers)
return content
def _check(self, instance):
addr, username, password, timeout, include_content, headers, response_time, tags, disable_ssl_validation, ssl_expire = self._load_conf(
instance)
content = ''
start = time.time()
service_checks = []
resp = None
try:
self.log.debug("Connecting to %s" % addr)
if disable_ssl_validation and urlparse(addr)[0] == "https":
self.warning(
"Skipping SSL certificate validation for %s based on configuration"
% addr)
h = Http(timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if username is not None and password is not None:
h.add_credentials(username, password)
resp, content = h.request(addr, "GET", headers=headers)
except socket.timeout, e:
length = int((time.time() - start) * 1000)
self.log.info(
"%s is DOWN, error: %s. Connection failed after %s ms" %
(addr, str(e), length))
service_checks.append(
(self.SC_STATUS, Status.DOWN,
"%s. Connection failed after %s ms" % (str(e), length)))
def savedsearch(self,q=""):
"""
Runs one of your saved searches
"""
query=Http(timeout=10)
query.add_credentials(self.username,self.password)
resp, cont=query.request("http://"+self.subdomain+".loggly.com/api/savedsearches","GET")
content=loads(cont)
saved=None
for search in content:
if search['name']==q:
saved=search
if saved==None:
raise ValueError("Your account does not have a search of that name,\
please go to "+self.subdomain+".loggly.com to check your saved searches")
params=saved['context']
opts={}
inputs=""
devices=""
for x in params:
if x!="terms" and x!="inputs" and x!="devices":
opts[self.ssdict[x]]=params[x]
if params['inputs']:
inputs+=" AND (inputname:"+" OR inputname:".join(params['inputs'])+")"
if params['devices']:
devices+=" AND (ip:"+" OR ip:".join(params['devices'])+")"
return self.search(q=params['terms']+inputs+devices,**opts)
def build_http_connection(config, timeout=120):
"""
@config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
}
@return: Http2.Http object
"""
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=config["proxy_url"],
proxy_port=config["proxy_port"],
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"])
else:
proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=config["proxy_url"],
proxy_port=config["proxy_port"])
http = Http(proxy_info=proxy_info, timeout=timeout,
disable_ssl_certificate_validation=True)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def build_http_connection(config, timeout=120):
"""
@config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
}
@return: Http2.Http object
"""
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=config["proxy_url"],
proxy_port=config["proxy_port"],
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"])
else:
proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=config["proxy_url"],
proxy_port=config["proxy_port"])
http = Http(proxy_info=proxy_info,
timeout=timeout,
disable_ssl_certificate_validation=True)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def get_data(*args):
#TODO Pass in a timeout value here
from httplib2 import Http
from urllib import urlencode
req = Http(timeout=10)
if (Prefs['authrequired']):
req.add_credentials(Prefs['username'], Prefs['password'])
results = []
for item in args:
u = item[0]
data = item[1]
print data
try:
if data:
headers = {'Content-type': 'application/x-www-form-urlencoded'}
resp, content = req.request(u,
"POST",
headers=headers,
body=urlencode(data))
print resp, content
else:
resp, content = req.request(u, "GET", data)
soup = BeautifulSoup(content)
results.append(soup)
except:
raise
return results
def _make_request(self, url, method, payload={}, headers={}):
"""
A wrapper around httplib2.Http.request.
Required Arguments:
url
The url of the request.
method
The method of the request. I.e. 'GET', 'PUT', 'POST', 'DELETE'.
Optional Arguments:
payload
The urlencoded parameters.
headers
Additional headers of the request.
"""
try:
if self._meta.ignore_ssl_validation:
http = Http(disable_ssl_certificate_validation=True)
else:
http = Http()
if self._auth_credentials:
http.add_credentials(self._auth_credentials[0], self._auth_credentials[1])
return http.request(url, method, payload, headers=headers)
except socket.error as e:
raise exc.dRestAPIError(e.args[1])
def findsavedsearchnames(self):
query=Http(timeout=10)
query.add_credentials(self.username,self.password)
resp, cont=query.request("http://"+self.subdomain+".loggly.com/api/savedsearches","GET")
content=loads(cont)
names=[x['name'] for x in content]
return names
def test_authentication(self):
url = address + '/token'
h = Http()
h.add_credentials('unit_test', 'unit_test')
resp, result = h.request(url,
'POST',
headers={"Content-Type": "application/json"})
self.assertEqual(resp['status'], '200')
def _http():
"""Shortcut for httplib2.Http with module-specific options."""
ret = Http(**_HTTPLIB2_OPTIONS)
for username, password in _HTTPLIB2_CREDENTIALS:
ret.add_credentials(username, password)
for key, cert, domain in _HTTPLIB2_CERTIFICATES:
ret.add_certificate(key, cert, credentials)
return ret
def request(url, meth, data='', user=None, passwd=None):
headers={'content-type' : 'application/x-www-form-urlencoded'}
h = Http()
if user:
# send the header is ('authorization', 'Basic user:pwd') in base64
# the server should see REMOTE_USER and HTTP_AUTHORIZATION
h.add_credentials(user, passwd)
return h.request(url, meth, urlencode(data), headers)
def _http():
"""Shortcut for httplib2.Http with module-specific options."""
ret = Http(**_HTTPLIB2_OPTIONS)
for username, password in _HTTPLIB2_CREDENTIALS:
ret.add_credentials(username, password)
for key, cert, domain in _HTTPLIB2_CERTIFICATES:
ret.add_certificate(key, cert, domain)
return ret
class Session(object):
def __init__(self, op_config):
self.op_config = op_config
self.http = Http(disable_ssl_certificate_validation=True)
self.http.follow_all_redirects = True
self.http.add_credentials(self.op_config.username,
self.op_config.password)
response = self.get('/')
self.api_version = response.get('api_version')
if self.api_version not in ['1']:
raise HTTPError('Invalid API version: %s' % self.api_version)
self.languages = response.get('languages', {})
def request(self, method, url, data=None, params=None):
data = data or {}
params = params or {}
headers = {'Accept': 'application/json',
'Content-Type': 'application/json',
'User-Agent': 'op/%s' % __version__}
if 'language' in data:
if data['language'] is not None \
and data['language'] not in self.languages:
raise HTTPError('Invalid language: %s' % data['language'])
data = json.dumps(data)
url = self.op_config.base_url + url.rstrip('/') + '/'
query_string_params = {}
for key, value in params.iteritems():
if value is not None:
query_string_params[key] = value
if len(query_string_params):
url += '?' + urlencode(query_string_params)
response_headers, response = \
self.http.request(url, method=method.upper(), body=data,
headers=headers)
if response_headers['content-type'] != 'application/json':
raise HTTPError('No application/json response found! Please ' \
'verify your ownpaste server URL!', url=url)
try:
data = json.loads(response)
except ValueError:
raise HTTPError('Failed to parse JSON response')
if data['status'] == 'ok':
return data
raise HTTPError(data['error'],
status_code=int(response_headers['status']), url=url)
def get(self, url, data=None, params=None):
return self.request('GET', url, data, params)
def post(self, url, data=None, params=None):
return self.request('POST', url, data, params)
def patch(self, url, data=None, params=None):
return self.request('PATCH', url, data, params)
def delete(self, url, data=None, params=None):
return self.request('DELETE', url, data, params)
def build_http_connection(config, timeout=120, disable_ssl_validation=False):
"""
:config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
"proxy_type": http,http_no_tunnel,sock4,sock5,
"proxy_rdns": 0 or 1,
}
:return: Http2.Http object
"""
proxy_type_to_code = {
"http": socks.PROXY_TYPE_HTTP,
"http_no_tunnel": socks.PROXY_TYPE_HTTP_NO_TUNNEL,
"socks4": socks.PROXY_TYPE_SOCKS4,
"socks5": socks.PROXY_TYPE_SOCKS5,
}
if config.get("proxy_type") in proxy_type_to_code:
proxy_type = proxy_type_to_code[config["proxy_type"]]
else:
proxy_type = socks.PROXY_TYPE_HTTP
rdns = scu.is_true(config.get("proxy_rdns"))
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"],
proxy_rdns=rdns)
else:
proxy_info = ProxyInfo(proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_rdns=rdns)
if proxy_info:
http = Http(proxy_info=proxy_info,
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
else:
http = Http(timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def get_stats(self, metric, dimension=None, filters=None):
h = Http('test-scripts/.cache')
h.add_credentials(self.email, self.password)
if dimension:
url = "https://api.addthis.com/analytics/1.0/pub/%s/%s.json" % (metric, dimension)
else:
url = "https://api.addthis.com/analytics/1.0/pub/%s.json" % metric
data = dict(("pubid", self.pubid) + filters.items()) if \
filters else {"pubid": self.pubid}
resp, content = h.request("%s?%s" % (url, urlencode(data)), "GET")
return content
def request_rest_process(process, params):
"""
Make a REST request for the WPS process named, with the provided parameters.
"""
url = "%srest/process/%s" % (settings.GEOSERVER_BASE_URL, process)
user, pw = settings.GEOSERVER_CREDENTIALS
http = Http()
http.add_credentials(user, pw)
response, content = http.request(url, "POST", json.dumps(params))
if (response.status is not 200):
raise Exception("REST process responded with\nStatus: {0}\nResponse:\n{1}".format(response.status, content))
return json.loads(content)
class SimpleRestClient:
"""A simple REST client library"""
def __init__(self, api_url, api_user, api_password):
self.url, self.user, self.password = api_url, api_user, api_password
self.client = Http()
self.client.follow_all_redirect = True
self.client.add_credentials(self.user, self.password)
def GET(self, uri):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
status, response = self.client.request(
'{url}{uri}'.format(url=current_url, uri=uri),
'GET',
headers={'accept': 'application/xml'})
response = self.parse_xml(response)
return status, response
def POST(self, uri, params={}):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
if not params:
params = {}
status, response = self.client.request(
'{url}{uri}'.format(url=current_url, uri=uri),
'POST',
urlencode(params),
headers={'accept': 'application/xml'})
response = self.parse_xml(response)
return status, response
def DELETE(self, uri):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
return self.client.request(
'{url}{uri}'.format(url=current_url, uri=uri), 'DELETE')
def PUT(self, uri):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
return self.client.request(
'{url}{uri}'.format(url=current_url, uri=uri), 'PUT')
def parse_xml(self, response):
return libxml2.parseDoc(response)
class SimpleRestClient:
"""A simple REST client library"""
def __init__(self, api_url, api_user, api_password):
self.url, self.user, self.password = api_url, api_user, api_password
self.client = Http()
self.client.follow_all_redirect = True
self.client.add_credentials(self.user, self.password)
def GET(self, uri):
if uri.startswith("http://"):
current_url = ""
else:
current_url = self.url
status, response = self.client.request(
"{url}{uri}".format(url=current_url, uri=uri), "GET", headers={"accept": "application/xml"}
)
response = self.parse_xml(response)
return status, response
def POST(self, uri, params={}):
if uri.startswith("http://"):
current_url = ""
else:
current_url = self.url
if not params:
params = {}
status, response = self.client.request(
"{url}{uri}".format(url=current_url, uri=uri),
"POST",
urlencode(params),
headers={"accept": "application/xml"},
)
response = self.parse_xml(response)
return status, response
def DELETE(self, uri):
if uri.startswith("http://"):
current_url = ""
else:
current_url = self.url
return self.client.request("{url}{uri}".format(url=current_url, uri=uri), "DELETE")
def PUT(self, uri):
if uri.startswith("http://"):
current_url = ""
else:
current_url = self.url
return self.client.request("{url}{uri}".format(url=current_url, uri=uri), "PUT")
def parse_xml(self, response):
return libxml2.parseDoc(response)
def wowlog():
"""Query user connections info from Wowza streaming server and save to DB.
"""
h = Http()
h.add_credentials(login, password)
root = etree.fromstring(h.request('http://' + server_ip + ':' + server_port +
'/connectioncounts/')[1])
value = int(root[0].text)
WowzaConnections.objects.create(query_time=datetime.now(), conn_counts=value)
return str(value)
def test_add_new_update(self):
url = address + '/version'
h = Http()
h.add_credentials('unit_test', 'unit_test')
data = dict(versionNumber="3.0.0",
nameUpdate="Version 3",
newFeatures="None",
bugFixes="None")
data = json.dumps(data)
resp, result = h.request(url,
'POST',
body=data,
headers={"Content-Type": "application/json"})
self.assertEqual(resp['status'], '200')
def send_http_request(self, url, basic_auth_username, basic_auth_password):
h = Http(disable_ssl_certificate_validation=True)
if basic_auth_username and basic_auth_password:
h.add_credentials(basic_auth_username, basic_auth_password)
project = self.video.get_team_video().project.slug if self.video else None
data = {
'event': self.event_name,
'api_url': self.api_url,
}
if self.team:
data['team'] = self.team.slug
if self.partner:
data['partner'] = self.partner.slug
if project:
data['project'] = project
if self.video:
data['video_id'] = self.video_id
if self.application_pk:
data['application_id'] = self.application_pk
if self.language:
data.update({
"language_code": self.language_code,
"language_id": self.language.pk,
})
data_sent = data
data = urlencode(data)
url = "%s?%s" % (url , data)
try:
resp, content = h.request(url, method="POST", body=data, headers={
'referer': '%s://%s' % (DEFAULT_PROTOCOL, Site.objects.get_current().domain)
})
success = 200 <= resp.status < 400
if success is False:
logger.error("Failed to notify team %s " % (self.team),
extra={
'team': self.team or self.partner,
'url': url,
'response': resp,
'content': content,
'data_sent':data_sent,
})
Meter('http-callback-notification-error').inc()
else:
Meter('http-callback-notification-success').inc()
return success, content
except:
logger.exception("Failed to send http notification ")
return None, None
def test_get_all_users(self):
create_user('stijn', 'test', '*****@*****.**')
h = Http()
h.add_credentials(name='stijn', password='******')
url = 'http://localhost:5000/api/v1/users'
try:
response, content_bytes = h.request(url, method='GET')
if response['status'] != '201' and response['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
response['status'])
content = json.loads(content_bytes.decode())
self.assertTrue(content.get('users'))
except Exception as e:
self.assertTrue(False, 'Received an unsuccessful status code of %s' %
response['status'])
def post_comment(message_id, comment):
"""
Posts new comment to Basecamp message
"""
h = Http()
h.add_credentials(BASECAMP_USER, BASECAMP_PASSWORD)
url = '%s/posts/%s/comments.xml' % (BASECAMP_URL, message_id)
req = ET.Element('comment')
ET.SubElement(req, 'body').text = str(comment)
headers = {
'Content-Type': 'application/xml',
'Accept': 'application/xml',
}
response = h.request(url, method="POST", body=ET.tostring(req), headers=headers)
print response
def test_delete_request(self):
user = create_user('stijn', 'test', '*****@*****.**')
request = create_request('stijn', 'test', False)
self.assertTrue(request.get('id'))
try:
h = Http()
h.add_credentials(name='stijn', password='******')
url = 'http://localhost:5000/api/v1/requests/%s' % request['id']
response, content_bytes = h.request(url, method='DELETE')
content = json.loads(content_bytes.decode())
self.assertFalse(content.get(request['id']))
except Exception as err:
self.assertTrue(False,
'Received an unsuccessful status code of %s' %
response['status'])
def get_item(title):
USER = credentials['USER']
PASSWORD = credentials['PASSWORD']
http = Http('.cache')
http.add_credentials(USER, PASSWORD)
url = 'http://survey.houseofkoffler.com/jsonapi/node/article?filter[article-title][path]=title&filter[article-title][value]=%s&filter[article-title][operator]==' % title
headers = {
'Content-type': 'application/vnd.api+json',
'Accept': 'application/vnd.api+json'
}
resp, content = http.request(uri=url, method='GET', headers=headers)
print(resp)
class SimpleRestClient:
"""A simple REST client library"""
def __init__(self, api_url, api_user, api_password):
self.url, self.user, self.password = api_url, api_user, api_password
self.client = Http()
self.client.follow_all_redirect = True
self.client.add_credentials(self.user, self.password)
def GET(self, uri):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
status, response = self.client.request('{url}{uri}'.format(url=current_url, uri=uri), 'GET', headers={'accept':'application/xml'})
response = self.parse_xml(response)
return status, response
def POST(self, uri, params={}):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
if not params:
params = {}
status, response = self.client.request('{url}{uri}'.format(url=current_url, uri=uri), 'POST',
urlencode(params), headers={'accept':'application/xml'})
response = self.parse_xml(response)
return status, response
def DELETE(self, uri):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
return self.client.request('{url}{uri}'.format(url=current_url, uri=uri), 'DELETE')
def PUT(self, uri):
if uri.startswith('http://'):
current_url = ''
else:
current_url = self.url
return self.client.request('{url}{uri}'.format(url=current_url, uri=uri), 'PUT')
def parse_xml(self, response):
return libxml2.parseDoc(response)
def _send_request(self, method, path, body=None, headers=None):
if TIMEOUTS_AVAILABLE:
http = Http(timeout=self.timeout)
if self.username is not None:
http.add_credentials(self.username, self.password)
url = self.base_url + path
try:
start_time = time.time()
self.log.debug("Starting request to '%s' (%s) with body '%s'..." % (url, method, str(body)[:10]))
headers, response = http.request(url, method=method, body=body, headers=headers)
end_time = time.time()
self.log.info("Finished '%s' (%s) with body '%s' in %0.3f seconds." % (url, method, str(body)[:10], end_time - start_time))
except AttributeError:
# For httplib2.
error_message = "Failed to connect to server at '%s'. Are you sure '%s' is correct? Checking it in a browser might help..." % (url, self.base_url)
self.log.error(error_message)
raise SolrError(error_message)
if int(headers['status']) != 200:
error_message = self._extract_error(headers, response)
self.log.error(error_message)
raise SolrError(error_message)
return response
else:
if headers is None:
headers = {}
conn = HTTPConnection(self.host, self.port)
start_time = time.time()
self.log.debug("Starting request to '%s:%s/%s' (%s) with body '%s'..." % (self.host, self.port, path, method, str(body)[:10]))
conn.request(method, path, body, headers)
response = conn.getresponse()
end_time = time.time()
self.log.info("Finished '%s:%s/%s' (%s) with body '%s' in %0.3f seconds." % (self.host, self.port, path, method, str(body)[:10], end_time - start_time))
if response.status != 200:
error_message = self._extract_error(dict(response.getheaders()), response.read())
self.log.error(error_message)
raise SolrError(error_message)
return response.read()
def create_proposal(username, password, filled=False):
try:
h = Http()
user_proposed_from = db.session.query(User).filter_by(username=username).first()
h.add_credentials(name=username, password=password)
url = 'http://*****:*****@example.com')
request_id = create_request(username='******', password='******', filled=True)
data = dict(user_proposed_to=user_proposed_to,
user_proposed_from=user_proposed_from,
request_id=request_id,
filled=filled)
response, content_bytes = h.request(
url, method='POST',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
content = json.loads(content_bytes.decode())
return content
except Exception as err:
return None
def addDescription(couchUrl, couchDbName, docId, description):
"""
Test the adddescription.js update function.
For use in this test to mimic operators clicking on stuff (i.e. using
httplib2 rather than CMSCouth direct REST interface).
"""
fragments = urlparse.urlparse(couchUrl)
userpassw = fragments[1].split("@",1)[0]
user,passw = userpassw.split(":",1)
newUrl = couchUrl.replace(userpassw, "")
newUrl = newUrl.replace("@", "")
h = Http()
h.add_credentials(user, passw)
data = {"newDescription" : description}
headers = {"Content-type": "application/x-www-form-urlencoded"}
url = "%s/%s/_design/OpsClipboard/_update/adddescription/%s" % (newUrl, couchDbName, docId)
resp, content = h.request(url, "POST", urlencode(data),headers= headers)
if content != "OK":
raise Exception("Exception at CouchDB server: response: '%s', content: '%s'" % (resp, content))
def create_request(username, password, filled=False):
try:
h = Http()
user = db.session.query(User).filter_by(username=username).first()
h.add_credentials(name=username, password=password)
url = 'http://localhost:5000/api/v1/requests/'
location_string = 'amsterdam'
data = dict(meal_type='pizza',
location_string=location_string,
meal_time='lunch',
user_id=user.id,
filled=filled)
response, content_bytes = h.request(
url, method='POST',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
content = json.loads(content_bytes.decode())
return content
except Exception as err:
return None
def test_change_user(self):
create_user('stijn', 'test', '*****@*****.**')
h = Http()
h.add_credentials(name='stijn', password='******')
url = 'http://*****:*****@example.com')
try:
response, content_bytes = h.request(
url, method='PUT',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
if response['status'] != '201' and response['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
response['status'])
content = json.loads(content_bytes.decode())
self.assertEquals(content.get('username'), 'casper')
except Exception as e:
self.assertTrue(False,
'Received an unsuccessful status code of %s' %
response['status'])
def send_http_request(self, url, basic_auth_username, basic_auth_password):
h = Http()
if basic_auth_username and basic_auth_password:
h.add_credentials(basic_auth_username, basic_auth_password)
project = self.video.get_team_video().project.slug
data = dict(event=self.event_name, api_url=self.api_url,
video_id=self.video_id, team=self.team.slug, project=project)
if self.language_code:
data.update({"language_code":self.language_code} )
data = urlencode(data)
url = "%s?%s" % (url , data)
try:
resp, content = h.request(url, method="POST", body=data)
success = 200<= resp.status <400
if success is False:
logger.error("Failed to send team notification to %s - from teams:%s, status code:%s, response:%s" %(
self.team, url, resp, content ))
return success, content
except:
logger.exception("Failed to send http notification ")
return None, None
def test_update_request(self):
user = create_user('stijn', 'test', '*****@*****.**')
request = create_request('stijn', 'test', False)
try:
h = Http()
h.add_credentials(name='stijn', password='******')
url = 'http://localhost:5000/api/v1/requests/%s' % request['id']
data = dict(meal_type='pasta',
location_string='rotterdam',
meal_time='lunch',
user_id=user['id'],
filled=True)
response, content_bytes = h.request(
url, method='PUT',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
content = json.loads(content_bytes.decode())
self.assertTrue(content.get('meal_type'), 'pasta')
except Exception as err:
self.assertTrue(False,
'Received an unsuccessful status code of %s' %
response['status'])
def test_get_all_requests(self):
create_user('stijn', 'test', '*****@*****.**')
# create one open and one filled meal request
create_request('stijn', 'test', False)
create_request('stijn', 'test', True)
try:
h = Http()
h.add_credentials(name='stijn', password='******')
url = 'http://localhost:5000/api/v1/requests/'
response, content_bytes = h.request(url, method='GET')
if response['status'] != '201' and response['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
response['status'])
content = json.loads(content_bytes.decode())
# expected one meal request
self.assertTrue(len(content['requests']) == 1)
except Exception as err:
self.assertTrue(False,
'Received an unsuccessful status code of %s' %
response['status'])
def _api_help(self, endpoint, params=None, method='GET'):
h = Http()
h.add_credentials(self.username, self.password)
url = '%s://%s.%s/%s' % (self.protocol, self.subdomain, self.domain,
endpoint)
if method == 'GET':
body = ''
if params:
url += '?' + urlencode(params)
elif params:
body = urlencode(params)
else:
body = ''
headers, results = h.request(url, method, body)
status = headers['status']
if int(status) == 401:
raise AuthFail('Sorry, your authentication was not accepted.')
# TODO check status, raise appropriate errors or something
try:
return loads(results.decode('utf-8'))
except ValueError:
return results
def _api_help(self, endpoint, params=None, method='GET'):
h = Http()
h.add_credentials(self.username, self.password)
url = '%s://%s.%s/%s' % (self.protocol, self.subdomain, self.domain,
endpoint)
if method == 'GET':
body = ''
if params:
url += '?' + urlencode(params)
elif params:
body = urlencode(params)
else:
body = ''
headers, results = h.request(url, method, body)
status = headers['status']
if int(status) == 401:
raise AuthFail('Sorry, your authentication was not accepted.')
# TODO check status, raise appropriate errors or something
try:
return loads(results.decode('utf-8'))
except ValueError:
return results
def request(self, path, method="GET", body=None, content_type=None):
from httplib2 import Http
import xml.etree.ElementTree as ET
from xml.parsers.expat import ExpatError
h = Http()
h.add_credentials(self.username, self.password)
self._validate_params()
uri = "{0}://{1}:{2}/API/{3}".format(self.protocol, self.host,
self.port, path)
headers = {'Accept': 'application/xml'}
if content_type is not None:
headers['Content-Type'] = content_type
if body is None:
(response, content) = h.request(uri,
method=method,
headers=headers)
else:
(response, content) = h.request(uri,
method=method,
body=body,
headers=headers)
if int(response['status']) < 200 or int(response['status']) > 299:
raise HttpError(response, content)
#register default namespace as vidispine, http://stackoverflow.com/questions/8983041/saving-xml-files-using-elementtree
#ET.register_namespace('', "http://xml.vidispine.com/schema/vidispine")
#ET._namespace_map['']="http://xml.vidispine.com/schema/vidispine"
try:
return ET.fromstring(content)
except ExpatError:
return content
body=data,
headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
except Exception as err:
print "Test 1 FAILED: Could not make a new user"
print err.args
sys.exit()
else:
print "Test 1 PASS: Succesfully made a new user"
#TEST 2 ADD NEW BAGELS TO THE DATABASE
try:
h = Http()
h.add_credentials('TinnyTim', 'Udacity')
url = address + '/product'
data = dict(
username="******",
password="******",
name="plain",
picture=
"http://bonacbagel.weebly.com/uploads/4/0/5/4/40548977/s318635836612132814_p1_i1_w240.jpeg",
description="Old-Fashioned Plain Bagel",
price="$1.99")
resp, content = h.request(url,
'POST',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
if resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
except Exception as err:
print("Test 1 FAILED: Could not make a new user")
print(err.args)
sys.exit()
else:
print("Test 1 PASS: Succesfully made a new user")
#TEST 2: OBTAIN A TOKEN
try:
h = Http()
h.add_credentials('Peter', 'Pan')
url = address + '/token'
resp, content = h.request(url,
'GET',
headers={"Content-Type": "application/json"})
if resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
new_content = json.loads(content)
if not new_content['token']:
raise Exception('No Token Received!')
token = new_content['token']
print("received token: %s" % token)
except Exception as err:
print("Test 2 FAILED: Could not exchange user credentials for a token")
print(err.args)
def sampleAndPost(*args):
print "----- Gathering sample at", datetime.now()
reading = d.readRegister(MODBUS_REGISTER)
print "===== Read", reading
data = dict(value=reading)
# Here is the call that posts to CloudDot
resp, content = h.request(writeUrl, "POST", urlencode(data))
print "+++++ Post to CloudDot at", datetime.now(
), "Response status:", resp["status"]
if resp["status"].startswith('2') == False:
raise Exception(
"Post failed; check your CloudDot username, API key, and channel. Response status was: %s"
% (resp["status"], ))
print
d = u3.U3()
writeUrl = "http://cloudapi.labjack.com/%s/channels/%s/write.json" % (
CLOUDDOT_USERNAME, CLOUDDOT_CHANNEL)
h = Http()
h.add_credentials(CLOUDDOT_USERNAME, CLOUDDOT_API_KEY)
# Call it once at first because we're impatient
sampleAndPost()
# Set it up to call every SAMPLE_INTERVAL
signal.signal(signal.SIGALRM, sampleAndPost)
signal.setitimer(signal.ITIMER_REAL, SAMPLE_INTERVAL, SAMPLE_INTERVAL)
while True:
signal.pause()
body=data,
headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
except Exception as err:
print "Test 1 FAILED: Could not make a new user"
print err.args
sys.exit()
else:
print "Test 1 PASS: Succesfully made a new user"
# TEST 2 ADD NEW BAGELS TO THE DATABASE
try:
h = Http()
h.add_credentials('TinnyTim', 'Udacity')
url = address + '/bagels'
data = dict(username="******",
password="******",
name="plain",
picture="http://bonacbagel.weebly.com/uploads/4/0/5/4/40548977/s318635836612132814_p1_i1_w240.jpeg",
description="Old-Fashioned Plain Bagel",
price="$1.99")
resp, content = h.request(url, 'POST',
body=json.dumps(data),
headers={"Content-Type" : "application/json"})
if resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
except Exception as err:
print "Test 2 FAILED: Could not add new bagels"
url, 'POST', body=data, headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception(
'Received an unsuccessful status code of %s' % resp['status'])
except Exception as err:
print("Test 1 FAILED: Could not make a new user")
print((err.args))
sys.exit()
else:
print("Test 1 PASS: Succesfully made a new user")
#TEST 2: OBTAIN A TOKEN
try:
h = Http()
h.add_credentials('Peter', 'Pan')
url = address + '/token'
resp, content = h.request(
url, 'GET', headers={"Content-Type": "application/json"})
if resp['status'] != '200':
raise Exception(
'Received an unsuccessful status code of %s' % resp['status'])
new_content = json.loads(content)
if not new_content['token']:
raise Exception('No Token Received!')
token = new_content['token']
print(("received token: %s" % token))
except Exception as err:
print("Test 2 FAILED: Could not exchange user credentials for a token")
print((err.args))
'param': par,
'database': '/openerp/databases/%s' % self.cr.dbname,
}
###
## Execute the before query if it available
##
if js_conf.get('before'):
self.cr.execute(js_conf['before'], {'id': ex})
body = BODY_TEMPLATE % body_args
log_debug('****\n%s\n****' % body)
headers = {'Content-type': 'text/xml', 'charset': 'UTF-8', 'SOAPAction': 'runReport'}
h = Http()
h.add_credentials(js_conf['user'], js_conf['pass'])
try:
uri = 'http://%s:%d%s' % (js_conf['host'], js_conf['port'], js_conf['repo'])
resp, content = h.request(uri, "POST", body, headers)
except ServerNotFoundError:
raise JasperException(_('Error'), _('Server not found !'))
except HttpLib2Error, e:
raise JasperException(_('Error'), '%s' % str(e))
except Exception, e:
# Bad fix for bug in httplib2 http://code.google.com/p/httplib2/issues/detail?id=96
# not fix yet
if str(e).find("'makefile'") >= 0:
raise JasperException(_('Connection error'), _('Cannot find the JasperServer at this address %s') % (uri,))
raise JasperException(_('Error'), '%s' % str(e))
log_debug('HTTP -> RESPONSE:')
headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
except Exception as err:
print "Test 1 FAILED: Could not make a new user"
print err.args
sys.exit()
else:
print "Test 1 PASS: Succesfully made a new user"
#TEST 2: OBTAIN A TOKEN
try:
h = Http()
h.add_credentials('mandal', 'Pan')
url = address + '/api/v2/token'
resp, content = h.request(url,
'GET',
headers={"Content-Type": "application/json"})
if resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
new_content = json.loads(content)
if not new_content['token']:
raise Exception('No Token Received!')
token = new_content['token']
print "received token: %s" % token
except Exception as err:
print "Test 2 FAILED: Could not exchange user credentials for a token"
print err.args
import getpass
import os, sys
sys.path[0:0] = os.path.join(os.path.dirname(__file__), "..")
from dolt import Dolt
from httplib2 import Http
class Readernaut(Dolt):
_api_url = "http://readernaut.com"
_url_template = '%(domain)s/api/v1/json/%(generated_url)s'
if __name__ == "__main__":
http = Http()
username = raw_input("Readernaut Username: "******"Readernaut Password: "******"Total books for webology: %d" % len(books)
class RequestHandler(meta.MetaMixin):
"""
Generic class that handles HTTP requests. Uses the Json Serialization
handler by default, but only 'deserializes' response content.
Optional Arguments / Meta:
debug
Boolean. Toggle debug console output. Default: False.
ignore_ssl_validation
Boolean. Whether or not to ignore ssl validation errors.
Default: False
response_handler
An un-instantiated Response Handler class used to return
responses to the caller. Default: drest.response.ResponseHandler.
serialization_handler
An un-instantiated Serialization Handler class used to
serialize/deserialize data.
Default: drest.serialization.JsonSerializationHandler.
serialize
Boolean. Whether or not to serialize data before sending
requests. Default: False.
deserialize
Boolean. Whether or not to deserialize data before returning
the Response object. Default: True.
trailing_slash
Boolean. Whether or not to append a trailing slash to the
request url. Default: True.
timeout
The amount of seconds where a request should timeout.
Default: None
"""
class Meta:
debug = False
ignore_ssl_validation = False
response_handler = response.ResponseHandler
serialization_handler = serialization.JsonSerializationHandler
serialize = False
deserialize = True
trailing_slash = True
allow_get_body = False
timeout = None
def __init__(self, **kw):
super(RequestHandler, self).__init__(**kw)
self._extra_params = {}
self._extra_url_params = {}
self._extra_headers = {}
self._auth_credentials = ()
self._http = None
if 'DREST_DEBUG' in os.environ and \
os.environ['DREST_DEBUG'] in [1, '1']:
self._meta.debug = True
response.validate(self._meta.response_handler)
if self._meta.serialization_handler:
serialization.validate(self._meta.serialization_handler)
self._serialization = self._meta.serialization_handler(**kw)
headers = self._serialization.get_headers()
for key in headers:
self.add_header(key, headers[key])
else:
self._meta.serialize = False
self._meta.deserialize = False
def _serialize(self, data):
if self._meta.serialize:
return self._serialization.serialize(data)
else:
return data
def _deserialize(self, data):
if self._meta.deserialize:
return self._serialization.deserialize(data)
else:
return data
def set_auth_credentials(self, user, password):
"""
Set the authentication user and password that will be used for
HTTP Basic and Digest Authentication.
Required Arguments:
user
The authentication username.
password
That user's password.
"""
self._auth_credentials = (user, password)
self._clear_http()
def add_param(self, key, value):
"""
Adds a key/value to self._extra_params, which is sent with every
request.
Required Arguments:
key
The key of the parameter.
value
The value of 'key'.
"""
self._extra_params[key] = value
def add_url_param(self, key, value):
"""
Adds a key/value to self._extra_url_params, which is sent with every
request (in the URL).
Required Arguments:
key
The key of the parameter.
value
The value of 'key'.
"""
self._extra_url_params[key] = value
def add_header(self, key, value):
"""
Adds a key/value to self._extra_headers, which is sent with every
request.
Required Arguments:
key
The key of the parameter.
value
The value of 'key'.
"""
self._extra_headers[key] = value
def _get_http(self):
"""
Returns either the existing (cached) httplib2.Http() object, or
a new instance of one.
"""
if self._http == None:
if self._meta.ignore_ssl_validation:
self._http = Http(disable_ssl_certificate_validation=True,
timeout=self._meta.timeout)
else:
self._http = Http(timeout=self._meta.timeout)
if self._auth_credentials:
self._http.add_credentials(self._auth_credentials[0],
self._auth_credentials[1])
return self._http
def _clear_http(self):
self._http = None
def _make_request(self, url, method, payload=None, headers=None):
"""
A wrapper around httplib2.Http.request.
Required Arguments:
url
The url of the request.
method
The method of the request. I.e. 'GET', 'PUT', 'POST', 'DELETE'.
Optional Arguments:
payload
The urlencoded parameters.
headers
Additional headers of the request.
"""
if payload is None:
payload = {}
if headers is None:
headers = {}
try:
http = self._get_http()
return http.request(url, method, payload, headers=headers)
except socket.error as e:
# Try again just in case there was an issue with the cached _http
try:
self._clear_http()
return self._get_http().request(url, method, payload,
headers=headers)
except socket.error as e:
raise exc.dRestAPIError(e)
except ServerNotFoundError as e:
raise exc.dRestAPIError(e.args[0])
def _get_complete_url(self, method, url, params):
url = "%s%s" % (url.strip('/'), '/' if self._meta.trailing_slash else '')
if method == 'GET':
url_params = dict(self._extra_url_params, **params)
else:
url_params = self._extra_url_params
if url_params:
url = "%s?%s" % (url, urlencode(url_params))
return url
def make_request(self, method, url, params=None, headers=None):
"""
Make a call to a resource based on path, and parameters.
Required Arguments:
method
One of HEAD, GET, POST, PUT, PATCH, DELETE, etc.
url
The full url of the request (without any parameters). Any
params (with GET method) and self.extra_url_params will be
added to this url.
Optional Arguments:
params
Dictionary of additional (one-time) keyword arguments for the
request.
headers
Dictionary of additional (one-time) headers of the request.
"""
if params is None:
params = {}
if headers is None:
headers = {}
params = dict(self._extra_params, **params)
headers = dict(self._extra_headers, **headers)
url = self._get_complete_url(method, url, params)
if self._meta.serialize:
payload = self._serialize(params)
else:
payload = urlencode(params)
if self._meta.debug:
print('DREST_DEBUG: method=%s url=%s params=%s headers=%s' % \
(method, url, payload, headers))
if method is 'GET' and not self._meta.allow_get_body:
payload = ''
if self._meta.debug:
print("DREST_DEBUG: supressing body for GET request")
res_headers, data = self._make_request(url, method, payload,
headers=headers)
unserialized_data = data
serialized_data = None
if self._meta.deserialize:
serialized_data = data
data = self._deserialize(data)
return_response = response.ResponseHandler(
int(res_headers['status']), data, res_headers,
)
return self.handle_response(return_response)
def handle_response(self, response_object):
"""
A simple wrapper to handle the response. By default raises
exc.dRestRequestError if the response code is within 400-499, or 500.
Must return the original, or modified, response object.
Required Arguments:
response_object
The response object created by the request.
"""
response = response_object
if (400 <= response.status <=499) or (response.status == 500):
msg = "Received HTTP Code %s - %s" % (
response.status,
httplib.responses[int(response.status)])
raise exc.dRestRequestError(msg, response=response)
return response
def _http_check(self, instance):
addr, username, password, timeout, headers, response_time, \
disable_ssl_validation, use_keystone, keystone_config, \
instance_name = self._load_http_conf(instance)
dimensions = self._set_dimensions({'url': addr}, instance)
start = time.time()
done = False
retry = False
while not done or retry:
if use_keystone:
ksclient = self._ksclients[instance_name]
token = ksclient.get_token()
if token:
headers["X-Auth-Token"] = token
headers["Content-type"] = "application/json"
else:
warning_string = """Unable to get token. Keystone API
server may be down. Skipping check for {0}""".format(addr)
self.log.warning(warning_string)
return False, warning_string
try:
self.log.debug("Connecting to %s" % addr)
if disable_ssl_validation:
self.warning(
"Skipping SSL certificate validation for %s based on configuration"
% addr)
h = Http(
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if username is not None and password is not None:
h.add_credentials(username, password)
resp, content = h.request(addr, "GET", headers=headers)
except (socket.timeout, HttpLib2Error, socket.error) as e:
length = int((time.time() - start) * 1000)
warn_string = '{0} is DOWN, error: {1}. Connection failed ' \
'after {2} ms'.format(addr, repr(e), length)
self.log.warn(warn_string)
return False, warn_string
except httplib.ResponseNotReady as e:
length = int((time.time() - start) * 1000)
warn_string = '{0} is DOWN, error: {1}. Network is not ' \
'routable after {2} ms'.format(addr, repr(e),
length)
self.log.warn(warn_string)
return False, warn_string
except Exception as e:
length = int((time.time() - start) * 1000)
error_string = '{0} is DOWN, error: {1}. Connection failed after {2} ms'.format(
addr, repr(e), length)
self.log.error(error_string)
return False, error_string
if response_time:
# Stop the timer as early as possible
running_time = time.time() - start
self.gauge('http_response_time',
running_time,
dimensions=dimensions)
if int(resp.status) >= 400:
if use_keystone and int(resp.status) == 401:
if retry:
error_string = '{0} is DOWN, unable to get a valid token to connect with'.format(
addr)
self.log.error(error_string)
return False, error_string
else:
# Get a new token and retry
self.log.info(
"Token expired, getting new token and retrying...")
retry = True
ksclient.refresh_token()
continue
else:
warn_string = '{0} is DOWN, error code: {1}'.\
format(addr, str(resp.status))
self.log.warn(warn_string)
return False, warn_string
done = True
return True, content
class Jasper(object):
def __init__(self, host='localhost', port=8080, user='******',
pwd='jasperadmin'):
"""
Initialise new Jasper Object
"""
self.cnx = Http()
self.host = host
self.port = port
self.user = user
self.pwd = pwd
self.repo = 'jasperserver/services/repository'
self.uri = 'http://%s:%s/%s' % (self.host, self.port, self.repo)
self.headers = {
'Content-type': 'text/xml',
'charset': 'UTF-8',
'SOAPAction': 'runReport'
}
self.body = ''
def auth(self,):
"""
Add credential
"""
self.cnx.add_credentials(self.user, self.pwd)
# We must simulate a request if we want to check the auth is correct
# Generate a soap query to verify the authentification
rq = Request(operationName='list', locale='fr_FR')
rq.append(RequestRD('folder', '', '/'))
self.body = SoapEnv('list', etree.tostring(rq)).output()
try:
res, content = self.cnx.request(self.uri, 'POST', self.body,
self.headers)
except socket.error:
raise ServerNotFound('Server not found')
if res.get('status', '200') == '401':
raise AuthError('Authentification Failed !')
elif res.get('status', '200') != '200':
return False
return True
def send(self, soapQuery=''): # noqa
try:
res, content = self.cnx.request(self.uri, 'POST', soapQuery,
self.headers)
except socket.error:
raise ServerNotFound('Server not found')
if res.get('status', '200') == '401':
raise AuthError('Authentification Failed !')
elif res.get('status', '200') != '200':
return False
try:
return self.parseMultipart(content)
except NotMultipartContent:
fp = StringIO(content)
tree = etree.parse(fp)
fp.close()
r = tree.xpath('//runReportReturn')
if not r:
raise UnknownResponse(content)
fp = StringIO(r[0].text.encode('utf-8'))
tree = etree.parse(fp)
fp.close()
raise ServerError(
u'[%s] %s' % (tree.xpath('//returnCode')[0].text, # noqa
tree.xpath('//returnMessage')[0].text)
)
def create_request(self, operation='list', wsType='', uri='/', name='', # noqa
arguments=None, params=None):
if arguments is None:
arguments = {}
if params is None:
params = {}
rq = Request(operationName=operation, locale='fr_FR')
for k in arguments:
rq.append(RequestArgument(name=k, value=arguments[k]))
# Add resource descriptor
rd = RequestRD(operation, name, uri)
label = etree.SubElement(rd, 'label')
label.text = 'null'
# Add query parameters
for k, v in params.items():
p = etree.SubElement(rd, 'parameter', name=k)
if isinstance(v, basestring):
p.text = v
else:
p.text = str(v)
rq.append(rd)
res = etree.tostring(rq, pretty_print=True)
_logger.debug(res)
return res
def run_report(self, uri='/', output='PDF', params=None):
"""
Launch a runReport in Jasper
"""
if output not in KNOWN_FORMAT:
raise UnknownFormat(output)
args = {
'RUN_OUTPUT_FORMAT': output,
'PAGE': '0',
}
return self.create_request(operation='runReport', wsType='reportUnit',
uri=uri, arguments=args, params=params)
@staticmethod
def parseMultipart(res): # noqa
srch = re.search(r'----=[^\r\n]*', res)
if srch is None:
raise NotMultipartContent()
boundary = srch.group()
res = " \n" + res
res = "Content-Type: multipart/alternative; boundary=%s\n%s" % \
(boundary, res)
message = email.message_from_string(res)
attachment = message.get_payload()[1]
return {'content-type': attachment.get_content_type(),
'data': attachment.get_payload()}
def log_last_request(self,):
"""
Return the last SOAP query as text
"""
return self.body
def _check(self, instance):
addr, username, password, timeout, headers, response_time, dimensions, disable_ssl_validation, pattern, use_keystone = self._load_conf(
instance)
content = ''
new_dimensions = {
'component': 'monasca-agent',
'service': 'monitoring',
'url': addr
}
if dimensions is not None:
new_dimensions.update(dimensions.copy())
start = time.time()
done = False
retry = False
while not done or retry:
if use_keystone:
api_config = self.agent_config['Api']
keystone = Keystone(api_config)
token = keystone.get_token()
if token:
headers["X-Auth-Token"] = token
headers["Content-type"] = "application/json"
else:
self.log.warning(
"""Unable to get token. Keystone API server may be down.
Skipping check for {}""".format(addr))
return
try:
self.log.debug("Connecting to %s" % addr)
if disable_ssl_validation:
self.warning(
"Skipping SSL certificate validation for %s based on configuration"
% addr)
h = Http(
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if username is not None and password is not None:
h.add_credentials(username, password)
resp, content = h.request(addr, "GET", headers=headers)
except socket.timeout as e:
length = int((time.time() - start) * 1000)
self.log.info(
"%s is DOWN, error: %s. Connection failed after %s ms" %
(addr, str(e), length))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "%s is DOWN, error: %s. Connection failed after %s ms" % (
addr, str(e), length)
except HttpLib2Error as e:
length = int((time.time() - start) * 1000)
self.log.info(
"%s is DOWN, error: %s. Connection failed after %s ms" %
(addr, str(e), length))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "%s is DOWN, error: %s. Connection failed after %s ms" % (
addr, str(e), length)
except socket.error as e:
length = int((time.time() - start) * 1000)
self.log.info(
"%s is DOWN, error: %s. Connection failed after %s ms" %
(addr, repr(e), length))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "%s is DOWN, error: %s. Connection failed after %s ms" % (
addr, str(e), length)
except httplib.ResponseNotReady as e:
length = int((time.time() - start) * 1000)
self.log.info(
"%s is DOWN, error: %s. Network is not routable after %s ms"
% (addr, repr(e), length))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "%s is DOWN, error: %s. Network is not routable after %s ms" % (
addr, str(e), length)
except Exception as e:
length = int((time.time() - start) * 1000)
self.log.error(
"Unhandled exception %s. Connection failed after %s ms" %
(str(e), length))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "%s is DOWN, error: %s. Connection failed after %s ms" % (
addr, str(e), length)
if response_time:
# Stop the timer as early as possible
running_time = time.time() - start
self.gauge('http_response_time',
running_time,
dimensions=new_dimensions)
# TODO(dschroeder): Save/send content data when supported by API
if int(resp.status) >= 400:
if use_keystone and int(resp.status) == 401:
if retry:
return Status.DOWN, "%s is DOWN, unable to get a valid token to connect with" % (
addr)
else:
# Get a new token and retry
self.log.warning(
"Token expired, getting new token and retrying...")
HTTPCheck.token = self.keystone.refresh_token()
retry = True
continue
else:
self.log.info("%s is DOWN, error code: %s" %
(addr, str(resp.status)))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "%s is DOWN, error code: %s" % (
addr, str(resp.status))
if pattern is not None:
if re.search(pattern, content, re.DOTALL):
self.log.debug("Pattern match successful")
else:
self.log.info("Pattern match failed! '%s' not in '%s'" %
(pattern, content))
self.gauge('http_status', 1, dimensions=new_dimensions)
return Status.DOWN, "Pattern match failed! '%s' not in '%s'" % (
pattern, content)
self.log.debug("%s is UP" % addr)
self.gauge('http_status', 0, dimensions=new_dimensions)
done = True
return Status.UP, "%s is UP" % addr
def test_access_with_credentials(self):
url = address + '/version'
h = Http()
h.add_credentials('unit_test', 'unit_test')
resp, result = h.request(url, 'GET')
self.assertEqual(resp['status'], '200')
body=data,
headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
resp['status'])
except Exception as err:
print("Test 1 FAILED: Could not make a new user")
print(err.args)
sys.exit()
else:
print("Test 1 PASS: Succesfully made a new user")
#TEST 2 ADD NEW BAGELS TO THE DATABASE
try:
h = Http()
h.add_credentials('TinnyTim', 'Udacity')
url = address + '/bagels'
data = dict(
username="******",
password="******",
name="plain",
picture=
"http://bonacbagel.weebly.com/uploads/4/0/5/4/40548977/s318635836612132814_p1_i1_w240.jpeg",
description="Old-Fashioned Plain Bagel",
price="$1.99")
resp, content = h.request(url,
'POST',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
if resp['status'] != '200':
raise Exception('Received an unsuccessful status code of %s' %
body=data,
headers={"Content-Type": "application/json"})
if resp['status'] != '201' and resp['status'] != '200':
raise Exception(
f"Received an unsuccessful status code of {resp['status']}")
except Exception as err:
print("Test 1 FAILED: Could not make a new user")
print(err.args)
sys.exit()
else:
print("Test 1 PASS: Successfully made a new user")
# TEST 2 ADD NEW BAGELS TO THE DATABASE
try:
h = Http()
h.add_credentials("douha", "password")
url = address + '/api/bagels'
data = dict(
username="******",
password="******",
name="plain",
picture=
"http://bonacbagel.weebly.com/uploads/4/0/5/4/40548977/s318635836612132814_p1_i1_w240.jpeg",
description="Old-Fashioned Plain Bagel",
price="$1.99")
resp, content = h.request(url,
'POST',
body=json.dumps(data),
headers={"Content-Type": "application/json"})
if resp['status'] != '200':
raise Exception(
}
###
## Execute the before query if it available
##
if js_conf.get('before'):
self.cr.execute(js_conf['before'], {'id': ex})
try:
d2 = {}
for k, v in par.items():
d2[k.encode('utf8')] = v.encode('utf8')
h = Http()
h.add_credentials(js_conf['user'], js_conf['pass'])
body=""
uri = 'http://%(js_host)s:%(js_port)s/jasperserver/rest_v2/reports/openerp/bases/%(db_name)s/%(report_unit)s.%(format)s?%(params)s' % {
'js_host': js_conf['host'],
'js_port': js_conf['port'],
'db_name': self.cr.dbname,
'report_unit': current_document.report_unit,
'format': current_document.format.lower(),
'params': urllib.urlencode(d2),
}
resp, content = h.request(uri, "GET")
if str(resp.status) in rest_exceptions.StatusException:
tt = ParseXML_REST(content)
raise rest_exceptions.StatusException[str(resp.status)]('\n'.join(tt))
if current_document.format.upper() == "PDF":
if len(args) == 1:
accessFile = args[0]
else:
accessFile = None
(base, appName, appPass) = connectionProperties(
parseConfigFile(options.config or 'crowd.properties'))
# Crowd deployment base URL
um = base + '/rest/usermanagement/1'
http = Http(cache='.cache')
# Crowd application credentials
http.add_credentials(appName, appPass)
CC_FRESH = {'Cache-Control': 'max-age=0', 'Accept': 'application/json'}
def get(url):
resp, content = http.request(url, headers=CC_FRESH)
if resp.status != 200:
print('Failed to fetch %s: %s' % (url, resp), file=stderr)
exit(10)
return json.loads(content.decode('utf-8'))
def getEventToken():
url = um + '/event'
resp, content = http.request(url, headers=CC_FRESH)
