def __init__(self):
self.n = 4
self.customers = 0
self.mutex = Lock()
self.barberAttention = Lock()
self.haircutStart = Barrier(2, timeout=None)
self.haircutFinished = Barrier(2, timeout=None)
def __init__(self, room):
super().__init__()
self.room = room
self.exception = None
self.__lastping = self.__lastpong = 0
agent = "Volafile-API/" + __version__
self.headers.update({"User-Agent": agent})
self.cookies.update({"allow-download": "1"})
self.lock = RLock()
self.__conn_barrier = Barrier(2)
self.listeners = defaultdict(Listeners)
self.must_process = False
self.__queues_enabled = True
self.__ping_interval = 20 # default
self.proto = Protocol(self)
self.handler = Handler(self)
self.last_ack = self.proto.max_id
def __init__(self, n_threads=4, initial_port=19997, q_table_version=0,
batch_size=None, learner=None, explorer=None):
self.barrier = Barrier(n_threads + 1, timeout=720)
self.n_threads = n_threads
self.initial_port = initial_port
self.batch_size = batch_size
self.controller = MyActionValueTable(q_table_version)
if learner is None:
self.learner = Q(0.5, 0.9)
else:
self.learner = learner
if explorer is None:
self.explorer = self.learner.explorer = EpsilonGreedyExplorer(0.2, 0.998)
else:
self.explorer = self.learner.explorer = explorer
self.agent = LearningAgent(self.controller, self.learner)
# Logger initialization
self.logger = logging.getLogger('master_logger')
self.logger.setLevel(logging.DEBUG)
self.logger.addHandler(logging.FileHandler(Utils.DATA_PATH + 'learning-tables/master.log'))
self.failed_simulations = []
self.n_episodes = 0
self.simulations = []
self.initialize_simulations()
def __init__(self,
event: Event = Event(),
start_thread: bool = None,
**kwargs):
"""Override the Thread.__init__.
默认设置为守护进程，也可以添加Thread的参数。
"""
# Default barrier.
# The parties is 2 thread : main thread and sub thread.
self.barrier = Barrier(2)
# The optional arguments: shared event.
self.event = event
self.event.set()
# Default daemon.
daemon = dict(kwargs).pop('daemon', True)
Thread.__init__(self, daemon=daemon, **kwargs)
# Thread.__init__(self, **kwargs)
# The optional arguments: start_thread
# start_thread = dict(kwargs).pop('start_thread', initial_start_thread)
flag = start_thread if start_thread is not None else initial_start_thread
if flag:
Thread.start(self)
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 using_multiply_thread():
print(glob_var)
# define global
global barriers
barriers = (
None, # start from index 1
None, # the first thread need't barrier
Barrier(2),
Barrier(2),
)
# create thread
threads = (
Thread(target=func1),
Thread(target=func2),
Thread(target=func3),
)
# start sub_thread
for thread in threads:
thread.start()
# wait sub thread complete
for thread in threads:
thread.join()
print(glob_var)
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))
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 __init__(self, func: Callable[[any], any], preload: Iterable = None,
keep=False, progress=False, size=os.cpu_count() * 2 + 1):
"""
parallel run func with multi-threading
:param func: target method to run, need receive an arg
:param preload: preload any args
:param keep: whether or not keep thread while queue is empty
if keep=False, thread will auto close while task end
:param size: how much thread to parallel run
"""
self.method = func
self.keep = keep
self.size = size
self.queue = Queue()
self.tasks = []
self.progress = progress
self.tqdm = None
self._is_start = Event()
self._is_stop = Event()
self.callbacks = [self._tasks_done_notify]
self._tasks_done = Barrier(size, action=self._tasks_done_callback)
self._results = Queue()
self._results_gen = None
for item in preload or []:
self.queue.put(item)
self.total = self.queue.qsize()
self.count = 0
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")
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 __init__(self, tellos: List[Tello]):
"""Initialize a TelloSwarm instance
Arguments:
tellos: list of [Tello][tello] instances
"""
self.tellos = tellos
self.barrier = Barrier(len(tellos))
self.funcBarrier = Barrier(len(tellos) + 1)
self.funcQueues = [Queue() for tello in tellos]
def worker(i):
queue = self.funcQueues[i]
tello = self.tellos[i]
while True:
func = queue.get()
self.funcBarrier.wait()
func(i, tello)
self.funcBarrier.wait()
self.threads = []
for i, tello in enumerate(tellos):
thread = Thread(target=worker, daemon=True, args=(i, ))
thread.start()
self.threads.append(thread)
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 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 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 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 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 __init__(self,
gamesize=10000,
nbSpherePnj=100,
nbMaxSpherePnj=1000,
minTailleSpheresPnj=100,
maxTailleSpheresPnj=1000):
"""
gamesize Taille du jeu en unités metriques (la carte est carrée)
nbSpherePnj nombre de spheres qu'a le PNJ au début
nbMaxSpherePnj nombre maximum de spheres qu'a le PNJ
minTailleSpheresPnj taille minimum d'une Sphere du PNJ
maxTailleSpheresPnj taille maximum d'une Sphere du PNJ
"""
self.lockmanger = Lock()
Thread.__init__(self)
self.game = Game(gamesize, nbSpherePnj, nbMaxSpherePnj,
minTailleSpheresPnj, maxTailleSpheresPnj)
self.data = self.game.toJson()
self.scores = self.game.scoresJson()
self.aManger = []
self.nbth = 0
self.joueursAAdd = []
#B2 barriere d'étape
self.barrierEtape = Barrier(0, action=self.randomPnj)
#B1 barriere de tours
self.barrierManger = Barrier(0, action=self.manger)
#barriere de spheres a manger
self.barrierTours = Barrier(0, action=self.updateNbTh)
self.debutTours = time.time()
def __init__(self):
self._h2o = Barrier(3)
self._atom_h = Semaphore(2)
self._atom_o = Semaphore(1)
pass
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 __init__(self): self.dc_count = 0 self.dc_waiting = Semaphore(0) self.marvel_count = 0 self.marvel_waiting = Semaphore(0) self.lock = Lock() self.barrier = Barrier(4) self.ride_count = 0
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 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())
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]
def __init__(self):
self.__currentSimTime = None
self.__previousSimTime = None
self.__events = None
self.__subscribers = {}
self.__syncBarrier = Barrier(1) # (1): Simulator Control Blocks too
self.__syncLock = Lock()
self.__isStarted = False
self.__cleared = True
def unsubscribe(self, name):
self.__syncLock.acquire()
if self.__syncBarrier.n_waiting != 0 and not self.__syncBarrier.broken:
raise Exception(
name, "tried to unsubscribe during runtime (syncBarrier has",
self.__syncBarrier.n_waiting, "threads waiting)")
del self.__subscribers[name]
self.__syncBarrier = Barrier(self.__syncBarrier.parties - 1)
self.__syncLock.release()
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 __init__(self):
self.democrat_count = self.republican_count = 0
self.democrat_lock = Semaphore(0)
self.republican_lock = Semaphore(0)
self.lock = Lock()
self.barrier = Barrier(4)
self.ride_id = 0
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 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 init(self, media_player):
"""
Sets up the PiFace CAD 2 module.
:param media_player: instance of MediaPlayer class which is being controlled
:return: None
"""
self._media_player = media_player
# https://github.com/piface/pifacedigitalio/issues/27
self._listeners_barrier = Barrier(2)
self._listeners_wait_for_deactivation_thread = Thread(target=self._switch_listener_wait_for_deactivation,
args=[])
self._listeners_wait_for_deactivation_thread.setDaemon(True)
self._listeners_wait_for_deactivation_thread.start()
self._switch_listener = pifacecad.SwitchEventListener()
self._switch_listener.register(0, pifacecad.IODIR_ON,
lambda event: self._clear_and_call(media_player.prev_branch))
self._switch_listener.register(1, pifacecad.IODIR_ON,
lambda event: self._clear_and_call(media_player.next_branch))
self._switch_listener.register(2, pifacecad.IODIR_ON,
lambda event: media_player.volume_down())
self._switch_listener.register(3, pifacecad.IODIR_ON,
lambda event: media_player.volume_up())
self._switch_listener.register(5, pifacecad.IODIR_ON,
lambda event: media_player.play_pause())
self._switch_listener.register(6, pifacecad.IODIR_ON,
lambda event: self._clear_and_call(media_player.prev_track))
self._switch_listener.register(7, pifacecad.IODIR_ON,
lambda event: self._clear_and_call(media_player.next_track))
self._switch_listener.activate()
try:
self._ir_listener = pifacecad.IREventListener(self._config['NAME'])
self._ir_listener.register('play_pause', lambda event: call_and_sleep(media_player.play_pause))
self._ir_listener.register('next_track',
lambda event: call_and_sleep(self._clear_and_call, media_player.next_track))
self._ir_listener.register('prev_track',
lambda event: call_and_sleep(self._clear_and_call, media_player.prev_track))
self._ir_listener.register('next_branch',
lambda event: call_and_sleep(self._clear_and_call, media_player.next_branch))
self._ir_listener.register('prev_branch',
lambda event: call_and_sleep(self._clear_and_call, media_player.prev_branch))
self._ir_listener.register('eject', lambda event: call_and_sleep(media_player.stop))
self._ir_listener.register('volume_up', lambda event: call_and_sleep(media_player.volume_up))
self._ir_listener.register('volume_down', lambda event: call_and_sleep(media_player.volume_down))
self._ir_listener.activate()
except Exception:
print('LIRC cannot be initialized.')
self._cad.lcd.clear()
self._cad.lcd.backlight_on()
self._cad.lcd.write('Loading')
self._write_info_thread = Thread(target=self._write_info_thread_func)
self._write_info_thread.setDaemon(True)
self._write_info_thread.start()
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 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()
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 __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 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 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 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 __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 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_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 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)
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)
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)
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))
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
print(
"MPlayer wurde nicht gefunden. Bitte mit folgendem Befehl installieren: "
"'sudo apt-get install mplayer'")
sys.exit(1)
else:
raise # Something else went wrong while trying to run `mplayer`
cad = pifacecad.PiFaceCAD()
global radio
radio = Radio(cad)
radio.play()
# 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)
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):
def hibernate(self):
#If inactive put the display in waiting state
self.currentState = LCD_SM.waiting.run()
self.t.cancel()
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
# ----------------------------
cad = pifacecad.PiFaceCAD()
# Radio initialisieren
countStations = len(Stations)
radio = Radio(cad, lastStationFile, lastStationPath, countStations)
# Radio weidergabe starten
radio.play()
# listener cannot deactivate itself so we have to wait until it has finished using a barrier.
global end_barrier
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()
menus.change_menu(int(event.ir_code))
if __name__ == "__main__":
cad = pifacecad.PiFaceCAD()
global menus
menus = Menus(cad)
hexagrams = Hexagrams(cad)
display_lcd = DisplayLCD(cad)
cad.lcd.blink_off()
cad.lcd.cursor_off()
#
# 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)
for menuid in range(4):
switchlistener.register(
menuid, pifacecad.IODIR_ON, menu_select_switch)
switchlistener.register(4, pifacecad.IODIR_ON, menus.back)
switchlistener.register(5, pifacecad.IODIR_ON, menus.confirm)
switchlistener.register(6, pifacecad.IODIR_ON, menus.previous_item)
switchlistener.register(7, pifacecad.IODIR_ON, menus.next_item)
#
irlistener = pifacecad.IREventListener(
prog="i-ching-hexagrams",
lircrc="/usr/share/doc/scifipi-i-ching/ichinglircrc")
for i in range(4):
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()
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()
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()
import subprocess, time, zmq, json, sys
from threading import Thread, Barrier
def mogrify(topic, msg):
""" json encode the message and prepend the topic """
return topic + ' ' + json.dumps(msg)
ctx = zmq.Context()
sender = ctx.socket(zmq.PUB)
sender.bind('tcp://*:5557')
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()
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()
else:
# The separator could have started in the current chunk but
# finishes in the next chunk, so we need to search the
# len(separator) - 1 last bytes of the separator again
start_search_index = max(0, len(msg_bytes) - (len(separator) - 1))
self.logger.debug('<-- {}'.format(msg_bytes))
return msg_bytes
if __name__ == '__main__':
import sys
from threading import Barrier, BrokenBarrierError, Thread
start_barrier = Barrier(2, timeout=5)
end_barrier = Barrier(3, timeout=60)
separator = b'\0\1\2\1\0'
messages = [
b'abcdef',
b'1234',
b'a', b'bc', b'de\0', b'\1\2\1\0fghi',
b'xyzZYX',
b'',
b'+++',
]
def server():
logger = logging.getLogger('server')
logger.info('server starting')
server_socket = ChunkyStreamSocket(logging.getLogger('server.socket'))
