gcloud 0.0.2 → 0.0.4

data/packages/gcutil-1.7.1/lib/google_apputils/google/apputils/setup_command.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+# Copyright 2010 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.
+
+"""Setuptools extension for running Google-style Python tests.
+
+Google-style Python tests differ from normal Python tests in that each test
+module is intended to be executed as an independent script. In particular, the
+test fixture code in basetest.main() that executes module-wide setUp() and
+tearDown() depends on __main__ being the module under test. This conflicts with
+the usual setuptools test style, which uses a single TestSuite to run all of a
+package's tests.
+
+This package provides a new setuptools command, google_test, that runs all of
+the google-style tests found in a specified directory.
+
+NOTE: This works by overriding sys.modules['__main__'] with the module under
+test, but still runs tests in the same process. Thus it will *not* work if your
+tests depend on any of the following:
+  - Per-process (as opposed to per-module) initialization.
+  - Any entry point that is not basetest.main().
+
+To use the google_test command in your project, do something like the following:
+
+In setup.py:
+  setup(
+      name = "mypackage",
+      ...
+      setup_requires = ["google-apputils>=0.2"],
+      google_test_dir = "tests",
+      )
+
+Run:
+  $ python setup.py google_test
+"""
+
+from distutils import errors
+import imp
+import os
+import re
+import shlex
+import sys
+import traceback
+
+from setuptools.command import test
+
+
+def ValidateGoogleTestDir(unused_dist, unused_attr, value):
+  """Validate that the test directory is a directory."""
+  if not os.path.isdir(value):
+    raise errors.DistutilsSetupError('%s is not a directory' % value)
+
+
+class GoogleTest(test.test):
+  """Command to run Google-style tests after in-place build."""
+
+  description = 'run Google-style tests after in-place build'
+
+  _DEFAULT_PATTERN = r'_(?:unit|reg)?test\.py$'
+
+  user_options = [
+      ('test-dir=', 'd', 'Look for test modules in specified directory.'),
+      ('test-module-pattern=', 'p',
+       ('Pattern for matching test modules. Defaults to %r. '
+        'Only source files (*.py) will be considered, even if more files match '
+        'this pattern.' % _DEFAULT_PATTERN)),
+      ('test-args=', 'a',
+       ('Arguments to pass to basetest.main(). May only make sense if '
+        'test_module_pattern matches exactly one test.')),
+      ]
+
+  def initialize_options(self):
+    self.test_dir = None
+    self.test_module_pattern = self._DEFAULT_PATTERN
+    self.test_args = ''
+
+    # Set to a dummy value, since we don't call the superclass methods for
+    # options parsing.
+    self.test_suite = True
+
+  def finalize_options(self):
+    if self.test_dir is None:
+      if self.distribution.google_test_dir:
+        self.test_dir = self.distribution.google_test_dir
+      else:
+        raise errors.DistutilsOptionError('No test directory specified')
+
+    self.test_module_pattern = re.compile(self.test_module_pattern)
+    self.test_args = shlex.split(self.test_args)
+
+  def _RunTestModule(self, module_path):
+    """Run a module as a test module given its path.
+
+    Args:
+      module_path: The path to the module to test; must end in '.py'.
+
+    Returns:
+      True if the tests in this module pass, False if not or if an error occurs.
+    """
+
+    path, filename = os.path.split(module_path)
+
+    old_argv = sys.argv[:]
+    old_path = sys.path[:]
+    old_modules = sys.modules.copy()
+
+    # Make relative imports in test modules work with our mangled sys.path.
+    sys.path.insert(0, path)
+
+    module_name = filename.replace('.py', '')
+    import_tuple = imp.find_module(module_name, [path])
+    module = imp.load_module(module_name, *import_tuple)
+
+    sys.modules['__main__'] = module
+    sys.argv = [module.__file__] + self.test_args
+
+    # Late import since this must be run with the project's sys.path.
+    import basetest
+    try:
+      try:
+        sys.stderr.write('Testing %s\n' % module_name)
+        basetest.main()
+
+        # basetest.main() should always call sys.exit, so this is very bad.
+        return False
+      except SystemExit, e:
+        returncode, = e.args
+        return not returncode
+      except:
+        traceback.print_exc()
+        return False
+    finally:
+      sys.argv[:] = old_argv
+      sys.path[:] = old_path
+      sys.modules.clear()
+      sys.modules.update(old_modules)
+
+  def run_tests(self):
+    ok = True
+    for path, _, filenames in os.walk(self.test_dir):
+      for filename in filenames:
+        if not filename.endswith('.py'):
+          continue
+        file_path = os.path.join(path, filename)
+        if self.test_module_pattern.search(file_path):
+          ok &= self._RunTestModule(file_path)
+
+    sys.exit(int(not ok))

data/packages/gcutil-1.7.1/lib/google_apputils/google/apputils/shellutil.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+#
+# Copyright 2003 Google Inc. All Rights Reserved.
+
+"""Utility functions for dealing with command interpreters."""
+
+
+
+import os
+
+# Running windows?
+win32 = (os.name == 'nt')
+
+
+def ShellEscapeList(words):
+  """Turn a list of words into a shell-safe string.
+
+  Args:
+    words: A list of words, e.g. for a command.
+
+  Returns:
+    A string of shell-quoted and space-separated words.
+  """
+
+  if win32:
+    return ' '.join(words)
+
+  s = ''
+  for word in words:
+    # Single quote word, and replace each ' in word with '"'"'
+    s += "'" + word.replace("'", "'\"'\"'") + "' "
+
+  return s[:-1]
+
+
+def ShellifyStatus(status):
+  """Translate from a wait() exit status to a command shell exit status."""
+
+  if not win32:
+    if os.WIFEXITED(status):
+      # decode and return exit status
+      status = os.WEXITSTATUS(status)
+    else:
+      # On Unix, the wait() produces a 16 bit return code.  Unix shells
+      # lossily compress this to an 8 bit value, using the formula below.
+      # Shell status code < 128 means the process exited normally, status
+      # code >= 128 means the process died because of a signal.
+      status = 128 + os.WTERMSIG(status)
+  return status

data/packages/gcutil-1.7.1/lib/google_apputils/google/apputils/stopwatch.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+# Copyright 2005 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.
+
+"""A useful class for digesting, on a high-level, where time in a program goes.
+
+Usage:
+
+sw = StopWatch()
+sw.start()
+sw.start('foo')
+foo()
+sw.stop('foo')
+args = overhead_code()
+sw.start('bar')
+bar(args)
+sw.stop('bar')
+sw.dump()
+
+If you start a new timer when one is already running, then the other one will
+stop running, and restart when you stop this timer.  This behavior is very
+useful for when you want to try timing for a subcall without remembering
+what is already running.  For instance:
+
+sw.start('all_this')
+do_some_stuff()
+sw.start('just_that')
+small_but_expensive_function()
+sw.stop('just_that')
+cleanup_code()
+sw.stop('all_this')
+
+In this case, the output will be what you want:  the time spent in
+small_but_expensive function will show up in the timer for just_that and not
+all_this.
+"""
+
+import StringIO
+import time
+
+
+__owner__ = 'dbentley@google.com (Dan Bentley)'
+
+
+class StopWatch(object):
+  """Class encapsulating a timer; see above for example usage.
+
+  Instance variables:
+    timers: map of stopwatch name -> time for each currently running stopwatch,
+            where time is seconds from the epoch of when this stopwatch was
+            started.
+    accum: map of stopwatch name -> accumulated time, in seconds, it has
+            already been run for.
+    stopped: map of timer name -> list of timer names that are blocking it.
+    counters: map of timer name -> number of times it has been started.
+  """
+
+  def __init__(self):
+    self.timers = {}
+    self.accum = {}
+    self.stopped = {}
+    self.counters = {}
+
+  def start(self, timer='total', stop_others=True):
+    """Start a timer.
+
+    Args:
+      timer: str; name of the timer to start, defaults to the overall timer.
+      stop_others: bool; if True, stop all other running timers.  If False, then
+                   you can have time that is spent inside more than one timer
+                   and there's a good chance that the overhead measured will be
+                   negative.
+    """
+    if stop_others:
+      stopped = []
+      for other in list(self.timers):
+        if not other == 'total':
+          self.stop(other)
+          stopped.append(other)
+      self.stopped[timer] = stopped
+    self.counters[timer] = self.counters.get(timer, 0) + 1
+    self.timers[timer] = time.time()
+
+  def stop(self, timer='total'):
+    """Stop a running timer.
+
+    This includes restarting anything that was stopped on behalf of this timer.
+
+    Args:
+      timer: str; name of the timer to stop, defaults to the overall timer.
+
+    Raises:
+      RuntimeError: if timer refers to a timer that was never started.
+    """
+    if timer not in self.timers:
+      raise RuntimeError(
+          'Tried to stop timer that was never started: %s' % timer)
+    self.accum[timer] = self.timervalue(timer)
+    del self.timers[timer]
+    for stopped in self.stopped.get(timer, []):
+      self.start(stopped, stop_others=0)
+
+  def timervalue(self, timer='total', now=None):
+    """Return the value seen by this timer so far.
+
+    If the timer is stopped, this will be the accumulated time it has seen.
+    If the timer is running, this will be the time it has seen up to now.
+    If the timer has never been started, this will be zero.
+
+    Args:
+      timer: str; the name of the timer to report on.
+      now: long; if provided, the time to use for 'now' for running timers.
+    """
+    if not now:
+      now = time.time()
+
+    if timer in self.timers:
+      # Timer is running now.
+      return self.accum.get(timer, 0.0) + (now - self.timers[timer])
+    elif timer in self.accum:
+      # Timer is stopped.
+      return self.accum[timer]
+    else:
+      # Timer is never started.
+      return 0.0
+
+  def overhead(self, now=None):
+    """Calculate the overhead.
+
+    Args:
+      now: (optional) time to use as the current time.
+
+    Returns:
+      The overhead, that is, time spent in total but not in any sub timer.  This
+      may be negative if time was counted in two sub timers.  Avoid this by
+      always using stop_others.
+    """
+    total = self.timervalue('total', now)
+    if total == 0.0:
+      return 0.0
+
+    all_timers = sum(self.accum.itervalues())
+    return total - (all_timers - total)
+
+  def results(self, verbose=False):
+    """Get the results of this stopwatch.
+
+    Args:
+      verbose: bool; if True, show all times; otherwise, show only the total.
+
+    Returns:
+      A list of tuples showing the output of this stopwatch, of the form
+      (name, value, num_starts) for each timer.  Note that if the total timer
+      is not used, non-verbose results will be the empty list.
+    """
+    now = time.time()
+
+    all_names = self.accum.keys()
+    names = []
+
+    if 'total' in all_names:
+      all_names.remove('total')
+    all_names.sort()
+    if verbose:
+      names = all_names
+
+    results = [(name, self.timervalue(name, now=now), self.counters[name])
+               for name in names]
+    if verbose:
+      results.append(('overhead', self.overhead(now=now), 1))
+    if 'total' in self.accum or 'total' in self.timers:
+      results.append(('total', self.timervalue('total', now=now),
+                      self.counters['total']))
+    return results
+
+  def dump(self, verbose=False):
+    """Describes where time in this stopwatch was spent.
+
+    Args:
+      verbose: bool; if True, show all timers; otherwise, show only the total.
+
+    Returns:
+      A string describing the stopwatch.
+    """
+    output = StringIO.StringIO()
+    results = self.results(verbose=verbose)
+    maxlength = max([len(result[0]) for result in results])
+    for result in results:
+      output.write('%*s: %6.2fs\n' % (maxlength, result[0], result[1]))
+    return output.getvalue()
+
+# Create a stopwatch to be publicly used.
+sw = StopWatch()

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

@@ -0,0 +1,140 @@
+# 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.
+
+"""Google Compute Engine specific helpers to use the common auth library."""
+
+
+
+import os
+
+import oauth2client.client as oauth2_client
+import oauth2client.multistore_file as oauth2_multistore_file
+import oauth2client.tools as oauth2_tools
+
+import gflags as flags
+
+from gcutil import auto_auth
+from gcutil import metadata_lib
+
+FLAGS = flags.FLAGS
+
+# These identifieres are required as part of the OAuth2 spec but have
+# limited utility with a command line tool.  Note that the secret
+# isn't really secret here.  These are copied from the Identity tab on
+# the Google APIs Console <http://code.google.com/apis/console>
+OAUTH2_CLIENT_ID = '1025389682001.apps.googleusercontent.com'
+OAUTH2_CLIENT_SECRET = 'xslsVXhA7C8aOfSfb6edB6p6'
+USER_AGENT = 'google-compute-cmdline/1.0'
+
+
+
+flags.DEFINE_string(
+    'credentials_file',
+    '~/.gcutil_auth',
+    'File where user authorization credentials are stored.')
+
+flags.DEFINE_string(
+    'auth_service_account',
+    'default',
+    'Service account to use for automatic authorization. '
+    'Empty string disables automatic authorization.')
+
+flags.DEFINE_string(
+    'authorization_uri_base',
+    'https://accounts.google.com/o/oauth2',
+    'The base URI for authorization requests')
+
+
+def GetCredentialFromStore(scopes,
+                           ask_user=True,
+                           force_reauth=False,
+                           credentials_file=None,
+                           authorization_uri_base=None,
+                           client_id=OAUTH2_CLIENT_ID,
+                           client_secret=OAUTH2_CLIENT_SECRET,
+                           user_agent=USER_AGENT,
+                           metadata=metadata_lib.Metadata(),
+                           logger=None):
+  """Get OAuth2 credentials for a specific scope.
+
+  Args:
+    scopes: A list of OAuth2 scopes to request.
+    ask_user: If True, prompt the user to authenticate.
+    force_reauth: If True, force users to reauth
+    credentials_file: The file to use to get/store credentials. If left at None
+      FLAGS.credentials_file will be used.
+    authorization_uri_base: The base URI for auth requests. If left at None
+      FLAGS.authorization_uri_base will be used.
+    client_id: The OAuth2 client id
+    client_secret: The OAuth2 client secret
+    user_agent: The user agent for requests
+
+  Returns:
+    An OAuth2Credentials object or None
+  """
+  if not credentials_file:
+    credentials_file = FLAGS.credentials_file
+  if not authorization_uri_base:
+    authorization_uri_base = FLAGS.authorization_uri_base
+
+  # Ensure that the directory to contain the credentials file exists.
+  credentials_dir = os.path.expanduser(os.path.dirname(credentials_file))
+  if not os.path.exists(credentials_dir):
+    os.makedirs(credentials_dir)
+
+
+  scopes = sorted(scopes)
+  scopes_str = ' '.join(scopes)
+
+  metadata_present = False
+  if FLAGS.auth_service_account:
+    metadata_present = metadata.IsPresent()
+
+  if FLAGS.auth_service_account and metadata_present:
+    try:
+      return auto_auth.Credentials(
+          metadata,
+          FLAGS.auth_service_account,
+          scopes,
+          any_available=True)
+    except auto_auth.CredentialsNotPresentError, e:
+      pass
+    except auto_auth.CredentialsError, e:
+      # We failed to get the scopes from the metadata server.
+      if logger:
+        logger.warn('Failed to automatically authenticate with service '
+                    'account: %s' % (e))
+
+  storage = oauth2_multistore_file.get_credential_storage(
+      credentials_file, client_id, user_agent, scopes_str)
+
+  credentials = storage.get()
+
+  if force_reauth and credentials:
+    credentials.invalid = True
+  if (not credentials or credentials.invalid == True) and ask_user:
+
+    if FLAGS.auth_service_account and metadata_present:
+      print ('Service account scopes are not enabled for %s on this instance. '
+             'Using manual authentication.') % (FLAGS.auth_service_account)
+
+    flow = oauth2_client.OAuth2WebServerFlow(
+        client_id=client_id,
+        client_secret=client_secret,
+        scope=scopes_str,
+        user_agent=user_agent,
+        auth_uri=authorization_uri_base + '/auth',
+        token_uri=authorization_uri_base + '/token')
+    credentials = oauth2_tools.run(flow, storage)
+  return credentials