def enable_chassis_reactive_code():
charm.use_defaults(
'charm.installed',
'config.changed',
'config.rendered',
'update-status',
'upgrade-charm',
'certificates.available',
)
def initialize_ovsdbs():
with charm.provide_charm_instance() as ovn_charm:
# this will render the ``/etc/default/ovn-central`` file without
# configuration for the cluster remote addresses which in turn
# leads ``ovn-ctl`` on the path to initializing a new cluster
ovn_charm.render_with_interfaces([])
if ovn_charm.enable_services():
# belated enablement of default certificates handler due to the
# ``ovsdb-server`` processes must have finished database
# initialization and be running prior to configuring TLS
charm.use_defaults('certificates.available')
reactive.set_flag('config.rendered')
ovn_charm.assess_status()
#
# 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.
import charms.reactive as reactive
import charms_openstack.charm as charm
# This charm's library contains all of the handler code associated with
# aodh
import charm.openstack.aodh as aodh
charm.use_defaults('certificates.available', )
# Minimal inferfaces required for operation
MINIMAL_INTERFACES = [
'shared-db.available',
'identity-service.available',
'amqp.available',
]
# use a synthetic state to ensure that it get it to be installed independent of
# the install hook.
@reactive.when_not('charm.installed')
def install_packages():
aodh.install()
reactive.set_state('charm.installed')
# https://charmsreactive.readthedocs.io/en/latest/
# https://docs.openstack.org/charm-guide/latest/charm-anatomy.html
import charms_openstack.charm as charm
import charms.reactive as reactive
# This charm's library contains all of the handler code associated with
# this charm -- we will use the auto-discovery feature of charms.openstack
# to get the definitions for the charm.
import charms_openstack.bus as bus
bus.discover()
charm.use_defaults(
'charm.installed',
'update-status',
'upgrade-charm',
#'keystone-backend.connected', ##need to define this on metadata (why do I need this?)
# I don't think I will need this because I'm not implementing an interface
)
@reactive.when('config.changed') #detects any change on config file
@reactive.when_not('keystone-ldap.installed') # not sure about this
def config():
#this will get the instance of the charm that we are deploying
with charm.provide_charm_instance() as keystone_charm:
##calls the method from the created charm
keystone_charm.config_ldap()
reactive.set_flag('config.finished')
import charm.openstack.magnum.magnum as magnum # noqa
import charms.reactive as reactive
import charms.leadership as leadership
import charms_openstack.charm as charm
import charmhelpers.core.hookenv as hookenv
from charmhelpers.contrib.openstack import context
from charmhelpers.core import templating
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults(
'charm.installed',
'amqp.connected',
'shared-db.connected',
'identity-service.available', # enables SSL support
'config.changed',
'update-status',
'upgrade-charm',
'certificates.available',
'cluster.available')
@reactive.when('shared-db.available')
@reactive.when('identity-service.available')
@reactive.when('amqp.available')
@reactive.when_not('is-update-status-hook')
def render_config(*interfaces):
with charm.provide_charm_instance() as magnum_charm:
magnum_charm.render_with_interfaces(interfaces)
magnum_charm.assess_status()
reactive.set_state('config.complete')
# Copyright 2018 Cloudbase Solutions
from __future__ import absolute_import
import charms.reactive as reactive
import charmhelpers.core.hookenv as hookenv
import charms_openstack.charm as charm
import charm.openstack.magnum.magnum as magnum # noqa
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults(
'charm.installed',
'amqp.connected',
'shared-db.connected',
'identity-service.available', # enables SSL support
'config.changed',
'update-status')
@reactive.when('shared-db.available')
@reactive.when('identity-service.available')
@reactive.when('amqp.available')
@reactive.when('trustee-credentials.available')
def render_stuff(*args):
hookenv.log("about to call the render_configs with {}".format(args))
with charm.provide_charm_instance() as magnum_charm:
magnum_charm.render_with_interfaces(charm.optional_interfaces(args))
magnum_charm.assess_status()
reactive.set_state('config.complete')
# 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.
import charms.reactive as reactive
import charms_openstack.bus
import charms_openstack.charm as charm
charms_openstack.bus.discover()
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults('charm.installed', 'config.changed', 'update-status',
'upgrade-charm')
@reactive.when('dashboard.available')
def dashboard_available():
"""Relation to OpenStack Dashboard principal charm complete.
"""
# config and restart is handled by package install, just update our status
with charm.provide_charm_instance() as watcher_dashboard_charm:
watcher_dashboard_charm.assess_status()
import charms_openstack.charm as charm
import charms.reactive as reactive
import charm.openstack.netapp as netapp
assert netapp
charm.use_defaults('charm.installed')
@reactive.when_any('storage-backend.joined', 'storage-backend.changed')
@reactive.when_not('storage-backend.available')
def storage_backend():
with charm.provide_charm_instance() as charm_class:
charm_class.set_relation_data()
reactive.set_state('storage-backend.available')
@reactive.when('config.changed')
def update_config():
reactive.remove_state('storage-backend.available')
with charm.provide_charm_instance() as charm_class:
charm_class.set_relation_data()
reactive.set_state('storage-backend.available')
import charm.openstack.designate as designate
COMPLETE_INTERFACE_STATES = [
'dns-backend.available',
'shared-db.available',
'identity-service.available',
'amqp.available',
]
# wire in defaults for various interfaces and default states
openstack_charm.use_defaults(
'charm.installed',
'amqp.connected',
'shared-db.connected',
'identity-service.connected',
'identity-service.available', # Enables the SSL handler
'config.changed',
'update-status')
@reactive.when_not('base-config.rendered')
@reactive.when(*COMPLETE_INTERFACE_STATES)
@openstack_charm.optional_interface('cluster.available')
@openstack_charm.provide_charm_instance
def configure_designate_basic(designate_charm, *args):
"""Configure the minimum to boostrap designate"""
designate_charm.render_base_config(args)
reactive.set_state('base-config.rendered')
def enable_default_certificates():
# belated enablement of default certificates handler due to the
# ``ovsdb-server`` processes must have finished database
# initialization and be running prior to configuring TLS
charm.use_defaults('certificates.available')
# 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.
import charms.reactive as reactive
from charms_openstack.charm import (
provide_charm_instance,
use_defaults,
)
import charm.openstack.infoblox as infoblox # noqa
use_defaults('update-status')
@reactive.when_not('infoblox.installed')
def install_infoblox():
with provide_charm_instance() as charm_class:
charm_class.install()
reactive.set_state('infoblox.installed')
@reactive.hook('config-changed')
def config_changed():
reactive.remove_state('neutron.configured')
reactive.remove_state('designate.configured')
# See the License for the specific language governing permissions and
# limitations under the License.
import charms_openstack.charm as charm
import charms.reactive as reactive
# This charm's library contains all of the handler code associated with
# dmapi
import charm.openstack.dmapi as dmapi # noqa
charm.use_defaults(
"charm.installed",
"amqp.connected",
"shared-db.connected",
"identity-service.connected",
"identity-service.available", # enables SSL support
"config.changed",
"update-status",
"certificates.available",
"cluster.available",
)
@reactive.when("shared-db.available")
@reactive.when("identity-service.available")
@reactive.when("amqp.available")
def render_config(*args):
"""Render the configuration for charm when all the interfaces are
available.
"""
with charm.provide_charm_instance() as charm_class:
#
# 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.
import charms.reactive as reactive
import charms_openstack.bus
import charms_openstack.charm as charm
charms_openstack.bus.discover()
charm.use_defaults(
'config.changed',
'update-status')
@reactive.when_not('charm.installed')
def check_snap_installed():
# Installation is handled by the ``snap`` layer, just update our status.
with charm.provide_charm_instance() as instance:
instance.assess_status()
reactive.set_flag('charm.installed')
@reactive.when('identity-credentials.connected')
@reactive.when_not('identity-credentials.available')
def request_credentials():
keystone_endpoint = reactive.endpoint_from_flag(
# 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.
import charms_openstack.charm as charm
# This charm's library contains all of the handler code associated with
# trilio_horizon_plugin
import charm.openstack.trilio_horizon_plugin as trilio_horizon_plugin # noqa
charm.use_defaults("charm.installed", "config.changed", "update-status")
# limitations under the License.
import charmhelpers.core as ch_core
import charms.reactive as reactive
import charms_openstack.bus
import charms_openstack.charm as charm
charms_openstack.bus.discover()
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults(
'charm.installed',
'config.changed',
'charm.default-select-release',
'update-status',
'upgrade-charm',
'certificates.available',
)
@reactive.when_none('neutron-plugin.db_migration', 'neutron-plugin.available')
@reactive.when('charm.installed')
def maybe_flag_db_migration():
with charm.provide_charm_instance() as instance:
if instance.db_migration_needed:
reactive.set_flag('neutron-plugin.db_migration')
@reactive.when_none('neutron-plugin.available', 'run-default-update-status')
@reactive.when('neutron-plugin.connected')
import charms.reactive as reactive
import charmhelpers.core.hookenv as hookenv
import charms_openstack.charm as charm
# This charm's library contains all of the handler code associated with
# barbican -- we need to import it to get the definitions for the charm.
import charm.openstack.barbican as barbican # noqa
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults(
'charm.installed',
'amqp.connected',
'shared-db.connected',
'identity-service.connected',
'identity-service.available', # enables SSL support
'config.changed',
'update-status')
# Note that because of the way reactive.when works, (which is to 'find' the
# __code__ segment of the decorated function, it's very, very difficult to add
# other kinds of decorators here. This rules out adding other things into the
# charm args list. It is also CPython dependent.
@reactive.when('shared-db.available')
@reactive.when('identity-service.available')
@reactive.when('amqp.available')
def render_stuff(*args):
"""Render the configuration for Barbican when all the interfaces are
available.
import charmhelpers.core.hookenv as hookenv
import charmhelpers.core.host as host
import charms.reactive.relations as relations
from charmhelpers.contrib.network import ip as ch_ip
DESIGNATE_DIR = '/etc/designate'
DESIGNATE_DEFAULT = '/etc/default/openstack'
DESIGNATE_CONF = DESIGNATE_DIR + '/designate.conf'
POOLS_YAML = DESIGNATE_DIR + '/pools.yaml'
RNDC_KEY_CONF = DESIGNATE_DIR + '/rndc.key'
NOVA_SINK_FILE = DESIGNATE_DIR + '/conf.d/nova_sink.cfg'
NEUTRON_SINK_FILE = DESIGNATE_DIR + '/conf.d/neutron_sink.cfg'
RC_FILE = '/root/novarc'
openstack_charm.use_defaults(
'charm.default-select-release',
'upgrade-charm',
)
class DesignateDBAdapter(openstack_adapters.DatabaseRelationAdapter):
"""Get database URIs for the two designate databases"""
@property
def designate_uri(self):
"""URI for designate DB"""
return self.get_uri(prefix='designate')
@property
def designate_pool_uri(self):
"""URI for designate pool DB"""
return self.get_uri(prefix='dpm')
import os
import charms_openstack.charm as ldap_charm
import charmhelpers.core.hookenv as ch_hookenv # noqa
#https://github.com/juju-solutions/charms.templating.jinja2
from charms.templating.jinja2 import render
#https://charm-helpers.readthedocs.io/en/latest/examples/config.html
hooks = ch_hookenv.Hooks()
ldap_charm.use_defaults('charm.default-select-release')
LDAP_CONFIG_FILE_DIR = "/etc/keystone/domains/"
LDAP_CONFIG_FILE = LDAP_CONFIG_FILE_DIR + "keystone.{}.conf"
TEMPLATE = "keystone_ldap.j2"
class CharmKeystoneLDAP():
name = 'keystone ldap configuration'
version = 'v0.0.1'
def config_ldap(self):
"""
Define the destination LDAP server in the /etc/keystone/keystone.conf or
/etc/keystone/domains/keystone.DOMAIN_NAME.conf :
[ldap]
url = ldap://localhost
user = dc=Manager,dc=example,dc=org
password = samplepassword
suffix = dc=example,dc=org
"""
# limitations under the License.
import charms.reactive as reactive
from charmhelpers.core.hookenv import (
config,
log,
)
from charms_openstack.charm import (
provide_charm_instance,
use_defaults,
)
use_defaults(
'charm.default-select-release',
'update-status',
)
@reactive.when_not('arista-package.installed')
@reactive.when('neutron-plugin-api-subordinate.available')
def install_arista():
with provide_charm_instance() as charm_class:
charm_class.install()
reactive.set_state('arista-package.installed')
@reactive.when_any('config.changed.eapi-host', 'config.changed.eapi-username',
'config.changed.eapi-password',
'config.changed.region-name', 'config.changed.api-type',
'neutron-plugin-api-subordinate.connected')
# limitations under the License.
# this is just for the reactive handlers and calls into the charm.
from __future__ import absolute_import
import charms.reactive as reactive
import charms_openstack.charm as charm
# This charm's library contains all of the handler code associated with trove
import charm.openstack.trove as trove
charm.use_defaults(
'config.changed',
'amqp.connected',
'identity-service.available',
'charm.installed',
'upgrade-charm',
'update-status',
'shared-db.connected',
)
# this is to check if ha is running
@reactive.when('ha.connected')
def cluster_connected(hacluster):
trove.configure_ha_resources(hacluster)
@reactive.when('identity-service.connected')
def setup_endpoint(keystone):
trove.setup_endpoint(keystone)
# 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.
import charms_openstack.charm as charm
import charms.reactive as reactive
# This charm's library contains all of the handler code associated with
# sdn_charm
import charm.openstack.group_based_policy as group_based_policy # noqa
charm.use_defaults('charm.installed', 'update-status')
@reactive.when('neutron-plugin.connected')
def configure_neutron_plugin(neutron_plugin):
with charm.provide_charm_instance() as charm_class:
neutron_plugin.configure_plugin(
plugin='group-based-policy',
config={
"neutron-api": {
"/etc/neutron/neutron.conf": {
"sections": {
'DEFAULT': [
('service_plugins',
'router,firewall,lbaas,vpnaas,metering,group_policy,servicechain'
),
import charms.reactive as reactive
import charms.leadership as leadership
import charms_openstack.bus
import charms_openstack.charm as charm
import charmhelpers.core as ch_core
import charmhelpers.contrib.openstack.cert_utils as cert_utils
import charms.coordinator as coordinator
import charm.openstack.mysql_innodb_cluster as mysql_innodb_cluster # noqa
charms_openstack.bus.discover()
charm.use_defaults('update-status')
@reactive.hook('upgrade-charm')
def custom_upgrade_charm():
"""Custom upgrade charm.
Fix old style dotted flag names during upgrade-charm hook
"""
with charm.provide_charm_instance() as instance:
if reactive.is_flag_set('leadership.is_leader'):
# Change leadership cluster flags with dots in their names
instance.update_dotted_flags()
instance.upgrade_charm()
instance.assess_status()
# See the License for the specific language governing permissions and
# limitations under the License.
# import to trigger openstack charm metaclass init
import charm.openstack.keystone_ldap # noqa
import charms_openstack.charm as charm
import charms.reactive as reactive
import charms.reactive.flags as flags
import charmhelpers.core.hookenv as hookenv
charm.use_defaults(
'charm.installed',
'update-status',
'upgrade-charm',
)
# if config has been changed we need to re-evaluate flags
# config.changed is set and cleared (atexit) in layer-basic
flags.register_trigger(when='config.changed',
clear_flag='config.rendered')
flags.register_trigger(when='config.changed',
clear_flag='config.complete')
@reactive.when('domain-backend.connected')
@reactive.when_not('domain-name-configured')
@reactive.when('config.complete')
def configure_domain_name(domain):
import charmhelpers.core.hookenv as hookenv
import charmhelpers.core.host as host
import charms.reactive.relations as relations
from charmhelpers.contrib.network import ip as ch_ip
DESIGNATE_DIR = '/etc/designate'
DESIGNATE_DEFAULT = '/etc/default/openstack'
DESIGNATE_CONF = DESIGNATE_DIR + '/designate.conf'
POOLS_YAML = DESIGNATE_DIR + '/pools.yaml'
RNDC_KEY_CONF = DESIGNATE_DIR + '/rndc.key'
NOVA_SINK_FILE = DESIGNATE_DIR + '/conf.d/nova_sink.cfg'
NEUTRON_SINK_FILE = DESIGNATE_DIR + '/conf.d/neutron_sink.cfg'
RC_FILE = '/root/novarc'
openstack_charm.use_defaults(
'charm.default-select-release',
'upgrade-charm',
)
class DesignateDBAdapter(openstack_adapters.DatabaseRelationAdapter):
"""Get database URIs for the two designate databases"""
@property
def designate_uri(self):
"""URI for designate DB"""
return self.get_uri(prefix='designate')
@property
def designate_pool_uri(self):
"""URI for designate pool DB"""
return self.get_uri(prefix='dpm')
# limitations under the License.
# this is just for the reactive handlers and calls into the charm.
from __future__ import absolute_import
import charms.reactive as reactive
import charmhelpers.core.hookenv as hookenv
import charms_openstack.charm as charm
# This charm's library contains all of the handler code associated with
# dragent -- we need to import it to get the definitions for the charm.
import charm.openstack.dragent as dragent # noqa
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults('charm.installed', 'amqp.connected', 'config.changed',
'update-status')
@reactive.when('charm.installed')
def debug():
if not hookenv.config('debug'):
return
for key, value in reactive.get_states().items():
print(key, value)
# Use for testing with the quagga charm
@reactive.when('endpoint.bgp-speaker.joined')
def publish_bgp_info(endpoint):
endpoint.publish_info(asn=hookenv.config('asn'), passive=True)
# 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.
import charms_openstack.charm as charm
import charms.reactive as reactive
# This charm's library contains all of the handler code associated with
# trilio_dm
import charm.openstack.trilio_dm as trilio_dm # noqa
charm.use_defaults(
"charm.installed",
"config.changed",
"update-status",
"shared-db.connected",
)
@reactive.when("shared-db.available")
@reactive.when("amqp.available")
def render_config(*args):
"""Render the configuration for charm when all the interfaces are
available.
"""
ceph = reactive.endpoint_from_flag("ceph.available")
if ceph:
args = (ceph, ) + args
with charm.provide_charm_instance() as charm_instance:
charm_instance.render_with_interfaces(args)
import charms_openstack.charm as charm
import charms.reactive as reactive
import boto3
import botocore
import charm.openstack.gnocchi as gnocchi # noqa
import charmhelpers.core.hookenv as hookenv
charm.use_defaults(
'charm.installed',
'shared-db.connected',
'identity-service.connected',
'config.changed',
'config.rendered',
'update-status',
'certificates.available',
'cluster.available',
)
required_interfaces = [
'coordinator-memcached.available', 'shared-db.available',
'identity-service.available'
]
if hookenv.config('storage-backend').lower() == 'ceph':
required_interfaces.append('storage-ceph.pools.available')
storage_config = [
'config.changed.storage-backend', 'config.changed.s3-endpoint-url',
import charms_openstack.adapters as openstack_adapters
import charms_openstack.charm as openstack_charm
import charms_openstack.ip as os_ip
from charmhelpers.contrib.openstack.utils import config_flags_parser
from charmhelpers.core.hookenv import (
config,
log,
WARNING
)
WATCHER_CONF = '/etc/watcher/watcher.conf'
WATCHER_WSGI_CONF = '/etc/apache2/sites-available/watcher-api.conf'
openstack_charm.use_defaults('charm.default-select-release')
@openstack_adapters.config_property
def planner_weights(cls):
conf = config('planner')
if conf in ['weight', 'workload_stabilization']:
conf = config_flags_parser(config('planner-config'))
weights = conf.get('weights', None)
if not weights:
log('Provided planner-config dictionary does not contain key '
'weights - ignoring', level=WARNING)
else:
return weights
import charms.reactive as reactive
import charms.leadership as leadership
import charms_openstack.bus
import charms_openstack.charm as charm
import charmhelpers.core as ch_core
import charm.mysql_innodb_cluster as mysql_innodb_cluster # noqa
charms_openstack.bus.discover()
charm.use_defaults(
'config.changed',
'update-status',
'upgrade-charm',
'certificates.available')
@reactive.when('leadership.is_leader')
@reactive.when('snap.installed.mysql-shell')
@reactive.when_not('charm.installed')
def leader_install():
"""Leader install.
Set passwords and install MySQL packages.
"""
with charm.provide_charm_instance() as instance:
instance.install()
reactive.set_flag("charm.installed")
from charms.reactive.flags import (
set_flag,
)
# This charm's library contains all of the handler code associated with
# nova_cell_controller -- we need to import it to get the definitions for the
# charm.
import charm.openstack.nova_cell_controller as nova_cell_controller # noqa
# Use the charms.openstack defaults for common states and hooks
charm.use_defaults(
'charm.installed',
'amqp.connected',
'shared-db.connected',
'config.changed',
'cluster.available',
'update-status')
@reactive.when('identity-credentials.connected')
def request_credentials():
keystone_relation = endpoint_from_flag(
'identity-credentials.connected')
keystone_relation.request_credentials(
'nova-cell-controller',
project='services')
# Note that because of the way reactive.when works, (which is to 'find' the
