googlecloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+# Copyright 2007 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.
+
+"""Simple file system utilities."""
+
+__author__ = ('elaforge@google.com (Evan LaForge)',
+              'matthewb@google.com (Matthew Blecker)')
+
+import errno
+import os
+import pwd
+import shutil
+import stat
+import tempfile
+
+
+class PasswdError(Exception):
+  """Exception class for errors loading a password from a file."""
+
+
+def ListDirPath(dir_name):
+  """Like os.listdir with prepended dir_name, which is often more convenient."""
+  return [os.path.join(dir_name, fn) for fn in os.listdir(dir_name)]
+
+
+def Read(filename):
+  """Read entire contents of file with name 'filename'."""
+  fp = open(filename)
+  try:
+    return fp.read()
+  finally:
+    fp.close()
+
+
+def Write(filename, contents, overwrite_existing=True, mode=0666):
+  """Create a file 'filename' with 'contents', with the mode given in 'mode'.
+
+  The 'mode' is modified by the umask, as in open(2).  If
+  'overwrite_existing' is False, the file will be opened in O_EXCL mode.
+
+  Args:
+    filename: str; the name of the file
+    contents: str; the data to write to the file
+    overwrite_existing: bool; whether or not to allow the write if the file
+                        already exists
+    mode: int; permissions with which to create the file (default is 0666 octal)
+  """
+  flags = os.O_WRONLY | os.O_TRUNC | os.O_CREAT
+  if not overwrite_existing:
+    flags |= os.O_EXCL
+  fd = os.open(filename, flags, mode)
+  try:
+    os.write(fd, contents)
+  finally:
+    os.close(fd)
+
+
+def AtomicWrite(filename, contents, mode=0666):
+  """Create a file 'filename' with 'contents' atomically.
+
+  As in Write, 'mode' is modified by the umask.  This creates and moves
+  a temporary file, and errors doing the above will be propagated normally,
+  though it will try to clean up the temporary file in that case.
+
+  This is very similar to the prodlib function with the same name.
+
+  Args:
+    filename: str; the name of the file
+    contents: str; the data to write to the file
+    mode: int; permissions with which to create the file (default is 0666 octal)
+  """
+  (fd, tmp_filename) = tempfile.mkstemp(dir=os.path.dirname(filename))
+  try:
+    os.write(fd, contents)
+  finally:
+    os.close(fd)
+  try:
+    os.chmod(tmp_filename, mode)
+    os.rename(tmp_filename, filename)
+  except OSError, exc:
+    try:
+      os.remove(tmp_filename)
+    except OSError, e:
+      exc = OSError('%s. Additional errors cleaning up: %s' % (exc, e))
+    raise exc
+
+
+def MkDirs(directory, force_mode=None):
+  """Makes a directory including its parent directories.
+
+  This function is equivalent to os.makedirs() but it avoids a race
+  condition that os.makedirs() has.  The race is between os.mkdir() and
+  os.path.exists() which fail with errors when run in parallel.
+
+  Args:
+    directory: str; the directory to make
+    force_mode: optional octal, chmod dir to get rid of umask interaction
+  Raises:
+    Whatever os.mkdir() raises when it fails for any reason EXCLUDING
+    "dir already exists".  If a directory already exists, it does not
+    raise anything.  This behaviour is different than os.makedirs()
+  """
+  name = os.path.normpath(directory)
+  dirs = name.split(os.path.sep)
+  for i in range(0, len(dirs)):
+    path = os.path.sep.join(dirs[:i+1])
+    try:
+      if path:
+        os.mkdir(path)
+        # only chmod if we created
+        if force_mode is not None:
+          os.chmod(path, force_mode)
+    except OSError, exc:
+      if not (exc.errno == errno.EEXIST and os.path.isdir(path)):
+        raise
+
+
+def RmDirs(dir_name):
+  """Removes dir_name and every non-empty directory in dir_name.
+
+  Unlike os.removedirs and shutil.rmtree, this function doesn't raise an error
+  if the directory does not exist.
+
+  Args:
+    dir_name: Directory to be removed.
+  """
+  try:
+    shutil.rmtree(dir_name)
+  except OSError, err:
+    if err.errno != errno.ENOENT:
+      raise
+
+  try:
+    parent_directory = os.path.dirname(dir_name)
+    while parent_directory:
+      try:
+        os.rmdir(parent_directory)
+      except OSError, err:
+        if err.errno != errno.ENOENT:
+          raise
+
+      parent_directory = os.path.dirname(parent_directory)
+  except OSError, err:
+    if err.errno not in (errno.EACCES, errno.ENOTEMPTY):
+      raise
+
+
+def HomeDir(user=None):
+  """Find the home directory of a user.
+
+  Args:
+    user: int, str, or None - the uid or login of the user to query for,
+          or None (the default) to query for the current process' effective user
+
+  Returns:
+    str - the user's home directory
+
+  Raises:
+    TypeError: if user is not int, str, or None.
+  """
+  if user is None:
+    pw_struct = pwd.getpwuid(os.geteuid())
+  elif isinstance(user, int):
+    pw_struct = pwd.getpwuid(user)
+  elif isinstance(user, str):
+    pw_struct = pwd.getpwnam(user)
+  else:
+    raise TypeError('user must be None or an instance of int or str')
+  return pw_struct.pw_dir

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

@@ -0,0 +1,67 @@
+#!/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.
+
+"""Wrapper around setuptools' pkg_resources with more Google-like names.
+
+This module is not very useful on its own, but many Google open-source projects
+are used to a different naming scheme, and this module makes the transition
+easier.
+"""
+
+__author__ = 'dborowitz@google.com (Dave Borowitz)'
+
+import atexit
+
+import pkg_resources
+
+
+def _Call(func, name):
+  """Call a pkg_resources function.
+
+  Args:
+    func: A function from pkg_resources that takes the arguments
+          (package_or_requirement, resource_name); for more info,
+          see http://peak.telecommunity.com/DevCenter/PkgResources
+    name: A name of the form 'module.name:path/to/resource'; this should
+          generally be built from __name__ in the calling module.
+
+  Returns:
+    The result of calling the function on the split resource name.
+  """
+  pkg_name, resource_name = name.split(':', 1)
+  return func(pkg_name, resource_name)
+
+
+def GetResource(name):
+  """Get a resource as a string; see _Call."""
+  return _Call(pkg_resources.resource_string, name)
+
+
+def GetResourceAsFile(name):
+  """Get a resource as a file-like object; see _Call."""
+  return _Call(pkg_resources.resource_stream, name)
+
+
+_extracted_files = False
+
+
+def GetResourceFilename(name):
+  """Get a filename for a resource; see _Call."""
+  global _extracted_files  # pylint: disable-msg=W0603
+  if not _extracted_files:
+    atexit.register(pkg_resources.cleanup_resources)
+    _extracted_files = True
+
+  return _Call(pkg_resources.resource_filename, name)

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

@@ -0,0 +1,217 @@
+#!/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.
+
+"""Script for running Google-style applications.
+
+Unlike normal scripts run through setuptools console_script entry points,
+Google-style applications must be run as top-level scripts.
+
+Given an already-imported module, users can use the RunScriptModule function to
+set up the appropriate executable environment to spawn a new Python process to
+run the module as a script.
+
+To use this technique in your project, first create a module called e.g.
+stubs.py with contents like:
+
+  from google.apputils import run_script_module
+
+  def RunMyScript():
+    import my.script
+    run_script_module.RunScriptModule(my.script)
+
+  def RunMyOtherScript():
+    import my.other_script
+    run_script_module.RunScriptModule(my.other_script)
+
+Then, set up entry points in your setup.py that point to the functions in your
+stubs module:
+
+  setup(
+      ...
+      entry_points = {
+          'console_scripts': [
+              'my_script = my.stubs:RunMyScript',
+              'my_other_script = my.stubs.RunMyOtherScript',
+              ],
+          },
+      )
+
+When your project is installed, setuptools will generate minimal wrapper scripts
+to call your stub functions, which in turn execv your script modules. That's it!
+"""
+
+__author__ = 'dborowitz@google.com (Dave Borowitz)'
+
+import os
+import re
+import sys
+
+
+def FindEnv(progname):
+  """Find the program in the system path.
+
+  Args:
+    progname: The name of the program.
+
+  Returns:
+    The full pathname of the program.
+
+  Raises:
+    AssertionError: if the program was not found.
+  """
+  for path in os.environ['PATH'].split(':'):
+    fullname = os.path.join(path, progname)
+    if os.access(fullname, os.X_OK):
+      return fullname
+  raise AssertionError(
+      "Could not find an executable named '%s' in the system path" % progname)
+
+
+def GetPdbArgs(python):
+  """Try to get the path to pdb.py and return it in a list.
+
+  Args:
+    python: The full path to a Python executable.
+
+  Returns:
+    A list of strings. If a relevant pdb.py was found, this will be
+    ['/path/to/pdb.py']; if not, return ['-m', 'pdb'] and hope for the best.
+    (This latter technique will fail for Python 2.2.)
+  """
+  # Usually, python is /usr/bin/pythonxx and pdb is /usr/lib/pythonxx/pdb.py
+  components = python.split('/')
+  if len(components) >= 2:
+    pdb_path = '/'.join(components[0:-2] + ['lib'] +
+                        components[-1:] + ['pdb.py'])
+    if os.access(pdb_path, os.R_OK):
+      return [pdb_path]
+
+  # No pdb module found in the python path, default to -m pdb
+  return ['-m', 'pdb']
+
+
+def StripDelimiters(s, beg, end):
+  if s[0] == beg:
+    assert s[-1] == end
+    return (s[1:-1], True)
+  else:
+    return (s, False)
+
+
+def StripQuotes(s):
+  (s, stripped) = StripDelimiters(s, '"', '"')
+  if not stripped:
+    (s, stripped) = StripDelimiters(s, "'", "'")
+  return s
+
+
+def PrintOurUsage():
+  """Print usage for the stub script."""
+  print 'Stub script %s (auto-generated). Options:' % sys.argv[0]
+  print ('--helpstub               '
+         'Show help for stub script.')
+  print ('--debug_binary           '
+         'Run python under debugger specified by --debugger.')
+  print ('--debugger=<debugger>    '
+         "Debugger for --debug_binary. Default: 'gdb --args'.")
+  print ('--debug_script           '
+         'Run wrapped script with python debugger module (pdb).')
+  print ('--show_command_and_exit  '
+         'Print command which would be executed and exit.')
+  print ('These options must appear first in the command line, all others will '
+         'be passed to the wrapped script.')
+
+
+def RunScriptModule(module):
+  """Run a module as a script.
+
+  Locates the module's file and runs it in the current interpreter, or
+  optionally a debugger.
+
+  Args:
+    module: The module object to run.
+  """
+  args = sys.argv[1:]
+
+  debug_binary = False
+  debugger = 'gdb --args'
+  debug_script = False
+  show_command_and_exit = False
+
+  while args:
+    if args[0] == '--helpstub':
+      PrintOurUsage()
+      sys.exit(0)
+    if args[0] == '--debug_binary':
+      debug_binary = True
+      args = args[1:]
+      continue
+    if args[0] == '--debug_script':
+      debug_script = True
+      args = args[1:]
+      continue
+    if args[0] == '--show_command_and_exit':
+      show_command_and_exit = True
+      args = args[1:]
+      continue
+    matchobj = re.match('--debugger=(.+)', args[0])
+    if matchobj is not None:
+      debugger = StripQuotes(matchobj.group(1))
+      args = args[1:]
+      continue
+    break
+
+  # Now look for my main python source file
+  # TODO(dborowitz): This will fail if the module was zipimported, which means
+  # no egg depending on this script runner can be zip_safe.
+  main_filename = module.__file__
+  assert os.path.exists(main_filename), ('Cannot exec() %r: file not found.' %
+                                         main_filename)
+  assert os.access(main_filename, os.R_OK), ('Cannot exec() %r: file not'
+                                             ' readable.' % main_filename)
+
+  args = [main_filename] + args
+
+  if debug_binary:
+    debugger_args = debugger.split()
+    program = debugger_args[0]
+    # If pathname is not absolute, determine full path using PATH
+    if not os.path.isabs(program):
+      program = FindEnv(program)
+    python_path = sys.executable
+    command_vec = [python_path]
+    if debug_script:
+      command_vec.extend(GetPdbArgs(python_path))
+    args = [program] + debugger_args[1:] + command_vec + args
+
+  elif debug_script:
+    args = [sys.executable] + GetPdbArgs(program) + args
+
+  else:
+    program = sys.executable
+    args = [sys.executable] + args
+
+  if show_command_and_exit:
+    print 'program: "%s"' % program
+    print 'args:', args
+    sys.exit(0)
+
+  try:
+    sys.stdout.flush()
+    os.execv(program, args)
+  except EnvironmentError, e:
+    if not getattr(e, 'filename', None):
+      e.filename = program  # Add info to error message
+    raise