def copy_app_to_host(cls, app_location, keyname, is_verbose):
"""Copies the given application to a machine running the Login service within
an AppScale deployment.
Args:
app_location: The location on the local filesystem where the application
can be found.
keyname: The name of the SSH keypair that uniquely identifies this
AppScale deployment.
is_verbose: A bool that indicates if we should print the commands we exec
to copy the app to the remote host to stdout.
Returns:
A str corresponding to the location on the remote filesystem where the
application was copied to.
"""
AppScaleLogger.log("Creating remote directory to copy app into")
app_id = AppEngineHelper.get_app_id_from_app_config(app_location)
remote_app_dir = "/var/apps/{0}/app".format(app_id)
cls.ssh(LocalState.get_login_host(keyname), keyname,
'mkdir -p {0}'.format(remote_app_dir), is_verbose)
AppScaleLogger.log("Tarring application")
rand = str(uuid.uuid4()).replace('-', '')[:8]
local_tarred_app = "/tmp/appscale-app-{0}-{1}.tar.gz".format(app_id, rand)
LocalState.shell("cd {0} && tar -czf {1} *".format(app_location,
local_tarred_app), is_verbose)
AppScaleLogger.log("Copying over application")
remote_app_tar = "{0}/{1}.tar.gz".format(remote_app_dir, app_id)
cls.scp(LocalState.get_login_host(keyname), keyname, local_tarred_app,
remote_app_tar, is_verbose)
os.remove(local_tarred_app)
return remote_app_tar
def create_user_accounts(cls, email, password, public_ip, keyname):
"""Registers two new user accounts with the UserAppServer.
One account is the standard account that users log in with (via their
e-mail address. The other is their XMPP account, so that they can log into
any jabber-compatible service and send XMPP messages to their application
(and receive them).
Args:
email: The e-mail address that should be registered for the user's
standard account.
password: The password that should be used for both the standard and XMPP
accounts.
public_ip: The location where the AppController can be found.
keyname: The name of the SSH keypair used for this AppScale deployment.
"""
acc = AppControllerClient(public_ip, LocalState.get_secret_key(keyname))
is_new_user = False
# first, create the standard account
encrypted_pass = LocalState.encrypt_password(email, password)
if acc.does_user_exist(email):
AppScaleLogger.log("User {0} already exists, so not creating it again.".
format(email))
else:
acc.create_user(email, encrypted_pass)
is_new_user = True
# next, create the XMPP account. if the user's e-mail is [email protected], then that
# means their XMPP account name is a@login_ip
username_regex = re.compile('\A(.*)@')
username = username_regex.match(email).groups()[0]
xmpp_user = "******".format(username, LocalState.get_login_host(keyname))
xmpp_pass = LocalState.encrypt_password(xmpp_user, password)
is_xmpp_user_exist = acc.does_user_exist(xmpp_user)
if is_xmpp_user_exist and is_new_user:
AppScaleLogger.log("XMPP User {0} conflict!".format(xmpp_user))
generated_xmpp_username = LocalState.generate_xmpp_username(username)
xmpp_user = "******".format(generated_xmpp_username, LocalState.get_login_host(keyname))
xmpp_pass = LocalState.encrypt_password(xmpp_user, password)
acc.create_user(xmpp_user, xmpp_pass)
elif is_xmpp_user_exist and not is_new_user:
AppScaleLogger.log("XMPP User {0} already exists, so not creating it again.".format(xmpp_user))
else:
acc.create_user(xmpp_user, xmpp_pass)
AppScaleLogger.log("Your XMPP username is {0}".format(xmpp_user))
def remove_app(cls, options):
"""Instructs AppScale to no longer host the named application.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
if not options.confirm:
response = raw_input("Are you sure you want to remove this " + \
"application? (Y/N) ")
if response not in ['y', 'yes', 'Y', 'YES']:
raise AppScaleException("Cancelled application removal.")
login_host = LocalState.get_login_host(options.keyname)
acc = AppControllerClient(login_host, LocalState.get_secret_key(
options.keyname))
userappserver_host = acc.get_uaserver_host(options.verbose)
userappclient = UserAppClient(userappserver_host, LocalState.get_secret_key(
options.keyname))
if not userappclient.does_app_exist(options.appname):
raise AppScaleException("The given application is not currently running.")
acc.stop_app(options.appname)
AppScaleLogger.log("Please wait for your app to shut down.")
while True:
if acc.is_app_running(options.appname):
time.sleep(cls.SLEEP_TIME)
else:
break
AppScaleLogger.success("Done shutting down {0}".format(options.appname))
def add_instances(cls, options):
"""Adds additional machines to an AppScale deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
if 'master' in options.ips.keys():
raise BadConfigurationException("Cannot add master nodes to an " + \
"already running AppScale deployment.")
# Skip checking for -n (replication) because we don't allow the user
# to specify it here (only allowed in run-instances).
additional_nodes_layout = NodeLayout(options)
# In virtualized cluster deployments, we need to make sure that the user
# has already set up SSH keys.
if LocalState.get_from_yaml(options.keyname, 'infrastructure') == "xen":
for ip in options.ips.values():
# throws a ShellException if the SSH key doesn't work
RemoteHelper.ssh(ip, options.keyname, "ls", options.verbose)
# Finally, find an AppController and send it a message to add
# the given nodes with the new roles.
AppScaleLogger.log("Sending request to add instances")
login_ip = LocalState.get_login_host(options.keyname)
acc = AppControllerClient(login_ip, LocalState.get_secret_key(
options.keyname))
acc.start_roles_on_nodes(json.dumps(options.ips))
# TODO(cgb): Should we wait for the new instances to come up and get
# initialized?
AppScaleLogger.success("Successfully sent request to add instances " + \
"to this AppScale deployment.")
def describe_instances(cls, options):
"""Queries each node in the currently running AppScale deployment and
reports on their status.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
login_host = LocalState.get_login_host(options.keyname)
login_acc = AppControllerClient(
login_host, LocalState.get_secret_key(options.keyname))
for ip in login_acc.get_all_public_ips():
acc = AppControllerClient(
ip, LocalState.get_secret_key(options.keyname))
AppScaleLogger.log("Status of node at {0}:".format(ip))
try:
AppScaleLogger.log(acc.get_status())
except Exception as exception:
AppScaleLogger.warn("Unable to contact machine: {0}\n".format(
str(exception)))
AppScaleLogger.success("View status information about your AppScale " + \
"deployment at http://{0}:{1}/status".format(login_host,
RemoteHelper.APP_DASHBOARD_PORT))
def gather_logs(cls, options):
"""Collects logs from each machine in the currently running AppScale
deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
# First, make sure that the place we want to store logs doesn't
# already exist.
if os.path.exists(options.location):
raise AppScaleException("Can't gather logs, as the location you " + \
"specified, {0}, already exists.".format(options.location))
acc = AppControllerClient(LocalState.get_login_host(options.keyname),
LocalState.get_secret_key(options.keyname))
# do the mkdir after we get the secret key, so that a bad keyname will
# cause the tool to crash and not create this directory
os.mkdir(options.location)
for ip in acc.get_all_public_ips():
# Get the logs from each node, and store them in our local directory
local_dir = "{0}/{1}".format(options.location, ip)
os.mkdir(local_dir)
RemoteHelper.scp_remote_to_local(ip, options.keyname,
'/var/log/appscale', local_dir,
options.verbose)
AppScaleLogger.success("Successfully copied logs to {0}".format(
options.location))
def remove_app(cls, options):
"""Instructs AppScale to no longer host the named application.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
if not options.confirm:
response = raw_input("Are you sure you want to remove this " + \
"application? (Y/N) ")
if response not in ['y', 'yes', 'Y', 'YES']:
raise AppScaleException("Cancelled application removal.")
login_host = LocalState.get_login_host(options.keyname)
secret = LocalState.get_secret_key(options.keyname)
acc = AppControllerClient(login_host, secret)
if not acc.does_app_exist(options.appname):
raise AppScaleException(
"The given application is not currently running.")
acc.stop_app(options.appname)
AppScaleLogger.log("Please wait for your app to shut down.")
while True:
if acc.is_app_running(options.appname):
time.sleep(cls.SLEEP_TIME)
else:
break
AppScaleLogger.success("Done shutting down {0}".format(
options.appname))
def copy_app_to_host(cls, app_location, app_id, keyname, is_verbose,
extras=None, custom_service_yaml=None):
"""Copies the given application to a machine running the Login service
within an AppScale deployment.
Args:
app_location: The location on the local filesystem where the application
can be found.
app_id: The project to use for this application.
keyname: The name of the SSH keypair that uniquely identifies this
AppScale deployment.
is_verbose: A bool that indicates if we should print the commands we exec
to copy the app to the remote host to stdout.
extras: A dictionary containing a list of files to include in the upload.
custom_service_yaml: A string specifying the location of the service
yaml being deployed.
Returns:
A str corresponding to the location on the remote filesystem where the
application was copied to.
"""
AppScaleLogger.log("Tarring application")
rand = str(uuid.uuid4()).replace('-', '')[:8]
local_tarred_app = "{0}/appscale-app-{1}-{2}.tar.gz".\
format(tempfile.gettempdir(), app_id, rand)
# Collect list of files that should be included in the tarball.
app_files = {}
for root, _, filenames in os.walk(app_location, followlinks=True):
relative_dir = os.path.relpath(root, app_location)
for filename in filenames:
# Ignore compiled Python files.
if filename.endswith('.pyc'):
continue
relative_path = os.path.join(relative_dir, filename)
app_files[relative_path] = os.path.join(root, filename)
if extras is not None:
app_files.update(extras)
with tarfile.open(local_tarred_app, 'w:gz') as app_tar:
for tarball_path, local_path in app_files.items():
# Replace app.yaml with the service yaml being deployed.
if custom_service_yaml and os.path.normpath(tarball_path) == 'app.yaml':
continue
app_tar.add(local_path, tarball_path)
if custom_service_yaml:
app_tar.add(custom_service_yaml, 'app.yaml')
AppScaleLogger.log("Copying over application")
remote_app_tar = "{0}/{1}.tar.gz".format(cls.REMOTE_APP_DIR, app_id)
cls.scp(LocalState.get_login_host(keyname), keyname, local_tarred_app,
remote_app_tar, is_verbose)
AppScaleLogger.verbose("Removing local copy of tarred application",
is_verbose)
os.remove(local_tarred_app)
return remote_app_tar
def get_serving_info(self, app_id, keyname):
"""Finds out what host and port are used to host the named application.
Args:
app_id: The application that we should find a serving URL for.
Returns:
A tuple containing the host and port where the application is serving
traffic from.
"""
total_wait_time = 0
# first, wait for the app to start serving
sleep_time = self.STARTING_SLEEP_TIME
while True:
if self.does_app_exist(app_id):
break
else:
AppScaleLogger.log("Waiting {0} second(s) to check on application...".\
format(sleep_time))
time.sleep(sleep_time)
sleep_time = min(sleep_time * 2, self.MAX_SLEEP_TIME)
total_wait_time += sleep_time
if total_wait_time > self.MAX_WAIT_TIME:
raise AppScaleException("App took too long to upload")
# next, get the serving host and port
app_data = self.server.get_app_data(app_id, self.secret)
host = LocalState.get_login_host(keyname)
port = int(re.search(".*\sports: (\d+)[\s|:]", app_data).group(1))
return host, port
def copy_app_to_host(cls, app_location, keyname, is_verbose):
"""Copies the given application to a machine running the Login service
within an AppScale deployment.
Args:
app_location: The location on the local filesystem where the application
can be found.
keyname: The name of the SSH keypair that uniquely identifies this
AppScale deployment.
is_verbose: A bool that indicates if we should print the commands we exec
to copy the app to the remote host to stdout.
Returns:
A str corresponding to the location on the remote filesystem where the
application was copied to.
"""
app_id = AppEngineHelper.get_app_id_from_app_config(app_location)
AppScaleLogger.log("Tarring application")
rand = str(uuid.uuid4()).replace('-', '')[:8]
local_tarred_app = "{0}/appscale-app-{1}-{2}.tar.gz".format(
tempfile.gettempdir(), app_id, rand)
LocalState.shell(
"cd '{0}' && COPYFILE_DISABLE=1 tar -czhf {1} --exclude='*.pyc' *".
format(app_location, local_tarred_app), is_verbose)
AppScaleLogger.log("Copying over application")
remote_app_tar = "{0}/{1}.tar.gz".format(cls.REMOTE_APP_DIR, app_id)
cls.scp(LocalState.get_login_host(keyname), keyname, local_tarred_app,
remote_app_tar, is_verbose)
os.remove(local_tarred_app)
return remote_app_tar
def gather_logs(cls, options):
"""Collects logs from each machine in the currently running AppScale
deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
# First, make sure that the place we want to store logs doesn't
# already exist.
if os.path.exists(options.location):
raise AppScaleException("Can't gather logs, as the location you " + \
"specified, {0}, already exists.".format(options.location))
acc = AppControllerClient(LocalState.get_login_host(options.keyname),
LocalState.get_secret_key(options.keyname))
# do the mkdir after we get the secret key, so that a bad keyname will
# cause the tool to crash and not create this directory
os.mkdir(options.location)
for ip in acc.get_all_public_ips():
# Get the logs from each node, and store them in our local directory
local_dir = "{0}/{1}".format(options.location, ip)
os.mkdir(local_dir)
RemoteHelper.scp_remote_to_local(ip, options.keyname, '/var/log/appscale',
local_dir, options.verbose)
AppScaleLogger.success("Successfully copied logs to {0}".format(
options.location))
def create_user_accounts(cls, email, password, uaserver_host, keyname):
"""Registers two new user accounts with the UserAppServer.
One account is the standard account that users log in with (via their
e-mail address. The other is their XMPP account, so that they can log into
any jabber-compatible service and send XMPP messages to their application
(and receive them).
Args:
email: The e-mail address that should be registered for the user's
standard account.
password: The password that should be used for both the standard and XMPP
accounts.
uaserver_host: The location of a UserAppClient, that can create new user
accounts.
keyname: The name of the SSH keypair used for this AppScale deployment.
"""
uaserver = UserAppClient(uaserver_host, LocalState.get_secret_key(keyname))
# first, create the standard account
encrypted_pass = LocalState.encrypt_password(email, password)
uaserver.create_user(email, encrypted_pass)
# next, create the XMPP account. if the user's e-mail is [email protected], then that
# means their XMPP account name is a@login_ip
username_regex = re.compile('\A(.*)@')
username = username_regex.match(email).groups()[0]
xmpp_user = "******".format(username, LocalState.get_login_host(keyname))
xmpp_pass = LocalState.encrypt_password(xmpp_user, password)
uaserver.create_user(xmpp_user, xmpp_pass)
AppScaleLogger.log("Your XMPP username is {0}".format(xmpp_user))
def get_serving_info(self, app_id, keyname):
"""Finds out what host and port are used to host the named application.
Args:
app_id: The application that we should find a serving URL for.
Returns:
A tuple containing the host and port where the application is serving
traffic from.
"""
total_wait_time = 0
# first, wait for the app to start serving
sleep_time = self.STARTING_SLEEP_TIME
while True:
if self.does_app_exist(app_id):
break
else:
AppScaleLogger.log("Waiting {0} second(s) to check on application...".\
format(sleep_time))
time.sleep(sleep_time)
sleep_time = min(sleep_time * 2, self.MAX_SLEEP_TIME)
total_wait_time += sleep_time
if total_wait_time > self.MAX_WAIT_TIME:
raise AppScaleException("App took too long to upload")
# next, get the serving host and port
app_data = self.server.get_app_data(app_id, self.secret)
host = LocalState.get_login_host(keyname)
port = int(re.search(".*\sports: (\d+)[\s|:]", app_data).group(1))
return host, port
def copy_app_to_host(cls, app_location, keyname, is_verbose):
"""Copies the given application to a machine running the Login service
within an AppScale deployment.
Args:
app_location: The location on the local filesystem where the application
can be found.
keyname: The name of the SSH keypair that uniquely identifies this
AppScale deployment.
is_verbose: A bool that indicates if we should print the commands we exec
to copy the app to the remote host to stdout.
Returns:
A str corresponding to the location on the remote filesystem where the
application was copied to.
"""
app_id = AppEngineHelper.get_app_id_from_app_config(app_location)
AppScaleLogger.log("Tarring application")
rand = str(uuid.uuid4()).replace('-', '')[:8]
local_tarred_app = "{0}/appscale-app-{1}-{2}.tar.gz".format(tempfile.gettempdir(),
app_id, rand)
LocalState.shell("cd '{0}' && COPYFILE_DISABLE=1 tar -czhf {1} --exclude='*.pyc' *".format(
app_location, local_tarred_app), is_verbose)
AppScaleLogger.log("Copying over application")
remote_app_tar = "{0}/{1}.tar.gz".format(cls.REMOTE_APP_DIR, app_id)
cls.scp(LocalState.get_login_host(keyname), keyname, local_tarred_app,
remote_app_tar, is_verbose)
os.remove(local_tarred_app)
return remote_app_tar
def relocate_app(cls, options):
"""Instructs AppScale to move the named application to a different port.
Args:
options: A Namespace that has fields for each parameter that can be passed
in via the command-line interface.
Raises:
AppScaleException: If the named application isn't running in this AppScale
cloud, if the destination port is in use by a different application, or
if the AppController rejects the request to relocate the application (in
which case it includes the reason why the rejection occurred).
"""
login_host = LocalState.get_login_host(options.keyname)
acc = AppControllerClient(login_host, LocalState.get_secret_key(
options.keyname))
app_info_map = acc.get_app_info_map()
if options.appname not in app_info_map.keys():
raise AppScaleException("The given application, {0}, is not currently " \
"running in this AppScale cloud, so we can't move it to a different " \
"port.".format(options.appname))
relocate_result = acc.relocate_app(options.appname, options.http_port,
options.https_port)
if relocate_result == "OK":
AppScaleLogger.success("Successfully issued request to move {0} to " \
"ports {1} and {2}.".format(options.appname, options.http_port,
options.https_port))
AppScaleLogger.success("Your app serves unencrypted traffic at: " +
"http://{0}:{1}".format(login_host, options.http_port))
AppScaleLogger.success("Your app serves encrypted traffic at: " +
"https://{0}:{1}".format(login_host, options.https_port))
else:
raise AppScaleException(relocate_result)
def add_instances(cls, options):
"""Adds additional machines to an AppScale deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
if 'master' in options.ips.keys():
raise BadConfigurationException("Cannot add master nodes to an " + \
"already running AppScale deployment.")
# Skip checking for -n (replication) because we don't allow the user
# to specify it here (only allowed in run-instances).
additional_nodes_layout = NodeLayout(options)
# In virtualized cluster deployments, we need to make sure that the user
# has already set up SSH keys.
if LocalState.get_from_yaml(options.keyname,
'infrastructure') == "xen":
for ip in options.ips.values():
# throws a ShellException if the SSH key doesn't work
RemoteHelper.ssh(ip, options.keyname, "ls", options.verbose)
# Finally, find an AppController and send it a message to add
# the given nodes with the new roles.
AppScaleLogger.log("Sending request to add instances")
login_ip = LocalState.get_login_host(options.keyname)
acc = AppControllerClient(login_ip,
LocalState.get_secret_key(options.keyname))
acc.start_roles_on_nodes(json.dumps(options.ips))
# TODO(cgb): Should we wait for the new instances to come up and get
# initialized?
AppScaleLogger.success("Successfully sent request to add instances " + \
"to this AppScale deployment.")
def remove_app(cls, options):
"""Instructs AppScale to no longer host the named application.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
if not options.confirm:
response = raw_input(
'Are you sure you want to remove this application? (y/N) ')
if response.lower() not in ['y', 'yes']:
raise AppScaleException("Cancelled application removal.")
login_host = LocalState.get_login_host(options.keyname)
secret = LocalState.get_secret_key(options.keyname)
acc = AppControllerClient(login_host, secret)
if not acc.is_app_running(options.appname):
raise AppScaleException("The given application is not currently running.")
# Makes a call to the AppController to get all the stats and looks
# through them for the http port the app can be reached on.
http_port = None
for _ in range(cls.MAX_RETRIES + 1):
result = acc.get_all_stats()
try:
json_result = json.loads(result)
apps_result = json_result['apps']
current_app = apps_result[options.appname]
http_port = current_app['http']
if http_port:
break
time.sleep(cls.SLEEP_TIME)
except (KeyError, ValueError):
AppScaleLogger.verbose("Got json error from get_all_data result.",
options.verbose)
time.sleep(cls.SLEEP_TIME)
if not http_port:
raise AppScaleException(
"Unable to get the serving port for the application.")
acc.stop_app(options.appname)
AppScaleLogger.log("Please wait for your app to shut down.")
for _ in range(cls.MAX_RETRIES + 1):
if RemoteHelper.is_port_open(login_host, http_port, options.verbose):
time.sleep(cls.SLEEP_TIME)
AppScaleLogger.log("Waiting for {0} to terminate...".format(
options.appname))
else:
AppScaleLogger.success("Done shutting down {0}.".format(
options.appname))
return
AppScaleLogger.warn("App {0} may still be running.".format(
options.appname))
def gather_logs(cls, options):
"""Collects logs from each machine in the currently running AppScale
deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
# First, make sure that the place we want to store logs doesn't
# already exist.
if os.path.exists(options.location):
raise AppScaleException("Can't gather logs, as the location you " + \
"specified, {0}, already exists.".format(options.location))
acc = AppControllerClient(LocalState.get_login_host(options.keyname),
LocalState.get_secret_key(options.keyname))
try:
all_ips = acc.get_all_public_ips()
except socket.error: # Occurs when the AppController has failed.
AppScaleLogger.warn("Couldn't get an up-to-date listing of the " + \
"machines in this AppScale deployment. Using our locally cached " + \
"info instead.")
all_ips = LocalState.get_all_public_ips(options.keyname)
# do the mkdir after we get the secret key, so that a bad keyname will
# cause the tool to crash and not create this directory
os.mkdir(options.location)
for ip in all_ips:
# Get the logs from each node, and store them in our local directory
local_dir = "{0}/{1}".format(options.location, ip)
os.mkdir(local_dir)
RemoteHelper.scp_remote_to_local(ip, options.keyname, '/var/log/appscale',
local_dir, options.verbose)
try:
RemoteHelper.scp_remote_to_local(ip, options.keyname,
'/var/log/cassandra', local_dir, options.verbose)
except ShellException:
pass
try:
RemoteHelper.scp_remote_to_local(ip, options.keyname,
'/var/log/zookeeper', local_dir, options.verbose)
except ShellException:
pass
RemoteHelper.scp_remote_to_local(ip, options.keyname, '/var/log/kern.log',
local_dir, options.verbose)
RemoteHelper.scp_remote_to_local(ip, options.keyname, '/var/log/syslog',
local_dir, options.verbose)
AppScaleLogger.success("Successfully copied logs to {0}".format(
options.location))
def publish_api_list(cls, api_list, url, keyname):
eager = EagerClient(LocalState.get_login_host(keyname),
LocalState.get_secret_key(keyname))
temp_api_list = []
for api in api_list:
temp_api_list.append(api.to_dict())
result = eager.publish_api_list(temp_api_list, url)
if result['success']:
AppScaleLogger.log('{0} APIs published to API store.'.format(len(api_list)))
else:
AppScaleLogger.warn(result['reason'])
if result.get('detail'):
AppScaleLogger.warn(str(result['detail']))
def perform_eager_validation(cls, app, keyname):
eager = EagerClient(LocalState.get_login_host(keyname),
LocalState.get_secret_key(keyname))
AppScaleLogger.log('Running EAGER validations for application.')
result = eager.validate_application_for_deployment(app.to_dict())
if not result['success']:
AppScaleLogger.log('Validation errors encountered: {0}'.format(result['reason']))
if hasattr(result, 'detail'):
errors = result['detail'].split('|')
AppScaleLogger.log('Following error details are available:')
for e in errors:
AppScaleLogger.log(' * {0}'.format(e))
return result['success']
def spawn_nodes_in_cloud(cls, options, count=1):
"""Starts a single virtual machine in a cloud infrastructure.
This method also prepares the virual machine for use by the AppScale Tools.
Args:
options: A Namespace that specifies the cloud infrastructure to use, as
well as how to interact with that cloud.
count: A int, the number of instances to start.
Returns:
The instance ID, public IP address, and private IP address of the machine
that was started.
"""
agent = InfrastructureAgentFactory.create_agent(options.infrastructure)
params = agent.get_params_from_args(options)
# If we have running instances under the current keyname, we try to
# re-attach to them. If we have issue finding the locations file or the
# IP of the head node, we throw an exception.
login_ip = None
public_ips, private_ips, instance_ids = agent.describe_instances(
params)
if public_ips:
try:
login_ip = LocalState.get_login_host(options.keyname)
except (IOError, BadConfigurationException):
raise AppScaleException(
"Couldn't get login ip for running deployment with keyname"
" {}.".format(options.keyname))
if login_ip not in public_ips:
raise AppScaleException(
"Couldn't recognize running instances for deployment with"
" keyname {}.".format(options.keyname))
if login_ip in public_ips:
AppScaleLogger.log("Reusing already running instances.")
return instance_ids, public_ips, private_ips
agent.configure_instance_security(params)
instance_ids, public_ips, private_ips = agent.run_instances(
count=count, parameters=params, security_configured=True)
if options.static_ip:
agent.associate_static_ip(params, instance_ids[0],
options.static_ip)
public_ips[0] = options.static_ip
AppScaleLogger.log("Static IP associated with head node.")
return instance_ids, public_ips, private_ips
def create_user_accounts(cls, email, password, public_ip, keyname):
"""Registers two new user accounts with the UserAppServer.
One account is the standard account that users log in with (via their
e-mail address. The other is their XMPP account, so that they can log into
any jabber-compatible service and send XMPP messages to their application
(and receive them).
Args:
email: The e-mail address that should be registered for the user's
standard account.
password: The password that should be used for both the standard and XMPP
accounts.
public_ip: The location where the AppController can be found.
keyname: The name of the SSH keypair used for this AppScale deployment.
"""
acc = AppControllerClient(public_ip,
LocalState.get_secret_key(keyname))
# first, create the standard account
encrypted_pass = LocalState.encrypt_password(email, password)
if acc.does_user_exist(email):
AppScaleLogger.log(
"User {0} already exists, so not creating it again.".format(
email))
else:
acc.create_user(email, encrypted_pass)
# next, create the XMPP account. if the user's e-mail is [email protected], then that
# means their XMPP account name is a@login_ip
username_regex = re.compile('\A(.*)@')
username = username_regex.match(email).groups()[0]
xmpp_user = "******".format(username,
LocalState.get_login_host(keyname))
xmpp_pass = LocalState.encrypt_password(xmpp_user, password)
if acc.does_user_exist(xmpp_user):
AppScaleLogger.log(
"XMPP User {0} already exists, so not creating it again.".
format(xmpp_user))
else:
acc.create_user(xmpp_user, xmpp_pass)
AppScaleLogger.log("Your XMPP username is {0}".format(xmpp_user))
def reset_password(cls, options):
"""Resets a user's password the currently running AppScale deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
secret = LocalState.get_secret_key(options.keyname)
username, password = LocalState.get_credentials(is_admin=False)
encrypted_password = LocalState.encrypt_password(username, password)
uac = UserAppClient(LocalState.get_login_host(options.keyname), secret)
try:
uac.change_password(username, encrypted_password)
AppScaleLogger.success("The password was successfully changed for the " \
"given user.")
except Exception as exception:
AppScaleLogger.warn("Could not change the user's password for the " + \
"following reason: {0}".format(str(exception)))
sys.exit(1)
def relocate_app(cls, options):
"""Instructs AppScale to move the named application to a different port.
Args:
options: A Namespace that has fields for each parameter that can be passed
in via the command-line interface.
Raises:
AppScaleException: If the named application isn't running in this AppScale
cloud, if the destination port is in use by a different application, or
if the AppController rejects the request to relocate the application (in
which case it includes the reason why the rejection occurred).
"""
login_host = LocalState.get_login_host(options.keyname)
acc = AppControllerClient(login_host,
LocalState.get_secret_key(options.keyname))
app_info_map = acc.get_app_info_map()
if options.appname not in app_info_map.keys():
raise AppScaleException("The given application, {0}, is not currently " \
"running in this AppScale cloud, so we can't move it to a different " \
"port.".format(options.appname))
relocate_result = acc.relocate_app(options.appname, options.http_port,
options.https_port)
if relocate_result == "OK":
AppScaleLogger.success("Successfully issued request to move {0} to " \
"ports {1} and {2}.".format(options.appname, options.http_port,
options.https_port))
RemoteHelper.sleep_until_port_is_open(login_host,
options.http_port,
options.verbose)
AppScaleLogger.success(
"Your app serves unencrypted traffic at: " +
"http://{0}:{1}".format(login_host, options.http_port))
AppScaleLogger.success(
"Your app serves encrypted traffic at: " +
"https://{0}:{1}".format(login_host, options.https_port))
else:
raise AppScaleException(relocate_result)
def get_serving_info(self, app_id, keyname):
"""Finds out what host and port are used to host the named application.
Args:
app_id: The application that we should find a serving URL for.
Returns:
A tuple containing the host and port where the application is serving
traffic from.
"""
# first, wait for the app to start serving
sleep_time = self.STARTING_SLEEP_TIME
while True:
if self.does_app_exist(app_id):
break
else:
time.sleep(sleep_time)
sleep_time = min(sleep_time * 2, self.MAX_SLEEP_TIME)
# next, get the serving host and port
app_data = self.server.get_app_data(app_id, self.secret)
host = LocalState.get_login_host(keyname)
port = int(re.search(".*\sports: (\d+)[\s|:]", app_data).group(1))
return host, port
def upload_app(cls, options):
"""Uploads the given App Engine application into AppScale.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
Returns:
A tuple containing the host and port where the application is serving
traffic from.
"""
if cls.TAR_GZ_REGEX.search(options.file):
file_location = LocalState.extract_tgz_app_to_dir(
options.file, options.verbose)
created_dir = True
elif cls.ZIP_REGEX.search(options.file):
file_location = LocalState.extract_zip_app_to_dir(
options.file, options.verbose)
created_dir = True
elif os.path.isdir(options.file):
file_location = options.file
created_dir = False
else:
raise AppEngineConfigException('{0} is not a tar.gz file, a zip file, ' \
'or a directory. Please try uploading either a tar.gz file, a zip ' \
'file, or a directory.'.format(options.file))
try:
app_id = AppEngineHelper.get_app_id_from_app_config(file_location)
except AppEngineConfigException as config_error:
AppScaleLogger.log(config_error)
if 'yaml' in str(config_error):
raise config_error
# Java App Engine users may have specified their war directory. In that
# case, just move up one level, back to the app's directory.
file_location = file_location + os.sep + ".."
app_id = AppEngineHelper.get_app_id_from_app_config(file_location)
app_language = AppEngineHelper.get_app_runtime_from_app_config(
file_location)
AppEngineHelper.validate_app_id(app_id)
if app_language == 'java':
if AppEngineHelper.is_sdk_mismatch(file_location):
AppScaleLogger.warn(
'AppScale did not find the correct SDK jar ' +
'versions in your app. The current supported ' +
'SDK version is ' + AppEngineHelper.SUPPORTED_SDK_VERSION +
'.')
login_host = LocalState.get_login_host(options.keyname)
secret_key = LocalState.get_secret_key(options.keyname)
acc = AppControllerClient(login_host, secret_key)
if options.test:
username = LocalState.DEFAULT_USER
elif options.email:
username = options.email
else:
username = LocalState.get_username_from_stdin(is_admin=False)
if not acc.does_user_exist(username):
password = LocalState.get_password_from_stdin()
RemoteHelper.create_user_accounts(username,
password,
login_host,
options.keyname,
clear_datastore=False)
app_exists = acc.does_app_exist(app_id)
app_admin = acc.get_app_admin(app_id)
if app_admin is not None and username != app_admin:
raise AppScaleException("The given user doesn't own this application" + \
", so they can't upload an app with that application ID. Please " + \
"change the application ID and try again.")
if app_exists:
AppScaleLogger.log(
"Uploading new version of app {0}".format(app_id))
else:
AppScaleLogger.log(
"Uploading initial version of app {0}".format(app_id))
acc.reserve_app_id(username, app_id, app_language)
# Ignore all .pyc files while tarring.
if app_language == 'python27':
AppScaleLogger.log("Ignoring .pyc files")
remote_file_path = RemoteHelper.copy_app_to_host(
file_location, options.keyname, options.verbose)
acc.done_uploading(app_id, remote_file_path)
acc.update([app_id])
# now that we've told the AppController to start our app, find out what port
# the app is running on and wait for it to start serving
AppScaleLogger.log("Please wait for your app to start serving.")
if app_exists:
time.sleep(20) # give the AppController time to restart the app
# Makes a call to the AppController to get all the stats and looks
# through them for the http port the app can be reached on.
sleep_time = 2 * cls.SLEEP_TIME
current_app = None
for i in range(cls.MAX_RETRIES):
try:
result = acc.get_all_stats()
json_result = json.loads(result)
apps_result = json_result['apps']
current_app = apps_result[app_id]
http_port = current_app['http']
break
except ValueError:
pass
except KeyError:
pass
AppScaleLogger.verbose("Waiting {0} second(s) for a port to be assigned to {1}".\
format(sleep_time, app_id), options.verbose)
time.sleep(sleep_time)
if not current_app:
raise AppScaleException(
"Unable to get the serving port for the application.")
RemoteHelper.sleep_until_port_is_open(login_host, http_port,
options.verbose)
AppScaleLogger.success(
"Your app can be reached at the following URL: " +
"http://{0}:{1}".format(login_host, http_port))
if created_dir:
shutil.rmtree(file_location)
return (login_host, http_port)
def run_instances(cls, options):
"""Starts a new AppScale deployment with the parameters given.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
Raises:
AppControllerException: If the AppController on the head node crashes.
When this occurs, the message in the exception contains the reason why
the AppController crashed.
BadConfigurationException: If the user passes in options that are not
sufficient to start an AppScale deployment (e.g., running on EC2 but
not specifying the AMI to use), or if the user provides us
contradictory options (e.g., running on EC2 but not specifying EC2
credentials).
"""
LocalState.make_appscale_directory()
LocalState.ensure_appscale_isnt_running(options.keyname, options.force)
if options.infrastructure:
if not options.disks and not options.test and not options.force:
LocalState.ensure_user_wants_to_run_without_disks()
AppScaleLogger.log("Starting AppScale " + APPSCALE_VERSION +
" over the " + options.infrastructure +
" cloud.")
else:
AppScaleLogger.log("Starting AppScale " + APPSCALE_VERSION +
" over a virtualized cluster.")
my_id = str(uuid.uuid4())
AppScaleLogger.remote_log_tools_state(options, my_id, "started",
APPSCALE_VERSION)
node_layout = NodeLayout(options)
if not node_layout.is_valid():
raise BadConfigurationException("There were errors with your " + \
"placement strategy:\n{0}".format(str(node_layout.errors())))
public_ip, instance_id = RemoteHelper.start_head_node(
options, my_id, node_layout)
AppScaleLogger.log(
"\nPlease wait for AppScale to prepare your machines " +
"for use. This can take few minutes.")
# Write our metadata as soon as possible to let users SSH into those
# machines via 'appscale ssh'.
LocalState.update_local_metadata(options, node_layout, public_ip,
instance_id)
RemoteHelper.copy_local_metadata(public_ip, options.keyname,
options.verbose)
acc = AppControllerClient(public_ip,
LocalState.get_secret_key(options.keyname))
# Let's now wait till the server is initialized.
while not acc.is_initialized():
AppScaleLogger.log('Waiting for head node to initialize...')
# This can take some time in particular the first time around, since
# we will have to initialize the database.
time.sleep(cls.SLEEP_TIME * 3)
try:
# We don't need to have any exception information here: we do expect
# some anyway while the UserAppServer is coming up.
acc.does_user_exist("non-existent-user", True)
except Exception as exception:
AppScaleLogger.log('UserAppServer not ready yet. Retrying ...')
time.sleep(cls.SLEEP_TIME)
# Update our metadata again so that users can SSH into other boxes that
# may have been started.
LocalState.update_local_metadata(options, node_layout, public_ip,
instance_id)
RemoteHelper.copy_local_metadata(public_ip, options.keyname,
options.verbose)
if options.admin_user and options.admin_pass:
AppScaleLogger.log("Using the provided admin username/password")
username, password = options.admin_user, options.admin_pass
elif options.test:
AppScaleLogger.log("Using default admin username/password")
username, password = LocalState.DEFAULT_USER, LocalState.DEFAULT_PASSWORD
else:
username, password = LocalState.get_credentials()
RemoteHelper.create_user_accounts(username, password, public_ip,
options.keyname,
options.clear_datastore)
acc.set_admin_role(username, 'true', cls.ADMIN_CAPABILITIES)
RemoteHelper.wait_for_machines_to_finish_loading(
public_ip, options.keyname)
# Finally, update our metadata once we know that all of the machines are
# up and have started all their API services.
LocalState.update_local_metadata(options, node_layout, public_ip,
instance_id)
RemoteHelper.copy_local_metadata(public_ip, options.keyname,
options.verbose)
RemoteHelper.sleep_until_port_is_open(
LocalState.get_login_host(options.keyname),
RemoteHelper.APP_DASHBOARD_PORT, options.verbose)
AppScaleLogger.success("AppScale successfully started!")
AppScaleLogger.success("View status information about your AppScale " + \
"deployment at http://{0}:{1}/status".format(LocalState.get_login_host(
options.keyname), RemoteHelper.APP_DASHBOARD_PORT))
AppScaleLogger.remote_log_tools_state(options, my_id, "finished",
APPSCALE_VERSION)
def gather_logs(cls, options):
"""Collects logs from each machine in the currently running AppScale
deployment.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
"""
# First, make sure that the place we want to store logs doesn't
# already exist.
if os.path.exists(options.location):
raise AppScaleException("Can't gather logs, as the location you " + \
"specified, {0}, already exists.".format(options.location))
acc = AppControllerClient(LocalState.get_login_host(options.keyname),
LocalState.get_secret_key(options.keyname))
try:
all_ips = acc.get_all_public_ips()
except socket.error: # Occurs when the AppController has failed.
AppScaleLogger.warn("Couldn't get an up-to-date listing of the " + \
"machines in this AppScale deployment. Using our locally cached " + \
"info instead.")
all_ips = LocalState.get_all_public_ips(options.keyname)
# do the mkdir after we get the secret key, so that a bad keyname will
# cause the tool to crash and not create this directory
os.mkdir(options.location)
# The log paths that we collect logs from.
log_paths = [
'/var/log/appscale', '/var/log/kern.log*', '/var/log/monit.log*',
'/var/log/nginx', '/var/log/syslog*', '/var/log/zookeeper'
]
failures = False
for ip in all_ips:
# Get the logs from each node, and store them in our local directory
local_dir = "{0}/{1}".format(options.location, ip)
os.mkdir(local_dir)
for log_path in log_paths:
try:
RemoteHelper.scp_remote_to_local(ip, options.keyname,
log_path, local_dir,
options.verbose)
except ShellException as shell_exception:
failures = True
AppScaleLogger.warn(
"Unable to collect logs from '{}' for host '{}'".
format(log_path, ip))
AppScaleLogger.verbose(
"Encountered exception: {}".format(
str(shell_exception)), options.verbose)
if failures:
AppScaleLogger.log(
"Done copying to {0}. There were "
"failures while collecting AppScale logs.".format(
options.location))
else:
AppScaleLogger.success(
"Successfully collected all AppScale logs into "
"{0}".format(options.location))
def upload_app(cls, options):
"""Uploads the given App Engine application into AppScale.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
Returns:
A tuple containing the host and port where the application is serving
traffic from.
"""
if cls.TAR_GZ_REGEX.search(options.file):
file_location = LocalState.extract_app_to_dir(
options.file, options.verbose)
created_dir = True
else:
file_location = options.file
created_dir = False
app_id = AppEngineHelper.get_app_id_from_app_config(file_location)
app_language = AppEngineHelper.get_app_runtime_from_app_config(
file_location)
AppEngineHelper.validate_app_id(app_id)
acc = AppControllerClient(LocalState.get_login_host(options.keyname),
LocalState.get_secret_key(options.keyname))
userappserver_host = acc.get_uaserver_host(options.verbose)
userappclient = UserAppClient(
userappserver_host, LocalState.get_secret_key(options.keyname))
if options.test:
username = LocalState.DEFAULT_USER
elif options.email:
username = options.email
else:
username = LocalState.get_username_from_stdin(is_admin=False)
if not userappclient.does_user_exist(username):
password = LocalState.get_password_from_stdin()
RemoteHelper.create_user_accounts(username, password,
userappserver_host,
options.keyname)
app_exists = userappclient.does_app_exist(app_id)
app_admin = userappclient.get_app_admin(app_id)
if app_admin is not None and username != app_admin:
raise AppScaleException("The given user doesn't own this application" + \
", so they can't upload an app with that application ID. Please " + \
"change the application ID and try again.")
if app_exists:
AppScaleLogger.log(
"Uploading new version of app {0}".format(app_id))
else:
AppScaleLogger.log(
"Uploading initial version of app {0}".format(app_id))
userappclient.reserve_app_id(username, app_id, app_language)
remote_file_path = RemoteHelper.copy_app_to_host(
file_location, options.keyname, options.verbose)
acc.done_uploading(app_id, remote_file_path)
acc.update([app_id])
# now that we've told the AppController to start our app, find out what port
# the app is running on and wait for it to start serving
AppScaleLogger.log("Please wait for your app to start serving.")
if app_exists:
time.sleep(20) # give the AppController time to restart the app
serving_host, serving_port = userappclient.get_serving_info(
app_id, options.keyname)
RemoteHelper.sleep_until_port_is_open(serving_host, serving_port,
options.verbose)
AppScaleLogger.success(
"Your app can be reached at the following URL: " +
"http://{0}:{1}".format(serving_host, serving_port))
if created_dir:
shutil.rmtree(file_location)
return (serving_host, serving_port)
def run_instances(cls, options):
"""Starts a new AppScale deployment with the parameters given.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
Raises:
AppControllerException: If the AppController on the head node crashes.
When this occurs, the message in the exception contains the reason why
the AppController crashed.
BadConfigurationException: If the user passes in options that are not
sufficient to start an AppScale deployment (e.g., running on EC2 but
not specifying the AMI to use), or if the user provides us
contradictory options (e.g., running on EC2 but not specifying EC2
credentials).
"""
LocalState.make_appscale_directory()
LocalState.ensure_appscale_isnt_running(options.keyname, options.force)
if options.infrastructure:
if not options.disks and not options.test and not options.force:
LocalState.ensure_user_wants_to_run_without_disks()
AppScaleLogger.log("Starting AppScale " + APPSCALE_VERSION +
" over the " + options.infrastructure +
" cloud.")
else:
AppScaleLogger.log("Starting AppScale " + APPSCALE_VERSION +
" over a virtualized cluster.")
my_id = str(uuid.uuid4())
AppScaleLogger.remote_log_tools_state(options, my_id, "started",
APPSCALE_VERSION)
node_layout = NodeLayout(options)
if not node_layout.is_valid():
raise BadConfigurationException("There were errors with your " + \
"placement strategy:\n{0}".format(str(node_layout.errors())))
if not node_layout.is_supported():
AppScaleLogger.warn("Warning: This deployment strategy is not " + \
"officially supported.")
public_ip, instance_id = RemoteHelper.start_head_node(
options, my_id, node_layout)
AppScaleLogger.log(
"\nPlease wait for AppScale to prepare your machines " +
"for use.")
# Write our metadata as soon as possible to let users SSH into those
# machines via 'appscale ssh'
LocalState.update_local_metadata(options, node_layout, public_ip,
instance_id)
RemoteHelper.copy_local_metadata(public_ip, options.keyname,
options.verbose)
acc = AppControllerClient(public_ip,
LocalState.get_secret_key(options.keyname))
try:
uaserver_host = acc.get_uaserver_host(options.verbose)
except Exception:
message = RemoteHelper.collect_appcontroller_crashlog(
public_ip, options.keyname, options.verbose)
raise AppControllerException(message)
RemoteHelper.sleep_until_port_is_open(uaserver_host,
UserAppClient.PORT,
options.verbose)
# Update our metadata again so that users can SSH into other boxes that
# may have been started.
LocalState.update_local_metadata(options, node_layout, public_ip,
instance_id)
RemoteHelper.copy_local_metadata(public_ip, options.keyname,
options.verbose)
AppScaleLogger.log("UserAppServer is at {0}".format(uaserver_host))
uaserver_client = UserAppClient(
uaserver_host, LocalState.get_secret_key(options.keyname))
if options.admin_user and options.admin_pass:
AppScaleLogger.log("Using the provided admin username/password")
username, password = options.admin_user, options.admin_pass
elif options.test:
AppScaleLogger.log("Using default admin username/password")
username, password = LocalState.DEFAULT_USER, LocalState.DEFAULT_PASSWORD
else:
username, password = LocalState.get_credentials()
RemoteHelper.create_user_accounts(username, password, uaserver_host,
options.keyname,
options.clear_datastore)
uaserver_client.set_admin_role(username)
RemoteHelper.wait_for_machines_to_finish_loading(
public_ip, options.keyname)
# Finally, update our metadata once we know that all of the machines are
# up and have started all their API services.
LocalState.update_local_metadata(options, node_layout, public_ip,
instance_id)
RemoteHelper.copy_local_metadata(public_ip, options.keyname,
options.verbose)
RemoteHelper.sleep_until_port_is_open(
LocalState.get_login_host(options.keyname),
RemoteHelper.APP_DASHBOARD_PORT, options.verbose)
AppScaleLogger.success("AppScale successfully started!")
AppScaleLogger.success("View status information about your AppScale " + \
"deployment at http://{0}:{1}/status".format(LocalState.get_login_host(
options.keyname), RemoteHelper.APP_DASHBOARD_PORT))
AppScaleLogger.remote_log_tools_state(options, my_id, "finished",
APPSCALE_VERSION)
def upload_app(cls, options):
"""Uploads the given App Engine application into AppScale.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
Returns:
A tuple containing the host and port where the application is serving
traffic from.
"""
if cls.TAR_GZ_REGEX.search(options.file):
file_location = LocalState.extract_tgz_app_to_dir(
options.file, options.verbose)
created_dir = True
elif cls.ZIP_REGEX.search(options.file):
file_location = LocalState.extract_zip_app_to_dir(
options.file, options.verbose)
created_dir = True
elif os.path.isdir(options.file):
file_location = options.file
created_dir = False
else:
raise AppEngineConfigException('{0} is not a tar.gz file, a zip file, ' \
'or a directory. Please try uploading either a tar.gz file, a zip ' \
'file, or a directory.'.format(options.file))
try:
app_id = AppEngineHelper.get_app_id_from_app_config(file_location)
except AppEngineConfigException:
# Java App Engine users may have specified their war directory. In that
# case, just move up one level, back to the app's directory.
file_location = file_location + os.sep + ".."
app_id = AppEngineHelper.get_app_id_from_app_config(file_location)
app_language = AppEngineHelper.get_app_runtime_from_app_config(
file_location)
AppEngineHelper.validate_app_id(app_id)
if app_language == 'java':
if AppEngineHelper.is_sdk_mismatch(file_location):
AppScaleLogger.warn(
'AppScale did not find the correct SDK jar ' +
'versions in your app. The current supported ' +
'SDK version is ' + AppEngineHelper.SUPPORTED_SDK_VERSION +
'.')
acc = AppControllerClient(LocalState.get_login_host(options.keyname),
LocalState.get_secret_key(options.keyname))
userappserver_host = acc.get_uaserver_host(options.verbose)
userappclient = UserAppClient(
userappserver_host, LocalState.get_secret_key(options.keyname))
if options.test:
username = LocalState.DEFAULT_USER
elif options.email:
username = options.email
else:
username = LocalState.get_username_from_stdin(is_admin=False)
if not userappclient.does_user_exist(username):
password = LocalState.get_password_from_stdin()
RemoteHelper.create_user_accounts(username,
password,
userappserver_host,
options.keyname,
clear_datastore=False)
app_exists = userappclient.does_app_exist(app_id)
app_admin = userappclient.get_app_admin(app_id)
if app_admin is not None and username != app_admin:
raise AppScaleException("The given user doesn't own this application" + \
", so they can't upload an app with that application ID. Please " + \
"change the application ID and try again.")
if app_exists:
AppScaleLogger.log(
"Uploading new version of app {0}".format(app_id))
else:
AppScaleLogger.log(
"Uploading initial version of app {0}".format(app_id))
userappclient.reserve_app_id(username, app_id, app_language)
remote_file_path = RemoteHelper.copy_app_to_host(
file_location, options.keyname, options.verbose)
acc.done_uploading(app_id, remote_file_path)
acc.update([app_id])
# now that we've told the AppController to start our app, find out what port
# the app is running on and wait for it to start serving
AppScaleLogger.log("Please wait for your app to start serving.")
if app_exists:
time.sleep(20) # give the AppController time to restart the app
serving_host, serving_port = userappclient.get_serving_info(
app_id, options.keyname)
RemoteHelper.sleep_until_port_is_open(serving_host, serving_port,
options.verbose)
AppScaleLogger.success(
"Your app can be reached at the following URL: " +
"http://{0}:{1}".format(serving_host, serving_port))
if created_dir:
shutil.rmtree(file_location)
return (serving_host, serving_port)
def run_instances(cls, options):
"""Starts a new AppScale deployment with the parameters given.
Args:
options: A Namespace that has fields for each parameter that can be
passed in via the command-line interface.
Raises:
AppControllerException: If the AppController on the head node crashes.
When this occurs, the message in the exception contains the reason why
the AppController crashed.
BadConfigurationException: If the user passes in options that are not
sufficient to start an AppScale deployment (e.g., running on EC2 but
not specifying the AMI to use), or if the user provides us
contradictory options (e.g., running on EC2 but not specifying EC2
credentials).
"""
LocalState.make_appscale_directory()
LocalState.ensure_appscale_isnt_running(options.keyname, options.force)
if options.infrastructure:
if not options.disks and not options.test and not options.force:
LocalState.ensure_user_wants_to_run_without_disks()
reduced_version = '.'.join(x for x in APPSCALE_VERSION.split('.')[:2])
AppScaleLogger.log("Starting AppScale " + reduced_version)
my_id = str(uuid.uuid4())
AppScaleLogger.remote_log_tools_state(options, my_id, "started",
APPSCALE_VERSION)
node_layout = NodeLayout(options)
if not node_layout.is_valid():
raise BadConfigurationException("There were errors with your " + \
"placement strategy:\n{0}".format(str(node_layout.errors())))
head_node = node_layout.head_node()
# Start VMs in cloud via cloud agent.
if options.infrastructure:
instance_ids, public_ips, private_ips = RemoteHelper.start_all_nodes(
options, len(node_layout.nodes))
AppScaleLogger.log("\nPlease wait for AppScale to prepare your machines "
"for use. This can take few minutes.")
# Set newly obtained node layout info for this deployment.
for i, _ in enumerate(instance_ids):
node_layout.nodes[i].public_ip = public_ips[i]
node_layout.nodes[i].private_ip = private_ips[i]
node_layout.nodes[i].instance_id = instance_ids[i]
# Enables root logins and SSH access on the head node.
RemoteHelper.enable_root_ssh(options, head_node.public_ip)
AppScaleLogger.verbose("Node Layout: {}".format(node_layout.to_list()),
options.verbose)
# Ensure all nodes are compatible.
RemoteHelper.ensure_machine_is_compatible(
head_node.public_ip, options.keyname, options.verbose)
# Use rsync to move custom code into the deployment.
if options.scp:
AppScaleLogger.log("Copying over local copy of AppScale from {0}".
format(options.scp))
RemoteHelper.rsync_files(head_node.public_ip, options.keyname, options.scp,
options.verbose)
# Start services on head node.
RemoteHelper.start_head_node(options, my_id, node_layout)
# Write deployment metadata to disk (facilitates SSH operations, etc.)
db_master = node_layout.db_master().private_ip
head_node = node_layout.head_node().public_ip
LocalState.update_local_metadata(options, db_master, head_node)
# Copy the locations.json to the head node
RemoteHelper.copy_local_metadata(node_layout.head_node().public_ip,
options.keyname, options.verbose)
# Wait for services on head node to start.
secret_key = LocalState.get_secret_key(options.keyname)
acc = AppControllerClient(head_node, secret_key)
try:
while not acc.is_initialized():
AppScaleLogger.log('Waiting for head node to initialize...')
# This can take some time in particular the first time around, since
# we will have to initialize the database.
time.sleep(cls.SLEEP_TIME*3)
except socket.error as socket_error:
AppScaleLogger.warn('Unable to initialize AppController: {}'.
format(socket_error.message))
message = RemoteHelper.collect_appcontroller_crashlog(
head_node, options.keyname, options.verbose)
raise AppControllerException(message)
# Set up admin account.
try:
# We don't need to have any exception information here: we do expect
# some anyway while the UserAppServer is coming up.
acc.does_user_exist("non-existent-user", True)
except Exception:
AppScaleLogger.log('UserAppServer not ready yet. Retrying ...')
time.sleep(cls.SLEEP_TIME)
if options.admin_user and options.admin_pass:
AppScaleLogger.log("Using the provided admin username/password")
username, password = options.admin_user, options.admin_pass
elif options.test:
AppScaleLogger.log("Using default admin username/password")
username, password = LocalState.DEFAULT_USER, LocalState.DEFAULT_PASSWORD
else:
username, password = LocalState.get_credentials()
RemoteHelper.create_user_accounts(username, password, head_node,
options.keyname)
acc.set_admin_role(username, 'true', cls.ADMIN_CAPABILITIES)
# Wait for machines to finish loading and AppScale Dashboard to be deployed.
RemoteHelper.wait_for_machines_to_finish_loading(head_node, options.keyname)
RemoteHelper.sleep_until_port_is_open(LocalState.get_login_host(
options.keyname), RemoteHelper.APP_DASHBOARD_PORT, options.verbose)
AppScaleLogger.success("AppScale successfully started!")
AppScaleLogger.success("View status information about your AppScale " + \
"deployment at http://{0}:{1}".format(LocalState.get_login_host(
options.keyname), RemoteHelper.APP_DASHBOARD_PORT))
AppScaleLogger.remote_log_tools_state(options, my_id,
"finished", APPSCALE_VERSION)
