gcloud 0.0.7 → 0.1.0

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

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

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

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

@@ -1,140 +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.
-
-"""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