def __init__(self, host='localhost', port=2828, b2gbin=False,
emulator=None, connectToRunningEmulator=False,
homedir=None, baseurl=None, noWindow=False, logcat_dir=None):
self.host = host
self.port = self.local_port = port
self.b2gbin = b2gbin
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
if b2gbin:
self.b2ginstance = B2GInstance(host=self.host, port=self.port, b2gbin=self.b2gbin)
self.b2ginstance.start()
assert(self.b2ginstance.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir, logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
def start_training(self):
self.emulators = dict()
number_of_points = np.linspace(
len(self.x_signal) / 6, len(self.x_signal),
self.n_emulator).astype(int)
number_of_rows = self.x_signal.shape[0]
for i in range(self.n_emulator):
print(number_of_points[i])
print(number_of_rows)
random_indices = np.random.choice(number_of_rows,
size=number_of_points[i],
replace=False)
x_signal = self.x_signal[random_indices, :]
y_signal = self.y_signal[random_indices, :]
if self.x_min_max != None:
x_min_max = self.x_min_max[random_indices, :]
y_min_max = self.y_min_max[random_indices, :]
else:
x_min_max = None
y_min_max = None
print(f'training on emulator n° {i} : started ')
# TODO dev other multi training methods
emulator = Emulator(f'Emulator_{i}', self.x_parameters,
self.t_series_names, self.normalize,
self.drop_outliers)
emulator.train(x_signal, y_signal, x_min_max, y_min_max)
self.emulators[emulator.name] = emulator
print(f'training on emulator n° {i} : done ')
def input(q):
from emulator import Emulator
import json
import math
while True:
text = q.get(True)
print(text)
emulator = Emulator(5554)
pages = math.ceil(len(text) / 1500.0)
counter = 0
texts = []
while len(text) > 0:
t = "%04d" % counter
if counter == 0:
t = "#%04d%04d" % (counter, pages - 1)
counter += 1
texts.append(t + text[:1500])
text = text[1500:]
if counter >= pages:
break
for text in texts:
emulator.send_sms("6666", text)
def __init__(self, host='localhost', port=2828, emulator=False,
connectToRunningEmulator=False, homedir=None,
baseurl=None, noWindow=False):
self.host = host
self.port = self.local_port = port
self.session = None
self.window = None
self.emulator = None
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
if emulator:
self.emulator = Emulator(homedir=homedir, noWindow=self.noWindow)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
def __init__(self,
host='localhost',
port=2828,
emulator=False,
connectToRunningEmulator=False,
homedir=None,
baseurl=None,
noWindow=False):
self.host = host
self.port = self.local_port = port
self.session = None
self.window = None
self.emulator = None
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
if emulator:
self.emulator = Emulator(homedir=homedir, noWindow=self.noWindow)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert (self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert (self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
def evaluate():
#Set this color as the default
print white, ''
maps_list = glob.glob('maps/*.map')
maps_list.sort()
maps_points = {}
maps_points_old = {}
if os.path.exists(cache_file):
maps_points_old = pickle.load(open(cache_file, 'r'))
for map_file in maps_list:
lines = []
map_data = open(map_file, 'r')
for line in map_data:
lines.append(line)
m_lifter = meta_lifter.MetaLifter()
m_lifter.hide_print = True
commands = m_lifter.lift(lines)
emu = Emulator(open(map_file, 'r'), commands)
emu.suppress_prints = True
emu.print_points = False
while not emu.quit:
emu.processCommand()
points = emu.points
maps_points[map_file] = points
delta_points = 0
delta_value = ''
#Check cache...
old_points = maps_points_old.get(map_file)
if old_points:
delta_points = points - old_points
if old_points > points:
color = red
elif old_points < points:
delta_value = '+'
color = green
else:
color = brown
else:
color = brown
if delta_points == 0:
delta_points = ''
print map_file, '\t' + color + str(points) + ' ' + delta_value + str(delta_points) + white
#Dump to the cache
pickle.dump(maps_points, open(cache_file, 'w'))
def shutdown(self):
"""
:return:
"""
e = Emulator("localhost", self._id)
if e.connect():
return e.kill()
else:
return None
def __init__(self, host='localhost', port=2828, bin=None, profile=None,
emulator=None, sdcard=None, emulatorBinary=None,
emulatorImg=None, emulator_res=None, gecko_path=None,
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None, busybox=None, symbols_path=None):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self._test_name = None
self.symbols_path = symbols_path
if bin:
port = int(self.port)
if not Marionette.is_port_available(port, host=self.host):
ex_msg = "%s:%d is unavailable." % (self.host, port)
raise MarionetteException(message=ex_msg)
self.instance = GeckoInstance(host=self.host, port=self.port,
bin=self.bin, profile=self.profile)
self.instance.start()
assert(self.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.setup(self,
gecko_path=gecko_path,
busybox=busybox)
def stop_traffic_capture(self):
"""
Stop traffic capture via exposed console.
"""
e = Emulator("localhost", self._id)
if e.connect():
return e.network_capture_stop()
else:
raise Exception("An error occured while connecting to the device.")
def __init__(self,
host='localhost',
port=2828,
bin=None,
profile=None,
emulator=None,
emulatorBinary=None,
emulatorImg=None,
emulator_res='480x800',
connectToRunningEmulator=False,
homedir=None,
baseurl=None,
noWindow=False,
logcat_dir=None):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
if bin:
self.instance = GeckoInstance(host=self.host,
port=self.port,
bin=self.bin,
profile=self.profile)
self.instance.start()
assert (self.instance.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert (self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert (self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
def __init__(self, host='localhost', port=2828, bin=None, profile=None,
emulator=None, sdcard=None, emulatorBinary=None,
emulatorImg=None, emulator_res='480x800', gecko_path=None,
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None, busybox=None, load_early=False):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self._test_name = None
if bin:
self.instance = GeckoInstance(host=self.host, port=self.port,
bin=self.bin, profile=self.profile)
self.instance.start()
assert(self.instance.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.setup(self, gecko_path=gecko_path,
load_early=load_early)
if busybox:
self.emulator.install_busybox(busybox)
def action_reset(self):
self.last_frame = []
if self.project_file is None:
return
self.emulator = Emulator(debug=False)
self.load_project_files()
self.emulator_state = EmulationState.LOADED
self.next_instruction = self.emulator.run_step()
self.actionReset.setEnabled(False)
def __init__(self, n_emulator, simulation, x_parameters, t_series_names,
normalize, drop_outliers):
self.n_emulator = n_emulator
self.simulation = simulation
self.x_parameters = x_parameters
self.t_series_names = t_series_names
self.normalize = normalize
self.drop_outliers = drop_outliers
self.formater_emulator = Emulator(f'Emulator_formater',
self.x_parameters,
self.t_series_names, self.normalize,
self.drop_outliers)
self.x_signal, self.y_signal, self.x_min_max, self.y_min_max = self.formater_emulator.format_data(
self.simulation)
def main():
arg_parser = ArgumentParser()
arg_parser.add_argument('--filename', help='ROM file')
arg_parser.add_argument('--state', help='Save state file')
args = arg_parser.parse_args()
filename = args.filename if args.filename else 'invaders.rom'
state = args.state
if state:
emu = Emulator.load(state)
else:
emu = Emulator(path=filename)
emu.run()
def __init__(self):
self.session = tf.InteractiveSession()
self.emulator = Emulator(settings)
settings['num_actions'] = len(self.emulator.actions)
self.replay = ReplayDB(settings)
with tf.variable_scope('model'):
self.model = Model(settings)
self.summary = tf.merge_all_summaries()
self.writer = tf.train.SummaryWriter('summary-log', self.session.graph_def)
self.session.run(tf.initialize_all_variables())
self.saver = tf.train.Saver(max_to_keep=1000000)
checkpoint = tf.train.get_checkpoint_state("networks")
if checkpoint and checkpoint.model_checkpoint_path:
self.saver.restore(self.session, checkpoint.model_checkpoint_path)
print("Loaded checkpoint: {}".format(checkpoint.model_checkpoint_path))
else:
print("Unable to load checkpoint")
self.summary_cnt = 0
self.episode_cnt = 0
self.timer = self.session.run(self.model.global_step)
self.no_op = tf.no_op()
def start_traffic_capture(self, pcap_file):
"""
Launch traffic capture via exposed console.
Params:
pcap_file: file where the traffic capture will be written
Returns:
True if successful, False otherwise
"""
with open(pcap_file, "wb") as f:
f.write("")
e = Emulator("localhost", self._id)
if e.connect():
return e.network_capture_start(pcap_file)
else:
raise Exception("An error occured while connecting to the device.")
def process_file(filename):
print('Processing file: ', filename)
with open(filename, 'rb') as file:
# Note, we can't close file until we have finished reading data
elf_file = ELFFile(file)
# Code is normally in the data section
text_section = elf_file.get_section_by_name(".text")
base_address = text_section.header['sh_addr']
disassembly = distorm3.Decompose(base_address, text_section.data())
# Get the symbol table as table of addresses mapped to names
symbol_table_section = elf_file.get_section_by_name(".symtab")
symbol_table = {} # TODO: Fill in the symbol table...
# Create an LLVM emulator
emulator = Emulator("module", symbol_table)
for instruction in disassembly:
if hasattr(emulator, instruction.mnemonic):
method = getattr(emulator, instruction.mnemonic)
method(instruction)
else:
print(instruction.mnemonic +
" not implemented yet. Please implement it!")
return disassembly
def instances_manager():
adb = config.config_file_reader('adb')
adb_devices = str(subprocess.check_output([adb, 'devices']))
# print(adb_devices)
adb_devices = adb_devices.split('\n')
# print(adb_devices)
adb_devices = adb_devices[1:]
# print(adb_devices)
emulator_ports = []
emulators = []
for adb_device in adb_devices:
emulator_port = adb_device.split('\t')[:1][0][9:]
# print ("hello")
# print adb_device.split('\t')[:1][0][9:]
if (len(emulator_port) > 3):
emulator_ports.append(emulator_port)
# pid = str(subprocess.check_output(['netstat', '-tulpn' ,'|', 'grep', emulator_port]))[9:]
# print(emulator_port, len(emulator_port), pid)
# print(emulator_port)
pid = str(
subprocess.check_output(['lsof', '-i', 'tcp:' + emulator_port
])).split('\n')[1:][0].split(' ')[1]
# print(pid)
device_details_in_ps = str(subprocess.check_output(['ps', pid]))
# print (device_details_in_ps)
model = get_device_emulator_model(device_details_in_ps)
# print(model)
current_emulator = Emulator(emulator_port, pid, model)
emulators.append(current_emulator)
# print(current_emulator)
return emulators
def evaluate(agent,nb_ite):
train = np.asarray([10,100,1000])
score = np.zeros(train.shape)
eval_loop = 100
Fmax=1
game = ContinuousCatcher()
random_agent = RandomAgent(1)
agent = QAgent(10,Fmax,game.gamma())
init_emul = Emulator(agent=random_agent)
init_history = init_emul.run()
agent.train(init_history)
i = 0
for nb_train in range(train[-1]):
if nb_train == train[i]:
evaluate(agent)
def init_app(app):
app.mold_config = MouldConfig.from_common_config()
app.tcs = tcs_from_config(app.mold_config)
app.wlanbox = Emulator(app.mold_config.tc_count)
# app.wlanbox = WLANBoxConnector(app.mold_config.tc_count)
app.msd_config = MSDConfig()
app.test_session = TestSession()
return app
def main(argv):
minidump = tempfile.mktemp('minidump')
emulator = Emulator(FLAGS.emulator,
FLAGS.maxboot,
avd=FLAGS.avd,
sdk_root=FLAGS.sdk_root,
avd_home=FLAGS.avd_root)
if not emulator.avd:
logging.info("No avds available!.")
sys.exit(1)
emulator.launch(FLAGS.args)
# Connection to the emulator
connection = emulator.connect_console()
crash_emulator(connection)
emulator.grab_minidump(minidump)
# Now let's analyze the crash report..
if not FLAGS.symbol_src or not FLAGS.stackwalker:
logging.error(
"No symbols, or stackwalker defined, did not validate symbols.")
sys.exit(1)
check_minidump(minidump)
def __init__(self, name, options={}):
self.fullname = name
self.shortname = utils.idx(options, 'nickname', name)
self.extensions = utils.idx(options, 'extensions', "")
self.custom_roms_directory = utils.idx(options, 'roms directory', None)
self.prefix = utils.idx(options, 'prefix', None)
self.icon = os.path.expanduser(utils.idx(options, 'icon', ""))
self.emulator = Emulator.lookup(utils.idx(options, 'emulator', ""))
def _setup_emulator(system):
beacon_catcher = CaptureLastBeacon(system.frame_decoder)
emulator_modules = [
BeaconModule(system, beacon_catcher.last_beacon),
AntennasModule(system),
RTCModule(system),
EPSModule(system),
PayloadModule(system),
CommModule(system, beacon_catcher.last_beacon),
LastFramesModule(last_frames)
]
emulator = Emulator(emulator_modules)
emulator.start(IPython.lib.guisupport.get_app_wx())
emulator.zmq_adapter = ZeroMQAdapter(system.comm)
beacon_catcher.start()
def __init__(self, name, options={}):
self.fullname = name
self.shortname = utils.idx(options, "nickname", name)
self.extensions = utils.idx(options, "extensions", "")
self.custom_roms_directory = utils.idx(options, "roms directory", None)
self.prefix = utils.idx(options, "prefix", "")
self.icon = os.path.expanduser(utils.idx(options, "icon", ""))
self.images_directory = os.path.expanduser(utils.idx(options, "images directory", ""))
self.emulator = Emulator.lookup(utils.idx(options, "emulator", ""))
def __init__(self, name, options={}):
self.fullname = name
self.shortname = utils.idx(options, 'nickname', name)
self.extensions = utils.idx(options, 'extensions', "")
self.custom_roms_directory = utils.idx(options, 'roms directory', None)
self.prefix = utils.idx(options, 'prefix', "")
self.icon = os.path.expanduser(utils.idx(options, 'icon', ""))
self.images_directory = os.path.expanduser(utils.idx(options, 'images directory', ""))
self.emulator = Emulator.lookup(utils.idx(options, 'emulator', ""))
def launch():
if request.headers.get('authorization', None) != settings.LAUNCH_AUTH_HEADER:
abort(403)
if len(emulators) >= settings.EMULATOR_LIMIT:
abort(503)
uuid = uuid4()
if '/' in request.form['platform'] or '/' in request.form['version']:
abort(400)
emu = Emulator(
request.form['token'],
request.form['platform'],
request.form['version'],
tz_offset=(int(request.form['tz_offset']) if 'tz_offset' in request.form else None),
oauth=request.form.get('oauth', None)
)
emulators[uuid] = emu
emu.last_ping = now()
emu.run()
return jsonify(uuid=uuid, ws_port=emu.ws_port, vnc_display=emu.vnc_display, vnc_ws_port=emu.vnc_ws_port)
def configure(args):
"""create and configure an emulator"""
emu = Emulator(args,
cpu='68030',
frequency=24 * 1000 * 1000)
emu.add_memory(base=0, size=512 * 1024, writable=False, from_file=args.rom)
emu.add_memory(base=0x4000000, size=64 * 1024 * 1024)
emu.add_device(args,
MC68681,
address=0xfffff000,
interrupt=m68k.IRQ_2,
register_arrangement='16-bit')
emu.add_device(args,
CompactFlash,
address=0xffffe000,
register_arrangement='8-bit')
return emu
class VotingSystem:
def __init__(self, n_emulator, simulation, x_parameters, t_series_names,
normalize, drop_outliers):
self.n_emulator = n_emulator
self.simulation = simulation
self.x_parameters = x_parameters
self.t_series_names = t_series_names
self.normalize = normalize
self.drop_outliers = drop_outliers
self.formater_emulator = Emulator(f'Emulator_formater',
self.x_parameters,
self.t_series_names, self.normalize,
self.drop_outliers)
self.x_signal, self.y_signal, self.x_min_max, self.y_min_max = self.formater_emulator.format_data(
self.simulation)
def start_training(self):
self.emulators = dict()
number_of_points = np.linspace(
len(self.x_signal) / 6, len(self.x_signal),
self.n_emulator).astype(int)
number_of_rows = self.x_signal.shape[0]
for i in range(self.n_emulator):
print(number_of_points[i])
print(number_of_rows)
random_indices = np.random.choice(number_of_rows,
size=number_of_points[i],
replace=False)
x_signal = self.x_signal[random_indices, :]
y_signal = self.y_signal[random_indices, :]
if self.x_min_max != None:
x_min_max = self.x_min_max[random_indices, :]
y_min_max = self.y_min_max[random_indices, :]
else:
x_min_max = None
y_min_max = None
print(f'training on emulator n° {i} : started ')
# TODO dev other multi training methods
emulator = Emulator(f'Emulator_{i}', self.x_parameters,
self.t_series_names, self.normalize,
self.drop_outliers)
emulator.train(x_signal, y_signal, x_min_max, y_min_max)
self.emulators[emulator.name] = emulator
print(f'training on emulator n° {i} : done ')
def predict(self, input_params):
prediction = dict()
for emulator_name in list(self.emulators.keys()):
prediction[emulator_name] = self.emulators[emulator_name].predict(
input_params)
return prediction
def configure(args):
iobase = 0xff0000
emu = Emulator(args,
cpu=args.cpu_type,
frequency=args.cpu_frequency * 1000 * 1000)
emu.add_memory(base=0, size=args.mem_size * 1024 * 1024)
emu.add_device(args,
UART,
address=iobase,
interrupt=m68k.IRQ_2)
emu.add_device(args,
Timer,
address=iobase + 0x1000,
interrupt=m68k.IRQ_6)
emu.add_device(args,
Disk,
address=iobase + 0x2000)
return emu
def __init__(self, host='localhost', port=2828, bin=None, profile=None,
emulator=None, emulatorBinary=None, emulator_res='480x800',
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
if bin:
self.instance = GeckoInstance(host=self.host, port=self.port,
bin=self.bin, profile=self.profile)
self.instance.start()
assert(self.instance.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
emulatorBinary=emulatorBinary,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir, logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
def __init__(self,map_file):
self.emu = Emulator(open(map_file, 'r'), '')
self.emu.suppress_prints = True
self.MAX_DEPTH = self.emu.command_limit
self.MAX_LEAVES = 10000000
self.MAX_SCORE = 75.0*self.emu.total_lambdas
print 'MAX DEPTH: ' + str(self.MAX_DEPTH)
print 'MAX LEAVES: ' + str(self.MAX_LEAVES)
print 'MAX SCORE: ' + str(self.MAX_SCORE)
self.best_score = 0.0
self.best_seed = -1
self.best_path = ''
def analyse(self):
ip = self.arch.instruction_pointer
sp = self.arch.stack_pointer
emu = Emulator(self.arch)
emu.map_code(self.address, self.code)
stack = get_random_page(self.arch)
stack_data = randoms(self.arch.page_size)
emu.setup_stack(
stack,
self.arch.page_size,
stack_data
)
init_regs = {}
for reg in self.arch.regs:
if reg in (ip, sp): continue
val = self.arch.unpack(randoms(self.arch.bits >> 3))
emu[reg] = val
init_regs[val] = reg
emu.run(self.address, len(self.code))
for reg in self.arch.regs:
self.regs[reg] = ("junk", )
val = emu[reg]
if init_regs.get(val, None):
self.regs[reg] = ("mov", init_regs[val])
continue
offset = gen_find(self.arch.pack(val), stack_data)
if offset != -1:
self.regs[reg] = ("stack", offset)
if self.regs[sp][0] == "junk":
self.move = emu[self.arch.stack_pointer] - stack
self.regs[sp] = ("add", self.move)
self.analysed = True
def __init__(self):
self.session = tf.InteractiveSession()
self.emulator = Emulator(settings)
settings['num_actions'] = len(self.emulator.actions)
with tf.variable_scope('model'):
self.model = Model(settings)
self.session.run(tf.initialize_all_variables())
self.saver = tf.train.Saver(max_to_keep=1000000)
checkpoint = tf.train.get_checkpoint_state("networks")
if checkpoint and checkpoint.model_checkpoint_path:
self.saver.restore(self.session, checkpoint.model_checkpoint_path)
print("Loaded checkpoint: {}".format(checkpoint.model_checkpoint_path))
else:
raise RuntimeError("Unable to load checkpoint")
cv2.startWindowThread()
cv2.namedWindow("preview")
cv2.namedWindow("full")
def configure(args):
"""create and configure an emulator"""
emu = Emulator(args, cpu='68000', frequency=8 * 1000 * 1000)
emu.add_memory(base=0, size=(16 * 1024 - 32) * 1024)
emu.add_device(args,
MC68681,
address=0xfff001,
interrupt=m68k.IRQ_2,
console_port='A',
register_arrangement='16-bit')
emu.add_device(args,
CompactFlash,
address=0xffe000,
register_arrangement='16-bit')
if args.eeprom is not None:
rom_image = open(args.eeprom, 'rb').read(32 * 1024 + 1)
if (len(rom_image) > (32 * 1024)):
raise RuntimeError(f'EEPROM image {args.eeprom} must be <= 32k')
print(f'loaded {len(rom_image)} bytes of EEPROM')
m68k.mem_write_bulk(0, rom_image)
return emu
def __init__(self,
name="",
client_id=None,
client_secret=None,
emulator=False,
debug=True,
template_folder='templates'):
self.name = name
self.emulator = emulator
self.debug = debug
self.web = flask.Flask(self.name,
static_folder=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'emulator'),
static_url_path='/emulator')
self.template_folder = template_folder
self.logger = self.web.logger
self.emulator_service = Emulator(app=self)
self.subscriptions = Subscriptions(app=self)
self.oauth = rauth.OAuth2Service(name=self.name,
client_id=client_id,
client_secret=client_secret,
access_token_url=self.OAUTH_ACCESS_TOKEN_URL,
authorize_url=self.OAUTH_AUTHORIZE_URL,
base_url=self.OAUTH_API_BASE_URL)
class Marionette(object):
CONTEXT_CHROME = 'chrome'
CONTEXT_CONTENT = 'content'
TIMEOUT_SEARCH = 'implicit'
TIMEOUT_SCRIPT = 'script'
TIMEOUT_PAGE = 'page load'
def __init__(self, host='localhost', port=2828, bin=None, profile=None,
emulator=None, sdcard=None, emulatorBinary=None,
emulatorImg=None, emulator_res='480x800', gecko_path=None,
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None, busybox=None):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self._test_name = None
if bin:
self.instance = GeckoInstance(host=self.host, port=self.port,
bin=self.bin, profile=self.profile)
self.instance.start()
assert(self.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.setup(self, gecko_path=gecko_path)
if busybox:
self.emulator.install_busybox(busybox)
def __del__(self):
if self.emulator:
self.emulator.close()
if self.instance:
self.instance.close()
for qemu in self.extra_emulators:
qemu.emulator.close()
@classmethod
def getMarionetteOrExit(cls, *args, **kwargs):
try:
m = cls(*args, **kwargs)
return m
except InstallGeckoError:
# Bug 812395 - the process of installing gecko into the emulator
# and then restarting B2G tickles some bug in the emulator/b2g
# that intermittently causes B2G to fail to restart. To work
# around this in TBPL runs, we will fail gracefully from this
# error so that the mozharness script can try the run again.
# This string will get caught by mozharness and will cause it
# to retry the tests.
print "Error installing gecko!"
# Exit without a normal exception to prevent mozharness from
# flagging the error.
sys.exit()
def wait_for_port(self, timeout=3000):
starttime = datetime.datetime.now()
while datetime.datetime.now() - starttime < datetime.timedelta(seconds=timeout):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((self.host, self.port))
data = sock.recv(16)
sock.close()
if '"from"' in data:
time.sleep(5)
return True
except socket.error:
pass
time.sleep(1)
return False
def _send_message(self, command, response_key, **kwargs):
if not self.session and command not in ('newSession', 'getStatus'):
raise MarionetteException(message="Please start a session")
message = { 'type': command }
if self.session:
message['session'] = self.session
if kwargs:
message.update(kwargs)
try:
response = self.client.send(message)
except socket.timeout:
self.session = None
self.window = None
self.client.close()
raise TimeoutException(message='socket.timeout', status=ErrorCodes.TIMEOUT, stacktrace=None)
# Process any emulator commands that are sent from a script
# while it's executing.
while response.get("emulator_cmd"):
response = self._handle_emulator_cmd(response)
if (response_key == 'ok' and response.get('ok') == True) or response_key in response:
return response[response_key]
else:
self._handle_error(response)
def _handle_emulator_cmd(self, response):
cmd = response.get("emulator_cmd")
if not cmd or not self.emulator:
raise MarionetteException(message="No emulator in this test to run "
"command against.")
cmd = cmd.encode("ascii")
result = self.emulator._run_telnet(cmd)
return self.client.send({"type": "emulatorCmdResult",
"id": response.get("id"),
"result": result})
def _handle_error(self, response):
if 'error' in response and isinstance(response['error'], dict):
status = response['error'].get('status', 500)
message = response['error'].get('message')
stacktrace = response['error'].get('stacktrace')
# status numbers come from
# http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes
if status == ErrorCodes.NO_SUCH_ELEMENT:
raise NoSuchElementException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_SUCH_FRAME:
raise NoSuchFrameException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.STALE_ELEMENT_REFERENCE:
raise StaleElementException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.ELEMENT_NOT_VISIBLE:
raise ElementNotVisibleException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_ELEMENT_STATE:
raise InvalidElementStateException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.UNKNOWN_ERROR:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.ELEMENT_IS_NOT_SELECTABLE:
raise ElementNotSelectableException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.JAVASCRIPT_ERROR:
raise JavascriptException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.XPATH_LOOKUP_ERROR:
raise XPathLookupException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.TIMEOUT:
raise TimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_SUCH_WINDOW:
raise NoSuchWindowException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_COOKIE_DOMAIN:
raise InvalidCookieDomainException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.UNABLE_TO_SET_COOKIE:
raise UnableToSetCookieException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_ALERT_OPEN:
raise NoAlertPresentException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.SCRIPT_TIMEOUT:
raise ScriptTimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_SELECTOR \
or status == ErrorCodes.INVALID_XPATH_SELECTOR \
or status == ErrorCodes.INVALID_XPATH_SELECTOR_RETURN_TYPER:
raise InvalidSelectorException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.MOVE_TARGET_OUT_OF_BOUNDS:
MoveTargetOutOfBoundsException(message=message, status=status, stacktrace=stacktrace)
else:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
raise MarionetteException(message=response, status=500)
def check_for_crash(self):
returncode = None
name = None
if self.emulator:
if self.emulator.check_for_crash():
returncode = self.emulator.proc.returncode
name = 'emulator'
elif self.instance:
# In the future, a check for crashed Firefox processes
# should be here.
pass
if returncode is not None:
print ('PROCESS-CRASH | %s | abnormal termination with exit code %d' %
(name, returncode))
return returncode is not None
def absolute_url(self, relative_url):
return "%s%s" % (self.baseurl, relative_url)
def status(self):
return self._send_message('getStatus', 'value')
def start_session(self, desired_capabilities=None):
# We are ignoring desired_capabilities, at least for now.
self.session = self._send_message('newSession', 'value')
self.b2g = 'b2g' in self.session
return self.session
@property
def test_name(self):
return self._test_name
@test_name.setter
def test_name(self, test_name):
if self._send_message('setTestName', 'ok', value=test_name):
self._test_name = test_name
def delete_session(self):
response = self._send_message('deleteSession', 'ok')
self.session = None
self.window = None
self.client.close()
return response
@property
def session_capabilities(self):
response = self._send_message('getSessionCapabilities', 'value')
return response
def set_script_timeout(self, timeout):
response = self._send_message('setScriptTimeout', 'ok', value=timeout)
return response
def set_search_timeout(self, timeout):
response = self._send_message('setSearchTimeout', 'ok', value=timeout)
return response
@property
def current_window_handle(self):
self.window = self._send_message('getWindow', 'value')
return self.window
@property
def title(self):
response = self._send_message('getTitle', 'value')
return response
@property
def window_handles(self):
response = self._send_message('getWindows', 'value')
return response
@property
def page_source(self):
response = self._send_message('getPageSource', 'value')
return response
def close(self, window_id=None):
if not window_id:
window_id = self.current_window_handle
response = self._send_message('closeWindow', 'ok', value=window_id)
return response
def set_context(self, context):
assert(context == self.CONTEXT_CHROME or context == self.CONTEXT_CONTENT)
return self._send_message('setContext', 'ok', value=context)
def switch_to_window(self, window_id):
response = self._send_message('switchToWindow', 'ok', value=window_id)
self.window = window_id
return response
def switch_to_frame(self, frame=None, focus=True):
if isinstance(frame, HTMLElement):
response = self._send_message('switchToFrame', 'ok', element=frame.id, focus=focus)
else:
response = self._send_message('switchToFrame', 'ok', value=frame, focus=focus)
return response
def get_url(self):
response = self._send_message('getUrl', 'value')
return response
def navigate(self, url):
response = self._send_message('goUrl', 'ok', value=url)
return response
def timeouts(self, timeout_type, ms):
assert(timeout_type == self.TIMEOUT_SEARCH or timeout_type == self.TIMEOUT_SCRIPT or timeout_type == self.TIMEOUT_PAGE)
response = self._send_message('timeouts', 'ok', timeoutType=timeout_type, ms=ms)
return response
def go_back(self):
response = self._send_message('goBack', 'ok')
return response
def go_forward(self):
response = self._send_message('goForward', 'ok')
return response
def refresh(self):
response = self._send_message('refresh', 'ok')
return response
def wrapArguments(self, args):
if isinstance(args, list):
wrapped = []
for arg in args:
wrapped.append(self.wrapArguments(arg))
elif isinstance(args, dict):
wrapped = {}
for arg in args:
wrapped[arg] = self.wrapArguments(args[arg])
elif type(args) == HTMLElement:
wrapped = {'ELEMENT': args.id }
elif (isinstance(args, bool) or isinstance(args, basestring) or
isinstance(args, int) or isinstance(args, float) or args is None):
wrapped = args
return wrapped
def unwrapValue(self, value):
if isinstance(value, list):
unwrapped = []
for item in value:
unwrapped.append(self.unwrapValue(item))
elif isinstance(value, dict):
unwrapped = {}
for key in value:
if key == 'ELEMENT':
unwrapped = HTMLElement(self, value[key])
else:
unwrapped[key] = self.unwrapValue(value[key])
else:
unwrapped = value
return unwrapped
def execute_js_script(self, script, script_args=None, async=True, new_sandbox=True, special_powers=False):
def __init__(
self,
host="localhost",
port=2828,
app=None,
app_args=None,
bin=None,
profile=None,
emulator=None,
sdcard=None,
emulatorBinary=None,
emulatorImg=None,
emulator_res=None,
gecko_path=None,
connectToRunningEmulator=False,
homedir=None,
baseurl=None,
noWindow=False,
logcat_dir=None,
busybox=None,
symbols_path=None,
timeout=None,
device_serial=None,
):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self._test_name = None
self.timeout = timeout
self.device_serial = device_serial
if bin:
port = int(self.port)
if not Marionette.is_port_available(port, host=self.host):
ex_msg = "%s:%d is unavailable." % (self.host, port)
raise MarionetteException(message=ex_msg)
if app:
# select instance class for the given app
try:
instance_class = geckoinstance.apps[app]
except KeyError:
msg = 'Application "%s" unknown (should be one of %s)'
raise NotImplementedError(msg % (app, geckoinstance.apps.keys()))
else:
try:
config = ConfigParser.RawConfigParser()
config.read(os.path.join(os.path.dirname(bin), "application.ini"))
app = config.get("App", "Name")
instance_class = geckoinstance.apps[app.lower()]
except (ConfigParser.NoOptionError, ConfigParser.NoSectionError, KeyError):
instance_class = geckoinstance.GeckoInstance
self.instance = instance_class(
host=self.host, port=self.port, bin=self.bin, profile=self.profile, app_args=app_args
)
self.instance.start()
assert self.wait_for_port(), "Timed out waiting for port!"
if emulator:
self.emulator = Emulator(
homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
symbols_path=symbols_path,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res,
)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert self.emulator.wait_for_port(), "Timed out waiting for port!"
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir, logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert self.emulator.wait_for_port(), "Timed out waiting for port!"
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.setup(self, gecko_path=gecko_path, busybox=busybox)
class Marionette(object):
CONTEXT_CHROME = 'chrome'
CONTEXT_CONTENT = 'content'
def __init__(self, host='localhost', port=2828, b2gbin=False,
emulator=None, emulatorBinary=None, connectToRunningEmulator=False,
homedir=None, baseurl=None, noWindow=False, logcat_dir=None):
self.host = host
self.port = self.local_port = port
self.b2gbin = b2gbin
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
if b2gbin:
self.b2ginstance = B2GInstance(host=self.host, port=self.port, b2gbin=self.b2gbin)
self.b2ginstance.start()
assert(self.b2ginstance.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
emulatorBinary=emulatorBinary)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir, logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
def __del__(self):
if self.emulator:
self.emulator.close()
if self.b2gbin:
self.b2ginstance.close()
for qemu in self.extra_emulators:
qemu.emulator.close()
def _send_message(self, command, response_key, **kwargs):
if not self.session and command not in ('newSession', 'getStatus'):
raise MarionetteException(message="Please start a session")
message = { 'type': command }
if self.session:
message['session'] = self.session
if kwargs:
message.update(kwargs)
try:
response = self.client.send(message)
except socket.timeout:
self.session = None
self.window = None
self.client.close()
if self.emulator:
port = self.emulator.restart(self.local_port)
if port is not None:
self.port = self.client.port = port
raise TimeoutException(message='socket.timeout', status=21, stacktrace=None)
# Process any emulator commands that are sent from a script
# while it's executing.
while response.get("emulator_cmd"):
response = self._handle_emulator_cmd(response)
if (response_key == 'ok' and response.get('ok') == True) or response_key in response:
return response[response_key]
else:
self._handle_error(response)
def _handle_emulator_cmd(self, response):
cmd = response.get("emulator_cmd")
if not cmd or not self.emulator:
raise MarionetteException(message="No emulator in this test to run "
"command against.")
cmd = cmd.encode("ascii")
result = self.emulator._run_telnet(cmd)
return self.client.send({"type": "emulatorCmdResult",
"id": response.get("id"),
"result": result})
def _handle_error(self, response):
if 'error' in response and isinstance(response['error'], dict):
status = response['error'].get('status', 500)
message = response['error'].get('message')
stacktrace = response['error'].get('stacktrace')
# status numbers come from
# http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes
if status == 7:
raise NoSuchElementException(message=message, status=status, stacktrace=stacktrace)
elif status == 8:
raise NoSuchFrameException(message=message, status=status, stacktrace=stacktrace)
elif status == 10:
raise StaleElementException(message=message, status=status, stacktrace=stacktrace)
elif status == 11:
raise ElementNotVisibleException(message=message, status=status, stacktrace=stacktrace)
elif status == 17:
raise JavascriptException(message=message, status=status, stacktrace=stacktrace)
elif status == 19:
raise XPathLookupException(message=message, status=status, stacktrace=stacktrace)
elif status == 21:
raise TimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == 23:
raise NoSuchWindowException(message=message, status=status, stacktrace=stacktrace)
elif status == 28:
raise ScriptTimeoutException(message=message, status=status, stacktrace=stacktrace)
else:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
raise MarionetteException(message=response, status=500)
def absolute_url(self, relative_url):
return "%s%s" % (self.baseurl, relative_url)
def status(self):
return self._send_message('getStatus', 'value')
def start_session(self, desired_capabilities=None):
# We are ignoring desired_capabilities, at least for now.
self.session = self._send_message('newSession', 'value')
self.b2g = 'b2g' in self.session
return self.session
def delete_session(self):
response = self._send_message('deleteSession', 'ok')
self.session = None
self.window = None
self.client.close()
return response
def get_session_capabilities(self):
response = self._send_message('getSessionCapabilities', 'value')
return response
def set_script_timeout(self, timeout):
response = self._send_message('setScriptTimeout', 'ok', value=timeout)
return response
def set_search_timeout(self, timeout):
response = self._send_message('setSearchTimeout', 'ok', value=timeout)
return response
def get_window(self):
self.window = self._send_message('getWindow', 'value')
return self.window
def get_windows(self):
response = self._send_message('getWindows', 'value')
return response
def close_window(self, window_id=None):
if not window_id:
window_id = self.get_window()
response = self._send_message('closeWindow', 'ok', value=window_id)
return response
def set_context(self, context):
assert(context == self.CONTEXT_CHROME or context == self.CONTEXT_CONTENT)
return self._send_message('setContext', 'ok', value=context)
def switch_to_window(self, window_id):
response = self._send_message('switchToWindow', 'ok', value=window_id)
self.window = window_id
return response
def switch_to_frame(self, frame=None):
if isinstance(frame, HTMLElement):
response = self._send_message('switchToFrame', 'ok', element=frame.id)
else:
response = self._send_message('switchToFrame', 'ok', value=frame)
return response
def get_url(self):
response = self._send_message('getUrl', 'value')
return response
def navigate(self, url):
response = self._send_message('goUrl', 'ok', value=url)
return response
def go_back(self):
response = self._send_message('goBack', 'ok')
return response
def go_forward(self):
response = self._send_message('goForward', 'ok')
return response
def refresh(self):
response = self._send_message('refresh', 'ok')
return response
def wrapArguments(self, args):
if isinstance(args, list):
wrapped = []
for arg in args:
wrapped.append(self.wrapArguments(arg))
elif isinstance(args, dict):
wrapped = {}
for arg in args:
wrapped[arg] = self.wrapArguments(args[arg])
elif type(args) == HTMLElement:
wrapped = {'ELEMENT': args.id }
elif (isinstance(args, bool) or isinstance(args, basestring) or
isinstance(args, int) or isinstance(args, float) or args is None):
wrapped = args
return wrapped
def unwrapValue(self, value):
if isinstance(value, list):
unwrapped = []
for item in value:
unwrapped.append(self.unwrapValue(item))
elif isinstance(value, dict):
unwrapped = {}
for key in value:
if key == 'ELEMENT':
unwrapped = HTMLElement(self, value[key])
else:
unwrapped[key] = self.unwrapValue(value[key])
else:
unwrapped = value
return unwrapped
def execute_js_script(self, script, script_args=None, timeout=True, new_sandbox=True):
if script_args is None:
script_args = []
args = self.wrapArguments(script_args)
response = self._send_message('executeJSScript',
'value',
value=script,
args=args,
timeout=timeout,
newSandbox=new_sandbox)
return self.unwrapValue(response)
def execute_script(self, script, script_args=None, new_sandbox=True):
if script_args is None:
script_args = []
args = self.wrapArguments(script_args)
response = self._send_message('executeScript',
'value',
value=script,
args=args,
newSandbox=new_sandbox)
return self.unwrapValue(response)
def execute_async_script(self, script, script_args=None, new_sandbox=True):
if script_args is None:
script_args = []
args = self.wrapArguments(script_args)
response = self._send_message('executeAsyncScript',
'value',
value=script,
args=args,
newSandbox=new_sandbox)
return self.unwrapValue(response)
def find_element(self, method, target, id=None):
kwargs = { 'value': target, 'using': method }
if id:
kwargs['element'] = id
response = self._send_message('findElement', 'value', **kwargs)
element = HTMLElement(self, response)
return element
def find_elements(self, method, target, id=None):
kwargs = { 'value': target, 'using': method }
if id:
kwargs['element'] = id
response = self._send_message('findElements', 'value', **kwargs)
assert(isinstance(response, list))
elements = []
for x in response:
elements.append(HTMLElement(self, x))
return elements
def log(self, msg, level=None):
return self._send_message('log', 'ok', value=msg, level=level)
def get_logs(self):
return self._send_message('getLogs', 'value')
import sys
from nes import Controller
from screen import Screen
from fps import FPS
from tas import TAS
from emulator import Emulator
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description = 'Dumps NES header information')
parser.add_argument('pathname', help='specify the NES file to open')
parser.add_argument('--tas', dest='tas', help='specify a TAS file to run', default=None)
parser.add_argument('--scale', dest='scale', help='specify the screen scale', default = 1)
args = parser.parse_args()
emulator = Emulator(args.pathname)
screen = Screen(args.scale)
fps = FPS()
if args.tas:
target_fps = 1000.0
tas = TAS(args.tas)
else:
target_fps = 60.0
tas = None
keep_going = True
while keep_going:
try:
# Get button presses
if tas == None:
pressed = pygame.key.get_pressed()
def __init__(self, host='localhost', port=2828, app=None, bin=None,
profile=None, emulator=None, sdcard=None, emulatorBinary=None,
emulatorImg=None, emulator_res=None, gecko_path=None,
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None, busybox=None, symbols_path=None):
self.host = host
self.port = self.local_port = port
self.app = app
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self._test_name = None
self.symbols_path = symbols_path
if bin:
port = int(self.port)
if not Marionette.is_port_available(port, host=self.host):
ex_msg = "%s:%d is unavailable." % (self.host, port)
raise MarionetteException(message=ex_msg)
if app:
# select instance class for the given app
try:
instance_class = geckoinstance.apps[app]
except KeyError:
msg = 'Application "%s" unknown (should be one of %s)'
raise NotImplementedError(msg % (app, geckoinstance.apps.keys()))
else:
instance_class = geckoinstance.GeckoInstance
self.instance = instance_class(host=self.host, port=self.port,
bin=self.bin, profile=self.profile)
self.instance.start()
assert(self.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.setup(self,
gecko_path=gecko_path,
busybox=busybox)
class Marionette(object):
"""
Represents a Marionette connection to a browser or device.
"""
CONTEXT_CHROME = 'chrome' # non-browser content: windows, dialogs, etc.
CONTEXT_CONTENT = 'content' # browser content: iframes, divs, etc.
TIMEOUT_SEARCH = 'implicit'
TIMEOUT_SCRIPT = 'script'
TIMEOUT_PAGE = 'page load'
def __init__(self, host='localhost', port=2828, app=None, app_args=None, bin=None,
profile=None, emulator=None, sdcard=None, emulatorBinary=None,
emulatorImg=None, emulator_res=None, gecko_path=None,
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None, busybox=None, symbols_path=None,
timeout=None, device_serial=None):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self._test_name = None
self.symbols_path = symbols_path
self.timeout = timeout
self.device_serial = device_serial
if bin:
port = int(self.port)
if not Marionette.is_port_available(port, host=self.host):
ex_msg = "%s:%d is unavailable." % (self.host, port)
raise MarionetteException(message=ex_msg)
if app:
# select instance class for the given app
try:
instance_class = geckoinstance.apps[app]
except KeyError:
msg = 'Application "%s" unknown (should be one of %s)'
raise NotImplementedError(msg % (app, geckoinstance.apps.keys()))
else:
instance_class = geckoinstance.GeckoInstance
self.instance = instance_class(host=self.host, port=self.port,
bin=self.bin, profile=self.profile, app_args=app_args)
self.instance.start()
assert(self.wait_for_port()), "Timed out waiting for port!"
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port()), "Timed out waiting for port!"
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port()), "Timed out waiting for port!"
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.setup(self,
gecko_path=gecko_path,
busybox=busybox)
def __del__(self):
if self.emulator:
self.emulator.close()
if self.instance:
self.instance.close()
for qemu in self.extra_emulators:
qemu.emulator.close()
@staticmethod
def is_port_available(port, host=''):
port = int(port)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.bind((host, port))
return True
except socket.error:
return False
finally:
s.close()
@classmethod
def getMarionetteOrExit(cls, *args, **kwargs):
try:
m = cls(*args, **kwargs)
return m
except InstallGeckoError:
# Bug 812395 - the process of installing gecko into the emulator
# and then restarting B2G tickles some bug in the emulator/b2g
# that intermittently causes B2G to fail to restart. To work
# around this in TBPL runs, we will fail gracefully from this
# error so that the mozharness script can try the run again.
# This string will get caught by mozharness and will cause it
# to retry the tests.
print "Error installing gecko!"
# Exit without a normal exception to prevent mozharness from
# flagging the error.
sys.exit()
def wait_for_port(self, timeout=30):
starttime = datetime.datetime.now()
while datetime.datetime.now() - starttime < datetime.timedelta(seconds=timeout):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((self.host, self.port))
data = sock.recv(16)
sock.close()
if '"from"' in data:
time.sleep(5)
return True
except socket.error:
pass
time.sleep(1)
return False
def _send_message(self, command, response_key, **kwargs):
if not self.session and command not in ('newSession', 'getStatus'):
raise MarionetteException(message="Please start a session")
message = { 'name': command }
if self.session:
message['sessionId'] = self.session
if kwargs:
message['parameters'] = kwargs
try:
response = self.client.send(message)
except socket.timeout:
self.session = None
self.window = None
self.client.close()
raise TimeoutException(message='socket.timeout', status=ErrorCodes.TIMEOUT, stacktrace=None)
# Process any emulator commands that are sent from a script
# while it's executing.
while response.get("emulator_cmd"):
response = self._handle_emulator_cmd(response)
if (response_key == 'ok' and response.get('ok') == True) or response_key in response:
return response[response_key]
else:
self._handle_error(response)
def _handle_emulator_cmd(self, response):
cmd = response.get("emulator_cmd")
if not cmd or not self.emulator:
raise MarionetteException(message="No emulator in this test to run "
"command against.")
cmd = cmd.encode("ascii")
result = self.emulator._run_telnet(cmd)
return self.client.send({"name": "emulatorCmdResult",
"id": response.get("id"),
"result": result})
def _handle_error(self, response):
if 'error' in response and isinstance(response['error'], dict):
status = response['error'].get('status', 500)
message = response['error'].get('message')
stacktrace = response['error'].get('stacktrace')
# status numbers come from
# http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes
if status == ErrorCodes.NO_SUCH_ELEMENT:
raise NoSuchElementException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_SUCH_FRAME:
raise NoSuchFrameException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.STALE_ELEMENT_REFERENCE:
raise StaleElementException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.ELEMENT_NOT_VISIBLE:
raise ElementNotVisibleException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_ELEMENT_STATE:
raise InvalidElementStateException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.UNKNOWN_ERROR:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.ELEMENT_IS_NOT_SELECTABLE:
raise ElementNotSelectableException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.JAVASCRIPT_ERROR:
raise JavascriptException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.XPATH_LOOKUP_ERROR:
raise XPathLookupException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.TIMEOUT:
raise TimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_SUCH_WINDOW:
raise NoSuchWindowException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_COOKIE_DOMAIN:
raise InvalidCookieDomainException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.UNABLE_TO_SET_COOKIE:
raise UnableToSetCookieException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_ALERT_OPEN:
raise NoAlertPresentException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.SCRIPT_TIMEOUT:
raise ScriptTimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_SELECTOR \
or status == ErrorCodes.INVALID_XPATH_SELECTOR \
or status == ErrorCodes.INVALID_XPATH_SELECTOR_RETURN_TYPER:
raise InvalidSelectorException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.MOVE_TARGET_OUT_OF_BOUNDS:
raise MoveTargetOutOfBoundsException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.FRAME_SEND_NOT_INITIALIZED_ERROR:
raise FrameSendNotInitializedError(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.FRAME_SEND_FAILURE_ERROR:
raise FrameSendFailureError(message=message, status=status, stacktrace=stacktrace)
else:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
raise MarionetteException(message=response, status=500)
def check_for_crash(self):
returncode = None
name = None
crashed = False
if self.emulator:
if self.emulator.check_for_crash():
returncode = self.emulator.proc.returncode
name = 'emulator'
crashed = True
if self.symbols_path and self.emulator.check_for_minidumps(self.symbols_path):
crashed = True
elif self.instance:
# In the future, a check for crashed Firefox processes
# should be here.
pass
if returncode is not None:
print ('PROCESS-CRASH | %s | abnormal termination with exit code %d' %
(name, returncode))
return crashed
def absolute_url(self, relative_url):
'''
Returns an absolute url for files served from Marionette's www directory.
:param relative_url: The url of a static file, relative to Marionette's www directory.
'''
return "%s%s" % (self.baseurl, relative_url)
def status(self):
return self._send_message('getStatus', 'value')
def start_session(self, desired_capabilities=None):
'''
Creates a new Marionette session.
You must call this method before performing any other action.
'''
try:
# We are ignoring desired_capabilities, at least for now.
self.session = self._send_message('newSession', 'value')
except:
exc, val, tb = sys.exc_info()
self.check_for_crash()
raise exc, val, tb
self.b2g = 'b2g' in self.session
return self.session
@property
def test_name(self):
return self._test_name
@test_name.setter
def test_name(self, test_name):
if self._send_message('setTestName', 'ok', value=test_name):
self._test_name = test_name
def delete_session(self):
response = self._send_message('deleteSession', 'ok')
self.session = None
self.window = None
self.client.close()
return response
@property
def session_capabilities(self):
'''
A JSON dictionary representing the capabilities of the current session.
'''
response = self._send_message('getSessionCapabilities', 'value')
return response
def set_script_timeout(self, timeout):
'''
Sets the maximum number of ms that an asynchronous script is allowed to run.
If a script does not return in the specified amount of time, a
ScriptTimeoutException is raised.
:param timeout: The maximum number of milliseconds an asynchronous
script can run without causing an ScriptTimeoutException to be raised
'''
response = self._send_message('setScriptTimeout', 'ok', ms=timeout)
return response
def set_search_timeout(self, timeout):
'''
Sets a timeout for the find methods.
When searching for an element using either
:class:`Marionette.find_element` or :class:`Marionette.find_elements`,
the method will continue trying to locate the element for up to timeout
ms. This can be useful if, for example, the element you're looking for
might not exist immediately, because it belongs to a page which is
currently being loaded.
:param timeout: Timeout in milliseconds.
'''
response = self._send_message('setSearchTimeout', 'ok', ms=timeout)
return response
@property
def current_window_handle(self):
'''
A reference to the current window.
'''
self.window = self._send_message('getWindow', 'value')
return self.window
@property
def title(self):
'''
Current title of the active window.
'''
response = self._send_message('getTitle', 'value')
return response
@property
def window_handles(self):
'''
A list of references to all available browser windows if called in
content context. If called while in the chrome context, it will list
all available windows, not just browser windows (ie: not just
'navigator:browser';).
'''
response = self._send_message('getWindows', 'value')
return response
@property
def page_source(self):
'''
A string representation of the DOM.
'''
response = self._send_message('getPageSource', 'value')
return response
def close(self, window_id=None):
'''
Closes the window that is in use by Marionette.
:param window_id: id of the window you wish to closed
'''
if not window_id:
window_id = self.current_window_handle
response = self._send_message('closeWindow', 'ok', value=window_id)
return response
def set_context(self, context):
'''
Sets the context that marionette commands are running in.
:param context: Context, may be one of the class properties
`CONTEXT_CHROME` or `CONTEXT_CONTENT`.
Usage example:
::
marionette.set_context(marionette.CONTEXT_CHROME)
'''
assert(context == self.CONTEXT_CHROME or context == self.CONTEXT_CONTENT)
return self._send_message('setContext', 'ok', value=context)
def switch_to_window(self, window_id):
'''
Switch to the specified window; subsequent commands will be directed at the new window.
:param window_id: The id or name of the window to switch to.
'''
response = self._send_message('switchToWindow', 'ok', name=window_id)
self.window = window_id
return response
def get_active_frame(self):
'''
Returns an HTMLElement representing the frame Marionette is currently acting on.
'''
response = self._send_message('getActiveFrame', 'value')
if response:
return HTMLElement(self, response)
return None
def switch_to_default_content(self):
'''
Switch the current context to page's default content.
'''
return self.switch_to_frame()
def switch_to_frame(self, frame=None, focus=True):
'''
Switch the current context to the specified frame. Subsequent commands will operate in the context of the specified frame, if applicable.
:param frame: A reference to the frame to switch to: this can be an HTMLElement, an index, name or an id attribute. If you call switch_to_frame() without an argument, it will switch to the top-level frame.
:param focus: A boolean value which determins whether to focus the frame that we just switched to.
'''
if isinstance(frame, HTMLElement):
response = self._send_message('switchToFrame', 'ok', element=frame.id, focus=focus)
else:
response = self._send_message('switchToFrame', 'ok', id=frame, focus=focus)
return response
def get_url(self):
'''
Returns the url of the active page in the browser.
'''
response = self._send_message('getUrl', 'value')
return response
def get_window_type(self):
'''
Gets the windowtype attribute of the window Marionette is currently acting on.
This command only makes sense in a chrome context. You might use this
method to distinguish a browser window from an editor window.
'''
response = self._send_message('getWindowType', 'value')
return response
def navigate(self, url):
'''
Causes the browser to navigate to the specified url.
:param url: The url to navigate to.
'''
response = self._send_message('goUrl', 'ok', url=url)
return response
def timeouts(self, timeout_type, ms):
assert(timeout_type == self.TIMEOUT_SEARCH or timeout_type == self.TIMEOUT_SCRIPT or timeout_type == self.TIMEOUT_PAGE)
response = self._send_message('timeouts', 'ok', type=timeout_type, ms=ms)
return response
def go_back(self):
'''
Causes the browser to perform a back navigation.
'''
response = self._send_message('goBack', 'ok')
return response
def go_forward(self):
'''
Causes the browser to perform a forward navigation.
'''
response = self._send_message('goForward', 'ok')
return response
def refresh(self):
'''
Causes the browser to perform to refresh the current page.
'''
response = self._send_message('refresh', 'ok')
return response
def wrapArguments(self, args):
if isinstance(args, list):
wrapped = []
for arg in args:
wrapped.append(self.wrapArguments(arg))
elif isinstance(args, dict):
wrapped = {}
for arg in args:
wrapped[arg] = self.wrapArguments(args[arg])
elif type(args) == HTMLElement:
wrapped = {'ELEMENT': args.id }
elif (isinstance(args, bool) or isinstance(args, basestring) or
isinstance(args, int) or isinstance(args, float) or args is None):
wrapped = args
return wrapped
def unwrapValue(self, value):
if isinstance(value, list):
unwrapped = []
for item in value:
unwrapped.append(self.unwrapValue(item))
elif isinstance(value, dict):
unwrapped = {}
for key in value:
if key == 'ELEMENT':
unwrapped = HTMLElement(self, value[key])
else:
unwrapped[key] = self.unwrapValue(value[key])
else:
unwrapped = value
return unwrapped
def execute_js_script(self, script, script_args=None, async=True,
new_sandbox=True, special_powers=False,
script_timeout=None, inactivity_timeout=None,
filename=None):
class Visualize(object):
def __init__(self):
self.session = tf.InteractiveSession()
self.emulator = Emulator(settings)
settings['num_actions'] = len(self.emulator.actions)
with tf.variable_scope('model'):
self.model = Model(settings)
self.session.run(tf.initialize_all_variables())
self.saver = tf.train.Saver(max_to_keep=1000000)
checkpoint = tf.train.get_checkpoint_state("networks")
if checkpoint and checkpoint.model_checkpoint_path:
self.saver.restore(self.session, checkpoint.model_checkpoint_path)
print("Loaded checkpoint: {}".format(checkpoint.model_checkpoint_path))
else:
raise RuntimeError("Unable to load checkpoint")
cv2.startWindowThread()
cv2.namedWindow("preview")
cv2.namedWindow("full")
def epsilon(self, test=False):
return settings['final_epsilon']
def choose_action(self, test=False):
if np.random.rand() < self.epsilon(test):
return random.randrange(len(self.emulator.actions))
else:
predictions = self.model.act_network.readout.eval({
self.model.images: [self.images]
})[0]
print predictions, np.argmax(predictions)
return np.argmax(predictions)
def episode(self, test=False, push_to=None):
self.emulator.reset()
self.images = np.dstack((self.emulator.image(),) * settings['phi_length'])
total_reward = 0
updates = 0
while True:
action = self.choose_action(test)
reward = self.emulator.act(action)
image = self.emulator.image()
cv2.imshow('preview', image)
cv2.imshow('full', self.emulator.full_image())
terminal = self.emulator.terminal()
if reward > 0:
print "reward:", reward
if terminal:
break
self.images = np.dstack((image, self.images[:,:,1:]))
total_reward += reward
time.sleep(0.1)
return total_reward
network.rewards: rewards
}
global summary_timer
summary_timer += 1
if timer > RECORD and summary_timer % SUMMARY_DELTA == 0:
writer.add_summary(
session.run(merged, feed_dict=feed_dict),
timer
)
train_op.run(feed_dict=feed_dict)
if __name__ == '__main__':
replay = deque([], maxlen=REPLAY_LEN)
emulator = Emulator(rom='breakout.bin')
session = tf.InteractiveSession()
with tf.variable_scope("network"):
network = Network(len(emulator.actions))
global_step = tf.Variable(0, name='global_step', trainable=False)
#optimizer = tf.train.RMSPropOptimizer(0.0002, 0.99, 0.99, 1e-6)
optimizer = tf.train.AdamOptimizer(1e-5)
grads_vars = optimizer.compute_gradients(network.cost)
clipped = [(tf.clip_by_norm(g, 5, name="clip_grads"), v) for (g, v) in grads_vars]
for g, v in clipped:
tf.histogram_summary("clipped_grad_" + v.name, g)
train_op = optimizer.apply_gradients(clipped, global_step=global_step, name="apply_grads")
#optimizer = tf.train.AdamOptimizer(25e-5, epsilon=0.1).minimize(network.cost)
class Engine(object):
def __init__(self):
self.session = tf.InteractiveSession()
self.emulator = Emulator(settings)
settings['num_actions'] = len(self.emulator.actions)
self.replay = ReplayDB(settings)
with tf.variable_scope('model'):
self.model = Model(settings)
self.summary = tf.merge_all_summaries()
self.writer = tf.train.SummaryWriter('summary-log', self.session.graph_def)
self.session.run(tf.initialize_all_variables())
self.saver = tf.train.Saver(max_to_keep=1000000)
checkpoint = tf.train.get_checkpoint_state("networks")
if checkpoint and checkpoint.model_checkpoint_path:
self.saver.restore(self.session, checkpoint.model_checkpoint_path)
print("Loaded checkpoint: {}".format(checkpoint.model_checkpoint_path))
else:
print("Unable to load checkpoint")
self.summary_cnt = 0
self.episode_cnt = 0
self.timer = self.session.run(self.model.global_step)
self.no_op = tf.no_op()
def epsilon(self, test=False):
e0 = settings['initial_epsilon']
e1 = settings['final_epsilon']
lim = settings['epsilon_anneal_length']
if test:
return e1
return e1 + max(0, (e0 - e1) * (lim - self.timer) / lim)
def choose_action(self, test=False):
if np.random.rand() < self.epsilon(test):
return random.randrange(len(self.emulator.actions))
else:
predictions = self.model.act_network.readout.eval({
self.model.images: [self.images]
})[0]
return np.argmax(predictions)
def episode(self, test=False, push_to=None):
self.emulator.reset()
self.images = np.dstack((self.emulator.image(),) * settings['phi_length'])
total_reward = 0
updates = 0
while True:
action = self.choose_action(test)
reward = self.emulator.act(action)
image = self.emulator.image()
terminal = self.emulator.terminal()
if not test:
self.replay.push(
image=image,
reward=reward,
action=action,
terminal=terminal
)
if push_to is not None:
push_to.append(action)
if terminal:
break
if not test and len(self.replay) >= settings['replay_start']:
if updates % settings['update_frequency'] == 0:
self.train()
updates += 1
self.images = np.dstack((image, self.images[:,:,1:]))
total_reward += reward
if not test:
self.episode_cnt += 1
if len(self.replay) >= settings['replay_start']:
self.writer.flush()
if self.episode_cnt % settings['save_every_episodes'] == 0:
self.saver.save(self.session, 'networks/checkpoint', global_step=self.timer)
return total_reward
def train(self):
minibatch = self.replay.sample()
action_mask = np.zeros((len(minibatch), settings['num_actions']))
for i, sample in enumerate(minibatch):
action_mask[i][sample.action] = 1
with_summary = self.summary_cnt % settings['write_summary_every'] == 0
self.summary_cnt += 1
_, summary = self.session.run([
self.model.train_op,
self.summary if with_summary else self.no_op],
{
self.model.images: [x.old_state for x in minibatch],
self.model.next_images: [x.new_state for x in minibatch],
self.model.action_mask: action_mask,
self.model.rewards: [x.reward for x in minibatch],
self.model.terminals: [x.terminal for x in minibatch]
}
)
if with_summary:
self.writer.add_summary(summary, self.timer)
self.timer += 1
if self.timer % settings['target_update_freq'] == 0:
self.session.run(self.model.reset_target_op)
import simh
import sys
if __name__ == '__main__':
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-s","--simh",action="store_true",default=False,
help="Use SIMH")
group.add_argument("-e","--emulator",type=str,default=None,
help="Console emulator port")
args = parser.parse_args()
emu = None
s = None
if args.simh:
emu = simh.SIMH("~/opt/bin/pdp11","./default.ini")
if args.emulator:
emu = Emulator(serial.Serial(args.emulator,9600,timeout=0.02))
o = LdaFile('pakdmp.lda')
for block in o.blocks:
emu.load_address(block.location)
for w in block.words:
emu.deposit_word(w)
emu.start(o.blocks[0].location)
emu.wait_for('READY')
emu.send('0')
for block in range(203):
sys.stdout.write(emu.read(014000 * 2))
from pascal_loader.main_io import PascalFile
from parse import Parser
from emulator import Emulator
if __name__ == '__main__':
pretty_printer = pprint.PrettyPrinter()
# UNCOMMENT the below statements one at a time
# tokens = get_token(PascalFile(input_file_location='simple_assignment.pas', output_location=''))
# tokens = get_token(PascalFile(input_file_location='complex_assignments.pas', output_location=''))
# tokens = get_token(PascalFile(input_file_location='control_repeat.pas', output_location=''))
# tokens = get_token(PascalFile(input_file_location='control_while.pas', output_location=''))
# tokens = get_token(PascalFile(input_file_location='control_if.pas', output_location=''))
# tokens = get_token(PascalFile(input_file_location='control_for.pas', output_location=''))
# tokens = get_token(PascalFile(input_file_location='case_statement.pas', output_location=''))
tokens = get_token(PascalFile(input_file_location='arrays.pas', output_location=''))
# This prints tokens, uncomment to see the generated tokens
# pretty_printer.pprint(tokens)
print '----------------------------------'
# setting verbose=True to parser will print to console as tokens are matched/warnings
# parser = Parser(token_list=tokens, verbose=True)
parser = Parser(token_list=tokens)
byte_array = parser.parse()
# This prints the byte array, uncomment to see the bytearray
# pretty_printer.pprint(byte_array)
print '----------------------------------'
emulator = Emulator(byte_array)
emulator.start()
from emulator import Emulator
from collections import deque, namedtuple
import random
import itertools
import numpy as np
import cv2
import time
if __name__ == '__main__':
emulator = Emulator(rom='SPCINVAD.BIN')
cv2.startWindowThread()
cv2.namedWindow("preview")
emulator.reset()
reward_episode = 0
print("Num frames per episode: {}".format(emulator.max_num_frames_per_episode))
for frame in range(emulator.max_num_frames_per_episode):
action_idx = int(input())
reward = emulator.act(emulator.actions[action_idx])
print("Instead: {}, i.e. {}, reward = {}".format(action_idx, emulator.actions[action_idx], reward))
if emulator.terminal():
break
reward_episode += reward
actions = np.zeros([len(emulator.actions)])
def main():
if DEMO_OUTPUT:
#from emulator import CombinedOutput # importing this without X fails
#output = CombinedOutput(SERIAL_DEVICE, BAUD, width=EMULATOR_WIDTH, height=EMULATOR_HEIGHT)
from emulator import Emulator # importing this without X fails
output = Emulator(width=EMULATOR_WIDTH, height=EMULATOR_HEIGHT)
else:
output = Serial(SERIAL_DEVICE, BAUD, timeout=1.5)
analyzer_read, analyzer_write = multiprocessing.Pipe(False)
analyzer = audio.Analyzer(analyzer_write, '/mnt/a/mpd.fifo', window_size=4096, squelch=False, std=False)
analyzer.start()
print "Analyzer started."
#layer_1 = Layer([util.Color(), util.Color(), util.Color(), util.Color()])
#layer_2 = Layer([util.Color(), util.Color(), util.Color(), util.Color()])
#layer_3 = Layer([util.Color(), util.Color(), util.Color(), util.Color()])
#layer_4 = Layer([util.Color(), util.Color(), util.Color(), util.Color()])
#pattern = HSVRotate(layer_1)
# WHOOP WHOOP ITS DA LIGHT OF DA POLICE
#pattern_1 = Irrlicht(layer_1, util.Color(hue=340, saturation=1, value=1), step=8, spot_width=140)
#pattern_1.deg = 180
#pattern_2 = Irrlicht(layer_2, util.Color(hue=200, saturation=1, value=1), step=8, spot_width=140)
#pattern_1 = Irrlicht(layer_1, util.Color(hue=250, saturation=1, value=0.5), step=0.36, spot_width=270)
#pattern_2 = Irrlicht(layer_2, util.Color(hue=30, saturation=1, value=0.8), step=0.36, spot_width=90)
#pattern_2.deg = 180
#pattern_3 = Irrlicht(layer_3, util.Color(hue=90, saturation=1, value=1.0), step=-0.2, spot_width=270)
# water-ish
#pattern_1 = Irrlicht(layer_1, util.Color(hue=200, saturation=1, value=0.2), step=2.17, spot_width=120)
#pattern_2 = Irrlicht(layer_2, util.Color(hue=190, saturation=1, value=0.2), step=-4.23, spot_width=200)
#pattern_3 = Irrlicht(layer_3, util.Color(hue=240, saturation=1, value=0.05), step=-16.1)
#pattern_4 = Irrlicht(layer_4, util.Color(hue=170, saturation=1, value=0.05), step=18.3)
# fire-ish
#pattern_1 = Irrlicht(layer_1, util.Color(hue=20, saturation=1, value=0.2), step=2, spot_width=200)
#pattern_1.deg = 180
#pattern_2 = Irrlicht(layer_2, util.Color(hue=40, saturation=1, value=1), step=-4, spot_width=200)
#pattern_3 = Irrlicht(layer_3, util.Color(hue=320, saturation=1, value=0.217), step=-16)
#pattern_4 = Irrlicht(layer_4, util.Color(hue=40, saturation=1, value=0.264317), step=12)
#pattern_1 = Ravelicht(4, util.Color(hue=40, saturation=1, value=1), spot_width=120)
#pattern_2 = Irrlicht(layer_2, util.Color(hue=180, saturation=1, value=1), step=-14, spot_width=140)
#pattern_2 = Visualizer(layer_2)
pattern_1 = Ravelichter(size=4)
display = Display(output, size=4, layers=[pattern_1])
time.sleep(2)
while True:
if analyzer_read.poll():
amplitudes = analyzer_read.recv()
if DEMO_OUTPUT:
#output.emulator.amplitudes = amplitudes
output.amplitudes = amplitudes
pattern_1.update(amplitudes)
#pattern_2.update(amplitudes)
#pattern_3.update()
#pattern_4.update()
display.update()
display.render()
class Marionette(object):
CONTEXT_CHROME = 'chrome'
CONTEXT_CONTENT = 'content'
def __init__(self, host='localhost', port=2828, bin=None, profile=None,
emulator=None, sdcard=None, emulatorBinary=None,
emulatorImg=None, emulator_res='480x800', gecko_path=None,
connectToRunningEmulator=False, homedir=None, baseurl=None,
noWindow=False, logcat_dir=None):
self.host = host
self.port = self.local_port = port
self.bin = bin
self.instance = None
self.profile = profile
self.session = None
self.window = None
self.emulator = None
self.extra_emulators = []
self.homedir = homedir
self.baseurl = baseurl
self.noWindow = noWindow
self.logcat_dir = logcat_dir
self.gecko_path = gecko_path
if bin:
self.instance = GeckoInstance(host=self.host, port=self.port,
bin=self.bin, profile=self.profile)
self.instance.start()
assert(self.instance.wait_for_port())
if emulator:
self.emulator = Emulator(homedir=homedir,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
arch=emulator,
sdcard=sdcard,
emulatorBinary=emulatorBinary,
userdata=emulatorImg,
res=emulator_res)
self.emulator.start()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
if connectToRunningEmulator:
self.emulator = Emulator(homedir=homedir,
logcat_dir=self.logcat_dir)
self.emulator.connect()
self.port = self.emulator.setup_port_forwarding(self.port)
assert(self.emulator.wait_for_port())
self.client = MarionetteClient(self.host, self.port)
if emulator:
self.emulator.wait_for_system_message(self)
if self.gecko_path:
self.emulator.install_gecko(self.gecko_path, self)
def __del__(self):
if self.emulator:
self.emulator.close()
if self.instance:
self.instance.close()
for qemu in self.extra_emulators:
qemu.emulator.close()
def _send_message(self, command, response_key, **kwargs):
if not self.session and command not in ('newSession', 'getStatus'):
raise MarionetteException(message="Please start a session")
message = { 'type': command }
if self.session:
message['session'] = self.session
if kwargs:
message.update(kwargs)
try:
response = self.client.send(message)
except socket.timeout:
self.session = None
self.window = None
self.client.close()
if self.emulator:
port = self.emulator.restart(self.local_port)
if port is not None:
self.port = self.client.port = port
raise TimeoutException(message='socket.timeout', status=ErrorCodes.TIMEOUT, stacktrace=None)
# Process any emulator commands that are sent from a script
# while it's executing.
while response.get("emulator_cmd"):
response = self._handle_emulator_cmd(response)
if (response_key == 'ok' and response.get('ok') == True) or response_key in response:
return response[response_key]
else:
self._handle_error(response)
def _handle_emulator_cmd(self, response):
cmd = response.get("emulator_cmd")
if not cmd or not self.emulator:
raise MarionetteException(message="No emulator in this test to run "
"command against.")
cmd = cmd.encode("ascii")
result = self.emulator._run_telnet(cmd)
return self.client.send({"type": "emulatorCmdResult",
"id": response.get("id"),
"result": result})
def _handle_error(self, response):
if 'error' in response and isinstance(response['error'], dict):
status = response['error'].get('status', 500)
message = response['error'].get('message')
stacktrace = response['error'].get('stacktrace')
# status numbers come from
# http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes
if status == ErrorCodes.NO_SUCH_ELEMENT:
raise NoSuchElementException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_SUCH_FRAME:
raise NoSuchFrameException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.STALE_ELEMENT_REFERENCE:
raise StaleElementException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.ELEMENT_NOT_VISIBLE:
raise ElementNotVisibleException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_ELEMENT_STATE:
raise InvalidElementStateException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.UNKNOWN_ERROR:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.ELEMENT_IS_NOT_SELECTABLE:
raise ElementNotSelectableException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.JAVASCRIPT_ERROR:
raise JavascriptException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.XPATH_LOOKUP_ERROR:
raise XPathLookupException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.TIMEOUT:
raise TimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_SUCH_WINDOW:
raise NoSuchWindowException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_COOKIE_DOMAIN:
raise InvalidCookieDomainException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.UNABLE_TO_SET_COOKIE:
raise UnableToSetCookieException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.NO_ALERT_OPEN:
raise NoAlertPresentException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.SCRIPT_TIMEOUT:
raise ScriptTimeoutException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.INVALID_SELECTOR \
or status == ErrorCodes.INVALID_XPATH_SELECTOR \
or status == ErrorCodes.INVALID_XPATH_SELECTOR_RETURN_TYPER:
raise InvalidSelectorException(message=message, status=status, stacktrace=stacktrace)
elif status == ErrorCodes.MOVE_TARGET_OUT_OF_BOUNDS:
MoveTargetOutOfBoundsException(message=message, status=status, stacktrace=stacktrace)
else:
raise MarionetteException(message=message, status=status, stacktrace=stacktrace)
raise MarionetteException(message=response, status=500)
def check_for_crash(self):
returncode = None
name = None
if self.emulator:
if self.emulator.check_for_crash():
returncode = self.emulator.proc.returncode
name = 'emulator'
elif self.instance:
# In the future, a check for crashed Firefox processes
# should be here.
pass
if returncode is not None:
print ('TEST-UNEXPECTED-FAIL - PROCESS CRASH - %s has terminated with exit code %d' %
(name, returncode))
return returncode is not None
def absolute_url(self, relative_url):
return "%s%s" % (self.baseurl, relative_url)
def status(self):
return self._send_message('getStatus', 'value')
def start_session(self, desired_capabilities=None):
# We are ignoring desired_capabilities, at least for now.
self.session = self._send_message('newSession', 'value')
self.b2g = 'b2g' in self.session
return self.session
def delete_session(self):
response = self._send_message('deleteSession', 'ok')
self.session = None
self.window = None
self.client.close()
return response
@property
def session_capabilities(self):
response = self._send_message('getSessionCapabilities', 'value')
return response
def set_script_timeout(self, timeout):
response = self._send_message('setScriptTimeout', 'ok', value=timeout)
return response
def set_search_timeout(self, timeout):
response = self._send_message('setSearchTimeout', 'ok', value=timeout)
return response
@property
def current_window_handle(self):
self.window = self._send_message('getWindow', 'value')
return self.window
@property
def title(self):
response = self._send_message('getTitle', 'value')
return response
@property
def window_handles(self):
response = self._send_message('getWindows', 'value')
return response
@property
def page_source(self):
response = self._send_message('getPageSource', 'value')
return response
def close(self, window_id=None):
if not window_id:
window_id = self.current_window_handle
response = self._send_message('closeWindow', 'ok', value=window_id)
return response
def set_context(self, context):
assert(context == self.CONTEXT_CHROME or context == self.CONTEXT_CONTENT)
return self._send_message('setContext', 'ok', value=context)
def switch_to_window(self, window_id):
response = self._send_message('switchToWindow', 'ok', value=window_id)
self.window = window_id
return response
def switch_to_frame(self, frame=None):
if isinstance(frame, HTMLElement):
response = self._send_message('switchToFrame', 'ok', element=frame.id)
else:
response = self._send_message('switchToFrame', 'ok', value=frame)
return response
def get_url(self):
response = self._send_message('getUrl', 'value')
return response
def navigate(self, url):
response = self._send_message('goUrl', 'ok', value=url)
return response
def go_back(self):
response = self._send_message('goBack', 'ok')
return response
def go_forward(self):
response = self._send_message('goForward', 'ok')
return response
def refresh(self):
response = self._send_message('refresh', 'ok')
return response
def wrapArguments(self, args):
if isinstance(args, list):
wrapped = []
for arg in args:
wrapped.append(self.wrapArguments(arg))
elif isinstance(args, dict):
wrapped = {}
for arg in args:
wrapped[arg] = self.wrapArguments(args[arg])
elif type(args) == HTMLElement:
wrapped = {'ELEMENT': args.id }
elif (isinstance(args, bool) or isinstance(args, basestring) or
isinstance(args, int) or isinstance(args, float) or args is None):
wrapped = args
return wrapped
def unwrapValue(self, value):
if isinstance(value, list):
unwrapped = []
for item in value:
unwrapped.append(self.unwrapValue(item))
elif isinstance(value, dict):
unwrapped = {}
for key in value:
if key == 'ELEMENT':
unwrapped = HTMLElement(self, value[key])
else:
unwrapped[key] = self.unwrapValue(value[key])
else:
unwrapped = value
return unwrapped
def execute_js_script(self, script, script_args=None, timeout=True, new_sandbox=True, special_powers=False):
if script_args is None:
script_args = []
args = self.wrapArguments(script_args)
response = self._send_message('executeJSScript',
'value',
value=script,
args=args,
timeout=timeout,
newSandbox=new_sandbox,
specialPowers=special_powers)
return self.unwrapValue(response)
def execute_script(self, script, script_args=None, new_sandbox=True, special_powers=False):
if script_args is None:
script_args = []
args = self.wrapArguments(script_args)
response = self._send_message('executeScript',
'value',
value=script,
args=args,
newSandbox=new_sandbox,
specialPowers=special_powers)
return self.unwrapValue(response)
def execute_async_script(self, script, script_args=None, new_sandbox=True, special_powers=False):
if script_args is None:
script_args = []
args = self.wrapArguments(script_args)
response = self._send_message('executeAsyncScript',
'value',
value=script,
args=args,
newSandbox=new_sandbox,
specialPowers=special_powers)
return self.unwrapValue(response)
def find_element(self, method, target, id=None):
kwargs = { 'value': target, 'using': method }
if id:
kwargs['element'] = id
response = self._send_message('findElement', 'value', **kwargs)
element = HTMLElement(self, response)
return element
def find_elements(self, method, target, id=None):
kwargs = { 'value': target, 'using': method }
if id:
kwargs['element'] = id
response = self._send_message('findElements', 'value', **kwargs)
assert(isinstance(response, list))
elements = []
for x in response:
elements.append(HTMLElement(self, x))
return elements
def log(self, msg, level=None):
return self._send_message('log', 'ok', value=msg, level=level)
def get_logs(self):
return self._send_message('getLogs', 'value')
def add_perf_data(self, suite, name, value):
return self._send_message('addPerfData', 'ok', suite=suite, name=name, value=value)
def get_perf_data(self):
return self._send_message('getPerfData', 'value')
def import_script(self, js_file):
js = ''
with open(js_file, 'r') as f:
js = f.read()
return self._send_message('importScript', 'ok', script=js)
@property
def application_cache(self):
return ApplicationCache(self)
class Lifter2():
# TODO: SIGINT handler
def __init__(self,map_file):
self.emu = Emulator(open(map_file, 'r'), '')
self.emu.suppress_prints = True
self.MAX_DEPTH = self.emu.command_limit
self.MAX_LEAVES = 10000000
self.MAX_SCORE = 75.0*self.emu.total_lambdas
print 'MAX DEPTH: ' + str(self.MAX_DEPTH)
print 'MAX LEAVES: ' + str(self.MAX_LEAVES)
print 'MAX SCORE: ' + str(self.MAX_SCORE)
self.best_score = 0.0
self.best_seed = -1
self.best_path = ''
def simSAMC(self,seed):
random.seed = seed
leafs = deque()
node0 = NState(0.0,0,'')
leafs.append(node0)
# use SA to expand branch
while ((len(leafs) > 0) &
(len(leafs) <= self.MAX_LEAVES)):
# pick the node
node = leafs.popleft()
#kT = 1 - node.depth/self.MAX_DEPTH # temprature
#kT = self.MAX_DEPTH - node.depth
kT = (self.MAX_DEPTH - node.depth) * self.MAX_SCORE
if (kT <= 0):
print 'touch bottom: ' + node.cmds
break
# with prob e(score/T) to expand
#energy = 1 - node.score/self.MAX_SCORE
energy = self.MAX_SCORE - node.score
if (random.random() < \
math.exp(-energy/kT)):
#print "to expand: " + \
# node.cmds + \
# '[depth: '+ str(node.depth) + \
# ' score: ' + str(node.score) + \
# ' proba: ' + str(math.exp(-energy/kT)) + ']'
for cmd in VALID_COMMANDS:
if cmd != COMMAND_SHAVE:
cmds = node.cmds + cmd
#print cmds
isdead, isquit, score = \
self.emu.getResults(cmds)
#print isdead
#print isquit
#print score
if not isdead:
if not isquit:
# use MC to cut branch
denergy = \
(score - node.score)
if ((denergy > 0) | \
(random.random() < \
math.exp(denergy/kT))):
#print '\taccept ' + cmd + ' with '\
# + 'proba: ' + \
# str(math.exp(denergy/kT))
newnode = NState(score, \
node.depth+1, \
cmds)
leafs.append(newnode)
else: # end of game
if (self.best_score < score):
self.best_score = score
print cmds + ': ' + str(score)
# ("DDDLLUURDLDL")
def startExplore(self):
# simulate a bunche of rand seeds
random.seed = 100
idx = 0
while 1:
seed = random.randint(1,10000)
print 'SEED: ' + str(seed)
self.simSAMC(seed)
idx = idx + 1
if (idx > 100): break
def endExplore(self):
# produce final results on SIGINT
print "TODO"
def scan(images=True):
""" scanning method that will scan all images or containers """
# FIXME using default 'unix://var/run/docker.sock'
client = docker.Client(base_url='unix://var/run/docker.sock')
emu = Emulator()
objs = client.images(quiet=True)
driver = client.info()['Driver']
# If there are no images/containers on the machine, objs will be ['']
if objs == ['']:
return
# does actual work here!
for im in objs:
try:
emu.create_dirs()
cid = mount_obj(emu.tmp_image_dir, im, driver)
if emu.is_applicable():
print "scanning " + im[:12]
emu.intial_setup()
emu.chroot_and_run()
emu.unmount()
else:
print im[:12] + " is not RHEL based"
unmount_obj(emu.tmp_image_dir, cid, driver)
emu.remove_dirs()
except MountError as dme:
force_clean(cid, client, emu)
print "Red Hat Insights was unable to complete " \
"due to the below error. All mounts and devices " \
"have been removed."
raise ValueError(str(dme))
except EmulatorError as eme:
force_clean(cid, client, emu)
print "Red Hat Insights was unable to complete " \
"due to the below error. All mounts and devices " \
"have been removed."
raise ValueError(str(eme))
emu.gather_data()
class Application(object):
OAUTH_ACCESS_TOKEN_URL = "https://accounts.google.com/o/oauth2/token"
OAUTH_AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/auth"
OAUTH_REDIRECT_URI = "authentification/google"
OAUTH_API_BASE_URL = "https://www.googleapis.com/"
OAUTH_SCOPES = [
'https://www.googleapis.com/auth/glass.location',
'https://www.googleapis.com/auth/glass.timeline',
'https://www.googleapis.com/auth/userinfo.profile',
'https://www.googleapis.com/auth/userinfo.email'
]
def __init__(self,
name="",
client_id=None,
client_secret=None,
emulator=False,
debug=True,
template_folder='templates'):
self.name = name
self.emulator = emulator
self.debug = debug
self.web = flask.Flask(self.name,
static_folder=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'emulator'),
static_url_path='/emulator')
self.template_folder = template_folder
self.logger = self.web.logger
self.emulator_service = Emulator(app=self)
self.subscriptions = Subscriptions(app=self)
self.oauth = rauth.OAuth2Service(name=self.name,
client_id=client_id,
client_secret=client_secret,
access_token_url=self.OAUTH_ACCESS_TOKEN_URL,
authorize_url=self.OAUTH_AUTHORIZE_URL,
base_url=self.OAUTH_API_BASE_URL)
@property
def oauth_redirect_uri(self):
return "%s/glass/oauth/callback" % (self.host)
def _oauth_authorize(self):
"""
(view) Display the authorization window for Google Glass
"""
params = {
'approval_prompt': 'force',
'scope': " ".join(self.OAUTH_SCOPES),
'state': '/profile',
'redirect_uri': self.oauth_redirect_uri,
'response_type': 'code'
}
url = self.oauth.get_authorize_url(**params)
return flask.redirect(url)
def _oauth_callback(self):
"""
(view) Callback for the oauth
"""
token = self.oauth.get_access_token(data={
'code': flask.request.args.get('code', ''),
'redirect_uri': self.oauth_redirect_uri,
'grant_type': 'authorization_code'
}, decoder=json.loads)
user = User(token=token, app=self)
# Add subscriptions
self.subscriptions.init_user(user)
# Call endpoint for user login
self.subscriptions.call_endpoint("login", user)
return token
def run(self, host="http://localhost", port=8080, debug=None):
"""
Start the application server
"""
if self.emulator:
self.emulator_service.run()
self.port = port
self.host = host
if port != 80:
self.host = "%s:%i" % (self.host, self.port)
# OAUTH
self.web.add_url_rule('/glass/oauth/authorize', 'oauth_authorize', self._oauth_authorize)
self.web.add_url_rule('/glass/oauth/callback', 'oauth_callback', self._oauth_callback)
self.web.debug = debug or self.debug
# Run webserver
self.web.run(port=self.port)
