#!/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
    # TODO: vhost cannot be specified in neutron Puppet manifests so this user has to be admin anyways
    neutron_puppet = vr.create('neutron_puppet', 'resources/neutron_puppet', {})[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_puppet)
    signals.connect(rabbitmq_service1, neutron_puppet, {
        'ip': 'rabbitmq_host',
        'port': 'rabbitmq_port'
    })
    signals.connect(openstack_rabbitmq_user, neutron_puppet, {
        'user_name': 'rabbitmq_user',
        'password': 'rabbitmq_password'})
    signals.connect(openstack_vhost, neutron_puppet, {
        'vhost_name': 'rabbitmq_virtual_host'})
    signals.connect(admin_user, neutron_puppet, {
        'user_name': 'keystone_user',
        'user_password': 'keystone_password',
        'tenant_name': 'keystone_tenant'
    })
    signals.connect(keystone_puppet, neutron_puppet, {
        'ip': 'keystone_host',
        'port': 'keystone_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'],
        'port': ['admin_port', 'internal_port', 'public_port'],
    })

    # 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'})

    # 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)
    nova_neutron_puppet = vr.create('nova_neutron_puppet', 'resources/nova_neutron_puppet', {})[0]
    signals.connect(node2, nova_neutron_puppet)

    # 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_keystone_user',
    'neutron_keystone_role',
    'neutron_puppet',
    'neutron_keystone_service_endpoint',

    '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',

    'nova_puppet2',
    'nova_compute_libvirt_puppet',
    'nova_neutron_puppet',
    'nova_compute_puppet',

    'glance_db',
    'glance_db_user',
    'glance_keystone_user',
    'glance_keystone_role',
    'glance_keystone_service_endpoint',
    'glance_api_puppet',
    'glance_registry_puppet',
]


@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()