def limits_usage(self):
ret = {'running_apps': 0, 'workers': 0}
for arp in ApplicationRunPlan.objects(
application__in=Application.objects(owner=self)):
ret['running_apps'] += 1
ret['workers'] += arp.workers_max
return ret
def obj_create(self, bundle, request=None, **kwargs):
# FIXME handle reference field properly using mongoengine-tastypie
log.debug(_("Going to create new run plan for user "
"'{name}'").format(name=bundle.request.user.username))
app = Application.objects(id=bundle.data['application'],
owner=bundle.request.user).first()
if not app or not app.current_package:
msg = _("Can't create new run plan, app not found, or no packages "
"built yet")
log.warning(msg)
raise exceptions.ValidationError(msg)
kwargs['application'] = app
kwargs['memory_per_worker'] = bundle.request.user.limits[
'memory_per_worker']
kwargs['max_log_size'] = bundle.request.user.limits['max_log_size']
try:
ret = super(MongoEngineResource, self).obj_create(bundle,
request=request,
**kwargs)
app.update(set__run_plan=ret.obj)
return ret
except mongoengine.ValidationError as e:
log.warning(_("Can't create new run plan, invalid data payload: "
"{msg}").format(msg=e.message))
raise exceptions.ValidationError(e.message)
except mongoengine.NotUniqueError:
msg = str(_("Application is already running"))
log.warning(msg)
raise exceptions.ValidationError(msg)
def create_user_list_with_apps(request):
with open(os.path.join(os.path.dirname(__file__), 'meta/redmine.yml'),
'rb') as meta:
metadata = meta.read()
users = []
users_data = {}
users_apps = {}
for i in range(0, 10):
data = {
'login': '******' % i,
'first_name': 'FirstName%d' % i,
'last_name': 'LastName%d' % i,
'email': 'email%d@domain%d.com' % (i, i),
'password': '******' % i,
}
u = User.objects(username=data['login']).first()
if u:
u.delete()
u = User(username=data['login'], first_name=data['first_name'],
last_name=data['last_name'], email=data['email'],
is_superuser=False)
u.set_password(data['password'])
u.save()
users.append(u)
users_data[u.safe_id] = u
app = Application(name='userApp', owner=u, metadata=metadata)
app.save()
users_apps[u] = app
def cleanup():
for us in users:
us.delete()
for ap in users_apps.values():
ap.delete()
request.addfinalizer(cleanup)
request.instance.user_list = users
request.instance.user_list_data = users_data
request.instance.user_list_apps = users_apps
def create_buildable_app(request):
data = {
'name': 'redmine',
'metadata_path': os.path.join(os.path.dirname(__file__),
'meta/mock_app.yml')
}
with open(data['metadata_path'], 'rb') as metadata:
data['metadata'] = metadata.read()
data['metadata_html'] = escape(data['metadata'])
app = Application.objects(name=data['name']).first()
if app:
app.delete()
create_user(request)
app = Application(name=data['name'], owner=request.instance.user,
metadata=data['metadata'])
app.save()
def cleanup():
for domain in app.custom_domains:
domain.delete()
for pkg in app.packages:
pkg.delete()
for flag in app.flags:
flag.delete()
for task in app.tasks:
task.delete()
if app.run_plan:
app.run_plan.delete()
app.delete()
request.addfinalizer(cleanup)
request.instance.app = app
request.instance.app_data = data
def migrate_domains(self):
done = 0
errors = 0
for app in OldApplication.objects():
new_app = Application.objects(id=app.id).first()
for old_domain in app.old_domains:
log.info("Migrating domain: %s / %s" % (app.name, old_domain.name))
domain = ApplicationDomain(
application=new_app,
name=old_domain.name,
date_created=old_domain.date_created,
validated=old_domain.validated,
)
try:
domain.save()
except NotUniqueError:
log.error("Domain %s already exists, it was NOT migrated")
errors += 1
else:
done += 1
app.update(unset__old_domains=True)
if done or errors:
log.info("%d domain(s) migrated, %d error(s)" % (done, errors))
def get_app(self, kwargs):
try:
return Application.objects(
**self.remove_api_resource_names(kwargs)).first()
except ValidationError:
return None
def running_applications(self):
return [arp.application for arp in ApplicationRunPlan.objects(
application__in=Application.objects(owner=self))]
def applications(self):
return Application.objects(owner=self)
