gcloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,260 @@
+#!/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 persistent disk snapshot commands."""
+
+
+
+import path_initializer
+path_initializer.InitializeSysPath()
+
+import copy
+import sys
+
+import gflags as flags
+import unittest
+
+from gcutil import command_base
+from gcutil import mock_api
+from gcutil import snapshot_cmds
+
+
+FLAGS = flags.FLAGS
+
+
+class SnapshotCmdsTest(unittest.TestCase):
+
+  def _DoTestAddSnapshotGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = snapshot_cmds.AddSnapshot('addsnapshot', flag_values)
+
+    expected_project = 'test_project'
+    expected_snapshot = 'test_snapshot'
+    expected_description = 'test snapshot'
+    submitted_source_disk = 'disk1'
+    submitted_zone = 'myzone'
+    flag_values.service_version = service_version
+    flag_values.source_disk = submitted_source_disk
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+
+    if command._IsUsingAtLeastApiVersion('v1beta14'):
+      flag_values.zone = submitted_zone
+
+    expected_source_disk = command.NormalizePerZoneResourceName(
+        expected_project,
+        submitted_zone,
+        'disks',
+        submitted_source_disk)
+
+    result = command.Handle(expected_snapshot)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['body']['name'], expected_snapshot)
+    self.assertEqual(result['body']['description'], expected_description)
+    self.assertEqual(result['body']['sourceDisk'], expected_source_disk)
+
+  def testAddSnapshotGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestAddSnapshotGeneratesCorrectRequest(version)
+
+  def _DoTestAddSnapshotWithoutZoneGeneratesCorrectRequest(self,
+                                                           service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = snapshot_cmds.AddSnapshot('addsnapshot', flag_values)
+
+    expected_project = 'test_project'
+    expected_snapshot = 'test_snapshot'
+    expected_description = 'test snapshot'
+    submitted_source_disk = 'disk1'
+    disk_zone = 'us-east-a'
+    api_base = 'https://www.googleapis.com/compute/%s' % service_version
+    disk_self_link = '%s/projects/%s/zones/%s/disks/%s' % (
+        api_base, expected_project, disk_zone, submitted_source_disk)
+
+    flag_values.service_version = service_version
+    flag_values.source_disk = submitted_source_disk
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+
+    zones = {'items': [{'name': disk_zone}]}
+    disks = {'items': [{'name': 'disk1',
+                        'selfLink': disk_self_link}]}
+
+    class MockZonesApi(object):
+      def list(self, **unused_kwargs):
+        return mock_api.MockRequest(zones)
+
+    class MockDisksApi(object):
+      def list(self, **unused_kwargs):
+        return mock_api.MockRequest(disks)
+
+    api = mock_api.MockApi()
+    api.zones = MockZonesApi
+    api.disks = MockDisksApi
+
+    command.SetFlags(flag_values)
+    command.SetApi(api)
+
+    expected_source_disk = command.NormalizePerZoneResourceName(
+        expected_project,
+        disk_zone,
+        'disks',
+        submitted_source_disk)
+
+    result = command.Handle(expected_snapshot)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['body']['name'], expected_snapshot)
+    self.assertEqual(result['body']['description'], expected_description)
+    self.assertEqual(result['body']['sourceDisk'], expected_source_disk)
+
+  def testAddSnapshotWithoutZoneGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestAddSnapshotWithoutZoneGeneratesCorrectRequest(version)
+
+  def testAddSnapshotRequiresSourceDisk(self):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = snapshot_cmds.AddSnapshot('addsnapshot', flag_values)
+
+    expected_project = 'test_project'
+    expected_snapshot = 'test_snapshot'
+    expected_description = 'test snapshot'
+    submitted_version = command_base.CURRENT_VERSION
+    submitted_source_disk = 'disk1'
+
+    flag_values.service_version = submitted_version
+    flag_values.project = expected_project
+    flag_values.description = expected_description
+
+    command.SetFlags(flag_values)
+
+    def GetDiskPath(disk_name):
+      disk_path = 'projects/test_project/disks/%s' % (disk_name)
+      if command._IsUsingAtLeastApiVersion('v1beta14'):
+        disk_path = 'projects/test_project/zones/zone-a/disks/%s' % (disk_name)
+      return disk_path
+
+    disks = {
+        'items': [
+            {'name': GetDiskPath('disk1')},
+            {'name': GetDiskPath('disk2')},
+            {'name': GetDiskPath('disk3')}]}
+
+    class MockDisksApi(object):
+      def list(self, **unused_kwargs):
+        return mock_api.MockRequest(disks)
+
+    api = mock_api.MockApi()
+    api.disks = MockDisksApi
+    command.SetApi(api)
+
+    expected_disk = command.NormalizePerZoneResourceName(
+        expected_project,
+        'zone-a',
+        'disks',
+        submitted_source_disk)
+
+    mock_output = mock_api.MockOutput()
+    mock_input = mock_api.MockInput('1\n\r')
+    oldin = sys.stdin
+    sys.stdin = mock_input
+    oldout = sys.stdout
+    sys.stdout = mock_output
+
+    result = command.Handle(expected_snapshot)
+    self.assertEqual(result['body']['sourceDisk'], expected_disk)
+    sys.stdin = oldin
+    sys.stdout = oldout
+
+  def _DoTestGetSnapshotGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = snapshot_cmds.GetSnapshot('getsnapshot', flag_values)
+
+    expected_project = 'test_project'
+    expected_snapshot = 'test_snapshot'
+    flag_values.project = expected_project
+    flag_values.service_version = service_version
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+
+    result = command.Handle(expected_snapshot)
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['snapshot'], expected_snapshot)
+
+  def testGetSnapshotGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestGetSnapshotGeneratesCorrectRequest(version)
+
+  def _DoTestDeleteSnapshotGeneratesCorrectRequest(self, service_version):
+    flag_values = copy.deepcopy(FLAGS)
+
+    command = snapshot_cmds.DeleteSnapshot('deletesnapshot', flag_values)
+
+    expected_project = 'test_project'
+    expected_snapshot = 'test_snapshot'
+    flag_values.project = expected_project
+
+    command.SetFlags(flag_values)
+    command.SetApi(mock_api.MockApi())
+    command._credential = mock_api.MockCredential()
+    flag_values.service_version = service_version
+
+    results, exceptions = command.Handle(expected_snapshot)
+    self.assertEquals(exceptions, [])
+    self.assertEquals(len(results['items']), 1)
+    result = results['items'][0]
+
+    self.assertEqual(result['project'], expected_project)
+    self.assertEqual(result['snapshot'], expected_snapshot)
+
+  def testDeleteSnapshotGeneratesCorrectRequest(self):
+    for version in command_base.SUPPORTED_VERSIONS:
+      self._DoTestDeleteSnapshotGeneratesCorrectRequest(version)
+
+  def testDeleteMultipleSnapshots(self):
+    flag_values = copy.deepcopy(FLAGS)
+    command = snapshot_cmds.DeleteSnapshot('deletesnapshot', flag_values)
+
+    expected_project = 'test_project'
+    expected_snapshots = ['test-snapshot-%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_snapshots)
+    self.assertEqual(exceptions, [])
+    results = results['items']
+    self.assertEqual(len(results), len(expected_snapshots))
+
+    for expected_snapshot, result in zip(expected_snapshots, results):
+      self.assertEqual(result['project'], expected_project)
+      self.assertEqual(result['snapshot'], expected_snapshot)
+
+
+if __name__ == '__main__':
+  unittest.main()

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

@@ -0,0 +1,266 @@
+# 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.
+
+"""Utility class for creating/storing SSH keys."""
+
+from __future__ import with_statement
+
+
+
+import base64
+import os
+import struct
+import subprocess
+
+
+import gflags as flags
+
+from gcutil import command_base
+from gcutil import gcutil_logging
+
+
+PRIVATE_KEY_FILE = 'google_compute_engine'
+PUBLIC_KEY_FILE = PRIVATE_KEY_FILE + '.pub'
+
+flags.DEFINE_string(
+    'public_key_file',
+    os.path.expanduser('~/.ssh/' + PUBLIC_KEY_FILE),
+    'The location of the default (generated) public ssh key for use '
+    'with Google Cloud Compute instances.')
+
+flags.DEFINE_string(
+    'private_key_file',
+    os.path.expanduser('~/.ssh/' + PRIVATE_KEY_FILE),
+    'The location of the default (generated) private ssh key for use '
+    'with Google Cloud Compute instances.')
+
+flags.DEFINE_string(
+    'ssh_user',
+    os.getenv('USER'),
+    'The default ssh user for the instance.')
+
+FLAGS = flags.FLAGS
+LOGGER = gcutil_logging.LOGGER
+
+
+class Error(Exception):
+  pass
+
+
+class UserSetupError(Error):
+  """Raised the users environment isn't set up correctly."""
+
+  def __init__(self, msg):
+    Error.__init__(self)
+    self.msg = msg
+
+  def __str__(self):
+    return self.msg
+
+
+class SshKeys(object):
+  """Collection of methods that work with Google Compute Engine SSH Keys."""
+
+  @staticmethod
+  def GetAuthorizedUserKeys(use_compute_key=True,
+                            authorized_ssh_keys=None):
+    """Get a typical list of ssh user/key dictionaries.
+
+    Args:
+      use_compute_key: authorize using ~/.ssh/compute.pub
+      authorized_ssh_keys: key string user1:keyfile1,user2:keyfile2...
+
+    Returns:
+      A list of {'user': ..., 'key': ...} dictionaries.
+    """
+    user_keys = []
+
+    if use_compute_key:
+      user_keys.append(SshKeys.GetPublicKey())
+
+    if authorized_ssh_keys:
+      for user_key_file_pair in authorized_ssh_keys:
+        user, key_file = user_key_file_pair.split(':')
+        user_keys.append({'user': user,
+                          'key': SshKeys.GetKeyFromFile(key_file)})
+    return user_keys
+
+  @staticmethod
+  def GetAuthorizedUserKeysFromMetadata(metadata):
+    """Get the set of authorized user keys from the given metadata.
+
+    Args:
+      metadata: list of {'key': ..., 'value': ...} dictionaries.
+    Returns:
+      A list of {'user': ..., 'key':...} dictionaries.
+    """
+
+    def GetAuthorizedUserKeyFromLine(line):
+      line_parts = line.split(':')
+      return {'user': line_parts[0], 'key': line_parts[1]}
+
+    for metadata_entry in metadata:
+      key = metadata_entry['key']
+      value = metadata_entry['value']
+      if key == 'sshKeys':
+        lines = value.split('\n')
+        return [GetAuthorizedUserKeyFromLine(line)
+                for line in lines if ':' in line]
+    return []
+
+  @staticmethod
+  def SetAuthorizedUserKeysInMetadata(metadata, authorized_user_keys):
+    """Add the authorized public ssh keys to the given metadata.
+
+    Args:
+      metadata: A list of {'key': ..., 'value': ...} dictionaries.
+      authorized_user_keys: A list of {'user': ..., 'key':...} dictionaries.
+    Returns:
+      The metadata updated to include exactly one 'sshKeys' entry that
+      matches the given authorized user keys.
+    """
+
+    all_user_keys_string = '\n'.join(
+        ['%(user)s:%(key)s' % user_keys for user_keys in authorized_user_keys])
+    for metadata_entry in metadata:
+      if metadata_entry['key'] == 'sshKeys':
+        metadata_entry['value'] = all_user_keys_string
+        return
+    metadata.append({'key': 'sshKeys', 'value': all_user_keys_string})
+
+  @staticmethod
+  def GetPublicKey():
+    """Returns the standard Compute key for the current user.
+
+    If the key doesn't exist, it will be created and will
+    interactively prompt the user.
+
+    Returns:
+      A dictionary of an user/key pair for the user's ssh key.
+    """
+    SshKeys.EnsureSshKeyCreated()
+    if (not FLAGS['ssh_user'].present) and FLAGS.ssh_user == 'root':
+      LOGGER.warn('Logging into root is not supported on default images. '
+                  'Please specify a different user account with --ssh_user. '
+                  'Use this flag for addinstance and all ssh based commands.')
+    return {'user': FLAGS.ssh_user,
+            'key': SshKeys.GetKeyFromFile(FLAGS.public_key_file)}
+
+  @staticmethod
+  def EnsureSshKeyCreated():
+    """Ensures that the ssh key actually exists.
+
+    This will create a public/private key pair if no existing
+    key pair is found.
+
+    Raises:
+      UserSetupError: Error when generating the ssh key
+    """
+    if (os.path.exists(FLAGS.public_key_file) and
+        os.path.exists(FLAGS.private_key_file)):
+      return
+
+    LOGGER.warn('You don\'t have an ssh key for Google Compute Engine. '
+                'Creating one now...')
+    command_line = [
+        'ssh-keygen',
+        '-t', 'rsa',
+        '-q',
+        '-f', FLAGS.private_key_file,
+    ]
+
+    LOGGER.debug(' '.join(command_line))
+    try:
+      process = subprocess.Popen(command_line)
+      process.communicate()
+      if process.wait() != 0:
+        raise UserSetupError('Error generating compute ssh key.')
+    except OSError as e:
+      raise UserSetupError('There was a problem running ssh-keygen: %s' % e)
+
+  @staticmethod
+  def GetKeyFromFile(key_file):
+    """Read an ssh key from key_file, and return it.
+
+    Args:
+      key_file: the file containing the ssh key
+
+    Returns:
+      A the ssh key stored in the file.
+    """
+    key_file = os.path.expanduser(key_file)
+    with open(key_file) as f:
+      return SshKeys._ValidateSshKey(f.read().strip(), key_file)
+
+  @staticmethod
+  def _ValidateSshKey(key, key_file):
+    """Validates the public ssh key format (OpenSSH).
+
+    Args:
+      key: string containing the public ssh key.
+      key_file: filename whence the key cometh.
+
+    Returns:
+      the ssh key value (value of key parameter) if validation has passed.
+
+    Raises:
+      UserSetupError: if the key validation fails.
+    """
+    if not key:
+      raise UserSetupError(
+          'Public key file (%s) doesn\'t contain a key.' % key_file)
+    if '\n' in key:
+      raise UserSetupError(
+          'Public key file (%s) has invalid format. '
+          'It must only contain single line.\n%s' % (key_file, key))
+    # Validate the OpenSSH key format
+    parts = key.split()
+    if len(parts) != 3:
+      raise UserSetupError(
+          'Public key file (%s) doesn\'t contain an OpenSSH public key. '
+          'The key must consist of exactly three space separated parts.\n%s' %
+          (key_file, key))
+
+    key_type, key_value, _ = parts
+
+    try:
+      key_value = base64.b64decode(key_value)
+    except TypeError:
+      raise UserSetupError(
+          'Public key file (%s) doesn\'t contain an OpenSSH public key. '
+          'The key is not a valid base64 encoded value.\n%s' %
+          (key_file, key))
+
+    if len(key_value) < 4:
+      raise UserSetupError(
+          'Public key file (%s) doesn\'t contain an OpenSSH public key. '
+          'The key has invalid length.\n%s' %
+          (key_file, key))
+
+    # First 4 bytes is the length of key type.
+    decoded_length = struct.unpack_from('>I', key_value)[0]
+    if len(key_value) < 4 + decoded_length:
+      raise UserSetupError(
+          'Public key file (%s) doesn\'t contain an OpenSSH public key. '
+          'The key doesn\'t have a valid type.\n%s' %
+          (key_file, key))
+
+    decoded_type = key_value[4:4 + decoded_length]
+    if key_type != decoded_type:
+      raise UserSetupError(
+          'Public key file (%s) doesn\'t contain an OpenSSH public key. '
+          'The decoded key type doesn\'t match.\n%s' %
+          (key_file, key))
+
+    return key