def terminate_instances(cls, options):
"""Stops all services running in an AppScale deployment, and in cloud
deployments, also powers off the instances previously spawned.
Raises:
AppScaleException: If AppScale is not running, and thus can't be
terminated.
"""
if not os.path.exists(
LocalState.get_secret_key_location(options.keyname)):
raise AppScaleException(
"AppScale is not running with the keyname {0}".format(
options.keyname))
infrastructure = LocalState.get_infrastructure(options.keyname)
# If the user is on a cloud deployment, and not backing their data to
# persistent disks, warn them before shutting down AppScale.
# Also, if we're in developer mode, skip the warning.
if infrastructure != "xen" and not LocalState.are_disks_used(
options.keyname) and not options.test:
LocalState.ensure_user_wants_to_terminate()
if infrastructure in InfrastructureAgentFactory.VALID_AGENTS:
RemoteHelper.terminate_cloud_infrastructure(
options.keyname, options.verbose)
else:
RemoteHelper.terminate_virtualized_cluster(options.keyname,
options.verbose)
LocalState.cleanup_appscale_files(options.keyname)
AppScaleLogger.success(
"Successfully shut down your AppScale deployment.")
def terminate_instances(cls, options):
"""Stops all services running in an AppScale deployment, and in cloud
deployments, also powers off the instances previously spawned.
Raises:
AppScaleException: If AppScale is not running, and thus can't be
terminated.
"""
if not os.path.exists(
LocalState.get_locations_yaml_location(options.keyname)):
raise AppScaleException(
"AppScale is not running with the keyname {0}".format(
options.keyname))
if LocalState.get_infrastructure(options.keyname) in \
InfrastructureAgentFactory.VALID_AGENTS:
RemoteHelper.terminate_cloud_infrastructure(
options.keyname, options.verbose)
else:
RemoteHelper.terminate_virtualized_cluster(options.keyname,
options.verbose)
LocalState.cleanup_appscale_files(options.keyname)
AppScaleLogger.success(
"Successfully shut down your AppScale deployment.")
def terminate_cloud_infrastructure(cls, keyname, is_verbose):
"""Powers off all machines in the currently running AppScale deployment.
Args:
keyname: The name of the SSH keypair used for this AppScale deployment.
is_verbose: A bool that indicates if we should print the commands executed
to stdout.
"""
AppScaleLogger.log("About to terminate instances spawned with keyname {0}"
.format(keyname))
# This sleep is here to allow a moment for user to Ctrl-C
time.sleep(2)
# get all the instance IDs for machines in our deployment
agent = InfrastructureAgentFactory.create_agent(
LocalState.get_infrastructure(keyname))
params = agent.get_params_from_yaml(keyname)
params['IS_VERBOSE'] = is_verbose
_, _, instance_ids = agent.describe_instances(params)
# terminate all the machines
params[agent.PARAM_INSTANCE_IDS] = instance_ids
agent.terminate_instances(params)
# delete the keyname and group
agent.cleanup_state(params)
def terminate_instances(cls, options):
"""Stops all services running in an AppScale deployment, and in cloud
deployments, also powers off the instances previously spawned.
Raises:
AppScaleException: If AppScale is not running, and thus can't be
terminated.
"""
if not os.path.exists(LocalState.get_secret_key_location(options.keyname)):
raise AppScaleException("AppScale is not running with the keyname {0}".format(options.keyname))
infrastructure = LocalState.get_infrastructure(options.keyname)
# If the user is on a cloud deployment, and not backing their data to
# persistent disks, warn them before shutting down AppScale.
# Also, if we're in developer mode, skip the warning.
if infrastructure != "xen" and not LocalState.are_disks_used(options.keyname) and not options.test:
LocalState.ensure_user_wants_to_terminate()
if infrastructure in InfrastructureAgentFactory.VALID_AGENTS:
RemoteHelper.terminate_cloud_infrastructure(options.keyname, options.verbose)
else:
RemoteHelper.terminate_virtualized_cluster(options.keyname, options.verbose)
LocalState.cleanup_appscale_files(options.keyname)
AppScaleLogger.success("Successfully shut down your AppScale deployment.")
def terminate_instances(cls, options):
"""Stops all services running in an AppScale deployment, and in cloud
deployments, also powers off the instances previously spawned.
Raises:
AppScaleException: If AppScale is not running, and thus can't be
terminated.
"""
try:
infrastructure = LocalState.get_infrastructure(options.keyname)
except IOError:
raise AppScaleException("Cannot find AppScale's configuration for keyname {0}".format(options.keyname))
if infrastructure == "xen" and options.terminate:
raise AppScaleException("Terminate option is invalid for cluster mode.")
if infrastructure == "xen" or not options.terminate:
# We are in cluster mode: let's check if AppScale is running.
if not os.path.exists(LocalState.get_secret_key_location(options.keyname)):
raise AppScaleException("AppScale is not running with the keyname {0}".format(options.keyname))
# Stop gracefully the AppScale deployment.
try:
RemoteHelper.terminate_virtualized_cluster(options.keyname, options.verbose)
except (IOError, AppScaleException):
# Don't fail if we cannot find the configuration.
pass
# And if we are on a cloud infrastructure, terminate instances if
# asked.
if infrastructure in InfrastructureAgentFactory.VALID_AGENTS and options.terminate:
RemoteHelper.terminate_cloud_infrastructure(options.keyname, options.verbose)
def terminate_cloud_infrastructure(cls, keyname, is_verbose):
"""Powers off all machines in the currently running AppScale deployment.
Args:
keyname: The name of the SSH keypair used for this AppScale deployment.
is_verbose: A bool that indicates if we should print the commands executed
to stdout.
"""
AppScaleLogger.log("About to terminate deployment and instances with "
"keyname {0}. Press Ctrl-C to stop.".format(keyname))
# This sleep is here to allow a moment for user to Ctrl-C
time.sleep(2)
# get all the instance IDs for machines in our deployment
agent = InfrastructureAgentFactory.create_agent(
LocalState.get_infrastructure(keyname))
params = agent.get_cloud_params(keyname)
params['IS_VERBOSE'] = is_verbose
params['autoscale_agent'] = False
# We want to terminate also the pending instances.
pending = True
_, _, instance_ids = agent.describe_instances(params, pending=pending)
# If using persistent disks, unmount them and detach them before we blow
# away the instances.
nodes = LocalState.get_local_nodes_info(keyname)
for node in nodes:
if node.get('disk'):
AppScaleLogger.log("Unmounting persistent disk at {0}".
format(node['public_ip']))
cls.unmount_persistent_disk(node['public_ip'], keyname, is_verbose)
agent.detach_disk(params, node['disk'], node['instance_id'])
# terminate all the machines
AppScaleLogger.log("Terminating instances spawned with keyname {0}"
.format(keyname))
params[agent.PARAM_INSTANCE_IDS] = instance_ids
agent.terminate_instances(params)
# Delete the network configuration created for the cloud.
agent.cleanup_state(params)
# Cleanup the keyname files created on the local filesystem.
# For GCE and Azure, the keypairs are created on the filesystem,
# rather than the cloud. So we have to clean up afterwards.
LocalState.cleanup_keyname(keyname)
def terminate_instances(cls, options):
"""Stops all services running in an AppScale deployment, and in cloud
deployments, also powers off the instances previously spawned.
Raises:
AppScaleException: If AppScale is not running, and thus can't be
terminated.
"""
try:
infrastructure = LocalState.get_infrastructure(options.keyname)
except IOError:
raise AppScaleException(
"Cannot find AppScale's configuration for keyname {0}".format(
options.keyname))
if infrastructure == "xen" and options.terminate:
raise AppScaleException(
"Terminate option is invalid for cluster mode.")
if infrastructure == "xen" or not options.terminate:
# We are in cluster mode: let's check if AppScale is running.
if not os.path.exists(
LocalState.get_secret_key_location(options.keyname)):
raise AppScaleException(
"AppScale is not running with the keyname {0}".format(
options.keyname))
# Stop gracefully the AppScale deployment.
try:
RemoteHelper.terminate_virtualized_cluster(options.keyname,
options.clean,
options.verbose)
except (IOError, AppScaleException):
# Don't fail if we cannot find the configuration.
pass
# And if we are on a cloud infrastructure, terminate instances if
# asked.
if (infrastructure in InfrastructureAgentFactory.VALID_AGENTS
and options.terminate):
RemoteHelper.terminate_cloud_infrastructure(
options.keyname, options.verbose)
if options.clean:
LocalState.clean_local_metadata(keyname=options.keyname)
def terminate_cloud_infrastructure(cls, keyname, is_verbose):
"""Powers off all machines in the currently running AppScale deployment.
Args:
keyname: The name of the SSH keypair used for this AppScale deployment.
is_verbose: A bool that indicates if we should print the commands executed
to stdout.
"""
AppScaleLogger.log(
"About to terminate deployment and instances with "
"keyname {0}. Press Ctrl-C to stop.".format(keyname))
# This sleep is here to allow a moment for user to Ctrl-C
time.sleep(2)
# get all the instance IDs for machines in our deployment
agent = InfrastructureAgentFactory.create_agent(
LocalState.get_infrastructure(keyname))
params = agent.get_cloud_params(keyname)
params['IS_VERBOSE'] = is_verbose
# We want to terminate also the pending instances.
pending = True
_, _, instance_ids = agent.describe_instances(params, pending=pending)
# If using persistent disks, unmount them and detach them before we blow
# away the instances.
nodes = LocalState.get_local_nodes_info(keyname)
for node in nodes:
if node.get('disk'):
AppScaleLogger.log("Unmounting persistent disk at {0}".format(
node['public_ip']))
cls.unmount_persistent_disk(node['public_ip'], keyname,
is_verbose)
agent.detach_disk(params, node['disk'], node['instance_id'])
# terminate all the machines
AppScaleLogger.log(
"Terminating instances spawned with keyname {0}".format(keyname))
params[agent.PARAM_INSTANCE_IDS] = instance_ids
agent.terminate_instances(params)
# delete the keyname and group
agent.cleanup_state(params)
def terminate_cloud_infrastructure(cls, keyname, is_verbose):
"""Powers off all machines in the currently running AppScale deployment.
Args:
keyname: The name of the SSH keypair used for this AppScale deployment.
is_verbose: A bool that indicates if we should print the commands executed
to stdout.
"""
AppScaleLogger.log("About to terminate instances spawned with keyname {0}"
.format(keyname))
# This sleep is here to allow a moment for user to Ctrl-C
time.sleep(2)
# get all the instance IDs for machines in our deployment
agent = InfrastructureAgentFactory.create_agent(
LocalState.get_infrastructure(keyname))
params = agent.get_params_from_yaml(keyname)
params['IS_VERBOSE'] = is_verbose
# We want to terminate also the pending instances.
pending = True
_, _, instance_ids = agent.describe_instances(params, pending=pending)
# If using persistent disks, unmount them and detach them before we blow
# away the instances.
cls.terminate_virtualized_cluster(keyname, is_verbose)
nodes = LocalState.get_local_nodes_info(keyname)
for node in nodes:
if node.get('disk'):
AppScaleLogger.log("Unmounting persistent disk at {0}".format(
node['public_ip']))
cls.unmount_persistent_disk(node['public_ip'], keyname, is_verbose)
agent.detach_disk(params, node['disk'], node['instance_id'])
# terminate all the machines
params[agent.PARAM_INSTANCE_IDS] = instance_ids
agent.terminate_instances(params)
# delete the keyname and group
agent.cleanup_state(params)
def terminate_instances(cls, options):
"""Stops all services running in an AppScale deployment, and in cloud
deployments, also powers off the instances previously spawned.
Raises:
AppScaleException: If AppScale is not running, and thus can't be
terminated.
"""
if not os.path.exists(LocalState.get_locations_yaml_location(
options.keyname)):
raise AppScaleException("AppScale is not running with the keyname {0}".
format(options.keyname))
if LocalState.get_infrastructure(options.keyname) in \
InfrastructureAgentFactory.VALID_AGENTS:
RemoteHelper.terminate_cloud_infrastructure(options.keyname,
options.verbose)
else:
RemoteHelper.terminate_virtualized_cluster(options.keyname,
options.verbose)
LocalState.cleanup_appscale_files(options.keyname)
AppScaleLogger.success("Successfully shut down your AppScale deployment.")
def down(self, clean=False, terminate=False):
""" 'down' provides a nicer experience for users than the
appscale-terminate-instances command, by using the configuration options
present in the AppScalefile found in the current working directory.
Args:
clean: A boolean to indicate if the deployment data and metadata
needs to be clean. This will clear the datastore.
terminate: A boolean to indicate if instances needs to be terminated
(valid only if we spawn instances at start).
Raises:
AppScalefileException: If there is no AppScalefile in the current working
directory.
"""
contents = self.read_appscalefile()
# Construct a terminate-instances command from the file's contents
command = []
contents_as_yaml = yaml.safe_load(contents)
if 'verbose' in contents_as_yaml and contents_as_yaml[
'verbose'] == True:
is_verbose = contents_as_yaml['verbose']
command.append("--verbose")
else:
is_verbose = False
if 'keyname' in contents_as_yaml:
keyname = contents_as_yaml['keyname']
command.append("--keyname")
command.append(contents_as_yaml['keyname'])
else:
keyname = 'appscale'
if "EC2_ACCESS_KEY" in contents_as_yaml:
os.environ["EC2_ACCESS_KEY"] = contents_as_yaml["EC2_ACCESS_KEY"]
if "EC2_SECRET_KEY" in contents_as_yaml:
os.environ["EC2_SECRET_KEY"] = contents_as_yaml["EC2_SECRET_KEY"]
if "EC2_URL" in contents_as_yaml:
os.environ["EC2_URL"] = contents_as_yaml["EC2_URL"]
if clean:
if 'test' not in contents_as_yaml or contents_as_yaml[
'test'] != True:
LocalState.confirm_or_abort(
"Clean will delete every data in the deployment.")
all_ips = LocalState.get_all_public_ips(keyname)
for ip in all_ips:
RemoteHelper.ssh(ip, keyname, self.TERMINATE, is_verbose)
AppScaleLogger.success(
"Successfully cleaned your AppScale deployment.")
if terminate:
infrastructure = LocalState.get_infrastructure(keyname)
if infrastructure != "xen" and not LocalState.are_disks_used(
keyname) and 'test' not in contents_as_yaml:
LocalState.confirm_or_abort(
"Terminate will delete instances and the data on them.")
command.append("--terminate")
if 'test' in contents_as_yaml and contents_as_yaml['test'] == True:
command.append("--test")
# Finally, exec the command. Don't worry about validating it -
# appscale-terminate-instances will do that for us.
options = ParseArgs(command, "appscale-terminate-instances").args
AppScaleTools.terminate_instances(options)
LocalState.cleanup_appscale_files(keyname, terminate)
AppScaleLogger.success(
"Successfully shut down your AppScale deployment.")
def down(self, clean=False, terminate=False):
""" 'down' provides a nicer experience for users than the
appscale-terminate-instances command, by using the configuration options
present in the AppScalefile found in the current working directory.
Args:
clean: A boolean to indicate if the deployment data and metadata
needs to be clean. This will clear the datastore.
terminate: A boolean to indicate if instances needs to be terminated
(valid only if we spawn instances at start).
Raises:
AppScalefileException: If there is no AppScalefile in the current working
directory.
"""
contents = self.read_appscalefile()
# Construct a terminate-instances command from the file's contents
command = []
contents_as_yaml = yaml.safe_load(contents)
if 'verbose' in contents_as_yaml and contents_as_yaml['verbose'] == True:
is_verbose = contents_as_yaml['verbose']
command.append("--verbose")
else:
is_verbose = False
if 'keyname' in contents_as_yaml:
keyname = contents_as_yaml['keyname']
command.append("--keyname")
command.append(contents_as_yaml['keyname'])
else:
keyname = 'appscale'
if "EC2_ACCESS_KEY" in contents_as_yaml:
os.environ["EC2_ACCESS_KEY"] = contents_as_yaml["EC2_ACCESS_KEY"]
if "EC2_SECRET_KEY" in contents_as_yaml:
os.environ["EC2_SECRET_KEY"] = contents_as_yaml["EC2_SECRET_KEY"]
if "EC2_URL" in contents_as_yaml:
os.environ["EC2_URL"] = contents_as_yaml["EC2_URL"]
if clean:
if 'test' not in contents_as_yaml or contents_as_yaml['test'] != True:
LocalState.confirm_or_abort("Clean will delete every data in the deployment.")
all_ips = LocalState.get_all_public_ips(keyname)
for ip in all_ips:
RemoteHelper.ssh(ip, keyname, self.TERMINATE, is_verbose)
AppScaleLogger.success("Successfully cleaned your AppScale deployment.")
if terminate:
infrastructure = LocalState.get_infrastructure(keyname)
if infrastructure != "xen" and not LocalState.are_disks_used(
keyname) and 'test' not in contents_as_yaml:
LocalState.confirm_or_abort("Terminate will delete instances and the data on them.")
command.append("--terminate")
if 'test' in contents_as_yaml and contents_as_yaml['test'] == True:
command.append("--test")
# Finally, exec the command. Don't worry about validating it -
# appscale-terminate-instances will do that for us.
options = ParseArgs(command, "appscale-terminate-instances").args
AppScaleTools.terminate_instances(options)
LocalState.cleanup_appscale_files(keyname, terminate)
AppScaleLogger.success("Successfully shut down your AppScale deployment.")
