Преглед на файлове

Create Calico plugin for Fuel 6.1

Change-Id: I96b81f269639c45d2e5765d8859e5eac58922101
tags/liberty-eol
Emma Gordon преди 4 години
родител
ревизия
a25d0b87de

+ 204
- 0
LICENSE Целия файл

@@ -0,0 +1,204 @@
Copyright 2015 Metaswitch Networks

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.

Copyright {yyyy} {name of copyright owner}

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.


+ 98
- 0
README.md Целия файл

@@ -0,0 +1,98 @@
Calico plugin for Mirantis Fuel
===============================

Calico provides seamless, scalable, secure Layer 3 Virtual Networking for your
Mirantis OpenStack Deployment.

By replacing OpenStack’s native networking model, Calico targets deployments
where the vast majority of workloads only require L3 connectivity, providing
efficient, easy to troubleshoot networking, without the complexity and
inefficiency of overlay networking models. Calico does not require any
additional nodes or Calico specific management – it just works, and gets out
of your way!

Limitations:
------------

In the current release, Calico requires a deployment with a single OpenStack
controller. This limitation will be lifted in future releases.

Compatible versions:
--------------------

Mirantis Fuel 6.1


To build the plugin:
--------------------

- Install the fuel plugin builder, fpb:

easy_install pip

pip install fuel-plugin-builder

- Clone the calico plugin repository and run the plugin builder:

git clone https://github.com/stackforge/fuel-plugin-calico

cd fuel-plugin-calico/

fpb --build .

- Check that the file calico-fuel-plugin-1.0-1.0.0-0.noarch.rpm was created.


To install the plugin:
----------------------

- Prepare a clean fuel master node.

- Copy the plugin onto the fuel master node:

scp calico-fuel-plugin-1.0-1.0.0-0.noarch.rpm root@<Fuel_Master_Node_IP>:/tmp

- Install the plugin on the fuel master node:

cd /tmp

fuel plugins --install calico-fuel-plugin-1.0-1.0.0-0.noarch.rpm

- Check the plugin was installed:

fuel plugins --list


User Guide
----------

To deploy a cluster with the Calico plugin, use the Fuel web UI to deploy an
OpenStack cluster in the usual way, with the following guidelines:

- Create a new OpenStack environment, selecting:

Juno on Ubuntu Trusty

"Neutron with VLAN segmentation" as the networking setup

- Under the settings tab, make sure the following options are checked:

"Assign public network to all nodes"

"Use Calico Virtual Networking"

- Under the network tab, configure the 'Public' settings (leaving all of the
other sections with their default values). For example (exact values will
depend on your setup):

- IP Range: 172.18.203.60 - 172.18.203.69
- CIDR: 172.18.203.0/24
- Use VLAN tagging: No
- Gateway: 172.18.203.1
- Floating IP range: 172.18.203.70 - 172.18.203.79

- Add nodes (for meaningful testing, you will need at least two compute nodes
in addition to the controller). Note that, in this release of Calico, only
a single controller node is supported.

- Deploy changes

+ 163
- 0
deployment_scripts/calico_compute.sh Целия файл

@@ -0,0 +1,163 @@
#!/bin/bash

exec > /tmp/calico_compute.log 2>&1

set -x

echo "Hi, I'm a compute node!"

this_node_address=$(python get_node_ip.py `hostname`)
controller_node_address=$(python get_controller_ip.py)

# Get APT key for binaries.projectcalico.org.

curl -L http://binaries.projectcalico.org/repo/key | apt-key add -

# Add source for binaries.projectcalico.org, removing the priority files that
# were automatically created by the fuel plugin installer (the version number
# in the file names causes problems as it contains full stops, and the file
# contents aren't what we want).

rm -f /etc/apt/preferences.d/calico-fuel-plugin-1.0.0 /etc/apt/sources.list.d/calico-fuel-plugin-1.0.0.list

cat > /etc/apt/sources.list.d/calico.list <<EOF
deb http://binaries.projectcalico.org/fuel6.1 ./
EOF

cat << PREFS >> /etc/apt/preferences.d/calico-fuel
Package: *
Pin: origin binaries.projectcalico.org
Pin-Priority: 1100
PREFS

# Add PPA for the etcd packages, and ensure that it has lower priority than
# binaries.projectcalico.org so that we get the fuel versions of the calico
# packages.

apt-add-repository -y ppa:project-calico/juno

cat > /etc/apt/preferences.d/calico-etcd <<EOF
Package: *
Pin: origin ppa:project-calico/juno
Pin-Priority: 1075
EOF

# Pick up package details from new sources.
apt-get update

# Install etcd and configure it for a compute node.

apt-get -y install etcd

service etcd stop
rm -rf /var/lib/etcd/*
awk '/exec \/usr\/bin\/etcd/{while(getline && $0 != ""){}}1' /etc/init/etcd.conf > tmp
mv tmp /etc/init/etcd.conf
cat << EXEC_CMD >> /etc/init/etcd.conf
exec /usr/bin/etcd -proxy on \\
-listen-client-urls http://127.0.0.1:4001 \\
-initial-cluster controller=http://${controller_node_address}:2380
EXEC_CMD
service etcd start

# Run apt-get upgrade and apt-get dist-upgrade. These commands will
# bring in Calico-specific updates to the OpenStack packages and to
# dnsmasq.

apt-get -y upgrade
apt-get -y dist-upgrade

# Open /etc/nova/nova.conf and remove the linuxnet_interface_driver line.

cp /etc/nova/nova.conf /etc/nova/nova.conf.pre-calico

sed -i "/^linuxnet_interface_driver/d" /etc/nova/nova.conf
service nova-compute restart

# Install some extra packages.

apt-get -y install neutron-common neutron-dhcp-agent nova-api-metadata

# Open /etc/neutron/dhcp_agent.ini in your preferred text editor. In
# the [DEFAULT] section, add the following line:
#
# interface_driver = neutron.agent.linux.interface.RoutedInterfaceDriver

cp /etc/neutron/dhcp_agent.ini /etc/neutron/dhcp_agent.ini.pre-calico

sed -i "/^interface_driver/d" /etc/neutron/dhcp_agent.ini

sed -i "/^\[DEFAULT\]/a\
interface_driver = neutron.agent.linux.interface.RoutedInterfaceDriver
" /etc/neutron/dhcp_agent.ini

# Allow BGP connections through the Fuel firewall. We do this before
# installing calico-compute, so that they will be included when the
# calico-compute install script does iptables-save.
iptables -I INPUT 1 -p tcp --dport 179 -j ACCEPT

# Add sources for BIRD and Ubuntu Precise.

gpg --keyserver keyserver.ubuntu.com --recv-keys F9C59A45
gpg -a --export F9C59A45 | apt-key add -

cat > /etc/apt/sources.list.d/bird.list <<EOF
deb http://ppa.launchpad.net/cz.nic-labs/bird/ubuntu trusty main
EOF

cat > /etc/apt/sources.list.d/trusty.list <<EOF
deb http://gb.archive.ubuntu.com/ubuntu/ trusty main
deb http://gb.archive.ubuntu.com/ubuntu/ trusty universe
EOF

apt-get update

# Install BIRD and calico-compute packages.

# Note that this will trigger the installation of iptables-persistent which
# will attempt to bring up a dialog box. We use debconf-set-selections to set
# the value beforehand to avoid this (so not to interrupt the automated
# installation process).
echo iptables-persistent iptables-persistent/autosave_v4 boolean true | debconf-set-selections
echo iptables-persistent iptables-persistent/autosave_v6 boolean true | debconf-set-selections

apt-get -y install calico-compute bird

# Configure BIRD. By default Calico assumes that you'll be deploying
# a route reflector to avoid the need for a full BGP mesh. To this
# end, it includes useful configuration scripts that will prepare a
# BIRD config file with a single peering to the route reflector. If
# that's correct for your network, you can run the following command
# for IPv4 connectivity between compute hosts.
#
# The calico_route_reflector.sh script will set up the required BGP
# Route Reflctor configuration on the controller to allow connections
# from the compute nodes.
#
# If you are configuring a full BGP mesh you'll need to handle the BGP
# configuration appropriately - by editing this script/the Route Reflector
# script. You should consult the relevant documentation for your chosen BGP
# stack.

calico-gen-bird-conf.sh $this_node_address $controller_node_address 64511

# Edit the /etc/calico/felix.cfg file:
# Change the MetadataAddr setting to 127.0.0.1.
# Change the MetadataPort setting to 8775.

cp /etc/calico/felix.cfg.example /etc/calico/felix.cfg

sed -i "/^MetadataAddr/d" /etc/calico/felix.cfg
sed -i "/^\[global\]/a\
MetadataAddr = 127.0.0.1
" /etc/calico/felix.cfg

sed -i "/^MetadataPort/d" /etc/calico/felix.cfg
sed -i "/^\[global\]/a\
MetadataPort = 8775
" /etc/calico/felix.cfg

# Restart the Felix service:
service calico-felix restart

exit 0

+ 183
- 0
deployment_scripts/calico_controller.sh Целия файл

@@ -0,0 +1,183 @@
#!/bin/bash

exec > /tmp/calico_controller.log 2>&1

set -x

echo "Hi, I'm a controller node!"

this_node_address=$(python get_node_ip.py `hostname`)

# Get APT key for binaries.projectcalico.org.

curl -L http://binaries.projectcalico.org/repo/key | apt-key add -

# Add source for binaries.projectcalico.org, removing the priority files that
# were automatically created by the fuel plugin installer (the version number
# in the file names causes problems as it contains full stops, and the file
# contents aren't what we want).

rm -f /etc/apt/preferences.d/calico-fuel-plugin-1.0.0 /etc/apt/sources.list.d/calico-fuel-plugin-1.0.0.list

cat > /etc/apt/sources.list.d/calico.list <<EOF
deb http://binaries.projectcalico.org/fuel6.1 ./
EOF

cat << PREFS >> /etc/apt/preferences.d/calico-fuel
Package: *
Pin: origin binaries.projectcalico.org
Pin-Priority: 1100
PREFS

# Add PPA for the etcd packages, and ensure that it has lower priority than
# binaries.projectcalico.org so that we get the fuel versions of the calico
# packages.

apt-add-repository -y ppa:project-calico/juno

cat > /etc/apt/preferences.d/calico-etcd <<EOF
Package: *
Pin: origin ppa:project-calico/juno
Pin-Priority: 1075
EOF

# Pick up package details from new sources.
apt-get update

# Install etcd and configure it for a controller node.

apt-get -y install etcd

service etcd stop
rm -rf /var/lib/etcd/*
awk '/exec \/usr\/bin\/etcd/{while(getline && $0 != ""){}}1' /etc/init/etcd.conf > tmp
mv tmp /etc/init/etcd.conf
cat << EXEC_CMD >> /etc/init/etcd.conf
exec /usr/bin/etcd -name controller \\
-advertise-client-urls "http://${this_node_address}:2379,http://${this_node_address}:4001" \\
-listen-client-urls "http://0.0.0.0:2379,http://0.0.0.0:4001" \\
-listen-peer-urls "http://0.0.0.0:2380" \\
-initial-advertise-peer-urls "http://${this_node_address}:2380" \\
-initial-cluster-token fuel-cluster-1 \\
-initial-cluster controller=http://${this_node_address}:2380 \\
-initial-cluster-state new
EXEC_CMD

service etcd start

# Ensure that the firewall isn't dropping traffic to the ports used by etcd.
iptables -I INPUT 1 -p tcp --dport 2379 -j ACCEPT
iptables -I INPUT 2 -p tcp --dport 2380 -j ACCEPT
iptables -I INPUT 3 -p tcp --dport 4001 -j ACCEPT
iptables-save > /etc/iptables.local
/sbin/iptables-restore < /etc/iptables.local

# Run apt-get upgrade and apt-get dist-upgrade. These commands will
# bring in Calico-specific updates to the OpenStack packages and to
# dnsmasq.

apt-get -y upgrade
apt-get -y dist-upgrade

# Install the calico-control package:

apt-get -y install calico-control

# Edit the /etc/neutron/plugins/ml2/ml2_conf.ini file:
#
# Find the line beginning with type_drivers, and change it to
# read type_drivers = local, flat.

cp /etc/neutron/plugins/ml2/ml2_conf.ini /etc/neutron/plugins/ml2/ml2_conf.ini.pre-calico

sed -i "/^type_drivers/d" /etc/neutron/plugins/ml2/ml2_conf.ini

sed -i "/^\[ml2\]/a\
type_drivers = local, flat
" /etc/neutron/plugins/ml2/ml2_conf.ini

# Find the line beginning with mechanism_drivers, and change it
# to read mechanism_drivers = calico.

sed -i "/^mechanism_drivers/d" /etc/neutron/plugins/ml2/ml2_conf.ini

sed -i "/^\[ml2\]/a\
mechanism_drivers = calico
" /etc/neutron/plugins/ml2/ml2_conf.ini

# Find the line beginning with tenant_network_types, and change it
# to read tenant_network_types = local.

sed -i "/^tenant_network_types/d" /etc/neutron/plugins/ml2/ml2_conf.ini

sed -i "/^\[ml2\]/a\
tenant_network_types = local
" /etc/neutron/plugins/ml2/ml2_conf.ini

# Edit the /etc/neutron/neutron.conf file:
#
# Find the line for the dhcp_agents_per_network setting,
# uncomment it, and set its value to the number of compute nodes
# that you will have (or any number larger than that). This
# allows a DHCP agent to run on every compute node, which Calico
# requires because the networks on different compute nodes are
# not bridged together.

cp /etc/neutron/neutron.conf /etc/neutron/neutron.conf.pre-calico

sed -i "/^dhcp_agents_per_network/d" /etc/neutron/neutron.conf

sed -i "/^\[DEFAULT\]/a\
dhcp_agents_per_network = 1000
" /etc/neutron/neutron.conf

# Remove api_workers and rpc_workers config, so that these default to
# 0. The Calico/OpenStack plugin doesn't currently work if the
# Neutron server is split across multiple OS processes.

sed -i "/^api_workers/d" /etc/neutron/neutron.conf
sed -i "/^rpc_workers/d" /etc/neutron/neutron.conf

# Set agent_down_time to 60, instead of Fuel's default setting of 15.
# The Calico/OpenStack plugin reports Felix agent status every 30
# seconds, based on the HEARTBEAT exchange between the plugin and each
# Felix; and it is recommended that agent_down_time should be double
# the expected reporting interval.

sed -i "/^agent_down_time/d" /etc/neutron/neutron.conf

sed -i "/^\[DEFAULT\]/a\
agent_down_time = 60
" /etc/neutron/neutron.conf

# If dnspython is installed, eventlet replaces socket.getaddrinfo() with its
# own version that cannot handle IPv6 addresses. As a workaround, we comment
# out the '::1 localhost' line from /etc/hosts.

sed -i "s/^::1\(.*\)/#::1\1 #commented out due to dnspython IPv6 issue/" /etc/hosts

# Restart the neutron server process:

service neutron-server restart

# BIRD installation

gpg --keyserver keyserver.ubuntu.com --recv-keys F9C59A45
gpg -a --export F9C59A45 | apt-key add -

cat > /etc/apt/sources.list.d/bird.list <<EOF
deb http://ppa.launchpad.net/cz.nic-labs/bird/ubuntu trusty main
EOF

apt-get update

apt-get -y install bird

# Allow BGP through the Fuel firewall
iptables -I INPUT 1 -p tcp --dport 179 -j ACCEPT

# Save the current iptables so that they will be restored if the
# controller is rebooted.
iptables-save > /etc/iptables/rules.v4

exit 0

+ 63
- 0
deployment_scripts/calico_route_reflector.sh Целия файл

@@ -0,0 +1,63 @@
#!/bin/bash

exec > /tmp/calico_route_reflector.log 2>&1

set -x

echo "Hi, I'm a route_reflector node!"

this_node_address=$(grep `hostname` /etc/hosts | awk '{print $1;}')

all_nodes=$(grep node- /etc/hosts | awk '{print $1;}')

# Generate basic config for a BIRD BGP route reflector.
cat > /etc/bird/bird.conf <<EOF
# Configure logging
log syslog { debug, trace, info, remote, warning, error, auth, fatal, bug };
log stderr all;
#log "tmp" all;

# Override router ID
router id $this_node_address;


filter import_kernel {
if ( net != 0.0.0.0/0 ) then {
accept;
}
reject;
}

# Turn on global debugging of all protocols
debug protocols all;

# This pseudo-protocol watches all interface up/down events.
protocol device {
scan time 2; # Scan interfaces every 10 seconds
}
EOF

# Add a BGP protocol stanza for each compute node.
for node in $all_nodes; do
if [ $node != $this_node_address ]; then
cat >> /etc/bird/bird.conf <<EOF

protocol bgp {
description "$node";
local as 64511;
neighbor $node as 64511;
multihop;
rr client;
import all;
export all;
source address ${this_node_address};
}

EOF
fi
done

# Restart BIRD with the new config.
service bird restart

exit 0

+ 15
- 0
deployment_scripts/get_controller_ip.py Целия файл

@@ -0,0 +1,15 @@
#!/usr/bin/env python

import yaml

with open("/etc/compute.yaml", "r") as f:
config = yaml.safe_load(f)

for node in config["nodes"]:
if node["role"] == "primary-controller":
controller_ip = node["internal_address"]
break
else:
controller_ip = None

print controller_ip

+ 50
- 0
deployment_scripts/get_node_ip.py Целия файл

@@ -0,0 +1,50 @@
#!/usr/bin/env python

import os
import sys
import yaml

usage = "./get_node_ip.py <hostname>"

PRIMARY_CONTROLLER_CFG = "/etc/primary-controller.yaml"
CONTROLLER_CFG = "/etc/controller.yaml"
COMPUTE_CFG = "/etc/compute.yaml"

def get_config_file_for_node_type():
if os.path.isfile(PRIMARY_CONTROLLER_CFG):
config_file = PRIMARY_CONTROLLER_CFG

elif os.path.isfile(CONTROLLER_CFG):
config_file = CONTROLLER_CFG

elif os.path.isfile(COMPUTE_CFG):
config_file = COMPUTE_CFG

else:
raise Exception("Unrecognised node type - can't obtain config")

return config_file

def main(hostname):
config_file = get_config_file_for_node_type()

with open(config_file, "r") as f:
config = yaml.safe_load(f)

for node in config["nodes"]:
if node["fqdn"] == hostname:
# Get the IP address that other OpenStack nodes can use to address
# services on this node, rather than the node's public IP address.
this_node_ip = node["internal_address"]
break
else:
this_node_ip = None

print this_node_ip

if __name__ == "__main__":
if len(sys.argv) != 2:
print usage
sys.exit(1)

main(sys.argv[1])

+ 1
- 0
environment_config.yaml Целия файл

@@ -0,0 +1 @@
attributes: {}

+ 29
- 0
metadata.yaml Целия файл

@@ -0,0 +1,29 @@
# Plugin name
name: calico-fuel-plugin
# Human-readable name for your plugin
title: Use Calico Virtual Networking
# Plugin version
version: 1.0.0
# Description
description: Layer 3 Virtual Networking for Highly Scalable Data Centers
# Required fuel version
fuel_version: ['6.1']
# Plugin authors
authors: ['Emma Gordon']
# Plugin license
licenses: [Apache License Version 2.0]
# Plugin project homepage
homepage: https://github.com/stackforge/fuel-plugin-calico
# Plugin group
groups: ['network']

# The plugin is compatible with releases in the list
releases:
- os: ubuntu
version: 2014.2-6.1
mode: ['ha', 'multinode']
deployment_scripts_path: deployment_scripts/
repository_path: repositories/ubuntu

# Version of plugin package
package_version: '2.0.0'

+ 18
- 0
pre_build_hook Целия файл

@@ -0,0 +1,18 @@
#!/bin/bash

# Add here any the actions which are required before plugin build
# like packages building, packages downloading from mirrors and so on.
# The script should return 0 if there were no errors.

#!/bin/bash
set -eux
ROOT="$(dirname `readlink -f $0`)"
MODULES="${ROOT}"/deployment_scripts/puppet/modules
mkdir -p "${MODULES}"
REPO_PATH='https://github.com/stackforge/fuel-library/tarball/f43d885914d74fbd062096763222f350f47480e1'
RPM_REPO="${ROOT}"/repositories/centos/
DEB_REPO="${ROOT}"/repositories/ubuntu/

wget -qO- "${REPO_PATH}" | \
tar -C "${MODULES}" --strip-components=3 -zxvf - \
stackforge-fuel-library-f43d885/deployment/puppet/{inifile,stdlib}

+ 0
- 0
repositories/centos/.gitkeep Целия файл


+ 0
- 0
repositories/ubuntu/.gitkeep Целия файл


+ 144
- 0
specs/calico-fuel-plugin.rst Целия файл

@@ -0,0 +1,144 @@
Fuel Plugin for Project Calico
==============================

The Calico plugin provides the ability to use Calico as a networking backend
for Mirantis OpenStack.

Compatible with Fuel version 6.1.

Problem description
===================

Calico is a new approach to virtual networking, based on the same scalable IP
networking principles as the Internet. It targets data centers where most of
the workloads (VMs, containers or bare metal servers) only require IP
connectivity, and provides that using standard IP routing. Isolation between
workloads - whether according to tenant ownership, or any finer grained
policy - is achieved by iptables programming at the servers hosting the source
and destination workloads.

Proposed change
===============

Implement a Fuel plugin that will install and configure Calico networking in a
Mirantis OpenStack deployment.

Alternatives
------------

N/A - the aim is to implement a Fuel plugin.

Data model impact
-----------------

None.

REST API impact
---------------

None.

Upgrade impact
--------------

When upgrading the Fuel Master node to Fuel Version higher than 6.1, plugin
compatibility should be checked, and a new plugin installed if necessary.

Security impact
---------------

None.

Notifications impact
--------------------

None.

Other end user impact
---------------------

Once the plugin is installed, the user can enable Calico networking on the
Settings tab of the Fuel Web UI, and customize the network settings.

Performance Impact
------------------

None.

Plugin impact
-------------

None.

Other deployer impact
---------------------

None.

Developer impact
----------------

None.

Infrastructure impact
---------------------

None.

Implementation
==============

Assignee(s)
-----------

Primary assignee:
Emma Gordon <emma@projectcalico.org> (developer)

Other contributors:
Neil Jerram <neil@projectcalico.org> (developer, reviewer)

Work Items
----------

* Integrate Calico with Fuel 6.1.

* Implement the Calico plugin.

* Test Calico plugin.

* Create the documentation.

Dependencies
============

* Fuel 6.1.

Testing
=======

* Prepare a test plan.

* Test the plugin according to the test plan.

Documentation Impact
====================

* User Guide.

* Test Plan.

* Test Report.

References
==========

* Project Calico wesbite - http://www.projectcalico.org/

* Calico code on GitHub - https://github.com/Metaswitch/calico

* Calico Documentation - http://docs.projectcalico.org/en/latest/index.html

* Subscribe to the Calico Technical Mailing List -
http://lists.projectcalico.org/listinfo/calico-tech

* Calico IRC - freenode IRC: #calico

+ 23
- 0
tasks.yaml Целия файл

@@ -0,0 +1,23 @@
# Install/configure calico on the controller after cluster deployment
# but before starting the BGP Route Reflector.
- role: ['controller', 'primary-controller']
stage: post_deployment/50
type: shell
parameters:
cmd: ./calico_controller.sh
timeout: 600

- role: ['controller', 'primary-controller']
stage: post_deployment/100
type: shell
parameters:
cmd: ./calico_route_reflector.sh
timeout: 60

# Install/configure calico on the compute nodes after cluster deployment.
- role: ['compute']
stage: post_deployment
type: shell
parameters:
cmd: ./calico_compute.sh
timeout: 600

Loading…
Отказ
Запис