class Accompanist:
def __init__(self):
self.queue_in = Queue()
self.queue_out = Queue()
self.predictor_queue = Queue()
self.running = Value('i', False)
self.tempo = Value('f', default_tempo)
self.deadline = Value('f', 0)
self.player = Player(self.queue_out, self.running, self.tempo,
self.deadline)
self.predictor = ChordPredictor(self.queue_in, self.queue_out)
self.listener = Listener(self.queue_in, self.running, self.tempo,
self.deadline)
def run(self):
self.running.value = True
self.listener.run()
self.player.run()
self.predictor.run()
def stop(self):
self.running.value = False
self.player.stop()
self.listener.stop()
self.predictor.stop()
self.queue_in = Queue()
self.queue_out = Queue()
def set_tempo(self, tempo=default_tempo):
self.tempo.value = tempo
def set_deadline(self, deadline=0):
self.deadline.value = deadline
player = None
listener = None
predictor = None
queue_in = None
queue_out = None
running = None
tempo = None
deadline = None
process = None
def run():
buffer = EventBuffer()
processor = Processor(buffer, contract_manager)
listener = Listener(buffer, contract_manager)
listener.run(sleep_in_sync)
import os, ConfigParser, atexit
from listener import Listener
config = ConfigParser.RawConfigParser()
config.read(
os.path.join(
os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)),
'settings.cfg'))
if __name__ == '__main__':
listener = Listener(google_key=config.get('google', 'key'))
listener.run()
atexit.register(listener.stop)
senders = None
index = -1
self.ON = False
finally:
file.close()
return senders, index
if len(sys.argv) == 5 and sys.argv[1] == '--send':
print 'Starting the measurement tool from', sys.argv[2], 'to', sys.argv[3]
time.sleep(1)
senders, index = parse(sys.argv[4], sys.argv[2])
if index == -1:
sys.exit(0)
sender = Sender(sys.argv[2], sys.argv[3], senders, index)
if sender.isAlive():
sender.run()
sender.close()
elif len(sys.argv) == 3 and sys.argv[1] == '--listen':
print 'Listening at', sys.argv[2]
listener = Listener(sys.argv[2])
if listener.isAlive():
listener.run()
listener.close()
else:
print 'python measurement.py [--send|--listen] addr'
sys.exit(0)
class KMLoger(threading.Thread):
""" Classe principal """
def __init__(self):
threading.Thread.__init__(self)
self.devices = get_devices()
self.keyfile = ".keymap" # Arquivo padrão para o mapa de caracteres
self.keymap = KeyMap(self.devices)
self.listener = Listener(self.devices)
self.history = History()
self.lock = False
self.listen()
self.copy = False
def record(self):
if self.copy:
self.copy = False
print("\rComandos gravados" + " "*80)
self.listener.del_key_sniffer("rec")
# self.listener.del_mouse_sniffer("mouse")
else:
self.copy = True
print("\rIniciando gravação" + " "*80)
self.history.reset()
self.listener.add_key_sniffer("rec", [self.keymap.get_key_by_func("rec")], self.history.append_event)
# self.listener.add_mouse_sniffer("mouse", self.history.append_event)
def pprint(self, *args):
if not self.copy:
print(args)
def listen(self):
""" Inicializando todas as fun """
self.listener.add_listener("redefine", ecodes.EV_KEY, self.keymap.get_key_by_func("redefine"), self.change_keys)
self.listener.add_listener("quit", ecodes.EV_KEY, self.keymap.get_key_by_func("quit"), self.exit)
self.listener.add_listener("copy", ecodes.EV_KEY, self.keymap.get_key_by_func("rec"), self.record)
self.listener.add_listener("run", ecodes.EV_KEY, self.keymap.get_key_by_func("run"), self.play)
# self.listener.add_listener("save", ecodes.EV_KEY, self.keymap.get_key_by_func("save"), self.history.save)
# self.listener.add_listener("load", ecodes.EV_KEY, self.keymap.get_key_by_func("load"), self.history.load)
# self.listener.add_listener("pause", ecodes.EV_KEY, self.keymap.get_key_by_func("pause"), self.history.sleep)
# self.listener.add_listener("stop", ecodes.EV_KEY, self.keymap.get_key_by_func("stop"), self.history.stop)
# self.listener.add_listener("run_forever", ecodes.EV_KEY, self.keymap.get_key_by_func("run_forever"), self.play_forever)
# self.listener.add_key_sniffer("rec", [self.keymap.get_key_by_func("rec")], self.history.append_event)
# self.listener.add_listener("copy", ecodes.EV_KEY, self.keymap.get_key_by_func("rec"), pprint, "record")
self.listener.add_listener("save", ecodes.EV_KEY, self.keymap.get_key_by_func("save"), self.pprint, "save")
self.listener.add_listener("load", ecodes.EV_KEY, self.keymap.get_key_by_func("load"), self.pprint, "load")
self.listener.add_listener("pause", ecodes.EV_KEY, self.keymap.get_key_by_func("pause"), self.pprint, "sleep")
self.listener.add_listener("stop", ecodes.EV_KEY, self.keymap.get_key_by_func("stop"), self.pprint, "stop")
# self.listener.add_listener("run", ecodes.EV_KEY, self.keymap.get_key_by_func("run"), self.pprint, "play")
self.listener.add_listener("run_forever", ecodes.EV_KEY, self.keymap.get_key_by_func("run_forever"), self.pprint, "play_forever")
def play(self):
if not self.copy:
print("\rplay" + " "*80)
self.history.set_n(1)
self.history.play()
def play_forever(self):
if not self.copy:
self.history.set_n(0)
self.history.play()
def run(self):
self.history.start()
self.listener.run()
self.history.join()
def save_key_map(self):
""" Salva o mapa de caracteres no arquivo padrão. """
pickle.dump( self.keymap, open(self.keyfile, 'wb'), -1)
def exit(self):
if not self.copy:
self.history.exit()
self.listener.exit()
flush_input()
print("\nBye!")
def load_key_map(self):
""" Carrega o mapa de caracteres do arquivo padrão. """
try:
self.keymap = pickle.load(open(self.keyfile, 'rb'))
except IOError:
self.save_key_map()
self.listen()
def change_keys(self):
if not self.copy:
self.keymap.setup()
print("\rNovo mapa de teclas salvo.")
self.save_key_map()
print("\rPrograma precisa ser reiniciado")
self.exit()
def print_keys(self):
self.keymap.print_keymap()
class Server:
setup_cache_contents = {}
def read_setup_cache():
"""Static function to setup cache"""
cache_file = ''
try:
cache_file = open(setup_cache, 'r')
except IOError:
cache_file = open(setup_cache, 'w')
cache_file.close()
cache_file = open(setup_cache, 'r')
contents = cache_file.readlines()
for server in contents:
Server.setup_cache_contents[server.strip()] = True
cache_file.close()
def __init__(self, ip, binary, name="noname", port=22):
self.name = name
self.ip = ip
self.port = port
listener_port = random.randint(20000, 25000)
self.listener = Listener(name, ip, listener_port, self)
self.binary = Binary(binary, self)
def __repr__(self):
return '{} at {}:{}'.format(self.name, self.ip, self.port)
def __str__(self):
return self.__repr__()
def run_proc(self, args):
if self.ip in ["127.0.0.1", "0.0.0.0", "localhost"]:
try:
ex = subprocess.call(["bash", "-c", " ".join(args)])
return ex
except KeyboardInterrupt:
print("Process stopped by user")
return 0
else:
return subprocess.call(["ssh", self.ip, "-t", " ".join(args)])
def copy_file(self, file_path_local, file_path_server, file_name_server):
return subprocess.call(["scp", file_path_local,
"{}:{}/{}".format(self.ip,
file_path_server,
file_name_server)])
def copy_executable(self, file_path_local, file_location_server,
file_name_server):
ex = self.copy_file(file_path_local, file_location_server,
file_name_server)
if ex != 0:
return ex
return self.run_proc(["chmod", "+x", "{}/{}".format(
file_location_server, file_name_server)])
def tail_file(self, file_path_server):
try:
self.run_proc(["tail", "-f", file_path_server])
finally:
pass
def setup_ssh(self):
ex = subprocess.call(["ssh-copy-id", self.ip])
if ex != 0:
sys.exit("Error while setting up SSH login on server {}"
.format(self.ip))
def setup_folder(self):
ex = self.run_proc(["mkdir", "-p", path_on_servers])
if ex != 0:
sys.exit("Error while setting up main data folder on {}"
.format(self.ip))
def clear_logs(self):
ex = self.run_proc(["bash", "-c",
"'rm {}/.*logs'".format(path_on_servers)])
if ex != 0:
sys.exit("Error while clearing logs on {}" .format(self.ip))
def finish_setup(self):
with open(setup_cache, "a") as f:
f.write("{}\n".format(self.ip))
def setup_volatile(self):
self.binary.setup()
self.listener.setup()
def setup(self, copy_anyway=False):
if len(Server.setup_cache_contents) == 0:
Server.read_setup_cache()
if self.ip in Server.setup_cache_contents:
if copy_anyway:
self.setup_volatile()
return
print("Setting up server {}".format(self.ip))
self.setup_ssh()
self.setup_folder()
self.clear_logs()
self.finish_setup()
print("Finished setting up server {}".format(self.ip))
def run(self):
self.setup_volatile()
self.listener.run()
def shutdown(self):
self.listener.stop()
