def update_application_allocation(application_name, changes):
allocations = {
'application_processes': 'num_procs',
'background_processes': 'celery_procs'
}
try:
application = Application.get_by_name(application_name)
cmd = [
os.path.join(MASTER_SETUID_DIR, 'run_allocate'),
'application_name', application_name
]
for key in changes.keys():
if allocations.get(key):
cmd += [str(allocations[key]), str(changes[key])]
result = run_external_program(cmd)
if external_program_encountered_error(result):
raise exceptions.UpdateAllocationException(result['exit_code'],
application_name)
for key in changes.keys():
if allocations.get(key):
try:
application.report_allocation_change(
Chargable.get_by_component(key), str(changes[key]))
except Exception as e:
log_error_message(e)
except Exception as e:
log_last_exception()
logging.error(e)
return False
return True
def update_application_allocation(application_name, changes):
allocations = {
'application_processes':'num_procs',
'background_processes':'celery_procs'
}
try:
application = Application.get_by_name(application_name)
cmd = [os.path.join(MASTER_SETUID_DIR, 'run_allocate'), 'application_name', application_name]
for key in changes.keys():
if allocations.get(key):
cmd += [str(allocations[key]), str(changes[key])]
result = run_external_program(cmd)
if external_program_encountered_error(result):
raise exceptions.UpdateAllocationException(result['exit_code'], application_name)
for key in changes.keys():
if allocations.get(key):
try:
application.report_allocation_change(Chargable.get_by_component(key), str(changes[key]))
except Exception as e:
log_error_message(e)
except Exception as e:
log_last_exception()
logging.error(e)
return False
return True
def name_available(name):
""" Checks for application name availability. """
if Application.get_by_name(name):
return False
else:
return (re.match('^[A-Za-z][A-Za-z0-9]{4,14}$', name) != None) \
and not (name in RESERVED_APPLICATION_NAMES)
def allocate_application(application_name,
num_procs=None,
proc_num_threads=None,
proc_mem_mb=None,
proc_stack_mb=None,
debug=None,
celery_procs=None):
application_info = Application.get_by_name(application_name)
if num_procs != None:
application_info.num_procs = int(num_procs)
if celery_procs != None:
application_info.celery_procs = int(celery_procs)
# Adjust allocation parameters relevant to each individual process of an
# application: num threads, total memory, stack size, debug
if proc_num_threads:
application_info.proc_num_threads = int(proc_num_threads)
if proc_mem_mb:
application_info.proc_mem_mb = int(proc_mem_mb)
if proc_stack_mb:
application_info.proc_stack_mb = int(proc_stack_mb)
if debug:
application_info.debug = (debug == 'True')
# Save the updated settings
application_info.save()
# Num processes is done differently because it requires
# reallocation of processes to hosts, and must directly
# contact hosts from which a process is removed.
if (num_procs != None) or (celery_procs != None):
allocate_workers(application_info)
else:
# Apply the settings to all deployed workers
call_worker_managers_allocate(application_name)
def name_available(name):
""" Checks for application name availability. """
if Application.get_by_name(name):
return False
else:
return (re.match('^[A-Za-z][A-Za-z0-9]{4,14}$', name) != None) \
and not (name in RESERVED_APPLICATION_NAMES)
def main():
check_trusted_uid(program_name = sys.argv[0])
kwargs = check_and_return_keyword_args(sys.argv, ['application_name'])
application_name = kwargs['application_name']
try:
# Look up the application
application = Application.get_by_name(application_name)
# Disable the application to the outside world
call_proxycache_managers_delete_application(application_name)
# Stop running the application
call_worker_managers_delete_application(application_name)
# Remove the git repository
try:
shutil.rmtree(os.path.join(REPOS_DIR, application_name + ".git"))
except:
log_last_exception()
# Remove the database
db = _mysql.connect(
host = application.db_host,
user = DATABASE_ROOT_USER,
passwd = DATABASE_ROOT_PASSWORD)
try: # try to remove the user if it already exists
db.query(""" DROP USER '%s'@'%%';""" % application_name)
except:
pass
try: # try to drop the database in case it exists
db.query(""" DROP DATABASE %s;""" % application_name)
except:
pass
# Mark the application as deleted
application.mark_deleted()
except:
log_last_exception()
print 'Remove failed for application "%s".' % application_name
sys.exit(1)
def main():
check_trusted_uid(program_name=sys.argv[0])
kwargs = check_and_return_keyword_args(sys.argv, ['application_name'])
application_name = kwargs['application_name']
try:
# Look up the application
application = Application.get_by_name(application_name)
# Disable the application to the outside world
call_proxycache_managers_delete_application(application_name)
# Stop running the application
call_worker_managers_delete_application(application_name)
# Remove the git repository
try:
shutil.rmtree(os.path.join(REPOS_DIR, application_name + ".git"))
except:
log_last_exception()
# Remove the database
db = _mysql.connect(host=application.db_host,
user=DATABASE_ROOT_USER,
passwd=DATABASE_ROOT_PASSWORD)
try: # try to remove the user if it already exists
db.query(""" DROP USER '%s'@'%%';""" % application_name)
except:
pass
try: # try to drop the database in case it exists
db.query(""" DROP DATABASE %s;""" % application_name)
except:
pass
# Mark the application as deleted
application.mark_deleted()
except:
log_last_exception()
print 'Remove failed for application "%s".' % application_name
sys.exit(1)
def allocate_application(application_name, num_procs=None, proc_num_threads=None, proc_mem_mb=None, proc_stack_mb=None, debug=None, celery_procs=None):
application_info = Application.get_by_name(application_name)
if num_procs != None:
application_info.num_procs = int(num_procs)
if celery_procs != None:
application_info.celery_procs = int(celery_procs)
# Adjust allocation parameters relevant to each individual process of an
# application: num threads, total memory, stack size, debug
if proc_num_threads:
application_info.proc_num_threads = int(proc_num_threads)
if proc_mem_mb:
application_info.proc_mem_mb = int(proc_mem_mb)
if proc_stack_mb:
application_info.proc_stack_mb = int(proc_stack_mb)
if debug:
application_info.debug = (debug == 'True')
# Save the updated settings
application_info.save()
# Num processes is done differently because it requires
# reallocation of processes to hosts, and must directly
# contact hosts from which a process is removed.
if (num_procs != None) or (celery_procs != None):
allocate_workers(application_info)
else:
# Apply the settings to all deployed workers
call_worker_managers_allocate(application_name)
def enable_server_cache(application_name):
application = Application.get_by_name(application_name)
application.enable_server_cache()
result = _call_proxycache_manager(application_name)
assert not external_program_encountered_error(result)
def delete_domain_name(application_name, domain_name):
Application.get_by_name(application_name).delete_domain_name(domain_name)
result = _call_proxycache_manager(application_name)
if external_program_encountered_error(result):
raise exceptions.DeleteDomainException(result['exit_code'],
application_name, domain_name)
def disable_server_cache(application_name):
application = Application.get_by_name(application_name)
application.disable_server_cache()
result = _call_proxycache_manager(application_name)
assert not external_program_encountered_error(result)
def delete_domain_name(application_name, domain_name):
Application.get_by_name(application_name).delete_domain_name(domain_name)
result = _call_proxycache_manager(application_name)
if external_program_encountered_error(result):
raise exceptions.DeleteDomainException(result['exit_code'], application_name, domain_name)
def add_application(application_name, email, pubkey):
""" Add the application specified by application_name and a corresponding database, owned by the user with the email address specified. """
# Claim the application name
ActiveApplicationName(name=application_name).save()
user = User.get_by_email(email)
# generate a secure password
db_password = gen_password()
# create the application row
app = Application()
app.name = application_name
app.account = user
app.db_name = application_name
app.db_username = application_name
app.db_password = db_password
app.db_host = DEFAULT_DATABASE_HOST
app.num_procs = 1
app.save()
# generate user and group ids to run as
uids_gid = gen_uids_gid(app.id)
app.setup_uid = uids_gid['setup_uid']
app.web_uid = uids_gid['web_uid']
app.cron_uid = uids_gid['cron_uid']
app.app_gid = uids_gid['app_gid']
app.save()
# enable git push
create_git_repository(application_name)
add_ssh_public_key(user, pubkey)
# allocate a proxycache host for the application -- improve on this later
ProxyCache(application = app, host = DEFAULT_PROXYCACHE_HOST).save()
# assign virtualhost on which to listen for application
VirtualHost(application = app, virtualhost = application_name + '.djangy.com').save()
# allocate the application to a worker host
# Note: this must happen after ProxyCache and VirtualHost are filled in.
allocate_workers(app)
# create the database
db = _mysql.connect(
host = DEFAULT_DATABASE_HOST,
user = DATABASE_ROOT_USER,
passwd = DATABASE_ROOT_PASSWORD)
try: # try to remove the user if it already exists
db.query(""" DROP USER '%s'@'%%';""" % application_name)
except:
pass
db.query("""
CREATE USER '%s'@'%%' IDENTIFIED BY '%s';""" % (application_name, db_password))
try: # try to drop the database in case it exists
db.query(""" DROP DATABASE %s;""" % application_name)
except:
pass
db.query("""
CREATE DATABASE %s;""" % application_name)
db.query("""
USE %s""" % application_name)
db.query("""
GRANT ALL ON %s.* TO '%s'@'%%';""" % (application_name, application_name))
return True
def add_application(application_name, email, pubkey):
""" Add the application specified by application_name and a corresponding database, owned by the user with the email address specified. """
# Claim the application name
ActiveApplicationName(name=application_name).save()
user = User.get_by_email(email)
# generate a secure password
db_password = gen_password()
# create the application row
app = Application()
app.name = application_name
app.account = user
app.db_name = application_name
app.db_username = application_name
app.db_password = db_password
app.db_host = DEFAULT_DATABASE_HOST
app.num_procs = 1
app.save()
# generate user and group ids to run as
uids_gid = gen_uids_gid(app.id)
app.setup_uid = uids_gid['setup_uid']
app.web_uid = uids_gid['web_uid']
app.cron_uid = uids_gid['cron_uid']
app.app_gid = uids_gid['app_gid']
app.save()
# enable git push
create_git_repository(application_name)
add_ssh_public_key(user, pubkey)
# allocate a proxycache host for the application -- improve on this later
ProxyCache(application=app, host=DEFAULT_PROXYCACHE_HOST).save()
# assign virtualhost on which to listen for application
VirtualHost(application=app,
virtualhost=application_name + '.djangy.com').save()
# allocate the application to a worker host
# Note: this must happen after ProxyCache and VirtualHost are filled in.
allocate_workers(app)
# create the database
db = _mysql.connect(host=DEFAULT_DATABASE_HOST,
user=DATABASE_ROOT_USER,
passwd=DATABASE_ROOT_PASSWORD)
try: # try to remove the user if it already exists
db.query(""" DROP USER '%s'@'%%';""" % application_name)
except:
pass
db.query("""
CREATE USER '%s'@'%%' IDENTIFIED BY '%s';""" %
(application_name, db_password))
try: # try to drop the database in case it exists
db.query(""" DROP DATABASE %s;""" % application_name)
except:
pass
db.query("""
CREATE DATABASE %s;""" % application_name)
db.query("""
USE %s""" % application_name)
db.query("""
GRANT ALL ON %s.* TO '%s'@'%%';""" %
(application_name, application_name))
return True
