googlecloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,271 @@
+#!/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 version_checker module."""
+
+
+
+import path_initializer
+path_initializer.InitializeSysPath()
+
+import json
+import os
+import tempfile
+
+import httplib2
+
+import unittest
+from gcutil import version_checker
+
+
+class VersionCheckerTests(unittest.TestCase):
+
+  class MockHttp(httplib2.Http):
+    """A mock for httplib2.Http that always times out on requests."""
+
+    def request(self, *unused_args, **unused_kwargs):
+      return (httplib2.Response({
+          'status': '200',
+          'content-length': '81',
+          'last-modified': 'Thu, 28 Jun 2012 21:35:00 GMT',
+          'date': 'Fri, 14 Sep 2012 21:59:51 GMT',
+          'content-type': 'application/json'}),
+              '{\n "version": "1.3.0",\n "package_name": "gcutil-1.3.0"\n}\n')
+
+  def testReadCacheWithNonExistentCacheFile(self):
+    vc = version_checker.VersionChecker(cache_path='non-existent-file')
+    self.assertEqual(vc._ReadCache(), {})
+
+  def testReadCacheWithMalformedJson(self):
+    malformed_caches = (
+        'MALFORMED JSON',
+        '{ "last_checked_version": "1.2", "last_check": 3000.0, }',
+        '{ "last_checked_version": "1.2", "last_check": 3000.0 }}',
+        '{ "last_checked_version": "1.2", "last_check": 3000.0 }bad characters')
+
+    for malformed_cache in malformed_caches:
+      _, bad_cache_file = tempfile.mkstemp()
+      try:
+        with open(bad_cache_file, 'w') as f:
+          f.write(malformed_cache)
+
+        vc = version_checker.VersionChecker(cache_path=bad_cache_file)
+        self.assertEqual(vc._ReadCache(), {})
+      finally:
+        os.remove(bad_cache_file)
+
+  def testReadCacheWithGoodCache(self):
+    _, cache_file = tempfile.mkstemp()
+    try:
+      with open(cache_file, 'w') as f:
+        f.write('{ "last_checked_version": "1.2", "last_check": 3000.0 }')
+
+      vc = version_checker.VersionChecker(cache_path=cache_file)
+      self.assertEqual(vc._ReadCache(), {'last_checked_version': '1.2',
+                                         'last_check': 3000})
+    finally:
+      os.remove(cache_file)
+
+  def testWriteToCache(self):
+    _, cache_file = tempfile.mkstemp()
+    try:
+      cache = {'last_checked_version': '1.2', 'last_check': 3000}
+      vc = version_checker.VersionChecker(cache_path=cache_file)
+      vc._WriteToCache(cache)
+
+      with open(cache_file) as f:
+        self.assertEqual(json.load(f), cache)
+    finally:
+      os.remove(cache_file)
+
+  def testUpdateCache(self):
+    vc = version_checker.VersionChecker(
+        cache_ttl_sec=20, current_version='1.2.0')
+    cache = {}
+    vc._UpdateCache(
+        cache, http=VersionCheckerTests.MockHttp(), current_time=123456.7)
+    self.assertEqual(cache['current_version'], '1.2.0')
+    self.assertEqual(cache['last_checked_version'], '1.3.0')
+    self.assertEqual(cache['last_check'], 123456.7)
+
+  def testIsCacheMalformed(self):
+    malformed_caches = (
+        {},
+        {'last_checked_version': 'x', 'last_check': 3000.0,
+         'current_version': 'y'},
+        {'last_checked_version': '1...2', 'last_check': 3000.0,
+         'current_version': '1.2'},
+        {'last_checked_version': '1.2', 'last_check': 3000,
+         'current_version': '1.2.0'},
+        {'last_checked_version': '1.2', 'current_version': '1.2.0'},
+        {'last_checked_version': '1.2.x', 'last_check': 3000,
+             'current_version': '1.2.0'})
+    for cache in malformed_caches:
+      self.assertTrue(version_checker.VersionChecker._IsCacheMalformed(cache))
+
+    good_caches = (
+        {'last_checked_version': '1.3.0', 'last_check': 3000.0,
+         'current_version': '1.2.0'},
+        {'last_checked_version': '1.3.0', 'last_check': 3000.0,
+         'current_version': '1.2.0',
+         'last_check_time': '2012-09-17T18:03:48.792579+00:00',
+         'latest_version': '1.1.20120628.1214'})
+    for cache in good_caches:
+      self.assertFalse(version_checker.VersionChecker._IsCacheMalformed(cache))
+
+  def testIsCacheStale(self):
+    vc = version_checker.VersionChecker(
+        cache_ttl_sec=20, current_version='1.2.0')
+    cache = {'last_checked_version': '1.2', 'last_check': 3000.0,
+             'current_version': '1.2.0'}
+
+    self.assertTrue(vc._IsCacheStale(cache, current_time=1))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=2000))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=2999))
+    self.assertFalse(vc._IsCacheStale(cache, current_time=3000))
+    self.assertFalse(vc._IsCacheStale(cache, current_time=3005))
+    self.assertFalse(vc._IsCacheStale(cache, current_time=3010))
+    self.assertFalse(vc._IsCacheStale(cache, current_time=3019))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3020))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3021))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=4000))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=398457398))
+
+    self.assertTrue(vc._IsCacheStale({}, current_time=1))
+    self.assertTrue(vc._IsCacheStale({}, current_time=2000))
+    self.assertTrue(vc._IsCacheStale({}, current_time=2999))
+    self.assertTrue(vc._IsCacheStale({}, current_time=3000))
+    self.assertTrue(vc._IsCacheStale({}, current_time=3005))
+    self.assertTrue(vc._IsCacheStale({}, current_time=3010))
+    self.assertTrue(vc._IsCacheStale({}, current_time=3019))
+    self.assertTrue(vc._IsCacheStale({}, current_time=3020))
+    self.assertTrue(vc._IsCacheStale({}, current_time=3021))
+    self.assertTrue(vc._IsCacheStale({}, current_time=4000))
+    self.assertTrue(vc._IsCacheStale({}, current_time=398457398))
+
+  def testIsCacheStaleWithMalformedCache(self):
+    vc = version_checker.VersionChecker(
+        cache_ttl_sec=20, current_version='1.2.0')
+    malformed_caches = (
+        {'last_checked_version': '1.2', 'last_check': 3000,
+         'current_version': '1.2.0'},
+        {'last_checked_version': '1.2', 'current_version': '1.2.0'},
+        {'last_checked_version': '1.2.x', 'last_check': 3000,
+             'current_version': '1.2.0'})
+
+    for cache in malformed_caches:
+      self.assertTrue(vc._IsCacheStale(cache, current_time=1))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=2000))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=2999))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=3000))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=3005))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=3010))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=3019))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=3020))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=3021))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=4000))
+      self.assertTrue(vc._IsCacheStale(cache, current_time=398457398))
+
+  def testIsCacheStaleWithUpgradedVersion(self):
+    vc = version_checker.VersionChecker(
+        cache_ttl_sec=20, current_version='1.3.0')
+    cache = {'last_checked_version': '1.3.0', 'last_check': 3000.0,
+             'current_version': '1.2.0'}
+
+    self.assertTrue(vc._IsCacheStale(cache, current_time=1))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=2000))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=2999))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3000))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3005))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3010))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3019))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3020))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=3021))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=4000))
+    self.assertTrue(vc._IsCacheStale(cache, current_time=398457398))
+
+  def testParseVersionString(self):
+    parse_fn = version_checker.VersionChecker._ParseVersionString
+    self.assertEqual(parse_fn('1'), (1,))
+    self.assertEqual(parse_fn('1.2'), (1, 2))
+    self.assertEqual(parse_fn('1.2.0'), (1, 2, 0))
+    self.assertEqual(parse_fn('0.1.0'), (0, 1, 0))
+    self.assertEqual(parse_fn('12.13.14'), (12, 13, 14))
+
+  def testCompareVersions(self):
+    compare_fn = version_checker.VersionChecker._CompareVersions
+    self.assertTrue(compare_fn('0', '1.2'))
+    self.assertTrue(compare_fn('1.2', '1.3'))
+    self.assertTrue(compare_fn('1.2', '1.2.1'))
+    self.assertTrue(compare_fn('1.2.0', '1.2.1'))
+    self.assertTrue(compare_fn('1.2.0', '1.2.13'))
+    self.assertTrue(compare_fn('1.2.0', '1.3'))
+    self.assertFalse(compare_fn('1.3', '1.3'))
+    self.assertFalse(compare_fn('1.2.2', '1.2.0'))
+    self.assertFalse(compare_fn('1.1', '1.0'))
+
+  def testNewVersionExistsWithNonStaleCache(self):
+
+    def MockReadCache():
+      return {'last_checked_version': '1.3.0', 'last_check': 3000.0,
+             'current_version': '1.2.0'}
+
+    def MockIsCacheStale(cache):
+      return False
+
+    vc = version_checker.VersionChecker(current_version='1.2.0')
+    vc._ReadCache = MockReadCache
+    vc._IsCacheStale = MockIsCacheStale
+    self.assertTrue(vc._NewVersionExists())
+
+    vc = version_checker.VersionChecker(current_version='1.3.0')
+    vc._ReadCache = MockReadCache
+    vc._IsCacheStale = MockIsCacheStale
+    self.assertFalse(vc._NewVersionExists())
+
+  def testNewVersionExistsWithStaleCache(self):
+
+    def MockIsCacheStale(cache):
+      return True
+
+    def MockUpdateCache(cache):
+      cache['last_checked_version'] = '1.3.0'
+
+    _, cache_file = tempfile.mkstemp()
+    try:
+      with open(cache_file, 'w') as f:
+        f.write('{ "last_checked_version": "1.2.0", "last_check": 3000.0,'
+                '   "current_version": "1.2.0"}')
+
+        vc = version_checker.VersionChecker(
+            cache_path=cache_file, current_version='1.2.0')
+        vc._IsCacheStale = MockIsCacheStale
+        vc._UpdateCache = MockUpdateCache
+        self.assertTrue(vc._NewVersionExists())
+        self.assertEqual(vc._ReadCache()['last_checked_version'], '1.3.0')
+
+        def MockUpdateCache2(cache):
+          cache['last_checked_version'] = '1.2.0'
+
+        vc._UpdateCache = MockUpdateCache2
+        self.assertFalse(vc._NewVersionExists())
+        self.assertEqual(vc._ReadCache()['last_checked_version'], '1.2.0')
+    finally:
+      os.remove(cache_file)
+
+
+if __name__ == '__main__':
+  unittest.main()

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

@@ -0,0 +1,151 @@
+# 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 availability zones."""
+
+
+
+import iso8601
+
+from google.apputils import appcommands
+import gflags as flags
+
+from gcutil import command_base
+
+
+FLAGS = flags.FLAGS
+
+
+class ZoneCommand(command_base.GoogleComputeCommand):
+  """Base command for working with the zones collection."""
+
+  default_sort_field = 'name'
+  summary_fields = (('name', 'name'),
+                    ('description', 'description'),
+                    ('status', 'status'),
+                    ('next-maintenance-window', 'next_maintenance_window'))
+
+  detail_fields = (('name', 'name'),
+                   ('description', 'description'),
+                   ('creation-time', 'creationTimestamp'),
+                   ('status', 'status'))
+
+  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._zones_api = api.zones()
+    if self._IsUsingAtLeastApiVersion('v1beta14'):
+      self.summary_fields = (
+          ('name', 'name'),
+          ('description', 'description'),
+          ('status', 'status'),
+          ('next-maintenance-window', 'next_maintenance_window'),
+          ('instances-usage', 'instances'),
+          ('cpus-usage', 'cpus'),
+          ('disks-usage', 'disks'),
+          ('disks-total-gb-usage', 'disks_total_gb'))
+
+
+class GetZone(ZoneCommand):
+  """Get a zone."""
+
+  positional_args = '<zone-name>'
+
+  def CustomizePrintResult(self, result, table):
+    """Customized result printing for this type.
+
+    Args:
+      result: json dictionary returned by the server
+      table: the pretty printing table to be customized
+
+    Returns:
+      None.
+
+    """
+    # Add machine types
+    for (i, m) in enumerate(result.get('availableMachineType', [])):
+      key = ''
+      if i == 0:
+        key = 'machine types'
+      table.AddRow((key, self._PresentElement(m)))
+    # Add the maintenance windows
+    table.AddRow(('maintenance-windows', ''))
+    for window in result.get('maintenanceWindows', []):
+      table.AddRow(('', ''))
+      table.AddRow(('  name', window['name']))
+      table.AddRow(('  description', window['description']))
+      table.AddRow(('  begin-time', window['beginTime']))
+      table.AddRow(('  end-time', window['endTime']))
+    # Add the zone quotas
+    table.AddRow(('', ''))
+    table.AddRow(('usage', ''))
+    for quota in result.get('quotas', []):
+      table.AddRow(('  %s' % quota['metric'].lower().replace('_', '-'),
+                    '%s/%s' % (str(quota['usage']), str(quota['limit']))))
+
+  def Handle(self, zone_name):
+    """Get the specified zone.
+
+    Args:
+      zone_name: Path of the zone to get.
+
+    Returns:
+      The result of getting the zone.
+    """
+    request = self._zones_api.get(project=self._project, zone=zone_name)
+    return request.execute()
+
+
+class ListZones(ZoneCommand, command_base.GoogleComputeListCommand):
+  """List available zones for a project."""
+
+  def ListFunc(self):
+    return self._zones_api.list
+
+  def Handle(self):
+    """List the project's zones."""
+    result = super(ListZones, self).Handle()
+    items = result.get('items', [])
+
+    # Add the next maintenance window start time to each entry.
+    for zone in items:
+      next_iso = None
+      next_str = 'None scheduled'
+
+      for window in zone.get('maintenanceWindows', []):
+        begin_str = window['beginTime']
+        begin_iso = iso8601.parse_date(begin_str)
+        if next_iso is None or begin_iso < next_iso:
+          next_iso = begin_iso
+          next_str = begin_str
+
+      zone['next_maintenance_window'] = next_str
+
+      for quota in zone.get('quotas', []):
+        column_name = quota['metric'].lower()
+        zone[column_name] = (
+            '%s/%s' % (str(quota['usage']), str(quota['limit'])))
+
+    return result
+
+
+def AddCommands():
+  appcommands.AddCmd('getzone', GetZone)
+  appcommands.AddCmd('listzones', ListZones)

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

@@ -0,0 +1,60 @@
+#!/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 zone 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 zone_cmds
+
+FLAGS = flags.FLAGS
+
+
+class ZoneCmdsTest(unittest.TestCase):
+
+  def testGetZoneGeneratesCorrectRequest(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = zone_cmds.GetZone('getzone', flag_values)
+
+    expected_jurisdiction = 'test_jurisdiction'
+    expected_region = 'test_region'
+    expected_zone = 'z'
+    submitted_full_zone = '%s-%s-%s' % (expected_jurisdiction,
+                                        expected_region,
+                                        expected_zone)
+    flag_values.service_version = command_base.CURRENT_VERSION
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+
+    result = command.Handle(submitted_full_zone)
+
+    self.assertEqual(result['zone'], submitted_full_zone)
+
+
+if __name__ == '__main__':
+  unittest.main()