class _Recognizer:
def __init__(self, index: int, callback: Callable[[Sound, int], None]):
self._logger = create_logger(f"Recognizer{index}")
self._barrier = Barrier(2)
self._index = index
self._callback = callback
self._stop = False
Thread(target=self._run).start()
def _run(self):
self._dejavu = Dejavu(dburl=f"sqlite:///bells{self._index}.sqlite")
while not self._stop:
self._barrier.wait()
self._recognize()
def recognize(self):
self._barrier.wait()
def _recognize(self):
song = self._dejavu.recognize(MicrophoneRecognizer,
seconds=_listen_seconds,
channels=1)
if song:
sound = Sound(song['song_id'])
confidence = song['confidence']
self._callback(sound, confidence)
def close(self):
self._stop = True
self._barrier.abort()
def __init__(self):
self.loop = None
self.condition = Condition()
barrier = Barrier(2)
self.thread = Thread(daemon=True, target=lambda: self._loop(barrier))
self.thread.start()
barrier.wait()
def worker(bar:Barrier):
logging.info("I am working-Number of waiting: {}".format(bar.n_waiting)) # numbers of threads stuck at barrier: once it;s 3, it will start
try:
bar.wait() # if timeout, barrier will abort and broken
except threading.BrokenBarrierError:
logging.info('Broken Error')
logging.info("Job done - Number of waiting: {}".format(bar.n_waiting))
def wrapper(self, *args, **kw):
"""Wraps instance method to be called on loop thread"""
# Just return when already on the event thread
if self.thread.ident == get_ident():
return func(self, *args, **kw)
barrier = Barrier(2)
result = None
ex = None
def call():
"""Calls function on loop thread"""
nonlocal result, ex
try:
result = func(self, *args, **kw)
except Exception as exc:
ex = exc
finally:
barrier.wait()
self.loop.call_soon_threadsafe(call)
barrier.wait()
if ex:
raise ex or Exception("Unknown error")
return result
def simulate_policy(self):
simulators = []
barrier = Barrier(self.n_threads + 1)
for i in range(self.n_threads):
executor = PolicyExecutor(self.initial_port + i, self.n_episodes,
barrier, self.dtmc_generator.policy)
simulators.append(executor)
executor.start()
barrier.wait()
counters = {
'goal': 0,
'far': 0,
'fallen': 0,
'collided': 0,
'unknown': 0
}
for sim in simulators:
self._add_to_t_table(sim.t_table)
# self._add_to_t_table(sim.t_table)
print(sim.counters)
for key, value in sim.counters.items():
counters[key] += value
self.logger.info('Simulation values: {}'.format(counters))
self.dtmc_generator.trans_prob_dict = self.dtmc_generator.compute_transition_probabilities_dict(
self.transition_counters)
self.t_table.save('data/repair/t-table-{}.pkl'.format(self.itr))
subprocess.Popen('pkill vrep', shell=True)
return counters
def setUp(self) -> None:
super(TestSuiteRuntimeServer, self).setUp()
self.scheduler.ws_data_mgr = DataStoreMgr(self.scheduler)
for name in self.scheduler.config.taskdefs:
task_proxy = create_task_proxy(task_name=name,
suite_config=self.suite_config,
is_startup=True)
warnings = self.task_pool.insert_tasks(items=[task_proxy.identity],
stopcp=None,
no_check=False)
assert 0 == warnings
self.task_pool.release_runahead_tasks()
self.scheduler.ws_data_mgr.initiate_data_model()
self.workflow_id = self.scheduler.ws_data_mgr.workflow_id
create_auth_files(self.suite_name) # auth keys are required for comms
barrier = Barrier(2, timeout=10)
self.server = SuiteRuntimeServer(self.scheduler,
context=SERVER_CONTEXT,
threaded=True,
barrier=barrier,
daemon=True)
self.server.public_priv = Priv.CONTROL
self.server.start(*PORT_RANGE)
# barrier.wait() doesn't seem to work properly here
# so this workaround will do
while barrier.n_waiting < 1:
sleep(0.2)
barrier.wait()
sleep(0.5)
def test_connection_acceptance(self):
"""Verify that when at attempt is made to connect to a session bridge it is accepted.
This test has to perform some ear-wiggling and hop-dart behaviour to
make sure it waits until the event loop has called the accept() method
before it tries to check to see if the accept() method has been called
(hence the thread barrier). Also, because the real socket accept
operation does not get performed, the mock accept() call can be
executed several times by the server before we get around to actually
checking up on it and we only care that it's called at least once, hence
the 'called_once' flag.
"""
barrier = Barrier(2, timeout=0.5)
called_once = False
real_session_address = launcher.translate_to_real_address(self._fake_session_socket)
def fake_accept(*args, called_once=called_once):
if not called_once:
called_once = True
barrier.wait()
sock = socket(AF_UNIX, SOCK_STREAM)
return (sock, 'xyzzy')
with patch('libertine.launcher.session.socket.accept', side_effect=fake_accept) as mock_accept:
with SessionEventLoopRunning(self._session):
sock = socket(AF_UNIX, SOCK_STREAM)
sock.connect(real_session_address)
with suppress(BrokenBarrierError):
barrier.wait()
self.assertThat(mock_accept.called, Equals(True), "accept() not called")
class OAuthHttpServer(HTTPServer):
"""Utility base class for coordinating between handlers and the CLI"""
def __init__(
self,
server_address: Tuple[str, int],
request_handler_class: Callable[..., BaseRequestHandler],
on_request_cb: Callable[[BaseRequestHandler], None] | None,
):
super().__init__(server_address, request_handler_class)
self._on_request_cb = on_request_cb
self.error_result = None
self.success_result = None
timeout_seconds = REQUEST_TIMEOUT.total_seconds()
self._request_started_barrier = Barrier(2, timeout=timeout_seconds)
self._request_finished_barrier = Barrier(2, timeout=timeout_seconds)
def wait_for_request_started(self):
self._request_started_barrier.wait()
def wait_for_request_finished(self):
self._request_finished_barrier.wait()
def on_request(self, handler: BaseRequestHandler):
if self._on_request_cb:
self._on_request_cb(handler)
def finish_with_error(self, error_result: str):
self.error_result = error_result
def finish_with_success(self, success_result: str):
self.success_result = success_result
def wrapper(self, *args, **kw):
"""Wraps instance method to be called on loop thread"""
# Just return when already on the event thread
if self.thread.ident == get_ident():
return func(self, *args, **kw)
barrier = Barrier(2)
result = None
ex = None
def call():
"""Calls function on loop thread"""
nonlocal result, ex
try:
result = func(self, *args, **kw)
except Exception as exc:
ex = exc
finally:
barrier.wait()
self.loop.call_soon_threadsafe(call)
barrier.wait()
if ex:
raise ex or Exception("Unknown error")
return result
def count_down(cnt: int, b: threading.Barrier):
b.wait()
t = time.time()
while cnt > 0:
cnt -= 1
delta = time.time() - t
print(f"time taken {delta}")
def isql_job(act: Action, b: Barrier, lock: Lock, result_list: List[str]):
dml_script = """
set bail on;
set list on;
set term ^;
execute block returns(ins_progress int) as
declare n int = 100000;
begin
ins_progress=0;
while (n > 0) do
begin
insert into test(s) values(rpad('', 500, uuid_to_char(gen_uuid())));
ins_progress = ins_progress + 1;
if (mod(ins_progress, 100) = 0) then suspend;
n = n - 1;
end
end
^ set term ;^
quit;
"""
b.wait()
result: CompletedProcess = run([
act.vars['isql'], '-user', act.db.user, '-password', act.db.password,
act.db.dsn
],
input=dml_script,
encoding='utf8',
stdout=PIPE,
stderr=STDOUT)
with lock:
result_list.append(result.stdout)
def __init__(self):
self.loop = None
self.condition = Condition()
barrier = Barrier(2)
self.awaken = Awakener(self.condition)
self.thread = Thread(daemon=True, target=lambda: self._loop(barrier))
self.thread.start()
barrier.wait()
class ThreadedProcessor:
def __init__(self, processor, scale):
self.processor = processor
self.scale = scale
self.iqueue = janus.Queue(maxsize=self.scale)
self.oqueue = janus.Queue(maxsize=self.scale)
self.barrier = Barrier(self.scale)
async def __call__(self, messages):
async for channel, message in self.run_threads(messages):
yield channel, message
async def run_threads(self, messages):
asyncio.ensure_future(self.thread_feeder(messages))
self.threads = dict(
(i, Thread(target=self.thread_consumer, args=(i, )).start())
for i in range(self.scale))
queue_iter = aiter(self.oqueue.async_q.get, (None, pipe.EOT))
async for channel, message in queue_iter:
self.oqueue.async_q.task_done()
yield channel, message
# Empty queue of threads' EOTs
for i in range(self.scale):
if i: # skip the one already consumed by aiter above
await self.oqueue.async_q.get()
self.oqueue.async_q.task_done()
# print(f'thread {i} EOT received back')
while self.threads: # FIXME: join threads instead, and move or retire del self.threads[]
asyncio.sleep(
0.1
) # ... while at it, catch exceptions and clean up queue with task_done # noqa: E501
# print(f'all threads stopped')
async def thread_feeder(self, messages):
async for (channel, message) in messages:
# TODO: recreate dead threads, report thread failures
await self.iqueue.async_q.put((channel, message))
for i in range(self.scale):
await self.iqueue.async_q.put((None, pipe.EOT))
# print(f'thread {i} EOT sent')
def thread_consumer(self, threadnum): # runs in thread
# print(f'thread {threadnum} started')
queue_iter = iter(self.iqueue.sync_q.get, (None, pipe.EOT))
for channel, message in self.processor(queue_iter):
self.iqueue.sync_q.task_done()
self.oqueue.sync_q.put((channel, message))
# print(f'thread {threadnum} EOT received')
self.iqueue.sync_q.task_done(
) # for EOT which does not make it past queue iterator
# print(f'thread {threadnum} task done')
self.barrier.wait()
self.oqueue.sync_q.put(
(None, pipe.EOT)) # TODO: use threading.Event to send just one
# print(f'thread {threadnum} EOT sent back')
del self.threads[threadnum]
class Boat():
def __init__(self, cap):
self.cap = cap
self._mutex = Lock() # mutex
self._serfqueue = Semaphore(4) # fila de serfs
self._hackerqueue = Semaphore(4) # fila de hackers
self._barrier = Barrier(4) # barreira
self._n_hackers = 0 # numero de hackers
self._n_serfs = 0 # numero de serfs
self._is_captain = False
def wait_hacker(self):
self._hackerqueue.acquire()
def wait_serf(self):
self._serfqueue.acquire()
def release_hacker(self):
self._hackerqueue.release()
def release_serf(self):
self._serfqueue.release()
def signal_barrier(self):
self._barrier.wait()
def wait_mutex(self):
self._mutex.acquire()
def release_mutex(self):
self._mutex.release()
def status_captain(self, estado):
self._is_captain = estado
def get_total(self):
return self._n_hackers + self._n_serfs
def get_n_serfs(self):
return self._n_serfs
def increment_serfs(self):
self._n_serfs += 1
def decrement_serfs(self):
self._n_serfs -= 1
def get_n_hackers(self):
return self._n_hackers
def increment_hackers(self):
self._n_hackers += 1
def decrement_hackers(self):
self._n_hackers -= 1
def print_boat_fleet(self):
print('h:', self.get_n_hackers(), ', s:', self.get_n_serfs())
def manage_data_t(b: threading.Barrier):
app_ = new_app()
name = threading.currentThread().getName()
b.wait()
t = time.time()
result = app_.send_task('tasks.data', args=())
data = result.get()
t2 = time.time()
delta = t2 - t
logging.info(f'{name} The Overall time taken is {delta}')
def test_serverFiveOrLessClient(self):
global sharedListData
# Create stop event
stopEvent = Event()
# Create server barrier
sBarrier = Barrier(2)
# Create server
bs = BufferServer(13001, 5, stopEvent, sBarrier, 5, 5, "http://localhost:8000", "quiltro", "perroCallejero")
streamingList = ObjectList()
streamingList.append(Streaming(randomStreaming(1)))
bs.communicator.service.postStreamings(streamingList)
searchList = ObjectList()
searchList.append(Search(randomSearch(1)))
bs.communicator.service.postSearches(searchList)
bs.start()
# Create barrier for N clients
randomClients = randomInteger(3) + 2
cBarrier = Barrier(randomClients + 1)
# Create N clients
for i in range(0, randomClients):
thread.start_new_thread(oneThread, (cBarrier, fakeClient,
bs.getHostName(), 13001, ))
cBarrier.wait()
time.sleep(5)
# stop server
stopEvent.set()
# Wait for server
sBarrier.wait()
time.sleep(5)
# Get data and compare
numberTweets = len(bs.globalBuffer.localBuffer.tweetList.list)
numberUsers = len(bs.globalBuffer.localBuffer.userList.list)
numberTweetStreaming = len(bs.globalBuffer.localBuffer.tweetStreamingList.list)
numberTweetSearch = len(bs.globalBuffer.localBuffer.tweetSearchList.list)
self.assertEqual(numberTweets, 0)
self.assertEqual(numberUsers, 0)
self.assertEqual(numberTweetStreaming, 0)
self.assertEqual(numberTweetSearch, 0)
# count originals
originalNumberTweets = 0
originalNumberUsers = 0
originalNumberTweetStreaming = 0
originalNumberTweetSearch = 0
lb = LocalBuffer()
for i in range(0, randomClients):
lb = countData(lb, sharedListData[i*4 + 0], sharedListData[i*4 + 1],
sharedListData[i*4 + 2], sharedListData[i*4 + 3])
originalNumberTweets += len(lb.tweetList.list)
originalNumberUsers += len(lb.userList.list)
originalNumberTweetStreaming += len(lb.tweetStreamingList.list)
originalNumberTweetSearch += len(lb.tweetSearchList.list)
self.assertEqual(originalNumberTweets, bs.communicator.sentTweets)
self.assertEqual(originalNumberUsers, bs.communicator.sentUsers)
self.assertEqual(originalNumberTweetStreaming, bs.communicator.sentTweetStreamings)
self.assertEqual(originalNumberTweetSearch, bs.communicator.sentTweetSearches)
def startBuffer(config):
stopEvent = Event()
barrier = Barrier(3)#Three threads. Main, Server, Signal
finalise = True
setGlobalVariable(stopEvent, barrier, finalise)
# Call server function
bs = BufferServer(config.socket_port, config.max_connection,
stopEvent, barrier, config.timeout, config.timer_seconds,
config.urldatabase, config.user, config.password)
bs.start()
barrier.wait()
def run_now(experiment: Experiment, probe: Probe, configuration: Configuration,
secrets: Secrets, done: threading.Barrier) -> None:
try:
run = execute_activity(experiment=experiment,
probe=probe,
configuration=configuration,
secrets=secrets)
finally:
done.wait()
interrupt_experiment_on_unhealthy_probe(probe, run, configuration, secrets)
def infer_async_thread_proc(
net, exec_net: ExecutableNetwork, dev_thread_request_id: int,
image_list: list, first_image_index: int, last_image_index: int,
num_total_inferences: int, result_list: list, result_index: int,
start_barrier: threading.Barrier, end_barrier: threading.Barrier,
simultaneous_infer_per_thread: int, infer_result_queue: queue.Queue,
input_blob, output_blob):
# Sync with the main start barrier
start_barrier.wait()
# Start times for the fps counter
start_time = time.time()
end_time = start_time
handle_list = [None] * simultaneous_infer_per_thread
image_index = first_image_index
image_result_start_index = 0
inferences_per_req = int(num_total_inferences /
simultaneous_infer_per_thread)
# For each thread, 6 async inference requests will be created
for outer_index in range(0, inferences_per_req):
# Start the simultaneous async inferences
for infer_id in range(0, simultaneous_infer_per_thread):
new_request_id = dev_thread_request_id + infer_id
handle_list[infer_id] = exec_net.start_async(
request_id=new_request_id,
inputs={input_blob: image_list[image_index]})
image_index += 1
if (image_index > last_image_index):
image_index = first_image_index
# Wait for the simultaneous async inferences to finish.
for wait_index in range(0, simultaneous_infer_per_thread):
infer_status = handle_list[wait_index].wait()
result = handle_list[wait_index].outputs[output_blob]
top_index = numpy.argsort(result, axis=1)[0, -1:][::-1]
top_index = top_index[0]
prob = result[0][top_index]
infer_result_queue.put((top_index, prob))
handle_list[wait_index] = None
# Save the time spent on inferences within this inference thread and associated reader thread
end_time = time.time()
total_inference_time = end_time - start_time
result_list[result_index] = total_inference_time
print("Thread " + str(result_index) + " end barrier reached")
# Wait for all inference threads to finish
end_barrier.wait()
class H2O:
def __init__(self):
self.b = Barrier(3)
self.h = Semaphore(2)
self.o = Semaphore(1)
def hydrogen(self, releaseHydrogen: 'Callable[[], None]') -> None:
self.h.acquire()
self.b.wait()
# releaseHydrogen() outputs "H". Do not change or remove this line.
releaseHydrogen()
self.h.release()
def test_honggfuzz_watcher(caplog, tmp_path):
caplog.set_level(logging.DEBUG)
queue_path = tmp_path / "queue"
config = Config(
fuzzer_type=FuzzerType.HONGGFUZZ, # unused
output_dir=tmp_path,
docker_enabled=False, # unused
afl_path=None, # unused
target_cmdline=[], # unused
ctrl_uri="", # unused
pull_uri="", # unused
push_uri="", # unused
)
connection = Mock()
watcher = HonggFuzzWatcher(config, connection)
# The driver should create the output folder if it does not already find one
assert queue_path.is_dir()
barrier = Barrier(2, timeout=2)
fuzzer_thread = Thread(target=_honggfuzz_thread,
args=(tmp_path, barrier),
daemon=True)
fuzzer_thread.start()
watcher.start(daemon=True)
connection.push_test_case = Mock(return_value=TEST_QUEUE_ID)
barrier.wait()
barrier.wait()
connection.push_test_case.assert_called_once()
args, _ = connection.push_test_case.call_args
seed_msg = args[0]
assert seed_msg.content == TEST_QUEUE_CONTENT
assert seed_msg.type == SeedMsg.SeedType.NORMAL
connection.push_test_case = Mock(return_value=TEST_QUEUE_ID)
barrier.wait()
barrier.wait()
connection.push_test_case.assert_called_once()
args, _ = connection.push_test_case.call_args
seed_msg = args[0]
assert seed_msg.content == TEST_CRASH_CONTENT
assert seed_msg.type == SeedMsg.SeedType.CRASH
barrier.wait()
watcher.stop()
def lock_until_files_are_safe(filenames):
def lock(f, b):
lock_until_file_is_safe(f)
b.wait()
barrier = Barrier(len(filenames) + 1)
for filename in filenames:
t = Thread(target=lock, args=(
filename,
barrier,
))
t.start()
barrier.wait()
class FooBar:
def __init__(self, n):
self.n = n
self.barrier = Barrier(2)
def foo(self, printFoo):
for i in range(self.n):
printFoo()
self.barrier.wait()
def bar(self, printBar):
for i in range(self.n):
self.barrier.wait()
printBar()
class H20:
def __init__(self):
self.barrier = Barrier(3)
self.semaphores = (Semaphore(2), Semaphore(1))
def hydrogen(self, releaseHydrogen: 'Callable[[], None]') -> None:
with self.semaphores[0]:
self.barrier.wait()
releaseHydrogen()
def oxygen(self, releaseOxygen: 'Callable[[], None]') -> None:
with self.semaphores[1]:
self.barrier.wait()
releaseOxygen()
class FooBar:
def __init__(self, n):
self.n = n
self.barrier = Barrier(2)
def foo(self, printFoo: 'Callable[[], None]') -> None:
for i in range(self.n):
printFoo()
self.barrier.wait()
def bar(self, printBar: 'Callable[[], None]') -> None:
for i in range(self.n):
self.barrier.wait()
printBar()
class FoowithBarrier:
def __init__(self):
self.first_barrier = Barrier(2)
self.second_barrier = Barrier(2)
def first(self):
print("First")
self.first_barrier.wait()
def second(self):
self.first_barrier.wait()
print("Second")
self.second_barrier.wait()
def third(self):
self.second_barrier.wait()
print("Third")
def run(self):
t1 = threading.Thread(target=self.second)
t2 = threading.Thread(target=self.first)
t3 = threading.Thread(target=self.third)
t2.start()
t1.start()
t3.start()
class FooBar:
def __init__(self, n):
self.n = n
self.barrier = Barrier(2)
def foo(self):
for i in range(self.n):
print("foo", end="")
self.barrier.wait()
def bar(self):
for i in range(self.n):
self.barrier.wait()
print("bar", end="")
class Foo:
def __init__(self):
self.first_barrier = Barrier(2)
self.second_barrier = Barrier(2)
def first(self, printFirst: 'Callable[[], None]') -> None:
# printFirst() outputs "first". Do not change or remove this line.
printFirst()
self.first_barrier.wait()
def second(self, printSecond: 'Callable[[], None]') -> None:
# printSecond() outputs "second". Do not change or remove this line.
self.first_barrier.wait()
printSecond()
self.second_barrier.wait()
def third(self, printThird: 'Callable[[], None]') -> None:
# printThird() outputs "third". Do not change or remove this line.
self.second_barrier.wait()
printThird()
class Foo(object):
def __init__(self):
self.first = Barrier(2)
self.second = Barrier(2)
pass
def first(self, printFirst):
"""
:type printFirst: method
:rtype: void
"""
# printFirst() outputs "first". Do not change or remove this line.
printFirst()
self.first.wait()
def second(self, printSecond):
"""
:type printSecond: method
:rtype: void
"""
self.first.wait()
# printSecond() outputs "second". Do not change or remove this line.
printSecond()
self.second.wait()
def third(self, printThird):
"""
:type printThird: method
:rtype: void
"""
self.second.wait()
# printThird() outputs "third". Do not change or remove this line.
printThird()
class H2O:
def __init__(self):
self.b = Barrier(3)
self.h = Semaphore(2)
self.o = Semaphore(1)
def hydrogen(self, releaseHydrogen):
with self.h:
self.b.wait()
releaseHydrogen()
def oxygen(self, releaseOxygen):
with self.o:
self.b.wait()
releaseOxygen()
def connect_client(sock: socket, barrier: Barrier):
global clients
send_msg(COMMANDS['NAME'], sock)
try:
name = recv_msg(sock)
send_msg(COMMANDS['PLAYER_JOINED'], data=split_msg_data([0, name]))
send_msg(COMMANDS['PLAYER_JOINED'], sock,
split_msg_data([1, game.pretty_player_names()]))
player_id = len(clients)
clients[player_id] = sock
game.add_player(name, player_id)
interface.player_joined(name)
barrier.wait()
except PlayerDisconnected as e:
pass
def wait_finish(self, show: Callable = None):
def lock(f, b):
lock_until_file_is_safe(f)
b.wait()
barrier = Barrier(len(self.files) + 1)
for filename in self.files:
t = Thread(target=lock, args=(
filename,
barrier,
))
t.start()
barrier.wait()
time.sleep(0.5) # just to be sure that the file has been given free
return True
class H2O:
def __init__(self):
self.barrier = Barrier(3)
self.h_queue = Semaphore(2)
self.o_queue = Semaphore(1)
def hydrogen(self, releaseHydrogen: 'Callable[[], None]') -> None:
with self.h_queue:
self.barrier.wait()
releaseHydrogen()
def oxygen(self, releaseOxygen: 'Callable[[], None]') -> None:
with self.o_queue:
self.barrier.wait()
releaseOxygen()
class H2O:
def __init__(self):
self.water_barrier = Barrier(3)
self.hydrogen_semaphore = Semaphore(2)
self.oxygen_semaphore = Semaphore(1)
def hydrogen(self, releaseHydrogen: 'Callable[[], None]') -> None:
with self.hydrogen_semaphore:
releaseHydrogen()
self.water_barrier.wait()
def oxygen(self, releaseOxygen: 'Callable[[], None]') -> None:
with self.oxygen_semaphore:
releaseOxygen()
self.water_barrier.wait()
def return_image(self):
self.max_freq = 1
pixels = np.zeros((self.yres, self.xres, 4), dtype=np.uint8)
image = np.zeros((self.yres, self.xres, 3), dtype=np.uint8)
mut = Lock()
col_bar = Barrier(self.threads + 1)
save_bar = Barrier(self.threads + 1)
for m in range(self.threads):
t = Thread(target=self.reduce,
args=(m, pixels, image, col_bar, save_bar, mut))
t.start()
col_bar.wait()
save_bar.wait()
return Image.fromarray(image)
def wrapper(self, *args, **kw):
"""Wraps instance method to be called on loop thread"""
barrier = Barrier(2)
result = None
ex = None
def call():
"""Calls function on loop thread"""
# pylint: disable=star-args,broad-except
nonlocal result, ex
try:
result = func(self, *args, **kw)
except Exception as exc:
ex = exc
barrier.wait()
self.loop.call_soon_threadsafe(call)
barrier.wait()
if ex:
raise ex or Exception("Unknown error")
return result
def main(self): global cad, p1, listener cad = pifacecad.PiFaceCAD() cad.lcd.clear() p1.init() p1.homeScreen() #Note from pifacecad github: #listener cannot deactivate itself so we have to wait until it has finished using a barrier global end_barrier end_barrier = Barrier(2) listener = pifacecad.SwitchEventListener(chip=cad) for i in range(8): listener.register(i, pifacecad.IODIR_FALLING_EDGE, p1.setParameters) listener.activate() end_barrier.wait() #Waiting until exit activated in the S5 method #Exit listener.deactivate()
def test_async_can_run_in_different_thread(self, mock):
b = Barrier(2, timeout=5)
def block_response(response_dict):
def callback(request, context):
b.wait()
body = request.body
request_json = json.loads(body)
response_dict['id'] = request_json['id']
context.status_code = 200
return response_dict
return callback
mock.register_uri('POST', "http://server/api/", [
{'status_code': 200, 'json': insert_id(
{"error": None, "jsonrpc": "2.0", "id": {},
"result": {"report_token": "08d7d7bc608848668b3afa6b528a45d8"}})},
{'status_code': 200, 'json': block_response(
{"error": None, "jsonrpc": "2.0", "id": {},
"result": {"status": "processing"}})},
{'status_code': 200, 'json': insert_id(
{"error": None, "jsonrpc": "2.0", "id": {},
"result": {"status": "ready"}})},
{'status_code': 200, 'json': insert_id(
{"error": None, "jsonrpc": "2.0", "id": {},
"result": {"report": "success"}})},
])
response = self.client.test.task(_sleep_interval=0.5, _async=True)
b.wait()
self.assertIsInstance(response, Future)
self.assertTrue(response.running())
done, not_done = concurrent.futures.wait([response], timeout=5)
self.assertGreater(len(done), 0)
self.assertIsInstance(response.result(), dict)
def test_latest_data(self):
"""
Cached should store the data, which generation was started at the latest point in time.
"""
def create_generator(event, sync, data):
def generator(_old_data):
sync.wait()
event.wait()
return data
return generator
def create_thread(func):
def run():
with cache_patcher() as cache:
cached = TestCached(func)
th = Thread(target=run)
th.start()
return th
# thread 1 starts to create some data
event1 = Event()
sync1 = Barrier(2, timeout=1)
data1 = "Wrong data"
t1 = create_thread(create_generator(event1, sync1, data1))
sync1.wait()
# thread 2 starts to create some data
event2 = Event()
sync2 = Barrier(2, timeout=1)
data2 = "Correct data"
t2 = create_thread(create_generator(event2, sync2, data2))
sync2.wait()
# thread 1 completes and stores data
event1.set()
t1.join()
# thread 2 completes and stores updated data
event2.set()
t2.join()
# thread 3 reads data from thread 2
cached3 = TestCached(lambda x: "Ignored data")
self.assertEqual(cached3.data, data2)
def setUp(self):
"""Set up an even loop fixture to watch for signals from spawned tasks. """
super().setUp()
self._sigchld_caught = False
def noopSignalHandler(*args):
pass
original_sigchld_handler = signal.signal(signal.SIGCHLD, noopSignalHandler)
self.addCleanup(lambda: signal.signal(signal.SIGCHLD, original_sigchld_handler))
sig_r_fd, sig_w_fd = os.pipe2(os.O_NONBLOCK | os.O_CLOEXEC)
signal.set_wakeup_fd(sig_w_fd)
pre_loop_barrier = Barrier(2)
self._post_loop_barrier = Barrier(2)
def loop():
pre_loop_barrier.wait(1)
selector = DefaultSelector()
selector.register(sig_r_fd, EVENT_READ)
with suppress(StopIteration):
while True:
events = selector.select(timeout=5)
if len(events) == 0:
raise StopIteration
for key, mask in events:
if key.fd == sig_r_fd:
data = os.read(sig_r_fd, 4)
self._sigchld_caught = True
raise StopIteration
self._post_loop_barrier.wait(1)
test_loop = Thread(target=loop)
self.addCleanup(lambda: test_loop.join(1))
test_loop.start()
pre_loop_barrier.wait(1)
class TestWindowCreator(object):
'''
Creates and cleans up windows to use for testing.
'''
def __init__(self):
'''
Constructor
Attributes:
windows (list): Holds references to the Frames from wxPython
created for testing.
'''
self.windows = []
self._syncBarrier = Barrier(2, timeout = 5)
self._nextTitleNumber = 1
self._wxApp = None
self._wxThread = None
def create(self, titleBase = 'TestWindow', numWindows = 1):
'''
Creates operating system windows (Frames in wxPython).
Adds them to the list in the public 'windows' property.
Every calls to create() should eventually end in a call to
destroy_all(). This method cannot be called twice without
a call to destroy_all() after the first call.
Args:
titleBase (Optional[str]): The left part of the created
window titles. A number is added to the end (right)
of the base title. Default is "TestWindow".
numWindows (Optional[int]): The number of windows to create.
Default is 1.
Raises:
RuntimeError: If two calls are made to create() without
a destroy_all() call between them.
'''
if self._wxApp:
raise RuntimeError('Caught attempt to call create() a second '
'time without first calling destroy_all().')
self._wxApp = wx.App(False)
# Create the windows (Frames) and add them to the public
# windows list.
for i in range(0, numWindows):
windowTitle = titleBase + str(self._nextTitleNumber)
self.windows.append(
wx.Frame(None, wx.ID_ANY, windowTitle)
)
self.windows[i].Show()
self._nextTitleNumber += 1
# Run the wxPython main loop in a different thread.
# One reason is that it loops indefinitely and would block
# other code from running in the main thread.
def wx_creation_thread_target():
nonlocal self
self._wxApp.MainLoop()
# Start the wxPython thread as a daemon so it should exit
# even if the main thread unexpectedly exits first.
self._wxThread = Thread(
target = wx_creation_thread_target,
daemon = True
)
self._wxThread.start()
# _Thread synchronization 1_
# Make sure the wxPython thread waits in the barrier after
# processing the window (Frame) creation.
wx.CallAfter(self._syncBarrier.wait)
# Make sure this main thread waits in the barrier until the
# wxPython thread is finished with the window (Frame) creation.
self._syncBarrier.wait()
# We synchronized at the barrier. Reset the barrier for next time.
self._syncBarrier.reset()
def destroy_all(self):
'''
Destroys all created windows (wxPython Frames) and the wxPython
App object.
Does not reset the window title numbers.
Note: As of 2015-6, this method doesn't actually work correctly.
The spawned wxPython threads and windows only die when
the main thread dies.
'''
# Destroy the windows (Frames) in the wxPython thread.
for window in self.windows:
window.Destroy()
wx.Exit()
# We need some way to wake up the wxPython thread and tell it
# to die, but an easy way does not seem to exist yet.
#wx.WakeUpMainThread()
# Empty the public list of windows.
self.windows.clear()
# Mark the wxPython App and thread as killed.
self._wxApp = None
self._wxThread = None
listener.register(ROCKER_LEFT, pifacecad.IODIR_ON, platypi.previous_option)
listener.register(ROCKER_PUSH, pifacecad.IODIR_ON, platypi.do_option)
return listener
def init_cad():
print('Creating CAD')
cad = pifacecad.PiFaceCAD()
cad.lcd.blink_off()
cad.lcd.cursor_off()
return cad
if __name__ == '__main__':
cad = init_cad()
pp = PlatyPi(cad, PPMOD_DIR, 'PlatyPi v{}'.format(VERSION))
pp.start()
global exit_barrier
exit_barrier = Barrier(2)
listener = register_buttons(cad, pp)
listener.activate()
print('1st wait()')
exit_barrier.wait()
pp.close()
listener.deactivate()
sys.exit(0)
# Store bitmaps for I Ching characters for use later
#
cad.lcd.store_custom_bitmap(i_tl_symbol_index,i_tl_symbol)
cad.lcd.store_custom_bitmap(i_tr_symbol_index,i_tr_symbol)
cad.lcd.store_custom_bitmap(i_bl_symbol_index,i_bl_symbol)
cad.lcd.store_custom_bitmap(i_br_symbol_index,i_br_symbol)
cad.lcd.store_custom_bitmap(ching_tl_symbol_index,ching_tl_symbol)
cad.lcd.store_custom_bitmap(ching_tr_symbol_index,ching_tr_symbol)
cad.lcd.store_custom_bitmap(ching_bl_symbol_index,ching_bl_symbol)
cad.lcd.store_custom_bitmap(ching_br_symbol_index,ching_br_symbol)
cad.lcd.backlight_on()
splash_loop() # display splash screen until a button is pressed.
help_splash() # Display help on what the buttons are called.
main_loop() # run Main Loop until pressing the 'Back' button clears the menus.active flag.
sleep(PAUSE_INTERVAL) # debugging delay.
cad.lcd.clear()
cad.lcd.write("Program Stopped")
#
# Disable Interrup processing
#
switchlistener.deactivate()
if irlistener_activated:
irlistener.deactivate()
end_barrier.wait() # wait for interrupt handlers to stop, then exit
#
# exit
menus.close()
# switchlistener.deactivate()
# if irlistener_activated:
# irlistener.deactivate()
except RuntimeError as e:
logger.critical(e)
logger.critical('client terminating')
break
try:
end_barrier.wait()
except BrokenBarrierError:
logger.error('client() end_barrier broken')
finally:
client_socket.close()
# Log everything to the console.
logger = logging.getLogger()
logger.setLevel(logging.NOTSET)
ch = logging.StreamHandler()
ch.setLevel(logging.NOTSET)
formatter = logging.Formatter('%(asctime)s - %(name)20s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
logger.addHandler(ch)
t1 = Thread(target=server, args=())
t2 = Thread(target=client, args=())
t1.start()
t2.start()
logger.info('Client and server running.')
try:
end_barrier.wait(timeout=5)
except BrokenBarrierError:
logger.error('Barrier broken. Terminating')
sys.exit(0)
class TestLauncherServiceTask(TestLauncher):
"""Verify the expected bahaviour of launch tasks."""
def setUp(self):
"""Set up an even loop fixture to watch for signals from spawned tasks. """
super().setUp()
self._sigchld_caught = False
def noopSignalHandler(*args):
pass
original_sigchld_handler = signal.signal(signal.SIGCHLD, noopSignalHandler)
self.addCleanup(lambda: signal.signal(signal.SIGCHLD, original_sigchld_handler))
sig_r_fd, sig_w_fd = os.pipe2(os.O_NONBLOCK | os.O_CLOEXEC)
signal.set_wakeup_fd(sig_w_fd)
pre_loop_barrier = Barrier(2)
self._post_loop_barrier = Barrier(2)
def loop():
pre_loop_barrier.wait(1)
selector = DefaultSelector()
selector.register(sig_r_fd, EVENT_READ)
with suppress(StopIteration):
while True:
events = selector.select(timeout=5)
if len(events) == 0:
raise StopIteration
for key, mask in events:
if key.fd == sig_r_fd:
data = os.read(sig_r_fd, 4)
self._sigchld_caught = True
raise StopIteration
self._post_loop_barrier.wait(1)
test_loop = Thread(target=loop)
self.addCleanup(lambda: test_loop.join(1))
test_loop.start()
pre_loop_barrier.wait(1)
def test_service_sends_SIGCHLD_on_exit(self):
"""Verify a SIGCHLD signal gets raised when the service exits.
Runs a fast-exiting 'service' (which should finish on its own in a
reasonable time) and verifies that a SIGCHLD is raised.
"""
config = launcher.TaskConfig(launcher.TaskType.LAUNCH_SERVICE, ("/bin/true"))
task = launcher.LaunchServiceTask(config)
task.start()
self._post_loop_barrier.wait(1)
self.assertThat(self._sigchld_caught, Equals(True))
def test_service_stop_exits_program(self):
"""Verify the service exists when stopped.
Runs a long-running service (which should not normally finish on its
own) and verifies that a SIGCHLD is received after calling stop() on the
task.
"""
config = launcher.TaskConfig(launcher.TaskType.LAUNCH_SERVICE, ("/usr/bin/yes"))
task = launcher.LaunchServiceTask(config)
task.start()
sleep(0.05)
task.stop()
self._post_loop_barrier.wait(1)
self.assertThat(self._sigchld_caught, Equals(True))
if event.pin_num == 1:
resolutionS2.S2(self)
print("haha!")
p1.printRes()
else:
pass
def printRes(self):
print(v1.resolutionW)
print(v1.resolutionH)
if __name__ == '__main__':
p1 = callAll(cad)
cad.lcd.clear()
#Note from pifacecad github:
#listener cannot deactivate itself so we have to wait until it has finished using a barrier
global end_barrier
end_barrier = Barrier(2)
listener = pifacecad.SwitchEventListener(chip=cad)
for i in range(8):
listener.register(i, pifacecad.IODIR_FALLING_EDGE, p1.setParameters)
listener.activate()
end_barrier.wait() #Waiting until exit activated in the S5 method
#Exit
listener.deactivate()
def start_framework(args):
global _netobj, _setup_ok
setup_logging(args.debug, args.logfile)
if args.listif:
devlist = _assemble_device_list(args)
dlist = [ str(d) for d in devlist ]
log_info("Devices found: {}".format(','.join(dlist)))
return
# assume testmode if compile flag is set
testmode = False
if args.compile or args.tests:
testmode = True
args.codearg = _parse_codeargs(args.codearg)
if args.verbose:
VerboseOutput.enable()
if args.cli:
t = Topology()
if args.topology:
try:
t = load_from_file(args.topology)
except FileNotFoundError:
print ("No such file {} exists to load topology.".format(args.topology))
return
run_simulation(t)
return
waiters = 1
if args.app:
waiters += 1
barrier = Barrier(waiters)
if args.app:
ApplicationLayer._init()
_appt = Thread(target=_start_app, args=(args.app,barrier))
_appt.start()
if args.app:
args.fwconfig = []
elif args.fwconfig is None or len(args.fwconfig) == 0:
args.fwconfig = ('all',)
if testmode:
if args.compile:
if args.usercode:
log_info("You specified user code to run with compile flag, "
"but I'm just doing compile.")
for scenario in args.compile:
log_info("Compiling scenario {}".format(scenario))
compile_scenario(scenario)
else:
if not args.usercode:
log_failure("In test mode, but not user code supplied.")
return
global platform
platform = sys.platform
setattr(sys, "origplatform", platform)
setattr(sys, "platform", "test")
with Firewall([], args.fwconfig):
_setup_ok = True
barrier.wait()
main_test(args)
else:
if sys.platform != 'win32' and os.geteuid() != 0:
log_warn("You're running in real mode, but not as root. "
"You should expect errors, but I'm going to "
"continue anyway.")
devlist = _assemble_device_list(args)
if not devlist:
log_failure("There are no network interfaces I can use after "
"processing include/exclude lists")
alldevs = make_device_list([], [])
log_failure("Here are all the interfaces I see on your system: "
"{}".format(', '.join(list(alldevs))))
barrier.wait()
return
with Firewall(devlist, args.fwconfig):
_setup_ok = True
barrier.wait()
_netobj = LLNetReal(devlist)
main_real(args.usercode, _netobj, args)
end_barrier = Barrier(2)
# Register Buttons
listener = pifacecad.SwitchEventListener(chip=cad)
for i in range(0, 4, 1):
listener.register(i, pifacecad.IODIR_ON, radio.toggle)
listener.register(4, pifacecad.IODIR_ON, end_barrier.wait)
listener.register(5, pifacecad.IODIR_ON, radio.toggle)
listener.register(6, pifacecad.IODIR_ON, radio.previous_station)
listener.register(7, pifacecad.IODIR_ON, radio.next_station)
listener.activate()
# wait unitl exit
end_barrier.wait()
# Exit Radio
radio.close()
listener.deactivate()
print("Radio finished")
# -----------------------------------------------
# Shutdown Raspberry
# -----------------------------------------------
print("Shutdown part") # debug
def pi_halt():
pi_end = subprocess.Popen("sudo shutdown -h now", shell=True)
for pstation in range(4):
switchlistener.register(
pstation, pifacecad.IODIR_ON, radio_preset_switch)
switchlistener.register(4, pifacecad.IODIR_ON, end_barrier.wait)
switchlistener.register(5, pifacecad.IODIR_ON, radio.toggle_playing)
switchlistener.register(6, pifacecad.IODIR_ON, radio.previous_station)
switchlistener.register(7, pifacecad.IODIR_ON, radio.next_station)
irlistener = pifacecad.IREventListener(
prog="pifacecad-radio-example",
lircrc="/usr/share/doc/python3-pifacecad/examples/radiolircrc")
for i in range(4):
irlistener.register(str(i), radio_preset_ir)
switchlistener.activate()
try:
irlistener.activate()
except lirc.InitError:
print("Der Infrarot-Empfänger konnte nicht initialisiert werden!")
irlistener_activated = False
else:
irlistener_activated = True
end_barrier.wait() # wait until exit
# exit
radio.close()
switchlistener.deactivate()
if irlistener_activated:
irlistener.deactivate()
if __name__ == "__main__":
cad = pifacecad.PiFaceCAD()
LCD_SM = LCD_SM(cad)
# listener cannot deactivate itself so we have to wait until it has
# finished using a barrier.
global end_barrier
end_barrier = Barrier(2)
# wait for button presses
switchlistener = pifacecad.SwitchEventListener(chip=cad)
switchlistener.register(0, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(1, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(2, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(3, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(4, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(5, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(6, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.register(7, pifacecad.IODIR_ON, LCD_SM.run, SETTLE_TIME)
switchlistener.activate()
end_barrier.wait() # wait unitl exit
#Deactivate LCD and exit program
switchlistener.deactivate()
class terminal_test:
#{{{
def __init__(self):
self.send_msg_flag = True
builtins.FileName = time.strftime('%Y-%m-%d-%H%M%S_log')
builtins.SendMsg_dic = [{} for i in range(number_of_servers)]
builtins.received_flag = [False for i in range(number_of_servers)]
builtins.AverageTime = ['' for i in range(number_of_servers)]
builtins.MaxTime = ['' for i in range(number_of_servers)]
# builtins.Send_Finished_flag = [False for i in range(number_of_servers)]
builtins.F = ('log/' + FileName)
self.B = Barrier(number_of_servers)
self.received_B = Barrier(number_of_servers)
# self.Send_B = Barrier(Send_Servers)
self.main()
#}}}
def main(self):
for i in range(number_of_servers):
def callback():
self.stability_test(WAIT, i)
t = threading.Thread(target=callback)
t.daemon = True
t.start()
builtins.PORT += 1
time.sleep(0.1)
def stability_test(self,wait,id_):
port = PORT
rece_dict =[set() for i in range(Send_Servers)]
check_code =[0 for i in range(Send_Servers)]
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, port))
s.settimeout(1)
s.listen(1)
tempformat = 'Listening....{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
while True:
try:
if EXIT_flag:
self.printlog(builtins.F, '{0} has been closed'.format(port))
return
conn, addr = s.accept()
break
except:
pass
#Display and logging address of connected
tempformat = '{0} Connected by {1}'.format(port, addr)
self.printlog(builtins.F, tempformat)
#Dictionary of testing bytes
if id_< Send_Servers:
MessageDict = [chr(i) for i in range(128)]
del MessageDict[10]
for i in range(5):
MessageDict += MessageDict
#waiting for welcome message and display it
WaitingForSecond = select.select([conn], [], [], 30)
if WaitingForSecond[0]:
StartMsg = conn.recv(4096)
self.printlog (builtins.F, str(StartMsg))
#start testing
self.B.wait()
def receive_server():
nonlocal rece_dict
nonlocal check_code
conn.settimeout(1)
while not EXIT_flag:
try:
data = 'start'
#try:
# WaitingForSecond = select.select([conn], [], [], 5)
#except ValueError:
# pass
try:
# if WaitingForSecond[0]:
data = conn.recv(4096)
except socket.timeout:
continue
except OSError:
pass
if data is 'start':
continue
if len(data) is 0:
print(data)
break
send_id, loop, len_of_string, received_time, t = self.string_analysis(data)
if 'unknow' in (send_id, loop, len_of_string):
tempformat =(
"""{data}\n{port} Received
=========unknow {0}bytes_{1:.3}s=========="""
.format(len(data),t , port=port,
id_=send_id, data=data)
)
self.printlog(builtins.F, tempformat)
builtins.Miss[id_] += 1
continue
while len_of_string < len(data):
data1 = data[:len_of_string]
data = data[len_of_string:]
send_id, loop, len_of_string, received_time, t =\
self.string_analysis(data)
send_id1, loop1, len_of_string1, received_time1, t1 =\
self.string_analysis(data1)
try:
rece_dict[send_id1].add(loop1)
if check_code[send_id1] is -1:
check_code[send_id1] = loop1
except TypeError:
pass
if received_time1 is not 0:
t1 = float(str(time.time())[7:14]) - received_time1
try:
builtins.MaxTime[id_] = max(AverageTime[id_],t1)
builtins.AverageTime[id_] = (builtins.AverageTime[id_]+t1)/2
except TypeError :
MaxTime[id_] = AverageTime[id_] = t1
if builtins.SendMsg_dic[send_id1].get(loop1) == data1:
tempformat = (
"""{port} Received {id_} {Loop}: (unpacked){0}bytes_{1:.3}s"""
.format(len(data1),t1 , port=port,
Loop = loop1+1, id_=send_id1)
)
self.printlog(builtins.F, tempformat)
else :
tempformat = (
"""{port} Received {id_} {Loop}:
=========WRONG {0}bytes_{1:.3}s=========="""
.format(len(data1),t1 , port=port,
Loop = loop1+1, id_=send_id1)
)
self.printlog(builtins.F, tempformat)
builtins.Miss[id_] += 1
# The Check_code will be set to -1(ignore miss string during offline)
# when server reconnected
try:
rece_dict[send_id].add(loop)
if check_code[send_id] is -1:
check_code[send_id] = loop
except TypeError:
pass
if received_time is not 0:
t = float(str(time.time())[7:14]) - received_time
try:
builtins.MaxTime[id_] = max(AverageTime[id_],t)
builtins.AverageTime[id_] = (builtins.AverageTime[id_]+t)/2
except TypeError :
MaxTime[id_] = AverageTime[id_] = t
tempformat = "{port} Received {id_} {Loop}: {0}bytes_{1:.3}s"\
. format(len(data),t , port=port, Loop = loop+1, id_=send_id)
self.printlog(builtins.F, tempformat)
#=============check received data if anything has been lost=============
try:
while len(rece_dict[send_id]) >= 3:
time.sleep(0.2)
try:
rece_dict[send_id].remove(check_code[send_id])
except KeyError:
self.printlog(builtins.F,\
'{port}----------{0} {1} has been missed!!--------------------'\
.format(send_id, check_code[send_id]+1, port=port))
builtins.Miss[id_] += 1
finally:
check_code[send_id] += 1
except TypeError:
pass
#======================================================================
if wait:
self.received_B.wait()
if send_id == id_:
self.received_flag[id_] = False
#==========for testing==================================
except ValueError:
print('111')
try:
for i in range(Send_Servers):
while len(rece_dict[i]) > 0:
try:
rece_dict[i].remove(check_code[i])
except KeyError:
self.printlog(builtins.F,\
'{port}----------{0} {1} has been missed!!--------------------'\
.format(i, check_code[i]+1, port=port))
builtins.Miss[id_] += 1
finally:
check_code[i] += 1
print(rece_dict[i])
except TypeError:
pass
tr = threading.Thread(target=receive_server)
tr.daemon = True
tr.start()
#=============================call disconnect function========================
if builtins.Disconn:
self.disconnect(conn, id_)
#=============================let send_servers delay 3seconds each===========
if id_< Send_Servers:
time.sleep(id_*3)
#========================make loop currect when disconnect function is ON======
i = 0
while i < Loop:
try:
#===================================check received_server is alive============
if not tr.is_alive():
raise ConnectionError
if wait:
self.B.wait()
if id_< Send_Servers:
#continue send message if receive server has not received in 15 seconds
_=0
while builtins.received_flag[id_]:
_ += 1
time.sleep(0.1)
if _ > 150:
builtins.received_flag[id_] = False
#====================================================================
if wait:
Waiting_time = random.randint(0,10)
self.printlog(builtins.F, str(i+1) + ' times, ' + 'wait ' + str(Waiting_time) + 's')
time.sleep(Waiting_time)
random_bytes = random.randint(min_bytes-15,max_bytes-15)
message = random.sample(MessageDict, random_bytes)
SendMsg = (
(str(time.time())[7:14] +
''.join(message)+ str(id_) +
'{0:0>6}'.format(i)+ chr(10))
)
SendMsg = (SendMsg[:10] + str(len(SendMsg)).zfill(4)+SendMsg[14:]).encode('ascii')
conn.sendall(SendMsg)
builtins.SendMsg_dic[id_][i] = SendMsg
if len(SendMsg_dic[id_]) > 3:
del SendMsg_dic[id_][i-3]
builtins.received_flag[id_] = True
tempformat = '{port} Sent {Loop}: {0}, {1}bytes'.\
format(SendMsg[:20], len(SendMsg), Loop = i+1, port=port)
self.printlog(builtins.F, tempformat)
if wait:
self.B.wait()
i += 1
if builtins.EXIT_flag:
break
except ConnectionError:
if builtins.EXIT_flag:
break
conn.close()
tempformat = 'Disconnected...{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
rece_dict =[set() for i in range(Send_Servers)]
tempformat = 'Listening....{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, port))
s.listen(1)
conn, addr = s.accept()
tempformat = '{0} Connected by {1}'.format(port, addr)
self.printlog(builtins.F, tempformat)
check_code = [-1 for i in range(Send_Servers)]
time.sleep(1)
tr = threading.Thread(target=receive_server)
tr.daemon = True
tr.start()
if builtins.Disconn:
self.disconnect(conn, id_)
builtins.Send_Finished_flag[id_] = True
# if not wait and id_ >= Send_Servers:
while not builtins.EXIT_flag:
while tr.is_alive():
time.sleep(0.2)
if not builtins.EXIT_flag:
conn.close()
tempformat = 'Disconnected...{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
tempformat = 'Listening....{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, port))
s.listen(1)
conn, addr = s.accept()
tempformat = '{0} Connected by {1}'.format(port, addr)
self.printlog(builtins.F, tempformat)
check_code = [-1 for i in range(Send_Servers)]
time.sleep(1)
tr = threading.Thread(target=receive_server)
tr.daemon = True
tr.start()
if builtins.Disconn:
self.disconnect(conn,id_)
time.sleep(5)
conn.close()
# if id_< Send_Servers:
# self.Send_B.wait()
# builtins.EXIT_flag = True
self.B.wait()
tempformat = "\n{Port}\nAverage : {Avg:.3}s\
\nMax : {Max:.3}s\
\n{Miss} message has been missed"\
.format(Avg = AverageTime[id_],\
Max = MaxTime[id_],\
Port=port,\
Miss = Miss[id_])
self.printlog(builtins.F, tempformat)
# self.B.wait()
# while tr.is_alive():
# time.sleep(0.1)
def string_analysis(self, data):
#{{{
try:
send_id = int(chr(data[-8]))
except :
send_id = 'unknow'
try:
loop=data[-7:-1]
loop = int(loop)
except :
loop = 'unknow'
try:
len_of_string = int(data[10:14])
except :
len_of_string = 'unknow'
try:
received_time = float(data[:6])
except :
received_time = 0
finally:
t = 0.000
#print(port,' ',len_of_string)
return send_id, loop, len_of_string, received_time, t #}}}
def disconnect(self, conn, id_):
if disconn_field[id_].get().strip():
def callback():
discount = 0
while discount <= int(builtins.disconn_field[id_].get()):
time.sleep(1)
discount += 1
conn.shutdown(2)
conn.close()
t = threading.Thread(target=callback)
t.daemon = True
t.start()
def printlog(self, filename, Print_format):
d = datetime.datetime
t = '[{0:.12}] '.format(d.strftime(d.now(), '%H:%M:%S.%f'))
filename = open(filename, 'a')
filename.write(t + Print_format + '\n')
print(t + Print_format)
filename.close()
class mainwindow(QtGui.QMainWindow,finestraprincipale.Ui_MainWindow):
'''
Classe che crea una finestra principale per il programma.
'''
#dialogs e finestre
_loginDialog = None
_aboutDialog = None
_postPlexer = None
#thread e altro
_logger = None
_barrier = None
_connettore = Comunicazione.comunicatore()
__VERSION__ = None
def __init__(self,version,parent = None):
'''
Costruisce una finestra principale di Thinkzone.
Ha bisogno di alcuni parametri per avviarsi.
@param version: La versione del programma.
'''
self.__VERSION__ = version
logging.basicConfig(filename="thinkzone_gui.log",format='%(asctime)s | Loglevel: %(levelname)s | %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
self._logger = logging.getLogger()
self._logger.setLevel(logging.DEBUG)
self._logger.info("Inizio nuova sessione")
QtGui.QMainWindow.__init__(self,parent)
self.ui = finestraprincipale.Ui_MainWindow()
self.setupUi(self)
spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.layoutTextarea.addItem(spacerItem)
#setup finestre di dialogo
self._loginDialog = loginDialog.Login(self)
self._aboutDialog = aboutDialog.aboutDial(self)
self._aboutDialog.labelVersion.setText("Version: "+self.__VERSION__)
#connettori
self._barrier = Barrier(2, timeout=200)
self._connettore._barrier = self._barrier
self._postPlexer = PostPlexer(self._connettore)
self._connettore._postPlexer = self._postPlexer
#connessione di tutti i segnali
QtCore.QObject.connect(self.buttonCrea,QtCore.SIGNAL('pressed()'), self._inviaCreazione)
QtCore.QObject.connect(self.actionLogin,QtCore.SIGNAL("triggered()"),self._loginDialog.show)
QtCore.QObject.connect(self.actionInformazioni_su,QtCore.SIGNAL("triggered()"),self._aboutDialog.show)
QtCore.QObject.connect(self._connettore,QtCore.SIGNAL('nuovoPost(int)'),self._creapost,2)
self._creapost(0)
self.layout_titolo.addWidget(self._postPlexer._postids[0])
def _inviaCreazione(self):
'''
Crea nella finestra un nuovo post.
'''
atti = self._postPlexer.myActivePost()
if(atti == None):
atti = 0
self._logger.debug("Creazione nuovo post.")
self._connettore._spedisci('\K'+str(atti)+'\\') # WARNING da ricontrollare meglio.
def _creapost(self,idpost):
'''
Parsing degli ID dei post. Crea nuovi post, seleziona post precedenti e dice quando non esistono.
'''
self._logger.debug("Creazione di un nuovo post con ID: "+str(idpost))
textArea = PostWidget.postWidget(idpost)
QtCore.QObject.connect(textArea,QtCore.SIGNAL('testoRimosso(int,int,int)'), self._connettore.spedisci_rimozione)
QtCore.QObject.connect(textArea,QtCore.SIGNAL('testoAggiunto(int,QString,int)'), self._connettore.spedisci_aggiunta)
self._postPlexer._postids[idpost] = textArea
if(idpost != 0):
self.layoutTextarea.addWidget(textArea)
self._barrier.wait()
receiver = ctx.socket(zmq.PULL)
receiver.bind('tcp://*:5558')
barrier = Barrier(2)
def senderThread():
time.sleep(2)
for ps in range(0, 20, 2):
for socks in range(0, 20, 2):
sender.send_string(mogrify('measurement_start'
, { 'processes': int(ps)
, 'sockets': int(socks)
, 'messages': int(sys.argv[2])
, 'max_length': int(sys.argv[3])
}))
barrier.wait()
Thread(target=senderThread).start()
for ps in range(0, 20, 2):
for socks in range(0, 20, 2):
res = []
for _ in range(int(sys.argv[1])):
res.append(receiver.recv_string())
print('result received', file=sys.stderr)
print(max(map(float, res)))
barrier.wait()
class terminal_test:
def __init__(self):
self.send_msg_flag = True
builtins.FileName = time.strftime('%Y-%m-%d-%H%M%S_log')
builtins.SendMsg_dic = [{} for i in range(number_of_servers)]
builtins.received_flag = [False for i in range(number_of_servers)]
builtins.AverageTime = ['' for i in range(number_of_servers)]
builtins.MaxTime = ['' for i in range(number_of_servers)]
# builtins.Send_Finished_flag = [False for i in range(number_of_servers)]
builtins.F = ('log/' + FileName)
self.B = Barrier(number_of_servers)
self.received_B = Barrier(number_of_servers)
# self.Send_B = Barrier(Send_Servers)
self.main()
def main(self):
for i in range(number_of_servers):
def callback():
self.stability_test(WAIT, i)
t = threading.Thread(target=callback)
t.daemon = True
t.start()
builtins.PORT += 1
time.sleep(0.1)
def stability_test(self,wait,id_):
port = PORT
rece_dict =[set() for i in range(Send_Servers)]
check_code =[0 for i in range(Send_Servers)]
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, port))
s.listen(1)
tempformat = 'Listening....{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
conn, addr = s.accept()
#Display and logging address of connected
tempformat = '{0} Connected by {1}'.format(port, addr)
self.printlog(builtins.F, tempformat)
#Dictionary of testing bytes
if id_< Send_Servers:
MessageDict = [chr(i) for i in range(128)]
del MessageDict[10]
for i in range(5):
MessageDict += MessageDict
#waiting for welcome message and display it
WaitingForSecond = select.select([conn], [], [], 30)
if WaitingForSecond[0]:
StartMsg = conn.recv(4096)
self.printlog (builtins.F, str(StartMsg))
#start testing
self.B.wait()
def receive_server():
nonlocal rece_dict
nonlocal check_code
while not EXIT_flag:
try:
data = b''
try:
WaitingForSecond = select.select([conn], [], [], 60)
except ValueError:
pass
try:
if WaitingForSecond[0]:
data = conn.recv(4096)
except OSError:
pass
if len(data) is 0:
break
try:
send_id = int(chr(data[-8]))
except ValueError:
send_id = 'unknow'
try:
loop=data[-7:-1]
loop = int(loop)
except ValueError:
loop = 'unknow'
try:
received_time = float(data[:6])
except ValueError:
received_time = 0
t = 0.000
try:
rece_dict[send_id].add(loop)
if check_code[send_id] is -1:
check_code[send_id] = loop
except TypeError:
pass
try:
while len(rece_dict[send_id]) >= 3:
time.sleep(0.2)
try:
rece_dict[send_id].remove(check_code[send_id])
except KeyError:
self.printlog(builtins.F,'{port}----------{0} {1} has been missed!!--------------------'\
.format(send_id, check_code[send_id]+1, port=port))
builtins.Miss[id_] += 1
finally:
check_code[send_id] += 1
except TypeError:
pass
#=================================================================
if received_time is not 0:
t = float(str(time.time())[7:14]) - received_time
try:
builtins.MaxTime[id_] = max(AverageTime[id_],t)
builtins.AverageTime[id_] = (builtins.AverageTime[id_]+t)/2
except TypeError :
MaxTime[id_] = AverageTime[id_] = t
tempformat = "{port} Received {id_} {Loop}: {0}bytes_{1:.3}s".format(len(data),t , port=port, Loop = loop+1, id_=send_id)
self.printlog(builtins.F, tempformat)
if builtins.SendMsg_dic[send_id].get(loop) != data:
tempformat = "-------------------------ERROR-------------------------"
self.printlog(builtins.F, tempformat)
builtins.Miss[id_] += 1
if wait:
self.received_B.wait()
if send_id == id_:
builtins.received_flag[id_] = False
except ValueError:
print('111')
# break
try:
for i in range(Send_Servers):
while len(rece_dict[i]) > 0:
try:
rece_dict[i].remove(check_code[i])
except KeyError:
self.printlog(builtins.F,'{port}----------{0} {1} has been missed!!--------------------'\
.format(i, check_code[i]+1, port=port))
builtins.Miss[id_] += 1
finally:
check_code[i] += 1
except TypeError:
pass
tr = threading.Thread(target=receive_server)
tr.daemon = True
tr.start()
if builtins.Disconn:
self.disconnect(conn, id_)
if id_< Send_Servers:
time.sleep(id_*3)
#for i in range(Loop):
i = 0
while i < Loop:
try:
if wait:
if not tr.is_alive():
raise Exception('Thread is crushed')
self.B.wait()
if id_< Send_Servers:
_=0
while builtins.received_flag[id_]:
_ += 1
time.sleep(0.1)
if _ > 150:
builtins.received_flag[id_] = False
if wait:
Waiting_time = random.randint(0,10)
self.printlog(builtins.F, str(i+1) + ' times, ' + 'wait ' + str(Waiting_time) + 's')
time.sleep(Waiting_time)
random_bytes = random.randint(min_bytes-15,max_bytes-15)
message = random.sample(MessageDict, random_bytes)
SendMsg = (
(str(time.time())[7:14] +
''.join(message)+ str(id_) +
'{0:0>6}'.format(i)+ chr(10))
)
SendMsg = (SendMsg[:10] + str(len(SendMsg)).zfill(4)+SendMsg[14:]).encode('ascii')
conn.sendall(SendMsg)
builtins.SendMsg_dic[id_][i] = SendMsg
if len(SendMsg_dic[id_]) > 3:
del SendMsg_dic[id_][i-3]
builtins.received_flag[id_] = True
tempformat = '{port} Sent {Loop}: {0}, {1}bytes'.\
format(SendMsg[:20], len(SendMsg), Loop = i+1, port=port)
self.printlog(builtins.F, tempformat)
i += 1
if builtins.EXIT_flag:
break
except OSError:
if builtins.EXIT_flag:
break
conn.close()
tempformat = 'Disconnected...{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
rece_dict =[set() for i in range(Send_Servers)]
tempformat = 'Listening....{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, port))
s.listen(1)
conn, addr = s.accept()
tempformat = '{0} Connected by {1}'.format(port, addr)
self.printlog(builtins.F, tempformat)
check_code = [-1 for i in range(Send_Servers)]
time.sleep(1)
tr = threading.Thread(target=receive_server)
tr.daemon = True
tr.start()
if builtins.Disconn:
self.disconnect(conn, id_)
builtins.Send_Finished_flag[id_] = True
# if not wait and id_ >= Send_Servers:
while not builtins.EXIT_flag:
while tr.is_alive():
time.sleep(0.1)
if not builtins.EXIT_flag:
conn.close()
tempformat = 'Disconnected...{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
tempformat = 'Listening....{0}:{1}'.format(HOST, port)
self.printlog(builtins.F, tempformat)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, port))
s.listen(1)
conn, addr = s.accept()
tempformat = '{0} Connected by {1}'.format(port, addr)
self.printlog(builtins.F, tempformat)
check_code = [-1 for i in range(Send_Servers)]
time.sleep(1)
tr = threading.Thread(target=receive_server)
tr.daemon = True
tr.start()
if builtins.Disconn:
self.disconnect(conn,id_)
time.sleep(5)
conn.close()
# if id_< Send_Servers:
# self.Send_B.wait()
# builtins.EXIT_flag = True
self.B.wait()
tempformat = "\n{Port}\nAverage : {Avg:.3}s\
\nMax : {Max:.3}s\
\n{Miss} message has been missed"\
.format(Avg = AverageTime[id_],\
Max = MaxTime[id_],\
Port=port,\
Miss = Miss[id_])
self.printlog(builtins.F, tempformat)
# self.B.wait()
# while tr.is_alive():
# time.sleep(0.1)
def disconnect(self, conn, id_):
if disconn_field[id_].get().strip():
def callback():
discount = 0
while discount <= int(builtins.disconn_field[id_].get()):
time.sleep(1)
discount += 1
conn.close()
t = threading.Thread(target=callback)
t.daemon = True
t.start()
def printlog(self, filename, Print_format):
d = datetime.datetime
t = '[{0:.12}] '.format(d.strftime(d.now(), '%H:%M:%S.%f'))
filename = open(filename, 'a')
filename.write(t + Print_format + '\n')
print(t + Print_format)
filename.close()
