RubyGems - gcloud - Versions diffs - 0.0.7 → 0.1.0 - Mend

gcloud 0.0.7 → 0.1.0

Files changed (998) hide show

data/packages/gcutil-1.7.1/lib/google_compute_engine/gcutil/network_cmds.pyc DELETED Viewed

Binary file

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

@@ -1,133 +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 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 DELETED Viewed

@@ -1,181 +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 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.pyc DELETED Viewed

Binary file

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

@@ -1,196 +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 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()