# -*- coding: utf-8 -*-
"""
Barbican Models
~~~~~~~~~~~~~~~
The models for Barbican.
:copyright: (c) 2013 by Jarret Raim
:license: Apache 2.0, see LICENSE for details
"""
from uuid import uuid4
from sqlalchemy import Column, Integer, String, DateTime, Text, Boolean
from sqlalchemy.orm import relationship, backref
from sqlalchemy.schema import ForeignKey
from database import Base
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(50), unique=True)
email = Column(String(120), unique=True)
password = Column(String(50))
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __init__(self, name=None, email=None, password=None):
self.name = name
self.email = email
self.password = password
def __repr__(self):
return '<User %r>' % self.name
class Tenant(Base):
__tablename__ = 'tenants'
id = Column(Integer, primary_key=True)
uuid = Column(String(36), unique=True)
def __init__(self, uuid=None, id=None):
self.id = id
if uuid is None:
self.uuid = str(uuid4())
else:
self.uuid = uuid
def __repr__(self):
return '<Tenant %s>' % self.uuid
def as_dict(self):
json = {
'id': self.id,
'uuid': self.uuid
}
return json
class Key(Base):
__tablename__ = 'keys'
id = Column(Integer, primary_key=True)
uuid = Column(String(36), unique=True)
filename = Column(String(128))
mime_type = Column(String(128))
expiration = Column(DateTime)
secret = Column(Text)
owner = Column(String(33))
group = Column(String(33))
cacheable = Column(Boolean)
policy_id = Column(Integer, ForeignKey('policies.id'))
policy = relationship("Policy", backref=backref('keys'))
def __init__(self, uuid=None, filename=None, mime_type=None, expiration=None, secret=None,
owner=None, group=None, cacheable=None, policy_id=None):
if uuid is None:
self.uuid = str(uuid4())
else:
self.uuid = uuid
self.filename = filename
self.mime_type = mime_type
self.expiration = expiration
self.secret = secret
self.owner = owner
self.group = group
self.cacheable = cacheable
self.policy_id = policy_id
def __repr__(self):
return '<Key %s>' % self.uuid
def as_dict(self):
json = {
'uuid': self.uuid,
'filename': self.filename,
'mime_type': self.mime_type,
'expiration': self.expiration.isoformat(),
'secret': self.secret,
'owner': self.owner,
'group': self.group,
'cachecable': self.cacheable
}
return json
class Agent(Base):
__tablename__ = 'agents'
id = Column(Integer, primary_key=True)
uuid = Column(String(36), unique=True)
hostname = Column(String(128))
os_version = Column(String(128))
agent_version = Column(String(33))
paired = Column(Boolean)
tenant_id = Column(Integer, ForeignKey('tenants.id'))
tenant = relationship("Tenant", backref=backref('agents', order_by=id))
def __init__(self, tenant=None, uuid=None, hostname=None, os_version=None, agent_version=None, paired=None):
self.tenant = tenant
self.tenant_id = tenant.id
if uuid is None:
self.uuid = str(uuid4())
else:
self.uuid = uuid
if paired is None:
self.paired = False
else:
self.paired = paired
self.hostname = hostname
self.os_version = os_version
self.agent_version = agent_version
def __repr__(self):
return '<Agent %s>' % self.uuid
def as_dict(self):
tags = map(Tag.as_dict, self.tags)
agent = {
'tenant_id': self.tenant_id,
'uuid': self.uuid,
'hostname': self.hostname,
'os_version': self.os_version,
'agent_version': self.agent_version,
'paired': self.paired,
'tags': tags
}
return agent
class Policy(Base):
__tablename__ = 'policies'
id = Column(Integer, primary_key=True)
uuid = Column(String(36), unique=True)
name = Column(String(100))
directory_name = Column(String(254))
max_key_accesses = Column(Integer)
time_available_after_reboot = Column(Integer)
tenant_id = Column(Integer, ForeignKey('tenants.id'))
tenant = relationship("Tenant", backref=backref('policies', order_by=id))
def __init__(self, uuid=None, name=None, directory_name=None, max_key_accesses=None,
time_available_after_reboot=None, tenant_id=None):
if uuid is None:
self.uuid = str(uuid4())
else:
self.uuid = uuid
self.name = name
self.directory_name = directory_name
self.max_key_accesses = max_key_accesses
self.time_available_after_reboot = time_available_after_reboot
self.tenant_id = tenant_id
def __repr__(self):
return '<Policy %s >' % self.uuid
def as_dict(self):
keys = map(Key.as_dict, self.keys)
json = {
'uuid': self.uuid,
'name': self.name,
'directory_name': self.directory_name,
'max_key_accesses': self.max_key_accesses,
'time_available_after_reboot': self.time_available_after_reboot,
'tenant_id': self.tenant_id,
'keys': keys
}
return json
class Event(Base):
__tablename__ = 'events'
id = Column(Integer, primary_key=True)
agent_id = Column(String(36))
received_on = Column(DateTime())
severity = Column(String(10))
message = Column(Text())
tenant_id = Column(Integer, ForeignKey('tenants.id'))
tenant = relationship("Tenant", backref=backref('events', order_by=id))
key_id = Column(Integer, ForeignKey('keys.id'))
key = relationship("Key", backref=backref('events', order_by=id))
def __init__(self, tenant_id=None, agent_id=None, received_on=None, severity=None,
message=None, tenant=None, key=None):
self.tenant_id = tenant_id
self.agent_id = agent_id
self.received_on = received_on
self.severity = severity
self.message = message
self.key = key
self.tenant = tenant
def __repr__(self):
return '<Event %s [%s] - %s >' % (self.received_on, self.severity, self.message[:25])
def as_dict(self):
json = {
'id': self.id,
'agent_id': self.agent_id,
'received_on': self.received_on.isoformat(),
'severity': self.severity,
'tenant_id': self.tenant_id,
'key_id': self.key_id,
'message': self.message
}
return json
class Tag(Base):
__tablename__ = 'tags'
id = Column(Integer, primary_key=True)
name = Column(String(128))
value = Column(String(1024))
agent_id = Column(Integer, ForeignKey('agents.id'))
agent = relationship("Agent", backref=backref('tags'))
def __init__(self, name=None, value=None):
self.name = name
self.value = value
def __repr__(self):
return '<Tag %s>' % self.id
def as_dict(self):
json = {
'name': self.name,
'value': self.value
}
return json