def setUp(self):
yield super(MachineAgentTest, self).setUp()
self.output = self.capture_logging(
"juju.agents.machine", level=logging.DEBUG)
config = self.get_test_environment_config()
environment = config.get_default()
# Store the environment to zookeeper
environment_state_manager = EnvironmentStateManager(self.client)
yield environment_state_manager.set_config_state(config, "myfirstenv")
# Load the environment with the charm state and charm binary
self.provider = environment.get_machine_provider()
self.storage = self.provider.get_file_storage()
self.charm = CharmDirectory(self.sample_dir1)
self.publisher = CharmPublisher(self.client, self.storage)
yield self.publisher.add_charm(local_charm_id(self.charm), self.charm)
charm_states = yield self.publisher.publish()
self.charm_state = charm_states[0]
# Create a service from the charm from which we can create units for
# the machine.
self.service_state_manager = ServiceStateManager(self.client)
self.service = yield self.service_state_manager.add_service_state(
"fatality-blog", self.charm_state)
def setUp(self):
yield super(MachineAgentTest, self).setUp()
self.output = self.capture_logging("juju.agents.machine",
level=logging.DEBUG)
config = self.get_test_environment_config()
environment = config.get_default()
# Store the environment to zookeeper
environment_state_manager = EnvironmentStateManager(self.client)
yield environment_state_manager.set_config_state(config, "myfirstenv")
# Load the environment with the charm state and charm binary
self.provider = environment.get_machine_provider()
self.storage = self.provider.get_file_storage()
self.charm = CharmDirectory(self.sample_dir1)
self.publisher = CharmPublisher(self.client, self.storage)
yield self.publisher.add_charm(local_charm_id(self.charm), self.charm)
charm_states = yield self.publisher.publish()
self.charm_state = charm_states[0]
# Create a service from the charm from which we can create units for
# the machine.
self.service_state_manager = ServiceStateManager(self.client)
self.service = yield self.service_state_manager.add_service_state(
"fatality-blog", self.charm_state)
def setUp(self):
yield super(CharmPublisherTestBase, self).setUp()
config = self.get_test_environment_config()
environment = config.get_default()
# Store the environment to zookeeper
environment_state_manager = EnvironmentStateManager(self.client)
yield environment_state_manager.set_config_state(config, "myfirstenv")
# Load the environment
self.provider = environment.get_machine_provider()
self.storage = self.provider.get_file_storage()
def sync_environment_state(client, config, name):
"""Push the local environment config to zookeeper.
This needs to be done:
* On any command which can cause the provisioning agent to take action
against the provider (ie create/destroy a machine), because the PA
needs to use credentials stored in the environment config to do so.
* On any command which uses constraints-related code (even if indirectly)
because Constraints objects are provider-specific, and need to be
created with the help of a MachineProvider; and the only way state code
can get a MachineProvider is by getting one from ZK (we certainly don't
want to thread the relevant provider from juju.control and/or the PA
itself all the way through the state code). So, we sync, to ensure
that state code can use an EnvironmentStateManager to get a provider.
"""
esm = EnvironmentStateManager(client)
return esm.set_config_state(config, name)
def deploy(env_config, environment, repository_path, charm_name,
service_name, log, config_file=None, num_units=1):
"""Deploy a charm within an environment.
This will publish the charm to the environment, creating
a service from the charm, and get it set to be launched
on a new machine.
"""
repo, charm_url = resolve(
charm_name, repository_path, environment.default_series)
# Validate config options prior to deployment attempt
service_options = {}
service_name = service_name or charm_url.name
if config_file:
service_options = parse_config_options(config_file, service_name)
charm = yield repo.find(charm_url)
charm_id = str(charm_url.with_revision(charm.get_revision()))
provider = environment.get_machine_provider()
placement_policy = provider.get_placement_policy()
client = yield provider.connect()
try:
storage = yield provider.get_file_storage()
service_manager = ServiceStateManager(client)
environment_state_manager = EnvironmentStateManager(client)
yield environment_state_manager.set_config_state(
env_config, environment.name)
# Publish the charm to juju
publisher = CharmPublisher(client, storage)
yield publisher.add_charm(charm_id, charm)
result = yield publisher.publish()
# In future we might have multiple charms be published at
# the same time. For now, extract the charm_state from the
# list.
charm_state = result[0]
# Create the service state
service_state = yield service_manager.add_service_state(
service_name, charm_state)
# Use the charm's ConfigOptions instance to validate service
# options.. Invalid options passed will thrown an exception
# and prevent the deploy.
state = yield service_state.get_config()
charm_config = yield charm_state.get_config()
# return the validated options with the defaults included
service_options = charm_config.validate(service_options)
state.update(service_options)
yield state.write()
# Create desired number of service units
for i in xrange(num_units):
unit_state = yield service_state.add_unit_state()
yield place_unit(client, placement_policy, unit_state)
# Check if we have any peer relations to establish
if charm.metadata.peers:
relation_manager = RelationStateManager(client)
for peer_name, peer_info in charm.metadata.peers.items():
yield relation_manager.add_relation_state(
RelationEndpoint(service_name,
peer_info["interface"],
peer_name,
"peer"))
log.info("Charm deployed as service: %r", service_name)
finally:
yield client.close()
def push_config(self, name, config):
self.write_config(yaml.dump(config))
self.config.load()
esm = EnvironmentStateManager(self.client)
return esm.set_config_state(self.config, name)