def main():
items = 100000
cluster = Cluster(['127.0.0.1'])
session = cluster.connect()
session.execute('DROP KEYSPACE queue_test;')
session.execute("CREATE KEYSPACE queue_test WITH REPLICATION = { 'class': 'SimpleStrategy', 'replication_factor': 1 };")
session.execute("USE queue_test;")
session.execute("CREATE TABLE queue (id text, event_at timeuuid, payload text, PRIMARY KEY(id, event_at));")
timeuuid = TimeUUID.with_utcnow()
for i in range(0, items - 1):
timeuuid = TimeUUID.with_utcnow()
query = "INSERT INTO queue (id, event_at, payload) VALUES ('queue_1', " + str(timeuuid) + ", 'payload" + str(i) + "');"
session.execute(query)
session.execute("DELETE FROM queue WHERE id = 'queue_1' AND event_at = " + str(timeuuid) + ";")
query = "INSERT INTO queue (id, event_at, payload) VALUES ('queue_1', " + str(TimeUUID.with_utcnow()) + ", 'payload100000');"
session.execute(query)
before = time.time()
result = session.execute("SELECT * FROM queue WHERE id = 'queue_1' LIMIT 1;")
print 'Not enqueued executed in %s ms' % str(time.time() - before)
print 'Result: %s' % str(result[0])
before = time.time()
result = session.execute("SELECT * FROM queue WHERE id = 'queue_1' AND event_at > " + str(timeuuid) + " LIMIT 1;")
print 'Enqueued executed in %s ms' % str(time.time() - before)
print 'Result: %s' % str(result[0])
session.execute("TRUNCATE queue;")
session.execute('DROP KEYSPACE queue_test;')
def test_with_utc(self):
time = datetime.datetime.utcnow()
res = TimeUUID.with_utc(time, randomize=True)
self.assertIsInstance(res, uuid.UUID)
self.assertIsInstance(res, TimeUUID)
res1 = TimeUUID.with_utc(time, randomize=False)
res2 = TimeUUID.with_utc(time, randomize=False)
self.assertEqual(res1, res2)
def test_upgrade(self):
self.assertIsNone(TimeUUID.upgrade(None))
origin = TimeUUID(int=random.randrange(1e7))
upgraded = TimeUUID.upgrade(origin)
self.assertIsInstance(upgraded, uuid.UUID)
self.assertIsInstance(upgraded, TimeUUID)
self.assertEqual(str(upgraded), str(origin))
origin = uuid.uuid1()
upgraded = TimeUUID.upgrade(origin)
self.assertIsInstance(upgraded, uuid.UUID)
self.assertIsInstance(upgraded, TimeUUID)
self.assertEqual(str(upgraded), str(origin))
self.assertRaises(TypeError, TimeUUID.upgrade, 'coucou')
def generate_uri(host, structure, dataset_type, uuid=None):
"""
Builds a URI from the structure and host defined in config file.
:param str host: Host value for the URI
:param str structure: Structure used to form the final URL
:param Model dataset_type: For which element the URI will be generated
:param str or None uuid: ID in case that already exists. Default: None
:return: Tuple with well formatted URI and UUID
:rtype: (str, str)
"""
Validators.is_informed(const.URI_HOST, host)
if not uuid:
uuid = str(TimeUUID.with_utcnow())
if dataset_type is Model.CATALOGUE:
return 'http://{host}/'.format(host=host), uuid
Validators.is_expected_value(const.URI_STRUCTURE, '{host}', structure)
if structure[-1] is not '/':
structure += '/'
structure += '{type}/'
return structure.format(host=host, type=dataset_type.value) + uuid, uuid
def get_ts_for_timeuuid(timeuuid, cassandra=False, iso=False):
'''
Extracts timestamp from TimeUUID.
By default, returns datetime.datetime.
Returns iso 8166 timestamp string if iso == True
'''
try:
if cassandra == True:
timeuuid = TimeUUID.convert(timeuuid)
ts = TimeUUID.get_datetime(timeuuid)
except:
e = "get_ts_for_timeuuid: %r is not a time_uuid.TimeUUID, is %r." % \
(timeuuid, type(timeuuid))
raise ValueError(e)
if iso:
return ts.isoformat()
else:
return ts
def get_issued_date(dataset_id):
"""
Cleans the value provided to get the issued date of the dataset.
:param str dataset_id: Dataset's stored identifier.
:return: The issued date in UTC ISO 8601 format.
:rtype: str
"""
time_uuid = TimeUUID.convert(uuid.UUID('{%s}' % dataset_id))
return Helpers.format_datetime(time_uuid.get_datetime())
def generate_token(username):
if username is None:
raise InvalidRequestData('Invalid username.')
conn = get_connection()
cursor = conn.cursor()
new_token = str(uuid.with_timestamp(utctime()))
cursor.execute('UPDATE auth SET token = ? WHERE user = ?',
(new_token, username))
conn.commit()
conn.close()
return new_token
def get_tuuid(self,
hex: Optional[str] = None,
timestamp: Optional[float] = None) -> TimeUUID:
"""
Get a TimeUUID.
Args:
hex: The optional TimeUUID as hex.
timestamp: The optional timestamp to use in the TimeUUID
Returns:
The TimeUUID.
"""
if hex:
tuuid = TimeUUID(hex=hex)
elif timestamp:
tuuid = TimeUUID.with_timestamp(timestamp)
else:
tuuid = TimeUUID.with_utcnow()
return tuuid
def extract_datetime(self, tuuid: TimeUUID) -> datetime:
"""
Extract the datetime from a TimeUUID.
Args:
tuuid: A TimeUUID.
Returns:
The timezone-aware UTC datetime.
"""
dt = tuuid.get_datetime().replace(tzinfo=timezone.utc)
return cast(datetime, dt)
def _has_valid_request_id(self, request_id):
# Extract the timestamp from the UUID1
timestamp = TimeUUID(request_id).get_timestamp()
# Check to see if this request has expired
has_valid_timestamp = time() - timestamp < self.expiry
# Check to see if this request has been attempted before
# (prevent replay)
is_unused = self._has_unused_id(request_id)
# Both checks are required to pass in order to validate the request id
return has_valid_timestamp and is_unused
def make_timeuuid(event_time):
'''
Creates a randomized time_uuid.TimeUUID for a given datetime.datetime
:param event_time: datetime.datetime to get timeuuid for
:retuens: time_uuid.TimeUUID
'''
try:
return TimeUUID.with_timestamp(
mktime(event_time.timetuple()), randomize=True)
except:
e = "get_event_id: %r is not a datetime.datetime, is %r." % \
(event_time, type(event_time))
raise ValueError(e)
def __init__(self, pool, column_family, key, **kwargs):
self.pool = pool
if isinstance(column_family, ColumnFamily):
self.column_family = column_family
else:
cf_kwargs = {k: kwargs.get(k) for k in _cf_args if k in kwargs}
self.column_family = ColumnFamily(self.pool, column_family, **cf_kwargs)
self.key = key
self.consistency_level = kwargs.get('consistency_level', ConsistencyLevel.LOCAL_QUORUM)
self.prefix = kwargs.get('prefix', '_lock_')
self.lock_id = kwargs.get('lock_id', str(TimeUUID.with_utcnow()))
self.fail_on_stale_lock = kwargs.get('fail_on_stale_lock', False)
self.timeout = kwargs.get('timeout', 60.0) # seconds
self.ttl = kwargs.get('ttl', None)
self.backoff_policy = kwargs.get('backoff_policy', getUtility(IRetryPolicy, 'run_once'))
self.allow_retry = kwargs.get('allow_retry', True)
self.locks_to_delete = set()
self.lock_column = None
def __init__(self, pool, column_family, key, **kwargs):
self.pool = pool
if isinstance(column_family, ColumnFamily):
self.column_family = column_family
else:
cf_kwargs = {k: kwargs.get(k) for k in _cf_args if k in kwargs}
self.column_family = ColumnFamily(self.pool, column_family,
**cf_kwargs)
self.key = key
self.consistency_level = kwargs.get('consistency_level',
ConsistencyLevel.LOCAL_QUORUM)
self.prefix = kwargs.get('prefix', '_lock_')
self.lock_id = kwargs.get('lock_id', str(TimeUUID.with_utcnow()))
self.fail_on_stale_lock = kwargs.get('fail_on_stale_lock', False)
self.timeout = kwargs.get('timeout', 60.0) # seconds
self.ttl = kwargs.get('ttl', None)
self.backoff_policy = kwargs.get('backoff_policy',
getUtility(IRetryPolicy, 'run_once'))
self.allow_retry = kwargs.get('allow_retry', True)
self.locks_to_delete = set()
self.lock_column = None
def test_get_time(self):
utc_time = datetime.utcnow()
log_entry = CassandraLogEntry(time_uuid=TimeUUID.convert(utc_time))
assert log_entry.time == utc_time
def time_uuid(self, value):
if value is not None:
self._time_uuid = TimeUUID.convert(value)
else:
self._time_uuid = None
def _create_time_uuid(date_time_string):
return TimeUUID.convert(arrow.get(date_time_string).datetime)
def _create_time_uuid(date_time_string):
return TimeUUID.convert(arrow.get(date_time_string).datetime)
def time(self):
if self.time_uuid is None:
return None
else:
return TimeUUID.upgrade(self.time_uuid).get_datetime()
def make_identifier() -> str:
return TimeUUID.with_timestamp(utctime())
def time(self):
if self.time_uuid is None:
return None
else:
return TimeUUID.upgrade(self.time_uuid).get_datetime()
def test_get_time(self):
utc_time = datetime.utcnow()
log_entry = CassandraLogEntry(time_uuid=TimeUUID.convert(utc_time))
assert log_entry.time == utc_time
# |--ServerID :string
# |
# +ReadingListNonSync
# |--AddedLocally :bool
# |
# |WebBookmarkType :string
# |WebBookmarkUUID :string
# |URLString :string
# |
# +ReadingList
# |--DateAdded :date
#
#print("%s\n%s\n%s\n%s\n" % (title, time_added, href, tags))
WebBookmarkUUID = TimeUUID.convert(long(time_added), randomize=False).get_urn()[9:]
have = False
for sub_item in sub_items:
if sub_item['WebBookmarkUUID'] == WebBookmarkUUID:
have = True
break
if have:
continue
DateAdded = dt.utcfromtimestamp(long(time_added))
entry = dict()
URIDictionary = dict()
Sync = dict()
def test_with_utcnow(self):
res = TimeUUID.with_utcnow()
self.assertIsInstance(res, uuid.UUID)
self.assertIsInstance(res, TimeUUID)
def time_uuid(self, value):
if value is not None:
self._time_uuid = TimeUUID.convert(value)
else:
self._time_uuid = None
def grpc_totimeUUID(uuid):
return TimeUUID(uuid.value)
