Rename from reddwarf to trove.0.1.3

Implements Blueprint reddwarf-trove-rename

Change-Id: Ib2d694c7466887ca297bea4250eca17cdc06b7bf

1 files changed, 385 insertions, 0 deletions

diff --git a/troveclient/cli.py b/troveclient/cli.py
new file mode 100644
index 0000000..487a45c
--- /dev/null
+++ b/troveclient/cli.py
@@ -0,0 +1,385 @@
+#!/usr/bin/env python
+
+#    Copyright 2011 OpenStack LLC
+#
+#    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.
+
+"""
+Trove Command line tool
+"""
+
+#TODO(tim.simpson): optparse is deprecated. Replace with argparse.
+import optparse
+import os
+import sys
+
+
+# If ../trove/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'troveclient',
+                               '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+
+from troveclient import common
+
+
+class InstanceCommands(common.AuthedCommandsBase):
+    """Commands to perform various instances operations and actions"""
+
+    params = [
+              'flavor',
+              'id',
+              'limit',
+              'marker',
+              'name',
+              'size',
+              'backup'
+    ]
+
+    def create(self):
+        """Create a new instance"""
+        self._require('name', 'flavor')
+        volume = None
+        if self.size is not None:
+            volume = {"size": self.size}
+        restorePoint = None
+        if self.backup is not None:
+            restorePoint = {"backupRef": self.backup}
+        self._pretty_print(self.dbaas.instances.create, self.name,
+                           self.flavor, volume, restorePoint=restorePoint)
+
+    def delete(self):
+        """Delete the specified instance"""
+        self._require('id')
+        print self.dbaas.instances.delete(self.id)
+
+    def get(self):
+        """Get details for the specified instance"""
+        self._require('id')
+        self._pretty_print(self.dbaas.instances.get, self.id)
+
+    def backups(self):
+        """Get a list of backups for the specified instance"""
+        self._require('id')
+        self._pretty_list(self.dbaas.instances.backups, self.id)
+
+    def list(self):
+        """List all instances for account"""
+        # limit and marker are not required.
+        limit = self.limit or None
+        if limit:
+            limit = int(limit, 10)
+        self._pretty_paged(self.dbaas.instances.list)
+
+    def resize_volume(self):
+        """Resize an instance volume"""
+        self._require('id', 'size')
+        self._pretty_print(self.dbaas.instances.resize_volume, self.id,
+                          self.size)
+
+    def resize_instance(self):
+        """Resize an instance flavor"""
+        self._require('id', 'flavor')
+        self._pretty_print(self.dbaas.instances.resize_instance, self.id,
+                          self.flavor)
+
+    def restart(self):
+        """Restart the database"""
+        self._require('id')
+        self._pretty_print(self.dbaas.instances.restart, self.id)
+
+    def reset_password(self):
+        """Reset the root user Password"""
+        self._require('id')
+        self._pretty_print(self.dbaas.instances.reset_password, self.id)
+
+
+class FlavorsCommands(common.AuthedCommandsBase):
+    """Commands for listing Flavors"""
+
+    params = []
+
+    def list(self):
+        """List the available flavors"""
+        self._pretty_list(self.dbaas.flavors.list)
+
+
+class DatabaseCommands(common.AuthedCommandsBase):
+    """Database CRUD operations on an instance"""
+
+    params = [
+              'name',
+              'id',
+              'limit',
+              'marker',
+             ]
+
+    def create(self):
+        """Create a database"""
+        self._require('id', 'name')
+        databases = [{'name': self.name}]
+        print self.dbaas.databases.create(self.id, databases)
+
+    def delete(self):
+        """Delete a database"""
+        self._require('id', 'name')
+        print self.dbaas.databases.delete(self.id, self.name)
+
+    def list(self):
+        """List the databases"""
+        self._require('id')
+        self._pretty_paged(self.dbaas.databases.list, self.id)
+
+
+class UserCommands(common.AuthedCommandsBase):
+    """User CRUD operations on an instance"""
+    params = [
+              'id',
+              'database',
+              'databases',
+              'hostname',
+              'name',
+              'password',
+             ]
+
+    def create(self):
+        """Create a user in instance, with access to one or more databases"""
+        self._require('id', 'name', 'password', 'databases')
+        self._make_list('databases')
+        databases = [{'name': dbname} for dbname in self.databases]
+        users = [{'name': self.name, 'host': self.hostname,
+                  'password': self.password, 'databases': databases}]
+        self.dbaas.users.create(self.id, users)
+
+    def delete(self):
+        """Delete the specified user"""
+        self._require('id', 'name')
+        self.dbaas.users.delete(self.id, self.name, self.hostname)
+
+    def get(self):
+        """Get a single user."""
+        self._require('id', 'name')
+        self._pretty_print(self.dbaas.users.get, self.id,
+                           self.name, self.hostname)
+
+    def list(self):
+        """List all the users for an instance"""
+        self._require('id')
+        self._pretty_paged(self.dbaas.users.list, self.id)
+
+    def access(self):
+        """Show all databases the user has access to."""
+        self._require('id', 'name')
+        self._pretty_list(self.dbaas.users.list_access, self.id,
+                          self.name, self.hostname)
+
+    def grant(self):
+        """Allow an existing user permissions to access one or more
+        databases."""
+        self._require('id', 'name', 'databases')
+        self._make_list('databases')
+        self.dbaas.users.grant(self.id, self.name, self.databases,
+                               self.hostname)
+
+    def revoke(self):
+        """Revoke from an existing user access permissions to a database."""
+        self._require('id', 'name', 'database')
+        self.dbaas.users.revoke(self.id, self.name, self.database,
+                                self.hostname)
+
+    def change_password(self):
+        """Change the password of a single user."""
+        self._require('id', 'name', 'password')
+        users = [{'name': self.name,
+                  'host': self.hostname,
+                  'password': self.password}]
+        self.dbaas.users.change_passwords(self.id, users)
+
+
+class RootCommands(common.AuthedCommandsBase):
+    """Root user related operations on an instance"""
+
+    params = [
+              'id',
+             ]
+
+    def create(self):
+        """Enable the instance's root user."""
+        self._require('id')
+        try:
+            user, password = self.dbaas.root.create(self.id)
+            print "User:\t\t%s\nPassword:\t%s" % (user, password)
+        except:
+            print sys.exc_info()[1]
+
+    def enabled(self):
+        """Check the instance for root access"""
+        self._require('id')
+        self._pretty_print(self.dbaas.root.is_root_enabled, self.id)
+
+
+class VersionCommands(common.AuthedCommandsBase):
+    """List available versions"""
+
+    params = [
+              'url',
+             ]
+
+    def list(self):
+        """List all the supported versions"""
+        self._require('url')
+        self._pretty_list(self.dbaas.versions.index, self.url)
+
+
+class LimitsCommands(common.AuthedCommandsBase):
+    """Show the rate limits and absolute limits"""
+
+    def list(self):
+        """List the rate limits and absolute limits"""
+        self._pretty_list(self.dbaas.limits.list)
+
+
+class BackupsCommands(common.AuthedCommandsBase):
+    """Command to manage and show backups"""
+    params = ['name', 'instance', 'description']
+
+    def get(self):
+        """Get details for the specified backup"""
+        self._require('id')
+        self._pretty_print(self.dbaas.backups.get, self.id)
+
+    def list(self):
+        """List backups"""
+        self._pretty_list(self.dbaas.backups.list)
+
+    def create(self):
+        """Create a new backup"""
+        self._require('name', 'instance')
+        self._pretty_print(self.dbaas.backups.create, self.name,
+                           self.instance, self.description)
+
+    def delete(self):
+        """Delete a backup"""
+        self._require('id')
+        self._pretty_print(self.dbaas.backups.delete, self.id)
+
+
+class SecurityGroupCommands(common.AuthedCommandsBase):
+    """Commands to list and show Security Groups For an Instance and """
+    """create and delete security group rules for them. """
+    params = ['id',
+              'secgroup_id',
+              'protocol',
+              'from_port',
+              'to_port',
+              'cidr'
+              ]
+
+    def get(self):
+        """Get a security group associated with an instance."""
+        self._require('id')
+        self._pretty_print(self.dbaas.security_groups.get, self.id)
+
+    def list(self):
+        """List all the Security Groups and the rules"""
+        self._pretty_paged(self.dbaas.security_groups.list)
+
+    def add_rule(self):
+        """Add a security group rule"""
+        self._require('secgroup_id', 'protocol',
+                      'from_port', 'to_port', 'cidr')
+        self.dbaas.security_group_rules.create(self.secgroup_id, self.protocol,
+                                               self.from_port, self.to_port,
+                                               self.cidr)
+
+    def delete_rule(self):
+        """Delete a security group rule"""
+        self._require('id')
+        self.dbaas.security_group_rules.delete(self.id)
+
+
+COMMANDS = {'auth': common.Auth,
+            'instance': InstanceCommands,
+            'flavor': FlavorsCommands,
+            'database': DatabaseCommands,
+            'limit': LimitsCommands,
+            'backup': BackupsCommands,
+            'user': UserCommands,
+            'root': RootCommands,
+            'version': VersionCommands,
+            'secgroup': SecurityGroupCommands,
+            }
+
+
+def main():
+    # Parse arguments
+    load_file = True
+    for index, arg in enumerate(sys.argv):
+        if (arg == "auth" and len(sys.argv) > (index + 1)
+            and sys.argv[index + 1] == "login"):
+            load_file = False
+
+    oparser = common.CliOptions.create_optparser(load_file)
+    for k, v in COMMANDS.items():
+        v._prepare_parser(oparser)
+    (options, args) = oparser.parse_args()
+
+    if not args:
+        common.print_commands(COMMANDS)
+
+    if options.verbose:
+        os.environ['RDC_PP'] = "True"
+        os.environ['REDDWARFCLIENT_DEBUG'] = "True"
+
+    # Pop the command and check if it's in the known commands
+    cmd = args.pop(0)
+    if cmd in COMMANDS:
+        fn = COMMANDS.get(cmd)
+        command_object = None
+        try:
+            command_object = fn(oparser)
+        except Exception as ex:
+            if options.debug:
+                raise
+            print(ex)
+
+        # Get a list of supported actions for the command
+        actions = common.methods_of(command_object)
+
+        if len(args) < 1:
+            common.print_actions(cmd, actions)
+
+        # Check for a valid action and perform that action
+        action = args.pop(0)
+        if action in actions:
+            if not options.debug:
+                try:
+                    getattr(command_object, action)()
+                except Exception as ex:
+                    if options.debug:
+                        raise
+                    print ex
+            else:
+                getattr(command_object, action)()
+        else:
+            common.print_actions(cmd, actions)
+    else:
+        common.print_commands(COMMANDS)
+
+
+if __name__ == '__main__':
+    main()