def __init__(self, id=None, volume=None, snapshot=None):
DatabaseObject.__init__(self)
if id is None:
self.id = uuid.uuid4().hex
# Transfer the class attribute to the database
self.type = self.type
self.state = None
self.time = None
self.volume_id = None
_task_threads[self.id] = None
else:
self.id = id
if volume is None:
self.volume = None
else:
self.volume_id = volume.id
self.volume = volume
if snapshot is not None:
self.snapshot_id = snapshot.id
self.snapshot = snapshot
self.update()
def __init__(self, id=None, type=None, resource_id=None):
DatabaseObject.__init__(self)
if id is None:
self.id = uuid.uuid4().hex
self.type = type
self.resource_id = resource_id
self.time = int(time.time() * 1000)
else:
self.id = id
def __init__(self, id=None, type=None, message=None):
DatabaseObject.__init__(self)
if id is None:
self.id = uuid.uuid4().hex
self.type = type or INFO
self.time = int(time.time())
self.message = message
Event(type=LOG_UPDATED)
else:
self.id = id
def __setattr__(self, name, value):
if name == 'thread':
if value is None:
if self.id in _task_threads:
del _task_threads[self.id]
else:
_task_threads[self.id] = value
else:
DatabaseObject.__setattr__(self, name, value)
if name == 'state' and value:
Event(volume_id=self.volume_id, type=TASKS_UPDATED)
def __init__(self, id=None, volume_id=None, type=None):
DatabaseObject.__init__(self)
if id is None:
self.id = uuid.uuid4().hex
self.type = type
self.time = int(time.time() * 1000)
self.volume_id = None
else:
self.id = id
if volume_id is not None:
self.volume_id = volume_id
def __getattr__(self, name):
if name == 'thread':
if self.id not in _task_threads:
return None
return _task_threads[self.id]
else:
return DatabaseObject.__getattr__(self, name)
def clean_database():
tasks_dict = {}
tasks_time = []
tasks_query = Task.db.get(Task.column_family)
for task_id in tasks_query:
task = tasks_query[task_id]
# Skip broken events
if not DatabaseObject.validate(Task, task_id, task):
continue
task['time'] = int(task['time'])
task_time_id = '%s-%s' % (task['time'], task_id)
tasks_dict[task_time_id] = task_id
tasks_time.append(task_time_id)
prune_count = len(tasks_query) - TASK_DB_MAX
if prune_count <= 0:
return
# Remove tasks after limit is reached
tasks_time = sorted(tasks_time)
for i in xrange(prune_count):
task_id = tasks_dict[tasks_time.pop(0)]
logger.debug('Max task count reached removing task ' + \
'from database. %r' % {
'task_id': task_id,
})
Task.db.remove(Task.column_family, task_id)
def get_events(last_time=0):
events = []
events_dict = {}
events_sort = []
cur_time = int(time.time() * 1000)
logger.debug('Getting events. %r' % {
'last_time': last_time,
})
events_query = Event.db.get(Event.column_family)
for event_id in events_query:
event = events_query[event_id]
# Skip broken events
if not DatabaseObject.validate(Event, event_id, event):
continue
event['time'] = int(event['time'])
if event['time'] <= last_time:
continue
time_id = '%s_%s' % (event['time'], event_id)
events_dict[time_id] = Event(id=event_id)
events_sort.append(time_id)
for time_id in sorted(events_sort):
events.append(events_dict[time_id])
return events
def get_log_entries():
logs = []
logs_dict = {}
logs_sort = []
logger.debug('Getting log entries.')
logs_query = LogEntry.db.get(LogEntry.column_family)
for log_id in logs_query:
log = logs_query[log_id]
if not DatabaseObject.validate(LogEntry, log_id, log):
continue
log['time'] = int(log['time'])
time_id = '%s_%s' % (log['time'], log_id)
logs_dict[time_id] = LogEntry(id=log_id)
logs_sort.append(time_id)
for time_id in reversed(sorted(logs_sort)):
logs.append(logs_dict[time_id])
for log in logs[DEFAULT_LOG_LIMIT:]:
logger.debug('Pruning log entry from database. %r' % {
'log_id': log.id,
})
LogEntry.db.remove(LogEntry.column_family, log.id)
return logs[:DEFAULT_LOG_LIMIT]
def get_task(task_id):
logger.debug('Getting task. %r' % {
'task_id': task_id,
})
task = Task.db.get(Task.column_family, task_id)
if task:
if DatabaseObject.validate(Task, task_id, task):
return Task(id=task_id)
def clean_database():
cur_time = int(time.time() * 1000)
events_query = Event.db.get(Event.column_family)
for event_id in events_query:
event = events_query[event_id]
# Skip broken events
if not DatabaseObject.validate(Event, event_id, event):
continue
event['time'] = int(event['time'])
# Remove events after ttl
if (cur_time - event['time']) > EVENT_DB_TTL:
logger.debug('Removing event past ttl from database. %r' % {
'event_id': event_id,
})
Event.db.remove(Event.column_family, event_id)
continue
def _get_tasks(volume, type, states=[]):
tasks = []
tasks_dict = {}
tasks_time = []
logger.debug('Getting tasks for volume. %r' % {
'volume_id': volume.id,
})
tasks_query = Task.db.get(Task.column_family)
for task_id in tasks_query:
task = tasks_query[task_id]
# Skip broken events
if not DatabaseObject.validate(Task, task_id, task):
continue
task['time'] = int(task['time'])
if type and task['type'] != type:
continue
if task['volume_id'] != volume.id:
continue
if states and task['state'] not in states:
continue
if not states and not task['state']:
continue
# Task update occurs here recheck state
task = Task(id=task_id)
if states and task.state not in states:
continue
task_time_id = '%s-%s' % (task.time, task_id)
tasks_dict[task_time_id] = task
tasks_time.append(task_time_id)
for task_time_id in sorted(tasks_time):
tasks.append(tasks_dict[task_time_id])
return tasks
def get_events(last_time=0):
events = []
events_dict = {}
events_time = []
cur_time = int(time.time() * 1000)
logger.debug('Getting global events. %r' % {
'last_time': last_time,
})
events_query = Event.db.get(Event.column_family)
for event_id in events_query:
event = events_query[event_id]
# Skip broken events
if not DatabaseObject.validate(Event, event_id, event):
continue
event['time'] = int(event['time'])
if event['time'] <= last_time:
continue
# Prevent events with the same time from breaking sorted list,
# event that is sent to client will always have original time
while True:
if event['time'] not in events_time:
break
event['time'] += 1
events_dict[event['time']] = Event(id=event_id)
events_time.append(event['time'])
for event_time in sorted(events_time):
events.append(events_dict[event_time])
return events
