def _log_action(self, instance, log_name, enable=None, disable=None,
                    publish=None, discard=None):
        """Perform action on guest log.

        :param instance: The :class:`Instance` (or its ID) of the database
                         instance to get the log for.
        :param log_name: The name of <log> to publish
        :param enable: Turn on <log>
        :param disable: Turn off <log>
        :param publish: Publish log to associated container
        :param discard: Delete the associated container
        :rtype: List of :class:`DatastoreLog`.
        """
        body = {"name": log_name}
        if enable:
            body.update({'enable': int(enable)})
        if disable:
            body.update({'disable': int(disable)})
        if publish:
            body.update({'publish': int(publish)})
        if discard:
            body.update({'discard': int(discard)})
        url = "/instances/%s/log" % base.getid(instance)
        resp, body = self.api.client.post(url, body=body)
        common.check_for_exceptions(resp, body, url)
        return DatastoreLog(self, body['log'], loaded=True)

 def _action(self, host_id, body):
     """
     Perform a host "action" -- update
     """
     url = "/mgmt/hosts/%s/instances/action" % host_id
     resp, body = self.api.client.post(url, body=body)
     common.check_for_exceptions(resp, body, url)

 def module_remove(self, instance, module):
     """Remove a module from an instance.
     """
     url = "/instances/%s/modules/%s" % (base.getid(instance),
                                         base.getid(module))
     resp, body = self.api.client.delete(url)
     common.check_for_exceptions(resp, body, url)

 def change_passwords(self, instance, users):
     """Change the password for one or more users."""
     instance_id = base.getid(instance)
     user_dict = {"users": users}
     url = "/instances/%s/users" % instance_id
     resp, body = self.api.client.put(url, body=user_dict)
     common.check_for_exceptions(resp, body, url)

 def _action(self, instance_id, body):
     """
     Perform a server "action" -- reboot/rebuild/resize/etc.
     """
     url = "/mgmt/instances/%s/action" % instance_id
     resp, body = self.api.client.post(url, body=body)
     check_for_exceptions(resp, body)

 def create(self, instance_id, users):
     """
     Create users with permissions to the specified databases
     """
     body = {"users": users}
     url = "/instances/%s/users" % instance_id
     resp, body = self.api.client.post(url, body=body)
     common.check_for_exceptions(resp, body, url)

 def create(self, instance_id):
     """
     Enable the root user and return the root password for the
     sepcified db instance
     """
     resp, body = self.api.client.post(self.url % instance_id)
     check_for_exceptions(resp, body)
     return body['user']['name'], body['user']['password']

    def delete(self, configuration):
        """Delete the specified configuration.

        :param configuration: The configuration id to delete
        """
        url = "/configurations/%s" % base.getid(configuration)
        resp, body = self.api.client.delete(url)
        common.check_for_exceptions(resp, body, url)

    def delete(self, backup_id):
        """Delete the specified backup.

        :param backup_id: The backup id to delete
        """
        url = "/backups/%s" % backup_id
        resp, body = self.api.client.delete(url)
        common.check_for_exceptions(resp, body, url)

 def _action(self, cluster, body):
     """Perform a cluster "action" -- grow/shrink/etc."""
     url = "/clusters/%s" % base.getid(cluster)
     resp, body = self.api.client.post(url, body=body)
     common.check_for_exceptions(resp, body, url)
     if body:
         return self.resource_class(self, body['cluster'], loaded=True)
     return body

    def delete(self, cluster):
        """Delete the specified cluster.

        :param cluster: The cluster to delete
        """
        url = "/clusters/%s" % base.getid(cluster)
        resp, body = self.api.client.delete(url)
        common.check_for_exceptions(resp, body, url)

 def revoke(self, instance, username, database, hostname=None):
     """Revoke from an existing user access permissions to a database."""
     instance_id = base.getid(instance)
     user = quote_user_host(username, hostname)
     url = "/instances/%(instance_id)s/users/%(user)s/" "databases/%(database)s"
     local_vars = locals()
     resp, body = self.api.client.delete(url % local_vars)
     check_for_exceptions(resp, body)

 def grant(self, instance, username, databases, hostname=None):
     """Allow an existing user permissions to access a database."""
     instance_id = base.getid(instance)
     user = quote_user_host(username, hostname)
     url = "/instances/%(instance_id)s/users/%(user)s/databases"
     dbs = {'databases': [{'name': db} for db in databases]}
     resp, body = self.api.client.put(url % locals(), body=dbs)
     check_for_exceptions(resp, body)

 def create(self, instance_id, databases):
     """
     Create new databases within the specified instance
     """
     body = {"databases": databases}
     url = "/instances/%s/databases" % instance_id
     resp, body = self.api.client.post(url, body=body)
     check_for_exceptions(resp, body)

    def delete(self, security_group_rule):
        """Delete the specified security group rule.

        :param security_group_rule: The security group rule to delete
        """
        url = "/security-group-rules/%s" % base.getid(security_group_rule)
        resp, body = self.api.client.delete(url)
        common.check_for_exceptions(resp, body, url)

 def module_apply(self, instance, modules):
     """Apply modules to an instance."""
     url = "/instances/%s/modules" % base.getid(instance)
     body = {"modules": self._get_module_list(modules)}
     resp, body = self.api.client.post(url, body=body)
     common.check_for_exceptions(resp, body, url)
     return [core_modules.Module(self, module, loaded=True)
             for module in body['modules']]

    def delete(self, instance):
        """Delete the specified instance.

        :param instance: A reference to the instance to delete
        """
        url = "/instances/%s" % base.getid(instance)
        resp, body = self.api.client.delete(url)
        common.check_for_exceptions(resp, body, url)

 def _action(self, instance, body):
     """Perform a server "action" -- reboot/rebuild/resize/etc."""
     url = "/instances/%s/action" % base.getid(instance)
     resp, body = self.api.client.post(url, body=body)
     common.check_for_exceptions(resp, body, url)
     if body:
         return self.resource_class(self, body, loaded=True)
     return body

    def create(self, instance_id):
        """Implements root-enable API.

        Enable the root user and return the root password for the
        specified db instance.
        """
        resp, body = self.api.client.post(self.url % instance_id)
        common.check_for_exceptions(resp, body, self.url)
        return body['user']['name'], body['user']['password']

    def index(self):
        """Get a list of all accounts with non-deleted instances"""

        url = "/mgmt/accounts"
        resp, body = self.api.client.get(url)
        check_for_exceptions(resp, body)
        if not body:
            raise Exception("Call to " + url + " did not return a body.")
        return base.Resource(self, body)