OpenStack Networking (Neutron)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
Tyler Smith 8a9133c183 Tweaking other multiblade tests. 10 years ago
bin Addressing comments from Dan 10 years ago
etc merge trunk 10 years ago
extensions fix print statements in novatenant and portprofile 10 years ago
quantum Tweaking other multiblade tests. 10 years ago
tests make CLI show_port command display interface-id, add additional test case 10 years ago
tools Addressing comments from Dan 10 years ago
.bzrignore adding /bzrignore to precent checking in pyc files and that sort of stuff... 11 years ago
LICENSE Adding Apache Version 2.0 license file. This is the official license agreement under which Quantum code is available to 10 years ago
README Santhosh/Rajaram|modified extensions section in README 10 years ago
TESTING Add TESTING document: description and polices for quantum tests 10 years ago
run_tests.py refactoring testing code to support plugin tests 10 years ago
run_tests.sh undo unintentional formatting change in run_tests.sh 10 years ago
setup.py PEP8 fixes for setup.py 10 years ago

README

# -- Welcome!

You have come across a cloud computing network fabric controller. It has
identified itself as "Quantum." It aims to tame your (cloud) networking!

# -- Basics:

1) Quantum REST API: Quantum supports a REST-ful programmatic interface to
manage your cloud networking fabric.

2) Quantum Plugins: Quantum sports a plug-able architecture that allows
Quantum's REST API to be backed by various entities that can create a
cloud-class virtual networking fabric. The advantages of this plug-able
architecture is two-folds:

a) Allows for ANY open-source project or commercial vendor to write a
Quantum plug-in.

b) Allows Quantum users to not be tied down to a single Quantum
implementation and enables them to switch out a plug-in by simple editing a
config file - plugins.ini

# -- Dependencies

The following python packages are required to run quantum. These can be
installed using pip:

eventlet>=0.9.12
nose
Paste
PasteDeploy
pep8==0.5.0
python-gflags
routes
simplejson
webob
webtest

1) Install easy_install (there is probably a distribution specific package for
this)

2) Install pip:
$ easy_install pip==dev
3) Install packages with pip:
$ pip install <package name>

# -- Configuring Quantum plug-in

1) Identify your desired plug-in. Choose a plugin from one of he options in
the quantum/plugins directory.

2) Update plug-in configuration by editing the quantum/plugins.ini file and
modify "provider" property to point to the location of the Quantum plug-in.
It should specify the class path to the plugin and the class name (i.e. for
a plugin class MyPlugin in quantum/plugins/myplugin/myplugin.py the
provider would be: quantum.plugins.myplugin.myplugin.MyPlugin)

3) Read the plugin specific README, this is usually found in the same
directory as your Quantum plug-in, and follow configuration instructions.

# -- Launching the Quantum Service

1) Start quantum using the following command [on the quantum service host]:
~/src/quantum$ PYTHONPATH=.:$PYTHONPATH python bin/quantum etc/quantum.conf

# -- Making requests against the Quantum Service

Please refer to sample Web Service client code in:

../quantum/test_scripts/miniclient.py

# -- CLI tools to program the Quantum-managed Cloud networking fabric

Quantum comes with a programmatic CLI that is driven by the Quantum Web
Service. You can use the CLI by issuing the following command:

~/src/quantum$ PYTHONPATH=.:$PYTHONPATH python quantum/cli.py

This will show help all of the available commands.

An example session looks like this:

$ export TENANT=t1
$ PYTHONPATH=. python quantum/cli.py -v create_net $TENANT network1
Created a new Virtual Network with ID:e754e7c0-a8eb-40e5-861a-b182d30c3441

# -- Writing your own Quantum plug-in

If you wish the write your own Quantum plugin, please refer to some concrete as
well as sample plugins available in:

../quantum/quantum/plugins/.. directory.

There are a few requirements to writing your own plugin:

1) Your plugin should implement all methods defined in the
quantum/quantum_plugin_base.QuantumPluginBase class

2) Copy your Quantum plug-in over to the quantum/quantum/plugins/.. directory

3) The next step is to edit the plugins.ini file in the same directory
as QuantumPluginBase class and specify the location of your custom plugin
as the "provider"

4) Launch the Quantum Service, and your plug-in is configured and ready to
manage a Cloud Networking Fabric.

# -- Extensions

1) Creating Extensions:
a) Extension files should be placed under ./extensions folder.
b) The extension file should have a class with the same name as the filename.
This class should implement the contract required by the extension framework.
See ExtensionDescriptor class in ./quantum/common/extensions.py for details
c) To stop a file in ./extensions folder from being loaded as an extension,
the filename should start with an "_"
For an example of an extension file look at Foxinsocks class in
./tests/unit/extensions/foxinsocks.py
The unit tests in ./tests/unit/test_extensions.py document all the ways in
which you can use extensions

2) Associating plugins with extensions:
a) A Plugin can advertize all the extensions it supports through the
'supported_extension_aliases' attribute. Eg:

class SomePlugin:
...
supported_extension_aliases = ['extension1_alias',
'extension2_alias',
'extension3_alias']
Any extension not in this list will not be loaded for the plugin

b) Extension Interfaces for plugins (optional)
The extension can mandate an interface that plugins have to support with the
'get_plugin_interface' method in the extension.
For an example see the FoxInSocksPluginInterface in foxinsocks.py.

The QuantumEchoPlugin lists foxinsox in its supported_extension_aliases
and implements the method from FoxInSocksPluginInterface.