gcloud 0.0.7 → 0.1.0

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

@@ -1,91 +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 installed kernels."""
-
-
-
-
-from google.apputils import appcommands
-import gflags as flags
-
-from gcutil import command_base
-
-
-FLAGS = flags.FLAGS
-
-
-
-class KernelCommand(command_base.GoogleComputeCommand):
-  """Base command for working with the kernels collection."""
-
-  default_sort_field = 'name'
-  summary_fields = (('name', 'name'),
-                    ('description', 'description'))
-
-  detail_fields = (('name', 'name'),
-                   ('description', 'description'),
-                   ('creation-time', 'creationTimestamp'))
-
-  resource_collection_name = 'kernels'
-
-  def __init__(self, name, flag_values):
-    super(KernelCommand, 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._kernels_api = api.kernels()
-
-
-class GetKernel(KernelCommand):
-  """Get a kernel."""
-
-  def __init__(self, name, flag_values):
-    super(GetKernel, self).__init__(name, flag_values)
-
-  def Handle(self, kernel_name):
-    """Get the specified kernel.
-
-    Args:
-      kernel_name: The name of the kernel to get.
-
-    Returns:
-      The result of getting the kernel.
-    """
-    kernel_request = self._kernels_api.get(
-        project=self._project,
-        kernel=self.DenormalizeResourceName(kernel_name))
-
-    return kernel_request.execute()
-
-
-class ListKernels(KernelCommand, command_base.GoogleComputeListCommand):
-  """List the kernels for a project."""
-
-  def ListFunc(self):
-    """Returns the fuction for listing kernels."""
-    return self._kernels_api.list
-
-
-def AddCommands():
-  appcommands.AddCmd('getkernel', GetKernel)
-  appcommands.AddCmd('listkernels', ListKernels)

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

@@ -1,56 +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.
-
-"""Unit tests for the kernel commands."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import copy
-
-import gflags as flags
-import unittest
-
-from gcutil import kernel_cmds
-from gcutil import mock_api
-
-FLAGS = flags.FLAGS
-
-
-class KernelCmdsTest(unittest.TestCase):
-
-  def testGetKernelGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = kernel_cmds.GetKernel('getkernel', flag_values)
-
-    expected_project = 'test_project'
-    expected_kernel = 'test_kernel'
-    flag_values.project = expected_project
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-
-    result = command.Handle(expected_kernel)
-
-    self.assertEqual(result['project'], expected_project)
-    self.assertEqual(result['kernel'], expected_kernel)
-
-
-if __name__ == '__main__':
-  unittest.main()

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

@@ -1,106 +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 types."""
-
-
-
-
-from google.apputils import appcommands
-import gflags as flags
-
-from gcutil import command_base
-
-
-FLAGS = flags.FLAGS
-
-
-
-class MachineTypeCommand(command_base.GoogleComputeCommand):
-  """Base command for working with the machine types collection."""
-
-  default_sort_field = 'name'
-  summary_fields = (('name', 'name'),
-                    ('description', 'description'),
-                    ('cpus', 'guestCpus'),
-                    ('memory-mb', 'memoryMb'),
-                    ('ephemeral-disk-size-gb', 'ephemeralDisks.diskGb'),
-                    ('max-pds', 'maximumPersistentDisks'),
-                    ('max-total-pd-size-gb', 'maximumPersistentDisksSizeGb'))
-
-  detail_fields = (('name', 'name'),
-                   ('description', 'description'),
-                   ('creation-time', 'creationTimestamp'),
-                   ('cpus', 'guestCpus'),
-                   ('memory-mb', 'memoryMb'),
-                   ('ephemeral-disk-size-gb', 'ephemeralDisks.diskGb'),
-                   ('max-pds', 'maximumPersistentDisks'),
-                   ('max-total-pd-size-gb',
-                    'maximumPersistentDisksSizeGb'),
-                   ('available-zones', 'availableZone'))
-
-  resource_collection_name = 'machineTypes'
-
-  def __init__(self, name, flag_values):
-    super(MachineTypeCommand, 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._machine_type_api = api.machineTypes()
-
-
-class GetMachineType(MachineTypeCommand):
-  """Get a machine type."""
-
-  def __init__(self, name, flag_values):
-    super(GetMachineType, self).__init__(name, flag_values)
-
-  def Handle(self, machine_type_name):
-    """Get the specified machine type.
-
-    Args:
-      machine_type_name: Name of the machine type to get.
-
-    Returns:
-      The result of getting the machine type.
-    """
-    machine_type_name = self.DenormalizeResourceName(machine_type_name)
-
-    machine_request = self._machine_type_api.get(
-        project=self._project,
-        machineType=machine_type_name)
-
-    return machine_request.execute()
-
-
-class ListMachineTypes(MachineTypeCommand,
-                       command_base.GoogleComputeListCommand):
-  """List the machine types for a project."""
-
-  def ListFunc(self):
-    """Returns the function for listing machine types."""
-    return self._machine_type_api.list
-
-
-def AddCommands():
-  appcommands.AddCmd('getmachinetype', GetMachineType)
-  appcommands.AddCmd('listmachinetypes', ListMachineTypes)

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

@@ -1,59 +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.
-
-"""Unit tests for the machine type commands."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import copy
-
-import gflags as flags
-import unittest
-
-from gcutil import command_base
-from gcutil import machine_type_cmds
-
-try:
-  from gcutil import mock_api
-except ImportError:
-  import mock_api
-
-FLAGS = flags.FLAGS
-
-
-class MachineTypeCmdsTest(unittest.TestCase):
-
-  def testGetMachineTypeGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = machine_type_cmds.GetMachineType('getmachinetype', flag_values)
-
-    expected_machine_type = 'test_machine_type'
-    flag_values.service_version = command_base.CURRENT_VERSION
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-
-    result = command.Handle(expected_machine_type)
-
-    self.assertEqual(result['machineType'], expected_machine_type)
-
-
-if __name__ == '__main__':
-  unittest.main()

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

@@ -1,96 +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.
-
-"""Helper class for metadata parsing from flags and reading from files."""
-
-from __future__ import with_statement
-
-
-
-
-from google.apputils import app
-import gflags as flags
-
-
-class MetadataFlagsProcessor(object):
-  """Helper class for processing flags and building the metadata list."""
-
-  def __init__(self, flag_values):
-    flags.DEFINE_multistring('metadata',
-                             [],
-                             'Metadata to be made available within the VM '
-                             'environment via the local metadata server. This '
-                             'should be in the form key:value. Metadata keys '
-                             'must be unique',
-                             flag_values=flag_values)
-    flags.DEFINE_multistring('metadata_from_file',
-                             [],
-                             'Metadata to be made available within the VM '
-                             'environment via the local metadata server. The '
-                             'value is loaded from a file. This should be in '
-                             'the form key:filename. Metadata keys must be '
-                             'unique',
-                             flag_values=flag_values)
-    self._flags = flag_values
-
-  def GatherMetadata(self):
-    """Gather the list of metadata dictionaries based on the parsed flag values.
-
-    Returns:
-      A list of 'key'/'value' dictionaries defining the metadata.
-    Raises:
-      app.UsageError: If the parsed flag values are malformed.
-    """
-    metadata_dict = {}
-
-    def CheckKey(key, metadata_dict):
-      """Raises KeyError if key is already in metadata_dict."""
-      if key in metadata_dict:
-        raise app.UsageError('The key \'%s\' has been specified more than once.'
-                             ' Metadata keys must be unique' % key)
-
-    def GatherFromList(metadata_entries, metadata_dict):
-      for metadata in metadata_entries:
-        if ':' not in metadata:
-          raise app.UsageError('Wrong syntax for metadata %s. Use key:value.',
-                               metadata)
-        key_value = metadata.split(':', 1)
-        key = key_value[0]
-        CheckKey(key, metadata_dict)
-        value = ''
-        if len(key_value) > 1:
-          value = key_value[1]
-          metadata_dict[key] = value
-
-    def GatherFromFiles(metadata_files, metadata_dict):
-      for metadata_entry in metadata_files:
-        if ':' not in metadata_entry:
-          raise app.UsageError('Wrong syntax for metadata_from_file %s. '
-                               'Use key:filename.', metadata_entry)
-        key_value = metadata_entry.split(':', 1)
-        key = key_value[0]
-        CheckKey(key, metadata_dict)
-        if len(key_value) != 2:
-          raise app.UsageError('No metadata file specified for %s.', key)
-        with open(key_value[1], 'r') as f:
-          metadata_dict[key] = f.read()
-
-    GatherFromList(self._flags.metadata, metadata_dict)
-    GatherFromFiles(self._flags.metadata_from_file, metadata_dict)
-
-    result = []
-    # We sort here to make testing easier.
-    result.extend([{'key': k, 'value': v}
-                   for (k, v) in sorted(metadata_dict.items())])
-    return result

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

@@ -1,357 +0,0 @@
-#!/usr/bin/python2.4
-#
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-
-"""Helper module for fetching metadata variables."""
-
-
-
-import datetime
-import json
-import urllib2
-
-
-class MetadataError(Exception):
-  """Base class for metadata errors."""
-  pass
-
-
-class NoMetadataServerError(MetadataError):
-  """Metadata server is not responding."""
-  pass
-
-
-class MetadataNotFoundError(MetadataError):
-  """Metadata not present."""
-  pass
-
-
-class Metadata(object):
-  """Client API for the metadata server."""
-
-  DEFAULT_METADATA_URL = 'http://metadata.google.internal/0.1/meta-data'
-
-  def __init__(self, server_address=DEFAULT_METADATA_URL):
-    """Construct a Metadata client.
-
-    Args:
-      server_address: The address of the metadata server.
-    """
-    self._server_address = server_address
-
-  def IsPresent(self):
-    """Return whether the metadata server is ready and available."""
-    try:
-      self.GetInstanceId(timeout=1)
-      return True
-    except MetadataError:
-      return False
-
-  def GetAttribute(self, path, **kwargs):
-    """Return a string value from the attributes/ subpath.
-
-    Args:
-      path: A subpath under attributes/ on the metadata server.
-
-    Returns:
-      The metadata value.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('attributes/%s' % (path), **kwargs)
-
-  def GetValue(self, path, **kwargs):
-    """Return a string value from the metadata server.
-
-    Args:
-      path: The path of the variable.
-
-    Returns:
-      The metadata value.
-
-    Raises:
-      MetadataError on failure.
-      MetadataNotFoundError if the metadata path is not present.
-      NoMetadataServerError if the metadata server does not seem to be present.
-    """
-    url = '%s/%s' % (self._server_address, path)
-    req = urllib2.Request(url)
-    try:
-      return self._DoHttpRequestRead(req, **kwargs)
-    except urllib2.URLError as e:
-      try:
-        if e.reason.errno == 111:
-          raise NoMetadataServerError('Metadata server not responding')
-        if e.reason.errno == -2:
-          raise NoMetadataServerError('Metadata server not resolving')
-      except AttributeError:
-        pass
-
-      raise MetadataError('URLError %s: %s' % (url, e))
-    except urllib2.HTTPError as e:
-      if e.code == 404:
-        raise MetadataNotFoundError('Metadata not found: %s' % (path))
-      raise MetadataError(
-          'Failed to get value %s: %s %s' % (path, e.code, e.reason))
-
-  def GetJSONValue(self, path, **kwargs):
-    """Return a decoded JSON value from the metadata server.
-
-    Args:
-      path: The path of the variable.
-
-    Returns:
-      A json-decoded object.
-
-    Raises:
-      MetadataError on failure.
-      MetadataNotFoundError if the metadata path is not present.
-      NoMetadataServerError if the metadata server does not seem to be present.
-    """
-    try:
-      return json.loads(self.GetValue(path, **kwargs))
-    except ValueError as e:
-      raise MetadataError('Failed to parse JSON: %s', e)
-
-  def GetAccessScopes(self, restrict_scopes=None,
-                      service_account='default'):
-    """Return available scopes for service_account.
-
-    Args:
-      restrict_scopes: Only check for these scopes.
-      service_account: The service_account to get scopes for.
-
-    Return:
-      A list of scopes.
-
-    Raises:
-      MetadataError on failure.
-    """
-    service_account_info = self.GetJSONValue(
-        'service-accounts/%s' % service_account)
-    scope_set = set(service_account_info['scopes'])
-    if restrict_scopes is not None:
-      scope_set = scope_set.intersection(set(restrict_scopes))
-    return list(scope_set)
-
-  def GetAccessToken(self, scopes, service_account='default',
-                     any_available=False):
-    """Get an access token.
-
-    Args:
-      scopes: The set of scopes desired in the access token.
-      service_account: The service account to use.
-      any_available: Allow only a subset of scopes to be in access token.
-
-    Returns:
-      (access-token, expiry-time). Expiry time is a datetime that may be None.
-
-    Raises:
-      MetadataError on failure.
-      MetadataNotFoundError if the token is not present.
-    """
-    if any_available:
-      scopes = self.GetAccessScopes(service_account=service_account,
-                                    restrict_scopes=scopes)
-    path = 'service-accounts/%s/acquire?scopes=%s' % (
-        service_account, '%20'.join(scopes))
-    token_info = self.GetJSONValue(path)
-    if 'accessToken' not in token_info:
-      raise MetadataError('Could not find accessToken in response.')
-
-    def ExtractExpiry(name):
-      """Try to extract a numeric field name from token_info."""
-      if name in token_info:
-        try:
-          return int(token_info[name])
-        except ValueError:
-          raise MetadataError(
-              '%s field %s is non-numeric' % (name, token_info[name]))
-      return None
-
-    # If response provides expiresAt, use it.
-    expires_at = ExtractExpiry('expiresAt')
-    if expires_at:
-      expires_at = datetime.datetime.utcfromtimestamp(expires_at)
-    else:
-      # Otherwise, look for an expiresIn and use it.
-      expires_in = ExtractExpiry('expiresIn')
-      if expires_in:
-        if expires_in > 1000000000:
-          expires_at = datetime.datetime.utcfromtimestamp(expires_in)
-        else:
-          expires_at = (datetime.datetime.utcnow() +
-                        datetime.timedelta(seconds=expires_in))
-
-    return (token_info['accessToken'], expires_at)
-
-  def AuthHttpRequest(self, http_request, scopes, service_account='default',
-                      any_available=False):
-    """Add an authorization header to an http request.
-
-    Args:
-      http_request: A urllib2 HTTP Request.
-      scopes: The scopes desired on the access token.
-      service_account: Which service_account to use.
-      any_available: Allow only a subset of scopes to be in access token.
-
-    Returns:
-      Whether we successfully authorized the request.
-
-    Raises:
-      MetadataError on failure.
-    """
-    (token, expiry) = self.GetAccessToken(scopes,
-                                          service_account=service_account,
-                                          any_available=any_available)
-    http_request.headers['Authorization'] = ('OAuth %s' % (token))
-    return True
-
-  def GetUserKeys(self, **kwargs):
-    """Get the current user keys from the metadata server.
-
-    Returns:
-      A dictionary mapping user names to their ssh keys.
-
-    Raises:
-      MetadataError on failure.
-    """
-    keys = self.GetValue('attributes/sshKeys', **kwargs)
-    keyof = lambda line: line.split(':', 1)[0]
-    return dict(map(lambda line: (keyof(line), line), keys.splitlines()))
-
-  def GetAttachedDisks(self, **kwargs):
-    """Get the set of disks attached to the VM.
-
-    Returns:
-      A list of the disks attached to the VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    data = self.GetJSONValue('attached-disks', **kwargs)
-    if 'disks' not in data:
-      raise MetadataError('No disks in attached-disks')
-    return data['disks']
-
-  def GetInstanceId(self, **kwargs):
-    """Return the unique instance id of this VM.
-
-    Returns:
-      The unique instance id of this VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('instance-id', **kwargs)
-
-  def GetNumericProjectId(self, **kwargs):
-    """Return the numeric project ID for this VM.
-
-    This value is typically useful for Google Storage "legacy access."
-    Other uses should probably use GetProjectId().
-
-    Returns:
-      The numeric project ID for this VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('numeric-project-id', **kwargs)
-
-  def GetProjectId(self, **kwargs):
-    """Return the unique name of the project for this VM.
-
-    Returns:
-      The unique name of the project for this VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('project-id', **kwargs)
-
-  def GetHostname(self, **kwargs):
-    """Get the hostname of the VM.
-
-    Returns:
-      The hostname of the VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('hostname', **kwargs)
-
-  def GetTags(self, **kwargs):
-    """Return the list of tags for the VM.
-
-    Returns:
-      The list of tags for this VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetJSONValue('tags', **kwargs)
-
-  def GetZone(self, **kwargs):
-    """Return the zone of the VM.
-
-    Returns:
-      The zone this VM is running in.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('zone', **kwargs)
-
-  def GetImage(self, **kwargs):
-    """Return the name of this VM's disk image.
-
-    Returns:
-      The name of this VM's disk image.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('image')
-
-  def GetMachineType(self, **kwargs):
-    """Return the name of this VM's machine type.
-
-    Returns:
-      The name of this VM's machine type.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('machine-type', **kwargs)
-
-  def GetDescription(self, **kwargs):
-    """Return the description associated with this VM.
-
-    Returns:
-      The description associated with this VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetValue('description', **kwargs)
-
-  def GetNetwork(self, **kwargs):
-    """Return the network configuration for this VM.
-
-    Returns:
-      The network configuration for this VM.
-
-    Raises:
-      MetadataError on failure.
-    """
-    return self.GetJSONValue('network', **kwargs)
-
-  def _DoHttpRequestRead(self, request, timeout=None):
-    """Open and return contents of an http request."""
-    if timeout is None:
-      return urllib2.urlopen(request).read()
-    else:
-      return urllib2.urlopen(request, timeout=timeout).read()