a63b971306
This change condenses the directory structure to something more similar to what we had before while producing similar packages. It also introduces version.py which allows us to get the version from git tags (or a fallback version if not available). Fixes lp bug 889336 Fixes lp bug 888795 Change-Id: I86136bd9dbabb5eb1f8366ed665ed9b54f695124
336 lines
12 KiB
Python
Executable File
336 lines
12 KiB
Python
Executable File
#!/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)
|