gcloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,274 @@
+# 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

@@ -0,0 +1,89 @@
+#!/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

@@ -0,0 +1,69 @@
+# 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

@@ -0,0 +1,262 @@
+# 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)