gcloud 0.0.2 → 0.0.4

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

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

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

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

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

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

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