googlecloud 0.0.2 → 0.0.4

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

@@ -0,0 +1,38 @@
+#!/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

@@ -0,0 +1,173 @@
+# 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

@@ -0,0 +1,111 @@
+#!/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

@@ -0,0 +1,61 @@
+# 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

@@ -0,0 +1,50 @@
+#!/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

@@ -0,0 +1,276 @@
+# 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)