def __init__(self, effects):
self.lines = ['#!/bin/bash', 'set -ex']
TypeDispatcher.__init__(
self, {
Run: self.perform_run,
Sudo: perform_sudo,
Put: perform_put,
Comment: self.perform_comment,
Sequence: perform_sequence
})
perform(self, effects)
# Add blank line to terminate script with a newline
self.lines.append('')
self._script = '\n'.join(self.lines)
def perform_tenant_scope(authenticator,
log,
service_configs,
throttler,
dispatcher,
tenant_scope,
box,
_concretize=concretize_service_request):
"""
Perform a :obj:`TenantScope` by performing its :attr:`TenantScope.effect`,
with a dispatcher extended with a performer for :obj:`ServiceRequest`
intents. The performer will use the tenant provided by the
:obj:`TenantScope`.
The first arguments before (dispatcher, tenant_scope, box) are intended
to be partially applied, and the result is a performer that can be put into
a dispatcher.
"""
@sync_performer
def scoped_performer(dispatcher, service_request):
return _concretize(authenticator, log, service_configs, throttler,
tenant_scope.tenant_id, service_request)
new_disp = ComposedDispatcher(
[TypeDispatcher({ServiceRequest: scoped_performer}), dispatcher])
perform(new_disp, tenant_scope.effect.on(box.succeed, box.fail))
def __init__(self, effects):
self.lines = [
'#!/bin/bash',
'set -ex'
]
TypeDispatcher.__init__(self, {
Run: self.perform_run,
Sudo: perform_sudo,
Put: perform_put,
Comment: self.perform_comment,
Sequence: perform_sequence
})
perform(self, effects)
# Add blank line to terminate script with a newline
self.lines.append('')
self._script = '\n'.join(self.lines)
def get_msg_time_dispatcher(reactor):
"""
Return dispatcher with performer of MsgWithTime in it
"""
return TypeDispatcher({
MsgWithTime: partial(perform_msg_time, reactor)
})
def perform_run_remotely(base_dispatcher, intent):
"""
Run a series of commands on a remote host.
"""
dispatcher = ComposedDispatcher([
TypeDispatcher({
Run: perform_run,
Sudo: perform_sudo,
Put: perform_put,
Comment: perform_comment,
}),
base_dispatcher,
])
host_string = "%s@%s" % (intent.username, intent.address)
with settings(
connection_attempts=24,
timeout=5,
pty=False,
host_string=host_string):
sync_perform(dispatcher, intent.commands)
disconnect_all()
def perform_retry_without_delay(actual_retry_intent):
should_retry = actual_retry_intent.should_retry
if isinstance(should_retry, ShouldDelayAndRetry):
def should_retry(exc_info):
exc_type, exc_value, exc_traceback = exc_info
failure = Failure(exc_value, exc_type, exc_traceback)
return Effect(
Constant(
actual_retry_intent.should_retry.can_retry(failure)))
new_retry_effect = Effect(
Retry(effect=actual_retry_intent.effect,
should_retry=should_retry))
_dispatchers = [
TypeDispatcher({Retry: perform_retry}), base_dispatcher
]
if fallback_dispatcher is not None:
_dispatchers.append(fallback_dispatcher)
seq = [(expected_retry_intent.effect.intent, performer)
for performer in performers]
return perform_sequence(seq, new_retry_effect,
ComposedDispatcher(_dispatchers))
def get_ssh_dispatcher(connection, context):
"""
:param Message context: The eliot message context to log.
:param connection: The SSH connection run commands on.
"""
@deferred_performer
def perform_run(dispatcher, intent):
context.bind(
message_type="flocker.provision.ssh:run",
command=intent.log_command_filter(intent.command),
).write()
endpoint = SSHCommandClientEndpoint.existingConnection(
connection, intent.command)
d = Deferred()
connectProtocol(endpoint, CommandProtocol(
deferred=d, context=context))
return d
return TypeDispatcher({
Run: perform_run,
Sudo: perform_sudo,
Put: perform_put,
Comment: perform_comment,
})
def get_dispatcher(self):
"""
Get an :module:`effect` dispatcher for interacting with this
:class:`FakeAWS`.
"""
return TypeDispatcher({
# Share implementation with real implementation
DownloadS3KeyRecursively:
perform_download_s3_key_recursively,
UploadToS3Recursively:
perform_upload_s3_key_recursively,
# Fake implementation
UpdateS3RoutingRule:
self._perform_update_s3_routing_rule,
UpdateS3ErrorPage:
self._perform_update_s3_error_page,
ListS3Keys:
self._perform_list_s3_keys,
DeleteS3Keys:
self._perform_delete_s3_keys,
CopyS3Keys:
self._perform_copy_s3_keys,
DownloadS3Key:
self._perform_download_s3_key,
UploadToS3:
self._perform_upload_s3_key,
CreateCloudFrontInvalidation:
self._perform_create_cloudfront_invalidation,
})
def dispatcher(self):
return ComposedDispatcher([
TypeDispatcher({
PackerConfigure: self.perform_packer_configure,
PackerBuild: self.perform_packer_build,
WriteToS3: self.perform_write_to_s3,
}), base_dispatcher
])
def make_dispatcher(reactor):
return ComposedDispatcher([
TypeDispatcher({
RunRemotely: partial(perform_run_remotely, reactor),
}),
make_twisted_dispatcher(reactor),
base_dispatcher,
])
def dispatcher(self):
return ComposedDispatcher([
TypeDispatcher({
PackerConfigure: self.perform_packer_configure,
PackerBuild: self.perform_packer_build,
StandardOut: self.perform_standard_out,
}), base_dispatcher
])
def test_dispatcher(disp=None):
disps = [
base_dispatcher,
TypeDispatcher({ParallelEffects: perform_parallel_async}),
]
if disp is not None:
disps.append(disp)
return ComposedDispatcher(disps)
def make_asyncio_dispatcher(loop=None):
"""
Create a dispatcher that knows how to perform certain built-in Intents
with asyncio-specific implementations.
"""
return TypeDispatcher({
ParallelEffects: perform_parallel_async,
Delay: perform_delay,
})
def make_dispatcher(reactor):
patch_twisted_7672()
return ComposedDispatcher([
TypeDispatcher({
RunRemotely: perform_run_remotely,
}),
make_twisted_dispatcher(reactor),
base_dispatcher,
])
def get_eviction_dispatcher(supervisor):
"""
Get a dispatcher with :class:`EvictServerFromScalingGroup`'s performer.
:param supervisor: a :class:`otter.supervisor.ISupervisor` provider
"""
return TypeDispatcher({
EvictServerFromScalingGroup:
partial(perform_evict_server, supervisor)
})
def test_delete(self):
model = ZKCrudModel()
eff = Effect(DeleteNode(path='/foo', version=1))
model.create('/foo', 'initial', makepath=True)
model.set('/foo', 'bar')
performer = partial(perform_delete_node, model)
dispatcher = TypeDispatcher({DeleteNode: performer})
result = sync_perform(dispatcher, eff)
self.assertEqual(model.nodes, {})
self.assertEqual(result, 'delete return value')
def make_twisted_dispatcher(reactor):
"""
Create a dispatcher that knows how to perform certain built-in Intents
with Twisted-specific implementations.
"""
return TypeDispatcher({
ParallelEffects:
perform_parallel_async,
Delay:
deferred_performer(partial(perform_delay, reactor)),
})
def get_log_dispatcher(log, fields):
"""
Get dispatcher containing performers for logging intents that
use given logger and are bound with given fields
"""
return TypeDispatcher({
BoundFields: partial(perform_logging, log, fields, bound_log),
Log: partial(perform_logging, log, fields, log_msg),
LogErr: partial(perform_logging, log, fields, log_err),
GetFields: sync_performer(lambda d, i: fields),
})
def dispatcher():
prefetch_dispatcher = TypeDispatcher({
TryPrefetch:
try_prefetch_performer,
CalculateSha256Sum:
sync_performer(lambda _, intent: calculate_sha256_sum(intent)),
GetListRemote:
get_list_remote_performer,
AbortWithErrorMessage:
abort_with_error_message_performer,
})
return ComposedDispatcher([base_dispatcher, prefetch_dispatcher])
def check_and_call():
class DoFunc(object):
pass
@deferred_performer
def func_performer(d, i):
return maybeDeferred(func, *args, **kwargs)
comp_dispatcher = ComposedDispatcher(
[TypeDispatcher({DoFunc: func_performer}), dispatcher])
return perform(comp_dispatcher,
call_if_acquired(lock, Effect(DoFunc())))
def get_cloud_client_dispatcher(reactor, authenticator, log, service_configs):
"""
Get a dispatcher suitable for running :obj:`ServiceRequest` and
:obj:`TenantScope` intents.
"""
# this throttler could be parameterized but for now it's basically a hack
# that we want to keep private to this module
throttler = partial(_default_throttler, WeakLocks(), reactor)
return TypeDispatcher({
TenantScope: partial(perform_tenant_scope, authenticator, log,
service_configs, throttler),
_Throttle: _perform_throttle,
})
def get_dispatcher(self):
"""
Get an :module:`effect` dispatcher for interacting with this
:class:`FakeYum`.
"""
return TypeDispatcher({
# Share implementation with real implementation
DownloadPackagesFromRepository:
perform_download_packages_from_repository,
# Fake implementation
CreateRepo: self._perform_create_repository,
})
def get_dispatcher(self, service_request_mappings):
"""
Set up an empty dictionary of intents to fake responses, and set up
the dispatcher.
"""
eq_dispatcher = EQDispatcher
if callable(service_request_mappings[0][-1]):
eq_dispatcher = EQFDispatcher
return ComposedDispatcher([
TypeDispatcher({ParallelEffects: perform_parallel_async}),
eq_dispatcher(service_request_mappings)
])
def test_perform_throttle(self):
"""
The bracket given to :obj:`_Throttle` is used to call the nested
performer.
"""
def bracket(f, *args, **kwargs):
return f(*args, **kwargs).addCallback(lambda r: ('bracketed', r))
throttle = _Throttle(bracket=bracket, effect=Effect(Constant('foo')))
dispatcher = ComposedDispatcher(
[TypeDispatcher({_Throttle: _perform_throttle}), base_dispatcher])
result = sync_perform(dispatcher, Effect(throttle))
self.assertEqual(result, ('bracketed', 'foo'))
def get_zk_dispatcher(kz_client):
"""Get a dispatcher that can support all of the ZooKeeper intents."""
return TypeDispatcher({
CreateOrSet:
partial(perform_create_or_set, kz_client),
DeleteNode:
partial(perform_delete_node, kz_client),
GetChildrenWithStats:
partial(perform_get_children_with_stats, kz_client),
GetChildren:
partial(perform_get_children, kz_client),
GetStat:
partial(perform_get_stat, kz_client)
})
def get_dispatcher(reactor):
"""
Create a dispatcher that can find performers for :obj:`ReadLine`,
:obj:`HTTPRequest`, and :obj:`ParallelEffects`.
:func:`make_twisted_dispatcher` is able to provide the ``ParallelEffects``
performer, so we compose it with our own custom :obj:`TypeDispatcher`.
"""
return ComposedDispatcher([
TypeDispatcher({
ReadLine: perform_readline_stdin,
HTTPRequest: perform_request_with_treq,
}),
make_twisted_dispatcher(reactor),
])
def test_print(self):
outputs = []
@sync_performer
def perform_print(dispatcher, print_):
outputs.append(print_.line)
test_interpreter = ComposedDispatcher([
TypeDispatcher({
Print: perform_print,
}),
base_dispatcher])
dispatcher = test_interpreter
sync_perform(dispatcher, program())
self.assertEqual(["What... is your quest?"], outputs)
def get_dispatcher():
"""
Create a dispatcher that can find performers for :obj:`ReadLine`,
:obj:`HTTPRequest`, and :obj:`ParallelEffects`. There's a built-in
performer for ParallelEffects that uses a multiprocessing ThreadPool,
:func:`effect.perform_parallel_with_pool`.
"""
my_pool = ThreadPool()
pool_performer = partial(perform_parallel_with_pool, my_pool)
return ComposedDispatcher([
TypeDispatcher({
ReadLine: perform_readline_stdin,
HTTPRequest: perform_request_requests,
ParallelEffects: pool_performer,
})
])
def test_perform_update_servers_cache(self):
"""
Performing :obj:`UpdateServersCache` updates using
CassScalingGroupServersCache
"""
dt = datetime(1970, 1, 1)
eff = Effect(UpdateServersCache('tid', 'gid', dt, [{'id': 'a'}]))
@sync_performer
def perform_update_tuple(disp, intent):
self.assertEqual(intent, ('cacheistidgid', dt, [{'id': 'a'}]))
disp = ComposedDispatcher([
TypeDispatcher({tuple: perform_update_tuple}),
self.get_dispatcher(self.get_store())
])
self.assertIsNone(sync_perform(disp, eff))
def test_event_added(self):
"""
Event is added to cloud feed
"""
class AddEvent(object):
pass
add_event_performer = deferred_performer(
lambda d, i: succeed('performed'))
cf = self.make_cf(add_event=lambda *a: Effect(AddEvent()),
get_disp=lambda *a: TypeDispatcher(
{AddEvent: add_event_performer}))
d = cf({'event': 'dict', 'cloud_feed': True, 'message': ('m', )})
self.assertEqual(self.successResultOf(d), 'performed')
self.assertFalse(self.log.err.called)
def get_dispatcher(self):
"""
Get an :module:`effect` dispatcher for interacting with this
:class:`FaleAWS`.
"""
return TypeDispatcher({
UpdateS3RoutingRule:
self._perform_update_s3_routing_rule,
ListS3Keys:
self._perform_list_s3_keys,
DeleteS3Keys:
self._perform_delete_s3_keys,
CopyS3Keys:
self._perform_copy_s3_keys,
CreateCloudFrontInvalidation:
self._perform_create_cloudfront_invalidation,
})
