RubyGems - gcloud - Versions diffs - 0.0.7 → 0.1.0 - Mend

gcloud 0.0.7 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (998) hide show

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/image_cmds.pyc DELETED Viewed

Binary file

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/image_cmds_test.py DELETED Viewed

@@ -1,172 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Unit tests for the machine image commands."""
-import path_initializer
-path_initializer.InitializeSysPath()
-import copy
-import gflags as flags
-import unittest
-from gcutil import command_base
-from gcutil import image_cmds
-from gcutil import mock_api
-FLAGS = flags.FLAGS
-class ImageCmdsTest(unittest.TestCase):
-  def _doTestAddImageGeneratesCorrectRequest(self, service_version,
-                                             requested_source,
-                                             expected_source):
-    flag_values = copy.deepcopy(FLAGS)
-    command = image_cmds.AddImage('addimage', flag_values)
-    expected_project = 'test_project'
-    expected_image = 'test_image'
-    expected_description = 'test image'
-    submitted_kernel = 'projects/test_project/kernels/test_kernel'
-    expected_type = 'RAW'
-    flag_values.project = expected_project
-    flag_values.description = expected_description
-    flag_values.preferred_kernel = submitted_kernel
-    flag_values.service_version = service_version
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    expected_kernel = command.NormalizeGlobalResourceName(expected_project,
-                                                          'kernels',
-                                                          submitted_kernel)
-    result = command.Handle(expected_image, requested_source)
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['body']['name'], expected_image)
-    self.assertEqual(result['body']['description'], expected_description)
-    self.assertEqual(result['body']['preferredKernel'], expected_kernel)
-    self.assertEqual(result['body']['sourceType'], expected_type)
-    self.assertEqual(result['body']['rawDisk']['source'], expected_source)
-  def testAddImageGeneratesCorrectRequest(self):
-    for version in command_base.SUPPORTED_VERSIONS:
-      self._doTestAddImageGeneratesCorrectRequest(
-          version, 'http://test.source', 'http://test.source')
-      self._doTestAddImageGeneratesCorrectRequest(
-          version, 'gs://test_bucket/source',
-          'http://storage.googleapis.com/test_bucket/source')
-  def testGetImageGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = image_cmds.GetImage('getimage', flag_values)
-    expected_project = 'test_project'
-    expected_image = 'test_image'
-    flag_values.project = expected_project
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    result = command.Handle(expected_image)
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['image'], expected_image)
-  def testDeleteImageGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = image_cmds.DeleteImage('deleteimage', flag_values)
-    expected_project = 'test_project'
-    expected_image = 'test_image'
-    flag_values.project = expected_project
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._credential = mock_api.MockCredential()
-    results, exceptions = command.Handle(expected_image)
-    self.assertEqual(exceptions, [])
-    self.assertEqual(len(results['items']), 1)
-    result = results['items'][0]
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['image'], expected_image)
-  def testDeleteMultipleImages(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = image_cmds.DeleteImage('deleteimage', flag_values)
-    expected_project = 'test_project'
-    expected_images = ['test-image-%02d' % x for x in xrange(100)]
-    flag_values.project = expected_project
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._credential = mock_api.MockCredential()
-    results, exceptions = command.Handle(*expected_images)
-    self.assertEqual(exceptions, [])
-    results = results['items']
-    self.assertEqual(len(results), len(expected_images))
-    for expected_image, result in zip(expected_images, results):
-      self.assertEqual(result['project'], expected_project)
-      self.assertEqual(result['image'], expected_image)
-  def testDeprecate(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = image_cmds.Deprecate('deprecateimage', flag_values)
-    expected_project = 'test_project'
-    expected_image = 'test_image'
-    expected_state = 'DEPRECATED'
-    expected_replacement = 'replacement_image'
-    expected_obsolete_timestamp = '1970-01-01T00:00:00Z'
-    expected_deleted_timestamp = '1980-01-01T00:00:00.000Z'
-    flag_values.project = expected_project
-    flag_values.state = expected_state
-    flag_values.replacement = expected_replacement
-    flag_values.obsolete_on = expected_obsolete_timestamp
-    flag_values.deleted_on = expected_deleted_timestamp
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    result = command.Handle(expected_image)
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['image'], expected_image)
-    self.assertEqual(result['body']['state'], expected_state)
-    self.assertEqual(result['body']['replacement'],
-                     command.NormalizeGlobalResourceName(
-                         expected_project, 'images', expected_replacement))
-    self.assertEqual(result['body']['obsolete'], expected_obsolete_timestamp)
-    self.assertEqual(result['body']['deleted'], expected_deleted_timestamp)
-if __name__ == '__main__':
-  unittest.main()

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/instance_cmds.py DELETED Viewed

@@ -1,1506 +0,0 @@
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Commands for interacting with Google Compute Engine VM instances."""
-import logging
-import os
-import time
-from apiclient import errors
-from google.apputils import app
-from google.apputils import appcommands
-import gflags as flags
-from gcutil import command_base
-from gcutil import gcutil_logging
-from gcutil import metadata
-from gcutil import scopes
-from gcutil import ssh_keys
-FLAGS = flags.FLAGS
-LOGGER = gcutil_logging.LOGGER
-class InstanceCommand(command_base.GoogleComputeCommand):
-  """Base command for working with the instances collection."""
-  default_sort_field = 'name'
-  summary_fields = (('name', 'name'),
-                    ('machine-type', 'machineType'),
-                    ('image', 'image'),
-                    ('network', 'networkInterfaces.network'),
-                    ('network-ip', 'networkInterfaces.networkIP'),
-                    ('external-ip', 'networkInterfaces.accessConfigs.natIP'),
-                    ('disks', 'disks.source'),
-                    ('zone', 'zone'),
-                    ('status', 'status'),
-                    ('status-message', 'statusMessage'))
-  # The remaining complex fields are filled in via CustomizePrintResult
-  detail_fields = (('name', 'name'),
-                   ('description', 'description'),
-                   ('creation-time', 'creationTimestamp'),
-                   ('machine', 'machineType'),
-                   ('image', 'image'),
-                   ('zone', 'zone'),
-                   ('tags-fingerprint', 'tags.fingerprint'),
-                   ('metadata-fingerprint', 'metadata.fingerprint'),
-                   ('status', 'status'),
-                   ('status-message', 'statusMessage'))
-  # A map from legal values for the disk "mode" option to the
-  # corresponding API value. Keys in this map should be lowercase, as
-  # we convert user provided values to lowercase prior to performing a
-  # look-up.
-  disk_modes = {
-      'read_only': 'READ_ONLY',
-      'ro': 'READ_ONLY',
-      'read_write': 'READ_WRITE',
-      'rw': 'READ_WRITE'}
-  resource_collection_name = 'instances'
-  # The default network interface name assigned by the service.
-  DEFAULT_NETWORK_INTERFACE_NAME = 'nic0'
-  # The default access config name
-  DEFAULT_ACCESS_CONFIG_NAME = 'External NAT'
-  # Currently, only access config type 'ONE_TO_ONE_NAT' is supported.
-  ONE_TO_ONE_NAT_ACCESS_CONFIG_TYPE = 'ONE_TO_ONE_NAT'
-  # Let the server select an ephemeral IP address.
-  EPHEMERAL_ACCESS_CONFIG_NAT_IP = 'ephemeral'
-  def __init__(self, name, flag_values):
-    super(InstanceCommand, self).__init__(name, flag_values)
-    flags.DEFINE_string('zone',
-                        None,
-                        'The zone for this request.',
-                        flag_values=flag_values)
-  def SetApi(self, api):
-    """Set the Google Compute Engine API for the command.
-    Args:
-      api: The Google Compute Engine API used by this command.
-    Returns:
-      None.
-    """
-    self._projects_api = api.projects()
-    self._instances_api = api.instances()
-    self._images_api = api.images()
-    self._kernels_api = api.kernels()
-    self._disks_api = api.disks()
-    self._machine_types_api = api.machineTypes()
-    self._zones_api = api.zones()
-  def CustomizePrintResult(self, result, table):
-    """Customized result printing for this type.
-    Args:
-      result: json dictionary returned by the server
-      table: the pretty printing table to be customized
-    Returns:
-      None.
-    """
-    # Add the disks
-    for disk in result.get('disks', []):
-      table.AddRow(('', ''))
-      table.AddRow(('disk', disk['index']))
-      table.AddRow(('  type', disk['type']))
-      if 'mode' in disk:
-        table.AddRow(('  mode', disk['mode']))
-      if 'deviceName' in disk:
-        table.AddRow(('  deviceName', disk['deviceName']))
-      if 'source' in disk:
-        table.AddRow(('  source', disk['source']))
-      if 'boot' in disk:
-        table.AddRow(('  boot', disk['boot']))
-      if 'deleteOnTerminate' in disk:
-        table.AddRow(('  delete on terminate', disk['deleteOnTerminate']))
-    # Add the networks
-    for network in result.get('networkInterfaces', []):
-      table.AddRow(('', ''))
-      table.AddRow(('network-interface', ''))
-      table.AddRow(('  network',
-                    self._PresentElement(network.get('network', ''))))
-      table.AddRow(('  ip', network.get('networkIP', '')))
-      for config in network.get('accessConfigs', []):
-        table.AddRow(('  access-configuration', config.get('name', '')))
-        table.AddRow(('    type', config.get('type', '')))
-        table.AddRow(('    external-ip', config.get('natIP', '')))
-    # Add the service accounts
-    for service_account in result.get('serviceAccounts', []):
-      table.AddRow(('', ''))
-      table.AddRow(('service-account', service_account.get('email', '')))
-      table.AddRow(('  scopes', service_account.get('scopes', '')))
-    # Add metadata
-    if result.get('metadata', []):
-      table.AddRow(('', ''))
-      table.AddRow(('metadata', ''))
-      table.AddRow(('fingerprint', result.get('metadata', {})
-                    .get('fingerprint', '')))
-      metadata_container = result.get('metadata', {}).get('items', [])
-      for i in metadata_container:
-        table.AddRow(('  %s' % i.get('key', ''),
-                      self._PresentElement(i.get('value', ''))))
-    # Add tags
-    if result.get('tags', []):
-      table.AddRow(('', ''))
-      table.AddRow(('tags', ''))
-      table.AddRow(('fingerprint', result.get('tags', {})
-                    .get('fingerprint', '')))
-      tags_container = result.get('tags', {}).get('items', [])
-      for i in tags_container:
-        table.AddRow(('   ',
-                      self._PresentElement(i)))
-  def _ExtractExternalIpFromInstanceRecord(self, instance_record):
-    """Extract the external IP(s) from an instance record.
-    Args:
-      instance_record: An instance as returned by the Google Compute Engine API.
-    Returns:
-      A list of internet IP addresses associated with this VM.
-    """
-    external_ips = set()
-    for network_interface in instance_record.get('networkInterfaces', []):
-      for access_config in network_interface.get('accessConfigs', []):
-        # At the moment, we only know how to translate 1-to-1 NAT
-        if (access_config.get('type') == self.ONE_TO_ONE_NAT_ACCESS_CONFIG_TYPE
-            and 'natIP' in access_config):
-          external_ips.add(access_config['natIP'])
-    return list(external_ips)
-  def _AddAuthorizedUserKeyToProject(self, authorized_user_key):
-    """Update the project to include the specified user/key pair.
-    Args:
-      authorized_user_key: A dictionary of a user/key pair for the user.
-    Returns:
-      True iff the ssh key was added to the project.
-    Raises:
-      command_base.CommandError: If the metadata update fails.
-    """
-    project = self._projects_api.get(project=self._project).execute()
-    common_instance_metadata = project.get('commonInstanceMetadata', {})
-    project_metadata = common_instance_metadata.get(
-        'items', [])
-    project_ssh_keys = ssh_keys.SshKeys.GetAuthorizedUserKeysFromMetadata(
-        project_metadata)
-    if authorized_user_key in project_ssh_keys:
-      return False
-    else:
-      project_ssh_keys.append(authorized_user_key)
-      ssh_keys.SshKeys.SetAuthorizedUserKeysInMetadata(
-          project_metadata, project_ssh_keys)
-      try:
-        request = self._projects_api.setCommonInstanceMetadata(
-            project=self._project,
-            body={'kind': self._GetResourceApiKind('metadata'),
-                  'items': project_metadata})
-        request.execute()
-      except errors.HttpError:
-        # A failure to add the ssh key probably means that the project metadata
-        # has exceeded the max size. The user needs to either manually
-        # clean up their project metadata, or set the ssh keys manually for this
-        # instance. Either way, trigger a usage error to let them know.
-        raise command_base.CommandError(
-            'Unable to add the local ssh key to the project. Either manually '
-            'remove some entries from the commonInstanceMetadata field of the '
-            'project, or explicitly set the authorized keys for this instance.')
-      return True
-  def _PrepareRequestArgs(self, instance_name, **other_args):
-    """Gets the dictionary of API method keyword arguments.
-    Args:
-      instance_name: The name of the instance.
-      **other_args: Keyword arguments that should be included in the request.
-    Returns:
-      Dictionary of keyword arguments that should be passed in the API call,
-      includes all keyword arguments passed in 'other_args' plus
-      common keys such as the name of the resource and the project.
-    """
-    kwargs = {
-        'project': self._project,
-        'instance': self.DenormalizeResourceName(instance_name)
-    }
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      if not self._flags.zone:
-        self._flags.zone = self.GetZoneForResource(self._instances_api,
-                                                   instance_name)
-      kwargs['zone'] = self._flags.zone
-    for key, value in other_args.items():
-      kwargs[key] = value
-    return kwargs
-  def _AddComputeKeyToProject(self):
-    """Update the current project to include the user's public ssh key.
-    Returns:
-      True iff the ssh key was added to the project.
-    """
-    compute_key = ssh_keys.SshKeys.GetPublicKey()
-    return self._AddAuthorizedUserKeyToProject(compute_key)
-  def _BuildAttachedDisk(self, disk_arg):
-    """Converts a disk argument into an AttachedDisk object."""
-    # Start with the assumption that the argument only specifies the
-    # name of the disk resource.
-    disk_name = disk_arg
-    device_name = disk_arg
-    mode = 'READ_WRITE'
-    boot = False
-    disk_parts = disk_arg.split(',')
-    if len(disk_parts) > 1:
-      # The argument includes new-style decorators. The first part is
-      # the disk resource name. The other parts are optional key/value
-      # pairs.
-      disk_name = disk_parts[0]
-      device_name = disk_parts[0]
-      for option in disk_parts[1:]:
-        if option == 'boot':
-          if self._IsUsingAtLeastApiVersion('v1beta14'):
-            boot = True
-            continue
-          else:
-            raise ValueError('boot flag is not supported for this API version')
-        if not '=' in option:
-          raise ValueError('Invalid disk option: %s' % option)
-        key, value = option.split('=', 2)
-        if key == 'deviceName':
-          device_name = value
-        elif key == 'mode':
-          mode = self.disk_modes.get(value.lower())
-          if not mode:
-            raise ValueError('Invalid disk mode: %s' % value)
-        else:
-          raise ValueError('Invalid disk option: %s' % key)
-    else:
-      # The user didn't provide any options using the newer key/value
-      # syntax, so check to see if they have used the old syntax where
-      # the device name is delimited by a colon.
-      disk_parts = disk_arg.split(':')
-      if len(disk_parts) > 1:
-        disk_name = disk_parts[0]
-        device_name = disk_parts[1]
-        LOGGER.info(
-            'Please use new disk device naming syntax: --disk=%s,deviceName=%s',
-            disk_name,
-            device_name)
-    disk_url = self.NormalizePerZoneResourceName(self._project,
-                                                 self._flags.zone,
-                                                 'disks',
-                                                 disk_name)
-    disk = {
-        'type': 'PERSISTENT',
-        'source': disk_url,
-        'mode': mode,
-        'deviceName': device_name}
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      disk['boot'] = boot
-    return disk
-class AddInstance(InstanceCommand):
-  """Create new VM instances.
-  More than one instance name can be specified.  Multiple instances will be
-  created in parallel.
-  """
-  positional_args = '<instance-name-1> ... <instance-name-n>'
-  status_field = 'status'
-  _TERMINAL_STATUS = ['RUNNING', 'TERMINATED']
-  def __init__(self, name, flag_values):
-    super(AddInstance, self).__init__(name, flag_values)
-    flags.DEFINE_string('description',
-                        '',
-                        'Instance description',
-                        flag_values=flag_values)
-    flags.DEFINE_string('image',
-                        None,
-                        'Image name. To get a list of images built by Google, '
-                        'run \'gcutil listimages --project=projects/google\'. '
-                        'To get a list of images you have built, run \'gcutil '
-                        'listimages\'.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('kernel',
-                        None,
-                        'Kernel name. To get a list of kernels built by '
-                        'Google, run \'gcutil listkernels --project=google\'. ',
-                        flag_values=flag_values)
-    flags.DEFINE_boolean('persistent_boot_disk',
-                         None,
-                         'Make boot disk persistent. Copy contents of the '
-                         'image onto a new disk named "boot-{instanceName}" '
-                         'and use it for booting. The preferred kernel for '
-                         'the image will be used to boot, but it may be '
-                         'overridden by passing --kernel.',
-                         flag_values=flag_values)
-    flags.DEFINE_string('machine_type',
-                        None,
-                        'Machine type name. To get a list of available machine '
-                        'types, run \'gcutil listmachinetypes\'.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('network',
-                        'default',
-                        'The network to which to attach the instance.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('internal_ip_address',
-                        '',
-                        'The internal (within the specified network) IP '
-                        'address for the instance; if not set the instance '
-                        'will be assigned an appropriate address.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('external_ip_address',
-                        self.EPHEMERAL_ACCESS_CONFIG_NAT_IP,
-                        'The external NAT IP of the new instance. The default '
-                        'value "ephemeral" indicates the service should choose '
-                        'an available ephemeral IP. The value "none" (or an '
-                        'empty string) indicates no external IP will be '
-                        'assigned to the new instance. If an explicit IP is '
-                        'given, that IP must be reserved by the project and '
-                        'not yet assigned to another instance.',
-                        flag_values=flag_values)
-    flags.DEFINE_multistring('disk',
-                             [],
-                             'The name of a disk to be attached to the '
-                             'instance. The name may be followed by a '
-                             'comma-separated list of name=value pairs '
-                             'specifying options. Legal option names are '
-                             '\'deviceName\', to specify the disk\'s device '
-                             'name, and \'mode\', to indicate whether the disk '
-                             'should be attached READ_WRITE (the default) or '
-                             'READ_ONLY. You may also use the \'boot\' '
-                             'flag to designate the disk as a boot device',
-                             flag_values=flag_values)
-    flags.DEFINE_boolean('use_compute_key',
-                         False,
-                         'Whether or not to include the default '
-                         'Google Compute Engine ssh key as one of the '
-                         'authorized ssh keys for the created instance. This '
-                         'has the side effect of disabling project-wide ssh '
-                         'key management for the instance.',
-                         flag_values=flag_values)
-    flags.DEFINE_boolean('add_compute_key_to_project',
-                         None,
-                         'Whether or not to add the default Google Compute '
-                         'Engine ssh key as one of the authorized ssh keys '
-                         'for the project. If the default key has already '
-                         'been added to the project, then this will have no '
-                         'effect. The default behavior is to add the key to '
-                         'the project if no instance-specific keys are '
-                         'defined.',
-                         flag_values=flag_values)
-    flags.DEFINE_list('authorized_ssh_keys',
-                      [],
-                      'Fix the list of user/key-file pairs to the specified '
-                      'entries, disabling project-wide key management for this '
-                      'instance. These are specified as a comma separated list '
-                      'of colon separated entries: '
-                      'user1:keyfile1,user2:keyfile2,...',
-                      flag_values=flag_values)
-    flags.DEFINE_string('service_account',
-                        'default',
-                        'The service account whose credentials are to be made'
-                        ' available for this instance.',
-                        flag_values=flag_values)
-    flags.DEFINE_list('service_account_scopes',
-                      [],
-                      'The scopes of credentials of the above service'
-                      ' account that are to be made available for this'
-                      ' instance (comma separated).  There are also a set of '
-                      'scope aliases supported: %s'
-                      % ', '.join(sorted(scopes.SCOPE_ALIASES.keys())),
-                      flag_values=flag_values)
-    flags.DEFINE_boolean('wait_until_running',
-                         False,
-                         'Whether the program should wait until the instance is'
-                         ' in running state.',
-                         flag_values=flag_values)
-    flags.DEFINE_list('tags',
-                      [],
-                      'A set of tags applied to this instance. Used for '
-                      'filtering and to configure network firewall rules '
-                      '(comma separated).',
-                      flag_values=flag_values)
-    self._metadata_flags_processor = metadata.MetadataFlagsProcessor(
-        flag_values)
-  def Handle(self, *instance_names):
-    """Add the specified instance.
-    Args:
-      *instance_names: A list of instance names to add.
-    Returns:
-      A tuple of (result, exceptions)
-    """
-    if not instance_names:
-      raise app.UsageError('You must specify at least one instance name')
-    if len(instance_names) > 1 and self._flags.disk:
-      raise command_base.CommandError(
-          'Specifying a disk when starting multiple instances is not '
-          'currently supported')
-    if max([len(i) for i in instance_names]) > 32:
-      LOGGER.warn('Hostnames longer than 32 characters have known issues with '
-                  'some linux distributions.')
-    self._flags.zone = self._GetZone(self._flags.zone or
-                                     self._FindDefaultZone(self._flags.disk))
-    if not self._flags.machine_type:
-      self._flags.machine_type = self._PromptForMachineType()['name']
-    # Processes the disks, so we can check for the presence of a boot
-    # disk before prompting for image or kernel.
-    disks = [self._BuildAttachedDisk(disk) for disk in self._flags.disk]
-    if (not self._flags.image and
-        self._IsUsingAtLeastApiVersion('v1beta14') and
-        (not self._HasBootDisk(disks) or self._flags.persistent_boot_disk)):
-      self._flags.image = self._PromptForImage()['selfLink']
-    if not self._flags.kernel and self._HasBootDisk(disks):
-      # Have boot disk but no kernel, prompt for a kernel.
-      self._flags.kernel = self._PromptForKernel()['selfLink']
-    instance_metadata = self._metadata_flags_processor.GatherMetadata()
-    if self._flags.authorized_ssh_keys or self._flags.use_compute_key:
-      instance_metadata = self._AddSshKeysToMetadata(instance_metadata)
-    # Map of instance_name => boot_disk.
-    boot_disks = {}
-    if self._flags.persistent_boot_disk:
-      if not self._IsUsingAtLeastApiVersion('v1beta14'):
-        raise app.UsageError(
-            'Booting from persistent disk is only supported in '
-            'v1beta14 and above.')
-      # Persistent boot device request. We need to create a new disk for each VM
-      # and populate it with contents of the specified image.
-      # Read the preferred kernel from the image unless overridden by the user.
-      if not self._flags.kernel:
-        normalized_image_name = self.NormalizeGlobalResourceName(
-            self._project, 'images', self._flags.image)
-        image_name_parts = normalized_image_name.split('/')
-        # Read the actual image, but first verify that the user gave us valid
-        # image URL.
-        if (image_name_parts[-2] != 'images' or
-            image_name_parts[-3] != 'global' or
-            image_name_parts[-5] != 'projects'):
-          raise app.UsageError('Invalid image URL: %s' %
-                               normalized_image_name)
-        image_resource = self._images_api.get(
-            project=image_name_parts[-4],
-            image=image_name_parts[-1]).execute()
-        self._flags.kernel = image_resource['preferredKernel']
-      disk_creation_requests = []
-      for instance_name in instance_names:
-        boot_disk_name = 'boot-%s' % (instance_name)
-        boot_disks[instance_name] = self._BuildAttachedDisk(
-            '%s,boot' % (boot_disk_name))
-        LOGGER.info('Preparing boot disk [%s] for instance [%s]'
-                    ' from disk image [%s].',
-                    boot_disk_name, instance_name,
-                    self._flags.image)
-        disk_creation_requests.append(
-            self._CreateDiskFromImageRequest(boot_disk_name))
-      self._flags.image = None
-      (disk_results, disk_exceptions) = self.ExecuteRequests(
-          disk_creation_requests, collection_name='disks')
-      if disk_exceptions:
-        return (self.MakeListResult(disk_results, 'operationList'),
-                disk_exceptions)
-    if self._flags.add_compute_key_to_project or (
-        self._flags.add_compute_key_to_project is None and
-        not 'sshKeys' in [entry.get('key', '') for entry in instance_metadata]):
-      try:
-        self._AddComputeKeyToProject()
-      except ssh_keys.UserSetupError as e:
-        LOGGER.warn('Could not generate compute ssh key: %s', e)
-    self._ValidateFlags()
-    requests = []
-    for instance_name in instance_names:
-      instance_disks = disks
-      if instance_name in boot_disks:
-        instance_disks = [boot_disks[instance_name]] + disks
-      requests.append(self._BuildRequestWithMetadata(
-          instance_name, instance_metadata, instance_disks))
-    (results, exceptions) = self.ExecuteRequests(requests)
-    if self._flags.wait_until_running:
-      instances_to_wait = results
-      results = []
-      for result in instances_to_wait:
-        if self.IsResultAnOperation(result):
-          results.append(result)
-        else:
-          instance_name = result['name']
-          kwargs = self._PrepareRequestArgs(instance_name)
-          get_request = self._instances_api.get(**kwargs)
-          instance_result = get_request.execute()
-          instance_result = self._WaitUntilInstanceIsRunning(
-              instance_result, kwargs)
-          results.append(instance_result)
-    if self._flags.synchronous_mode:
-      return (self.MakeListResult(results, 'instanceList'), exceptions)
-    else:
-      return (self.MakeListResult(results, 'operationList'), exceptions)
-  def _WaitUntilInstanceIsRunning(self, result, kwargs):
-    """Waits for the instance to start.
-    Periodically polls the server for current instance status. Exits if the
-    status of the instance is RUNNING or TERMINATED or the maximum waiting
-    timeout has been reached. In both cases returns the last known instance
-    details.
-    Args:
-      result: the current state of the instance.
-      kwargs: keyword arguments to _instances_api.get()
-    Returns:
-      Json containing full instance information.
-    """
-    current_status = result[self.status_field]
-    start_time = time.time()
-    instance_name = kwargs['instance']
-    LOGGER.info('Ensuring %s is running.  Will wait to start for: %d seconds.',
-                instance_name, self._flags.max_wait_time)
-    while (time.time() - start_time < self._flags.max_wait_time and
-           current_status not in self._TERMINAL_STATUS):
-      LOGGER.info(
-          'Waiting for instance \'%s\' to start. '
-          'Current status: %s. Sleeping for %ss.',
-          instance_name,
-          current_status, self._flags.sleep_between_polls)
-      time.sleep(self._flags.sleep_between_polls)
-      result = self._instances_api.get(**kwargs).execute()
-      current_status = result[self.status_field]
-    if current_status not in self._TERMINAL_STATUS:
-      LOGGER.warn('Timeout reached. Instance %s has not yet started.',
-                  instance_name)
-    return result
-  def _FindDefaultZone(self, disks):
-    """Given the persistent disks for an instance, find a default zone.
-    Args:
-      disks: The list of persistent disks to be used by the instance.
-    Returns:
-      The name of a zone if a clear default can be determined
-      from the persistent disks, otherwise None.
-    """
-    for disk in disks:
-      # Remove any options from the disk name. We need to strip using
-      # both ',' and ':' to handle the new and old methods for
-      # providing disk options.
-      if ',' in disk:
-        disk = disk.split(',')[0]
-      elif ':' in disk:
-        disk = disk.split(':')[0]
-      disk_name = self.DenormalizeResourceName(disk)
-      if self._IsUsingAtLeastApiVersion('v1beta14'):
-        return self.GetZoneForResource(self._disks_api, disk_name,
-                                       fail_if_not_found=False)
-      get_request = self._disks_api.get(
-          project=self._project, disk=disk_name)
-      return get_request.execute()['zone']
-  def _AddSshKeysToMetadata(self, instance_metadata):
-    instance_ssh_keys = ssh_keys.SshKeys.GetAuthorizedUserKeys(
-        use_compute_key=self._flags.use_compute_key,
-        authorized_ssh_keys=self._flags.authorized_ssh_keys)
-    if instance_ssh_keys:
-      new_value = ['%(user)s:%(key)s' % user_key
-                   for user_key in instance_ssh_keys]
-      # Have the new value extend the old value
-      old_values = [entry['value'] for entry in instance_metadata
-                    if entry['key'] == 'sshKeys']
-      all_values = '\n'.join(old_values + new_value)
-      instance_metadata = [entry for entry in instance_metadata
-                           if entry['key'] != 'sshKeys']
-      instance_metadata.append({'key': 'sshKeys', 'value': all_values})
-    return instance_metadata
-  def _HasBootDisk(self, disks):
-    """Determines if any of the disks in a list is a boot disk."""
-    for disk in disks:
-      if disk.get('boot', False):
-        return True
-    return False
-  def _ValidateFlags(self):
-    """Validate flags coming in before we start building resources.
-    Raises:
-      app.UsageError: If service account explicitly given without scopes.
-      command_base.CommandError: If scopes contains ' '.
-    """
-    if (self._flags.service_account and
-        self._flags.service_account_scopes):
-      # Ensures that the user did not space-delimit his or her scopes
-      # list.
-      for scope in self._flags.service_account_scopes:
-        if ' ' in scope:
-          raise command_base.CommandError(
-              'Scopes list must be comma-delimited, not space-delimited.')
-    elif self._flags['service_account'].present:
-      raise app.UsageError(
-          '--service_account given without --service_account_scopes.')
-    if self._flags.wait_until_running and not self._flags.synchronous_mode:
-      LOGGER.warn('wait_until_running set. Implying synchronous_mode.')
-      self._flags.synchronous_mode = True
-  def _CreateDiskFromImageRequest(self, disk_name):
-    """Build a request that creates disk from source image.
-    Args:
-      disk_name: Name of the disk.
-    Returns:
-      The prepared disk insert request.
-    """
-    disk_resource = {
-        'kind': self._GetResourceApiKind('instance'),
-        'name': disk_name,
-        'description': 'Persistent boot disk created from %s.' % (
-            self._flags.image),
-        'zone': self.NormalizeTopLevelResourceName(self._project, 'zones',
-                                                   self._flags.zone),
-        }
-    source_image_url = self.NormalizeGlobalResourceName(self._project, 'images',
-                                                        self._flags.image)
-    kwargs = {
-        'project': self._project,
-        'body': disk_resource,
-        'sourceImage': source_image_url
-    }
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      kwargs['zone'] = disk_resource['zone'].split('/')[-1]
-      del disk_resource['zone']
-    return self._disks_api.insert(**kwargs)
-  def _BuildRequestWithMetadata(self, instance_name, instance_metadata, disks):
-    """Build a request to add the specified instance, given the ssh keys for it.
-    Args:
-      instance_name: Name of the instance to build a request for.
-      instance_metadata: The metadata to be passed to the VM.  This is in the
-        form of [{'key': <key>, 'value': <value>}] form, ready to be
-        sent to the server.
-      disks: Disks to attach to the instance.
-    Returns:
-      The prepared instance request.
-    """
-    instance_resource = {
-        'kind': self._GetResourceApiKind('instance'),
-        'name': self.DenormalizeResourceName(instance_name),
-        'description': self._flags.description,
-        'networkInterfaces': [],
-        'disks': disks,
-        'metadata': [],
-        }
-    if self._flags.image:
-      instance_resource['image'] = self.NormalizeGlobalResourceName(
-          self._project, 'images', self._flags.image)
-    if self._flags.kernel:
-      instance_resource['kernel'] = self.NormalizeGlobalResourceName(
-          self._project, 'kernels', self._flags.kernel)
-    if self._flags.machine_type:
-      instance_resource['machineType'] = self.NormalizeGlobalResourceName(
-          self._project, 'machine-types', self._flags.machine_type)
-    instance_resource['zone'] = self.NormalizeTopLevelResourceName(
-        self._project, 'zones', self._flags.zone)
-    if self._flags.network:
-      network_interface = {
-          'network': self.NormalizeGlobalResourceName(self._project, 'networks',
-                                                      self._flags.network)
-          }
-      if self._flags.internal_ip_address:
-        network_interface['networkIP'] = self._flags.internal_ip_address
-      external_ip_address = self._flags.external_ip_address
-      if external_ip_address and external_ip_address.lower() != 'none':
-        access_config = {
-            'name': self.DEFAULT_ACCESS_CONFIG_NAME,
-            'type': self.ONE_TO_ONE_NAT_ACCESS_CONFIG_TYPE,
-            }
-        if external_ip_address.lower() != self.EPHEMERAL_ACCESS_CONFIG_NAT_IP:
-          access_config['natIP'] = self._flags.external_ip_address
-        network_interface['accessConfigs'] = [access_config]
-      instance_resource['networkInterfaces'].append(network_interface)
-    metadata_subresource = {
-        'kind': self._GetResourceApiKind('metadata'),
-        'items': []}
-    metadata_subresource['items'].extend(instance_metadata)
-    instance_resource['metadata'] = metadata_subresource
-    if self._flags.service_account and (
-        len(self._flags.service_account_scopes)):
-      instance_resource['serviceAccounts'] = []
-      expanded_scopes = scopes.ExpandScopeAliases(
-          self._flags.service_account_scopes)
-      instance_resource['serviceAccounts'].append({
-          'email': self._flags.service_account,
-          'scopes': expanded_scopes})
-    instance_tags = sorted(set(self._flags.tags))
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      instance_tags = {'items': sorted(set(self._flags.tags))}
-    instance_resource['tags'] = instance_tags
-    kwargs = {
-        'project': self._project,
-        'body': instance_resource,
-    }
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      kwargs['zone'] = self.DenormalizeResourceName(self._flags.zone)
-      del instance_resource['zone']
-    return self._instances_api.insert(**kwargs)
-class GetInstance(InstanceCommand):
-  """Get a machine instance."""
-  positional_args = '<instance-name>'
-  def Handle(self, instance_name):
-    """Get the specified instance.
-    Args:
-      instance_name: The name of the instance to get.
-    Returns:
-      The result of getting the instance.
-    """
-    instance_request = self._instances_api.get(
-        **self._PrepareRequestArgs(instance_name))
-    return instance_request.execute()
-class DeleteInstance(InstanceCommand):
-  """Delete one or more VM instances.
-  If multiple instance names are specified, the instances will be deleted
-  in parallel.
-  """
-  positional_args = '<instance-name-1> ... <instance-name-n>'
-  safety_prompt = 'Delete instance'
-  def Handle(self, *instance_names):
-    """Delete the specified instances.
-    Args:
-      *instance_names: Names of the instances to delete.
-    Returns:
-      The result of deleting the instance.
-    """
-    if self._IsUsingAtLeastApiVersion('v1beta14') and not self._flags.zone:
-      if len(instance_names) > 1:
-        self._flags.zone = self._GetZone()
-      else:
-        self._flags.zone = self.GetZoneForResource(self._instances_api,
-                                                   instance_names[0])
-    requests = []
-    for instance_name in instance_names:
-      requests.append(self._instances_api.delete(
-          **self._PrepareRequestArgs(instance_name)))
-    (results, exceptions) = self.ExecuteRequests(requests)
-    return (self.MakeListResult(results, 'operationList'), exceptions)
-class ListInstances(InstanceCommand, command_base.GoogleComputeListCommand):
-  """List the instances for a project."""
-  is_global_level_collection = False
-  is_zone_level_collection = True
-  def ListFunc(self):
-    """Returns the function for listing instances."""
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      return None
-    return self._instances_api.list
-  def ListZoneFunc(self):
-    """Returns the function for listing instances in a zone."""
-    return self._instances_api.list
-class AddAccessConfig(InstanceCommand):
-  """Adds an access config to an instance's network interface."""
-  positional_args = '<instance-name>'
-  def __init__(self, name, flag_values):
-    super(AddAccessConfig, self).__init__(name, flag_values)
-    flags.DEFINE_string('network_interface_name',
-                        self.DEFAULT_NETWORK_INTERFACE_NAME,
-                        'The name of the instance\'s network interface to '
-                        'which to add the new access config.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('access_config_name',
-                        self.DEFAULT_ACCESS_CONFIG_NAME,
-                        'The name of the new access config.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('access_config_type',
-                        self.ONE_TO_ONE_NAT_ACCESS_CONFIG_TYPE,
-                        'The type of the new access config. Currently only '
-                        'type "ONE_TO_ONE_NAT" is supported.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('access_config_nat_ip',
-                        self.EPHEMERAL_ACCESS_CONFIG_NAT_IP,
-                        'The external NAT IP of the new access config. The '
-                        'default value "ephemeral" indicates the service '
-                        'should choose an available ephemeral IP. If an '
-                        'explicit IP is given, that IP must be reserved by '
-                        'the project and not yet assigned to another instance.',
-                        flag_values=flag_values)
-  def Handle(self, instance_name):
-    """Adds an access config to an instance's network interface.
-    Args:
-      instance_name: The instance name to which to add the new access config.
-    Returns:
-      An operation resource.
-    """
-    access_config_resource = {
-        'name': self._flags.access_config_name,
-        'type': self._flags.access_config_type,
-        }
-    if (self._flags.access_config_nat_ip.lower() !=
-        self.EPHEMERAL_ACCESS_CONFIG_NAT_IP):
-      access_config_resource['natIP'] = self._flags.access_config_nat_ip
-    add_access_config_request = self._instances_api.addAccessConfig(
-        **self._PrepareRequestArgs(
-            instance_name,
-            network_interface=self._flags.network_interface_name,
-            body=access_config_resource))
-    return add_access_config_request.execute()
-class DeleteAccessConfig(InstanceCommand):
-  """Deletes an access config from an instance's network interface."""
-  positional_args = '<instance-name>'
-  def __init__(self, name, flag_values):
-    super(DeleteAccessConfig, self).__init__(name, flag_values)
-    flags.DEFINE_string('network_interface_name',
-                        self.DEFAULT_NETWORK_INTERFACE_NAME,
-                        'The name of the instance\'s network interface from '
-                        'which to delete the access config.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('access_config_name',
-                        self.DEFAULT_ACCESS_CONFIG_NAME,
-                        'The name of the access config to delete.',
-                        flag_values=flag_values)
-  def Handle(self, instance_name):
-    """Deletes an access config from an instance's network interface.
-    Args:
-      instance_name: The instance name from which to delete the access config.
-    Returns:
-      An operation resource.
-    """
-    delete_access_config_request = self._instances_api.deleteAccessConfig(
-        **self._PrepareRequestArgs(
-            instance_name,
-            network_interface=self._flags.network_interface_name,
-            access_config=self._flags.access_config_name))
-    return delete_access_config_request.execute()
-class SshInstanceBase(InstanceCommand):
-  """Base class for SSH-based commands."""
-  # We want everything after 'ssh <instance>' to be passed on to the
-  # ssh command in question.  As such, all arguments to the utility
-  # must come before the 'ssh' command.
-  sort_args_and_flags = False
-  def __init__(self, name, flag_values):
-    super(SshInstanceBase, self).__init__(name, flag_values)
-    flags.DEFINE_integer(
-        'ssh_port',
-        22,
-        'TCP port to connect to',
-        flag_values=flag_values)
-    flags.DEFINE_multistring(
-        'ssh_arg',
-        [],
-        'Additional arguments to pass to ssh',
-        flag_values=flag_values)
-    flags.DEFINE_integer(
-        'ssh_key_push_wait_time',
-        300,  # 5 minutes
-        'Number of seconds to wait for updates to project-wide ssh keys '
-        'to cascade to the instances within the project',
-        flag_values=flag_values)
-  def PrintResult(self, _):
-    """Override the PrintResult to be a noop."""
-    pass
-  def _GetInstanceResource(self, instance_name):
-    """Get the instance resource. This is the dictionary returned by the API.
-    Args:
-      instance_name: The name of the instance to retrieve the ssh address for.
-    Returns:
-      The data for the instance resource as returned by the API.
-    Raises:
-      command_base.CommandError: If the instance does not exist.
-    """
-    request = self._instances_api.get(
-        **self._PrepareRequestArgs(instance_name))
-    result = request.execute()
-    if not result:
-      raise command_base.CommandError(
-          'Unable to find the instance %s.' % (instance_name))
-    return result
-  def _GetSshAddress(self, instance_resource):
-    """Retrieve the ssh address from the passed instance resource data.
-    Args:
-      instance_resource: The resource data of the instance for which
-        to retrieve the ssh address.
-    Returns:
-      The ssh address and port.
-    Raises:
-      command_base.CommandError: If the instance has no external address.
-    """
-    external_addresses = self._ExtractExternalIpFromInstanceRecord(
-        instance_resource)
-    if len(external_addresses) < 1:
-      raise command_base.CommandError(
-          'Cannot connect to an instance with no external address')
-    return (external_addresses[0], self._flags.ssh_port)
-  def _EnsureSshable(self, instance_resource):
-    """Ensure that the user can ssh into the specified instance.
-    This method checks if the instance has SSH keys defined for it, and if
-    it does not this makes sure the enclosing project contains a metadata
-    entry for the user's public ssh key.
-    If the project is updated to add the user's ssh key, then this method
-    waits for the amount of time specified by the wait_time_for_ssh_key_push
-    flag for the change to cascade down to the instance.
-    Args:
-      instance_resource: The resource data for the instance to which to connect.
-    Raises:
-      command_base.CommandError: If the instance is not in the RUNNING state.
-    """
-    instance_status = instance_resource.get('status')
-    if instance_status != 'RUNNING':
-      raise command_base.CommandError(
-          'Cannot connect to the instance since its current status is %s.'
-          % instance_status)
-    instance_metadata = instance_resource.get('metadata', {})
-    instance_ssh_key_entries = (
-        [entry for entry in instance_metadata.get(
-            'items', [])
-         if entry.get('key') == 'sshKeys'])
-    if not instance_ssh_key_entries:
-      if self._AddComputeKeyToProject():
-        wait_time = self._flags.ssh_key_push_wait_time
-        LOGGER.info('Updated project with new ssh key. It can take several '
-                    'minutes for the instance to pick up the key.')
-        LOGGER.info('Waiting %s seconds before attempting to connect.',
-                    wait_time)
-        time.sleep(wait_time)
-  def _BuildSshCmd(self, instance_resource, command, args):
-    """Builds the given SSH-based command line with the given arguments.
-    A complete SSH-based command line is built from the given command,
-    any common arguments, and the arguments provided. The value of
-    each argument is formatted using a dictionary that contains the
-    following keys: host and port.
-    Args:
-      instance_resource: The resource data of the instance for which
-        to build the ssh command.
-      command: the ssh-based command to run (e.g. ssh or scp)
-      args: arguments for the command
-    Returns:
-      The command line used to perform the requested ssh operation.
-    Raises:
-      IOError: An error occured accessing SSH details.
-    """
-    (host, port) = self._GetSshAddress(instance_resource)
-    values = {'host': host,
-              'port': port,
-              'user': self._flags.ssh_user}
-    command_line = [
-        command,
-        '-o', 'UserKnownHostsFile=/dev/null',
-        '-o', 'CheckHostIP=no',
-        '-o', 'StrictHostKeyChecking=no',
-        '-i', self._flags.private_key_file
-    ] + self._flags.ssh_arg
-    if LOGGER.level <= logging.DEBUG:
-      command_line.append('-v')
-    for arg in args:
-      command_line.append(arg % values)
-    return command_line
-  def _RunSshCmd(self, instance_name, command, args):
-    """Run the given SSH-based command line with the given arguments.
-    The specified SSH-base command is run for the arguments provided.
-    The value of each argument is formatted using a dictionary that
-    contains the following keys: host and port.
-    Args:
-      instance_name: The name of the instance for which to run the ssh command.
-      command: the ssh-based command to run (e.g. ssh or scp)
-      args: arguments for the command
-    Raises:
-      IOError: An error occured accessing SSH details.
-    """
-    instance_resource = self._GetInstanceResource(instance_name)
-    command_line = self._BuildSshCmd(instance_resource, command, args)
-    try:
-      self._EnsureSshable(instance_resource)
-    except ssh_keys.UserSetupError as e:
-      LOGGER.warn('Could not generate compute ssh key: %s', e)
-      return
-    LOGGER.info('Running command line: %s', ' '.join(command_line))
-    try:
-      os.execvp(command, command_line)
-    except OSError as e:
-      LOGGER.error('There was a problem executing the command: %s', e)
-class SshToInstance(SshInstanceBase):
-  """Ssh to an instance."""
-  positional_args = '<instance-name> <ssh-args>'
-  def _GenerateSshArgs(self, *argv):
-    """Generates the command line arguments for the ssh command.
-    Args:
-      *argv: List of additional ssh command line args, if any.
-    Returns:
-      The complete ssh argument list.
-    """
-    ssh_args = ['-A', '-p', '%(port)d', '%(user)s@%(host)s', '--']
-    escaped_args = [a.replace('%', '%%') for a in argv]
-    ssh_args.extend(escaped_args)
-    return ssh_args
-  def Handle(self, instance_name, *argv):
-    """SSH into the instance.
-    Args:
-      instance_name: The name of the instance to ssh to.
-      *argv: The remaining unhandled arguments.
-    Returns:
-      The result of the ssh command
-    """
-    ssh_args = self._GenerateSshArgs(*argv)
-    self._RunSshCmd(instance_name, 'ssh', ssh_args)
-class PushToInstance(SshInstanceBase):
-  """Push one or more files to an instance."""
-  positional_args = '<instance-name> <file-1> ... <file-n> <destination>'
-  def _GenerateScpArgs(self, *argv):
-    """Generates the command line arguments for the scp command.
-    Args:
-      *argv: List of files to push and instance-relative destination.
-    Returns:
-      The scp argument list.
-    Raises:
-      command_base.CommandError: If an invalid number of arguments are passed
-          in.
-    """
-    if len(argv) < 2:
-      raise command_base.CommandError('Invalid number of arguments passed.')
-    scp_args = ['-r', '-P', '%(port)d', '--']
-    escaped_args = [a.replace('%', '%%') for a in argv]
-    scp_args.extend(escaped_args[0:-1])
-    scp_args.append('%(user)s@%(host)s:' + escaped_args[-1])
-    return scp_args
-  def Handle(self, instance_name, *argv):
-    """Pushes one or more files into the instance.
-    Args:
-      instance_name: The name of the instance to push files to.
-      *argv: The remaining unhandled arguments.
-    Returns:
-      The result of the scp command
-    Raises:
-      command_base.CommandError: If an invalid number of arguments are passed
-        in.
-    """
-    scp_args = self._GenerateScpArgs(*argv)
-    self._RunSshCmd(instance_name, 'scp', scp_args)
-class PullFromInstance(SshInstanceBase):
-  """Pull one or more files from an instance."""
-  positional_args = '<instance-name> <file-1> ... <file-n> <destination>'
-  def _GenerateScpArgs(self, *argv):
-    """Generates the command line arguments for the scp command.
-    Args:
-      *argv: List of files to pull and local-relative destination.
-    Returns:
-      The scp argument list.
-    Raises:
-      command_base.CommandError: If an invalid number of arguments are passed
-          in.
-    """
-    if len(argv) < 2:
-      raise command_base.CommandError('Invalid number of arguments passed.')
-    scp_args = ['-r', '-P', '%(port)d', '--']
-    escaped_args = [a.replace('%', '%%') for a in argv]
-    for arg in escaped_args[0:-1]:
-      scp_args.append('%(user)s@%(host)s:' + arg)
-    scp_args.append(escaped_args[-1])
-    return scp_args
-  def Handle(self, instance_name, *argv):
-    """Pulls one or more files from the instance.
-    Args:
-      instance_name: The name of the instance to pull files from.
-      *argv: The remaining unhandled arguments.
-    Returns:
-      The result of the scp command
-    Raises:
-      command_base.CommandError: If an invalid number of arguments are passed
-          in.
-    """
-    scp_args = self._GenerateScpArgs(*argv)
-    self._RunSshCmd(instance_name, 'scp', scp_args)
-class GetSerialPortOutput(InstanceCommand):
-  """Get the output of an instance's serial port."""
-  positional_args = '<instance-name>'
-  def Handle(self, instance_name):
-    """Get the specified instance's serial port output.
-    Args:
-      instance_name: The name of the instance.
-    Returns:
-      The output of the instance's serial port.
-    """
-    if self._IsUsingAtLeastApiVersion('v1beta13'):
-      instance_request = self._instances_api.getSerialPortOutput(
-          **self._PrepareRequestArgs(instance_name))
-      return instance_request.execute()
-    else:
-      raise app.UsageError(
-          'Serial port output is only supported in v1beta13 and above.')
-  def PrintResult(self, result):
-    """Override the PrintResult to be a noop."""
-    if self._flags.print_json:
-      super(GetSerialPortOutput, self).PrintResult(result)
-    else:
-      print result['contents']
-class OptimisticallyLockedInstanceCommand(InstanceCommand):
-  """Base class for instance commands that require a fingerprint."""
-  def __init__(self, name, flag_values):
-    super(OptimisticallyLockedInstanceCommand, self).__init__(name, flag_values)
-    flags.DEFINE_string('fingerprint',
-                        None,
-                        'Fingerprint of the data to be overwritten. '
-                        'This fingerprint provides optimistic locking--'
-                        'data will only be set if the given fingerprint '
-                        'matches the state of the data prior to this request.',
-                        flag_values=flag_values)
-  def Handle(self, *args, **kwargs):
-    """Invokes the HandleCommand method of the subclass."""
-    if not self._flags.fingerprint:
-      raise app.UsageError('You must provide a fingerprint with your request.')
-    return self.HandleCommand(*args, **kwargs)
-class SetMetadata(OptimisticallyLockedInstanceCommand):
-  """Sets instance metadata and sends new metadata to instances.
-  This method overwrites existing instance metadata with new metadata.
-  Common metadata (project-wide) is preserved.
-  For example, running:
-    gcutil --project=<project-name> setinstancemetadata my-instance \
-      --metadata="key1:value1" \
-      --fingerprint=<original-fingerprint>
-    ...
-    gcutil --project=<project-name> setinstancemetadata my-instance \
-      --metadata="key2:value2" \
-      --fingerprint=<new-fingerprint>
-  will result in 'my-instance' having 'key2:value2' as its metadata.
-  """
-  positional_args = '<instance-name>'
-  def __init__(self, name, flag_values):
-    super(SetMetadata, self).__init__(name, flag_values)
-    flags.DEFINE_bool('force',
-                      None,
-                      'Set new metadata even if the key "sshKeys" will '
-                      'no longer be present.',
-                      flag_values=flag_values,
-                      short_name='f')
-    self._metadata_flags_processor = metadata.MetadataFlagsProcessor(
-        flag_values)
-  def HandleCommand(self, instance_name):
-    """Set instance-specific metadata.
-    Args:
-      instance_name: The name of the instance scoping this request.
-    Returns:
-      An operation resource.
-    """
-    new_metadata = self._metadata_flags_processor.GatherMetadata()
-    if not self._flags.force:
-      new_keys = set([entry['key'] for entry in new_metadata])
-      get_project = self._projects_api.get(project=self._project)
-      project_resource = get_project.execute()
-      project_metadata = project_resource.get('commonInstanceMetadata', {})
-      project_metadata = project_metadata.get('items', [])
-      project_keys = set([entry['key'] for entry in project_metadata])
-      get_instance = self._instances_api.get(
-          **self._PrepareRequestArgs(instance_name))
-      instance_resource = get_instance.execute()
-      instance_metadata = instance_resource.get('metadata', {})
-      instance_metadata = instance_metadata.get('items', [])
-      instance_keys = set([entry['key'] for entry in instance_metadata])
-      if ('sshKeys' in instance_keys and 'sshKeys' not in new_keys
-          and 'sshKeys' not in project_keys):
-        raise command_base.CommandError(
-            'Discarding update that would have erased instance sshKeys.'
-            '\n\nRe-run with the -f flag to force the update.')
-    metadata_resource = {'kind': self._GetResourceApiKind('metadata'),
-                         'items': new_metadata,
-                         'fingerprint': self._flags.fingerprint}
-    set_metadata_request = self._instances_api.setMetadata(
-        **self._PrepareRequestArgs(instance_name, body=metadata_resource))
-    return set_metadata_request.execute()
-class SetTags(OptimisticallyLockedInstanceCommand):
-  """Sets instance tags and sends new tags to the instance.
-  This method overwrites existing instance tags.
-  For example, running:
-    gcutil --project=<project-name> setinstancetags my-instance \
-      --tags="tag-1" \
-      --fingerprint=<original-fingerprint>
-    ...
-    gcutil --project=<project-name> setinstancetags my-instance \
-      --tags="tag-2,tag-3" \
-      --fingerprint=<new-fingerprint>
-  will result in 'my-instance' having tags 'tag-2' and 'tag-3'.
-  """
-  def __init__(self, name, flag_values):
-    super(SetTags, self).__init__(name, flag_values)
-    flags.DEFINE_list('tags',
-                      [],
-                      'A set of tags applied to this instance. Used for '
-                      'filtering and to configure network firewall rules '
-                      '(comma separated).',
-                      flag_values=flag_values)
-  def HandleCommand(self, instance_name):
-    """Set instance tags.
-    Args:
-      instance_name: The name of the instance scoping this request.
-    Returns:
-      An operation resource.
-    """
-    tag_resource = {'items': sorted(set(self._flags.tags)),
-                    'fingerprint': self._flags.fingerprint}
-    set_tags_request = self._instances_api.setTags(
-        **self._PrepareRequestArgs(instance_name, body=tag_resource))
-    return set_tags_request.execute()
-def AddCommands():
-  """Add all of the instance related commands."""
-  appcommands.AddCmd('addinstance', AddInstance)
-  appcommands.AddCmd('getinstance', GetInstance)
-  appcommands.AddCmd('deleteinstance', DeleteInstance)
-  appcommands.AddCmd('listinstances', ListInstances)
-  appcommands.AddCmd('addaccessconfig', AddAccessConfig)
-  appcommands.AddCmd('deleteaccessconfig', DeleteAccessConfig)
-  appcommands.AddCmd('ssh', SshToInstance)
-  appcommands.AddCmd('push', PushToInstance)
-  appcommands.AddCmd('pull', PullFromInstance)
-  appcommands.AddCmd('getserialportoutput', GetSerialPortOutput)
-  appcommands.AddCmd('setinstancemetadata', SetMetadata)
-  appcommands.AddCmd('setinstancetags', SetTags)