class Usage(db.Model):
"""Quota and Usage"""
id = id_column()
soft = db.Column(db.BigInteger, nullable=False)
hard = db.Column(db.BigInteger, nullable=False)
usage = db.Column(db.BigInteger, nullable=False)
owner_id = db.Column(None,
db.ForeignKey("owner.id"),
nullable=False,
index=True)
snapshot_id = db.Column(None,
db.ForeignKey("snapshot.id"),
nullable=False,
index=True)
filesystem_id = db.Column(None,
db.ForeignKey("filesystem.id"),
nullable=False,
index=True)
def json(self):
"""Jsonify"""
return {
"owner": self.owner_id,
"filesystem": self.filesystem_id,
"snapshot": self.snapshot_id,
"soft": self.soft,
"hard": self.hard,
"usage": self.usage
}
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 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 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 EntityNameMapping(db.Model):
"""Entity-Name Mapping"""
id = id_column()
entity_id = db.Column(None, db.ForeignKey("entity.id"), nullable=False)
name_id = db.Column(None, db.ForeignKey("entity_name.id"), nullable=False)
start_time = db.Column(db.Integer)
end_time = db.Column(db.Integer)
def json(self):
"""JSON"""
return to_dict(self,
["entity_id", "name_id", "start_time", "end_time"])
class Usage(db.Model):
id = id_column()
bytes = db.Column(db.BigInteger, nullable=False)
containers = db.Column(db.Integer, nullable=False)
objects = db.Column(db.Integer, nullable=False)
quota = db.Column(db.BigInteger)
account_id = db.Column(None, db.ForeignKey("account.id"), nullable=False)
snapshot_id = db.Column(None, db.ForeignKey("snapshot.id"), nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["bytes", "containers", "objects", "quota",
"account_id", "snapshot_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 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 PersonEmail(db.Model):
"""Person-Email Mapping Data Model"""
id = id_column()
person_id = db.Column(None, db.ForeignKey("person.id"))
email_id = db.Column(None, db.ForeignKey("email.id"))
snapshot_id = db.Column(None, db.ForeignKey("snapshot.id"))
def json(self):
"""Jsonify"""
return {
"id": self.id,
"person": self.person_id,
"email": self.email_id,
"snapshot": self.snapshot_id
}
class Membership(db.Model):
"""Organisation Membership Data Model"""
id = id_column()
person_id = db.Column(None, db.ForeignKey("person.id"))
organisation_id = db.Column(None, db.ForeignKey("organisation.id"))
snapshot_id = db.Column(None, db.ForeignKey("snapshot.id"))
def json(self):
"""Jsonify"""
return {
"id": self.id,
"person": self.person_id,
"organisation": self.organisation_id,
"snapshot": self.snapshot_id
}
class PersonUsername(db.Model):
"""Person-Username Mapping Data Model"""
id = id_column()
person_id = db.Column(None, db.ForeignKey("person.id"))
username_id = db.Column(None, db.ForeignKey("username.id"))
snapshot_id = db.Column(None, db.ForeignKey("snapshot.id"))
def json(self):
"""Jsonify"""
return {
"id": self.id,
"person": self.person_id,
"username": self.username_id,
"snapshot": self.snapshot_id
}
class Allocation(db.Model):
"""HPC Job-Host Mapping"""
id = id_column()
job_id = db.Column(None, db.ForeignKey("job.id"))
host_id = db.Column(None, db.ForeignKey("host.id"))
cores = db.Column(db.Integer)
def json(self):
"""Jsonify"""
return {
"id": self.id,
"job": self.job_id,
"host": self.host_id,
"cores": self.cores
}
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 EntityRelationshipMapping(db.Model):
"""Entity-Relationship Mapping"""
id = id_column()
relationship_id = db.Column(None,
db.ForeignKey("entity_relationship.id"),
nullable=False)
entity1_id = db.Column(None, db.ForeignKey("entity.id"), nullable=False)
entity2_id = db.Column(None, db.ForeignKey("entity.id"), nullable=False)
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, [
"relationship_id", "entity1_id", "entity2_id", "weight",
"start_time", "end_time"
])
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 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 FilesystemUsage(db.Model):
"""Filesystem Usage"""
id = id_column()
capacity = db.Column(db.BigInteger, nullable=False)
free = db.Column(db.BigInteger, nullable=False)
live_usage = db.Column(db.BigInteger, nullable=False)
snapshot_usage = db.Column(db.BigInteger, nullable=False)
snapshot_id = db.Column(None,
db.ForeignKey("snapshot.id"),
index=True,
nullable=False)
filesystem_id = db.Column(None,
db.ForeignKey("filesystem.id"),
index=True,
nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["capacity", "free", "live_usage",
"snapshot_usage", "snapshot_id", "filesystem_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 VirtualVolumeUsage(db.Model):
"""Virtual Volume Usage"""
id = id_column()
files = db.Column(db.BigInteger, nullable=False)
quota = db.Column(db.BigInteger, nullable=False)
usage = db.Column(db.BigInteger, nullable=False)
owner_id = db.Column(None, db.ForeignKey("owner.id"))
snapshot_id = db.Column(None,
db.ForeignKey("snapshot.id"),
index=True,
nullable=False)
virtual_volume_id = db.Column(None,
db.ForeignKey("virtual_volume.id"),
index=True,
nullable=False)
def json(self):
"""JSON"""
return to_dict(self, ["files", "quota", "usage", "owner_id", "snapshot_id",
"virtual_volume_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 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 Usage(db.Model):
"""HCP Usage"""
id = id_column()
start_time = db.Column(db.Integer, index=True, nullable=False)
end_time = db.Column(db.Integer, index=True, nullable=False)
ingested_bytes = db.Column(db.BigInteger, nullable=False)
raw_bytes = db.Column(db.BigInteger, nullable=False)
reads = db.Column(db.BigInteger, nullable=False)
writes = db.Column(db.BigInteger, nullable=False)
deletes = db.Column(db.BigInteger, nullable=False)
objects = db.Column(db.BigInteger, nullable=False)
bytes_in = db.Column(db.BigInteger, nullable=False)
bytes_out = db.Column(db.BigInteger, nullable=False)
# FIXME: below four should be optional as the current producer seems not having them
# The HCP official doc checked on 2016/05/10 at:
# http://hcpsdk.readthedocs.io/en/latest/40_mapi/40-3_mapi-chargeback.html
metadata_only_objects = db.Column(db.BigInteger, nullable=False)
metadata_only_bytes = db.Column(db.BigInteger, nullable=False)
tiered_objects = db.Column(db.BigInteger, nullable=False)
tiered_bytes = db.Column(db.BigInteger, nullable=False)
snapshot_id = db.Column(None,
db.ForeignKey("snapshot.id"),
index=True,
nullable=False)
namespace_id = db.Column(None,
db.ForeignKey("namespace.id"),
index=True,
nullable=False)
def json(self):
"""JSON"""
return to_dict(self, [
"start_time", "end_time", "ingested_bytes", "raw_bytes", "reads",
"writes", "deletes", "objects", "bytes_in", "bytes_out",
"metadata_only_objects", "metadata_only_bytes", "tiered_objects",
"tiered_bytes", "snapshot_id", "namespace_id"
])
class Usage(db.Model):
"""Owner/Group Usage"""
id = id_column()
blocks = db.Column(db.BigInteger, nullable=False)
bytes = db.Column(db.BigInteger, nullable=False)
files = db.Column(db.BigInteger, nullable=False)
owner_id = db.Column(None,
db.ForeignKey("owner.id"),
nullable=False,
index=True)
project_id = db.Column(None,
db.ForeignKey("project.id"),
nullable=False,
index=True)
snapshot_id = db.Column(None,
db.ForeignKey("snapshot.id"),
nullable=False,
index=True)
def json(self):
"""JSON"""
return to_dict(self, [
"blocks", "bytes", "files", "owner_id", "project_id", "snapshot_id"
])
class Snapshot(db.Model):
"""Storage Snapshot"""
id = id_column()
ts = db.Column(db.Integer, nullable=False)
usage = db.relationship("Usage", backref="snapshot")
host_id = db.Column(None, db.ForeignKey("host.id"), nullable=False)
message = db.Column(UUID, nullable=False, unique=True)
def json(self):
"""Jsonify"""
return {
"id": self.id,
"ts": self.ts,
"host": self.host_id,
"message": self.message
}
class Entity(db.Model):
"""Entity"""
id = id_column()
type_id = db.Column(None, db.ForeignKey("entity_type.id"), nullable=False)
names = db.relationship("EntityNameMapping", backref="entity")
integers = db.relationship("EntityIntegerAttributeMapping",
backref="entity")
floats = db.relationship("EntityFloatAttributeMapping", backref="entity")
strings = db.relationship("EntityStringAttributeMapping", backref="entity")
relationships1 = db.relationship(
"EntityRelationshipMapping",
foreign_keys="EntityRelationshipMapping.entity1_id",
backref="entity1")
relationships2 = db.relationship(
"EntityRelationshipMapping",
foreign_keys="EntityRelationshipMapping.entity2_id",
backref="entity2")
def json(self):
"""JSON"""
return to_dict(self, ["name", "type_id"])
class Snapshot(db.Model):
"""Storage Snapshot"""
id = id_column()
ts = db.Column(db.Integer, nullable=False)
usage = db.relationship("Usage", backref="snapshot")
bavail = db.Column(db.BigInteger)
bfree = db.Column(db.BigInteger)
blocks = db.Column(db.BigInteger)
bsize = db.Column(db.Integer)
favail = db.Column(db.BigInteger)
ffree = db.Column(db.BigInteger)
files = db.Column(db.BigInteger)
frsize = db.Column(db.Integer)
filesystem_id = db.Column(None,
db.ForeignKey("filesystem.id"),
nullable=False)
def json(self):
"""JSON"""
return to_dict(self, [
"ts", "filesystem_id", "bavail", "bfree", "blocks", "bsize",
"favail", "ffree", "files", "frsize"
])
