gcloud 0.0.7 → 0.1.0

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

@@ -1,128 +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 ssh key utility."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import base64
-
-import gflags as flags
-import unittest
-
-from gcutil import ssh_keys
-
-FLAGS = flags.FLAGS
-
-
-class SshKeyTest(unittest.TestCase):
-
-
-  def testNoKeysProducesEmptyAuthorizedUserKeysString(self):
-    authorized_user_keys = ssh_keys.SshKeys.GetAuthorizedUserKeys(
-        use_compute_key=False,
-        authorized_ssh_keys=[])
-
-    self.assertEqual(authorized_user_keys, [])
-
-  def testGetAuthorizedUserKeysFromMetadata(self):
-    mock_ssh_keys = 'foo:bar\nbaz:bat'
-    mock_metadata = [
-        {'key': 'startup-script', 'value': 'echo "Hello, World!"'},
-        {'key': 'sshKeys', 'value': mock_ssh_keys},
-        {'key': 'key', 'value': 'value'}]
-    authorized_user_keys = ssh_keys.SshKeys.GetAuthorizedUserKeysFromMetadata(
-        mock_metadata)
-
-    self.assertEqual(authorized_user_keys,
-                     [{'user': 'foo', 'key': 'bar'},
-                      {'user': 'baz', 'key': 'bat'}])
-
-  def testGetAuthorizedUserKeysFromMetadataWithNoMetadata(self):
-    authorized_user_keys = (
-        ssh_keys.SshKeys.GetAuthorizedUserKeysFromMetadata([]))
-    self.assertEqual(authorized_user_keys, [])
-
-  def testGetAuthorizedUserKeysFromMetadataWithEmptySshKeys(self):
-    authorized_user_keys = ssh_keys.SshKeys.GetAuthorizedUserKeysFromMetadata(
-        [{'key': 'sshKeys', 'value': ''}])
-    self.assertEqual(authorized_user_keys, [])
-
-  def testSetAuthorizedUserKeysInMetadata(self):
-    metadata = [{'key': 'key1', 'value': 'value1'},
-                {'key': 'sshKeys', 'value': 'foo:bar\nbaz:bat'},
-                {'key': 'key3', 'value': 'value3'}]
-    ssh_keys.SshKeys.SetAuthorizedUserKeysInMetadata(
-        metadata,
-        [{'user': 'user1', 'key': 'key1'}, {'user': 'user2', 'key': 'key2'}])
-    self.assertEqual(
-        [{'key': 'key1', 'value': 'value1'},
-         {'key': 'sshKeys', 'value': 'user1:key1\nuser2:key2'},
-         {'key': 'key3', 'value': 'value3'}],
-        metadata)
-
-  def testValidateSshKey(self):
-    key = ('ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCm60IMJ0qIzJB+K4AEpEhyvfEL0eX'
-           '2WuQ2LpT51s5JE0UCIUqX7t7cYHwfFxqwx34ZGM5RqZbj2RFkeZfU7NwjAS1YMfjxkT'
-           '0l/pGnsCPzCZhV5++U9+AZpnM+669fQiA9pRq9JlL4JJtmz0dZHbBSlOwe2ty6lSS5G'
-           'xAcZ+g553dj5NLfTTAH+HRzA9AnySOEExUIJ1Vpix+NEyyRkMQbBHcJnWAnqd+yBe5d'
-           'E0ojpO6ZZzciF4waBhmMK4T8kuuXII/bTqlZKGzl3qdzBIhFaMmXDXq+3bw9hRvPb+g'
-           'ChIDYiPmx0HJyqtZ7OkRbh5MyR5W/Zu8cn4sjoiBWIfxJ comment@comment.com')
-    self.assertEqual(key, ssh_keys.SshKeys._ValidateSshKey(key, 'filename'))
-
-    # No key - exception
-    self.assertRaises(ssh_keys.UserSetupError, ssh_keys.SshKeys._ValidateSshKey,
-                      '', 'filename')
-
-    def AssertUserSetupError(key, message):
-      filename = '/the/file/path'
-      try:
-        ssh_keys.SshKeys._ValidateSshKey(key, filename)
-      except ssh_keys.UserSetupError, e:
-        self.assert_(key in e.msg)
-        self.assert_(filename in e.msg)
-        self.assert_(message in e.msg)
-      else:
-        self.fail('Expected an UserSetupError exception')
-
-    # Newline in the key
-    AssertUserSetupError('\n'.join(key.split()), 'single line')
-    # More than 3 parts
-    AssertUserSetupError(key + ' another_part', 'exactly three space separated')
-    # Or fewer than 3
-    AssertUserSetupError(
-        ' '.join(key.split()[:-1]),
-        'exactly three space separated')
-    # Base-64 cannot contain '_'
-    AssertUserSetupError(key.replace('Q', '_'), 'is not a valid base64 encoded')
-    # Malformed key - not enought data
-    AssertUserSetupError(
-        'ssh-rsa ' + base64.b64encode('\00\00\04') + ' comment',
-        'The key has invalid length.')
-    # Malformed key - not enough data for length + type
-    AssertUserSetupError(
-        'ssh-rsa ' + base64.b64encode('\00\00\00\07ssh-') + ' comment',
-        'The key doesn\'t have a valid type.')
-    # Malformed key - mismatched type
-    AssertUserSetupError(
-        ' '.join(['ssh-rsb'] + key.split()[1:]),
-        'The decoded key type doesn\'t match.')
-
-if __name__ == '__main__':
-  unittest.main()

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

@@ -1,563 +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.
-
-"""Table formatting library.
-
-We define a TableFormatter interface, and create subclasses for
-several different print formats, including formats intended for both
-human and machine consumption:
-
-Human Consumption
------------------
-
- PrettyFormatter: This prints ASCII-art bordered tables. Inspired
-   by the prettytable python library. Example:
-
-     +-----+---------------+
-     | foo | longer header |
-     +-----+---------------+
-     | a   |             3 |
-     |         ...         |
-     | abc |           123 |
-     +-----+---------------+
-
- SparsePrettyFormatter: This is a PrettyFormatter which simply
-   doesn't print most of the border. Example:
-
-      foo   longer header
-     ----- ---------------
-      a                 3
-              ...
-      abc             123
-
- PrettyJsonFormatter: Prints JSON output in a format easily
-   read by a human. Example:
-
-     [
-       {
-         "foo": "a",
-         "longer header": 3
-       },
-       ...
-       {
-         "foo": "abc",
-         "longer header": 123
-       }
-     ]
-
-Machine Consumption
--------------------
-
-  CsvFormatter: Prints output in CSV form, with minimal
-    quoting, '\n' separation between lines, and including
-    a header line. Example:
-
-     foo,longer header
-     a,3
-     ...
-     abc,123
-
-  JsonFormatter: Prints JSON output in the most compact
-    form possible. Example:
-
-    [{"foo":"a","longer header":3},...,{"foo":"abc","longer header":123}]
-
-Additional formatters can be added by subclassing TableFormatter and
-overriding the following methods:
-  __len__, __unicode__, AddRow, column_names, AddColumn
-"""
-
-
-
-import cStringIO
-import csv
-import itertools
-import json
-import sys
-
-
-class FormatterException(Exception):
-  pass
-
-
-class TableFormatter(object):
-  """Interface for table formatters."""
-
-  def __init__(self, **kwds):
-    """Initializes the base class.
-
-    Keyword arguments:
-      skip_header_when_empty: If true, does not print the table's header
-        if there are zero rows. This argument has no effect on
-        PrettyJsonFormatter.
-    """
-    if self.__class__ == TableFormatter:
-      raise NotImplementedError(
-          'Cannot instantiate abstract class TableFormatter')
-    self.skip_header_when_empty = kwds.get('skip_header_when_empty', False)
-
-  def __nonzero__(self):
-    return bool(len(self))
-
-  def __len__(self):
-    raise NotImplementedError('__len__ must be implemented by subclass')
-
-  def __str__(self):
-    return unicode(self).encode(sys.getdefaultencoding(), 'backslashreplace')
-
-  def __unicode__(self):
-    raise NotImplementedError('__unicode__ must be implemented by subclass')
-
-  def Print(self):
-    if self:
-      # TODO(user): Make encoding a customizable attribute on
-      # the TableFormatter.
-      encoding = sys.stdout.encoding or 'utf8'
-      print unicode(self).encode(encoding, 'backslashreplace')
-
-  def AddRow(self, row):
-    """Add a new row (an iterable) to this formatter."""
-    raise NotImplementedError('AddRow must be implemented by subclass')
-
-  def AddRows(self, rows):
-    """Add all rows to this table."""
-    for row in rows:
-      self.AddRow(row)
-
-  def AddField(self, field):
-    """Add a field as a new column to this formatter."""
-    # TODO(user): Excise this bigquery-specific method.
-    align = 'l' if field.get('type', []) == 'STRING' else 'r'
-    self.AddColumn(field['name'], align=align)
-
-  def AddFields(self, fields):
-    """Convenience method to add a list of fields."""
-    for field in fields:
-      self.AddField(field)
-
-  def AddDict(self, d):
-    """Add a dict as a row by using column names as keys."""
-    self.AddRow([d.get(name, '') for name in self.column_names])
-
-  @property
-  def column_names(self):
-    """Return the ordered list of column names in self."""
-    raise NotImplementedError('column_names must be implemented by subclass')
-
-  def AddColumn(self, column_name, align='r', **kwds):
-    """Add a new column to this formatter."""
-    raise NotImplementedError('AddColumn must be implemented by subclass')
-
-  def AddColumns(self, column_names, kwdss=None):
-    """Add a series of columns to this formatter."""
-    kwdss = kwdss or [{}] * len(column_names)
-    for column_name, kwds in zip(column_names, kwdss):
-      self.AddColumn(column_name, **kwds)
-
-
-class PrettyFormatter(TableFormatter):
-  """Formats output as an ASCII-art table with borders."""
-
-  def __init__(self, **kwds):
-    """Initialize a new PrettyFormatter.
-
-    Keyword arguments:
-      junction_char: (default: +) Character to use for table junctions.
-      horizontal_char: (default: -) Character to use for horizontal lines.
-      vertical_char: (default: |) Character to use for vertical lines.
-    """
-    super(PrettyFormatter, self).__init__(**kwds)
-
-    self.junction_char = kwds.get('junction_char', '+')
-    self.horizontal_char = kwds.get('horizontal_char', '-')
-    self.vertical_char = kwds.get('vertical_char', '|')
-
-    self.rows = []
-    self.row_heights = []
-    self._column_names = []
-    self.column_widths = []
-    self.column_alignments = []
-    self.header_height = 1
-
-  def __len__(self):
-    return len(self.rows)
-
-  def __unicode__(self):
-    if self or not self.skip_header_when_empty:
-      lines = itertools.chain(
-          self.FormatHeader(), self.FormatRows(), self.FormatHrule())
-    else:
-      lines = []
-    return '\n'.join(lines)
-
-  @staticmethod
-  def CenteredPadding(interval, size, left_justify=True):
-    """Compute information for centering a string in a fixed space.
-
-    Given two integers interval and size, with size <= interval, this
-    function computes two integers left_padding and right_padding with
-      left_padding + right_padding + size = interval
-    and
-      |left_padding - right_padding| <= 1.
-
-    In the case that interval and size have different parity,
-    left_padding will be larger iff left_justify is True. (That is,
-    iff the string should be left justified in the "center" space.)
-
-    Args:
-      interval: Size of the fixed space.
-      size: Size of the string to center in that space.
-      left_justify: (optional, default: True) Whether the string
-        should be left-justified in the center space.
-
-    Returns:
-      left_padding, right_padding: The size of the left and right
-        margins for centering the string.
-
-    Raises:
-      FormatterException: If size > interval.
-    """
-    if size > interval:
-      raise FormatterException('Illegal state in table formatting')
-    same_parity = (interval % 2) == (size % 2)
-    padding = (interval - size) / 2
-    if same_parity:
-      return padding, padding
-    elif left_justify:
-      return padding, padding + 1
-    else:
-      return padding + 1, padding
-
-  @staticmethod
-  def Abbreviate(s, width):
-    """Abbreviate a string to at most width characters."""
-    suffix = '.' * min(width, 3)
-    return s if len(s) <= width else s[:width - len(suffix)] + suffix
-
-  @staticmethod
-  def FormatCell(entry, cell_width, cell_height=1, align='c', valign='t'):
-    """Format an entry into a list of strings for a fixed cell size.
-
-    Given a (possibly multi-line) entry and a cell height and width,
-    we split the entry into a list of lines and format each one into
-    the given width and alignment. We then pad the list with
-    additional blank lines of the appropriate width so that the
-    resulting list has exactly cell_height entries. Each entry
-    is also padded with one space on either side.
-
-    We abbreviate strings for width, but we require that the
-    number of lines in entry is at most cell_height.
-
-    Args:
-      entry: String to format, which may have newlines.
-      cell_width: Maximum width for lines in the cell.
-      cell_height: Number of lines in the cell.
-      align: Alignment to use for lines of text.
-      valign: Vertical alignment in the cell. One of 't',
-        'c', or 'b' (top, center, and bottom, respectively).
-
-    Returns:
-      An iterator yielding exactly cell_height lines, each of
-      exact width cell_width + 2, corresponding to this cell.
-
-    Raises:
-      FormatterException: If there are too many lines in entry.
-      ValueError: If the valign is invalid.
-    """
-    entry_lines = [PrettyFormatter.Abbreviate(line, cell_width)
-                   for line in entry.split('\n')]
-    if len(entry_lines) > cell_height:
-      raise FormatterException('Too many lines (%s) for a cell of size %s' % (
-          len(entry_lines), cell_height))
-    if valign == 't':
-      top_lines = []
-      bottom_lines = itertools.repeat(' ' * (cell_width + 2),
-                                      cell_height - len(entry_lines))
-    elif valign == 'c':
-      top_padding, bottom_padding = PrettyFormatter.CenteredPadding(
-          cell_height, len(entry_lines))
-      top_lines = itertools.repeat(' ' * (cell_width + 2), top_padding)
-      bottom_lines = itertools.repeat(' ' * (cell_width + 2), bottom_padding)
-    elif valign == 'b':
-      bottom_lines = []
-      top_lines = itertools.repeat(' ' * (cell_width + 2),
-                                   cell_height - len(entry_lines))
-    else:
-      raise ValueError('Unknown value for valign: %s' % (valign,))
-    content_lines = []
-    for line in entry_lines:
-      if align == 'c':
-        left_padding, right_padding = PrettyFormatter.CenteredPadding(
-            cell_width, len(line))
-        content_lines.append(' %s%s%s ' % (
-            ' ' * left_padding, line, ' ' * right_padding))
-      elif align in ('l', 'r'):
-        fmt = ' %*s ' if align == 'r' else ' %-*s '
-        content_lines.append(fmt % (cell_width, line))
-      else:
-        raise FormatterException('Unknown alignment: %s' % (align,))
-    return itertools.chain(top_lines, content_lines, bottom_lines)
-
-  def FormatRow(self, entries, row_height,
-                column_alignments=None, column_widths=None):
-    """Format a row into a list of strings.
-
-    Given a list of entries, which must be the same length as the
-    number of columns in this table, and a desired row height, we
-    generate a list of strings corresponding to the printed
-    representation of that row.
-
-    Args:
-      entries: List of entries to format.
-      row_height: Number of printed lines corresponding to this row.
-      column_alignments: (optional, default self.column_alignments)
-        The alignment to use for each column.
-      column_widths: (optional, default self.column_widths) The widths
-        of each column.
-
-    Returns:
-      An iterator over the strings in the printed representation
-      of this row.
-    """
-    column_alignments = column_alignments or self.column_alignments
-    column_widths = column_widths or self.column_widths
-
-    # pylint:disable-msg=C6402
-    curried_format = lambda entry, width, align: self.__class__.FormatCell(
-        unicode(entry), width, cell_height=row_height, align=align)
-    printed_rows = itertools.izip(*itertools.imap(
-        curried_format, entries, column_widths, column_alignments))
-    return (self.vertical_char.join(itertools.chain([''], cells, ['']))
-            for cells in printed_rows)
-
-  def HeaderLines(self):
-    """Return an iterator over the row(s) for the column names."""
-    aligns = itertools.repeat('c')
-    return self.FormatRow(self.column_names, self.header_height,
-                          column_alignments=aligns)
-
-  def FormatHrule(self):
-    """Return a list containing an hrule for this table."""
-    entries = (''.join(itertools.repeat('-', width + 2))
-               for width in self.column_widths)
-    return [self.junction_char.join(itertools.chain([''], entries, ['']))]
-
-  def FormatHeader(self):
-    """Return an iterator over the lines for the header of this table."""
-    return itertools.chain(
-        self.FormatHrule(), self.HeaderLines(), self.FormatHrule())
-
-  def FormatRows(self):
-    """Return an iterator over all the rows in this table."""
-    return itertools.chain(*itertools.imap(
-        self.FormatRow, self.rows, self.row_heights))
-
-  def AddRow(self, row):
-    """Add a row to this table.
-
-    Args:
-      row: A list of length equal to the number of columns in this table.
-
-    Raises:
-      FormatterException: If the row length is invalid.
-    """
-    if len(row) != len(self.column_names):
-      raise FormatterException('Invalid row length: %s' % (len(row),))
-    split_rows = [unicode(entry).split('\n') for entry in row]
-    self.row_heights.append(max(len(lines) for lines in split_rows))
-    column_widths = (max(len(line) for line in entry) for entry in split_rows)
-    self.column_widths = [max(width, current) for width, current
-                          in itertools.izip(column_widths, self.column_widths)]
-    self.rows.append(row)
-
-  def AddColumn(self, column_name, align='l', **kwds):
-    """Add a column to this table.
-
-    Args:
-      column_name: Name for the new column.
-      align: (optional, default: 'l') Alignment for the new column entries.
-
-    Raises:
-      FormatterException: If the table already has any rows, or if the
-        provided alignment is invalid.
-    """
-    if self:
-      raise FormatterException(
-          'Cannot add a new column to an initialized table')
-    if align not in ('l', 'c', 'r'):
-      raise FormatterException('Invalid column alignment: %s' % (align,))
-    lines = column_name.split('\n')
-    self.column_widths.append(max(len(line) for line in lines))
-    self.column_alignments.append(align)
-    self.column_names.append(column_name)
-    self.header_height = max(len(lines), self.header_height)
-
-  @property
-  def column_names(self):
-    return self._column_names
-
-
-class SparsePrettyFormatter(PrettyFormatter):
-  """Formats output as a table with a header and separator line."""
-
-  def __init__(self, **kwds):
-    """Initialize a new SparsePrettyFormatter."""
-    default_kwds = {'junction_char': ' ',
-                    'vertical_char': ' '}
-    default_kwds.update(kwds)
-    super(SparsePrettyFormatter, self).__init__(**default_kwds)
-
-  def __unicode__(self):
-    if self or not self.skip_header_when_empty:
-      lines = itertools.chain(self.FormatHeader(), self.FormatRows())
-    else:
-      lines = []
-    return '\n'.join(lines)
-
-  def FormatHeader(self):
-    """Return an iterator over the header lines for this table."""
-    return itertools.chain(self.HeaderLines(), self.FormatHrule())
-
-
-class CsvFormatter(TableFormatter):
-  """Formats output as CSV with header lines.
-
-  The resulting CSV file includes a header line, uses Unix-style
-  newlines, and only quotes those entries which require it, namely
-  those that contain quotes, newlines, or commas.
-  """
-
-  def __init__(self, **kwds):
-    super(CsvFormatter, self).__init__(**kwds)
-    self._buffer = cStringIO.StringIO()
-    self._header = []
-    self._table = csv.writer(
-        self._buffer, quoting=csv.QUOTE_MINIMAL, lineterminator='\n')
-
-  def __nonzero__(self):
-    return bool(self._buffer.tell())
-
-  def __len__(self):
-    return len(unicode(self).splitlines())
-
-  def __unicode__(self):
-    if self or not self.skip_header_when_empty:
-      lines = [','.join(self._header), self._buffer.getvalue()]
-    else:
-      lines = []
-    # Note that we need to explicitly decode here to work around
-    # the fact that the CSV module does not work with unicode.
-    return '\n'.join(line.decode('utf8') for line in lines).rstrip()
-
-  @property
-  def column_names(self):
-    return self._header[:]
-
-  def AddColumn(self, column_name, **kwds):
-    if self:
-      raise FormatterException(
-          'Cannot add a new column to an initialized table')
-    self._header.append(column_name)
-
-  def AddRow(self, row):
-    self._table.writerow([unicode(entry).encode('utf8', 'backslashreplace')
-                          for entry in row])
-
-
-class JsonFormatter(TableFormatter):
-  """Formats output in maximally compact JSON."""
-
-  def __init__(self, **kwds):
-    super(JsonFormatter, self).__init__(**kwds)
-    self._field_names = []
-    self._table = []
-
-  def __len__(self):
-    return len(self._table)
-
-  def __unicode__(self):
-    return json.dumps(self._table, separators=(',', ':'), ensure_ascii=False)
-
-  @property
-  def column_names(self):
-    return self._field_names[:]
-
-  def AddColumn(self, column_name, **kwds):
-    if self:
-      raise FormatterException(
-          'Cannot add a new column to an initialized table')
-    self._field_names.append(column_name)
-
-  def AddRow(self, row):
-    if len(row) != len(self._field_names):
-      raise FormatterException('Invalid row: %s' % (row,))
-    self._table.append(dict(zip(self._field_names, row)))
-
-
-class PrettyJsonFormatter(JsonFormatter):
-  """Formats output in human-legible JSON."""
-
-  def __unicode__(self):
-    return json.dumps(self._table, sort_keys=True, indent=2, ensure_ascii=False)
-
-
-class NullFormatter(TableFormatter):
-  """Formatter that prints no output at all."""
-
-  def __init__(self, **kwds):
-    super(NullFormatter, self).__init__(**kwds)
-    self._column_names = []
-    self._rows = []
-
-  def __nonzero__(self):
-    return bool(self._rows)
-
-  def __len__(self):
-    return len(self._rows)
-
-  def __unicode__(self):
-    return ''
-
-  def AddRow(self, row):
-    self._rows.append(row)
-
-  def AddRows(self, rows):
-    for row in rows:
-      self.AddRow(row)
-
-  @property
-  def column_names(self):
-    return self._column_names[:]
-
-  def AddColumn(self, column_name, **kwds):
-    self._column_names.append(column_name)
-
-
-def GetFormatter(table_format):
-  """Map a format name to a TableFormatter object."""
-  if table_format == 'csv':
-    table_formatter = CsvFormatter()
-  elif table_format == 'pretty':
-    table_formatter = PrettyFormatter()
-  elif table_format == 'json':
-    table_formatter = JsonFormatter()
-  elif table_format == 'prettyjson':
-    table_formatter = PrettyJsonFormatter()
-  elif table_format == 'sparse':
-    table_formatter = SparsePrettyFormatter()
-  elif table_format == 'none':
-    table_formatter = NullFormatter()
-  else:
-    raise FormatterException('Unknown format: %s' % table_format)
-  return table_formatter