def response(progress): if progress >= 85: if not self.isReady: self.isReady = True self.torApp.on_ready() return #TODO: handle the case where we get here with <80% progress. What then? Can it even happen? elif progress >= 80: #start a thread to periodically try launching circuits to random routers: self.startup_circuits = [] Scheduler.schedule_repeat(2, self.try_new_circuit)
def start(self): """Delete the old logs and open the new ones""" if ProgramState.PY2EXE: #these redirect output, to avoid writing to the Main.exe.log (default py2exe behavior) #we want to avoid that because it pops a dialog about errors, and we definitely want to fail silently when demoing the app... sys.stdout = open(os.path.join(Globals.LOG_FOLDER, 'stdout.out'), "w") sys.stderr = open(os.path.join(Globals.LOG_FOLDER, 'stderr.out'), "w") #remove the old tor logs: Files.delete_file(os.path.join(Globals.LOG_FOLDER, 'tor.out'), True) #open up the debug logs and create the testfile: self.start_logs(["main", "errors", "automated", "pysocks", "tor_conn"], "main", Globals.LOG_FOLDER) #rotate the logs every half an hour, so that they can have lots of info, but not fill someone's hard drive... Scheduler.schedule_repeat(30 * 60, self.rotate_logs)
def _on_bank_ready(self, result): """Called when the bank has finished starting. Alerts the applications to any startup arguments that were passed in, which will likely cause them to actually start.""" if result != True: log_msg("Bank failed to start correctly!", 0) return result #handle the starting arguments: Startup.handle_args(ProgramState.STARTING_DIR, sys.argv[1:]) GlobalEvents.throw_event("startup") #if this is the first run, save all the settings files: if self.bbApp.isFirstRun: for app in [self.bbApp, self.btApp, self.torApp, self.ffApp]: if app: app.settings.save() self.coreSettings.save() #schedule update function: def do_update(): BWHistory.update_all() return True ProgramState.DO_UPDATES = True self.updateEvent = Scheduler.schedule_repeat(Globals.INTERVAL_BETWEEN_UPDATES, do_update) return result
def start_connections(self, list): peers_added = 0 #add to our current list except duplicates: for peer in list: if self.to_connect.count(peer) == 0: if self.prev_connected.count(peer) == 0: self.never_connected.append(peer) peers_added += 1 else: self.to_connect.append(peer) peers_added += 1 log_msg("Added %s to our list of peers, now %s long." % (peers_added, len(self.to_connect)), 2, "tracker") #without this, the peers would be each get connected to twice on the very first update if they fail if self.lastPeerCycleTime == 0: self.lastPeerCycleTime = time.time() #for testing: sometimes handy to print out peers so I can make sure we can connect to them later #f = open("peer_list.txt", "wb") #for x in list: # dns, id, encrypted = x # #log_msg("%s %s (%s)" % (encrypted, dns, id)) # f.write("%s:%s\n" % (dns[0], dns[1])) #f.close() #make sure we're starting connections from that list: if not self.startConnectionsEvent: self.startConnectionsEvent = Scheduler.schedule_repeat(1.0, self._start_connection_from_queue) self._start_connection_from_queue()
def _start_test(self, widget=None): self.torApp.start_server() for box in (self.relayBox, self.dirBox, self.dhtBox): box.apply_value() self.torApp.settings.on_apply(self.torApp, "") self._cancel_test_update() self.testUpdateEvent = Scheduler.schedule_repeat(0.1, self._test_update) #update the title to reflect the fact that we are currently testing self._on_test_started()
def _check_apps(self): if not self.programCheckEvent: self.programCheckEvent = Scheduler.schedule_repeat(1.0, self._check_apps) #program still running? if self.currentApp and self.currentApp.poll() == None: log_msg("Waiting for UAC app to finish...", 1) return True #are there any more to launch? if len(self.launchList) > 0: #launch the next one: cmd, nextDeferred = self.launchList.pop(0) log_msg("Launching next UAC app: %s" % (cmd), 1) self.currentApp = LaunchProcess.LaunchProcess(cmd) process = Process.Process(self.currentApp.pid) process.d.chainDeferred(nextDeferred) return True #nothing else to launch: else: log_msg("No more UAC apps to launch.", 1) self.programCheckEvent = None return False
def do_expose_event(self, event): #schedule the draw event if this is the first time we've ever been exposed if not self.shouldDraw: self.shouldDraw = True Scheduler.schedule_repeat(1.0, self.draw) self.visible_cb() #Create the cairo context self.cr = self.window.cairo_create() #Restrict Cairo to the exposed area; avoid extra work self.cr.rectangle(event.area.x, event.area.y, event.area.width, event.area.height) self.cr.clip() width, height = self.window.get_size() cr = self.cr cr.set_source_rgb(*self.cFill) cr.rectangle(0, 0, width, height) cr.fill() #figure out the scale mapping between values and pixels: maxYVal = self.maxVal maxValueText, maxValueUnits = Format.bytes_per_second(maxYVal).split(" ") x_bearing, y_bearing, w, h = cr.text_extents(maxValueText)[:4] xStart = w + self.PADDING_LEFT + self.PADDING_AXIS xEnd = width - self.PADDING_RIGHT xStepSize = float(xEnd - xStart) / float(self.NUM_VALUES) x_bearing, y_bearing, w, h = cr.text_extents("100MB/s")[:4] bottomY = height - (self.PADDING_BOTTOM + h + self.PADDING_AXIS) yScale = float(bottomY - self.PADDING_TOP) / float(maxYVal) #shade enclosed rectangle white cr.set_source_rgb(self.cInnerShade[0], self.cInnerShade[1], self.cInnerShade[2]) cr.rectangle(xStart, self.PADDING_TOP, width-self.PADDING_RIGHT-xStart, bottomY-self.PADDING_TOP) cr.fill() #labels cr.set_line_width(0.6) cr.set_font_size(self.FONT_SIZE) #vertical lines: numLines = self.NUM_VERT_LINES cr.set_source_rgb(self.cLines[0], self.cLines[1], self.cLines[2]) if self.xMiddleTics: numLines = (numLines * (self.xMiddleTics+1)) for i in range(0, numLines + 1): if self.xMiddleTics: if i % (1+self.xMiddleTics) == 0: cr.set_line_width(0.6) else: cr.set_line_width(0.2) s = (self.NUM_VALUES / numLines) * i #should be a dark color... x = xStart + int(xStepSize * s) cr.move_to(x, self.PADDING_TOP) cr.line_to(x, bottomY) cr.stroke() x_bearing, y_bearing, w, h = cr.text_extents("Time (1 second step)")[:4] yPos = bottomY + self.PADDING_AXIS + h - self.lineWidth #make left label: cr.move_to(xStart, yPos) cr.show_text("Time (1 second step)") #middle label: x_bearing, y_bearing, w, h = cr.text_extents("Grid: 10 seconds")[:4] cr.move_to((xStart+xEnd)/2 - w/2, yPos) cr.show_text("Grid: 10 seconds") #make right label: x_bearing, y_bearing, w, h = cr.text_extents("Now")[:4] cr.move_to(xEnd-w, yPos) cr.show_text("Now") #horizontal lines: cr.set_source_rgb(self.cLines[0], self.cLines[1], self.cLines[2]) numLines = self.NUM_HORIZ_LINES if self.yMiddleTics: numLines = (numLines * (self.yMiddleTics+1)) j = 0 for i in range(0,maxYVal+1,maxYVal/numLines): if self.yMiddleTics: if j % (1+self.yMiddleTics) == 0: cr.set_line_width(0.6) else: cr.set_line_width(0.2) j += 1 #should be a dark color... y = bottomY - int(yScale * i) cr.move_to(xEnd, y) cr.line_to(xStart, y) cr.stroke() #make top label: x_bearing, y_bearing, w, h = cr.text_extents("0")[:4] cr.move_to(self.PADDING_LEFT, self.PADDING_TOP+h) cr.show_text(maxValueText) #middle label: self.cr.rotate(-1*math.pi / 2.0) x_bearing, y_bearing, w, h = cr.text_extents(maxValueUnits)[:4] cr.move_to(-1 * height / 2.0 - w/2 + self.PADDING_TOP, self.PADDING_LEFT + h + 2) cr.show_text(maxValueUnits) self.cr.rotate(math.pi / 2.0) #make bottom label: x_bearing, y_bearing, w, h = cr.text_extents("0")[:4] cr.move_to(xStart-self.PADDING_AXIS-w, bottomY) cr.show_text("0") #draw the data lines on the graph: for sourceVals in (self.dataSource.bytesRead, self.dataSource.bytesWritten): # Set properties for the line (different colors for read and written) if sourceVals == self.dataSource.bytesWritten: cr.set_source_rgb(self.cWritten[0], self.cWritten[1], self.cWritten[2]) else: cr.set_source_rgb(self.cRead[0], self.cRead[1], self.cRead[2]) cr.set_line_width(self.lineWidth) #for every bw value, vals = sourceVals[len(sourceVals)-self.NUM_VALUES:] for i in range(0, len(vals)-1): #draw a line segment: startX = xStart + int(xStepSize * i) endX = xStart + int(xStepSize * (i+1)) y1 = bottomY - (vals[i] * yScale) y2 = bottomY - (vals[i+1] * yScale) cr.move_to(startX, y1) cr.line_to(endX, y2) #Apply the ink cr.stroke() #update the maximum y value and scale for next time: newMax = 0 for v in vals: if v > newMax: newMax = v #double the scale until we contain the max value: while newMax > self.maxVal: self.maxVal *= 2 else: if newMax < self.maxVal / 2: self.scale_too_big += 1 else: self.scale_too_big = 0 #if the scale has been too big for more than 5 ticks, make it smaller if self.scale_too_big > 5: #dont go below the original axis value: if self.maxVal > 32 * 1024: self.maxVal /= 2
def start(self): self.check_for_updates() Scheduler.schedule_repeat(60 * 60 * 12, self.check_for_updates)
if controller: controller.prompt_about_port(portNum, successFunc) else: log_msg("no gui controller yet to prompt_about_port", 2) return successFunc() def add_updater(obj): def update(): if ProgramState.DO_UPDATES: try: obj.on_update() except Exception, error: log_ex(error, "During update for %s" % (obj)) return True Scheduler.schedule_repeat(Globals.INTERVAL_BETWEEN_UPDATES, update) def get_image_file(imageName): """Given the name of an image, return the filename for the image data""" return os.path.join(Globals.DATA_DIR, unicode(imageName)) def create_error_archive(description): logs = ["main.out", "errors.out", "stderr.out", "tor.out", "tor_conn.out", "tor_conn.out.old", "log.out.old"] zipFile = zipfile.ZipFile(Globals.BUG_REPORT_NAME, "w") MAX_SIZE = 2 * 1024L * 1024L for log in logs: #write the file log with name log logName = os.path.join(Globals.LOG_FOLDER, log) if Files.file_exists(logName): fileSize = os.path.getsize(logName) if fileSize > MAX_SIZE:
else: log_msg("no gui controller yet to prompt_about_port", 2) return successFunc() def add_updater(obj): def update(): if ProgramState.DO_UPDATES: try: obj.on_update() except Exception, error: log_ex(error, "During update for %s" % (obj)) return True Scheduler.schedule_repeat(Globals.INTERVAL_BETWEEN_UPDATES, update) def get_image_file(imageName): """Given the name of an image, return the filename for the image data""" return os.path.join(Globals.DATA_DIR, unicode(imageName)) def create_error_archive(description): logs = [ "main.out", "errors.out", "stderr.out", "tor.out", "tor_conn.out", "tor_conn.out.old", "log.out.old" ] zipFile = zipfile.ZipFile(Globals.BUG_REPORT_NAME, "w") MAX_SIZE = 2 * 1024L * 1024L for log in logs:
def __init__(self, config, Output, isAnonymous): try: self.config = config self.Output = Output self.torrent_dir = config['torrent_dir'] self.torrent_cache = {} self.file_cache = {} self.blocked_files = {} self.scan_period = config['parse_dir_interval'] self.stats_period = config['display_interval'] self.torrent_list = [] self.downloads = {} self.counter = 0 self.doneflag = Event() self.hashcheck_queue = [] self.hashcheck_current = None self.rawserver = JashRawServer() upnp_type = UPnP_test(config['upnp_nat_access']) self.listen_port = None while True: try: self.listen_port = self.rawserver.find_and_bind( config['minport'], config['maxport'], config['bind'], ipv6_socket_style=config['ipv6_binds_v4'], upnp=upnp_type, randomizer=config['random_port']) break except socketerror, e: if upnp_type and e == UPnP_ERROR: log_msg('WARNING: COULD NOT FORWARD VIA UPnP', 0) upnp_type = 0 continue self.failed("Couldn't listen - " + str(e)) return self.dht = None if isAnonymous: self.dht = dht.Proxy.DHTProxy( BitTorrent.BitTorrentClient.get()) else: if self.listen_port: self.dht = dht.Node.LocalDHTNode(self.listen_port, config['dht_file_name']) self.ratelimiter = RateLimiter(self.rawserver.add_task, config['upload_unit_size']) self.ratelimiter.set_upload_rate(config['max_upload_rate']) self.handler = MultiHandler(self.rawserver, self.doneflag, config) seed(createPeerID()) #self.rawserver.add_task(self.scan, 0) if self.scan_period: self.scan() self.scanEvent = Scheduler.schedule_repeat( self.scan_period, self.scan) else: self.scanEvent = None
def icon_menu_cb(self, status_icon, button, activate_time): """creates a drop down menu on the system tray icon when right clicked hopefully pay attention: both the popup menu and the menu list are passed to the trigger, which adds to both with new menuitems""" if self.popupMenu: self.popupMenu.destroy() self.popupMenu = gtk.Menu() self.allMenus = [] #note, popupMenu and menus are changed externally.... self._trigger_event("popup", self.popupMenu, self.allMenus) self.popupMenu.show() self.popupMenu.popup(None, None, None, button, activate_time) # self.popupMenu.connect("selection-done", self._recursive_menu_activate) def on_click(menu, event, popupMenu): if popupMenu != self.popupMenu: return log_msg("clicked %s %s" % (event.x, event.y), 4) if self.bestWidget: self.bestWidget.emit("activate") else: children = menu.get_children() if len(children) > 0: children[0].emit("activate") self._hide_popup_menu() return True # def debugprint(widget, eventName): # log_msg(eventName) for menuItem in self.popupMenu.get_children(): # for eventName in ("activate", "activate-item"): # menuItem.connect(eventName, debugprint, eventName) submenu = menuItem.get_submenu() if submenu: self.popupMenu.window.set_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.ENTER_NOTIFY_MASK | gtk.gdk.LEAVE_NOTIFY_MASK | gtk.gdk.EXPOSURE_MASK | gtk.gdk.STRUCTURE_MASK) submenu.connect('button_press_event', on_click, self.popupMenu) # for eventName in ("activate-current", "selection-done"): # submenu.connect(eventName, debugprint, eventName) # self.popupMenu.window.set_events(gtk.gdk.BUTTON_PRESS_MASK) # for eventName in ("activate-current", "selection-done"): # self.popupMenu.connect(eventName, debugprint, "parent"+eventName) # self.popupMenu.connect('button_press_event', on_click) self.bestWidget = None self.isHoveringOverMenu = False self.lastHoveredOverMenu = time.time() # self.popupMenu.window.raise_() # self.popupMenu.window.set_accept_focus(True) ## self.popupMenu.window.focus() # self.popupMenu.window.set_modal_hint(True) #need to kill the popup when the mouse leaves... menus was populated in the triggered events self.allMenus.append(self.popupMenu) for menu in self.allMenus: menu.connect("enter_notify_event", self._on_hover_over_menu) menu.connect("leave_notify_event", self._on_leave_menu) if menu != self.popupMenu: for child in menu.get_children(): child.connect("enter_notify_event", self._on_hover_over_widget) child.connect("leave_notify_event", self._on_leave_widget) Scheduler.schedule_repeat(0.1, self._fade_out_window)
def connectionMade(self): self.bytesLeft = 2 * 1024 * 1024 self.transport.write(struct.pack("!I", self.bytesLeft)) self.sendEvent = Scheduler.schedule_repeat(0.1, self.send_more, 1024 * 10)
if acoin.is_fresh(self.currentACoinInterval): addFunc(acoin) else: log_msg("Dropped an expired acoin from %s interval because we are at %s." % \ (acoin.interval,self.currentACoinInterval), 1) f.close() assert not self.ACoins, "must not load coins more than once?" read(self.ACOIN_FILE_NAME, self.add_acoin) assert not self.depositingACoins, "cannot deposit coins while loading?" read(self.DEPOSITED_FILE_NAME, self.depositingACoins.append) except Exception, e: log_ex(e, "Failed to load coins from disk") #schedule the event to save the coins, now that they are loaded #TODO: make this save way less often, this is just for debugging self.updateEvent = Scheduler.schedule_repeat(10, self.update_coins) def save_coins(self): """This function is called periodically. It checks if any coins have been added or removed from our collections, and if so, stores them back to disk.""" #if there have been any changes to our coins recently: if self.coinsChanged: #TODO: properly deal with various filesystem errors--permissions, etc :-/ try: def write(unicodeFileName, coins): fileName = System.encode_for_filesystem(unicodeFileName) #do not overwrite existing until we're sure the whole file has been output newFileName = fileName + ".new" f = open(newFileName, "wb") msg = ""