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