gcloud 0.0.7 → 0.1.0

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/flags_cache.py

@@ -1,274 +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.
-
-"""Cache of previously used flag values."""
-
-from __future__ import with_statement
-
-
-
-import copy
-import os
-
-import gflags as flags
-from gcutil import gcutil_logging
-
-FLAGS = flags.FLAGS
-LOGGER = gcutil_logging.LOGGER
-
-flags.DEFINE_bool(
-    'cache_flag_values',
-    False,
-    'If true, cache all specified flag values in the file specified '
-    'by the "cached_flags_file" flag.')
-flags.DEFINE_string(
-    'cached_flags_file',
-    '.gcutil.flags',
-    'File storing a cache of gcutil flag values. If the name does not '
-    'contain a path separator it will be searched in the current working '
-    'directory and up to "/", as well as the user\'s home directory. '
-    'The first matching file will be used and no merging is done upstream. '
-    'Use the "cache_flag_values" flag to persist the current flags.')
-
-
-class FlagsCache(object):
-  """File based cache of values for flags with user-specific defaults."""
-
-  def __init__(self, cache_file_name=None, open_function=open, os_module=os):
-    """Constructor.
-
-    Args:
-      cache_file_name: (str) optional path of the flags cache file (default
-        is FLAGS.cached_flags_file).
-      open_function: (function) used to open a file (overriden in tests).
-      os_module: (module) used to perform OS operations (overriden in testsa).
-    """
-    self._open = open_function
-    self._os = os_module
-    self.cache_file_path = FlagsCache._FindFlagsCacheFile(
-        cache_file_name or FLAGS.cached_flags_file, self._os)
-    if self._os.path.exists(self.cache_file_path):
-      LOGGER.debug('Found flag cache file: %s', self.cache_file_path)
-      with self._open(self.cache_file_path) as cache_file:
-        self.cache_string = cache_file.read()
-    else:
-      self.cache_string = ''
-
-    self._serialized_flags = None
-
-  @staticmethod
-  def _FindFlagsCacheFile(name, os_module):
-    """Returns the full path to the flags cache file.
-
-    If the name contains a file separator or a user expander ('~'), then
-    its full expanded path is returned.  Otherwise name is searched in
-    the current working directory and recursively up, as well as in the
-    user's home directory.  If an existing flags cache file cannot be found,
-    then the full path to the config file in the user's home directory is
-    returned so that it can be optionally created.
-
-    Args:
-      name: (string) the name of the file to search.
-      os_module: (module) used to perform OS operations.
-    Returns:
-      (string) the path to an existing or expected cache flag file, or the
-        empty string if name is None or empty.
-    """
-    if not name:
-      return ''
-
-    name = os_module.path.expanduser(name)
-
-    if os_module.path.isdir(name):
-      gcutil_flags = '.gcutil.flags'
-      return os_module.path.join(name, gcutil_flags)
-    elif os_module.path.dirname(name):
-      # name contains a path separator.
-      return os_module.path.realpath(name)
-
-    # Search for the flags cache file up the directory path.
-    directory = os_module.path.realpath(os_module.getcwd())
-    while directory:
-      filename = os_module.path.join(directory, name)
-      if os_module.path.exists(filename):
-        return filename
-      parent = os_module.path.dirname(directory)
-      if parent == directory:
-        directory = None
-      else:
-        directory = parent
-
-    # Use the flags cache file in the home directory.
-    return os_module.path.realpath(os_module.path.expanduser(
-        os_module.path.join('~', name)))
-
-  @staticmethod
-  def _GetCacheableFlagValues(flag_values):
-    """Get the subset of flags that are appropriate to cache.
-
-    All non-duplicate flags excluding --cache_flag_values and
-    --cached_flags_file are eligible for caching.
-
-    Args:
-      flag_values: The superset FlagValues object.
-    Returns:
-      A subset FlagValues object that contains only the cacheable flags.
-    """
-    cacheable_flag_values = flags.FlagValues()
-    for name, flag in flag_values.FlagDict().iteritems():
-      # We only process the flag if seen by its full name (not short_name).
-      if (name == flag.name and
-          not name in ['cache_flag_values', 'cached_flags_file'] and
-          not name in cacheable_flag_values and
-          not flag.short_name in cacheable_flag_values):
-        cacheable_flag_values[name] = flag
-
-    return cacheable_flag_values
-
-  @staticmethod
-  def _GetCachedFlagValues(flag_values, cache_string):
-    """Get the values for cacheable flags from the given cache string.
-
-    Any flags in the parsed_flags argument will be omitted regardless of
-    whether or not they are in the cache_string. This allows cached and
-    parsed flags to be combined without conflict.
-
-    Args:
-      flag_values: A FlagValues instance defining the cacheable flags.
-      cache_string: The contents of the cache as a newline delimited string.
-    Returns:
-      A FlagValues instance containing the flags present in the cache.
-    """
-    # We don't want to inadvertantly overwrite the parsed members of the
-    # cacheable_flags, so we make a deep copy of it before appending.
-    flag_values_copy = copy.deepcopy(flag_values)
-
-    # Clear flags to load cache into clean state.
-    for _, flag in flag_values_copy.FlagDict().iteritems():
-      flag.present = 0
-      flag.value = None
-
-    cached_flag_values = flags.FlagValues()
-    cached_flag_values.AppendFlagValues(flag_values_copy)
-    undefok = []
-    cache_entries = cache_string.split('\n')
-    while cache_entries:
-      try:
-        argv = (['dummy_command', '--undefok=\'%s\'' % ','.join(undefok)] +
-                cache_entries)
-        cache_entries = cached_flag_values(argv)[2:]
-      except flags.UnrecognizedFlagError, err:
-        undefok.append(err.flagname)
-    return cached_flag_values
-
-  @staticmethod
-  def _UnifyProjectFlags(flags, warn=False):
-    """Unifies --project and --project_id flags in the flag value set.
-
-    Args:
-      flags: A FlagValues instance with the flags to unify.
-      warn: If True, log warning if project_id is encountered.
-    """
-    if 'project_id' in flags and 'project' in flags:
-      project_id = flags['project_id']
-      project = flags['project']
-      if project_id.present:
-        if not project.present:
-          if warn:
-            LOGGER.warning('--project_id is deprecated, please use --project')
-          project.present = project_id.present
-          project.value = project_id.value
-        elif warn:
-          LOGGER.warning('--project_id and --project provided. '
-                         '--project_id is deprecated, using value of '
-                         '--project.')
-        project_id.present = 0
-        project_id.value = None
-
-  @staticmethod
-  def _ApplyCachedFlags(cacheable, cached):
-    """Applies cached values to the flags in cacheable flag set.
-
-    Only flags that are not themselves present are updated with the
-    cached value.  Returns flags whose value is present, either by
-    user specifying them at command line (cacheable) or by having been
-    loaded from cache (cached).
-
-    Args:
-      cacheable: flags whose value can be cached (and whose values will be
-          updated from cache if value not present)
-      cache: flags loaded from the cache.
-
-    Returns:
-      FlagValues object which contains all present flags
-    """
-    canonical = flags.FlagValues()
-    for name, flag in cacheable.FlagDict().iteritems():
-      if flag.name == name:
-        if not flag.present:
-          cached_flag = cached[name]
-          if cached_flag.present:
-            LOGGER.debug('Flag override from cache file: %s -> %s',
-                         repr(name), repr(cached_flag.value))
-            flag.present = cached_flag.present
-            flag.value = cached_flag.value
-
-        if flag.present:
-          canonical[name] = flag
-    return canonical
-
-  def UpdateCacheFile(self, update_cache=None):
-    """Updates the flags cache file.
-
-    This method assumes that SynchronizeFlags() has been called. If
-    the assumption is violated, this method will produce a DEBUG log
-    message and return.
-
-    Args:
-      update_cache: If True, updates the cache file. This is for testing.
-    """
-    if self._serialized_flags is None:
-      LOGGER.debug('Flags cache cannot be updated before synchronizing flags.')
-      return
-
-    if update_cache or FLAGS.cache_flag_values:
-      with self._open(self.cache_file_path, 'w') as cache_file:
-        cache_file.write(self._serialized_flags)
-
-  def SynchronizeFlags(self, flag_values=None):
-    """Synchronize the given FlagValues instance with this cache.
-
-    This updates the FlagValues instance with values for any unparsed flags if
-    they have an entry in the cache.
-
-    Args:
-      flag_values: The FlagValues instance to synchronized. If not specified,
-          then the global FlagValues instance is used.
-    Returns:
-      The synchronized FlagValues instance.
-    """
-    if not flag_values:
-      flag_values = FLAGS
-    # update_cache will be set to a boolean value, so we have to explicitly
-    # check if it is None rather than relying on the implicit false behavior.
-
-    cacheable = FlagsCache._GetCacheableFlagValues(flag_values)
-    cached = FlagsCache._GetCachedFlagValues(cacheable, self.cache_string)
-
-    FlagsCache._UnifyProjectFlags(cacheable, True)
-    FlagsCache._UnifyProjectFlags(cached)
-
-    canonical = FlagsCache._ApplyCachedFlags(cacheable, cached)
-    self._serialized_flags = canonical.FlagsIntoString()
-    return flag_values

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/gcutil

@@ -1,89 +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.
-
-"""Command line tool for interacting with Google Compute Engine.
-
-Please refer to http://developers.google.com/compute/docs/gcutil/tips for
-more information about gcutil usage.
-"""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import atexit
-import logging
-import os
-import sys
-
-
-from google.apputils import appcommands
-import gflags as flags
-
-from gcutil import basic_cmds
-from gcutil import disk_cmds
-from gcutil import firewall_cmds
-from gcutil import image_cmds
-from gcutil import instance_cmds
-from gcutil import kernel_cmds
-from gcutil import machine_type_cmds
-from gcutil import move_cmds
-from gcutil import network_cmds
-from gcutil import operation_cmds
-from gcutil import project_cmds
-from gcutil import snapshot_cmds
-from gcutil import version_checker
-from gcutil import zone_cmds
-
-
-FLAGS = flags.FLAGS
-
-# This utility will often be run in a VM and the local web server
-# behavior can be annoying there.
-FLAGS.SetDefault('auth_local_webserver', False)
-
-
-def main(unused_argv):
-  # The real work is performed by the appcommands.Run() method, which
-  # first invokes this method, and then runs the specified command.
-
-  # Set up early logging configuration
-  format_string = '%(levelname)s: %(message)s'
-  logging.basicConfig(stream=sys.stderr, format=format_string)
-
-  # Next, register all the commands.
-  basic_cmds.AddCommands()
-  disk_cmds.AddCommands()
-  firewall_cmds.AddCommands()
-  image_cmds.AddCommands()
-  instance_cmds.AddCommands()
-  kernel_cmds.AddCommands()
-  machine_type_cmds.AddCommands()
-  move_cmds.AddCommands()
-  network_cmds.AddCommands()
-  operation_cmds.AddCommands()
-  project_cmds.AddCommands()
-  snapshot_cmds.AddCommands()
-  zone_cmds.AddCommands()
-
-
-  # Registers the version checker.
-  vc = version_checker.VersionChecker()
-  atexit.register(vc.CheckForNewVersion)
-
-if __name__ == '__main__':
-  appcommands.Run()

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/gcutil_logging.py

@@ -1,69 +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.
-
-"""Common code for logging across gcutil."""
-
-import logging
-
-import gflags as flags
-
-FLAGS = flags.FLAGS
-
-_LOG_ROOT = 'gcutil-logs'
-LOGGER = logging.getLogger(_LOG_ROOT)
-
-CRITICAL = logging.CRITICAL
-FATAL = logging.FATAL
-ERROR = logging.ERROR
-WARNING = logging.WARNING
-WARN = logging.WARN
-INFO = logging.INFO
-DEBUG = logging.DEBUG
-
-_LOG_LEVELS = (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-_LOG_LEVEL_NAMES = tuple(map(logging.getLevelName, _LOG_LEVELS))
-
-
-flags.DEFINE_enum(
-    'log_level',
-    logging.getLevelName(logging.INFO),
-    _LOG_LEVEL_NAMES,
-    'Logging output level for core Google Compute Engine messages.  '
-    'For logging output from other libraries, use library_log_level.')
-flags.DEFINE_enum(
-    'library_log_level',
-    logging.getLevelName(logging.WARN),
-    _LOG_LEVEL_NAMES,
-    'Logging output level for libraries.')
-
-
-def SetupLogging():
-  """Set up a logger that will have its own logging level."""
-  gc_handler = logging.StreamHandler()
-  gc_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
-  LOGGER.addHandler(gc_handler)
-  LOGGER.propagate = False
-
-  log_level_map = dict(
-      [(logging.getLevelName(level), level) for level in _LOG_LEVELS])
-
-  # Update library_log_level to INFO if user wants to see
-  # dump_request_response.
-  if FLAGS.dump_request_response:
-    if (not FLAGS['library_log_level'].present and
-        not logging.getLogger().isEnabledFor(logging.INFO)):
-      FLAGS.library_log_level = 'INFO'
-
-  LOGGER.setLevel(log_level_map[FLAGS.log_level])
-  logging.getLogger().setLevel(log_level_map[FLAGS.library_log_level])

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/image_cmds.py

@@ -1,262 +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 machine images."""
-
-
-
-
-
-from google.apputils import appcommands
-import gflags as flags
-
-from gcutil import command_base
-
-
-FLAGS = flags.FLAGS
-
-
-
-class ImageCommand(command_base.GoogleComputeCommand):
-  """Base command for working with the images collection."""
-
-  default_sort_field = 'name'
-  summary_fields = (('name', 'name'),
-                    ('description', 'description'),
-                    ('creation-time', 'creationTimestamp'),
-                    ('kernel', 'preferredKernel'))
-
-  detail_fields = (('name', 'name'),
-                   ('description', 'description'),
-                   ('creation-time', 'creationTimestamp'),
-                   ('kernel', 'preferredKernel'))
-
-  resource_collection_name = 'images'
-
-  def __init__(self, name, flag_values):
-    super(ImageCommand, self).__init__(name, 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._images_api = api.images()
-    self._kernels_api = api.kernels()
-
-
-class AddImage(ImageCommand):
-  """Create a new machine image.
-
-  The root_source_tarball parameter must point to a tar file of the
-  contents of the desired root directory stored in Google Storage.
-  """
-
-  positional_args = '<image-name> <root-source-tarball>'
-
-  def __init__(self, name, flag_values):
-    super(AddImage, self).__init__(name, flag_values)
-    flags.DEFINE_string('description',
-                        '',
-                        'Image description',
-                        flag_values=flag_values)
-    flags.DEFINE_string('preferred_kernel',
-                        None,
-                        'Kernel name',
-                        flag_values=flag_values)
-
-  def Handle(self, image_name, root_source_tarball):
-    """Add the specified image.
-
-    Args:
-      image_name: The name of the image to add.
-      root_source_tarball: Tarball in Google Storage containing the
-        desired root directory for the resulting image.
-
-    Returns:
-      The result of inserting the image.
-    """
-
-    # Accept gs:// URLs.
-    if root_source_tarball.startswith('gs://'):
-      root_source_tarball = ('http://storage.googleapis.com/' +
-                             root_source_tarball[len('gs://'):])
-
-    image_resource = {
-        'kind': self._GetResourceApiKind('image'),
-        'name': self.DenormalizeResourceName(image_name),
-        'description': self._flags.description,
-        'sourceType': 'RAW',
-        'rawDisk': {
-            'source': root_source_tarball,
-            'containerType': 'TAR'
-            }
-        }
-
-    if self._flags.preferred_kernel:
-      image_resource['preferredKernel'] = self.NormalizeGlobalResourceName(
-          self._project, 'kernels', self._flags.preferred_kernel)
-    elif self._IsUsingAtLeastApiVersion('v1beta14'):
-      kernel = self._PromptForKernel()
-      image_resource['preferredKernel'] = kernel['selfLink']
-    image_request = self._images_api.insert(project=self._project,
-                                            body=image_resource)
-    return image_request.execute()
-
-
-class GetImage(ImageCommand):
-  """Get a machine image."""
-
-  positional_args = '<image-name>'
-
-  def __init__(self, name, flag_values):
-    super(GetImage, self).__init__(name, flag_values)
-
-  def Handle(self, image_name):
-    """GSet the specified image.
-
-    Args:
-      image_name: The name of the image to get.
-
-    Returns:
-      The result of getting the image.
-    """
-    image_request = self._images_api.get(
-        project=self._project,
-        image=self.DenormalizeResourceName(image_name))
-
-    return image_request.execute()
-
-
-class DeleteImage(ImageCommand):
-  """Delete one or more machine images.
-
-  If multiple image names are specified, the images will be deleted in parallel.
-  """
-
-  positional_args = '<image-name-1> ... <image-name-n>'
-  safety_prompt = 'Delete image'
-
-  def __init__(self, name, flag_values):
-    super(DeleteImage, self).__init__(name, flag_values)
-
-  def Handle(self, *image_names):
-    """Delete the specified images.
-
-    Args:
-      *image_names: The names of the images to delete.
-
-    Returns:
-      Tuple (results, exceptions) - results of deleting the images.
-    """
-    requests = []
-    for name in image_names:
-      requests.append(self._images_api.delete(
-          project=self._project,
-          image=self.DenormalizeResourceName(name)))
-    results, exceptions = self.ExecuteRequests(requests)
-    return (self.MakeListResult(results, 'operationList'), exceptions)
-
-
-class ListImages(ImageCommand, command_base.GoogleComputeListCommand):
-  """List the images for a project."""
-
-  def ListFunc(self):
-    """Returns the function for listing images."""
-    return self._images_api.list
-
-
-class Deprecate(ImageCommand):
-  """Sets the deprecation status for an image."""
-
-  positional_args = '<image-name>'
-
-  def __init__(self, name, flag_values):
-    super(Deprecate, self).__init__(name, flag_values)
-    flags.DEFINE_enum('state',
-                      None,
-                      ['DEPRECATED', 'OBSOLETE', 'DELETED'],
-                      'The new deprecation state for this image. '
-                      'Valid values are DEPRECATED, OBSOLETE, and '
-                      'DELETED.  DEPRECATED resources will generate '
-                      'a warning when new uses occur, OBSOLETE '
-                      'and DELETED resources generate an error on '
-                      'new uses.',
-                      flag_values=flag_values)
-    flags.DEFINE_string('replacement',
-                        None,
-                        'A valid full URL to a compute engine image. '
-                        'Users of the deprecated image will be advised '
-                        'to switch to this replacement.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('deprecated_on',
-                        None,
-                        'A valid RFC 3339 full-date or date-time on which '
-                        'the state of this resource became or will become '
-                        'DEPRECATED.  For example:  2020-01-02T00:00:00Z for '
-                        'midnight on January 2nd, 2020.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('obsolete_on',
-                        None,
-                        'A valid RFC 3339 full-date or date-time on which '
-                        'the state of this resource became or will become '
-                        'OBSOLETE.  For example:  2020-01-02T00:00:00Z for '
-                        'midnight on January 2nd, 2020.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('deleted_on',
-                        None,
-                        'A valid RFC 3339 full-date or date-time on which '
-                        'the state of this resource became or will become '
-                        'DELETED.  For example:  2020-01-02T00:00:00Z for '
-                        'midnight on January 2nd, 2020.',
-                        flag_values=flag_values)
-
-  def _BuildRequest(self, image_name):
-    """Build a request to set deprecation status for the given image."""
-    deprecation_status = {
-        'state': self._flags.state,
-        'replacement': self.NormalizeGlobalResourceName(
-            self._project, 'images', self._flags.replacement),
-        'deprecated': self._flags.deprecated_on,
-        'obsolete': self._flags.obsolete_on,
-        'deleted': self._flags.deleted_on,
-        }
-    return self._images_api.deprecate(
-        project=self._project,
-        image=self.DenormalizeResourceName(image_name),
-        body=deprecation_status)
-
-  def Handle(self, image_name):
-    """Sets deprecation status on an image.
-
-    Args:
-      image_name: the name of the image for which deprecation will be set.
-
-    Returns:
-      An operation resource.
-    """
-    set_deprecation_request = self._BuildRequest(image_name)
-    return set_deprecation_request.execute()
-
-
-def AddCommands():
-  appcommands.AddCmd('addimage', AddImage)
-  appcommands.AddCmd('getimage', GetImage)
-  appcommands.AddCmd('deleteimage', DeleteImage)
-  appcommands.AddCmd('listimages', ListImages)
-  appcommands.AddCmd('deprecateimage', Deprecate)