class Job(db.Model):
"""HPC Job"""
id = id_column()
job_id = db.Column(db.String(64), unique=True, nullable=False)
owner_id = db.Column(None, db.ForeignKey("owner.id"))
queue_id = db.Column(None, db.ForeignKey("queue.id"))
name = db.Column(db.String(256))
start = db.Column(db.Integer)
end = db.Column(db.Integer)
cores = db.Column(db.Integer)
cpu_seconds = db.Column(db.Integer)
allocations = db.relationship("Allocation", backref="job")
def json(self):
"""Jsonify"""
return {
"id": self.id,
"job_id": self.job_id,
"name": self.name,
"owner": self.owner_id,
"queue": self.queue_id,
"start": self.start,
"end": self.end,
"cores": self.cores,
"cpu_seconds": self.cpu_seconds
}
class VolumeSnapshot(db.Model):
id = id_column()
openstack_id = db.Column(db.String(64), nullable=False, unique=True)
size = db.Column(db.Integer, nullable=False)
name = db.Column(db.String(128))
description = db.Column(db.String(512))
source = db.Column(db.String(64), nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["openstack_id", "name", "size", "description",
"source"])
class Volume(db.Model):
id = id_column()
openstack_id = db.Column(db.String(64), nullable=False, unique=True)
owner = db.Column(db.String(64), nullable=False)
tenant = db.Column(db.String(64), nullable=False)
availability_zone_id = db.Column(None,
db.ForeignKey("availability_zone.id"))
attachments = db.relationship("VolumeAttachment", backref="volume")
states = db.relationship("VolumeState", backref="volume")
def json(self):
"""JSON"""
return to_dict(self, ["openstack_id", "availability_zone_id", "owner",
"tenant"])
class VolumeStatus(db.Model):
id = id_column()
name = db.Column(db.String(64), nullable=False, unique=True)
states = db.relationship("VolumeState", backref="status")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class AvailabilityZone(db.Model):
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
volumes = db.relationship("Volume", backref="availability_zone")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class Account(db.Model):
id = id_column()
openstack_id = db.Column(db.String(64), unique=True, nullable=False)
account_snapshots = db.relationship("Usage", backref="account")
def json(self):
"""JSON"""
return to_dict(self, ["openstack_id"])
class Owner(db.Model):
"""Storage Owner"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
usage = db.relationship("Usage", backref="owner")
def json(self):
"""Jsonify"""
return {"id": self.id, "name": self.name}
class Host(db.Model):
"""HPC Host"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
allocations = db.relationship("Allocation", backref="host")
def json(self):
"""Jsonify"""
return {"id": self.id, "name": self.name}
class Host(db.Model):
"""Storage Host"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
filesystems = db.relationship("Filesystem", backref="host")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class Email(db.Model):
"""Email Data Model"""
id = id_column()
address = db.Column(db.String(128), index=True, nullable=False)
person = db.relationship("PersonEmail", backref="email")
def json(self):
"""Jsonify"""
return {"id": self.id, "address": self.address}
class Project(db.Model):
"""Storage Group/Project"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
usage = db.relationship("Usage", backref="project")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class Queue(db.Model):
"""HPC Queue"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
jobs = db.relationship("Job", backref="queue")
def json(self):
"""Jsonify"""
return {"id": self.id, "name": self.name}
class EntityName(db.Model):
"""Entity Name"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
mappings = db.relationship("EntityNameMapping", backref="name")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class Username(db.Model):
"""Username Data Model"""
id = id_column()
username = db.Column(db.String(64), index=True, nullable=False)
person = db.relationship("PersonUsername", backref="username")
def json(self):
"""Jsonify"""
return {"id": self.id, "username": self.username}
class Person(db.Model):
"""Person Data Model"""
id = id_column()
insightly_id = db.Column(db.Integer, index=True, nullable=False)
first_name = db.Column(db.String(128), index=True)
last_name = db.Column(db.String(128), index=True)
email = db.relationship("PersonEmail", backref="person")
username = db.relationship("PersonUsername", backref="person")
membership = db.relationship("Membership", backref="person")
def json(self):
"""Jsonify"""
return {
"id": self.id,
"insightly_id": self.insightly_id,
"first_name": self.first_name,
"last_name": self.last_name
}
class Tenant(db.Model):
"""HCP Tenant"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
namespaces = db.relationship("Namespace", backref="tenant")
allocation_id = db.Column(None, db.ForeignKey("allocation.id"))
def json(self):
"""JSON"""
return to_dict(self, ["name", "allocation_id"])
class Host(db.Model):
"""Storage Host"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
snapshots = db.relationship("Snapshot", backref="host")
filesystems = db.relationship("Filesystem", backref="host")
def json(self):
"""Jsonify"""
return {"id": self.id, "name": self.name}
class Filesystem(db.Model):
"""Filesystem"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
snapshots = db.relationship("Snapshot", backref="filesystem")
host_id = db.Column(None, db.ForeignKey("host.id"), nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["name", "host_id"])
class Filesystem(db.Model):
"""Filesystem"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
virtual_volumes = db.relationship("VirtualVolume", backref="filesystem")
usage = db.relationship("FilesystemUsage", backref="filesystem")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class Owner(db.Model):
"""Storage Account/Owner"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
virtual_volume_usage = db.relationship("VirtualVolumeUsage",
backref="owner")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
class EntityRelationship(db.Model):
"""Entity Relationship"""
id = id_column()
valid1_id = db.Column(None, db.ForeignKey("entity_type.id"))
valid2_id = db.Column(None, db.ForeignKey("entity_type.id"))
name = db.Column(db.String(64), unique=True, nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["name", "valid1_id", "valid2_id"])
class EntityStringAttribute(db.Model):
"""Entity Attribute"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
type_id = db.Column(None, db.ForeignKey("entity_type.id"), nullable=False)
mappings = db.relationship("EntityStringAttributeMapping",
backref="attribute")
def json(self):
"""JSON"""
return to_dict(self, ["name", "type_id"])
class VolumeAttachment(db.Model):
id = id_column()
instance = db.Column(db.String(64), nullable=False)
volume_id = db.Column(None, db.ForeignKey("volume.id"), primary_key=True)
snapshot_id = db.Column(None,
db.ForeignKey("snapshot.id"),
primary_key=True)
def json(self):
"""JSON"""
return to_dict(self, ["instance", "volume_id", "snapshot_id"])
class Filesystem(db.Model):
"""Filesystem"""
id = id_column()
name = db.Column(db.String(256), nullable=False)
usage = db.relationship("Usage", backref="filesystem")
host_id = db.Column(None, db.ForeignKey("host.id"), nullable=False)
__table_args__ = (UniqueConstraint("host_id", "name"), )
def json(self):
"""Jsonify"""
return {"id": self.id, "name": self.name, "host": self.host_id}
class VirtualVolume(db.Model):
"""Virtual Volume"""
id = id_column()
name = db.Column(db.String(256), unique=True, nullable=False)
usage = db.relationship("VirtualVolumeUsage", backref="virtual_volume")
filesystem_id = db.Column(None,
db.ForeignKey("filesystem.id"),
index=True,
nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["name", "filesystem_id"])
class Namespace(db.Model):
"""HCP Namespace"""
id = id_column()
name = db.Column(db.String(256), nullable=False)
usage = db.relationship("Usage", backref="namespace")
tenant_id = db.Column(None,
db.ForeignKey("tenant.id"),
index=True,
nullable=False)
allocation_id = db.Column(None, db.ForeignKey("allocation.id"))
def json(self):
"""JSON"""
return to_dict(self, ["name", "tenant_id", "allocation_id"])
class VolumeState(db.Model):
id = id_column()
name = db.Column(db.String(128))
size = db.Column(db.Integer, nullable=False, index=True)
snapshot_id = db.Column(None, db.ForeignKey("snapshot.id"), nullable=False)
volume_id = db.Column(None, db.ForeignKey("volume.id"), nullable=False)
status_id = db.Column(None,
db.ForeignKey("volume_status.id"),
nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["name", "size", "snapshot_id", "volume_id",
"status_id"])
class Organisation(db.Model):
"""Organisation Data Model"""
id = id_column()
insightly_id = db.Column(db.Integer, index=True, nullable=False)
name = db.Column(db.String(256), index=True)
membership = db.relationship("Membership", backref="organisation")
def json(self):
"""Jsonify"""
return {
"id": self.id,
"insightly_id": self.insightly_id,
"name": self.name
}
class EntityStringAttributeMapping(db.Model):
"""Entity-Attribute Mapping"""
id = id_column()
entity_id = db.Column(None, db.ForeignKey("entity.id"), nullable=False)
attribute_id = db.Column(None,
db.ForeignKey("entity_string_attribute.id"),
nullable=False)
value = db.Column(db.String(2048))
weight = db.Column(db.Integer, default=1)
start_time = db.Column(db.Integer)
end_time = db.Column(db.Integer)
def json(self):
"""JSON"""
return to_dict(self, [
"entity_id", "attribute_id", "value", "weight", "start_time",
"end_time"
])
class EntityType(db.Model):
"""Entity Type"""
id = id_column()
name = db.Column(db.String(64), unique=True, nullable=False)
entities = db.relationship("Entity", backref="type")
relationships1 = db.relationship(
"EntityRelationship",
foreign_keys="EntityRelationship.valid1_id",
backref="valid1")
relationships2 = db.relationship(
"EntityRelationship",
foreign_keys="EntityRelationship.valid2_id",
backref="valid2")
integer_attributes = db.relationship("EntityIntegerAttribute",
backref="type")
float_attributes = db.relationship("EntityFloatAttribute", backref="type")
string_attributes = db.relationship("EntityStringAttribute",
backref="type")
def json(self):
"""JSON"""
return to_dict(self, ["name"])
