def create(cls, uid, value, check_sum=None, processes=list()):
"""
Creates, processes and returns a record
:param uid: str
:param value: str
:param check_sum: str
:param processes: list
:return: object
"""
record = dict()
record['uid'] = uid
record['value'] = value
record['timestamp'] = time.time()
if not check_sum:
check_sum = Helpers.sign(value)
record['check_sum'] = check_sum
for process in processes:
process.process(record)
record['size'] = Helpers.iterable_size(target=record)
return record
def _put_job(self, url, dirs, params, data):
"""Puts result data job
"""
Helpers.request_put(url=url,
dirs=dirs,
data=data,
params=params)
def test_put_exists(self):
self.start_simple_server()
first_content = self.sample_fixed['value']
second_content = 'New content.'
response = Helpers.request_post(
url=URL,
dirs=['text', self.sample_fixed['uid']],
data={'value': first_content})
self.assertEqual(response.status_code, 200, 'First post failed')
first_len = len(response.content)
difference = len(second_content) - len(first_content)
expected_second_len = first_len + difference
response = Helpers.request_put(
url=URL,
dirs=['text', self.sample_fixed['uid']],
data={'value': 'New content.'})
self.assertEqual(response.status_code, 200, 'Put failed')
second_len = len(response.content)
second_len -= 1 # Due to optional negative sign on check_sum
self.assertLessEqual(second_len, expected_second_len)
response = Helpers.request_delete(
url=URL,
dirs=['text', self.sample_fixed['uid']])
self.assertEqual(response.status_code, 200, 'Delete failed')
def test_post_new(self):
self.start_simple_server()
uid = self.new_uid()
response = Helpers.request_post(
url=URL,
dirs=['text', uid],
data={'value': self.sample_normal['value']})
self.assertEqual(response.status_code, 200, 'Post failed')
response = Helpers.request_delete(
url=URL,
dirs=['text', uid])
self.assertEqual(response.status_code, 200, 'Delete failed')
def _bounce_delete_job(self, url, uid, params=None):
"""
Requests a delete job given an url, uid and value, and optionally a
get url parameters.
Returns False if response code is not 200.
:param url: str
:param uid: str
:param params: dict
:return: bool
"""
response = Helpers.request_delete(
url=url,
dirs=[uid],
params=params,
)
if response.status_code != 200:
return False
try:
self._cache.forget(uid=uid)
finally:
return True
def _bounce_post_job(self, url, uid, value, to_cache=False, params=None):
"""
Requests a post job given an url, uid and value, and optionally a
get url parameters.
Optionally inserts the record into cache.
Returns False if response code is not 200. Converts the response
content into a valid record if possible and returns the record on
success.
:param url: str
:param uid: str
:param value: str
:param to_cache: bool. If True records the response into cache.
:param params: dict
:return: dict
"""
response = Helpers.request_post(
url=url,
dirs=[uid],
data={'value': value},
params=params,
)
record = RecordHelper.str2record(content=response.content)
if response.status_code != 200 or not record:
return False
if to_cache:
self._cache.put(record)
return record
def update(self, uid, values):
"""
Updates a record. Raises an exception if record exists
:param uid: str
:param values: dict
:return: dict
"""
text = values['value']
self._valid_exists(uid=uid)
last_check_sum = self.get_check_sum(uid=uid)
new_check_sum = Helpers.sign(text)
if last_check_sum == new_check_sum:
raise RecordExists('Record has no change')
record = self.create(uid=uid,
value=text,
check_sum=new_check_sum,
processes=self._processes)
self._storage.update(record=record)
return record
def test_delete_not_exists_error(self):
self.start_simple_server()
response = Helpers.request_delete(
url=URL,
dirs=['text', self.new_uid()])
self.assertEqual(response.status_code, 404)
def test_put_not_exists_error(self):
self.start_simple_server()
response = Helpers.request_put(
url=URL,
dirs=['text', self.new_uid()],
data={'value': 'dummy content'})
self.assertEqual(response.status_code, 404)
def _remove_file_by_uid(self, uid):
"""
Removes the file
:param uid: str
"""
file_path = self.__format_filename(filename=uid,
base_path=self._base_path)
return Helpers.delete_file(file_path=file_path)
def _remove_file_by_uid(self, uid):
"""
Removes the file
:param uid: str
"""
file_path = self.__format_filename(filename=uid,
base_path=self._base_path)
return Helpers.delete_file(file_path=file_path)
def exists(self, uid):
"""
Checks if a record exists and returns True or False.
:param uid: str
:return: bool
"""
file_path = self.__format_filename(filename=uid,
base_path=self._base_path)
return Helpers.path_exists(file_path)
def exists(self, uid):
"""
Checks if a record exists and returns True or False.
:param uid: str
:return: bool
"""
file_path = self.__format_filename(filename=uid,
base_path=self._base_path)
return Helpers.path_exists(file_path)
def test_get_exists(self):
self.start_simple_server()
uid = self.sample_fixed_len['uid']
expected_len = 158
response = Helpers.request_post(
url=URL,
dirs=['text', uid],
data={'value': self.sample_fixed_len['value']})
self.assertEqual(response.status_code, 200, 'Post failed')
response = Helpers.request_get(
url=URL,
dirs=['text', uid])
self.assertEqual(response.status_code, 200, 'Get failed')
self.assertEqual(len(response.content), expected_len)
response = Helpers.request_delete(
url=URL,
dirs=['text', uid])
self.assertEqual(response.status_code, 200, 'Delete failed')
def _bounce_get_job(cls, url, uid, params=None):
"""
Requests a get job given an url and uid, and optionally a set of url
parameters.
Returns False if response code is not 200. Converts the response
content into a valid record if possible and returns the record on
success.
:param url: str
:param uid: str
:param params: dict
:return: dict
"""
response = Helpers.request_get(url=url, dirs=[uid], params=params)
record = RecordHelper.str2record(content=response.content)
if response.status_code != 200 or not record:
return False
return record
def _delete_job(self, url, dirs, params):
Helpers.request_delete(url=url, dirs=dirs, params=params)
uid = dirs[-1]
self._cache.forget(uid=uid)
def triple_server_common(self, route_key):
self.start_triple_server(key=route_key)
uid = self.sample_fixed['uid']
value = self.sample_fixed['value']
response = Helpers.request_post(
url=URL1,
dirs=['text', uid],
data={'value': value})
self.assertEqual(response.status_code, 200)
time.sleep(10)
record1 = self.get_record_by_path(
'test-sandbox/{key}/{key}1/{uid}'.format(key=route_key, uid=uid)
)
record2 = self.get_record_by_path(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
record3 = self.get_record_by_path(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertEqual(record1, record2, 'POST: Record 1 and 2')
self.assertEqual(record2, record3, 'POST: Record 2 and 3')
self.assertEqual(record1['uid'], uid, 'POST: Unexpected uid')
value = 'I have changed the content on first and {!s} site too.'\
.format(route_key)
response = Helpers.request_put(
url=URL1,
dirs=['text', uid],
data={'value': value})
self.assertEqual(response.status_code, 200)
response_record = self.get_record_by_response_content(response.content)
self.assertEqual(response_record['value'][0:20], value[0:20])
time.sleep(10)
record1 = self.get_record_by_path(
'test-sandbox/{key}/{key}1/{uid}'.format(key=route_key, uid=uid)
)
record2 = self.get_record_by_path(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
record3 = self.get_record_by_path(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertEqual(record1, record2, 'PUT: Record 1 and 2')
self.assertEqual(record2, record3, 'PUT: Record 2 and 3')
self.assertEqual(record1['uid'], uid, 'PUT: Unexpected uid')
response = Helpers.request_delete(
url=URL1,
dirs=['text', uid])
self.assertEqual(response.status_code, 200)
time.sleep(10)
exists1 = Helpers.path_exists(
'test-sandbox/{key}/{key}1/{uid}'.format(key=route_key, uid=uid)
)
exists2 = Helpers.path_exists(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
exists3 = Helpers.path_exists(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertFalse(exists1)
self.assertFalse(exists2)
self.assertFalse(exists3)
self.stop_all_apis()
def triple_server_inequable(self, route_key):
self.start_triple_server(key=route_key)
uid = self.sample_fixed['uid']
value = self.sample_fixed['value']
response = Helpers.request_post(
url=URL1,
dirs=['text', uid],
data={'value': value})
self.assertEqual(response.status_code, 200)
time.sleep(10)
Helpers.delete_file(
file_path='test-sandbox/{key}/{key}1/{uid}'.format(key=route_key,
uid=uid)
)
exists1 = Helpers.path_exists(
'test-sandbox/{key}/{key}1/{uid}'.format(key=route_key, uid=uid)
)
self.assertFalse(exists1, 'Record 1 still exists')
record2 = self.get_record_by_path(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
record3 = self.get_record_by_path(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertEqual(record2, record3, 'POST: Record 2 and 3')
self.assertEqual(record2['uid'], uid, 'POST: Unexpected uid')
response = Helpers.request_get(
url=URL1,
dirs=['text', uid])
self.assertEqual(response.status_code, 200, 'Get failed')
record1 = RecordHelper.str2record(content=response.content)
self.assertEqual(record1, record2, 'POST: Record 1 and 2')
response = Helpers.request_delete(
url=URL1,
dirs=['text', uid])
self.assertEqual(response.status_code, 200)
time.sleep(10)
exists1 = Helpers.path_exists(
'test-sandbox/{key}/{key}1/{uid}'.format(key=route_key, uid=uid)
)
exists2 = Helpers.path_exists(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
exists3 = Helpers.path_exists(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertFalse(exists1)
self.assertFalse(exists2)
self.assertFalse(exists3)
self.stop_all_apis()
def test_cache(self):
route_key = 'cache'
self.start_triple_server(key=route_key)
uid = self.sample_fixed['uid']
value = self.sample_fixed['value']
response = Helpers.request_post(
url=URL1,
dirs=['text', uid],
data={'value': value},
params={CACHE_MODE: int(True)},
)
self.assertEqual(response.status_code, 200)
time.sleep(10)
self.assertRaises(IOError,
self.get_record_by_path,
'test-sandbox/{key}/{key}1/{uid}'.format(
key=route_key,
uid=uid
))
record2 = self.get_record_by_path(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
record3 = self.get_record_by_path(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertNotEqual(record2, record3, 'POST: Record 2 and 3 are equal')
self.assertEqual(record2['value'], record3['value'],
'POST: Record 2 and 3 different values')
self.assertEqual(record2['uid'], uid, 'POST: Unexpected uid')
value = 'I have changed the content on first and {!s} site too.'\
.format(route_key)
response = Helpers.request_put(
url=URL1,
dirs=['text', uid],
data={'value': value},
params={CACHE_MODE: int(True)},
)
self.assertEqual(response.status_code, 200)
response_record = self.get_record_by_response_content(response.content)
self.assertEqual(response_record['value'][0:20], value[0:20])
time.sleep(10)
self.assertRaises(IOError,
self.get_record_by_path,
'test-sandbox/{key}/{key}1/{uid}'.format(
key=route_key,
uid=uid
))
record2 = self.get_record_by_path(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
record3 = self.get_record_by_path(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertNotEqual(record2, record3, 'PUT: Record 2 and 3 are equal')
self.assertEqual(record2['value'], record3['value'],
'PUT: Record 2 and 3 different values')
self.assertEqual(record2['uid'], uid, 'PUT: Unexpected uid')
response = Helpers.request_delete(
url=URL1,
dirs=['text', uid],
params={CACHE_MODE: int(True)},
)
self.assertEqual(response.status_code, 200)
time.sleep(10)
exists1 = Helpers.path_exists(
'test-sandbox/{key}/{key}1/{uid}'.format(key=route_key, uid=uid)
)
exists2 = Helpers.path_exists(
'test-sandbox/{key}/{key}2/{uid}'.format(key=route_key, uid=uid)
)
exists3 = Helpers.path_exists(
'test-sandbox/{key}/{key}3/{uid}'.format(key=route_key, uid=uid)
)
self.assertFalse(exists1)
self.assertFalse(exists2)
self.assertFalse(exists3)
self.stop_all_apis()
if len(sys.argv) < 3:
print AboutHelper.help_info(default_port=DEFAULT_PORT)
exit(1)
servers_list_path = sys.argv[1]
if servers_list_path == '-h' or servers_list_path == '--help':
print AboutHelper.help_info(default_port=DEFAULT_PORT)
exit(1)
base_path = sys.argv[2]
try:
port = int(sys.argv[3])
except IndexError:
port = DEFAULT_PORT
if not Helpers.path_exists(servers_list_path):
print "Error: provided SERVERS_LIST_PATH is not a valid path.\n"
print "See --help for more information.\n"
exit(1)
if not Helpers.path_exists(base_path):
print "Error: provided BASE_PATH is not a valid path.\n"
print "See --help for more information.\n"
exit(1)
print "Running on port {:d}".format(port)
make_server('', port, app).serve_forever()
if len(sys.argv) < 3:
print AboutHelper.help_info(default_port=DEFAULT_PORT)
exit(1)
servers_list_path = sys.argv[1]
if servers_list_path == '-h' or servers_list_path == '--help':
print AboutHelper.help_info(default_port=DEFAULT_PORT)
exit(1)
base_path = sys.argv[2]
try:
port = int(sys.argv[3])
except IndexError:
port = DEFAULT_PORT
if not Helpers.path_exists(servers_list_path):
print "Error: provided SERVERS_LIST_PATH is not a valid path.\n"
print "See --help for more information.\n"
exit(1)
if not Helpers.path_exists(base_path):
print "Error: provided BASE_PATH is not a valid path.\n"
print "See --help for more information.\n"
exit(1)
print "Running on port {:d}".format(port)
make_server('', port, app).serve_forever()
