def text_handler(update, context):
tgid = update.message.from_user.id
if not tgid in config.kernel_dict:
update.message.reply_text('Kernel not running, please use command /start')
else:
(km, cl, t, kernel) = config.kernel_dict[tgid]
if not km.is_alive():
update.message.reply_text('Kernel not running, please use command /restart')
else:
t.cancel()
t = Timer(config.timer_value, stop_kernel, [tgid])
t.start()
config.kernel_dict[tgid] = (km, cl, t, kernel)
li = Listener(kernel)
try:
timeout = 5.0
if kernel == 'octave' and update.message.text[:11] == 'pkg install':
timeout = 60.0
reply = cl.execute_interactive(update.message.text, allow_stdin=False,
timeout=timeout, output_hook=li.output_cb)
except TimeoutError:
context.bot.send_message( chat_id=update.message.chat_id, text='Timeout waiting for reply' )
if li.text:
text = li.escape_ansi_text()
if len(text) <= 4096:
context.bot.send_message( chat_id=update.message.chat_id, text=text )
else:
context.bot.send_message( chat_id=update.message.chat_id, text=text[:4092]+'\n...' )
if li.img_data:
image = base64.b64decode(li.img_data)
bio = BytesIO()
bio.name = 'image.png'
bio.write(image)
bio.seek(0)
context.bot.send_photo(chat_id=update.message.chat_id, photo=bio)
def __init__(s, master, todo):
#Dane:
Listener.__init__(s)
s.__master = master
s.__todo = todo
#Definicje:
s.__draw()
s.listen2(todo)
def rec(url):
l = Listener(url)
m = Monitor(l)
print('start')
while True:
if l.DetectLiveStream():
m.Record()
time.sleep(120)
def __init__(self,manager,world=None):
eventTypes = [Event.UpdateEvent,Event.NewPlayerEvent,Event.GameLoadedEvent]
Listener.__init__(self,manager,eventTypes)
self.creator = Creator()
#self.worldList = []
self.worldIDToWorld = {}
self.entityIDToEntity = {}
self.activeWorld = world
def set_threads(self, manager):
self.ts = Sender(self.client.multicast_addr, self.client.port,
self.client.pvt_port)
self.ts.start()
self.tr = Receiver(self.client.multicast_addr, self.client.port,
manager)
self.tr.start()
self.trp = Receiver_pvt(manager)
self.trp.start()
self.tl = Listener(manager)
self.tl.start()
def __init__(self,manager,world,networked=True,gameClientID=None):
# registers the WorldManipulator as a Listener for the given
# events with the event manager.
eventTypes = [ Event.EventExecutionEvent,Event.WorldManipulationEvent,Event.StartedEvent,Event.LoadGameEvent,Event.GameLoadedEvent]
Listener.__init__(self,manager,eventTypes)
self.networked=networked
self.world=world
self.gameClientID = gameClientID
print 'WorldManipulator thinks the gameID is',gameClientID
def __init__(s,C,note):
#Dane:
Listener.__init__(s)
s.__C=C
s.__note=note
s.__tag=s.__genTag()
s.__font=Font(family="Monaco",size=14)
#Definicje:
s.__draw()
s.__bind()
s.listen2(note)
def __init__(self, username="******", plugin=False, live_debug=False):
start = time.time()
self.debug = debug(live_debug=live_debug)
self.debug.addEvent("Starting DOC...", "SYSTEM")
self.debug.addEvent("Create Variables...", "SYSTEM")
# init names
self.username = username
self.user = "******" + self.username
self.plugin = "PLUGIN"
self.consoleGeneral = "CONSOLE"
self.system = "SYSTEM"
self.consoleGeneral = "CONSOLE"
self.consoleInput = "CONSOLE IN"
self.consoleOutput = "CONSOLE OUT"
self.installed = []
instance = self
self.debug.addEvent("Create Variables...Finished", self.system)
self.debug.addEvent("Listener Build...", self.system)
self.Listener = Listener()
self.Listener.ConsoleStart()
self.debug.addEvent("Listener Build... Finished", self.system)
self.debug.addEvent("Interpret Build...", self.system)
self.interpret = interpret(instance)
self.debug.addEvent("Interpret Build... Finished", self.system)
self.pluginMode = plugin
if self.pluginMode == True:
self.sender = self.plugin
elif __name__ == "system":
self.sender = self.system
else:
self.sender = self.user
self.debug.addEvent("Starting DOC... Finished", self.system)
stop = time.time()
starttime = round((stop - start) * 1000) / 1000
if starttime < 1:
starttime = "under 1"
self.debug.addEvent("DOC started in " + str(starttime) + " second(s)", self.system)
def __init__(self, op, caption, post_id, file_format, addr):
self.likes = 0
self.op = op
self.caption = caption
self.id = post_id
self.liked_by = []
self.file_format = file_format
self.link = 'users/' + str(int(post_id / lpn)) + '/' + str(
post_id % lpn) + '.' + self.file_format
self.list_sock = None
listener = Listener(self.link, addr, self)
listener.start()
def __init__(self):
LogImplementer.__init__(self)
Thread.__init__(self)
self.listener = Listener(self.incomingMessages)
self.createReceiverCallbacks()
assert (self.callbackDict is not None
), f'Failed to create dictionary for callback functions!'
self.initiaterFactory = InitiatorFactory()
self.receiverFactory = ReceiverFactory(self.callbackDict)
self.setName('Net-Man Thread')
def __init__(self):
speaker = Speaker()
listener = Listener()
self.target = speaker.data # target
self.dense_rep_target = speaker.data_encoder(self.target) # dense representation of target
self.message = speaker.dense2message(self.dense_rep_target) # message
self.all_candidate = listener.data # all candidates
self.dense_rep_candidates = listener.data_encoder(self.all_candidate) # dense representation of all candidate
self.encoded_message = listener.message2dense(self.message) # encoded message
# sample from Gibbs
self.likelihoods = tf.nn.softmax(tf.matmul(z, tf.transpose(self.dense_rep_candidate))) # Gibbs distribution of dot product of z and u in U
self.dist = tf.distributions.Categorical(probs=self.likelihoods)
self.prediction = self.dist.sample(1) # sample from Gibbs distribution to get target picked
self.loss = (self.target == self.prediction)
def __init__(self,manager,clientID):
eventTypes = [Event.NotificationEvent, Event.ResourceChangeEvent,
Event.EntityFocusEvent, Event.SelectedEntityEvent]
Listener.__init__(self,manager,eventTypes)
self.descBox = DescriptionBox()
self.resourceBar = ResourceBar((811,0))
self.selectedUnitBar = SelectedUnitBar()
self.clientID = clientID
#self.infoRect=pygame.Rect((0,20), (self.size[0], self.size[1]-20))
self.note=NotificationList()
async def process_file(self, file_path):
print('processing {}'.format(file_path))
listener_output = Listener.read_wav_file(file_path)
print('Listening completed')
dispatcher_output = Dispatcher.offline(listener_output, self.config)
print('Dispatching completed')
return dispatcher_output
def __init__(self,manager,world,clientID):
eventTypes = [ Event.RenderEvent, Event.MouseMovedEvent, \
Event.SelectionEvent, Event.SingleAddSelectionEvent, \
Event.InitiateActionEvent, \
Event.UpdateEvent, Event.WorldChangeEvent, \
Event.DisplaySurfaceCreatedEvent, Event.CompleteActionEvent, \
Event.DragBeganEvent, Event.DragEvent, \
Event.DragCompletedEvent, Event.AddDragCompletedEvent, \
Event.NumberKeyPressEvent, Event.GameOverEvent]
Listener.__init__(self,manager,eventTypes)
self.activeOverlay = None
self.activeWorld = world
self.activeScreen = None
self.debugOverlay = None
self.clientID = clientID
self.TEST_interface()
def __init__(self, query):
self.query = query
self.tokens = json.load(
open('./api/tokens.json',
'rb')) #This is dangerous, need to use better relative paths
self.consumer_key = self.tokens['twitter']['consumer-key']
self.consumer_secret = self.tokens['twitter']['consumer-secret']
self.access_token = self.tokens['twitter']['oauth-token']
self.access_token_secret = self.tokens['twitter']['oauth-secret']
self.auth = tweepy.OAuthHandler(self.consumer_key,
self.consumer_secret)
self.auth.set_access_token(self.access_token, self.access_token_secret)
self.stream = tweepy.Stream(
self.auth,
Listener('blank' if not self.query else '-'.join(self.query)))
print 'Streaming started...'
try:
self.stream.filter(track=self.query, languages=['en'])
except AttributeError as inst:
print inst
self.stream.disconnect()
except:
print 'here'
def appStarted(self):
# Citation: this is a modified version of image from user BENL at link
# https://www.chiefdelphi.com/t/top-down-orthographic-view-of-frcs-2019-playing-field/335397/9
self._fieldImage = self.loadImage("Skills-field.png")
self.fieldImageScaled = ImageTk.PhotoImage(self._fieldImage)
self._robotImage = self.scaleImage(self.loadImage("robot-blue2.png"),
0.57)
self._WAYPOINT_RADIUS = 30
self.setAppDims()
self.resetUserInputs()
self.FIELD_REAL_WIDTH = 9.2 # meters
self.FIELD_REAL_HEIGHT = 4.6 # 16.46
self.timerDelay = 30 # milliseconds
self.waypoints = []
self.robot = RobotModel(1.0, 1.0, 0.0)
self.time = 0.0
self.listener = Listener()
self.UPDATE_RATE = 100
# odometryThread = threading.Thread(
# target=self.odometryPeriodic, daemon=True)
# odometryThread.start()
self.logger = Logger()
self.logger.registerLoggerDict(self.robot.logDict, "robot")
# self.logger.registerLoggerDict(self.controls.logDict, "controls")
yAxes = [
self.logger.dict["robot.heading"], self.logger.dict["robot.vel"]
]
self.graph = StackedTimeGraph(self.logger.time, yAxes,
(self.fieldImageWidth, self.width),
(self.height, 0))
def main(argv):
inp = FileStream(argv[1])
lexer = TinyLexer(inp)
token_stream = CommonTokenStream(lexer)
parser = TinyParser(token_stream)
listener = Listener()
tree = parser.program()
walker = ParseTreeWalker().walk(listener, tree)
lines = []
assembly_code = listener.assembly_code
for i in range(len(assembly_code)):
while assembly_code[i]:
line = assembly_code[i].pop()
l = convert(line)
assert isinstance(l, list)
assert len(l) == 2
lines.append(l[0])
if l[1]:
lines.append(l[1])
for xyz in lines:
print(xyz)
print("sys halt")
def startListener(self):
"""
Starts a listener for incoming remote messages. The method will refuse
to create a listener if there is already one
"""
if not self.listener:
self.mylogger.info("Starting listener")
self.listener = Listener(self.httpTree, self.myconfig)
self.listener.start()
else:
msg = "Refusing to start listener (there is already one)."
self.mylogger.info(msg)
def main(argv):
inp = FileStream(argv[1])
lexer = TinyLexer(inp)
token_stream = CommonTokenStream(lexer)
parser = TinyParser(token_stream)
listener = Listener()
tree = parser.program()
walker = ParseTreeWalker().walk(listener, tree)
tables = listener.get_symbol_table()
for t in tables:
print("Symbol table %s" % t.name)
for k, v in t.symbols.items():
if v[1]:
print("name %s type %s value %s" % (k, v[0], v[1]))
else:
print("name %s type %s" % (k, v[0]))
print("")
def start_listener(self):
'''
Creates a new thread listening for an upstream
connection from the ground station.
'''
listenerThread = Listener(self.recievedQueue)
listenerThread.setName('ISRU Listener')
listenerThread.start()
return listenerThread
async def replay_server(sockets, protocol, nursery):
print("Testing", protocol)
print(str(sockets))
try:
for service in sockets:
port = service.port
print("Port", port)
self.processList[port] = Listener(
port,
service,
protocol,
self.config.response_delay,
nursery,
)
nursery.start_soon(self.processList[port].handler)
except Exception as ex:
print("Replay_server exception", str(ex))
def start_watching (connection, configuration, utils): # Watchdog initialtion observer = Observer() observer.schedule(Listener(connection, configuration, utils), configuration.watch_dir, recursive=True) observer.start() print(Back.GREEN + Fore.BLACK + 'LemonSync is listening to changes for ' + connection["theme"] + ' in ' + configuration.watch_dir + Style.RESET_ALL) try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join() return
def main(self):
self.twweeterObj = Twweeter()
self.listenerObj = Listener(self.twweeterObj)
self.check_data_dir_exists()
print(('Press 99 to quit the Application'))
while True:
option = input('Enter \'twweet\' or \'get\' or \'edit\': ')
if option == '99':
break
if option == 'twweet':
tweet = input('Enter your twweet\n')
self.twweeterObj.api.update_status(status=tweet)
# Yes, tweet is called 'status' rather confusing
elif option == 'get':
check = True
while check:
check = self.home_select_action()
elif option == 'edit':
self.twweeterObj.createCreds()
else:
print(('Please choose any of the above options \n \n'))
class ClientApp(tk.Tk):
def __init__(self, download_dir, source_dir):
self.download_dir = download_dir
tk.Tk.__init__(self)
self.title("Torrent Sucks")
self.geometry("500x500+300+100")
self.resizable(False, True)
self.config(bg="#474040")
self.frame = tk.Frame(self, bg='#474040')
self.frame.pack(side=tk.TOP, fill=tk.BOTH)
self.search_bar = PlaceholderEntry(self.frame,
"Please Enter the Filename",
width=50)
self.search_bar.pack(side=tk.LEFT, pady=20, padx=20)
self.search_button = FocusButton(self.frame,
text="Search",
in_color="gray",
out_color="black",
fg="white",
command=self.search)
self.search_button.pack(side=tk.RIGHT, padx=20, pady=20)
self.listbox_frame = tk.Frame(self, bg="#474040")
self.listbox_frame.pack(side=tk.TOP, fill=tk.BOTH)
self.listbox = tk.Listbox(self.listbox_frame, width=70, height=20)
self.listbox.pack(side=tk.TOP, pady=20, padx=20)
self.download_button = FocusButton(self.listbox_frame,
text="Download",
in_color="#52bf9c",
out_color="#6ed1ff",
fg="black",
command=self.download)
self.download_button.pack(side=tk.RIGHT, pady=20, padx=20)
self.status_text = tk.Label(self.listbox_frame,
text="",
bg="#474040",
font='Helvetica 10 bold')
self.status_text.pack(side=tk.LEFT, pady=20, padx=20)
#Start listener
global host
self.listener = Listener(host, source_dir)
self.host, self.port = self.listener.get_self()
print("Running On: {}:{}".format(self.host, self.port))
self.listen_thread = multiprocessing.Process(
target=self.listener.listen)
self.listen_thread.start()
self.protocol("WM_DELETE_WINDOW", self.on_closing)
self.search_file = ""
#Start Sender
self.sender = Sender(source_dir, self.host, self.port)
global ft_server
#Uncomment this if server is on
print("Connecting to Server...")
# print(ft_server[0])
# print(ft_server[1])
status = self.sender.start_conn(ft_server[0], ft_server[1])
if (status == 0):
tkinter.messagebox.showerror(
title="Error",
message=
"Couldn't correctly connect to FT server!\nCheck the ip configuration in Client.py, and restart the app!"
)
# If server is not ready this will say "Could not connect to server"
def search(self):
filename = self.search_bar.get().strip()
self.search_file = filename
self.listbox.delete(0, tk.END)
succ, status_message = self.sender.search(filename)
if not succ:
self.status_text.configure(text=status_message, fg="red")
else:
self.status_text.configure(text="")
for result in self.sender.get_results():
self.listbox.insert(tk.END, result.strip())
def download(self):
#<jpg, 54280, 07/30/2018, 127.0.0.1, 55682>
data = self.listbox.get(tk.ACTIVE).strip()[1:-1].split(',')
data = list(map(lambda str: str.strip(), data))
status_message = "Nothing happened"
status_color = "gray"
if (len(data) != 5):
status_message = "Failed to download data format is not correct!"
status_color = "red"
else:
req_file = {
"name": self.search_file, #self.search_bar.get().strip()
"type": data[0],
"size": int(data[1]),
"date": data[2],
"ip": data[3],
"port": int(data[4]),
"dir": self.download_dir
}
succ, status_message = download_handler(req_file)
if (succ):
status_color = "green"
else:
status_color = "red"
self.status_text.configure(text=status_message, fg=status_color)
def on_closing(self):
print("Closing!")
self.sender.close()
self.listen_thread.terminate()
sys.exit()
def initListener(self):
if self.listener == None:
self.listener = Listener(self)
def _(*args, **kwargs):
from Listener import Listener
return Listener(TEST_PORT, args[0], args[1], args[2], args[3])
from Listener import Listener
from dotenv import load_dotenv
import logging
from time import sleep
import os
logging.basicConfig(level=logging.INFO)
current_dir = os.path.dirname(os.path.abspath(__file__))
load_dotenv(dotenv_path="{}/.env".format(current_dir))
l = Listener()
l.start()
def main():
while True:
logging.info("*")
sleep(1)
if l.stop():
break
if __name__ == '__main__':
main()
def search():
#Gets text from search textbox
userSearch = self.userSearch.get()
#Wikipedia Checkbox
if(self.chkVar1.get()):
#webbrowser.open("http://en.wikipedia.org/w/index.php?title=" + str(userSearch))
#Displays Wikipedia hyperlink in label and binds it to left-click event and places in grid
self.lblDisplayWikiURL.config(text="http://en.wikipedia.org/w/index.php?title=" + str(userSearch), font=("Times 10"), fg="Blue", cursor="hand2")
self.lblDisplayWikiURL.bind('<Button-1>', self.wikicallback)
#Flickr Checkbox
if(self.chkVar2.get()):
#sets the userSearchFlickr to the userSearch get method
flickrPull = flickrSearch(userSearchFlickr=str(userSearch))
flickrPull.userSearch = userSearch
#webbrowser.open("http://www.flickr.com/search/?q=" + str(userSearch))
#Opens the flickDB files and reads them for displaying in the lblDisplayFlickrData labels below, and then closes it
saveFileFlickr = open('flickDB0.csv')
readFileFlickr = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB1.csv')
readFileFlickr2 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB2.csv')
readFileFlickr3 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB3.csv')
readFileFlickr4 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB4.csv')
readFileFlickr5 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB5.csv')
readFileFlickr6 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB6.csv')
readFileFlickr7 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB7.csv')
readFileFlickr8 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB8.csv')
readFileFlickr9 = saveFileFlickr.read()
saveFileFlickr.close()
saveFileFlickr = open('flickDB9.csv')
readFileFlickr10 = saveFileFlickr.read()
saveFileFlickr.close()
#Displays Flickr hyperlink in label and binds it to left-click event and places in grid
self.lblDisplayFlickrURL.config(text="http://www.flickr.com/search/?q=" + str(userSearch), fg="Blue", cursor="hand2")
self.lblDisplayFlickrURL.bind('<Button-1>', self.flickrcallback)
self.lblDisplayFlickrData.config(text=readFileFlickr, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData.bind('<Button-1>', self.flickrDisplayPhotocallback)
self.lblDisplayFlickrData.grid(row=15, column=2, sticky=W)
self.lblDisplayFlickrData2.config(text=readFileFlickr2, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData2.bind('<Button-1>', self.flickrDisplayPhotocallback2)
self.lblDisplayFlickrData2.grid(row=16, column=2, sticky=W)
self.lblDisplayFlickrData3.config(text=readFileFlickr3, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData3.bind('<Button-1>', self.flickrDisplayPhotocallback3)
self.lblDisplayFlickrData3.grid(row=17, column=2, sticky=W)
self.lblDisplayFlickrData4.config(text=readFileFlickr4, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData4.bind('<Button-1>', self.flickrDisplayPhotocallback4)
self.lblDisplayFlickrData4.grid(row=18, column=2, sticky=W)
self.lblDisplayFlickrData5.config(text=readFileFlickr5, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData5.bind('<Button-1>', self.flickrDisplayPhotocallback5)
self.lblDisplayFlickrData5.grid(row=19, column=2, sticky=W)
self.lblDisplayFlickrData6.config(text=readFileFlickr6, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData6.bind('<Button-1>', self.flickrDisplayPhotocallback6)
self.lblDisplayFlickrData6.grid(row=20, column=2, sticky=W)
self.lblDisplayFlickrData7.config(text=readFileFlickr7, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData7.bind('<Button-1>', self.flickrDisplayPhotocallback7)
self.lblDisplayFlickrData7.grid(row=21, column=2, sticky=W)
self.lblDisplayFlickrData8.config(text=readFileFlickr8, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData8.bind('<Button-1>', self.flickrDisplayPhotocallback8)
self.lblDisplayFlickrData8.grid(row=22, column=2, sticky=W)
self.lblDisplayFlickrData9.config(text=readFileFlickr9, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData9.bind('<Button-1>', self.flickrDisplayPhotocallback9)
self.lblDisplayFlickrData9.grid(row=23, column=2, sticky=W)
self.lblDisplayFlickrData10.config(text=readFileFlickr10, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT)
self.lblDisplayFlickrData10.bind('<Button-1>', self.flickrDisplayPhotocallback10)
self.lblDisplayFlickrData10.grid(row=24, column=2, sticky=W)
#Twitter Checkbox
if(self.chkVar3.get()):
#webbrowser.open("http://twitter.com/search?q=" + str(userSearch) + "&src=typd")1q
#Streams the tweets using the Listener class and searches with the criteria of the userSearch
twitterStream = Stream(authorize, Listener())
#Filters the twitter results with the user search input
twitterStream.filter(track=[userSearch])
#Opens the tDB3 file and reads for displaying in the lblDisplayTwitterData below, and then closes it
saveFile2 = open('tDB3.csv')
readFile = saveFile2.read()
saveFile2.close()
#Displays Twitter hyperlink in label and binds it to left-click event and places in grid
self.lblDisplayTwitterURL.config(text="http://twitter.com/search?q=" + str(userSearch) + "&src=typd", fg="Blue", cursor="hand2")
self.lblDisplayTwitterURL.bind('<Button-1>', self.twittercallback)
self.lblDisplayTwitterData.config(text=readFile, font=("Times 10"), justify=LEFT)
self.lblDisplayTwitterData.grid(row=27, column=2, sticky=W)
#Function that starts the thread
def run():
while Listener.alive:
multi = threading.Thread(target=search)
multi.start()
def __init__(self, port=22000):
Listener.__init__(self)
self.port = port
print('[-] No arp spoof running at the moment.')
else:
print('[!] Hook injector already running.')
elif command == 'vulnscan':
vuln_scanner = VulnerabilityScanner.vulnscan_info()
print("\n[+] Initializing Vulnerability Scanner...")
try:
vuln_scanner.crawl()
vuln_scanner.run_scanner()
except:
print("[!] Something went wrong.")
print("\n[+] Process finished...")
elif command == 'backdoor':
my_listener = Listener("10.0.2.10", 6217)
service = multiprocessing.Process(target=my_listener.server)
connections_status = multiprocessing.Process(
target=my_listener.check_connections)
service.start()
connections_status.start()
my_listener.shell()
connections_status.terminate()
service.terminate()
elif command == 'portscan':
tcp_ports = scan_ports()
print("Open Ports: {}".format(str(tcp_ports).replace(' ', '')))
elif command == 'requestdns':
my_ip = '10.0.2.10'
def handle_task(task, status, args):
response = "Nothing happened"
global running_tasks
if status in [0, 1, 2] and task in known_tasks:
# set index for corresponding listener object in array
i = 0
for t in known_tasks:
if t.partition("_")[0] in task:
chosen_task = t
print('task chosen:', chosen_task)
if status == 2:
response = chosen_task
is_running_str = " is running" if running_tasks[
i].is_running() else " is not running"
return response + is_running_str + "\n"
if chosen_task in known_listeners:
other_listeners = [
x for x in known_listeners if x != chosen_task
]
for listener in running_tasks:
if listener.get_name(
) in other_listeners and listener.is_running():
response = listener.get_name(
) + " is running, kill it before running " + chosen_task
return response + "\n"
# reinitialize Listener object with proper arguments if necessary, or quit early if nonesense request
if chosen_task == "camera_stream":
if running_tasks[i].is_running(
) and args != running_tasks[i].get_args():
response = "Camera stream already running on port " + running_tasks[
i].get_args()
response += "\nTurn this stream of before starting or stopping a new one\n"
return response
# set appropriate usb port in args
elif args and not running_tasks[i].is_running():
ports = glob.glob('/dev/tty[A-Za-z]*')
if args in ports:
running_tasks[i] = Listener(
scripts[i], "bash", args, 1, True)
else:
response = "Requested port not available, is the camera properly plugged into the USB port?"
return response + "\n"
elif chosen_task == "arm_listener":
if args and not running_tasks[i].is_running():
if args == 'usb' or args == 'uart':
running_tasks[i] = Listener(
scripts[i], "python", args)
else:
response = "Requested serial type is invalid"
return response + '\n'
elif chosen_task == "science_listener":
if args and not running_tasks[i].is_running():
if args == 'usb' or args == 'uart':
running_tasks[i] = Listener(
scripts[i], "python", args)
else:
response = "Requested serial type is invalid"
return response + '\n'
break
i += 1
if status == 1:
if running_tasks[i].start():
response = "Started " + chosen_task
else:
response = "Failed to start " + chosen_task
if running_tasks[i].is_running():
response += ", already running"
else: # in this case it is worth trying to start the chosen_task
if running_tasks[i].start():
response = "Started " + chosen_task
else:
if len(running_tasks) >= 1 and isinstance(running_tasks[i],
Listener):
if running_tasks[i].stop():
response = "Stopped " + chosen_task
else:
response = chosen_task + " not running, cannot terminate it"
return response + "\n"
def __init__(self, download_dir, source_dir):
self.download_dir = download_dir
tk.Tk.__init__(self)
self.title("Torrent Sucks")
self.geometry("500x500+300+100")
self.resizable(False, True)
self.config(bg="#474040")
self.frame = tk.Frame(self, bg='#474040')
self.frame.pack(side=tk.TOP, fill=tk.BOTH)
self.search_bar = PlaceholderEntry(self.frame,
"Please Enter the Filename",
width=50)
self.search_bar.pack(side=tk.LEFT, pady=20, padx=20)
self.search_button = FocusButton(self.frame,
text="Search",
in_color="gray",
out_color="black",
fg="white",
command=self.search)
self.search_button.pack(side=tk.RIGHT, padx=20, pady=20)
self.listbox_frame = tk.Frame(self, bg="#474040")
self.listbox_frame.pack(side=tk.TOP, fill=tk.BOTH)
self.listbox = tk.Listbox(self.listbox_frame, width=70, height=20)
self.listbox.pack(side=tk.TOP, pady=20, padx=20)
self.download_button = FocusButton(self.listbox_frame,
text="Download",
in_color="#52bf9c",
out_color="#6ed1ff",
fg="black",
command=self.download)
self.download_button.pack(side=tk.RIGHT, pady=20, padx=20)
self.status_text = tk.Label(self.listbox_frame,
text="",
bg="#474040",
font='Helvetica 10 bold')
self.status_text.pack(side=tk.LEFT, pady=20, padx=20)
#Start listener
global host
self.listener = Listener(host, source_dir)
self.host, self.port = self.listener.get_self()
print("Running On: {}:{}".format(self.host, self.port))
self.listen_thread = multiprocessing.Process(
target=self.listener.listen)
self.listen_thread.start()
self.protocol("WM_DELETE_WINDOW", self.on_closing)
self.search_file = ""
#Start Sender
self.sender = Sender(source_dir, self.host, self.port)
global ft_server
#Uncomment this if server is on
print("Connecting to Server...")
# print(ft_server[0])
# print(ft_server[1])
status = self.sender.start_conn(ft_server[0], ft_server[1])
if (status == 0):
tkinter.messagebox.showerror(
title="Error",
message=
"Couldn't correctly connect to FT server!\nCheck the ip configuration in Client.py, and restart the app!"
)
def __init__(self, controller):
self.controller = controller
listener = Listener(controller)
listener.start()
class RemoteMsg(object):
"""
_RemoteMsg_
Main interface of the RemoteMsg module. Clients wishing to use the
RemoteMsg should instantiate an object of this class and interface
it using the public methods declared by it.
"""
def __init__(self, config, addresses=[], queue=True):
"""
Constructor.
Requires a WMCore.Configuration object with configuration
information. The addresses of recipients and the flag for
queue/handling mode can be set with setAdress or setQueue methods
also (have a look at their docstring for further help). The
listener for messages needs to be started with the startListener
method, meanwhile only publication capabilities are available.
"""
self.myconfig = config
sections = self.myconfig.listSections_()
if not "RemoteMsg" in sections:
msg = "Cannot create RemoteMsg object without "
msg += "RemoteMsg section in config file"
raise Exception(msg)
self.mylogger = None
self.logMsg = None
self.__setLogging__()
self.mylogger.info("\n\n>>>>>RemoteMsg object being created <<<<<<\n")
self.myComp = None
if hasattr(self.myconfig.RemoteMsg, "inComponent"):
self.myComp = self.myconfig.RemoteMsg.inComponent
self.queueMode = queue
self.addresses = addresses
self.user = None
self.passwd = None
self.msgLock = threading.Lock()
self.handlerLock = threading.Lock()
self.factory = WMFactory("RemoteMsg")
# If this is instantiated by a WMCore component, get its DB interface
if self.myComp:
# Get a reference to our invoking component's DB factory
myThread = threading.currentThread()
self.dbFactory = myThread.dbFactory
self.dialect = myThread.dialect
# TODO: Our msg queue is just in memo for now, but it might be in a DB
# We already have the DB interface, but we would need our own Create
# and Queries modules (in principle, different from those of the comp)
# self.factory = WMFactory("threadPool", "WMCore.ThreadPool."+ \
# myThread.dialect)
# self.queries = factory.loadObject(self.myComp+"Database"+ \
# myThread.dialect+"Queries")
self.msgQueue = []
self.handlerMap = {}
# Formatter for responses (change only if in synchronous mode)
formatter = "RemoteMsgComp.DefaultFormatter"
if hasattr(self.myconfig.RemoteMsg, "formatter"):
formatter = self.myconfig.RemoteMsg.formatter
formatterObj = self.factory.loadObject(formatter)
params = {
"msgQueue": self.msgQueue,
"handlerMap": self.handlerMap,
"msgLock": self.msgLock,
"formatter": formatterObj,
"queueMode": self.queueMode,
}
if self.myComp:
params["component"] = self.myComp
params["dbFactory"] = self.dbFactory
params["dialect"] = self.dialect
self.httpTree = HttpTree(params)
self.sender = None
self.__createSender__()
self.listener = None
def __del__(self):
# Tell cherrypy to die
self.mylogger.info("Asking listener to die")
if self.listener:
self.listener.terminate()
self.listener.join()
def __setLogging__(self):
"""
Initializes logging. Use by the constructor.
"""
compSect = self.myconfig.RemoteMsg
# Logging
if not hasattr(compSect, "logFile"):
compSect.logFile = os.path.join(compSect.RemoteMsgDir, "remoteMsg.log")
print("Log file is: " + compSect.logFile)
if not hasattr(compSect, "listenerLogFile"):
compSect.listenerLogFile = os.path.join(compSect.RemoteMsgDir, "listener.log")
print("Listener log file is: " + compSect.listenerLogFile)
logHandler = RotatingFileHandler(compSect.logFile, "a", 1000000, 3)
logFormatter = logging.Formatter("%(asctime)s:%(levelname)s:%(filename)s:%(message)s")
logHandler.setFormatter(logFormatter)
self.mylogger = logging.getLogger("RemoteMsg")
self.mylogger.addHandler(logHandler)
self.mylogger.setLevel(logging.INFO)
# map log strings to integer levels:
self.logMsg = {
"DEBUG": logging.DEBUG,
"ERROR": logging.ERROR,
"NOTSET": logging.NOTSET,
"CRITICAL": logging.CRITICAL,
"WARNING": logging.WARNING,
"INFO": logging.INFO,
}
## 'SQLDEBUG' : logging.SQLDEBUG }
if hasattr(compSect, "logLevel") and compSect.logLevel in self.logMsg.keys():
self.mylogger.setLevel(self.logMsg[compSect.logLevel])
def __createSender__(self):
"""
Initializes the sender object. Used by the constructor.
"""
# Sender is not a new thread, so it does not need a lock
params = {}
params["addresses"] = self.addresses
params["port"] = "8030"
if hasattr(self.myconfig.RemoteMsg, "senderPort"):
params["port"] = self.myconfig.RemoteMsg.senderPort
params["service"] = "msg"
if hasattr(self.myconfig.RemoteMsg, "senderService"):
params["service"] = self.myconfig.RemoteMsg.senderService
params["user"] = None
if hasattr(self.myconfig.RemoteMsg, "senderUser"):
params["user"] = self.myconfig.RemoteMsg.senderUser
params["pwd"] = None
if hasattr(self.myconfig.RemoteMsg, "senderPwd"):
params["pwd"] = self.myconfig.RemoteMsg.senderPwd
params["realm"] = "RemoteMsg"
if hasattr(self.myconfig.RemoteMsg, "realm"):
params["realm"] = self.myconfig.RemoteMsg.senderRealm
self.sender = Sender(self.msgQueue, params)
def startListener(self):
"""
Starts a listener for incoming remote messages. The method will refuse
to create a listener if there is already one
"""
if not self.listener:
self.mylogger.info("Starting listener")
self.listener = Listener(self.httpTree, self.myconfig)
self.listener.start()
else:
msg = "Refusing to start listener (there is already one)."
self.mylogger.info(msg)
def setAddress(self, addresses):
"""
Sets the addresses of the remote ends. Argument should be a list of
IPs or hostnames. The publish method will send messages to all members
of this list.
"""
self.addresses = addresses
self.sender.setAddress(self.addresses)
def setAuthentication(self, user, passwd):
"""
Sets the user/password for authentication
with the remote application. Has to be done
before sending a message.
"""
self.mylogger.debug("Setting user and passwd")
self.user = user
self.passwd = passwd
def setQueue(self, value):
"""
This is an option that either allows messages that are being received
to be put in a local queue (so a get method can retrieve them), or if
set to False messages are handled directly through the handler framework.
"""
self.queueMode = value
self.httpTree.setQueue(self.queueMode)
def get(self):
"""
Gets messages from the local buffer (those not handled as explained
in the setQueue method).
The first message of the queue is retrieved and returned. This method
is only used when the queue is set to True. If queue is set to False
or there are no stored messages, None is returned.
"""
if self.queueMode:
self.msgLock.acquire()
if self.msgQueue:
result = self.msgQueue.pop(0)
else:
result = None
self.msgLock.release()
return result
else:
return None
def publish(self, msgType, payload, sync=False):
"""
Sends a message to the remote end.
If sync is set to True, the remote server will complete the message
handling before replying with some generated data. Otherwise, the
remote end will immediately reply with some "Message received"
indication and execute the handler asynchronously (if the remote end
is in queue mode, there is no handler execution, so this flag is
meaningless).
In any case, the response of the message (e.g. a json string product
of the handling of the HTTP request) is returned.
Can throw an HTTP exception in case of error connecting with the remote
end.
"""
return self.sender.send(msgType, payload, sync)
def setHandler(self, msgType, handler):
"""
Maps the specified handler to the indicated message type.
The handler must be the name of a class which can be called (e.g.
RemoteMsg.SimpleHandler). The handler will only be called if
queue mode is set to False.
"""
msg = "Setting new handler %s for msgType %s" % (handler, msgType)
self.mylogger.debug(msg)
# Factory to dynamically load handlers
params = {}
if self.myComp:
params["component"] = self.myComp
newHandler = self.factory.loadObject(handler, params)
self.handlerLock.acquire()
self.handlerMap[msgType] = newHandler
self.handlerLock.release()
from Pagenator import Pagenator
from Server import server
import time
import logging
import os.path
if __name__ == '__main__':
currdir = os.path.abspath(os.getcwd()+'/../')
try:
logging.basicConfig(filename=os.path.normpath(currdir+'/logs/runlog.log'), level=logging.DEBUG)
db = Database()
listener = Listener(6969,256,db)
listener.start()
logging.info("Waiting 15 seconds for sensor data to populate the database...")
time.sleep(15)
serverdoc = Pagenator(db)
#print serverdoc
webpage = server(serverdoc,db)
webpage.run()
except SystemExit:
print "Shutting Down..."
logging.info("Shutting Down Main Thread...")
webpage.stop()
label.setText('New Hotkey: Enter Keycombination')
self.layout.addWidget(label)
label = QLabel(self)
label.setText('Delete Hotkey: Press DELETE')
self.layout.addWidget(label)
label = QLabel(self)
label.setText('Cancel: Press ESC')
self.layout.addWidget(label)
self.setLayout(self.layout)
if __name__ == '__main__':
settings = Settings()
listener = Listener(settings)
app = QApplication(sys.argv)
win = MainWindow(settings, listener)
mw = windows.ModernWindow(win)
stylesheet_path = os.path.join(wd, './Style/frameless.qss')
icon_path = os.path.join(wd, './Compiled/owl.ico')
with open(stylesheet_path) as stylesheet:
mw.setStyleSheet(stylesheet.read())
mw.setWindowIcon(QIcon(icon_path))
mw.show()
sys.exit(app.exec_())
from Listener import Listener
from pynput.keyboard import Key, Controller
import serial
listener = Listener(
serial.Serial(port="COM5",
baudrate=115200,
bytesize=8,
timeout=2,
stopbits=serial.STOPBITS_ONE))
keyboard = Controller()
commands = listener.start()
for command in commands:
if (command == 'buttonA'):
keyboard.press(Key.space)
elif (command == 'buttonB'):
keyboard.press(Key.down)
else:
keyboard.release(Key.down)
keyboard.release(Key.space)
def __init__(self,manager,host = 'localhost',port = 51423):
networking.Client.__init__(self,host,port)
print self.socketThread
eventTypes = [Event.WorldManipulationEvent,Event.LoadGameEvent]
Listener.__init__(self,manager,eventTypes)
'stop_loss': None
}]
if __name__ == '__main__':
trader = Trader(API_KEY, API_SECRET, SLACK_TOKEN)
in_analyzers = [
InAnalyzer(trader, params=params_in[i]) for i in range(len(params_in))
]
out_analyzers = [
OutAnalyzer(trader, params=params_out[i])
for i in range(len(params_out))
]
trader.hire(in_analyzers, out_analyzers)
follow_dict = csv_to_dict(FOLLOWED_USERS_FILE)
listener = Listener(follow_dict, trader)
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
try:
followed_users_id = follow_dict.keys()
tracked_words = [] # words you are looking for
stream = Stream(auth, listener)
stream.filter(follow=followed_users_id,
track=tracked_words,
async=True)
trader.slackclient.api_call("chat.postMessage",
channel='#bot-python',
text="Bot init")
#!/usr/bin/env python3
import rospy
import os
from Listener import Listener
from task_handler.srv import *
current_dir = os.path.dirname(os.path.realpath(__file__)) + "/"
print(current_dir)
scripts = [
current_dir + "RoverCommandListener.py",
current_dir + "ArmCommandListener.py", current_dir + "start_stream.sh"
]
running_tasks = [
Listener(scripts[0], "python3"),
Listener(scripts[1], "python3"),
Listener(scripts[2], "bash", 1, True)
]
known_tasks = ["rover_listener", "arm_listener", "camera_stream"]
def handle_task_request(req):
response = "\n" + handle_task(req.task, req.status)
return response
def handle_task(task, status):
response = "Nothing happened"
#Reporter.log
reporterlogger = logging.getLogger("reporter")
reporterlogger.setLevel(logging.DEBUG)
reporterfh = logging.handlers.RotatingFileHandler('logs/Reporter.log', maxBytes = 10*1024*1024, backupCount=2)
reporterfh.setFormatter(formatter)
reporterlogger.addHandler(reporterfh)
########initialize Listeners
#first create server socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('192.168.1.222', 1060))
overseerlogger.info("(+) Listening socket created.")
#create 5 Listeners and start them
for i in range(5):
t = Listener(sock, i+1)
t.start()
overseerlogger.info("(+) Listener "+str(i+1)+" started.")
########Initialize Alert Queue
alertQueue = Queue()
########initialize Reporter
reporter = Reporter(alertQueue, 0)
reporter.start()
overseerlogger.info("(+) Reporter started.")
########Initialize dict to hold phrases of active sessions and their states
sessionsDict = dict()
#Initialize list to hold SessionHanlder objects
sessionHandlers = list()
