702 lines
28 KiB
Python
702 lines
28 KiB
Python
#!/usr/bin/env python
|
|
|
|
import click
|
|
import sys
|
|
import time
|
|
|
|
from solar.core import actions
|
|
from solar.core import resource
|
|
from solar.core import signals
|
|
from solar.core import validation
|
|
from solar.core.resource import virtual_resource as vr
|
|
from solar import errors
|
|
|
|
from solar.interfaces.db import get_db
|
|
|
|
|
|
GIT_PUPPET_LIBS_URL = 'https://github.com/CGenie/puppet-libs-resource'
|
|
|
|
|
|
# TODO
|
|
# Resource for repository OR puppet apt-module in run.pp
|
|
# add-apt-repository cloud-archive:juno
|
|
# To discuss: install stuff in Docker container
|
|
|
|
# NOTE
|
|
# No copy of manifests, pull from upstream (implemented in the puppet handler)
|
|
# Official puppet manifests, not fuel-library
|
|
|
|
|
|
db = get_db()
|
|
|
|
|
|
@click.group()
|
|
def main():
|
|
pass
|
|
|
|
|
|
def setup_resources():
|
|
db.clear()
|
|
|
|
signals.Connections.clear()
|
|
|
|
node1, node2 = vr.create('nodes', 'templates/nodes.yml', {})
|
|
|
|
# MARIADB
|
|
mariadb_service1 = vr.create('mariadb_service1', 'resources/mariadb_service', {
|
|
'image': 'mariadb',
|
|
'port': 3306
|
|
})[0]
|
|
|
|
signals.connect(node1, mariadb_service1)
|
|
|
|
# RABBIT
|
|
rabbitmq_service1 = vr.create('rabbitmq_service1', 'resources/rabbitmq_service/', {
|
|
'management_port': 15672,
|
|
'port': 5672,
|
|
})[0]
|
|
openstack_vhost = vr.create('openstack_vhost', 'resources/rabbitmq_vhost/', {
|
|
'vhost_name': 'openstack'
|
|
})[0]
|
|
|
|
openstack_rabbitmq_user = vr.create('openstack_rabbitmq_user', 'resources/rabbitmq_user/', {
|
|
'user_name': 'openstack',
|
|
'password': 'openstack_password'
|
|
})[0]
|
|
|
|
signals.connect(node1, rabbitmq_service1)
|
|
signals.connect(rabbitmq_service1, openstack_vhost)
|
|
signals.connect(rabbitmq_service1, openstack_rabbitmq_user)
|
|
signals.connect(openstack_vhost, openstack_rabbitmq_user, {
|
|
'vhost_name',
|
|
})
|
|
|
|
# KEYSTONE
|
|
keystone_puppet = vr.create('keystone_puppet', 'resources/keystone_puppet', {})[0]
|
|
keystone_db = vr.create('keystone_db', 'resources/mariadb_db/', {
|
|
'db_name': 'keystone_db',
|
|
'login_user': 'root'
|
|
})[0]
|
|
keystone_db_user = vr.create('keystone_db_user', 'resources/mariadb_user/', {
|
|
'user_name': 'keystone',
|
|
'user_password': 'keystone',
|
|
})[0]
|
|
keystone_service_endpoint = vr.create('keystone_service_endpoint', 'resources/keystone_service_endpoint', {
|
|
'endpoint_name': 'keystone',
|
|
'adminurl': 'http://{{admin_ip}}:{{admin_port}}/v2.0',
|
|
'internalurl': 'http://{{internal_ip}}:{{internal_port}}/v2.0',
|
|
'publicurl': 'http://{{public_ip}}:{{public_port}}/v2.0',
|
|
'description': 'OpenStack Identity Service',
|
|
'type': 'identity'
|
|
})[0]
|
|
|
|
admin_tenant = vr.create('admin_tenant', 'resources/keystone_tenant', {
|
|
'tenant_name': 'admin'
|
|
})[0]
|
|
admin_user = vr.create('admin_user', 'resources/keystone_user', {
|
|
'user_name': 'admin',
|
|
'user_password': 'admin'
|
|
})[0]
|
|
admin_role = vr.create('admin_role', 'resources/keystone_role', {
|
|
'role_name': 'admin'
|
|
})[0]
|
|
services_tenant = vr.create('services_tenant', 'resources/keystone_tenant', {
|
|
'tenant_name': 'services'
|
|
})[0]
|
|
|
|
signals.connect(node1, keystone_db)
|
|
signals.connect(node1, keystone_db_user)
|
|
signals.connect(node1, keystone_puppet)
|
|
signals.connect(mariadb_service1, keystone_db, {
|
|
'port': 'login_port',
|
|
'root_user': 'login_user',
|
|
'root_password': 'login_password',
|
|
'ip' : 'db_host',
|
|
})
|
|
signals.connect(keystone_db, keystone_db_user, {
|
|
'db_name',
|
|
'login_port',
|
|
'login_user',
|
|
'login_password',
|
|
'db_host'
|
|
})
|
|
|
|
signals.connect(node1, keystone_service_endpoint)
|
|
signals.connect(keystone_puppet, keystone_service_endpoint, {
|
|
'admin_token': 'admin_token',
|
|
'admin_port': ['admin_port', 'keystone_admin_port'],
|
|
'ip': ['keystone_host', 'admin_ip', 'internal_ip', 'public_ip'],
|
|
'port': ['internal_port', 'public_port'],
|
|
})
|
|
|
|
signals.connect(keystone_puppet, admin_tenant)
|
|
signals.connect(keystone_puppet, admin_tenant, {
|
|
'admin_port': 'keystone_port',
|
|
'ip': 'keystone_host'
|
|
})
|
|
signals.connect(admin_tenant, admin_user)
|
|
signals.connect(admin_user, admin_role)
|
|
|
|
signals.connect(keystone_puppet, services_tenant)
|
|
signals.connect(keystone_puppet, services_tenant, {
|
|
'admin_port': 'keystone_port',
|
|
'ip': 'keystone_host'
|
|
})
|
|
|
|
signals.connect(keystone_db, keystone_puppet, {
|
|
'db_name',
|
|
})
|
|
signals.connect(keystone_db_user, keystone_puppet, {
|
|
'user_name': 'db_user',
|
|
'user_password': 'db_password',
|
|
'db_host' : 'db_host'
|
|
})
|
|
|
|
# OPENRC
|
|
openrc = vr.create('openrc_file', 'resources/openrc_file', {})[0]
|
|
|
|
signals.connect(node1, openrc)
|
|
signals.connect(keystone_puppet, openrc, {'ip': 'keystone_host', 'admin_port':'keystone_port'})
|
|
signals.connect(admin_user, openrc, {'user_name': 'user_name','user_password':'password', 'tenant_name': 'tenant'})
|
|
|
|
# NEUTRON
|
|
# Deploy chain neutron -> (plugins) -> neutron_server -> ( agents )
|
|
neutron_puppet = vr.create('neutron_puppet', 'resources/neutron_puppet', {
|
|
'core_plugin': 'neutron.plugins.openvswitch.ovs_neutron_plugin.OVSNeutronPluginV2'
|
|
})[0]
|
|
signals.connect(node1, neutron_puppet)
|
|
signals.connect(rabbitmq_service1, neutron_puppet, {
|
|
'ip': 'rabbit_host',
|
|
'port': 'rabbit_port'
|
|
})
|
|
signals.connect(openstack_rabbitmq_user, neutron_puppet, {
|
|
'user_name': 'rabbit_user',
|
|
'password': 'rabbit_password'})
|
|
signals.connect(openstack_vhost, neutron_puppet, {
|
|
'vhost_name': 'rabbit_virtual_host'})
|
|
|
|
# NEUTRON API (SERVER)
|
|
neutron_server_puppet = vr.create('neutron_server_puppet', 'resources/neutron_server_puppet', {
|
|
'sync_db': True,
|
|
})[0]
|
|
neutron_db = vr.create('neutron_db', 'resources/mariadb_db/', {
|
|
'db_name': 'neutron_db', 'login_user': 'root'})[0]
|
|
neutron_db_user = vr.create('neutron_db_user', 'resources/mariadb_user/', {
|
|
'user_name': 'neutron', 'user_password': 'neutron', 'login_user': 'root'})[0]
|
|
neutron_keystone_user = vr.create('neutron_keystone_user', 'resources/keystone_user', {
|
|
'user_name': 'neutron',
|
|
'user_password': 'neutron'
|
|
})[0]
|
|
neutron_keystone_role = vr.create('neutron_keystone_role', 'resources/keystone_role', {
|
|
'role_name': 'admin'
|
|
})[0]
|
|
neutron_keystone_service_endpoint = vr.create('neutron_keystone_service_endpoint', 'resources/keystone_service_endpoint', {
|
|
'endpoint_name': 'neutron',
|
|
'adminurl': 'http://{{admin_ip}}:{{admin_port}}',
|
|
'internalurl': 'http://{{internal_ip}}:{{internal_port}}',
|
|
'publicurl': 'http://{{public_ip}}:{{public_port}}',
|
|
'description': 'OpenStack Network Service',
|
|
'type': 'network'
|
|
})[0]
|
|
|
|
signals.connect(node1, neutron_db)
|
|
signals.connect(node1, neutron_db_user)
|
|
signals.connect(mariadb_service1, neutron_db, {
|
|
'port': 'login_port',
|
|
'root_password': 'login_password',
|
|
'root_user': 'login_user',
|
|
'ip' : 'db_host'})
|
|
signals.connect(mariadb_service1, neutron_db_user, {'port': 'login_port', 'root_password': 'login_password'})
|
|
signals.connect(neutron_db, neutron_db_user, {'db_name', 'db_host'})
|
|
signals.connect(neutron_db_user, neutron_server_puppet, {
|
|
'user_name':'db_user',
|
|
'db_name':'db_name',
|
|
'user_password':'db_password',
|
|
'db_host' : 'db_host'})
|
|
signals.connect(node1, neutron_server_puppet)
|
|
signals.connect(admin_user, neutron_server_puppet, {
|
|
'user_name': 'auth_user',
|
|
'user_password': 'auth_password',
|
|
'tenant_name': 'auth_tenant'
|
|
})
|
|
signals.connect(keystone_puppet, neutron_server_puppet, {
|
|
'ip': 'auth_host',
|
|
'port': 'auth_port'
|
|
})
|
|
signals.connect(services_tenant, neutron_keystone_user)
|
|
signals.connect(neutron_keystone_user, neutron_keystone_role)
|
|
signals.connect(keystone_puppet, neutron_keystone_service_endpoint, {
|
|
'ip': ['ip', 'keystone_host'],
|
|
'ssh_key': 'ssh_key',
|
|
'ssh_user': 'ssh_user',
|
|
'admin_port': 'keystone_admin_port',
|
|
'admin_token': 'admin_token',
|
|
})
|
|
signals.connect(neutron_puppet, neutron_keystone_service_endpoint, {
|
|
'ip': ['admin_ip', 'internal_ip', 'public_ip'],
|
|
'bind_port': ['admin_port', 'internal_port', 'public_port'],
|
|
})
|
|
|
|
# NEUTRON OVS PLUGIN & AGENT WITH GRE
|
|
neutron_plugins_ovs = vr.create('neutron_plugins_ovs', 'resources/neutron_plugins_ovs_puppet', {
|
|
'tenant_network_type': 'gre',
|
|
})[0]
|
|
signals.connect(node1, neutron_plugins_ovs)
|
|
signals.connect(neutron_db_user, neutron_plugins_ovs, {
|
|
'user_name':'db_user',
|
|
'db_name':'db_name',
|
|
'user_password':'db_password',
|
|
'db_host' : 'db_host'
|
|
})
|
|
neutron_agents_ovs = vr.create('neutron_agents_ovs', 'resources/neutron_agents_ovs_puppet', {
|
|
# TODO(bogdando) these should come from the node network resource
|
|
'enable_tunneling': True,
|
|
'local_ip': '10.1.0.13' # should be the IP addr of the br-mesh int.
|
|
})[0]
|
|
signals.connect(node1, neutron_agents_ovs)
|
|
|
|
# NEUTRON DHCP, L3, metadata agents
|
|
neutron_agents_dhcp = vr.create('neutron_agents_dhcp', 'resources/neutron_agents_dhcp_puppet', {})[0]
|
|
signals.connect(node1, neutron_agents_dhcp)
|
|
neutron_agents_l3 = vr.create('neutron_agents_l3', 'resources/neutron_agents_l3_puppet', {
|
|
# TODO(bogdando) these should come from the node network resource
|
|
'metadata_port': 8775,
|
|
'external_network_bridge': 'br-floating',
|
|
})[0]
|
|
signals.connect(node1, neutron_agents_l3)
|
|
neutron_agents_metadata = vr.create('neutron_agents_metadata', 'resources/neutron_agents_metadata_puppet', {
|
|
'shared_secret': 'secret',
|
|
})[0]
|
|
signals.connect(node1, neutron_agents_metadata)
|
|
signals.connect(neutron_server_puppet, neutron_agents_metadata, {
|
|
'auth_host', 'auth_port', 'auth_password',
|
|
'auth_tenant', 'auth_user',
|
|
})
|
|
|
|
# NEUTRON FOR COMPUTE (node2)
|
|
# Deploy chain neutron -> (plugins) -> ( agents )
|
|
neutron_puppet2 = vr.create('neutron_puppet2', 'resources/neutron_puppet', {})[0]
|
|
signals.connect(node2, neutron_puppet2)
|
|
signals.connect(neutron_puppet, neutron_puppet2, {
|
|
'rabbit_host', 'rabbit_port',
|
|
'rabbit_user', 'rabbit_password',
|
|
'rabbit_virtual_host',
|
|
'package_ensure', 'core_plugin',
|
|
})
|
|
|
|
# NEUTRON OVS PLUGIN & AGENT WITH GRE FOR COMPUTE (node2)
|
|
neutron_plugins_ovs2 = vr.create('neutron_plugins_ovs2', 'resources/neutron_plugins_ovs_puppet', {})[0]
|
|
signals.connect(node2, neutron_plugins_ovs2)
|
|
signals.connect(neutron_plugins_ovs, neutron_plugins_ovs2, {
|
|
'db_host', 'db_name', 'db_password', 'db_user', 'tenant_network_type'
|
|
})
|
|
neutron_agents_ovs2 = vr.create('neutron_agents_ovs2', 'resources/neutron_agents_ovs_puppet', {
|
|
# TODO(bogdando) these should come from the node network resource
|
|
'enable_tunneling': True,
|
|
'local_ip': '10.1.0.14' # Should be the IP addr of the br-mesh int.
|
|
})[0]
|
|
signals.connect(node2, neutron_agents_ovs2)
|
|
|
|
# CINDER
|
|
cinder_puppet = vr.create('cinder_puppet', 'resources/cinder_puppet', {})[0]
|
|
cinder_db = vr.create('cinder_db', 'resources/mariadb_db/', {
|
|
'db_name': 'cinder_db', 'login_user': 'root'})[0]
|
|
cinder_db_user = vr.create('cinder_db_user', 'resources/mariadb_user/', {
|
|
'user_name': 'cinder', 'user_password': 'cinder', 'login_user': 'root'})[0]
|
|
cinder_keystone_user = vr.create('cinder_keystone_user', 'resources/keystone_user', {
|
|
'user_name': 'cinder', 'user_password': 'cinder'})[0]
|
|
cinder_keystone_role = vr.create('cinder_keystone_role', 'resources/keystone_role', {
|
|
'role_name': 'admin'})[0]
|
|
cinder_keystone_service_endpoint = vr.create(
|
|
'cinder_keystone_service_endpoint',
|
|
'resources/keystone_service_endpoint', {
|
|
'endpoint_name': 'cinder',
|
|
'adminurl': 'http://{{admin_ip}}:{{admin_port}}/v2/%(tenant_id)s',
|
|
'internalurl': 'http://{{internal_ip}}:{{internal_port}}/v2/%(tenant_id)s',
|
|
'publicurl': 'http://{{public_ip}}:{{public_port}}/v2/%(tenant_id)s',
|
|
'description': 'OpenStack Block Storage Service', 'type': 'volume'})[0]
|
|
|
|
signals.connect(node1, cinder_puppet)
|
|
signals.connect(node1, cinder_db)
|
|
signals.connect(node1, cinder_db_user)
|
|
signals.connect(rabbitmq_service1, cinder_puppet, {'ip': 'rabbit_host', 'port': 'rabbit_port'})
|
|
signals.connect(admin_user, cinder_puppet, {'user_name': 'keystone_user', 'user_password': 'keystone_password', 'tenant_name': 'keystone_tenant'}) #?
|
|
signals.connect(openstack_vhost, cinder_puppet, {'vhost_name': 'rabbit_virtual_host'})
|
|
signals.connect(openstack_rabbitmq_user, cinder_puppet, {'user_name': 'rabbit_userid', 'password': 'rabbit_password'})
|
|
signals.connect(mariadb_service1, cinder_db, {
|
|
'port': 'login_port',
|
|
'root_password': 'login_password',
|
|
'root_user': 'login_user',
|
|
'ip' : 'db_host'})
|
|
signals.connect(mariadb_service1, cinder_db_user, {'port': 'login_port', 'root_password': 'login_password'})
|
|
signals.connect(cinder_db, cinder_db_user, {'db_name', 'db_host'})
|
|
signals.connect(cinder_db_user, cinder_puppet, {
|
|
'user_name':'db_user',
|
|
'db_name':'db_name',
|
|
'user_password':'db_password',
|
|
'db_host' : 'db_host'})
|
|
signals.connect(keystone_puppet, cinder_puppet, {'ip': 'keystone_host', 'admin_port': 'keystone_port'}) #or non admin port?
|
|
signals.connect(services_tenant, cinder_keystone_user)
|
|
signals.connect(cinder_keystone_user, cinder_keystone_role)
|
|
signals.connect(cinder_keystone_user, cinder_puppet, {'user_name': 'keystone_user', 'tenant_name': 'keystone_tenant', 'user_password': 'keystone_password'})
|
|
signals.connect(mariadb_service1, cinder_puppet, {'ip':'ip'})
|
|
signals.connect(cinder_puppet, cinder_keystone_service_endpoint, {
|
|
'ssh_key': 'ssh_key', 'ssh_user': 'ssh_user',
|
|
'ip': ['ip', 'keystone_host', 'admin_ip', 'internal_ip', 'public_ip'],
|
|
'port': ['admin_port', 'internal_port', 'public_port'],})
|
|
signals.connect(keystone_puppet, cinder_keystone_service_endpoint, {
|
|
'admin_port': 'keystone_admin_port', 'admin_token': 'admin_token'})
|
|
|
|
# CINDER GLANCE
|
|
# Deploy chain: cinder_puppet -> cinder_glance -> ( cinder_api, cinder_scheduler, cinder_volume )
|
|
cinder_glance_puppet = vr.create('cinder_glance_puppet', 'resources/cinder_glance_puppet', {})[0]
|
|
signals.connect(node1, cinder_glance_puppet)
|
|
|
|
# CINDER API
|
|
cinder_api_puppet = vr.create('cinder_api_puppet', 'resources/cinder_api_puppet', {})[0]
|
|
signals.connect(node1, cinder_api_puppet)
|
|
signals.connect(cinder_puppet, cinder_api_puppet, {
|
|
'keystone_password', 'keystone_tenant', 'keystone_user'})
|
|
signals.connect(cinder_puppet, cinder_api_puppet, {
|
|
'keystone_host': 'keystone_auth_host',
|
|
'keystone_port': 'keystone_auth_port'})
|
|
|
|
# CINDER SCHEDULER
|
|
cinder_scheduler_puppet = vr.create('cinder_scheduler_puppet', 'resources/cinder_scheduler_puppet', {})[0]
|
|
signals.connect(node1, cinder_scheduler_puppet)
|
|
signals.connect(cinder_puppet, cinder_scheduler_puppet)
|
|
|
|
# CINDER VOLUME
|
|
cinder_volume_puppet = vr.create('cinder_volume_puppet', 'resources/cinder_volume_puppet', {})[0]
|
|
signals.connect(node1, cinder_volume_puppet)
|
|
signals.connect(cinder_puppet, cinder_volume_puppet)
|
|
|
|
# NOVA
|
|
nova_puppet = vr.create('nova_puppet', 'resources/nova_puppet', {})[0]
|
|
nova_db = vr.create('nova_db', 'resources/mariadb_db/', {
|
|
'db_name': 'nova_db',
|
|
'login_user': 'root'})[0]
|
|
nova_db_user = vr.create('nova_db_user', 'resources/mariadb_user/', {
|
|
'user_name': 'nova',
|
|
'user_password': 'nova',
|
|
'login_user': 'root'})[0]
|
|
nova_keystone_user = vr.create('nova_keystone_user', 'resources/keystone_user', {
|
|
'user_name': 'nova',
|
|
'user_password': 'nova'})[0]
|
|
nova_keystone_role = vr.create('nova_keystone_role', 'resources/keystone_role', {
|
|
'role_name': 'admin'})[0]
|
|
nova_keystone_service_endpoint = vr.create('nova_keystone_service_endpoint', 'resources/keystone_service_endpoint', {
|
|
'endpoint_name': 'nova',
|
|
'adminurl': 'http://{{admin_ip}}:{{admin_port}}/v2/%(tenant_id)s',
|
|
'internalurl': 'http://{{internal_ip}}:{{internal_port}}/v2/%(tenant_id)s',
|
|
'publicurl': 'http://{{public_ip}}:{{public_port}}/v2/%(tenant_id)s',
|
|
'description': 'OpenStack Compute Service',
|
|
'type': 'compute'})[0]
|
|
|
|
signals.connect(node1, nova_puppet)
|
|
signals.connect(node1, nova_db)
|
|
signals.connect(node1, nova_db_user)
|
|
signals.connect(mariadb_service1, nova_db, {
|
|
'port': 'login_port',
|
|
'root_password': 'login_password',
|
|
'root_user': 'login_user',
|
|
'ip' : 'db_host'})
|
|
signals.connect(mariadb_service1, nova_db_user, {
|
|
'port': 'login_port',
|
|
'root_password': 'login_password'})
|
|
signals.connect(admin_user, nova_puppet, {'user_name': 'keystone_user', 'user_password': 'keystone_password', 'tenant_name': 'keystone_tenant'}) #?
|
|
signals.connect(openstack_vhost, nova_puppet, {'vhost_name': 'rabbit_virtual_host'})
|
|
signals.connect(nova_db, nova_db_user, {'db_name', 'db_host'})
|
|
signals.connect(services_tenant, nova_keystone_user)
|
|
signals.connect(nova_keystone_user, nova_keystone_role)
|
|
signals.connect(keystone_puppet, nova_puppet, {
|
|
'ip': 'keystone_host',
|
|
'admin_port': 'keystone_port'})
|
|
signals.connect(nova_keystone_user, nova_puppet, {
|
|
'user_name': 'keystone_user',
|
|
'tenant_name': 'keystone_tenant',
|
|
'user_password': 'keystone_password'})
|
|
signals.connect(rabbitmq_service1, nova_puppet, {
|
|
'ip': 'rabbit_host', 'port': 'rabbit_port'})
|
|
signals.connect(openstack_rabbitmq_user, nova_puppet, {
|
|
'user_name': 'rabbit_userid',
|
|
'password': 'rabbit_password'})
|
|
signals.connect(keystone_puppet, nova_keystone_service_endpoint, {
|
|
'ip': 'keystone_host',
|
|
'admin_port': 'keystone_admin_port',
|
|
'admin_token': 'admin_token'})
|
|
signals.connect(mariadb_service1, nova_puppet, {
|
|
'ip':'db_host'})
|
|
signals.connect(nova_db_user, nova_puppet, {
|
|
'user_name':'db_user',
|
|
'db_name':'db_name',
|
|
'user_password':'db_password',
|
|
'db_host' : 'db_host'})
|
|
signals.connect(nova_puppet, nova_keystone_service_endpoint, {
|
|
'ip': ['ip', 'keystone_host', 'public_ip', 'internal_ip', 'admin_ip'],
|
|
'port': ['admin_port', 'internal_port', 'public_port'],
|
|
'ssh_key': 'ssh_key',
|
|
'ssh_user': 'ssh_user'})
|
|
|
|
# NOVA API
|
|
nova_api_puppet = vr.create('nova_api_puppet', 'resources/nova_api_puppet', {})[0]
|
|
signals.connect(node1, nova_api_puppet)
|
|
signals.connect(nova_puppet, nova_api_puppet, {
|
|
'keystone_tenant': 'admin_tenant_name',
|
|
'keystone_user': 'admin_user',
|
|
'keystone_password': 'admin_password',
|
|
'keystone_host': 'auth_host',
|
|
'keystone_port': 'auth_port'})
|
|
signals.connect(nova_api_puppet, neutron_agents_metadata, {'ip': 'metadata_ip'})
|
|
|
|
# NOVA CONDUCTOR
|
|
nova_conductor_puppet = vr.create('nova_conductor_puppet', 'resources/nova_conductor_puppet', {})[0]
|
|
signals.connect(node1, nova_conductor_puppet)
|
|
signals.connect(nova_puppet, nova_conductor_puppet)
|
|
|
|
# NOVA COMPUTE
|
|
# Deploy chain (nova, node_networking(TODO)) -> (nova_compute_libvirt, nova_neutron) -> nova_compute
|
|
nova_compute_puppet = vr.create('nova_compute_puppet', 'resources/nova_compute_puppet', {})[0]
|
|
# TODO (bogdando) figure out how to use it for multiple glance api servers
|
|
nova_puppet2 = vr.create('nova_puppet2', 'resources/nova_puppet', {
|
|
'glance_api_servers': '{{glance_api_servers_host}}:{{glance_api_servers_port}}'
|
|
})[0]
|
|
signals.connect(nova_puppet, nova_puppet2, {
|
|
'ensure_package', 'rabbit_host',
|
|
'rabbit_password', 'rabbit_port', 'rabbit_userid',
|
|
'rabbit_virtual_host', 'db_user', 'db_password',
|
|
'db_name', 'db_host', 'keystone_password',
|
|
'keystone_port', 'keystone_host', 'keystone_tenant',
|
|
'keystone_user',
|
|
})
|
|
# TODO(bogdando): Make a connection for nova_puppet2.glance_api_servers = "glance_api_puppet.ip:glance_api_puppet.bind_port"
|
|
signals.connect(node2, nova_puppet2)
|
|
signals.connect(node2, nova_compute_puppet)
|
|
|
|
# NOVA COMPUTE LIBVIRT, NOVA_NEUTRON
|
|
# NOTE(bogdando): changes nova config, so should notify nova compute service
|
|
nova_compute_libvirt_puppet = vr.create('nova_compute_libvirt_puppet', 'resources/nova_compute_libvirt_puppet', {})[0]
|
|
signals.connect(node2, nova_compute_libvirt_puppet)
|
|
# compute configuration for neutron, use http auth/endpoint protocols, keystone v2 auth hardcoded for the resource
|
|
nova_neutron_puppet = vr.create('nova_neutron_puppet', 'resources/nova_neutron_puppet', {})[0]
|
|
signals.connect(node2, nova_neutron_puppet)
|
|
signals.connect(neutron_server_puppet, nova_neutron_puppet, {
|
|
'auth_password': 'neutron_admin_password',
|
|
'auth_user': 'neutron_admin_username',
|
|
'auth_type': 'neutron_auth_strategy',
|
|
'auth_host': 'auth_host', 'auth_port': 'auth_port',
|
|
'auth_protocol': 'auth_protocol',
|
|
})
|
|
signals.connect(neutron_keystone_service_endpoint, nova_neutron_puppet, {
|
|
'internal_ip':'neutron_endpoint_host',
|
|
'internal_port':'neutron_endpoint_port',
|
|
})
|
|
|
|
# signals.connect(keystone_puppet, nova_network_puppet, {'ip': 'keystone_host', 'port': 'keystone_port'})
|
|
# signals.connect(keystone_puppet, nova_keystone_service_endpoint, {'ip': 'keystone_host', 'admin_port': 'keystone_port', 'admin_token': 'admin_token'})
|
|
# signals.connect(rabbitmq_service1, nova_network_puppet, {'ip': 'rabbitmq_host', 'port': 'rabbitmq_port'})
|
|
|
|
# GLANCE (base and API)
|
|
glance_api_puppet = vr.create('glance_api_puppet', 'resources/glance_puppet', {})[0]
|
|
glance_db_user = vr.create('glance_db_user', 'resources/mariadb_user/', {
|
|
'user_name': 'glance', 'user_password': 'glance', 'login_user': 'root'})[0]
|
|
glance_db = vr.create('glance_db', 'resources/mariadb_db/', {
|
|
'db_name': 'glance', 'login_user': 'root'})[0]
|
|
glance_keystone_user = vr.create('glance_keystone_user', 'resources/keystone_user', {
|
|
'user_name': 'glance', 'user_password': 'glance123'})[0]
|
|
glance_keystone_role = vr.create('glance_keystone_role', 'resources/keystone_role', {
|
|
'role_name': 'admin'})[0]
|
|
glance_keystone_service_endpoint = vr.create(
|
|
'glance_keystone_service_endpoint',
|
|
'resources/keystone_service_endpoint', {
|
|
'endpoint_name': 'glance',
|
|
'adminurl': 'http://{{admin_ip}}:{{admin_port}}',
|
|
'internalurl': 'http://{{internal_ip}}:{{internal_port}}',
|
|
'publicurl': 'http://{{public_ip}}:{{public_port}}',
|
|
'description': 'OpenStack Image Service', 'type': 'volume'})[0]
|
|
|
|
signals.connect(node1, glance_api_puppet)
|
|
signals.connect(node1, glance_db)
|
|
signals.connect(node1, glance_db_user)
|
|
signals.connect(admin_user, glance_api_puppet, {
|
|
'user_name': 'keystone_user', 'user_password': 'keystone_password',
|
|
'tenant_name': 'keystone_tenant'}) #?
|
|
signals.connect(mariadb_service1, glance_db, {
|
|
'port': 'login_port',
|
|
'root_password': 'login_password',
|
|
'root_user': 'login_user',
|
|
'ip' : 'db_host'})
|
|
signals.connect(mariadb_service1, glance_db_user, {'port': 'login_port', 'root_password': 'login_password'})
|
|
signals.connect(glance_db, glance_db_user, {'db_name', 'db_host'})
|
|
signals.connect(glance_db_user, glance_api_puppet, {
|
|
'user_name':'db_user',
|
|
'db_name':'db_name',
|
|
'user_password':'db_password',
|
|
'db_host' : 'db_host'})
|
|
signals.connect(keystone_puppet, glance_api_puppet, {'ip': 'keystone_host', 'admin_port': 'keystone_port'}) #or non admin port?
|
|
signals.connect(services_tenant, glance_keystone_user)
|
|
signals.connect(glance_keystone_user, glance_keystone_role)
|
|
signals.connect(glance_keystone_user, glance_api_puppet, {
|
|
'user_name': 'keystone_user', 'tenant_name': 'keystone_tenant',
|
|
'user_password': 'keystone_password'})
|
|
signals.connect(mariadb_service1, glance_api_puppet, {'ip':'ip'})
|
|
signals.connect(glance_api_puppet, glance_keystone_service_endpoint, {
|
|
'ssh_key': 'ssh_key', 'ssh_user': 'ssh_user',
|
|
'ip': ['ip', 'keystone_host', 'admin_ip', 'internal_ip', 'public_ip'],
|
|
'bind_port': ['admin_port', 'internal_port', 'public_port'],})
|
|
signals.connect(keystone_puppet, glance_keystone_service_endpoint, {
|
|
'admin_port': 'keystone_admin_port', 'admin_token': 'admin_token'})
|
|
|
|
# GLANCE REGISTRY
|
|
glance_registry_puppet = vr.create('glance_registry_puppet', 'resources/glance_registry_puppet', {})[0]
|
|
signals.connect(node1, glance_registry_puppet)
|
|
signals.connect(glance_api_puppet, glance_registry_puppet)
|
|
# API and registry should not listen same ports
|
|
# should not use the same log destination and a pipeline,
|
|
# so disconnect them and restore the defaults
|
|
signals.disconnect_receiver_by_input(glance_registry_puppet, 'bind_port')
|
|
signals.disconnect_receiver_by_input(glance_registry_puppet, 'log_file')
|
|
signals.disconnect_receiver_by_input(glance_registry_puppet, 'pipeline')
|
|
glance_registry_puppet.update({
|
|
'bind_port': 9191,
|
|
'log_file': '/var/log/glance/registry.log',
|
|
'pipeline': 'keystone',
|
|
})
|
|
|
|
# Update glance_api_service for cinder
|
|
signals.connect(glance_api_puppet, cinder_glance_puppet, {
|
|
'ip': 'glance_api_servers_host',
|
|
'bind_port': 'glance_api_servers_port'
|
|
})
|
|
# Update glance_api_service for nova compute
|
|
signals.connect(glance_api_puppet, nova_puppet2, {
|
|
'ip': 'glance_api_servers_host',
|
|
'bind_port': 'glance_api_servers_port'
|
|
})
|
|
|
|
has_errors = False
|
|
for r in locals().values():
|
|
if not isinstance(r, resource.Resource):
|
|
continue
|
|
|
|
print 'Validating {}'.format(r.name)
|
|
errors = validation.validate_resource(r)
|
|
if errors:
|
|
has_errors = True
|
|
print 'ERROR: %s: %s' % (r.name, errors)
|
|
|
|
if has_errors:
|
|
sys.exit(1)
|
|
|
|
|
|
resources_to_run = [
|
|
'rabbitmq_service1',
|
|
'openstack_vhost',
|
|
'openstack_rabbitmq_user',
|
|
|
|
'mariadb_service1',
|
|
|
|
'keystone_db',
|
|
'keystone_db_user',
|
|
'keystone_puppet',
|
|
'openrc_file',
|
|
|
|
'admin_tenant',
|
|
'admin_user',
|
|
'admin_role',
|
|
|
|
'keystone_service_endpoint',
|
|
'services_tenant',
|
|
|
|
'neutron_db',
|
|
'neutron_db_user',
|
|
'neutron_keystone_user',
|
|
'neutron_keystone_role',
|
|
'neutron_puppet',
|
|
'neutron_keystone_service_endpoint',
|
|
'neutron_plugins_ovs',
|
|
'neutron_server_puppet',
|
|
'neutron_agents_ovs',
|
|
'neutron_agents_dhcp',
|
|
'neutron_agents_l3',
|
|
'neutron_agents_metadata',
|
|
|
|
'cinder_db',
|
|
'cinder_db_user',
|
|
'cinder_keystone_user',
|
|
'cinder_keystone_role',
|
|
'cinder_puppet',
|
|
'cinder_keystone_service_endpoint',
|
|
'cinder_glance_puppet',
|
|
'cinder_api_puppet',
|
|
'cinder_scheduler_puppet',
|
|
'cinder_volume_puppet',
|
|
|
|
'nova_db',
|
|
'nova_db_user',
|
|
'nova_keystone_user',
|
|
'nova_keystone_role',
|
|
'nova_puppet',
|
|
'nova_keystone_service_endpoint',
|
|
'nova_api_puppet',
|
|
'nova_conductor_puppet',
|
|
|
|
'glance_db',
|
|
'glance_db_user',
|
|
'glance_keystone_user',
|
|
'glance_keystone_role',
|
|
'glance_keystone_service_endpoint',
|
|
'glance_api_puppet',
|
|
'glance_registry_puppet',
|
|
|
|
'nova_puppet2',
|
|
'nova_compute_libvirt_puppet',
|
|
'nova_neutron_puppet',
|
|
'nova_compute_puppet',
|
|
|
|
'neutron_puppet2',
|
|
'neutron_plugins_ovs2',
|
|
'neutron_agents_ovs2',
|
|
]
|
|
|
|
@click.command()
|
|
def deploy():
|
|
setup_resources()
|
|
|
|
# run
|
|
resources = map(resource.wrap_resource, db.get_list(collection=db.COLLECTIONS.resource))
|
|
resources = {r.name: r for r in resources}
|
|
|
|
for name in resources_to_run:
|
|
try:
|
|
actions.resource_action(resources[name], 'run')
|
|
except errors.SolarError as e:
|
|
print 'WARNING: %s' % str(e)
|
|
raise
|
|
|
|
time.sleep(10)
|
|
|
|
|
|
@click.command()
|
|
def undeploy():
|
|
resources = map(resource.wrap_resource, db.get_list(collection=db.COLLECTIONS.resource))
|
|
resources = {r.name: r for r in resources}
|
|
|
|
for name in reversed(resources_to_run):
|
|
try:
|
|
actions.resource_action(resources[name], 'remove')
|
|
except errors.SolarError as e:
|
|
print 'WARNING: %s' % str(e)
|
|
|
|
db.clear()
|
|
|
|
signals.Connections.clear()
|
|
|
|
|
|
main.add_command(deploy)
|
|
main.add_command(undeploy)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|