Split out quantum.client and quantum.common.
Change-Id: I1241bcd3305b6859c0cd2bb8c35b523e27aa3b18changes/65/3165/4
Monty Taylor
parent
e85f2ea8bf
commit
13222958a5
|
|
@ -2,9 +2,9 @@
|
|||
*.DS_Store
|
||||
build/*
|
||||
build-stamp
|
||||
quantum.egg-info/
|
||||
run_tests.err.log
|
||||
run_tests.log
|
||||
tests/
|
||||
.quantum-venv/
|
||||
.venv/
|
||||
quantum/vcsversion.py
|
||||
|
|
|
|||
24
bin/quantum
24
bin/quantum
|
|
@ -1,24 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
|
||||
# Copyright 2011 Nicira Neworks, 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.
|
||||
|
||||
import os
|
||||
import sys
|
||||
sys.path.insert(0, os.getcwd())
|
||||
import quantum.client.cli as cli
|
||||
|
||||
cli.main()
|
||||
|
|
@ -49,7 +49,7 @@ auth_admin_password = secrete
|
|||
#auth_admin_token = <token-value>
|
||||
|
||||
[filter:extensions]
|
||||
paste.filter_factory = quantum.common.extensions:plugin_aware_extension_middleware_factory
|
||||
paste.filter_factory = quantum.extensions.extensions:plugin_aware_extension_middleware_factory
|
||||
|
||||
[app:quantumversions]
|
||||
paste.app_factory = quantum.api.versions:Versions.factory
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ api_extensions_path = ../../../../extensions
|
|||
pipeline = extensions extensions_test_app
|
||||
|
||||
[filter:extensions]
|
||||
paste.filter_factory = quantum.common.extensions:plugin_aware_extension_middleware_factory
|
||||
paste.filter_factory = quantum.extensions.extensions:plugin_aware_extension_middleware_factory
|
||||
|
||||
[app:extensions_test_app]
|
||||
paste.app_factory = quantum.plugins.cisco.tests.unit.test_cisco_extension:app_factory
|
||||
|
|
|
|||
|
|
@ -1,359 +0,0 @@
|
|||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
|
||||
# Copyright 2011 Citrix Systems
|
||||
# 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.
|
||||
# @author: Tyler Smith, Cisco Systems
|
||||
|
||||
import logging
|
||||
import httplib
|
||||
import socket
|
||||
import urllib
|
||||
|
||||
from quantum.common import exceptions
|
||||
from quantum.common.serializer import Serializer
|
||||
|
||||
LOG = logging.getLogger('quantum.client')
|
||||
EXCEPTIONS = {
|
||||
400: exceptions.BadInputError,
|
||||
401: exceptions.NotAuthorized,
|
||||
420: exceptions.NetworkNotFound,
|
||||
421: exceptions.NetworkInUse,
|
||||
430: exceptions.PortNotFound,
|
||||
431: exceptions.StateInvalid,
|
||||
432: exceptions.PortInUseClient,
|
||||
440: exceptions.AlreadyAttachedClient,
|
||||
501: exceptions.NotImplementedError}
|
||||
AUTH_TOKEN_HEADER = "X-Auth-Token"
|
||||
|
||||
|
||||
class ApiCall(object):
|
||||
"""A Decorator to add support for format and tenant overriding"""
|
||||
def __init__(self, function):
|
||||
self.function = function
|
||||
|
||||
def __get__(self, instance, owner):
|
||||
def with_params(*args, **kwargs):
|
||||
"""
|
||||
Temporarily sets the format and tenant for this request
|
||||
"""
|
||||
(format, tenant) = (instance.format, instance.tenant)
|
||||
|
||||
if 'format' in kwargs:
|
||||
instance.format = kwargs['format']
|
||||
if 'tenant' in kwargs:
|
||||
instance.tenant = kwargs['tenant']
|
||||
|
||||
ret = self.function(instance, *args)
|
||||
(instance.format, instance.tenant) = (format, tenant)
|
||||
return ret
|
||||
return with_params
|
||||
|
||||
|
||||
class Client(object):
|
||||
|
||||
"""A base client class - derived from Glance.BaseClient"""
|
||||
|
||||
#Metadata for deserializing xml
|
||||
_serialization_metadata = {
|
||||
"application/xml": {
|
||||
"attributes": {
|
||||
"network": ["id", "name"],
|
||||
"port": ["id", "state"],
|
||||
"attachment": ["id"]},
|
||||
"plurals": {"networks": "network",
|
||||
"ports": "port"}},
|
||||
}
|
||||
|
||||
# Action query strings
|
||||
networks_path = "/networks"
|
||||
network_path = "/networks/%s"
|
||||
ports_path = "/networks/%s/ports"
|
||||
port_path = "/networks/%s/ports/%s"
|
||||
attachment_path = "/networks/%s/ports/%s/attachment"
|
||||
|
||||
def __init__(self, host="127.0.0.1", port=9696, use_ssl=False, tenant=None,
|
||||
format="xml", testingStub=None, key_file=None, cert_file=None,
|
||||
auth_token=None, logger=None,
|
||||
action_prefix="/v1.0/tenants/{tenant_id}"):
|
||||
"""
|
||||
Creates a new client to some service.
|
||||
|
||||
:param host: The host where service resides
|
||||
:param port: The port where service resides
|
||||
:param use_ssl: True to use SSL, False to use HTTP
|
||||
:param tenant: The tenant ID to make requests with
|
||||
:param format: The format to query the server with
|
||||
:param testingStub: A class that stubs basic server methods for tests
|
||||
:param key_file: The SSL key file to use if use_ssl is true
|
||||
:param cert_file: The SSL cert file to use if use_ssl is true
|
||||
:param auth_token: authentication token to be passed to server
|
||||
:param logger: Logger object for the client library
|
||||
:param action_prefix: prefix for request URIs
|
||||
"""
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.use_ssl = use_ssl
|
||||
self.tenant = tenant
|
||||
self.format = format
|
||||
self.connection = None
|
||||
self.testingStub = testingStub
|
||||
self.key_file = key_file
|
||||
self.cert_file = cert_file
|
||||
self.logger = logger
|
||||
self.auth_token = auth_token
|
||||
self.action_prefix = action_prefix
|
||||
|
||||
def get_connection_type(self):
|
||||
"""
|
||||
Returns the proper connection type
|
||||
"""
|
||||
if self.testingStub:
|
||||
return self.testingStub
|
||||
if self.use_ssl:
|
||||
return httplib.HTTPSConnection
|
||||
else:
|
||||
return httplib.HTTPConnection
|
||||
|
||||
def _send_request(self, conn, method, action, body, headers):
|
||||
# Salvatore: Isolating this piece of code in its own method to
|
||||
# facilitate stubout for testing
|
||||
if self.logger:
|
||||
self.logger.debug("Quantum Client Request:\n" \
|
||||
+ method + " " + action + "\n")
|
||||
if body:
|
||||
self.logger.debug(body)
|
||||
conn.request(method, action, body, headers)
|
||||
return conn.getresponse()
|
||||
|
||||
def do_request(self, method, action, body=None,
|
||||
headers=None, params=None, exception_args={}):
|
||||
"""
|
||||
Connects to the server and issues a request.
|
||||
Returns the result data, or raises an appropriate exception if
|
||||
HTTP status code is not 2xx
|
||||
|
||||
:param method: HTTP method ("GET", "POST", "PUT", etc...)
|
||||
:param body: string of data to send, or None (default)
|
||||
:param headers: mapping of key/value pairs to add as headers
|
||||
:param params: dictionary of key/value pairs to add to append
|
||||
to action
|
||||
|
||||
"""
|
||||
LOG.debug("Client issuing request: %s", action)
|
||||
# Ensure we have a tenant id
|
||||
if not self.tenant:
|
||||
raise Exception("Tenant ID not set")
|
||||
|
||||
# Add format and tenant_id
|
||||
action += ".%s" % self.format
|
||||
action = self.action_prefix + action
|
||||
action = action.replace('{tenant_id}', self.tenant)
|
||||
|
||||
if isinstance(params, dict):
|
||||
action += '?' + urllib.urlencode(params)
|
||||
if body:
|
||||
body = self.serialize(body)
|
||||
|
||||
try:
|
||||
connection_type = self.get_connection_type()
|
||||
headers = headers or {"Content-Type":
|
||||
"application/%s" % self.format}
|
||||
# if available, add authentication token
|
||||
if self.auth_token:
|
||||
headers[AUTH_TOKEN_HEADER] = self.auth_token
|
||||
# Open connection and send request, handling SSL certs
|
||||
certs = {'key_file': self.key_file, 'cert_file': self.cert_file}
|
||||
certs = dict((x, certs[x]) for x in certs if certs[x] is not None)
|
||||
|
||||
if self.use_ssl and len(certs):
|
||||
conn = connection_type(self.host, self.port, **certs)
|
||||
else:
|
||||
conn = connection_type(self.host, self.port)
|
||||
res = self._send_request(conn, method, action, body, headers)
|
||||
status_code = self.get_status_code(res)
|
||||
data = res.read()
|
||||
|
||||
if self.logger:
|
||||
self.logger.debug("Quantum Client Reply (code = %s) :\n %s" \
|
||||
% (str(status_code), data))
|
||||
if status_code in (httplib.OK,
|
||||
httplib.CREATED,
|
||||
httplib.ACCEPTED,
|
||||
httplib.NO_CONTENT):
|
||||
return self.deserialize(data, status_code)
|
||||
else:
|
||||
error_message = res.read()
|
||||
LOG.debug("Server returned error: %s", status_code)
|
||||
LOG.debug("Error message: %s", error_message)
|
||||
# Create exception with HTTP status code and message
|
||||
if res.status in EXCEPTIONS:
|
||||
raise EXCEPTIONS[res.status](**exception_args)
|
||||
# Add error code and message to exception arguments
|
||||
ex = Exception("Server returned error: %s" % status_code)
|
||||
ex.args = ([dict(status_code=status_code,
|
||||
message=error_message)],)
|
||||
raise ex
|
||||
except (socket.error, IOError), e:
|
||||
msg = "Unable to connect to server. Got error: %s" % e
|
||||
LOG.exception(msg)
|
||||
raise Exception(msg)
|
||||
|
||||
def get_status_code(self, response):
|
||||
"""
|
||||
Returns the integer status code from the response, which
|
||||
can be either a Webob.Response (used in testing) or httplib.Response
|
||||
"""
|
||||
if hasattr(response, 'status_int'):
|
||||
return response.status_int
|
||||
else:
|
||||
return response.status
|
||||
|
||||
def serialize(self, data):
|
||||
"""
|
||||
Serializes a dictionary with a single key (which can contain any
|
||||
structure) into either xml or json
|
||||
"""
|
||||
if data is None:
|
||||
return None
|
||||
elif isinstance(data, dict):
|
||||
return Serializer().serialize(data, self.content_type())
|
||||
else:
|
||||
raise Exception("unable to serialize object of type = '%s'" \
|
||||
% type(data))
|
||||
|
||||
def deserialize(self, data, status_code):
|
||||
"""
|
||||
Deserializes a an xml or json string into a dictionary
|
||||
"""
|
||||
if status_code == 204:
|
||||
return data
|
||||
return Serializer(self._serialization_metadata).\
|
||||
deserialize(data, self.content_type())
|
||||
|
||||
def content_type(self, format=None):
|
||||
"""
|
||||
Returns the mime-type for either 'xml' or 'json'. Defaults to the
|
||||
currently set format
|
||||
"""
|
||||
if not format:
|
||||
format = self.format
|
||||
return "application/%s" % (format)
|
||||
|
||||
@ApiCall
|
||||
def list_networks(self):
|
||||
"""
|
||||
Fetches a list of all networks for a tenant
|
||||
"""
|
||||
return self.do_request("GET", self.networks_path)
|
||||
|
||||
@ApiCall
|
||||
def show_network_details(self, network):
|
||||
"""
|
||||
Fetches the details of a certain network
|
||||
"""
|
||||
return self.do_request("GET", self.network_path % (network),
|
||||
exception_args={"net_id": network})
|
||||
|
||||
@ApiCall
|
||||
def create_network(self, body=None):
|
||||
"""
|
||||
Creates a new network
|
||||
"""
|
||||
return self.do_request("POST", self.networks_path, body=body)
|
||||
|
||||
@ApiCall
|
||||
def update_network(self, network, body=None):
|
||||
"""
|
||||
Updates a network
|
||||
"""
|
||||
return self.do_request("PUT", self.network_path % (network), body=body,
|
||||
exception_args={"net_id": network})
|
||||
|
||||
@ApiCall
|
||||
def delete_network(self, network):
|
||||
"""
|
||||
Deletes the specified network
|
||||
"""
|
||||
return self.do_request("DELETE", self.network_path % (network),
|
||||
exception_args={"net_id": network})
|
||||
|
||||
@ApiCall
|
||||
def list_ports(self, network):
|
||||
"""
|
||||
Fetches a list of ports on a given network
|
||||
"""
|
||||
return self.do_request("GET", self.ports_path % (network))
|
||||
|
||||
@ApiCall
|
||||
def show_port_details(self, network, port):
|
||||
"""
|
||||
Fetches the details of a certain port
|
||||
"""
|
||||
return self.do_request("GET", self.port_path % (network, port),
|
||||
exception_args={"net_id": network, "port_id": port})
|
||||
|
||||
@ApiCall
|
||||
def create_port(self, network, body=None):
|
||||
"""
|
||||
Creates a new port on a given network
|
||||
"""
|
||||
return self.do_request("POST", self.ports_path % (network), body=body,
|
||||
exception_args={"net_id": network})
|
||||
|
||||
@ApiCall
|
||||
def delete_port(self, network, port):
|
||||
"""
|
||||
Deletes the specified port from a network
|
||||
"""
|
||||
return self.do_request("DELETE", self.port_path % (network, port),
|
||||
exception_args={"net_id": network, "port_id": port})
|
||||
|
||||
@ApiCall
|
||||
def update_port(self, network, port, body=None):
|
||||
"""
|
||||
Sets the attributes of the specified port
|
||||
"""
|
||||
return self.do_request("PUT",
|
||||
self.port_path % (network, port), body=body,
|
||||
exception_args={"net_id": network,
|
||||
"port_id": port})
|
||||
|
||||
@ApiCall
|
||||
def show_port_attachment(self, network, port):
|
||||
"""
|
||||
Fetches the attachment-id associated with the specified port
|
||||
"""
|
||||
return self.do_request("GET", self.attachment_path % (network, port),
|
||||
exception_args={"net_id": network, "port_id": port})
|
||||
|
||||
@ApiCall
|
||||
def attach_resource(self, network, port, body=None):
|
||||
"""
|
||||
Sets the attachment-id of the specified port
|
||||
"""
|
||||
return self.do_request("PUT",
|
||||
self.attachment_path % (network, port), body=body,
|
||||
exception_args={"net_id": network,
|
||||
"port_id": port,
|
||||
"attach_id": str(body)})
|
||||
|
||||
@ApiCall
|
||||
def detach_resource(self, network, port):
|
||||
"""
|
||||
Removes the attachment-id of the specified port
|
||||
"""
|
||||
return self.do_request("DELETE",
|
||||
self.attachment_path % (network, port),
|
||||
exception_args={"net_id": network, "port_id": port})
|
||||
|
|
@ -1,167 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
|
||||
# Copyright 2011 Nicira Networks, Inc.
|
||||
# Copyright 2011 Citrix Systems
|
||||
#
|
||||
# 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.
|
||||
# @author: Somik Behera, Nicira Networks, Inc.
|
||||
# @author: Brad Hall, Nicira Networks, Inc.
|
||||
# @author: Salvatore Orlando, Citrix
|
||||
|
||||
import gettext
|
||||
import logging
|
||||
import logging.handlers
|
||||
import os
|
||||
import sys
|
||||
|
||||
from optparse import OptionParser
|
||||
|
||||
|
||||
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, 'quantum', '__init__.py')):
|
||||
sys.path.insert(0, possible_topdir)
|
||||
|
||||
gettext.install('quantum', unicode=1)
|
||||
|
||||
from quantum.client import cli_lib
|
||||
from quantum.client import Client
|
||||
|
||||
#Configure logger for client - cli logger is a child of it
|
||||
#NOTE(salvatore-orlando): logger name does not map to package
|
||||
#this is deliberate. Simplifies logger configuration
|
||||
LOG = logging.getLogger('quantum')
|
||||
FORMAT = 'json'
|
||||
commands = {
|
||||
"list_nets": {
|
||||
"func": cli_lib.list_nets,
|
||||
"args": ["tenant-id"]},
|
||||
"create_net": {
|
||||
"func": cli_lib.create_net,
|
||||
"args": ["tenant-id", "net-name"]},
|
||||
"delete_net": {
|
||||
"func": cli_lib.delete_net,
|
||||
"args": ["tenant-id", "net-id"]},
|
||||
"show_net": {
|
||||
"func": cli_lib.show_net,
|
||||
"args": ["tenant-id", "net-id"]},
|
||||
"update_net": {
|
||||
"func": cli_lib.update_net,
|
||||
"args": ["tenant-id", "net-id", "new-name"]},
|
||||
"list_ports": {
|
||||
"func": cli_lib.list_ports,
|
||||
"args": ["tenant-id", "net-id"]},
|
||||
"create_port": {
|
||||
"func": cli_lib.create_port,
|
||||
"args": ["tenant-id", "net-id"]},
|
||||
"delete_port": {
|
||||
"func": cli_lib.delete_port,
|
||||
"args": ["tenant-id", "net-id", "port-id"]},
|
||||
"update_port": {
|
||||
"func": cli_lib.update_port,
|
||||
"args": ["tenant-id", "net-id", "port-id", "params"]},
|
||||
"show_port": {
|
||||
"func": cli_lib.show_port,
|
||||
"args": ["tenant-id", "net-id", "port-id"]},
|
||||
"plug_iface": {
|
||||
"func": cli_lib.plug_iface,
|
||||
"args": ["tenant-id", "net-id", "port-id", "iface-id"]},
|
||||
"unplug_iface": {
|
||||
"func": cli_lib.unplug_iface,
|
||||
"args": ["tenant-id", "net-id", "port-id"]}, }
|
||||
|
||||
|
||||
def help():
|
||||
print "\nCommands:"
|
||||
for k in commands.keys():
|
||||
print " %s %s" % (k,
|
||||
" ".join(["<%s>" % y for y in commands[k]["args"]]))
|
||||
|
||||
|
||||
def build_args(cmd, cmdargs, arglist):
|
||||
args = []
|
||||
orig_arglist = arglist[:]
|
||||
try:
|
||||
for x in cmdargs:
|
||||
args.append(arglist[0])
|
||||
del arglist[0]
|
||||
except:
|
||||
LOG.error("Not enough arguments for \"%s\" (expected: %d, got: %d)" % (
|
||||
cmd, len(cmdargs), len(orig_arglist)))
|
||||
print "Usage:\n %s %s" % (cmd,
|
||||
" ".join(["<%s>" % y for y in commands[cmd]["args"]]))
|
||||
return None
|
||||
if len(arglist) > 0:
|
||||
LOG.error("Too many arguments for \"%s\" (expected: %d, got: %d)" % (
|
||||
cmd, len(cmdargs), len(orig_arglist)))
|
||||
print "Usage:\n %s %s" % (cmd,
|
||||
" ".join(["<%s>" % y for y in commands[cmd]["args"]]))
|
||||
return None
|
||||
return args
|
||||
|
||||
|
||||
def main():
|
||||
usagestr = "Usage: %prog [OPTIONS] <command> [args]"
|
||||
parser = OptionParser(usage=usagestr)
|
||||
parser.add_option("-H", "--host", dest="host",
|
||||
type="string", default="127.0.0.1", help="ip address of api host")
|
||||
parser.add_option("-p", "--port", dest="port",
|
||||
type="int", default=9696, help="api poort")
|
||||
parser.add_option("-s", "--ssl", dest="ssl",
|
||||
action="store_true", default=False, help="use ssl")
|
||||
parser.add_option("-v", "--verbose", dest="verbose",
|
||||
action="store_true", default=False, help="turn on verbose logging")
|
||||
parser.add_option("-f", "--logfile", dest="logfile",
|
||||
type="string", default="syslog", help="log file path")
|
||||
parser.add_option("-t", "--token", dest="token",
|
||||
type="string", default=None, help="authentication token")
|
||||
options, args = parser.parse_args()
|
||||
|
||||
if options.verbose:
|
||||
LOG.setLevel(logging.DEBUG)
|
||||
else:
|
||||
LOG.setLevel(logging.WARN)
|
||||
#logging.handlers.WatchedFileHandler
|
||||
|
||||
if options.logfile == "syslog":
|
||||
LOG.addHandler(logging.handlers.SysLogHandler(address='/dev/log'))
|
||||
else:
|
||||
LOG.addHandler(logging.handlers.WatchedFileHandler(options.logfile))
|
||||
# Set permissions on log file
|
||||
os.chmod(options.logfile, 0644)
|
||||
|
||||
if len(args) < 1:
|
||||
parser.print_help()
|
||||
help()
|
||||
sys.exit(1)
|
||||
|
||||
cmd = args[0]
|
||||
if cmd not in commands.keys():
|
||||
LOG.error("Unknown command: %s" % cmd)
|
||||
help()
|
||||
sys.exit(1)
|
||||
|
||||
args = build_args(cmd, commands[cmd]["args"], args[1:])
|
||||
if not args:
|
||||
sys.exit(1)
|
||||
LOG.info("Executing command \"%s\" with args: %s" % (cmd, args))
|
||||
|
||||
client = Client(options.host, options.port, options.ssl,
|
||||
args[0], FORMAT,
|
||||
auth_token=options.token)
|
||||
commands[cmd]["func"](client, *args)
|
||||
|
||||
LOG.info("Command execution completed")
|
||||
sys.exit(0)
|
||||
|
|
@ -1,335 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
|
||||
# Copyright 2011 Nicira Networks, Inc.
|
||||
# Copyright 2011 Citrix Systems
|
||||
#
|
||||
# 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.
|
||||
# @author: Somik Behera, Nicira Networks, Inc.
|
||||
# @author: Brad Hall, Nicira Networks, Inc.
|
||||
# @author: Salvatore Orlando, Citrix
|
||||
|
||||
""" Functions providing implementation for CLI commands. """
|
||||
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
FORMAT = "json"
|
||||
LOG = logging.getLogger('quantum.client.cli_lib')
|
||||
|
||||
|
||||
class OutputTemplate(object):
|
||||
""" A class for generating simple templated output.
|
||||
Based on Python templating mechanism.
|
||||
Templates can also express attributes on objects, such as network.id;
|
||||
templates can also be nested, thus allowing for iteration on inner
|
||||
templates.
|
||||
|
||||
Examples:
|
||||
1) template with class attributes
|
||||
Name: %(person.name)s \n
|
||||
Surname: %(person.surname)s \n
|
||||
2) template with iteration
|
||||
Telephone numbers: \n
|
||||
%(phone_numbers|Telephone number:%(number)s)
|
||||
3) template with iteration and class attributes
|
||||
Addresses: \n
|
||||
%(Addresses|Street:%(address.street)s\nNumber%(address.number))
|
||||
|
||||
Instances of this class are initialized with a template string and
|
||||
the dictionary for performing substition. The class implements the
|
||||
__str__ method, so it can be directly printed.
|
||||
"""
|
||||
|
||||
def __init__(self, template, data):
|
||||
self._template = template
|
||||
self.data = data
|
||||
|
||||
def __str__(self):
|
||||
return self._template % self
|
||||
|
||||
def __getitem__(self, key):
|
||||
items = key.split("|")
|
||||
if len(items) == 1:
|
||||
return self._make_attribute(key)
|
||||
else:
|
||||
# Note(salvatore-orlando): items[0] must be subscriptable
|
||||
return self._make_list(self.data[items[0]], items[1])
|
||||
|
||||
def _make_attribute(self, item):
|
||||
""" Renders an entity attribute key in the template.
|
||||
e.g.: entity.attribute
|
||||
"""
|
||||
items = item.split('.')
|
||||
if len(items) == 1:
|
||||
return self.data[item]
|
||||
elif len(items) == 2:
|
||||
return self.data[items[0]][items[1]]
|
||||
|
||||
def _make_list(self, items, inner_template):
|
||||
""" Renders a list key in the template.
|
||||
e.g.: %(list|item data:%(item))
|
||||
"""
|
||||
#make sure list is subscriptable
|
||||
if not hasattr(items, '__getitem__'):
|
||||
raise Exception("Element is not iterable")
|
||||
return "\n".join([inner_template % item for item in items])
|
||||
|
||||
|
||||
class CmdOutputTemplate(OutputTemplate):
|
||||
""" This class provides templated output for CLI commands.
|
||||
Extends OutputTemplate loading a different template for each command.
|
||||
"""
|
||||
|
||||
_templates = {
|
||||
"list_nets": "Virtual Networks for Tenant %(tenant_id)s\n" +
|
||||
"%(networks|\tNetwork ID: %(id)s)s",
|
||||
"show_net": "Network ID: %(network.id)s\n" +
|
||||
"network Name: %(network.name)s",
|
||||
"create_net": "Created a new Virtual Network with ID: " +
|
||||
"%(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s",
|
||||
"update_net": "Updated Virtual Network with ID: %(network.id)s\n" +
|
||||
"for Tenant: %(tenant_id)s\n",
|
||||
"delete_net": "Deleted Virtual Network with ID: %(network_id)s\n" +
|
||||
"for Tenant %(tenant_id)s",
|
||||
"list_ports": "Ports on Virtual Network: %(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s\n" +
|
||||
"%(ports|\tLogical Port: %(id)s)s",
|
||||
"create_port": "Created new Logical Port with ID: %(port_id)s\n" +
|
||||
"on Virtual Network: %(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s",
|
||||
"show_port": "Logical Port ID: %(port.id)s\n" +
|
||||
"administrative State: %(port.state)s\n" +
|
||||
"interface: %(port.attachment)s\n" +
|
||||
"on Virtual Network: %(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s",
|
||||
"update_port": "Updated Logical Port " +
|
||||
"with ID: %(port.id)s\n" +
|
||||
"on Virtual Network: %(network_id)s\n" +
|
||||
"for tenant: %(tenant_id)s",
|
||||
"delete_port": "Deleted Logical Port with ID: %(port_id)s\n" +
|
||||
"on Virtual Network: %(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s",
|
||||
"plug_iface": "Plugged interface %(attachment)s\n" +
|
||||
"into Logical Port: %(port_id)s\n" +
|
||||
"on Virtual Network: %(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s",
|
||||
"unplug_iface": "Unplugged interface from Logical Port:" +
|
||||
"%(port_id)s\n" +
|
||||
"on Virtual Network: %(network_id)s\n" +
|
||||
"for Tenant: %(tenant_id)s"}
|
||||
|
||||
def __init__(self, cmd, data):
|
||||
super(CmdOutputTemplate, self).__init__(self._templates[cmd], data)
|
||||
|
||||
|
||||
def _handle_exception(ex):
|
||||
LOG.exception(sys.exc_info())
|
||||
print "Exception:%s - %s" % (sys.exc_info()[0], sys.exc_info()[1])
|
||||
status_code = None
|
||||
message = None
|
||||
# Retrieve dict at 1st element of tuple at last argument
|
||||
if ex.args and isinstance(ex.args[-1][0], dict):
|
||||
status_code = ex.args[-1][0].get('status_code', None)
|
||||
message = ex.args[-1][0].get('message', None)
|
||||
msg_1 = "Command failed with error code: %s" \
|
||||
% (status_code or '<missing>')
|
||||
msg_2 = "Error message:%s" % (message or '<missing>')
|
||||
LOG.exception(msg_1 + "-" + msg_2)
|
||||
print msg_1
|
||||
print msg_2
|
||||
|
||||
|
||||
def prepare_output(cmd, tenant_id, response):
|
||||
LOG.debug("Preparing output for response:%s", response)
|
||||
response['tenant_id'] = tenant_id
|
||||
output = str(CmdOutputTemplate(cmd, response))
|
||||
LOG.debug("Finished preparing output for command:%s", cmd)
|
||||
return output
|
||||
|
||||
|
||||
def list_nets(client, *args):
|
||||
tenant_id = args[0]
|
||||
res = client.list_networks()
|
||||
LOG.debug("Operation 'list_networks' executed.")
|
||||
output = prepare_output("list_nets", tenant_id, res)
|
||||
print output
|
||||
|
||||
|
||||
def create_net(client, *args):
|
||||
tenant_id, name = args
|
||||
data = {'network': {'name': name}}
|
||||
new_net_id = None
|
||||
try:
|
||||
res = client.create_network(data)
|
||||
new_net_id = res["network"]["id"]
|
||||
LOG.debug("Operation 'create_network' executed.")
|
||||
output = prepare_output("create_net", tenant_id,
|
||||
dict(network_id=new_net_id))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def delete_net(client, *args):
|
||||
tenant_id, network_id = args
|
||||
try:
|
||||
client.delete_network(network_id)
|
||||
LOG.debug("Operation 'delete_network' executed.")
|
||||
output = prepare_output("delete_net", tenant_id,
|
||||
dict(network_id=network_id))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def show_net(client, *args):
|
||||
tenant_id, network_id = args
|
||||
try:
|
||||
#NOTE(salvatore-orlando) changed for returning exclusively
|
||||
# output for GET /networks/{net-id} API operation
|
||||
res = client.show_network_details(network_id)["network"]
|
||||
LOG.debug("Operation 'show_network_details' executed.")
|
||||
output = prepare_output("show_net", tenant_id,
|
||||
dict(network=res))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def update_net(client, *args):
|
||||
tenant_id, network_id, param_data = args
|
||||
data = {'network': {}}
|
||||
for kv in param_data.split(","):
|
||||
k, v = kv.split("=")
|
||||
data['network'][k] = v
|
||||
data['network']['id'] = network_id
|
||||
try:
|
||||
client.update_network(network_id, data)
|
||||
LOG.debug("Operation 'update_network' executed.")
|
||||
# Response has no body. Use data for populating output
|
||||
output = prepare_output("update_net", tenant_id, data)
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def list_ports(client, *args):
|
||||
tenant_id, network_id = args
|
||||
try:
|
||||
ports = client.list_ports(network_id)
|
||||
LOG.debug("Operation 'list_ports' executed.")
|
||||
data = ports
|
||||
data['network_id'] = network_id
|
||||
output = prepare_output("list_ports", tenant_id, data)
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def create_port(client, *args):
|
||||
tenant_id, network_id = args
|
||||
try:
|
||||
res = client.create_port(network_id)
|
||||
LOG.debug("Operation 'create_port' executed.")
|
||||
new_port_id = res["port"]["id"]
|
||||
output = prepare_output("create_port", tenant_id,
|
||||
dict(network_id=network_id,
|
||||
port_id=new_port_id))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def delete_port(client, *args):
|
||||
tenant_id, network_id, port_id = args
|
||||
try:
|
||||
client.delete_port(network_id, port_id)
|
||||
LOG.debug("Operation 'delete_port' executed.")
|
||||
output = prepare_output("delete_port", tenant_id,
|
||||
dict(network_id=network_id,
|
||||
port_id=port_id))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
return
|
||||
|
||||
|
||||
def show_port(client, *args):
|
||||
tenant_id, network_id, port_id = args
|
||||
try:
|
||||
port = client.show_port_details(network_id, port_id)["port"]
|
||||
LOG.debug("Operation 'list_port_details' executed.")
|
||||
#NOTE(salvatore-orland): current API implementation does not
|
||||
#return attachment with GET operation on port. Once API alignment
|
||||
#branch is merged, update client to use the detail action.
|
||||
# (danwent) Until then, just make additonal webservice call.
|
||||
attach = client.show_port_attachment(network_id, port_id)['attachment']
|
||||
if "id" in attach:
|
||||
port['attachment'] = attach['id']
|
||||
else:
|
||||
port['attachment'] = '<none>'
|
||||
output = prepare_output("show_port", tenant_id,
|
||||
dict(network_id=network_id,
|
||||
port=port))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def update_port(client, *args):
|
||||
tenant_id, network_id, port_id, param_data = args
|
||||
data = {'port': {}}
|
||||
for kv in param_data.split(","):
|
||||
k, v = kv.split("=")
|
||||
data['port'][k] = v
|
||||
data['network_id'] = network_id
|
||||
data['port']['id'] = port_id
|
||||
try:
|
||||
client.update_port(network_id, port_id, data)
|
||||
LOG.debug("Operation 'udpate_port' executed.")
|
||||
# Response has no body. Use data for populating output
|
||||
output = prepare_output("update_port", tenant_id, data)
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def plug_iface(client, *args):
|
||||
tenant_id, network_id, port_id, attachment = args
|
||||
try:
|
||||
data = {'attachment': {'id': '%s' % attachment}}
|
||||
client.attach_resource(network_id, port_id, data)
|
||||
LOG.debug("Operation 'attach_resource' executed.")
|
||||
output = prepare_output("plug_iface", tenant_id,
|
||||
dict(network_id=network_id,
|
||||
port_id=port_id,
|
||||
attachment=attachment))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
||||
|
||||
def unplug_iface(client, *args):
|
||||
tenant_id, network_id, port_id = args
|
||||
try:
|
||||
client.detach_resource(network_id, port_id)
|
||||
LOG.debug("Operation 'detach_resource' executed.")
|
||||
output = prepare_output("unplug_iface", tenant_id,
|
||||
dict(network_id=network_id,
|
||||
port_id=port_id))
|
||||
print output
|
||||
except Exception as ex:
|
||||
_handle_exception(ex)
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
# Copyright 2011 Nicira Networks, 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.
|
||||
# @author: Somik Behera, Nicira Networks, Inc.
|
||||
|
|
@ -1,327 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
|
||||
# Copyright 2011 Nicira Networks, 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.
|
||||
|
||||
"""
|
||||
Routines for configuring Quantum
|
||||
"""
|
||||
|
||||
import ConfigParser
|
||||
import logging
|
||||
import logging.config
|
||||
import logging.handlers
|
||||
import optparse
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
from paste import deploy
|
||||
|
||||
from quantum.common import flags
|
||||
from quantum.common import exceptions as exception
|
||||
|
||||
DEFAULT_LOG_FORMAT = "%(asctime)s %(levelname)8s [%(name)s] %(message)s"
|
||||
DEFAULT_LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
|
||||
|
||||
FLAGS = flags.FLAGS
|
||||
LOG = logging.getLogger('quantum.wsgi')
|
||||
|
||||
|
||||
def parse_options(parser, cli_args=None):
|
||||
"""
|
||||
Returns the parsed CLI options, command to run and its arguments, merged
|
||||
with any same-named options found in a configuration file.
|
||||
|
||||
The function returns a tuple of (options, args), where options is a
|
||||
mapping of option key/str(value) pairs, and args is the set of arguments
|
||||
(not options) supplied on the command-line.
|
||||
|
||||
The reason that the option values are returned as strings only is that
|
||||
ConfigParser and paste.deploy only accept string values...
|
||||
|
||||
:param parser: The option parser
|
||||
:param cli_args: (Optional) Set of arguments to process. If not present,
|
||||
sys.argv[1:] is used.
|
||||
:retval tuple of (options, args)
|
||||
"""
|
||||
|
||||
(options, args) = parser.parse_args(cli_args)
|
||||
|
||||
return (vars(options), args)
|
||||
|
||||
|
||||
def add_common_options(parser):
|
||||
"""
|
||||
Given a supplied optparse.OptionParser, adds an OptionGroup that
|
||||
represents all common configuration options.
|
||||
|
||||
:param parser: optparse.OptionParser
|
||||
"""
|
||||
help_text = "The following configuration options are common to "\
|
||||
"all quantum programs."
|
||||
|
||||
group = optparse.OptionGroup(parser, "Common Options", help_text)
|
||||
group.add_option('-v', '--verbose', default=False, dest="verbose",
|
||||
action="store_true",
|
||||
help="Print more verbose output")
|
||||
group.add_option('-d', '--debug', default=False, dest="debug",
|
||||
action="store_true",
|
||||
help="Print debugging output")
|
||||
group.add_option('--config-file', default=None, metavar="PATH",
|
||||
help="Path to the config file to use. When not specified "
|
||||
"(the default), we generally look at the first "
|
||||
"argument specified to be a config file, and if "
|
||||
"that is also missing, we search standard "
|
||||
"directories for a config file.")
|
||||
parser.add_option_group(group)
|
||||
|
||||
|
||||
def add_log_options(parser):
|
||||
"""
|
||||
Given a supplied optparse.OptionParser, adds an OptionGroup that
|
||||
represents all the configuration options around logging.
|
||||
|
||||
:param parser: optparse.OptionParser
|
||||
"""
|
||||
help_text = "The following configuration options are specific to logging "\
|
||||
"functionality for this program."
|
||||
|
||||
group = optparse.OptionGroup(parser, "Logging Options", help_text)
|
||||
group.add_option('--log-config', default=None, metavar="PATH",
|
||||
help="If this option is specified, the logging "
|
||||
"configuration file specified is used and overrides "
|
||||
"any other logging options specified. Please see "
|
||||
"the Python logging module documentation for "
|
||||
"details on logging configuration files.")
|
||||
group.add_option('--log-date-format', metavar="FORMAT",
|
||||
default=DEFAULT_LOG_DATE_FORMAT,
|
||||
help="Format string for %(asctime)s in log records. "
|
||||
"Default: %default")
|
||||
group.add_option('--log-file', default=None, metavar="PATH",
|
||||
help="(Optional) Name of log file to output to. "
|
||||
"If not set, logging will go to stdout.")
|
||||
group.add_option("--log-dir", default=None,
|
||||
help="(Optional) The directory to keep log files in "
|
||||
"(will be prepended to --logfile)")
|
||||
parser.add_option_group(group)
|
||||
|
||||
|
||||
def setup_logging(options, conf):
|
||||
"""
|
||||
Sets up the logging options for a log with supplied name
|
||||
|
||||
:param options: Mapping of typed option key/values
|
||||
:param conf: Mapping of untyped key/values from config file
|
||||
"""
|
||||
|
||||
if options.get('log_config', None):
|
||||
# Use a logging configuration file for all settings...
|
||||
if os.path.exists(options['log_config']):
|
||||
logging.config.fileConfig(options['log_config'])
|
||||
return
|
||||
else:
|
||||
raise RuntimeError("Unable to locate specified logging "
|
||||
"config file: %s" % options['log_config'])
|
||||
|
||||
# If either the CLI option or the conf value
|
||||
# is True, we set to True
|
||||
debug = options.get('debug') or \
|
||||
get_option(conf, 'debug', type='bool', default=False)
|
||||
verbose = options.get('verbose') or \
|
||||
get_option(conf, 'verbose', type='bool', default=False)
|
||||
root_logger = logging.root
|
||||
if debug:
|
||||
root_logger.setLevel(logging.DEBUG)
|
||||
elif verbose:
|
||||
root_logger.setLevel(logging.INFO)
|
||||
else:
|
||||
root_logger.setLevel(logging.WARNING)
|
||||
|
||||
# Set log configuration from options...
|
||||
# Note that we use a hard-coded log format in the options
|
||||
# because of Paste.Deploy bug #379
|
||||
# http://trac.pythonpaste.org/pythonpaste/ticket/379
|
||||
log_format = options.get('log_format', DEFAULT_LOG_FORMAT)
|
||||
log_date_format = options.get('log_date_format', DEFAULT_LOG_DATE_FORMAT)
|
||||
formatter = logging.Formatter(log_format, log_date_format)
|
||||
|
||||
logfile = options.get('log_file')
|
||||
if not logfile:
|
||||
logfile = conf.get('log_file')
|
||||
|
||||
if logfile:
|
||||
logdir = options.get('log_dir')
|
||||
if not logdir:
|
||||
logdir = conf.get('log_dir')
|
||||
if logdir:
|
||||
logfile = os.path.join(logdir, logfile)
|
||||
logfile = logging.FileHandler(logfile)
|
||||
logfile.setFormatter(formatter)
|
||||
logfile.setFormatter(formatter)
|
||||
root_logger.addHandler(logfile)
|
||||
else:
|
||||
handler = logging.StreamHandler(sys.stdout)
|
||||
handler.setFormatter(formatter)
|
||||
root_logger.addHandler(handler)
|
||||
|
||||
|
||||
def find_config_file(options, args, config_file='quantum.conf'):
|
||||
"""
|
||||
Return the first config file found.
|
||||
|
||||
We search for the paste config file in the following order:
|
||||
* If --config-file option is used, use that
|
||||
* If args[0] is a file, use that
|
||||
* Search for the configuration file in standard directories:
|
||||
* .
|
||||
* ~.quantum/
|
||||
* ~
|
||||
* $FLAGS.state_path/etc/quantum
|
||||
* $FLAGS.state_path/etc
|
||||
|
||||
:retval Full path to config file, or None if no config file found
|
||||
"""
|
||||
|
||||
fix_path = lambda p: os.path.abspath(os.path.expanduser(p))
|
||||
if options.get('config_file'):
|
||||
if os.path.exists(options['config_file']):
|
||||
return fix_path(options['config_file'])
|
||||
elif args:
|
||||
if os.path.exists(args[0]):
|
||||
return fix_path(args[0])
|
||||
|
||||
dir_to_common = os.path.dirname(os.path.abspath(__file__))
|
||||
root = os.path.join(dir_to_common, '..', '..', '..', '..')
|
||||
# Handle standard directory search for the config file
|
||||
config_file_dirs = [fix_path(os.path.join(os.getcwd(), 'etc')),
|
||||
fix_path(os.path.join('~', '.venv', 'etc',
|
||||
'quantum')),
|
||||
fix_path('~'),
|
||||
os.path.join(FLAGS.state_path, 'etc'),
|
||||
os.path.join(FLAGS.state_path, 'etc', 'quantum'),
|
||||
fix_path(os.path.join('~', '.local',
|
||||
'etc', 'quantum')),
|
||||
'/usr/etc/quantum',
|
||||
'/usr/local/etc/quantum',
|
||||
'/etc/quantum/',
|
||||
'/etc']
|
||||
|
||||
if 'plugin' in options:
|
||||
config_file_dirs = [os.path.join(x, 'quantum', 'plugins',
|
||||
options['plugin'])
|
||||
for x in config_file_dirs]
|
||||
|
||||
if os.path.exists(os.path.join(root, 'plugins')):
|
||||
plugins = [fix_path(os.path.join(root, 'plugins', p, 'etc'))
|
||||
for p in os.listdir(os.path.join(root, 'plugins'))]
|
||||
plugins = [p for p in plugins if os.path.isdir(p)]
|
||||
config_file_dirs.extend(plugins)
|
||||
|
||||
for cfg_dir in config_file_dirs:
|
||||
cfg_file = os.path.join(cfg_dir, config_file)
|
||||
if os.path.exists(cfg_file):
|
||||
return cfg_file
|
||||
|
||||
|
||||
def load_paste_config(app_name, options, args):
|
||||
"""
|
||||
Looks for a config file to use for an app and returns the
|
||||
config file path and a configuration mapping from a paste config file.
|
||||
|
||||
We search for the paste config file in the following order:
|
||||
* If --config-file option is used, use that
|
||||
* If args[0] is a file, use that
|
||||
* Search for quantum.conf in standard directories:
|
||||
* .
|
||||
* ~.quantum/
|
||||
* ~
|
||||
* /etc/quantum
|
||||
* /etc
|
||||
|
||||
:param app_name: Name of the application to load config for, or None.
|
||||
None signifies to only load the [DEFAULT] section of
|
||||
the config file.
|
||||
:param options: Set of typed options returned from parse_options()
|
||||
:param args: Command line arguments from argv[1:]
|
||||
:retval Tuple of (conf_file, conf)
|
||||
|
||||
:raises RuntimeError when config file cannot be located or there was a
|
||||
problem loading the configuration file.
|
||||
"""
|
||||
conf_file = find_config_file(options, args)
|
||||
if not conf_file:
|
||||
raise RuntimeError("Unable to locate any configuration file. "
|
||||
"Cannot load application %s" % app_name)
|
||||
try:
|
||||
conf = deploy.appconfig("config:%s" % conf_file, name=app_name)
|
||||
return conf_file, conf
|
||||
except Exception, e:
|
||||
raise RuntimeError("Error trying to load config %s: %s"
|
||||
% (conf_file, e))
|
||||
|
||||
|
||||
def load_paste_app(app_name, options, args):
|
||||
"""
|
||||
Builds and returns a WSGI app from a paste config file.
|
||||
|
||||
We search for the paste config file in the following order:
|
||||
* If --config-file option is used, use that
|
||||
* If args[0] is a file, use that
|
||||
* Search for quantum.conf in standard directories:
|
||||
* .
|
||||
* ~.quantum/
|
||||
* ~
|
||||
* /etc/quantum
|
||||
* /etc
|
||||
|
||||
:param app_name: Name of the application to load
|
||||
:param options: Set of typed options returned from parse_options()
|
||||
:param args: Command line arguments from argv[1:]
|
||||
|
||||
:raises RuntimeError when config file cannot be located or application
|
||||
cannot be loaded from config file
|
||||
"""
|
||||
conf_file, conf = load_paste_config(app_name, options, args)
|
||||
|
||||
try:
|
||||
app = deploy.loadapp("config:%s" % conf_file, name=app_name)
|
||||
except (LookupError, ImportError), e:
|
||||
raise RuntimeError("Unable to load %(app_name)s from "
|
||||
"configuration file %(conf_file)s."
|
||||
"\nGot: %(e)r" % locals())
|
||||
return conf, app
|
||||
|
||||
|
||||
def get_option(options, option, **kwargs):
|
||||
if option in options:
|
||||
value = options[option]
|
||||
type_ = kwargs.get('type', 'str')
|
||||
if type_ == 'bool':
|
||||
if hasattr(value, 'lower'):
|
||||
return value.lower() == 'true'
|
||||
else:
|
||||
return value
|
||||
elif type_ == 'int':
|
||||
return int(value)
|
||||
elif type_ == 'float':
|
||||
return float(value)
|
||||
else:
|
||||
return value
|
||||
elif 'default' in kwargs:
|
||||
return kwargs['default']
|
||||
else:
|
||||
raise KeyError("option '%s' not found" % option)
|
||||
|
|
@ -1,178 +0,0 @@
|
|||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
|
||||
# Copyright 2011 Nicira Networks, 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.
|
||||
|
||||
"""
|
||||
Quantum base exception handling, including decorator for re-raising
|
||||
Quantum-type exceptions. SHOULD include dedicated exception logging.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import gettext
|
||||
|
||||
gettext.install('quantum', unicode=1)
|
||||
|
||||
|
||||
class QuantumException(Exception):
|
||||
"""Base Quantum Exception
|
||||
|
||||
Taken from nova.exception.NovaException
|
||||
To correctly use this class, inherit from it and define
|
||||
a 'message' property. That message will get printf'd
|
||||
with the keyword arguments provided to the constructor.
|
||||
|
||||
"""
|
||||
message = _("An unknown exception occurred.")
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
try:
|
||||
self._error_string = self.message % kwargs
|
||||
|
||||
except Exception:
|
||||
# at least get the core message out if something happened
|
||||
self._error_string = self.message
|
||||
|
||||
def __str__(self):
|
||||
return self._error_string
|
||||
|
||||
|
||||
class ProcessExecutionError(IOError):
|
||||
def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None,
|
||||
description=None):
|
||||
if description is None:
|
||||
description = "Unexpected error while running command."
|
||||
if exit_code is None:
|
||||
exit_code = '-'
|
||||
message = "%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r" % (
|
||||
description, cmd, exit_code, stdout, stderr)
|
||||
IOError.__init__(self, message)
|
||||
|
||||
|
||||
class Error(Exception):
|
||||
def __init__(self, message=None):
|
||||
super(Error, self).__init__(message)
|
||||
|
||||
|
||||
class ApiError(Error):
|
||||
def __init__(self, message='Unknown', code='Unknown'):
|
||||
self.message = message
|
||||
self.code = code
|
||||
super(ApiError, self).__init__('%s: %s' % (code, message))
|
||||
|
||||
|
||||
class NotFound(QuantumException):
|
||||
pass
|
||||
|
||||
|
||||
class ClassNotFound(NotFound):
|
||||
message = _("Class %(class_name)s could not be found")
|
||||
|
||||
|
||||
class NetworkNotFound(NotFound):
|
||||
message = _("Network %(net_id)s could not be found")
|
||||
|
||||
|
||||
class PortNotFound(NotFound):
|
||||
message = _("Port %(port_id)s could not be found " \
|
||||
"on network %(net_id)s")
|
||||
|
||||
|
||||
class StateInvalid(QuantumException):
|
||||
message = _("Unsupported port state: %(port_state)s")
|
||||
|
||||
|
||||
class NetworkInUse(QuantumException):
|
||||
message = _("Unable to complete operation on network %(net_id)s. " \
|
||||
"There is one or more attachments plugged into its ports.")
|
||||
|
||||
|
||||
class PortInUse(QuantumException):
|
||||
message = _("Unable to complete operation on port %(port_id)s " \
|
||||
"for network %(net_id)s. The attachment '%(att_id)s" \
|
||||
"is plugged into the logical port.")
|
||||
|
||||
|
||||
class AlreadyAttached(QuantumException):
|
||||
message = _("Unable to plug the attachment %(att_id)s into port " \
|
||||
"%(port_id)s for network %(net_id)s. The attachment is " \
|
||||
"already plugged into port %(att_port_id)s")
|
||||
|
||||
|
||||
# NOTE: on the client side, we often do not know all of the information
|
||||
# that is known on the server, thus, we create separate exception for
|
||||
# those scenarios
|
||||
class PortInUseClient(QuantumException):
|
||||
message = _("Unable to complete operation on port %(port_id)s " \
|
||||
"for network %(net_id)s. An attachment " \
|
||||
"is plugged into the logical port.")
|
||||
|
||||
|
||||
class AlreadyAttachedClient(QuantumException):
|
||||
message = _("Unable to plug the attachment %(att_id)s into port " \
|
||||
"%(port_id)s for network %(net_id)s. The attachment is " \
|
||||
"already plugged into another port.")
|
||||
|
||||
|
||||
class MalformedRequestBody(QuantumException):
|
||||
message = _("Malformed request body: %(reason)s")
|
||||
|
||||
|
||||
class Duplicate(Error):
|
||||
pass
|
||||
|
||||
|
||||
class NotAuthorized(Error):
|
||||
pass
|
||||
|
||||
|
||||
class NotEmpty(Error):
|
||||
pass
|
||||
|
||||
|
||||
class Invalid(Error):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidContentType(Invalid):
|
||||
message = _("Invalid content type %(content_type)s.")
|
||||
|
||||
|
||||
class BadInputError(Exception):
|
||||
"""Error resulting from a client sending bad input to a server"""
|
||||
pass
|
||||
|
||||
|
||||
class MissingArgumentError(Error):
|
||||
pass
|
||||
|
||||
|
||||