class Domain(db.Model):
id = db.Column(db.Integer, primary_key=True)
slug = db.Column(db.String(255))
uri = db.Column(db.String(255))
htpasswd = db.Column(db.String(128))
ssl_key = db.Column(db.String(128))
upstreams = db.relationship(
'Upstream',
backref='domain',
)
domain_controller_id = db.Column(db.Integer,
db.ForeignKey('domain_controller.id'))
aliases = db.relationship(
'Alias',
backref=db.backref('domain', lazy='joined'),
)
def has_upstream(self, upstreamInfo):
for upstream in self.upstreams:
if upstream == upstreamInfo:
return True
return False
def __str__(self):
return 'Domain {}: {} with controller : {}'\
.format(self.id, self.uri, self.domain_controller.id)
class Host(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
params = db.Column(db.Text)
provider = db.Column(db.String(128))
instances = db.relationship(
'VagrantInstance',
backref='host',
)
def __init__(self, id, name, params, provider):
self.id = id
self.name = name
self.params = params
self.provider = provider
class Team(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
users = db.relationship(
'User',
secondary=teams_users,
backref=db.backref('teams', lazy='select'),
)
permissions_grids = db.relationship(
'TeamPermissionsGrids',
backref='team',
)
def __init__(self, id, name, users=[]):
self.id = id
self.name = name
self.users = users
def get_permissions_grids(self, objectType=None, objectId=None):
permissions_grids = sorted(self.permissions_grids,
key=lambda item: item.objectType)
if objectType is not None:
permissions_grids = filter(
lambda item: item.objectType == objectType, permissions_grids)
if objectId is not None:
permissions_grids = filter(lambda item: item.objectId == objectId,
permissions_grids)
return permissions_grids
class SSL(db.Model):
__tablename__ = 'ssl_keys'
__table_args__ = (UniqueConstraint('name',
'domaincontroller_id',
name='_ssl_dc_uc'), )
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
domaincontroller_id = db.Column(db.Integer,
db.ForeignKey('domain_controller.id'))
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
base_path = db.Column(db.String(1024))
git_address = db.Column(db.String(256))
instances = db.relationship(
'VagrantInstance',
backref='project',
)
def __init__(self,
id,
name,
base_path=None,
git_address=None,
instances=[]):
self.id = id
self.name = name
self.base_path = base_path
self.git_address = git_address
self.instances = instances
class Upstream(db.Model):
id = db.Column(db.Integer, primary_key=True)
ip = db.Column(db.String(32))
port = db.Column(db.Integer)
port_ssl = db.Column(db.Integer)
websocket = db.Column(db.Boolean, default=False)
location = db.Column(db.String(254), default='/')
state = db.Column(db.Enum(*UPSTREAM_STATES))
domain_id = db.Column(db.Integer, db.ForeignKey('domain.id'))
def __eq__(self, other):
if other.id == self.id:
return True
if other.ip == self.ip and other.port == self.port\
and other.port_ssl == self.port_ssl:
return True
return False
def __str__(self):
return 'Upstream {}: {} with state : {}'\
.format(self.id, self.ip, self.state)
class AuditLog(db.Model):
__tablename__ = 'audit_log'
id = db.Column(db.Integer, primary_key=True)
jobid = db.Column(db.Integer)
objectId = db.Column(db.Integer)
objectType = db.Column(db.String(255))
objectName = db.Column(db.String(255))
action = db.Column(db.String(255))
user_id = db.Column(db.String(64))
user_name = db.Column(db.String(255))
start_date = db.Column(db.DateTime, default=datetime.utcnow)
end_date = db.Column(db.DateTime)
summary = db.Column(db.Text)
request_details = db.Column(db.Text)
result = db.Column(db.String(255))
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
from jeto import db
teams_users = db.Table(
'teams_users', db.Column('team_id', db.Integer, db.ForeignKey('team.id')),
db.Column('user_id', db.String(64), db.ForeignKey('user.id')))
class Team(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
users = db.relationship(
'User',
secondary=teams_users,
backref=db.backref('teams', lazy='select'),
)
permissions_grids = db.relationship(
'TeamPermissionsGrids',
backref='team',
)
def __init__(self, id, name, users=[]):
self.id = id
self.name = name
self.users = users
def get_permissions_grids(self, objectType=None, objectId=None):
permissions_grids = sorted(self.permissions_grids,
key=lambda item: item.objectType)
if objectType is not None:
class User(db.Model):
id = db.Column(db.String(64), primary_key=True)
name = db.Column(db.String(64))
email = db.Column(db.String(128), unique=True)
given_name = db.Column(db.String(128))
family_name = db.Column(db.String(128))
picture = db.Column(db.String(256))
role = db.Column(db.String(32), default=ROLE_DEV)
last_login = db.Column(db.DateTime)
permissions_grids = db.relationship(
'UserPermissionsGrids',
backref='user',
)
def __init__(self,
id,
name,
email,
given_name,
family_name,
picture,
role=ROLE_DEV,
last_login=None,
permissions_grids=None):
self.id = id
self.name = name
self.email = email
self.given_name = given_name
self.family_name = family_name
self.picture = picture
self.role = role
self.last_login = last_login
def __unicode__(self):
return 'User {} : {}, Role :{}'.format(self.id, self.name, self.role)
def __str__(self):
return self.__unicode__()
def get_id(self):
return unicode(self.id)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return True
def is_admin(self):
if self.role == ROLE_ADMIN:
return True
return False
def get_permissions_grids(self):
return sorted(self.permissions_grids, key=lambda item: item.objectType)
def has_permission(self, permission_type, objectId):
if objectId is None:
return True
admin = Permission(RoleNeed(ROLE_ADMIN))
if isinstance(permission_type, tuple):
for permission_type_item in permission_type:
permission = permission_type_item(unicode(objectId))
if permission.can() or admin.can():
return True
else:
permission = permission_type(unicode(objectId))
if permission.can() or admin.can():
return True
return False
class VagrantInstance(db.Model):
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(256))
name = db.Column(db.String(128))
environment = db.Column(db.String(128))
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
host_id = db.Column(db.Integer, db.ForeignKey('host.id'))
git_reference = db.Column(db.String(128))
archive_url = db.Column(db.String(256))
def __init__(self,
id,
path,
name,
environment,
git_reference=None,
archive_url=None):
self.id = id
self.path = path
self.name = name
self.environment = environment
self.git_reference = git_reference
self.archive_url = archive_url
# self.init_on_load()
def __unicode__(self):
return '{} : {} : {}'.format(self.name, self._status,
self._generatePath())
def __str__(self):
return self.__unicode__()
def post(self):
return self
@orm.reconstructor
def init_on_load(self):
# self.status = self._status()
# if 'running' in self.status:
# self.ip = self._ip()
pass
def _status(self):
path = self._generatePath()
results = self._submit_job(
'status',
path=path,
host=self.host,
environment=self.environment,
)
machines, jeto_infos, scripts, date_commit = self._parse_status(
results)
machinesFormatted = []
for machine, value in machines.iteritems():
app.logger.debug(value)
if 'state-human-short' in value:
val = value['state-human-short']
elif 'error-exit' in value:
val = value['error-exit'] # Vagrant is not ready yet
else:
val = 'Something went wrong'
machinesFormatted.append({
'name': machine,
'status': val,
# 'ip': value['ip']
})
return machinesFormatted, jeto_infos, scripts, date_commit
def _parse_status(self, results):
results = json.loads(results)
date_commit = results.get('date_commit', None)
jeto_infos = results.get('jeto_infos')
scripts = None
if jeto_infos:
scripts = jeto_infos.get('scripts', None)
if scripts:
del jeto_infos['scripts']
results = results.get('vagrant', 'Something went wrong\n')
machines = {}
if results is not None:
results = results.split('\n')
# Vagrant returns 5 lines, the first one being #BEGIN# and
# the last line being #END#, we want everything else
results = results[1:-3]
formatted = []
item = []
for result in results:
# Clean up
result = result.replace('\\', ' ')
if ',' in result and len(item) > 0:
formatted.append(item)
item = []
# Each field is comma seperated
if ',' in result:
item = result.split(',')
# !(VAGRANT_COMMA) is a real comma, but escaped by vagrant
item[-1] = item[-1].replace('%!(VAGRANT_COMMA)', ',')
formatted.append(item)
else:
# !(VAGRANT_COMMA) is a real comma, but escaped by vagrant
result = result.replace('%!(VAGRANT_COMMA)', ',')
if len(item):
item[-1] = item[-1] + result
withoutTimestamp = []
for item in formatted:
withoutTimestamp.append(item[1:])
for item in withoutTimestamp:
if item[0] not in machines:
machines[item[0]] = {}
if len(item) >= 3:
machines[item[0]][item[1]] = item[2]
return (machines, jeto_infos, scripts, date_commit)
def _ip(self, machineName):
results = self._submit_job(
'ip',
path=self._generatePath(),
machineName=machineName,
host=self.host,
environment=self.environment,
)
return results
def _generatePath(self):
path = self.path
if self.git_reference:
return PROJECT_BASEPATH + \
slugify.slugify(self.project.name) +\
'/' + \
slugify.slugify(self.name) + \
'/' + \
self.git_reference
elif self.archive_url:
return PROJECT_BASEPATH + \
slugify.slugify(self.project.name) +\
'/' + \
slugify.slugify(self.name) + \
'/' + \
'tgz'
return path
def start(self, machineName='default'):
results = self._submit_job(
'run',
machineName=machineName,
path=self._generatePath(),
environment=self.environment,
host=self.host,
)
return results
def provision(self, machineName):
results = self._submit_job(
'provision',
path=self._generatePath(),
environment=self.environment,
machineName=machineName,
host=self.host,
)
return results
def stop(self, machineName):
results = self._submit_job(
'stop',
path=self._generatePath(),
environment=self.environment,
machineName=machineName,
host=self.host,
)
return results
def delete(self):
self._submit_job(
'destroy',
path=self._generatePath(),
environment=self.environment,
host=self.host,
)
db.session.delete(self)
db.session.commit()
def extract(self):
results = self._submit_job(
'extract',
path=self._generatePath(),
archive_url=self.archive_url,
host=self.host,
)
return results
def rsync(self):
results = self._submit_job(
'rsync',
path=self._generatePath(),
host=self.host,
)
return results
def sync(self):
results = self._submit_job(
'sync',
path=self._generatePath(),
git_reference=self.git_reference,
)
return results
def clone(self):
results = self._submit_job(
'clone',
path=self._generatePath(),
git_address=self.project.git_address,
git_reference=self.git_reference,
host=self.host,
)
return results
def runScript(self, script, machineName='default'):
results = self._submit_job(
'run_script',
path=self._generatePath(),
host=self.host,
environment=self.environment,
machineName=machineName,
script=script,
)
return results
def _submit_job(self, action, **kwargs):
with Connection():
queue = Queue('high', connection=redis_conn)
action = 'worker.{}'.format(action)
job = queue.enqueue_call(
func=action,
timeout=1200,
job_id=str(time.time()),
kwargs=kwargs,
)
if action != 'worker.status':
redis_conn.hmset('jobs:{}'.format(self.id),
{job.id: str(current_user.id)})
if is_async() is False:
while job.result is None:
time.sleep(0.5)
else:
return job.id
return job.result
class Alias(db.Model):
id = db.Column(db.Integer, primary_key=True)
uri = db.Column(db.String(255))
domain_id = db.Column(db.Integer, db.ForeignKey('domain.id'))
class APIKey(db.Model):
__tablename__ = 'api_key'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
comment = db.Column(db.String(255))
user_id = db.Column(db.String(64), db.ForeignKey('user.id'))
class TeamPermissionsGrids(db.Model):
id = db.Column(db.Integer, primary_key=True)
objectId = db.Column(db.Integer)
objectType = db.Column(db.String(64))
action = db.Column(db.String(64))
team_id = db.Column(db.Integer, db.ForeignKey('team.id'))
class UserPermissionsGrids(db.Model):
id = db.Column(db.Integer, primary_key=True)
objectId = db.Column(db.Integer)
objectType = db.Column(db.String(64))
action = db.Column(db.String(64))
user_id = db.Column(db.String(64), db.ForeignKey('user.id'))
