示例#1
0
class Generator():
    
    def __init__(self, configurationPath, outputQueue):
        self.processorQueue = outputQueue
        self.logger = logging.getLogger("generator")
        self.lirchandle = pylirc.init("pylirc", configurationPath, False)
        self.stopFlag = Event()

    def loop(self):
        self.logger.info("Starting up.")
        if(self.lirchandle):
            inputLirc = [self.lirchandle]
            timeout = 2
            self.logger.info("Succesfully opened lirc, handle is " + str(self.lirchandle))
            self.logger.info("Started.")
            while (not self.stopFlag.is_set()):
                inputready, outputready, exceptready = select.select(inputLirc,[],[], timeout)
                s = pylirc.nextcode(1)                    
                if(s):
                    for code in s:                        
                        repeat = code["repeat"]
                        currentCommand = code["config"]
                        self.logger.info("New event received: id: = %s, repeat = %s" % (currentCommand, repeat))
                        try:                            
                            self.processorQueue.put_nowait(GeneratorEvent(currentCommand, repeat))
                        except Queue.Full:
                            self.logger.error("Processor queue is overloaded.")                    
            self.logger.info("Shutted down.")

    def shutdown(self):
        self.logger.debug("Shutting down.")        
        self.stopFlag.set()
        pylirc.exit()        
class Async_Optimize(object):
    def __init__(self):
        self.callback = lambda *x: None
        self.runsignal = Event()
        self.SENTINEL = "SENTINEL"

    def async_callback_collect(self, q):
        while self.runsignal.is_set():
            try:
                for ret in iter(lambda: q.get(timeout=1), self.SENTINEL):
                    self.callback(*ret)
                self.runsignal.clear()
            except Empty:
                pass

    def opt_async(self, f, df, x0, callback, update_rule=PolakRibiere,
                   messages=0, maxiter=5e3, max_f_eval=15e3, gtol=1e-6,
                   report_every=10, *args, **kwargs):
        self.runsignal.set()
        c = None
        outqueue = None
        if callback:
            outqueue = Queue()
            self.callback = callback
            c = Thread(target=self.async_callback_collect, args=(outqueue,))
            c.start()
        p = _CGDAsync(f, df, x0, update_rule, self.runsignal, self.SENTINEL,
                 report_every=report_every, messages=messages, maxiter=maxiter,
                 max_f_eval=max_f_eval, gtol=gtol, outqueue=outqueue, *args, **kwargs)
        p.start()
        return p, c

    def opt(self, f, df, x0, callback=None, update_rule=FletcherReeves,
                   messages=0, maxiter=5e3, max_f_eval=15e3, gtol=1e-6,
                   report_every=10, *args, **kwargs):
        p, c = self.opt_async(f, df, x0, callback, update_rule, messages,
                            maxiter, max_f_eval, gtol,
                            report_every, *args, **kwargs)
        while self.runsignal.is_set():
            try:
                p.join(1)
                if c: c.join(1)
            except KeyboardInterrupt:
                # print "^C"
                self.runsignal.clear()
                p.join()
                if c: c.join()
        if c and c.is_alive():
#             self.runsignal.set()
#             while self.runsignal.is_set():
#                 try:
#                     c.join(.1)
#                 except KeyboardInterrupt:
#                     # print "^C"
#                     self.runsignal.clear()
#                     c.join()
            print("WARNING: callback still running, optimisation done!")
        return p.result
示例#3
0
def _process_inner(function: Callable[..., Any], log_level: str,
                   log_format: str, start_event: synchronize.Event,
                   stop_event: synchronize.Event, **kwargs: Any) -> None:
    basic_config(level=log_level, log_format=log_format)
    start_event.set()
    try:
        function(**kwargs)
    finally:
        stop_event.set()
示例#4
0
def watch_for_smtps(ready_flag: MP_Event, retq: MP.Queue):
    has_smtps = False
    ready_flag.set()
    start = time.monotonic()
    delay = AUTOSTOP_DELAY * 1.5
    while (time.monotonic() - start) <= delay:
        try:
            with SMTP_SSL("localhost", 8025, timeout=0.1) as client:
                client.ehlo("exemple.org")
                has_smtps = True
                break
        except Exception:
            time.sleep(0.05)
    retq.put(has_smtps)
示例#5
0
class ASensor(Thread):
    '''
    La classe ASensor rappresenta un sensore generico, in essa sono implementati:
    gli attributi, le configurazioni iniziali comuni a qualunque sensore.
    Ogni sensore e' uno Thread in modo tale che il suo flusso di controllo sia indipendente.
    '''


    def __init__(self, name,typeSensor,pin):
        '''
        il costruttuore accetta in ingresso:
        un nome per identificare il sensore, il tipo del sensore
        e il PIN al quale e' collegato sul Raspberry.
        
        Viene creato un oggetto di tipo Subject che rappresenta lo Stream di valori in uscita dal sensore.
        Necessario per implementare il paradigma reactive
        '''
        Thread.__init__(self, None, None, name, None, None, None)
        self.name=name
        self.typeSensor=typeSensor
        self.pin=pin
        self.flag = Event()
        self.stream=Subject()
        
    '''
    Classi che verranno implementate dai singoli sensori
    '''
    
    def getValue(self):
        pass
    
    def getName(self):
        return self.name
    
    def getType(self):
        return self.typeSensor
    
    def getPin(self):
        return self.pin
    
    def getOutputStream(self):
        return self.stream
        
    '''
    la funzione initialize configura il PIN per poterlo utilizzare.
    Questa procedura e' comune a tutti i sensori (con l'utilizzo della libreria RPi.GPIO)
    '''
     
    def stop(self):
        self.flag.set()
示例#6
0
def execute_worker(
    task_queue: Queue,
    continue_execution_flag: Value,
    i_am_done_event: EventType,
    worker_wait_for_exit_event: EventType,
) -> None:
    """Define workers work loop."""
    while True:
        if not continue_execution_flag.value:
            i_am_done_event.set()
            worker_wait_for_exit_event.wait()
        try:
            _ = task_queue.get(block=False)
            sleep(0.001)
        except Empty:
            continue
示例#7
0
class Solver(object):
    UNSOLVED = -1
    SOLVED = 0
    SOLVING = 1
    UNSOLVABLE = 2
    r"""
    @attention: Always reference the model thus: solver.model.xxx
    """
    def __init__(self, model, count=1):
        self._lock = RLock()
        self._model = model
        #    Context:
        self._abort = Event()
        self._abort.clear()
        self._solvers = Context(count, self._getModel, self._abort, self._lock)
        self._isAborted = False
    def _getModel(self):
        with self.lock():
            return self._model
    model = property(_getModel)
    def __str__(self):
        pre="Unsolved"
        with self.lock():
            if len(list(self._model.unknowns()))==0:
                pre="> SOLVED < "
            return "\n".join(["%(PRE)sSolver:"%{"PRE":pre}, str(self._model)])
    def lock(self):
        return self._lock
    def serialize(self):
        #    Retrieve the model ready for storing:
        with self.lock():
            return self._model.serialize()
    def deserialize(self, data):
        #    Load the model ready for use:
        with self.lock():
            self._model = self.model.deserialize(data)
    def clone(self):
        with self.lock():
            try:
                self.abort()
            except Aborted, _e:
                pass
            self._abort.set()
            m = self.model.clone()
            self._isAborted = False
            return Solver(m)
示例#8
0
def _handle_lock(event_in: synchronize.Event, event_out: synchronize.Event,
                 path: str) -> None:
    """
    Acquire a file lock on given path, then wait to release it. This worker is coordinated
    using events to signal when the lock should be acquired and released.
    :param multiprocessing.Event event_in: event object to signal when to release the lock
    :param multiprocessing.Event event_out: event object to signal when the lock is acquired
    :param path: the path to lock
    """
    if os.path.isdir(path):
        my_lock = lock.lock_dir(path)
    else:
        my_lock = lock.LockFile(path)
    try:
        event_out.set()
        assert event_in.wait(
            timeout=20), 'Timeout while waiting to release the lock.'
    finally:
        my_lock.release()
示例#9
0
def watch_for_tls(ready_flag: MP_Event, retq: MP.Queue):
    has_tls = False
    req_tls = False
    ready_flag.set()
    start = time.monotonic()
    delay = AUTOSTOP_DELAY * 4
    while (time.monotonic() - start) <= delay:
        try:
            with SMTPClient("localhost", 8025, timeout=0.1) as client:
                resp = client.docmd("HELP", "HELO")
                if resp == S.S530_STARTTLS_FIRST:
                    req_tls = True
                client.ehlo("exemple.org")
                if "starttls" in client.esmtp_features:
                    has_tls = True
                break
        except Exception:
            time.sleep(0.05)
    retq.put(has_tls)
    retq.put(req_tls)
示例#10
0
def execute_queries(
    worker_id: str,
    task_queue: Queue,
    connection_pool: pool,
    continue_execution_flag: Value,
    database_id: str,
    i_am_done_event: EventType,
    worker_wait_for_exit_event: EventType,
) -> None:
    """Define workers work loop."""
    with PoolCursor(connection_pool) as cur:
        with StorageCursor(STORAGE_HOST, STORAGE_PORT, STORAGE_USER,
                           STORAGE_PASSWORD, database_id) as log:
            succesful_queries: List[Tuple[int, int, str, str, str]] = []
            failed_queries: List[Tuple[int, str, str, str]] = []
            last_batched = time_ns()
            while True:
                if not continue_execution_flag.value:
                    i_am_done_event.set()
                    worker_wait_for_exit_event.wait()

                try:
                    task: Tuple[str, Tuple[Tuple[Union[str, int],
                                                 Optional[str]], ...], str,
                                str] = task_queue.get(block=False)
                    query, not_formatted_parameters, workload_type, query_type = task
                    query = query.replace("[STREAM_ID]", str(worker_id))
                    formatted_parameters = get_formatted_parameters(
                        not_formatted_parameters)
                    endts, latency = execute_task(cur, query,
                                                  formatted_parameters)
                    succesful_queries.append(
                        (endts, latency, workload_type, query_type, worker_id))
                except Empty:
                    continue
                except (ValueError, Error) as e:
                    failed_queries.append(
                        (time_ns(), worker_id, str(task), str(e)))

                last_batched = log_results(log, last_batched,
                                           succesful_queries, failed_queries)
示例#11
0
class PagedResultHandler(object):

    def __init__(self, future):
        self.error = None
        self.finished_event = Event()
        self.future = future
        self.future.add_callbacks(
            callback=self.handle_page,
            errback=self.handle_error)
        self.res = set()

    def handle_page(self, results):
        
        for row in results:            
            self.res.add(row[0])

        if self.future.has_more_pages:
            self.future.start_fetching_next_page()
        else:
            self.finished_event.set()

    def handle_error(self, exc):
        self.error = exc
        self.finished_event.set()
示例#12
0
class Async_Optimize(object):
    def __init__(self):
        self.callback = lambda *x: None
        self.runsignal = Event()
        self.SENTINEL = "SENTINEL"

    def async_callback_collect(self, q):
        while self.runsignal.is_set():
            try:
                for ret in iter(lambda: q.get(timeout=1), self.SENTINEL):
                    self.callback(*ret)
                self.runsignal.clear()
            except Empty:
                pass

    def opt_async(self,
                  f,
                  df,
                  x0,
                  callback,
                  update_rule=PolakRibiere,
                  messages=0,
                  maxiter=5e3,
                  max_f_eval=15e3,
                  gtol=1e-6,
                  report_every=10,
                  *args,
                  **kwargs):
        self.runsignal.set()
        c = None
        outqueue = None
        if callback:
            outqueue = Queue()
            self.callback = callback
            c = Thread(target=self.async_callback_collect, args=(outqueue, ))
            c.start()
        p = _CGDAsync(f,
                      df,
                      x0,
                      update_rule,
                      self.runsignal,
                      self.SENTINEL,
                      report_every=report_every,
                      messages=messages,
                      maxiter=maxiter,
                      max_f_eval=max_f_eval,
                      gtol=gtol,
                      outqueue=outqueue,
                      *args,
                      **kwargs)
        p.start()
        return p, c

    def opt(self,
            f,
            df,
            x0,
            callback=None,
            update_rule=FletcherReeves,
            messages=0,
            maxiter=5e3,
            max_f_eval=15e3,
            gtol=1e-6,
            report_every=10,
            *args,
            **kwargs):
        p, c = self.opt_async(f, df, x0, callback, update_rule, messages,
                              maxiter, max_f_eval, gtol, report_every, *args,
                              **kwargs)
        while self.runsignal.is_set():
            try:
                p.join(1)
                if c: c.join(1)
            except KeyboardInterrupt:
                # print "^C"
                self.runsignal.clear()
                p.join()
                if c: c.join()
        if c and c.is_alive():
            #             self.runsignal.set()
            #             while self.runsignal.is_set():
            #                 try:
            #                     c.join(.1)
            #                 except KeyboardInterrupt:
            #                     # print "^C"
            #                     self.runsignal.clear()
            #                     c.join()
            print("WARNING: callback still running, optimisation done!")
        return p.result