def tornado_routes(server):
return [
(
"/v1/ws",
WSHandler,
{
"commander": Commander(store, final_future=server.final_future),
"server_time": time.time(),
"wsconnections": server.wsconnections,
},
),
]
async def setup(self,
server_options,
*,
tasks,
sender,
cleaners,
animation_options=None):
self.sender = sender
self.cleaners = cleaners
self.server_options = server_options
self.animation_options = animation_options
self.tasks = tasks
self.tasks._merged_options_formattable = True
self.database = DB(self.server_options.database.uri)
self.database._merged_options_formattable = True
self.cleaners.append(self.database.finish)
await self.database.start()
self.finder = Finder(sender, final_future=self.final_future)
self.finder._merged_options_formattable = True
self.cleaners.append(self.finder.finish)
self.daemon = DeviceFinderDaemon(sender,
finder=self.finder,
**self.server_options.daemon_options)
self.cleaners.append(self.daemon.finish)
await self.daemon.start()
self.animations = Animations(self.final_future, self.tasks,
self.sender, self.animation_options)
self.animations._merged_options_formattable = True
self.commander = Commander(
self.store,
tasks=self.tasks,
sender=self.sender,
finder=self.finder,
zeroconf=self.server_options.zeroconf,
database=self.database,
animations=self.animations,
final_future=self.final_future,
server_options=self.server_options,
)
async def setup(self, server_options, ts, sender, reference, cleaners):
self.sender = sender
self.cleaners = cleaners
self.server_options = server_options
self.tasks = ts
self.tasks._merged_options_formattable = True
self.arranger = Arranger(self.final_future, self.sender, reference,
server_options.animation_options, cleaners)
self.arranger._merged_options_formattable = True
self.tasks.add(self.arranger.run())
self.commander = Commander(
self.store,
tasks=self.tasks,
arranger=self.arranger,
final_future=self.final_future,
server_options=self.server_options,
)
async def setup(self, server_options, cleaners, target_register,
protocol_register, animation_options):
self.cleaners = cleaners
self.server_options = server_options
self.target_register = target_register
self.protocol_register = protocol_register
test_devices = None
if self.server_options.fake_devices:
from photons_interactor.commander import test_helpers as cthp
from photons_control import test_helpers as chp
runner = chp.MemoryTargetRunner(self.final_future,
cthp.fakery.devices)
target = runner.target
await runner.start()
async def clean_memory_target():
await runner.close()
self.cleaners.append(clean_memory_target)
else:
target = self.target_register.resolve("lan")
self.db_queue = DBQueue(self.final_future, 5, lambda exc: 1,
self.server_options.database.uri)
self.cleaners.append(self.db_queue.finish)
self.db_queue.start()
self.finder = DeviceFinder(target,
**self.server_options.device_finder_options)
self.arranger = ArrangeState()
self.animations = AnimationsStore(
self.server_options.animations_presets, self.arranger,
animation_options)
self.cleaners.append(self.animations.finish)
await self.finder.start()
async def clean_finder():
await self.finder.finish()
self.cleaners.append(clean_finder)
# Make sure to wait for the wsconnections
async def waiter():
self.final_future.cancel()
await wait_for_futures(self.wsconnections)
self.cleaners.append(waiter)
self.commander = Commander(
self.store,
finder=self.finder,
db_queue=self.db_queue,
arranger=self.arranger,
animations=self.animations,
test_devices=test_devices,
final_future=self.final_future,
server_options=self.server_options,
target_register=self.target_register,
protocol_register=self.protocol_register,
)
value = dictobj.Field(sb.string_spec, wrapper=sb.required)
store = store.injected("store")
async def execute(self):
assert not self.request_future.done()
return self, self.value
describe "Commander":
async it "works":
other = mock.Mock(name="other")
progress_cb = mock.Mock(name="progress_cb")
request_handler = mock.Mock(name="request_handler")
commander = Commander(store, other=other)
value = str(uuid.uuid1())
thing, val = await commander.executor(progress_cb, request_handler).execute(
"/v1", {"command": "thing", "args": {"value": value}}
)
assert val == value
assert thing.other is other
assert thing.commander is commander
assert thing.progress_cb is progress_cb
assert thing.request_handler is request_handler
assert thing.path == "/v1"
assert thing.store is store
async def setup(self, tornado_routes, store, wsconnections, server_time):
self.commander = Commander(store)
self.server_time = server_time
self.wsconnections = wsconnections
self._tornado_routes = tornado_routes