gcloud 0.0.7 → 0.1.0

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

@@ -1,38 +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.
-
-"""Contains a utility for initializing the system path."""
-
-
-
-import os
-import sys
-
-def InitializeSysPath():
-  """Adds gcutil's dependencies to sys.path.
-
-  This function assumes that the site module has not been
-  imported. The site module can be supressed by launching this program
-  using python -S.
-  """
-  lib_dir = os.path.dirname(os.path.dirname(os.path.dirname(
-      os.path.realpath(__file__))))
-  libs = [os.path.join(lib_dir, lib) for lib in os.listdir(lib_dir)]
-
-  # Removes entries from libs that are already on the path.
-  libs = list(set(libs) - set(sys.path))
-
-  sys.path = libs + sys.path

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

@@ -1,173 +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."""
-
-
-
-import httplib2
-import json
-
-
-from google.apputils import appcommands
-import gflags as flags
-
-from gcutil import auth_helper
-from gcutil import command_base
-from gcutil import gcutil_logging
-from gcutil import metadata
-from gcutil import scopes
-from gcutil import version
-
-
-FLAGS = flags.FLAGS
-LOGGER = gcutil_logging.LOGGER
-
-
-class ProjectCommand(command_base.GoogleComputeCommand):
-  """Base command for working with the projects collection."""
-
-  default_sort_field = 'name'
-  summary_fields = (('name', 'name'),
-                    ('ips', 'externalIpAddresses'))
-
-  def __init__(self, name, flag_values):
-    super(ProjectCommand, self).__init__(name, 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.
-
-    Returns:
-      None.
-
-    """
-    self._projects_api = api.projects()
-
-  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 the 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']))))
-    # Add the metadata
-    if result.get('commonInstanceMetadata', []):
-      table.AddRow(('', ''))
-      table.AddRow(('common-instance-metadata', ''))
-      metadata_container = result.get('commonInstanceMetadata', [])
-      if 'kind' in metadata_container:
-        metadata_container = metadata_container.get('items', [])
-      for metadata_entry in metadata_container:
-        table.AddRow(('  %s' % metadata_entry.get('key', ''),
-                      self._PresentElement(metadata_entry.get('value', ''))))
-
-
-class GetProject(ProjectCommand):
-  """Get the resource for a Google Compute Engine project."""
-
-  positional_args = '<project-name>'
-
-  # The remaining complex fields are filled in via CustomizePrintResult
-  detail_fields = (('name', 'name'),
-                   ('description', 'description'),
-                   ('creation-time', 'creationTimestamp'),
-                   ('ips', 'externalIpAddresses'))
-
-  def __init__(self, name, flag_values):
-    super(GetProject, self).__init__(name, flag_values)
-
-  def Handle(self, project=None):
-    """Get the specified project.
-
-    Args:
-      project: The project for which to get defails.
-
-    Returns:
-      The result of getting the project.
-    """
-    project = project or self._flags.project
-    project_request = self._projects_api.get(project=project)
-    return project_request.execute()
-
-
-class SetCommonInstanceMetadata(ProjectCommand):
-  """Set the commonInstanceMetadata field for a Google Compute Engine project.
-
-  This is a blanket overwrite of all of the project wide metadata.
-  """
-
-  def __init__(self, name, flag_values):
-    super(SetCommonInstanceMetadata, self).__init__(name, flag_values)
-    flags.DEFINE_bool('force',
-                      False,
-                      'Set the metadata even if it erases existing keys',
-                      flag_values=flag_values,
-                      short_name='f')
-    self._metadata_flags_processor = metadata.MetadataFlagsProcessor(
-        flag_values)
-
-  def Handle(self):
-    """Set the metadata common to all instances in the specified project.
-
-    Args:
-      None.
-
-    Returns:
-      The result of setting the project wide metadata.
-
-    Raises:
-
-      command_base.CommandError: If the update would cause some metadata to
-        be deleted.
-    """
-    new_metadata = self._metadata_flags_processor.GatherMetadata()
-
-    if not self._flags.force:
-      get_request = self._projects_api.get(project=self._flags.project)
-      project_resource = get_request.execute()
-      project_metadata = project_resource.get('commonInstanceMetadata', [])
-      if 'kind' in project_metadata:
-        project_metadata = project_metadata.get('items', [])
-      existing_keys = set([entry['key'] for entry in project_metadata])
-      new_keys = set([entry['key'] for entry in new_metadata])
-      dropped_keys = existing_keys - new_keys
-      if dropped_keys:
-        raise command_base.CommandError(
-            'Discarding update that would wipe out the following metadata: %s.'
-            '\n\nRe-run with the -f flag to force the update.' %
-            ', '.join(list(dropped_keys)))
-
-    project_request = self._projects_api.setCommonInstanceMetadata(
-        project=self._flags.project,
-        body={'kind': self._GetResourceApiKind('metadata'),
-              'items': new_metadata})
-    return project_request.execute()
-
-
-def AddCommands():
-  appcommands.AddCmd('getproject', GetProject)
-  appcommands.AddCmd('setcommoninstancemetadata', SetCommonInstanceMetadata)

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

@@ -1,111 +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 project commands."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import copy
-import re
-import tempfile
-
-
-import gflags as flags
-import unittest
-
-from gcutil import auth_helper
-from gcutil import command_base
-from gcutil import flags_cache
-from gcutil import mock_api
-from gcutil import project_cmds
-
-FLAGS = flags.FLAGS
-
-
-class ComputeCmdsTest(unittest.TestCase):
-  def testGetProjectGeneratesCorrectRequest(self):
-    flag_values = copy.deepcopy(FLAGS)
-
-    command = project_cmds.GetProject('getproject', flag_values)
-
-    expected_project = 'test_project'
-    flag_values.project = expected_project
-
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-
-    result = command.Handle()
-
-    self.assertEqual(result['project'], expected_project)
-
-  def testSetCommonInstanceMetadataGeneratesCorrectRequest(self):
-
-    class SetCommonInstanceMetadata(object):
-
-      def __call__(self, project, body):
-        self._project = project
-        self._body = body
-        return self
-
-      def execute(self):
-        return {'project': self._project, 'body': self._body}
-
-    flag_values = copy.deepcopy(FLAGS)
-    command = project_cmds.SetCommonInstanceMetadata(
-        'setcommoninstancemetadata', flag_values)
-
-    expected_project = 'test_project'
-    flag_values.project = expected_project
-    flag_values.service_version = 'v1beta13'
-    with tempfile.NamedTemporaryFile() as metadata_file:
-      metadata_file.write('foo:bar')
-      metadata_file.flush()
-      flag_values.metadata_from_file = ['sshKeys:%s' % metadata_file.name]
-
-      command.SetFlags(flag_values)
-      command.SetApi(mock_api.MockApi())
-      command._projects_api.get = mock_api.CommandExecutor(
-          {'commonInstanceMetadata': [{'key': 'sshKeys', 'value': ''}]})
-      command._projects_api.setCommonInstanceMetadata = (
-          SetCommonInstanceMetadata())
-
-      result = command.Handle()
-      self.assertEquals(expected_project, result['project'])
-      self.assertEquals(
-          {'kind': 'compute#metadata',
-           'items': [{'key': 'sshKeys', 'value': 'foo:bar'}]},
-          result['body'])
-
-  def testSetCommonInstanceMetadataChecksForOverwrites(self):
-    flag_values = copy.deepcopy(FLAGS)
-    command = project_cmds.SetCommonInstanceMetadata(
-        'setcommoninstancemetadata', flag_values)
-
-    expected_project = 'test_project'
-    flag_values.project = expected_project
-    flag_values.service_version = 'v1beta13'
-    command.SetFlags(flag_values)
-    command.SetApi(mock_api.MockApi())
-    command._projects_api.get = mock_api.CommandExecutor(
-        {'commonInstanceMetadata': [{'key': 'sshKeys', 'value': 'foo:bar'}]})
-
-    self.assertRaises(command_base.CommandError, command.Handle)
-
-if __name__ == '__main__':
-  unittest.main()

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

@@ -1,61 +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.
-
-"""The Google API scopes used by Google Compute Engine."""
-
-
-
-USER_INFO_SCOPE = 'https://www.googleapis.com/auth/userinfo.email'
-COMPUTE_RW_SCOPE = 'https://www.googleapis.com/auth/compute'
-COMPUTE_RO_SCOPE = 'https://www.googleapis.com/auth/compute.readonly'
-STORAGE_R_SCOPE = 'https://www.googleapis.com/auth/devstorage.read_only'
-STORAGE_W_SCOPE = 'https://www.googleapis.com/auth/devstorage.write_only'
-STORAGE_RW_SCOPE = (
-        'https://www.googleapis.com/auth/devstorage.read_write')
-STORAGE_FULL_SCOPE = 'https://www.googleapis.com/auth/devstorage.full_control'
-DEFAULT_AUTH_SCOPES = [
-    COMPUTE_RW_SCOPE, COMPUTE_RO_SCOPE,
-    # USER_INFO_SCOPE allows seeing who user authenticated as.
-    USER_INFO_SCOPE,
-    # Image commands use STORAGE access.
-    STORAGE_R_SCOPE, STORAGE_W_SCOPE, STORAGE_RW_SCOPE, STORAGE_FULL_SCOPE
-    ]
-
-TASKQUEUE = 'https://www.googleapis.com/auth/taskqueue'
-BIGQUERY = 'https://www.googleapis.com/auth/bigquery'
-CLOUDSQL = 'https://www.googleapis.com/auth/sqlservice'
-
-SCOPE_ALIASES = {
-    'bigquery': BIGQUERY,
-    'cloudsql': CLOUDSQL,
-    'compute-ro': COMPUTE_RO_SCOPE,
-    'compute-rw': COMPUTE_RW_SCOPE,
-    'storage-full': STORAGE_FULL_SCOPE,
-    'storage-ro': STORAGE_R_SCOPE,
-    'storage-rw': STORAGE_RW_SCOPE,
-    'storage-wo': STORAGE_W_SCOPE,
-    'taskqueue': TASKQUEUE,
-    }
-
-
-def ExpandScopeAliases(scopes):
-  """Expand a list of scope aliases if available.
-
-  Args:
-    scopes: a list of scopes and scope aliases
-
-  Returns:
-    a list of scopes
-  """
-  return [SCOPE_ALIASES.get(s, s) for s in scopes]

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

@@ -1,50 +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.
-
-"""Tests for scopes module."""
-
-
-
-import path_initializer
-path_initializer.InitializeSysPath()
-
-import unittest
-from gcutil import scopes
-
-
-class ScopesTest(unittest.TestCase):
-  def testExpandPassthrough(self):
-    scopes_in = ['foo', 'bar', scopes.TASKQUEUE]
-    scopes_out = scopes.ExpandScopeAliases(scopes_in)
-    self.assertEqual(scopes_out, scopes_in)
-
-  def testExpandEmpty(self):
-    scopes_in = []
-    scopes_out = scopes.ExpandScopeAliases(scopes_in)
-    self.assertEqual(scopes_out, scopes_in)
-
-  def testExpandSingle(self):
-    scopes_in = ['compute-rw']
-    scopes_out = scopes.ExpandScopeAliases(scopes_in)
-    self.assertEqual(scopes_out, [scopes.COMPUTE_RW_SCOPE])
-
-  def testExpandMixed(self):
-    scopes_in = ['compute-rw', scopes.TASKQUEUE]
-    scopes_out = scopes.ExpandScopeAliases(scopes_in)
-    self.assertEqual(scopes_out, [scopes.COMPUTE_RW_SCOPE, scopes.TASKQUEUE])
-
-if __name__ == '__main__':
-  unittest.main()

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

@@ -1,276 +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 disk snapshots."""
-
-
-
-import time
-
-
-from google.apputils import appcommands
-import gflags as flags
-
-from gcutil import command_base
-from gcutil import gcutil_logging
-
-
-FLAGS = flags.FLAGS
-LOGGER = gcutil_logging.LOGGER
-
-
-class SnapshotCommand(command_base.GoogleComputeCommand):
-  """Base command for working with the snapshots collection."""
-
-  default_sort_field = 'name'
-  summary_fields = (('name', 'name'),
-                    ('description', 'description'),
-                    ('creation-time', 'creationTimestamp'),
-                    ('status', 'status'),
-                    ('disk-size-gb', 'diskSizeGb'),
-                    ('source-disk', 'sourceDisk'))
-
-  detail_fields = (('name', 'name'),
-                   ('description', 'description'),
-                   ('creation-time', 'creationTimestamp'),
-                   ('status', 'status'),
-                   ('disk-size-gb', 'diskSizeGb'),
-                   ('source-disk', 'sourceDisk'))
-
-  resource_collection_name = 'snapshots'
-
-  def __init__(self, name, flag_values):
-    super(SnapshotCommand, self).__init__(name, 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.
-
-    Returns:
-      None.
-
-    """
-    self._snapshots_api = api.snapshots()
-    self._disks_api = api.disks()
-    self._zones_api = api.zones()
-
-  def _PrepareRequestArgs(self, snapshot_name, **other_args):
-    """Gets the dictionary of API method keyword arguments.
-
-    Args:
-      snapshot_name: The name of the snapshot.
-      **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,
-        'snapshot': self.DenormalizeResourceName(snapshot_name)
-    }
-    for key, value in other_args.items():
-      kwargs[key] = value
-    return kwargs
-
-
-class AddSnapshot(SnapshotCommand):
-  """Create a new persistent disk snapshot."""
-
-  positional_args = '<snapshot-name>'
-  status_field = 'status'
-  _TERMINAL_STATUS = ['READY', 'FAILED']
-
-  def __init__(self, name, flag_values):
-    super(AddSnapshot, self).__init__(name, flag_values)
-    flags.DEFINE_string('description',
-                        '',
-                        'Snapshot description.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('source_disk',
-                        None,
-                        'The source disk for this snapshot.',
-                        flag_values=flag_values)
-    flags.DEFINE_string('zone',
-                        None,
-                        'The zone of the disk.',
-                        flag_values=flag_values)
-    flags.DEFINE_boolean('wait_until_complete',
-                         False,
-                         'Whether the program should wait until the snapshot'
-                         ' is complete.',
-                         flag_values=flag_values)
-
-  def Handle(self, snapshot_name):
-    """Add the specified snapshot.
-
-    Args:
-      snapshot_name: The name of the snapshot to add
-
-    Returns:
-      The result of inserting the snapshot.
-    """
-    if not self._flags.source_disk:
-      disk = self._PromptForDisk()
-      if not disk:
-        raise command_base.CommandError(
-            'You cannot create a snapshot if you have no disks.')
-      self._flags.source_disk = disk['name']
-
-    zone = 'unused'
-    if self._IsUsingAtLeastApiVersion('v1beta14'):
-      zone = self.GetZoneForResource(self._disks_api, self._flags.source_disk)
-
-    source_disk = self.NormalizePerZoneResourceName(
-        self._project,
-        zone,
-        'disks',
-        self._flags.source_disk)
-
-    kwargs = {
-        'project': self._project,
-    }
-
-    snapshot_resource = {
-        'kind': self._GetResourceApiKind('snapshot'),
-        'name': self.DenormalizeResourceName(snapshot_name),
-        'description': self._flags.description,
-        'sourceDisk': source_disk
-        }
-
-    kwargs['body'] = snapshot_resource
-    snapshot_request = self._snapshots_api.insert(**kwargs)
-
-    result = snapshot_request.execute()
-
-    if self._flags.wait_until_complete:
-      result = self.WaitForOperation(self._flags, time, result)
-      if not result.get('error'):
-        result = self._InternalGetSnapshot(snapshot_name)
-        result = self._WaitUntilSnapshotIsComplete(result, snapshot_name)
-
-    return result
-
-  def _InternalGetSnapshot(self, snapshot_name):
-    """A simple implementation of getting current snapshot state.
-
-    Args:
-      snapshot_name: the name of the snapshot to get.
-
-    Returns:
-      Json containing full snapshot information.
-    """
-    snapshot_request = self._snapshots_api.get(
-        **self._PrepareRequestArgs(snapshot_name))
-    return snapshot_request.execute()
-
-  def _WaitUntilSnapshotIsComplete(self, result, snapshot_name):
-    """Waits for the snapshot to complete.
-
-    Periodically polls the server for current snapshot status. Exits if the
-    status of the snapshot is READY or FAILED or the maximum waiting
-    timeout has been reached. In both cases returns the last known snapshot
-    details.
-
-    Args:
-      result: the current state of the snapshot.
-      snapshot_name: the name of the snapshot to watch.
-
-    Returns:
-      Json containing full snapshot information.
-    """
-    current_status = result[self.status_field]
-    start_time = time.time()
-    LOGGER.info('Will wait for snapshot to complete for: %d seconds.',
-                self._flags.max_wait_time)
-    while (time.time() - start_time < self._flags.max_wait_time and
-           current_status not in self._TERMINAL_STATUS):
-      LOGGER.info(
-          'Waiting for snapshot. Current status: %s. Sleeping for %ss.',
-          current_status, self._flags.sleep_between_polls)
-      time.sleep(self._flags.sleep_between_polls)
-      result = self._InternalGetSnapshot(snapshot_name)
-      current_status = result[self.status_field]
-    if current_status not in self._TERMINAL_STATUS:
-      LOGGER.warn('Timeout reached. Snapshot %s has not yet completed.',
-                  snapshot_name)
-    return result
-
-
-class GetSnapshot(SnapshotCommand):
-  """Get a machine snapshot."""
-
-  positional_args = '<snapshot-name>'
-
-  def __init__(self, name, flag_values):
-    super(GetSnapshot, self).__init__(name, flag_values)
-
-  def Handle(self, snapshot_name):
-    """Get the specified snapshot.
-
-    Args:
-      snapshot_name: The name of the snapshot to get
-
-    Returns:
-      The result of getting the snapshot.
-    """
-    snapshot_request = self._snapshots_api.get(
-        **self._PrepareRequestArgs(snapshot_name))
-
-    return snapshot_request.execute()
-
-
-class DeleteSnapshot(SnapshotCommand):
-  """Delete one or more machine snapshots."""
-
-  positional_args = '<snapshot-name>'
-  safety_prompt = 'Delete snapshot'
-
-  def __init__(self, name, flag_values):
-    super(DeleteSnapshot, self).__init__(name, flag_values)
-
-  def Handle(self, *snapshot_names):
-    """Delete the specified snapshots.
-
-    Args:
-      *snapshot_names: The names of the snapshots to delete
-
-    Returns:
-      Tuple (results, exceptions) - results of deleting the snapshots.
-    """
-    requests = []
-    for snapshot_name in snapshot_names:
-      requests.append(self._snapshots_api.delete(
-          **self._PrepareRequestArgs(snapshot_name)))
-    results, exceptions = self.ExecuteRequests(requests)
-    return self.MakeListResult(results, 'operationList'), exceptions
-
-
-class ListSnapshots(SnapshotCommand, command_base.GoogleComputeListCommand):
-  """List the machine snapshots for a project."""
-
-  def ListFunc(self):
-    """Returns the function for listing snapshots."""
-    return self._snapshots_api.list
-
-
-def AddCommands():
-  appcommands.AddCmd('addsnapshot', AddSnapshot)
-  appcommands.AddCmd('getsnapshot', GetSnapshot)
-  appcommands.AddCmd('deletesnapshot', DeleteSnapshot)
-  appcommands.AddCmd('listsnapshots', ListSnapshots)