def jobs(self, *args, **kwargs):
if not args:
jobs = []
query = Job.visible(request)
jobs = [
t.serialize(
skip=['id', 'key', 'owner_id', 'deployment_id', 'uid'],
rel=[('owner.username', 'owner'),
('params', 'params', _try_load),
('deployment', 'automation', lambda d: d.name)])
for t in query.all()
]
return O._anon(jobs=sorted(jobs, key=lambda t: t['name'].lower()),
quota=dict(allowed=request.user.tier.cron_jobs))
else:
job_name = args[0]
try:
job = Job.visible(request).filter(Job.name == job_name).one()
return O.job(**job.serialize(
skip=['id', 'key', 'owner_id', 'deployment_id', 'uid'],
rel=[('owner.username',
'owner'), ('params', 'params', _try_load),
('deployment', 'automation', lambda d: d.name)]))
except exc.NoResultFound, ex:
LOG.error(ex)
request.db.rollback()
return O.error(msg="Job %s not found" % job_name)
def deployments(self, name=None, **kwargs):
skip = ['id', 'owner_id']
def _encode(s):
try:
return json.loads(s)
except ValueError:
return {}
if name:
depl = Deployment.my(request).filter(
Deployment.name == name).first()
if depl:
return O.deployment(**depl.serialize(
skip=skip,
rel=[('content', 'content',
lambda p: _encode(p))]))
else:
return O.error(msg="Cannot find deployment '%s'" % name)
else:
depl = sorted([d.serialize(skip=skip)
for d in Deployment.my(request).all()],
key=lambda d: d['name'])
return O._anon(deployments=depl,
quota=dict(allowed=request.user.tier.deployments))
return O.none()
def profiles(self, name=None, *args):
def shares(p):
return [sh.serialize(
skip=['id', 'profile_id', 'password']) for sh in p]
def nodes(ns):
return [n.name for n in ns]
def shares_details(p):
return [sh.serialize(
skip=['id', 'profile_id', 'password'],
rel=[('shared_nodes', 'nodes', nodes)]
) for sh in p]
if name:
prof = CloudProfile.my(request).filter(
CloudProfile.name == name).first()
return O.profile(prof.serialize(
skip=['id', 'owner_id', 'share_id', 'password', 'arguments'],
rel=[('shares', 'shares', shares_details)]))
else:
profs = [p.serialize(
skip=['id', 'owner_id', 'share_id', 'password', 'arguments'],
rel=[('shares', 'shares', shares)])
for p in CloudProfile.my(request).all()]
return O._anon(
profiles=profs,
quota=dict(allowed=request.user.tier.cloud_profiles))
def users(self, name=None, *args, **kwargs):
def modifier(roles):
return [
dict(as_user=role.as_user, servers=role.servers)
for role in roles
]
if name:
user = User.visible(request).filter(User.username == name).first()
return O.user(
user.serialize(skip=['id', 'org_id', 'password'],
rel=[('groups.name', 'groups')]))
else:
users = [
u.serialize(skip=['id', 'org_id', 'password'],
rel=[('groups.name', 'groups')]) for u in
User.visible(request).options(joinedload(User.groups)).all()
]
groups = [
u.serialize(skip=['id', 'org_id'],
rel=[
('roles', 'roles', modifier),
('users', 'users',
lambda us: [u.username for u in us]),
])
for u in Group.visible(request).options(joinedload(
Group.users)).options(joinedload(Group.roles)).all()
]
return O._anon(users=users,
groups=groups,
quota=dict(users=request.user.tier.users,
groups=request.user.tier.groups))
def repo(self, *args, **kwargs):
if not args:
repos = Repository.visible(request).all()
tier = request.user.tier
repositories = sorted([r.serialize(
skip=['id', 'org_id', 'owner_id', 'linked_id'],
rel=[('owner.username', 'owner')],
editable=lambda r: r.editable(request))
for r in repos],
key=lambda l: l['name'])
return O._anon(repositories=repositories,
quota=dict(total=tier.total_repos,
user=tier.total_repos,
external=tier.external_repos == "True"))
else:
repo_name = args[0]
repo = Repository.visible(request).filter(
Repository.name == repo_name).first()
def get_creds(repo):
parents = [p for p in repo.parents
if p.org.name == request.user.org]
if parents:
return dict(auth_user=parents[0].credentials.auth_user)
else:
return {}
if repo.type == 'cloudrunner':
return O.repository(repo.serialize(
skip=['id', 'org_id', 'owner_id', 'linked_id'],
rel=[('owner.username', 'owner')],
editable=lambda r: r.editable(request)))
else:
if repo.editable(request):
return O.repository(repo.serialize(
skip=['id', 'org_id', 'owner_id', 'linked_id'],
rel=[('owner.username', 'owner'),
('linked', 'credentials', get_creds),
# ('credentials.auth_user', 'key'),
# ('credentials.auth_pass', 'secret'),
# ('credentials.auth_args', 'args')
],
editable=lambda r: True))
else:
return O.repository(**repo.serialize(
skip=['id', 'org_id', 'owner_id', 'linked_id'],
rel=[('owner.username', 'owner')],
editable=lambda r: True))
def groups(self, name=None, *args):
def modifier(roles):
return [dict(as_user=role.as_user, servers=role.servers)
for role in roles]
if name:
group = Group.visible(request).filter(Group.name == name).first()
return O.group(group.serialize(
skip=['id', 'org_id'],
rel=[('roles', 'roles', modifier)]))
else:
groups = [u.serialize(
skip=['id', 'org_id'],
rel=[('roles', 'roles', modifier)])
for u in Group.visible(request).all()]
return O._anon(groups=groups,
quota=dict(allowed=request.user.tier.groups))
def shares(self, profile, *args, **kwargs):
def nodes(p):
return []
if args:
sh = CloudShare.my(
request, profile).filter(CloudShare.name == args[0]).first()
return O.share(
sh.serialize(skip=['id', 'profile_id'],
rel=[('shared_nodes', 'nodes', nodes)]))
else:
profs = [
p.serialize(skip=['id', 'profile_id', 'password'],
rel=[('shared_nodes', 'nodes', nodes)])
for p in CloudShare.my(request, profile).all()
]
return O._anon(shares=profs)
def shares(self, profile, *args, **kwargs):
def nodes(p):
return []
if args:
sh = CloudShare.my(request, profile).filter(
CloudShare.name == args[0]).first()
return O.share(sh.serialize(
skip=['id', 'profile_id'],
rel=[('shared_nodes', 'nodes', nodes)]))
else:
profs = [p.serialize(
skip=['id', 'profile_id', 'password'],
rel=[('shared_nodes', 'nodes', nodes)])
for p in CloudShare.my(request, profile).all()]
return O._anon(shares=profs)
def groups(self, name=None, *args):
def modifier(roles):
return [
dict(as_user=role.as_user, servers=role.servers)
for role in roles
]
if name:
group = Group.visible(request).filter(Group.name == name).first()
return O.group(
group.serialize(skip=['id', 'org_id'],
rel=[('roles', 'roles', modifier)]))
else:
groups = [
u.serialize(skip=['id', 'org_id'],
rel=[('roles', 'roles', modifier)])
for u in Group.visible(request).all()
]
return O._anon(groups=groups,
quota=dict(allowed=request.user.tier.groups))
def nodes(self, name=None, **kwargs):
if name:
node = Node.visible(request).filter(Node.name == name).first()
return O.node(node.serialize(skip=['id', 'org_id']))
else:
nodes = sorted(Node.visible(request).all(), key=lambda n: n.name)
groups = sorted(NodeGroup.visible(request).all(),
key=lambda g: g.name)
return O._anon(nodes=[
n.serialize(skip=['id', 'org_id'],
rel=[('meta', 'meta', lambda n: json.loads(n)
if n else {}),
('tags', 'tags',
lambda lst: [x.value for x in lst]
if lst else [])]) for n in nodes
],
groups=[
g.serialize(skip=['id', 'org_id'],
rel=[('nodes', 'members',
_serialize)]) for g in groups
],
quota=dict(allowed=request.user.tier.nodes))
def profiles(self, name=None, *args):
def shares(p):
return [
sh.serialize(skip=['id', 'profile_id', 'password']) for sh in p
]
def nodes(ns):
return [n.name for n in ns]
def shares_details(p):
return [
sh.serialize(skip=['id', 'profile_id', 'password'],
rel=[('shared_nodes', 'nodes', nodes)])
for sh in p
]
if name:
prof = CloudProfile.my(request).filter(
CloudProfile.name == name).first()
return O.profile(
prof.serialize(skip=[
'id', 'owner_id', 'share_id', 'password', 'arguments'
],
rel=[('shares', 'shares', shares_details)]))
else:
profs = [
p.serialize(skip=[
'id', 'owner_id', 'share_id', 'password', 'arguments'
],
rel=[('shares', 'shares', shares)])
for p in CloudProfile.my(request).all()
]
return O._anon(
profiles=profs,
quota=dict(allowed=request.user.tier.cloud_profiles))
def apikeys(self, *args):
keys = request.db.query(ApiKey).join(User).filter(
User.id == request.user.id).all()
return O._anon(
keys=[k.serialize(skip=['id', 'user_id']) for k in keys],
quota=dict(allowed=request.user.tier.api_keys))
def execute(self, user_id, deployment, revision=None, **kwargs):
LOG.info("Starting %s " % deployment.name)
self._prepare_db(user_id=user_id, **kwargs)
self.db.begin(subtransactions=True)
remote_tasks = []
local_runs = []
# batch_id = None
ctx = self.get_user_ctx(user_id)
try:
tags = kwargs.get('tags', [])
if tags:
tags = sorted(re.split(r'[\s,;]', tags))
timeout = kwargs.get('timeout', 0)
env = kwargs.get('env') or {}
if env and not isinstance(env, dict):
kwargs['env'] = env = json.loads(env)
if deployment.env:
deployment.env.update(env)
env = deployment.env
group = TaskGroup(deployment=deployment.object)
self.db.add(group)
LOG.info("Execute %s by %s" % (deployment.name, ctx.user.name))
task = Task(status=LOG_STATUS.Running,
group=group,
owner_id=ctx.user.id,
script_content=revision,
exec_start=timestamp(),
timeout=timeout,
exit_code=-99,
script_name=deployment.name)
self.db.add(task)
for tag in tags:
task.tags.append(Tag(name=tag))
for i, step in enumerate(deployment.steps):
targets = step.targets
remote_task = dict(attachments=step.atts,
body=step.body,
lang=step.lang,
targets=targets,
timeout=step.timeout,
env=step.env or {})
flat_targets = []
for t in targets:
if isinstance(t, dict):
flat_targets.append("%(provider)s::%(name)s" % t)
else:
flat_targets.append(t)
run = Run(task=task,
lang=step.lang,
exec_start=timestamp(),
exec_user_id=ctx.user.id,
target=" ".join(flat_targets),
exit_code=-99,
timeout=step.timeout,
step_index=i,
full_script=step.body)
if i == 0:
run.env_in = json.dumps(env)
self.db.add(task)
remote_tasks.append(remote_task)
local_runs.append(run)
self.db.add(run)
self.db.commit()
if not remote_tasks:
return
self.db.begin(subtransactions=True)
msg = Master(ctx.user.name).command(
'dispatch',
task_id=group.id,
tasks=remote_tasks,
roles=self._roles(ctx),
disabled_nodes=self.disabled_nodes(ctx),
includes=[],
attachments=[],
env=env)
if not isinstance(msg, Queued):
return
LOG.info("TASK UUIDs: %s" % msg.task_ids)
for i, job_id in enumerate(msg.task_ids):
# Update
run = local_runs[i]
run.uuid = job_id
if msg.task_ids:
self.db.commit()
return O._anon(task_uid=task.uuid,
group=task.taskgroup_id,
parent_uid=task.uuid)
except Exception, ex:
LOG.exception(ex)
self.db.rollback()
