def test_get(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query_doc.get('key1')
query_doc.make_request.assert_called_once_with(
method='GET', uri='queries/key1')
def test_put(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query_doc.put('key1', {'query_doc': 1})
query_doc.make_request.assert_called_once_with(
method='PUT', uri='queries/key1/', data={'query_doc': 1})
def test_post(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query_doc.post({'query_doc': 1})
query_doc.make_request.assert_called_once_with(
method='POST', uri='queries/', data={'query_doc': 1})
def test_execute_with_variable(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query_doc.execute('key1', 'variable')
query_doc.make_request.assert_called_once_with(
method='GET', uri='queries/key1/execute/?variable=variable')
def test_delete(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query_doc.delete('key1')
query_doc.make_request.assert_called_once_with(
method='DELETE', uri='queries/key1/')
def generate_auth(self):
LOGGER.info('New Auth')
self.auth = auth.Auth(api_url=self.host,
username=GLOBOMAP_API_USERNAME,
password=GLOBOMAP_API_PASSWORD)
self.doc = Document(auth=self.auth)
self.query = Query(auth=self.auth)
def test_list_with_pagination(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query_doc.list(20, 2)
params = {
'per_page': 20,
'page': 2
}
query_doc.make_request.assert_called_once_with(
method='GET', uri='queries/', params=params)
def test_search(self):
query_doc = Query(Mock())
query_doc.make_request = Mock()
query = [[{'field': 'name', 'operator': 'LIKE', 'value': 'test'}]]
query_doc.search(query, 20, 2)
params = {
'query': json.dumps(query),
'per_page': 20,
'page': 2
}
query_doc.make_request.assert_called_once_with(
method='GET', uri='queries/', params=params)
import os
from globomap_api_client.auth import Auth
from globomap_api_client.collection import Collection
from globomap_api_client.edge import Edge
from globomap_api_client.graph import Graph
from globomap_api_client.query import Query
GMAP_API_PORT = os.getenv('GMAP_API_PORT', '7002')
auth_inst = Auth(api_url='http://localhost:{}'.format(GMAP_API_PORT),
username='******',
password='******')
coll = Collection(auth=auth_inst)
edge = Edge(auth=auth_inst)
graph = Graph(auth=auth_inst)
query = Query(auth=auth_inst)
coll.post({
'name': 'vip',
'alias': 'vip',
'icon': 'icon',
})
coll.post({
'name': 'vm',
'alias': 'vm',
'icon': 'icon',
})
coll.post({
'name': 'network',
'alias': 'network',
'icon': 'icon',
})
class GloboMapClient(object):
def __init__(self, host):
self.host = host
self.generate_auth()
def generate_auth(self):
LOGGER.info('New Auth')
self.auth = auth.Auth(api_url=self.host,
username=GLOBOMAP_API_USERNAME,
password=GLOBOMAP_API_PASSWORD)
self.doc = Document(auth=self.auth)
self.query = Query(auth=self.auth)
def update_element_state(self,
action,
type,
collection,
element,
key,
retries=0):
try:
if action.upper() == 'CREATE':
return self.create(type, collection, element)
elif action.upper() == 'UPDATE':
return self.update(type, collection, key, element)
elif action.upper() == 'PATCH':
return self.patch(type, collection, key, element)
elif action.upper() == 'DELETE':
return self.delete(type, collection, key)
elif action.upper() == 'CLEAR':
return self.clear(type, collection, element)
except exceptions.ValidationError as err:
if '1200' in err.message['errors'] and retries < RETRIES:
LOGGER.warning('Retry action %s %s %s %s %s', action, type,
collection, element, key)
retries += 1
time.sleep(2)
self.update_element_state(action, type, collection, element,
key, retries)
else:
LOGGER.error('Bad request in send element %s %s %s %s %s %s',
action, type, collection, element, key,
err.message)
raise GloboMapException(err.message, err.status_code)
except exceptions.Unauthorized as err:
if retries < RETRIES:
LOGGER.warning('Retry action %s %s %s %s %s', action, type,
collection, element, key)
retries += 1
self.generate_auth()
time.sleep(5 + (retries * 5))
self.update_element_state(action, type, collection, element,
key, retries)
else:
LOGGER.error('Error send element %s %s %s %s %s', action, type,
collection, element, key)
raise GloboMapException(err.message, err.status_code)
except exceptions.Forbidden as err:
LOGGER.error('Forbbiden send element %s %s %s %s %s', action, type,
collection, element, key)
raise GloboMapException(err.message, err.status_code)
except exceptions.ApiError as err:
if retries < RETRIES:
LOGGER.warning('Retry send element %s %s %s %s %s', action,
type, collection, element, key)
retries += 1
time.sleep(5 + (retries * 5))
self.update_element_state(action, type, collection, element,
key, retries)
else:
LOGGER.error('Error send element %s %s %s %s %s', action, type,
collection, element, key)
raise GloboMapException(err.message, err.status_code)
def create(self, type, collection, payload):
try:
return self.doc.post(type, collection, payload)
except exceptions.NotFound as err:
raise GloboMapException(err.message, err.status_code)
except exceptions.DocumentAlreadyExists:
LOGGER.warning('Element already insered')
def update(self, type, collection, key, payload):
try:
return self.doc.put(type, collection, key, payload)
except exceptions.NotFound:
return self.create(type, collection, payload)
def patch(self, type, collection, key, payload):
try:
return self.doc.patch(type, collection, key, payload)
except exceptions.NotFound:
return self.create(type, collection, payload)
def delete(self, type, collection, key):
try:
return self.doc.delete(type, collection, key)
except exceptions.NotFound:
LOGGER.warning('Element %s already deleted', key)
def clear(self, type, collection, payload):
return self.doc.clear(type, collection, payload)
def run_query(self, query_id, variable):
return self.query.execute(query_id, variable)