"""Return a formatted string of a server's networks

output = []

for (network, addresses) in networks.items():

if not addresses:

continue

addresses_csv = ', '.join(addresses)

group = "%s=%s" % (network, addresses_csv)

output.append(group)

"""Prepare the detailed server dict for printing

info = server._info.copy()

# Call .get() to retrieve all of the server information

# as findall(name=blah) and REST /details are not the same

# and do not return flavor and image information.

server = compute_client.servers.get(info['id'])

info.update(server._info)

# Convert the image blob to a name

image_info = info.get('image', {})

if image_info:

image_id = image_info.get('id', '')

image = utils.find_resource(compute_client.images, image_id)

info['image'] = "%s (%s)" % (image.name, image_id)

# Convert the flavor blob to a name

flavor_info = info.get('flavor', {})

flavor_id = flavor_info.get('id', '')

flavor = utils.find_resource(compute_client.flavors, flavor_id)

info['flavor'] = "%s (%s)" % (flavor.name, flavor_id)

# NOTE(dtroyer): novaclient splits these into separate entries...

# Format addresses in a useful way

info['addresses'] = _format_servers_list_networks(server.networks)

# Map 'metadata' field to 'properties'

info.update(

{'properties': utils.format_dict(info.pop('metadata'))}

)

# Remove values that are long and not too useful

info.pop('links', None)

"""Add security group to server"""

log = logging.getLogger(__name__ + '.AddServerSecurityGroup')

def get_parser(self, prog_name):

parser = super(AddServerSecurityGroup, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

parser.add_argument(

'group',

metavar='<group>',

help=_('Security group to add (name or ID)'),

)

return parser

def take_action(self, parsed_args):

self.log.debug("take_action(%s)", parsed_args)

compute_client = self.app.client_manager.compute

server = utils.find_resource(

compute_client.servers,

parsed_args.server,

)

security_group = utils.find_resource(

compute_client.security_groups,

parsed_args.group,

)

server.add_security_group(security_group.name)

"""Add volume to server"""

log = logging.getLogger(__name__ + '.AddServerVolume')

def get_parser(self, prog_name):

parser = super(AddServerVolume, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

parser.add_argument(

'volume',

metavar='<volume>',

help=_('Volume to add (name or ID)'),

)

parser.add_argument(

'--device',

metavar='<device>',

help=_('Server internal device name for volume'),

)

return parser

def take_action(self, parsed_args):

self.log.debug("take_action(%s)", parsed_args)

compute_client = self.app.client_manager.compute

volume_client = self.app.client_manager.volume

server = utils.find_resource(

compute_client.servers,

parsed_args.server,

)

volume = utils.find_resource(

volume_client.volumes,

parsed_args.volume,

)

compute_client.volumes.create_server_volume(

server.id,

volume.id,

parsed_args.device,

"""Create a new server"""

log = logging.getLogger(__name__ + '.CreateServer')

def get_parser(self, prog_name):

parser = super(CreateServer, self).get_parser(prog_name)

parser.add_argument(

'server_name',

metavar='<server-name>',

help=_('New server name'),

)

disk_group = parser.add_mutually_exclusive_group(

required=True,

)

disk_group.add_argument(

'--image',

metavar='<image>',

help=_('Create server from this image'),

)

disk_group.add_argument(

'--volume',

metavar='<volume>',

help=_('Create server from this volume'),

)

parser.add_argument(

'--flavor',

metavar='<flavor>',

required=True,

help=_('Create server with this flavor'),

)

parser.add_argument(

'--security-group',

metavar='<security-group-name>',

action='append',

default=[],

help=_('Security group to assign to this server '

'(repeat for multiple groups)'),

)

parser.add_argument(

'--key-name',

metavar='<key-name>',

help=_('Keypair to inject into this server (optional extension)'),

)

parser.add_argument(

'--property',

metavar='<key=value>',

action=parseractions.KeyValueAction,

help=_('Set a property on this server '

'(repeat for multiple values)'),

)

parser.add_argument(

'--file',

metavar='<dest-filename=source-filename>',

action='append',

default=[],

help=_('File to inject into image before boot '

'(repeat for multiple files)'),

)

parser.add_argument(

'--user-data',

metavar='<user-data>',

help=_('User data file to serve from the metadata server'),

)

parser.add_argument(

'--availability-zone',

metavar='<zone-name>',

help=_('Select an availability zone for the server'),

)

parser.add_argument(

'--block-device-mapping',

metavar='<dev-name=mapping>',

action='append',

default=[],

help=_('Map block devices; map is '

'<id>:<type>:<size(GB)>:<delete_on_terminate> '

'(optional extension)'),

)

parser.add_argument(

'--nic',

metavar='<nic-config-string>',

action='append',

default=[],

help=_('Specify NIC configuration (optional extension)'),

)

parser.add_argument(

'--hint',

metavar='<key=value>',

action='append',

default=[],

help=_('Hints for the scheduler (optional extension)'),

)

parser.add_argument(

'--config-drive',

metavar='<config-drive-volume>|True',

default=False,

help=_('Use specified volume as the config drive, '

'or \'True\' to use an ephemeral drive'),

)

parser.add_argument(

'--min',

metavar='<count>',

type=int,

default=1,

help=_('Minimum number of servers to launch (default=1)'),

)

parser.add_argument(

'--max',

metavar='<count>',

type=int,

default=1,

help=_('Maximum number of servers to launch (default=1)'),

)

parser.add_argument(

'--wait',

action='store_true',

help=_('Wait for build to complete'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

volume_client = self.app.client_manager.volume

# Lookup parsed_args.image

image = None

if parsed_args.image:

image = utils.find_resource(

compute_client.images,

parsed_args.image,

)

# Lookup parsed_args.volume

volume = None

if parsed_args.volume:

volume = utils.find_resource(

volume_client.volumes,

parsed_args.volume,

).id

# Lookup parsed_args.flavor

flavor = utils.find_resource(compute_client.flavors,

parsed_args.flavor)

boot_args = [parsed_args.server_name, image, flavor]

files = {}

for f in parsed_args.file:

dst, src = f.split('=', 1)

try:

files[dst] = io.open(src, 'rb')

except IOError as e:

raise exceptions.CommandError("Can't open '%s': %s" % (src, e))

if parsed_args.min > parsed_args.max:

msg = _("min instances should be <= max instances")

raise exceptions.CommandError(msg)

if parsed_args.min < 1:

msg = _("min instances should be > 0")

raise exceptions.CommandError(msg)

if parsed_args.max < 1:

msg = _("max instances should be > 0")

raise exceptions.CommandError(msg)

userdata = None

if parsed_args.user_data:

try:

userdata = io.open(parsed_args.user_data)

except IOError as e:

msg = "Can't open '%s': %s"

raise exceptions.CommandError(msg % (parsed_args.user_data, e))

block_device_mapping = {}

if volume:

# When booting from volume, for now assume no other mappings

# This device value is likely KVM-specific

block_device_mapping = {'vda': volume}

else:

for dev_map in parsed_args.block_device_mapping:

dev_key, dev_vol = dev_map.split('=', 1)

block_volume = None

if dev_vol:

block_volume = utils.find_resource(

volume_client.volumes,

dev_vol,

).id

block_device_mapping.update({dev_key: block_volume})

nics = []

for nic_str in parsed_args.nic:

nic_info = {"net-id": "", "v4-fixed-ip": ""}

nic_info.update(dict(kv_str.split("=", 1)

for kv_str in nic_str.split(",")))

nics.append(nic_info)

hints = {}

for hint in parsed_args.hint:

key, _sep, value = hint.partition('=')

# NOTE(vish): multiple copies of the same hint will

# result in a list of values

if key in hints:

if isinstance(hints[key], six.string_types):

hints[key] = [hints[key]]

hints[key] += [value]

else:

hints[key] = value

# What does a non-boolean value for config-drive do?

# --config-drive argument is either a volume id or

# 'True' (or '1') to use an ephemeral volume

if str(parsed_args.config_drive).lower() in ("true", "1"):

config_drive = True

elif str(parsed_args.config_drive).lower() in ("false", "0",

"", "none"):

config_drive = None

else:

config_drive = parsed_args.config_drive

boot_kwargs = dict(

meta=parsed_args.property,

files=files,

reservation_id=None,

min_count=parsed_args.min,

max_count=parsed_args.max,

security_groups=parsed_args.security_group,

userdata=userdata,

key_name=parsed_args.key_name,

availability_zone=parsed_args.availability_zone,

block_device_mapping=block_device_mapping,

nics=nics,

scheduler_hints=hints,

config_drive=config_drive)

self.log.debug('boot_args: %s', boot_args)

self.log.debug('boot_kwargs: %s', boot_kwargs)

# Wrap the call to catch exceptions in order to close files

try:

server = compute_client.servers.create(*boot_args, **boot_kwargs)

finally:

# Clean up open files - make sure they are not strings

for f in files:

if hasattr(f, 'close'):

f.close()

if hasattr(userdata, 'close'):

userdata.close()

if parsed_args.wait:

if utils.wait_for_status(

compute_client.servers.get,

server.id,

callback=_show_progress,

):

sys.stdout.write('\n')

else:

self.log.error(_('Error creating server: %s'),

parsed_args.server_name)

sys.stdout.write(_('\nError creating server'))

raise SystemExit

details = _prep_server_detail(compute_client, server)

"""Create a new disk image from a running server"""

log = logging.getLogger(__name__ + '.CreateServerImage')

def get_parser(self, prog_name):

parser = super(CreateServerImage, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

parser.add_argument(

'--name',

metavar='<image-name>',

help=_('Name of new image (default is server name)'),

)

parser.add_argument(

'--wait',

action='store_true',

help=_('Wait for image create to complete'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

image_client = self.app.client_manager.image

server = utils.find_resource(

compute_client.servers,

parsed_args.server,

)

if parsed_args.name:

name = parsed_args.name

else:

name = server.name

image_id = compute_client.servers.create_image(

server,

name,

)

if parsed_args.wait:

if utils.wait_for_status(

image_client.images.get,

image_id,

callback=_show_progress,

):

sys.stdout.write('\n')

else:

self.log.error(_('Error creating server snapshot: %s'),

parsed_args.image_name)

sys.stdout.write(_('\nError creating server snapshot'))

raise SystemExit

image = utils.find_resource(

image_client.images,

image_id,

)

"""Delete server command"""

log = logging.getLogger(__name__ + '.DeleteServer')

def get_parser(self, prog_name):

parser = super(DeleteServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

server = utils.find_resource(

compute_client.servers, parsed_args.server)

compute_client.servers.delete(server.id)

"""List servers"""

log = logging.getLogger(__name__ + '.ListServer')

def get_parser(self, prog_name):

parser = super(ListServer, self).get_parser(prog_name)

parser.add_argument(

'--reservation-id',

metavar='<reservation-id>',

help=_('Only return instances that match the reservation'),

)

parser.add_argument(

'--ip',

metavar='<ip-address-regex>',

help=_('Regular expression to match IP addresses'),

)

parser.add_argument(

'--ip6',

metavar='<ip-address-regex>',

help=_('Regular expression to match IPv6 addresses'),

)

parser.add_argument(

'--name',

metavar='<name-regex>',

help=_('Regular expression to match names'),

)

parser.add_argument(

'--instance-name',

metavar='<server-name>',

help=_('Regular expression to match instance name (admin only)'),

)

parser.add_argument(

'--status',

metavar='<status>',

# FIXME(dhellmann): Add choices?

help=_('Search by server status'),

)

parser.add_argument(

'--flavor',

metavar='<flavor>',

help=_('Search by flavor'),

)

parser.add_argument(

'--image',

metavar='<image>',

help=_('Search by image'),

)

parser.add_argument(

'--host',

metavar='<hostname>',

help=_('Search by hostname'),

)

parser.add_argument(

'--all-projects',

action='store_true',

default=bool(int(os.environ.get("ALL_PROJECTS", 0))),

help=_('Include all projects (admin only)'),

)

parser.add_argument(

'--long',

action='store_true',

default=False,

help=_('List additional fields in output'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

search_opts = {

'reservation_id': parsed_args.reservation_id,

'ip': parsed_args.ip,

'ip6': parsed_args.ip6,

'name': parsed_args.name,

'instance_name': parsed_args.instance_name,

'status': parsed_args.status,

'flavor': parsed_args.flavor,

'image': parsed_args.image,

'host': parsed_args.host,

'all_tenants': parsed_args.all_projects,

}

self.log.debug('search options: %s', search_opts)

if parsed_args.long:

columns = (

'ID',

'Name',

'Status',

'Networks',

'OS-EXT-AZ:availability_zone',

'OS-EXT-SRV-ATTR:host',

'Metadata',

)

column_headers = (

'ID',

'Name',

'Status',

'Networks',

'Availability Zone',

'Host',

'Properties',

)

mixed_case_fields = [

'OS-EXT-AZ:availability_zone',

'OS-EXT-SRV-ATTR:host',

]

else:

columns = ('ID', 'Name', 'Status', 'Networks')

column_headers = columns

mixed_case_fields = []

data = compute_client.servers.list(search_opts=search_opts)

return (column_headers,

(utils.get_item_properties(

s, columns,

mixed_case_fields=mixed_case_fields,

formatters={

'Networks': _format_servers_list_networks,

'Metadata': utils.format_dict,

},

"""Lock server"""

log = logging.getLogger(__name__ + '.LockServer')

def get_parser(self, prog_name):

parser = super(LockServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

utils.find_resource(

compute_client.servers,

parsed_args.server,

"""Migrate server to different host"""

log = logging.getLogger(__name__ + '.MigrateServer')

def get_parser(self, prog_name):

parser = super(MigrateServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

parser.add_argument(

'--live',

metavar='<hostname>',

help=_('Target hostname'),

)

migration_group = parser.add_mutually_exclusive_group()

migration_group.add_argument(

'--shared-migration',

dest='shared_migration',

action='store_true',

default=True,

help=_('Perform a shared live migration (default)'),

)

migration_group.add_argument(

'--block-migration',

dest='shared_migration',

action='store_false',

help=_('Perform a block live migration'),

)

disk_group = parser.add_mutually_exclusive_group()

disk_group.add_argument(

'--disk-overcommit',

action='store_true',

default=False,

help=_('Allow disk over-commit on the destination host'),

)

disk_group.add_argument(

'--no-disk-overcommit',

dest='disk_overcommit',

action='store_false',

default=False,

help=_('Do not over-commit disk on the'

' destination host (default)'),

)

parser.add_argument(

'--wait',

action='store_true',

help=_('Wait for resize to complete'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

server = utils.find_resource(

compute_client.servers,

parsed_args.server,

)

if parsed_args.live:

server.live_migrate(

parsed_args.live,

parsed_args.shared_migration,

parsed_args.disk_overcommit,

)

else:

server.migrate()

if parsed_args.wait:

if utils.wait_for_status(

compute_client.servers.get,

server.id,

callback=_show_progress,

):

sys.stdout.write(_('Complete\n'))

else:

sys.stdout.write(_('\nError migrating server'))

"""Pause server"""

log = logging.getLogger(__name__ + '.PauseServer')

def get_parser(self, prog_name):

parser = super(PauseServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

utils.find_resource(

compute_client.servers,

parsed_args.server,

"""Perform a hard or soft server reboot"""

log = logging.getLogger(__name__ + '.RebootServer')

def get_parser(self, prog_name):

parser = super(RebootServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

group = parser.add_mutually_exclusive_group()

group.add_argument(

'--hard',

dest='reboot_type',

action='store_const',

const=servers.REBOOT_HARD,

default=servers.REBOOT_SOFT,

help=_('Perform a hard reboot'),

)

group.add_argument(

'--soft',

dest='reboot_type',

action='store_const',

const=servers.REBOOT_SOFT,

default=servers.REBOOT_SOFT,

help=_('Perform a soft reboot'),

)

parser.add_argument(

'--wait',

action='store_true',

help=_('Wait for reboot to complete'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

server = utils.find_resource(

compute_client.servers, parsed_args.server)

server.reboot(parsed_args.reboot_type)

if parsed_args.wait:

if utils.wait_for_status(

compute_client.servers.get,

server.id,

callback=_show_progress,

):

sys.stdout.write(_('\nReboot complete\n'))

else:

sys.stdout.write(_('\nError rebooting server\n'))

"""Rebuild server"""

log = logging.getLogger(__name__ + '.RebuildServer')

def get_parser(self, prog_name):

parser = super(RebuildServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

parser.add_argument(

'--image',

metavar='<image>',

required=True,

help=_('Recreate server from this image'),

)

parser.add_argument(

'--password',

metavar='<password>',

help="Set the password on the rebuilt instance",

)

parser.add_argument(

'--wait',

action='store_true',

help=_('Wait for rebuild to complete'),

)

return parser

def take_action(self, parsed_args):

self.log.debug('take_action(%s)', parsed_args)

compute_client = self.app.client_manager.compute

# Lookup parsed_args.image

image = utils.find_resource(compute_client.images, parsed_args.image)

server = utils.find_resource(

compute_client.servers, parsed_args.server)

server = server.rebuild(image, parsed_args.password)

if parsed_args.wait:

if utils.wait_for_status(

compute_client.servers.get,

server.id,

callback=_show_progress,

):

sys.stdout.write(_('\nComplete\n'))

else:

sys.stdout.write(_('\nError rebuilding server'))

raise SystemExit

details = _prep_server_detail(compute_client, server)

"""Remove security group from server"""

log = logging.getLogger(__name__ + '.RemoveServerSecurityGroup')

def get_parser(self, prog_name):

parser = super(RemoveServerSecurityGroup, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Name or ID of server to use'),

)

parser.add_argument(

'group',

metavar='<group>',

help=_('Name or ID of security group to remove from server'),

)

return parser

def take_action(self, parsed_args):

self.log.debug("take_action(%s)", parsed_args)

compute_client = self.app.client_manager.compute

server = utils.find_resource(

compute_client.servers,

parsed_args.server,

)

security_group = utils.find_resource(

compute_client.security_groups,

parsed_args.group,

)

"""Remove volume from server"""

log = logging.getLogger(__name__ + '.RemoveServerVolume')

def get_parser(self, prog_name):

parser = super(RemoveServerVolume, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

parser.add_argument(

'volume',

metavar='<volume>',

help=_('Volume to remove (name or ID)'),

)

return parser

def take_action(self, parsed_args):

self.log.debug("take_action(%s)", parsed_args)

compute_client = self.app.client_manager.compute

volume_client = self.app.client_manager.volume

server = utils.find_resource(

compute_client.servers,

parsed_args.server,

)

volume = utils.find_resource(

volume_client.volumes,

parsed_args.volume,

)

compute_client.volumes.delete_server_volume(

server.id,

volume.id,

"""Put server in rescue mode"""

log = logging.getLogger(__name__ + '.RescueServer')

def get_parser(self, prog_name):

parser = super(RescueServer, self).get_parser(prog_name)

parser.add_argument(

'server',

metavar='<server>',

help=_('Server (name or ID)'),

)

return parser