googlecloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,133 @@
+#!/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 network commands."""
+
+
+
+import path_initializer
+path_initializer.InitializeSysPath()
+
+import copy
+
+import gflags as flags
+import unittest
+
+from gcutil import command_base
+from gcutil import mock_api
+from gcutil import network_cmds
+
+FLAGS = flags.FLAGS
+
+
+class NetworkCmdsTest(unittest.TestCase):
+
+  def _doTestAddNetworkGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = network_cmds.AddNetwork('addnetwork', flag_values)
+
+    expected_project = 'test_project'
+    expected_network = 'test-network'
+    expected_range = '192.168.0.0/16'
+    expected_gateway = '192.168.0.1'
+    expected_description = 'test network'
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+    flag_values.range = expected_range
+    flag_values.gateway = expected_gateway
+    flag_values.service_version = service_version
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+
+    result = command.Handle(expected_network)
+
+    self.assertEqual(result['project'], expected_project)
+
+    response_body = result['body']
+    self.assertEqual(response_body['name'], expected_network)
+    self.assertEqual(response_body['description'], expected_description)
+
+    self.assertEqual(response_body['IPv4Range'], expected_range)
+    self.assertEqual(response_body['gatewayIPv4'], expected_gateway)
+
+  def testAddNetworkGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._doTestAddNetworkGeneratesCorrectRequest(version)
+
+  def testGetNetworkGeneratesCorrectRequest(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = network_cmds.GetNetwork('getnetwork', flag_values)
+
+    expected_project = 'test_project'
+    expected_network = 'test_network'
+    flag_values.project = expected_project
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+
+    result = command.Handle(expected_network)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['network'], expected_network)
+
+  def testDeleteNetworkGeneratesCorrectRequest(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = network_cmds.DeleteNetwork('deletenetwork', flag_values)
+
+    expected_project = 'test_project'
+    expected_network = 'test_network'
+    flag_values.project = expected_project
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(expected_network)
+    self.assertEqual(exceptions, [])
+    self.assertEqual(len(results['items']), 1)
+    result = results['items'][0]
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['network'], expected_network)
+
+  def testDeleteMultipleNetworks(self):
+    flag_values = copy.deepcopy(FLAGS)
+    command = network_cmds.DeleteNetwork('deletenetwork', flag_values)
+
+    expected_project = 'test_project'
+    expected_networks = ['test-network-%02d' % x for x in xrange(100)]
+    flag_values.project = expected_project
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(*expected_networks)
+    self.assertEqual(exceptions, [])
+    results = results['items']
+    self.assertEqual(len(results), len(expected_networks))
+
+    for expected_network, result in zip(expected_networks, results):
+      self.assertEqual(result['project'], expected_project)
+      self.assertEqual(result['network'], expected_network)
+
+
+if __name__ == '__main__':
+  unittest.main()

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

@@ -0,0 +1,181 @@
+# 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 operations."""
+
+
+
+from google.apputils import appcommands
+import gflags as flags
+
+from gcutil import command_base
+
+
+FLAGS = flags.FLAGS
+
+
+class OperationCommand(command_base.GoogleComputeCommand):
+  """Base command for working with the operations collection.
+
+  Attributes:
+    default_sort_field: The json field name used to sort list output for the
+        command.
+    summary_fields: A set of tuples of (json field name, human
+        readable name) used to generate a pretty-printed summary description
+        of a list of operation resources.
+    detail_fields: A set of tuples of (json field name, human
+        readable name) used to generate a pretty-printed detailed description
+        of an operation resource.
+    resource_collection_name: The name of the REST API collection handled by
+        this command type.
+  """
+
+  default_sort_field = (
+      command_base.GoogleComputeCommand.operation_default_sort_field)
+  summary_fields = command_base.GoogleComputeCommand.operation_summary_fields
+  detail_fields = command_base.GoogleComputeCommand.operation_detail_fields
+
+  resource_collection_name = 'operations'
+
+  def __init__(self, name, flag_values):
+    super(OperationCommand, self).__init__(name, flag_values)
+    flags.DEFINE_string('zone',
+                        None,
+                        'The name of the operation zone or \'%s\' for global '
+                        'operations.' % command_base.GLOBAL_ZONE_NAME,
+                        flag_values=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.
+    """
+    self._zones_api = api.zones()
+
+    if self._IsUsingAtLeastApiVersion('v1beta14'):
+      self._zone_operations_api = api.zoneOperations()
+      self._global_operations_api = api.globalOperations()
+    else:
+      self._global_operations_api = api.operations()
+
+  def _PrepareRequestArgs(self, operation_name, **other_args):
+    """Gets the dictionary of API method keyword arguments.
+
+    Args:
+      operation_name: The name of the operation.
+      **other_args: Keyword arguments that should be included in the request.
+
+    Returns:
+      Dictionary of keyword arguments that should be passed in the API call,
+      includes all keyword arguments passed in 'other_args' plus
+      common keys such as the name of the resource and the project.
+    """
+
+    kwargs = {
+        'project': self._project,
+        'operation': self.DenormalizeResourceName(operation_name)
+    }
+    if self._IsUsingAtLeastApiVersion('v1beta14'):
+      if self._flags.zone != command_base.GLOBAL_ZONE_NAME:
+        kwargs['zone'] = self._flags.zone
+    for key, value in other_args.items():
+      kwargs[key] = value
+    return kwargs
+
+
+class GetOperation(OperationCommand):
+  """Retrieve an operation resource."""
+
+  positional_args = '<operation-name>'
+
+  def Handle(self, operation_name):
+    """Get the specified operation.
+
+    Args:
+      operation_name: The name of the operation to get.
+
+    Returns:
+      The json formatted object resulting from retrieving the operation
+      resource.
+    """
+    # Force asynchronous mode so the caller doesn't wait for this operation
+    # to complete before returning.
+    self._flags.synchronous_mode = False
+
+    kwargs = self._PrepareRequestArgs(operation_name)
+    method = self._global_operations_api.get
+
+    if self._IsUsingAtLeastApiVersion('v1beta14') and 'zone' in kwargs:
+      method = self._zone_operations_api.get
+
+    request = method(**kwargs)
+    return request.execute()
+
+
+class DeleteOperation(OperationCommand):
+  """Delete one or more operations."""
+
+  positional_args = '<operation-name-1> ... <operation-name-n>'
+  safety_prompt = 'Delete operation'
+
+  def Handle(self, *operation_names):
+    """Delete the specified operations.
+
+    Args:
+      *operation_names: The names of the operations to delete.
+
+    Returns:
+      Tuple (results, exceptions) - results of deleting the operations.
+    """
+    requests = []
+    for operation_name in operation_names:
+      kwargs = self._PrepareRequestArgs(operation_name)
+      method = self._global_operations_api.delete
+      if self._IsUsingAtLeastApiVersion('v1beta14') and 'zone' in kwargs:
+        method = self._zone_operations_api.delete
+      requests.append(method(**kwargs))
+
+    _, exceptions = self.ExecuteRequests(requests)
+    return '', exceptions
+
+
+class ListOperations(OperationCommand, command_base.GoogleComputeListCommand):
+  """List the operations for a project."""
+
+  is_global_level_collection = True
+  is_zone_level_collection = True
+
+  def __init__(self, name, flag_values):
+    super(OperationCommand, self).__init__(name, flag_values)
+    flags.DEFINE_string('zone',
+                        None,
+                        'The zone to list.',
+                        flag_values=flag_values)
+
+  def ListFunc(self):
+    """Returns the function for listing global operations."""
+    return self._global_operations_api.list
+
+  def ListZoneFunc(self):
+    """Returns the function for listing operations in a zone."""
+    if self._IsUsingAtLeastApiVersion('v1beta14'):
+      return self._zone_operations_api.list
+    return self._global_operations_api.list
+
+
+def AddCommands():
+  appcommands.AddCmd('getoperation', GetOperation)
+  appcommands.AddCmd('deleteoperation', DeleteOperation)
+  appcommands.AddCmd('listoperations', ListOperations)

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

@@ -0,0 +1,196 @@
+#!/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 asynchronous operations commands."""
+
+
+
+import path_initializer
+path_initializer.InitializeSysPath()
+
+import copy
+
+import gflags as flags
+import unittest
+
+from gcutil import command_base
+from gcutil import mock_api
+from gcutil import operation_cmds
+
+FLAGS = flags.FLAGS
+
+
+class OperationCmdsTest(unittest.TestCase):
+
+  def _DoTestGetOperationGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = operation_cmds.GetOperation('getoperation', flag_values)
+
+    expected_project = 'test_project'
+    expected_operation = 'test_operation'
+    flag_values.project = expected_project
+    flag_values.service_version = service_version
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      submitted_zone = 'myzone'
+      flag_values.zone = submitted_zone
+
+    result = command.Handle(expected_operation)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['operation'], expected_operation)
+
+    api = command._global_operations_api
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      api = command._zone_operations_api
+
+    self.assertEquals(1, len(api.requests))
+    request = api.requests[0]
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      self.assertEqual(submitted_zone, request.request_payload['zone'])
+    else:
+      self.assertFalse('zone' in request.request_payload)
+    self.assertEqual(expected_project, request.request_payload['project'])
+    self.assertEqual(expected_operation, request.request_payload['operation'])
+
+  def testGetOperationGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestGetOperationGeneratesCorrectRequest(version)
+
+  def _DoTestDeleteOperationGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = operation_cmds.DeleteOperation('deleteoperation', flag_values)
+
+    expected_project = 'test_project'
+    expected_operation = 'test_operation'
+    flag_values.project = expected_project
+    flag_values.service_version = service_version
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      submitted_zone = 'myzone'
+      flag_values.zone = submitted_zone
+
+    results, exceptions = command.Handle(expected_operation)
+    self.assertEqual(exceptions, [])
+    self.assertEqual(results, '')
+
+    # Verify the request
+    api = command._global_operations_api
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      api = command._zone_operations_api
+
+    self.assertEquals(1, len(api.requests))
+    request = api.requests[0]
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      self.assertEqual(submitted_zone, request.request_payload['zone'])
+    else:
+      self.assertFalse('zone' in request.request_payload)
+    self.assertEqual(expected_project, request.request_payload['project'])
+    self.assertEqual(expected_operation, request.request_payload['operation'])
+
+  def testDeleteOperationGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestDeleteOperationGeneratesCorrectRequest(version)
+
+  def _DoTestGetGlobalOperationGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = operation_cmds.GetOperation('getoperation', flag_values)
+
+    expected_project = 'test_project'
+    expected_operation = 'test_operation'
+    flag_values.project = expected_project
+    flag_values.service_version = service_version
+    flag_values.zone = command_base.GLOBAL_ZONE_NAME
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+    if not command._IsUsingAtLeastApiVersion('v1beta14'):
+      return
+
+    command.Handle(expected_operation)
+
+    # Verify the request
+    self.assertEquals(1, len(command._global_operations_api.requests))
+    request = command._global_operations_api.requests[0]
+    self.assertEqual('get', request.method_name)
+    self.assertEqual(expected_project, request.request_payload['project'])
+    self.assertEqual(expected_operation, request.request_payload['operation'])
+
+  def testGetGlobalOperationGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestGetGlobalOperationGeneratesCorrectRequest(version)
+
+  def _DoTestDeleteGlobalOperationGeneratesCorrectRequest(self,
+                                                          service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = operation_cmds.DeleteOperation('deleteoperation', flag_values)
+
+    expected_project = 'test_project'
+    expected_operation = 'test_operation'
+    flag_values.project = expected_project
+    flag_values.service_version = service_version
+    flag_values.zone = command_base.GLOBAL_ZONE_NAME
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+    if not command._IsUsingAtLeastApiVersion('v1beta14'):
+      return
+
+    results, exceptions = command.Handle(expected_operation)
+    self.assertEqual(exceptions, [])
+    self.assertEqual(results, '')
+
+    # Verify the request
+    self.assertEquals(1, len(command._global_operations_api.requests))
+    request = command._global_operations_api.requests[0]
+    self.assertEqual('delete', request.method_name)
+    self.assertEqual(expected_project, request.request_payload['project'])
+    self.assertEqual(expected_operation, request.request_payload['operation'])
+
+  def testDeleteGlobalOperationGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestDeleteGlobalOperationGeneratesCorrectRequest(version)
+
+  def testDeleteMultipleOperations(self):
+    flag_values = copy.deepcopy(FLAGS)
+    command = operation_cmds.DeleteOperation('deleteoperation', flag_values)
+
+    expected_project = 'test_project'
+    expected_operations = ['test-operation-%02d' % x for x in xrange(100)]
+    flag_values.project = expected_project
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+
+    results, exceptions = command.Handle(*expected_operations)
+    self.assertEqual(exceptions, [])
+    self.assertEqual(results, '')
+
+
+if __name__ == '__main__':
+  unittest.main()