Esempio n. 1
0
	def push(self, username=None, password=None):
		if not self.repo_is_defined:
			error("No Git repository found for the current directory.")
			self.repo.git.push()
			return
		try:
			pexpect.spawnu('git push')
		except:
			try:
				self.repo.git.push()
				print("Push was successful")
			except Exception as e:
				error("Git push failed!")
				print(type(e))
			return
		try:
			g.logfile_read = sys.stdout
			if not username: username = ''
			if not password: password = ''
			while True:
				i = g.expect([u'Username for .*', u'Password for .*', pexpect.EOF])
				if(i == 0):
					g.send(username+'\n')
				elif(i == 1):
					# Python 2
					# g.send(codecs.decode(password, 'base64')+'\n')
					# End Python 2
	       			# Python 3
					g.send(str(codecs.decode(password.encode(), 'base64'), 'utf-8')+'\n')
					# End Python 3
				else:
					break
		except:
			print("Notice: Auto-credentials currently not operational")
		'''
    def test_default_eclipse_adt_install(self):
        """Install eclipse adt from scratch test case"""
        self.child = pexpect.spawnu(self.command('{} android eclipse-adt'.format(UDTC)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("\[I Accept.*\]")  # ensure we have a license question
        self.child.sendline("a")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_no_warn()

        # we have an installed launcher, added to the launcher and an icon file
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assertTrue(self.path_exists(self.exec_path))
        self.assertTrue(self.path_exists(get_icon_path(self.icon_filename)))
        self.assertTrue(self.is_in_path("adb"))
        self.assertTrue(self.is_in_path("ddms"))

        # launch it, send SIGTERM and check that it exits fine
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL)

        # on 64 bits, there is a java subprocess, we kill that one with SIGKILL (eclipse isn't reliable on SIGTERM)
        if self.arch_option == "x86_64":
            self.check_and_kill_process(["java", self.arch_option, self.installed_path],
                                        wait_before=self.TIMEOUT_START, send_sigkill=True)
        else:
            self.check_and_kill_process([self.exec_path],
                                        wait_before=self.TIMEOUT_START, send_sigkill=True)
        proc.wait(self.TIMEOUT_STOP)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} android eclipse-adt'.format(UDTC)))
        self.expect_and_no_warn("Eclipse ADT is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_no_warn()
Esempio n. 3
0
def test_tcpv6_send(board_group, application, env=None):
    env_client = os.environ.copy()
    if env != None:
        env_client.update(env)
    env_client.update(board_group.boards[0].to_env())
    env_server = os.environ.copy()
    if env != None:
        env_server.update(env)
    env_server.update(board_group.boards[1].to_env())
    with pexpect.spawnu("make", ["-C", application, "term"], env=env_client,
                        timeout=DEFAULT_TIMEOUT) as client, \
         pexpect.spawnu("make", ["-C", application, "term"], env=env_server,
                        timeout=DEFAULT_TIMEOUT) as server:
        port = random.randint(0x0000, 0xffff)
        server_ip = get_ipv6_address(server)
        client_ip = get_ipv6_address(client)

        server.sendline(u"tcp server start %d" % port)
        # wait for neighbor discovery to be done
        time.sleep(5)
        client.sendline(u"tcp connect %s %d" % (server_ip, port))
        server.expect(u"TCP client \\[%s\\]:[0-9]+ connected" % client_ip)
        client.sendline(u"tcp send affe:abe")
        client.expect_exact(u"Success: send 4 byte over TCP to server")
        server.expect(u"00000000  AF  FE  AB  E0")
        client.sendline(u"tcp disconnect")
        client.sendline(u"tcp send affe:abe")
        client.expect_exact(u"could not send")
    def test_adt_reinstall_other_non_empty_path(self):
        """Reinstall eclipse adt on another path (non empty) once installed should remove the first version"""
        original_install_path = self.installed_path
        if not self.in_container:
            self.reinstalled_path = tempfile.mkdtemp()
        else:  # we still give a path for the container
            self.reinstalled_path = os.path.join(tempfile.gettempdir(), "tmptests")
        self.create_file(os.path.join(self.reinstalled_path, "bar"), "foo")
        for loop in ("install", "reinstall"):
            if loop == "reinstall":
                self.installed_path = self.reinstalled_path
                self.child = pexpect.spawnu(self.command('{} android eclipse-adt {}'.format(UDTC, self.installed_path)))
                self.expect_and_no_warn("Eclipse ADT is already installed.*\[.*\] ")
                self.child.sendline("y")
                self.expect_and_no_warn("{} isn't an empty directory.*there\? \[.*\] ".format(self.installed_path))
                self.child.sendline("y")
            else:
                self.child = pexpect.spawnu(self.command('{} android eclipse-adt'.format(UDTC)))
                self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
                self.child.sendline("")
            self.expect_and_no_warn("\[.*\] ")
            self.child.sendline("a")
            self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
            self.wait_and_no_warn()

            # we have an installed launcher, added to the launcher
            self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
            self.assertTrue(self.path_exists(self.exec_path))
            self.assertTrue(self.path_exists(get_icon_path(self.icon_filename)))

        # ensure that version first isn't installed anymore
        self.assertFalse(self.path_exists(original_install_path))
    def test_adt_reinstall_other_path(self):
        """Reinstall eclipse adt on another path once installed should remove the first version"""
        original_install_path = self.installed_path
        for loop in ("install", "reinstall"):
            if loop == "reinstall":
                self.installed_path = "/tmp/foo"
                self.child = pexpect.spawnu(self.command('{} android eclipse-adt {}'.format(UDTC, self.installed_path)))
                self.expect_and_no_warn("Eclipse ADT is already installed.*\[.*\] ")
                self.child.sendline("y")
            else:
                self.child = pexpect.spawnu(self.command('{} android eclipse-adt'.format(UDTC)))
                self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
                self.child.sendline("")
            self.expect_and_no_warn("\[.*\] ")
            self.child.sendline("a")
            self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
            self.wait_and_no_warn()

            # we have an installed launcher, added to the launcher
            self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
            self.assertTrue(self.path_exists(self.exec_path))
            self.assertTrue(self.path_exists(get_icon_path(self.icon_filename)))

        # ensure that version first isn't installed anymore
        self.assertFalse(self.path_exists(original_install_path))
Esempio n. 6
0
    def test_default_install(self):
        """Install visual studio from scratch test case"""

        self.child = pexpect.spawnu(self.command('{} web visual-studio-code'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("\[I Accept.*\]")  # ensure we have a license question
        self.child.sendline("a")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_no_warn()

        # we have an installed launcher, added to the launcher and an icon file
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assert_exec_exists()
        self.assert_icon_exists()

        # launch it, send SIGTERM and check that it exits fine
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL)

        self.check_and_kill_process(["Code", self.installed_path],
                                    wait_before=self.TIMEOUT_START, send_sigkill=True)
        proc.wait(self.TIMEOUT_STOP)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} web visual-studio-code'.format(UMAKE)))
        self.expect_and_no_warn("Visual Studio Code is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_no_warn()
Esempio n. 7
0
    def test_default_stencyl_install(self):
        """Install stencyl from scratch test case"""
        self.child = pexpect.spawnu(self.command('{} games stencyl'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_no_warn()

        # we have an installed launcher, added to the launcher
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assert_exec_exists()
        self.assert_icon_exists()

        # launch it, send SIGTERM and check that it exits fine
        use_cwd = self.installed_path
        if self.in_container:
            use_cwd = None
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL, cwd=use_cwd)
        self.check_and_kill_process(["./runtimes/jre-linux/bin/java"], wait_before=self.TIMEOUT_START)
        proc.wait(self.TIMEOUT_STOP)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} games stencyl'.format(UMAKE)))
        self.expect_and_no_warn("Stencyl is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_no_warn()
Esempio n. 8
0
    def test_default_install(self):
        """Install the distribution from scratch test case"""
        self.child = pexpect.spawnu(self.command('{} ide arduino'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_close()

        # we have an installed launcher, added to the launcher and an icon file
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assert_exec_exists()
        self.assert_icon_exists()
        self.assertTrue(self.is_in_group("dialout"))

        # launch it, send SIGTERM and check that it exits fine
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL)

        self.check_and_kill_process(["java", "processing.app.Base"], wait_before=self.TIMEOUT_START)
        proc.wait(self.TIMEOUT_STOP)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} ide arduino'.format(UMAKE)))
        self.expect_and_no_warn("Arduino is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_close()
    def test_default_android_studio_install(self):
        """Install android studio from scratch test case"""
        self.child = pexpect.spawnu(self.command('{} android android-studio'.format(UDTC)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("\[I Accept.*\]")  # ensure we have a license question
        self.child.sendline("a")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_no_warn()

        # we have an installed launcher, added to the launcher
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assertTrue(self.path_exists(self.exec_path))
        self.assertTrue(self.is_in_path("adb"))
        self.assertTrue(self.is_in_path("ddms"))

        # launch it, send SIGTERM and check that it exits fine
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL)
        self.check_and_kill_process(["java", self.installed_path], wait_before=self.TIMEOUT_START)
        self.assertEquals(proc.wait(self.TIMEOUT_STOP), 0)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} android android-studio'.format(UDTC)))
        self.expect_and_no_warn("Android Studio is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_no_warn()
Esempio n. 10
0
    def test_default_android_sdk_install(self):
        """Install android sdk from scratch test case"""
        self.child = pexpect.spawnu(self.command('{} android android-sdk'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("\[I Accept.*\]")  # ensure we have a license question
        self.child.sendline("a")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_close()

        # we have an installed sdk exec
        self.assert_exec_exists()
        self.assertTrue(self.is_in_path(self.exec_path))

        # launch it, send SIGTERM and check that it exits fine
        self.assertEqual(subprocess.check_call(self.command_as_list([self.exec_path, "list"]),
                                               stdout=subprocess.DEVNULL,
                                               stderr=subprocess.DEVNULL),
                         0)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} android android-sdk'.format(UMAKE)))
        self.expect_and_no_warn("Android SDK is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_close()
Esempio n. 11
0
    def test_default_install(self):
        """Install from scratch test case"""
        self.child = pexpect.spawnu(self.command('{} ide pycharm'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_no_warn()

        logger.info("Installed, running...")

        # we have an installed launcher, added to the launcher and an icon file
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assertTrue(self.path_exists(self.exec_path))
        self.assertTrue(self.path_exists(self.full_icon_path))

        # launch it, send SIGTERM and check that it exits fine
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL)

        self.check_and_kill_process(["java", self.installed_path], wait_before=self.TIMEOUT_START)
        proc.wait(self.TIMEOUT_STOP)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} ide pycharm'.format(UMAKE)))
        self.expect_and_no_warn("PyCharm is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_no_warn()
Esempio n. 12
0
    def test_default_unity3D_install(self):
        """Install unity3D editor from scratch test case"""

        # only an amd64 test
        if platform.machine() != "x86_64":
            return

        self.child = pexpect.spawnu(self.command('{} games unity3d'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_close()

        # we have an installed launcher, added to the launcher
        self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
        self.assert_exec_exists()
        self.assert_icon_exists()

        # ensure setuid
        self.assertEqual(self.get_file_perms(os.path.join(self.installed_path, "Editor", "chrome-sandbox")),
                         '-rwsr-xr-x')

        # launch it, send SIGTERM and check that it exits fine
        proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                stderr=subprocess.DEVNULL)
        self.check_and_kill_process([self.exec_path], wait_before=self.TIMEOUT_START)
        proc.wait(self.TIMEOUT_STOP)

        # ensure that it's detected as installed:
        self.child = pexpect.spawnu(self.command('{} games unity3d'.format(UMAKE)))
        self.expect_and_no_warn("Unity3d is already installed.*\[.*\] ")
        self.child.sendline()
        self.wait_and_close()
Esempio n. 13
0
    def get_kerberos_ticket(username, password):
        """Attempts to create a Kerberos ticket for a user.

        Args:
            username
                The username.
            password
                The password.

        Returns:
            Boolean indicating success or failure of ticket creation

        """

        cache = "/tmp/ion-%s" % uuid.uuid4()

        logger.debug("Setting KRB5CCNAME to 'FILE:{}'".format(cache))
        os.environ["KRB5CCNAME"] = "FILE:" + cache

        try:
            realm = settings.CSL_REALM
            kinit = pexpect.spawnu("/usr/bin/kinit {}@{}".format(username, realm), timeout=settings.KINIT_TIMEOUT)
            kinit.expect(":")
            kinit.sendline(password)
            returned = kinit.expect([pexpect.EOF, "password:"******"Password for {}@{} expired, needs reset".format(username, realm))
                return "reset"
            kinit.close()
            exitstatus = kinit.exitstatus
        except pexpect.TIMEOUT:
            KerberosAuthenticationBackend.kinit_timeout_handle(username, realm)
            exitstatus = 1

        if exitstatus != 0:
            try:
                realm = settings.AD_REALM
                kinit = pexpect.spawnu("/usr/bin/kinit {}@{}".format(username, realm), timeout=settings.KINIT_TIMEOUT)
                kinit.expect(":")
                kinit.sendline(password)
                kinit.expect([pexpect.EOF, "password:"******"KRB5CCNAME" in os.environ:
            subprocess.check_call(['kdestroy', '-c', os.environ["KRB5CCNAME"]])
            del os.environ["KRB5CCNAME"]

        if exitstatus == 0:
            logger.debug("Kerberos authorized {}@{}".format(username, realm))
            return True
        else:
            logger.debug("Kerberos failed to authorize {}".format(username))
            return False
Esempio n. 14
0
 def run(install_dir,admin_email, admin_password):
     child = pexpect.spawnu("{}".format(os.path.join(install_dir,"seafile-server-latest","seahub.sh")),["start-fastcgi"],timeout=180)
     child.logfile = sys.stdout
     child.expect_exact("[ admin email ]")
     child.sendline(admin_email)
     child.expect_exact("[ admin password ]")
     child.sendline(admin_password)
     child.expect_exact("[ admin password again ]")
     child.sendline(admin_password)
     child = pexpect.spawnu("{}".format(os.path.join(install_dir,"seafile-server-latest","seahub.sh")),["stop"],timeout=180)
     child.expect(pexpect.EOF) 
     child = pexpect.spawnu("{}".format(os.path.join(install_dir,"seafile-server-latest","seafile.sh")),["stop"],timeout=180)
     child.expect(pexpect.EOF)
Esempio n. 15
0
def connectToSeed():
    """ Create a Pexpect connecton to the seedhost """
    # Use spawnu for Python3 compatibility

    ssh_passwd_opts=''
    if CONFIG['seed_password'] == '':
        command = '/usr/bin/ssh ' + ssh_passwd_opts + ' ' + CONFIG['seed_login']
        DEBUG(1, "Logging in to seed using ssh-keys <" + command + ">")
        client = pexpect.spawnu(command)
        seen = client.expect('^.+')
        if seen == 0:
            DEBUG(1, client.before)
            #FAIL("SSH-KEYS: failed to log in to seedhost <" + CONFIG['seed_login'] + "> using ssh-keys")
        STEP("SEEDHOST")
        return client

    #ssh_passwd_opts='-o PreferredAuthentications=keyboard-interactive -o PubkeyAuthentication=no'
    ssh_passwd_opts='-o PubkeyAuthentication=no'
    command = '/usr/bin/ssh ' + ssh_passwd_opts + ' ' + CONFIG['seed_login']
    DEBUG(1, "Logging in to seed using password <" + command + ">")
    client = pexpect.spawnu(command)
    # [email protected]'s password:
    #seen = client.expect('.+s password:'******'password:'******'s input and out to a file or the screen.
        # The following will turn on logging and send output to stdout (the screen).
        #client = pexpect.spawn (foo)
        #client.logfile = sys.stdout
        sys.exit(1)

    #if VERBOSE: DEBUG(1, "SEEN=" + str(seen))
    if seen == 0:
        DEBUG(1, client.before)
        #FAIL("PASSWORD: failed to log in to seedhost <" + CONFIG['seed_login'] + "> using password")

    DEBUG(1, "Sending password (contains " + str(len(CONFIG['seed_password'])) + " chars)")
    client.sendline(CONFIG['seed_password'])
    #FAIL("PASSWORD")

    STEP("SEEDHOST")
    return client
Esempio n. 16
0
def check_swport_usage(sw_pair,SW1,SW2,username,password):
    # uses pexpect to obtain switchport status outputs from SW1 and SW2
    print()
    input('Hit Enter to check the switchport statuses on '+sw_pair+':')
    print()
    for switch in [SW1,SW2]:
        try:
            child = pexpect.spawnu('telnet '+switch+'.dn.net')
            child.expect('Username: '******'Password: '******'6513-'+switch+'-(sec-)*c\d{1,2}#',timeout=3)
            print('====================================')
            print(switch+':\n')
            child.sendline('term len 55')
            child.expect('6513-'+switch+'-(sec-)*c\d{1,2}#',timeout=3)
            child.sendline('sh int status mod 4')
            child.expect('Gi4/25',timeout=3)
            print(child.before)
            child.sendline('exit')
        except (EOF,TIMEOUT,ExceptionPexpect):
            print('ERROR: Unable to display mod 4 interface statuses from '+switch)
            print('Try checking statuses manually instead:')
            print()
            print('  '+switch+':')
            print('    sh int status mod 4')
            print()

        try:
            child = pexpect.spawnu('telnet '+switch+'.dn.net')
            child.expect('Username: '******'Password: '******'6513-'+switch+'-(sec-)*c\d{1,2}#',timeout=3)
            child.sendline('term len 55')
            child.expect('6513-'+switch+'-(sec-)*c\d{1,2}#',timeout=3)
            child.sendline('sh int status mod 4 | beg Gi4/25')
            child.expect('6513-'+switch+'-(sec-)*c\d{1,2}#',timeout=3)
            print(child.before)
            child.sendline('exit')
        except (EOF,TIMEOUT,ExceptionPexpect):
            print('ERROR: Unable to display mod 4 interface statuses from '+switch)
            print('Try checking statuses manually instead:')
            print()
            print('  '+switch+':')
            print('    sh int status mod 4')
            print()
Esempio n. 17
0
	def __init__(self, id):
		# change directory if needed
		if not self.SAVE_DIR in os.getcwd():
			os.chdir(self.SAVE_DIR)

		# local variables
		self.id = id
		self.active = True
		
		# if a saved game exists restore it
		if os.path.isfile(str(id)):
			self.proc = pexpect.spawnu('python3 -madventure ' + str(id))
			self.getOutput() # avoid 'GAME RESTORED' message
		else:
			self.proc = pexpect.spawnu('python3 -madventure')
Esempio n. 18
0
def spawn(request, tag, dockerfile, cmd):
    if bare:
        proc = pexpect.spawnu(cmd)
    else:
        tag = 'thefuck/{}'.format(tag)
        build_container(tag, dockerfile)
        proc = pexpect.spawnu('docker run --volume {}:/src --tty=true '
                              '--interactive=true {} {}'.format(root, tag, cmd))
        proc.sendline('pip install /src')
    proc.sendline('cd /')

    proc.logfile = sys.stdout

    request.addfinalizer(proc.terminate)
    return proc
Esempio n. 19
0
    def test_default_go_install(self):
        """Install eclipse from scratch test case"""
        if not self.in_container:
            self.example_prog_dir = tempfile.mkdtemp()
            self.additional_dirs.append(self.example_prog_dir)
            example_file = os.path.join(self.example_prog_dir, "hello.go")
            open(example_file, "w").write(self.EXAMPLE_PROJECT)
            compile_command = ["bash", "-l", "-c", "go run {}".format(example_file)]
        else:  # our mock expects getting that path
            compile_command = ["bash", "-l", "go run /tmp/hello.go"]

        self.child = pexpect.spawnu(self.command('{} go'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
        self.wait_and_no_warn()

        self.assert_exec_exists()
        self.assertTrue(self.is_in_path(self.exec_path))

        # compile a small project
        output = subprocess.check_output(self.command_as_list(compile_command)).decode()

        if self.in_container:
            self.assertEqual(output, "hello, world\r\n")
        else:
            self.assertEqual(output, "hello, world")
def test_onionbalance_config_automatic_key_with_password(tmpdir, mocker):
    """
    Run onionbalance-config with an existing key, export as password protected
    key.
    """

    # Create input private_key
    private_key = Crypto.PublicKey.RSA.generate(1024)
    key_path = tmpdir.join('private_key')
    key_path.write(private_key.exportKey())

    # Start onionbalance-config in automatic mode
    cli = pexpect.spawnu("onionbalance-config", logfile=sys.stdout,
                         args=[
                             '--output', str(tmpdir.join(u"configdir")),
                             '--key', str(key_path),
                             '--password', 'testpassword',
                         ])
    cli.expect(u"Done! Successfully generated")

    # Check master config was generated with password protected key.
    master_dir = tmpdir.join('configdir', 'master')
    output_key_path = [fpath for fpath in master_dir.listdir()
                       if fpath.ext == '.key'][0]
    assert output_key_path.check()

    # Check key decrypts and is valid
    mocker.patch('getpass.getpass', lambda *_: 'testpassword')
    output_key = onionbalance.util.key_decrypt_prompt(str(output_key_path))
    assert isinstance(output_key, Crypto.PublicKey.RSA._RSAobj)
Esempio n. 21
0
 def __init__(self):
     # FIXME: Need configuration of this:
     self._exp = pexpect.spawnu('netcat 192.168.145.253 23')
     if _debug_cmds: self._exp.logfile = sys.stdout
     self._do_command('s' + str(_MICROSTEP))
     self._heading_angle = 0
     self._heading_steps = 0
Esempio n. 22
0
    def test_normal_output(self):
        self.sut = pexpect.spawnu(
            "python -m colorize -f 'b%(message)sb' -- echo foo", timeout=3
        )

        self.sut.expect_exact("bfoob")
        self.assertEquals(0, self.sut.wait())
Esempio n. 23
0
    def test_just_stdout(self):
        self.sut = pexpect.spawnu(
            "python -m colorize -f 'b%(message)sb' -- echo FAILURE", timeout=3
        )

        self.sut.expect_exact("b\x1b[1;37;41mFAILURE\x1b[mb")
        self.assertEquals(0, self.sut.wait())
Esempio n. 24
0
    def test_basic_format(self):
        self.sut = pexpect.spawnu(
            "python -m colorize -f 'a%(message)sa' -- echo FAILURE", timeout=3
        )

        self.sut.expect_exact("a\x1b[1;37;41mFAILURE\x1b[ma")
        self.assertEquals(0, self.sut.wait())
 def test_is_default_framework(self):
     """Android Studio is chosen as the default framework"""
     self.child = pexpect.spawnu(self.command('{} android'.format(UDTC)))
     # we ensure it thanks to installed_path being the android-studio one
     self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
     self.child.sendcontrol('C')
     self.wait_and_no_warn()
    def test_eclipse_adt_reinstall(self):
        """Reinstall eclipse adt once installed"""
        for loop in ("install", "reinstall"):
            self.child = pexpect.spawnu(self.command('{} android eclipse-adt'.format(UDTC)))
            if loop == "reinstall":
                self.expect_and_no_warn("Eclipse ADT is already installed.*\[.*\] ")
                self.child.sendline("y")
            self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
            self.child.sendline("")
            self.expect_and_no_warn("\[.*\] ")
            self.child.sendline("a")
            self.expect_and_no_warn("Installation done", timeout=self.TIMEOUT_INSTALL_PROGRESS)
            self.wait_and_no_warn()

            # we have an installed launcher, added to the launcher
            self.assertTrue(self.launcher_exists_and_is_pinned(self.desktop_filename))
            self.assertTrue(self.path_exists(self.exec_path))
            self.assertTrue(self.path_exists(get_icon_path(self.icon_filename)))

            # launch it, send SIGTERM and check that it exits fine
            proc = subprocess.Popen(self.command_as_list(self.exec_path), stdout=subprocess.DEVNULL,
                                    stderr=subprocess.DEVNULL)

            # on 64 bits, there is a java subprocess, we kill that one with SIGKILL (eclipse isn't reliable on SIGTERM)
            if self.arch_option == "x86_64":
                self.check_and_kill_process(["java", self.arch_option, self.installed_path],
                                            wait_before=self.TIMEOUT_START, send_sigkill=True)
            else:
                self.check_and_kill_process([self.exec_path],
                                            wait_before=self.TIMEOUT_START, send_sigkill=True)
            proc.wait(self.TIMEOUT_STOP)
Esempio n. 27
0
def collectBackups(devices):
    for device in devices:
        # use pexpect to pull out config dump from device
        print('\nCollecting backup from '+device+'...')
        username = '******'
        password = '******'
        outfile = open(time.strftime("%Y-%m-%d")+'--'+device+'.txt', 'w')
        header = device + '('+ time.strftime("%Y-%m-%d") + '):\n'
        print(header, file=outfile)
        try:
            child = pexpect.spawnu('ssh '+username+'@'+device)
            i = child.expect(['Are you sure you want to continue connecting (yes/no)?','.*(P|p)assword:'],timeout=10)
            if i == 0:
                child.sendline('yes')
                child.expect('.*(P|p)assword:',timeout=3)
                child.sendline(password)
                child.expect(device+'#',timeout=3)
            else:
                child.sendline(password)
                child.expect(device+'#',timeout=3)
            print('Login successful')
            child.sendline('term len 0')
            child.expect(device+'#',timeout=3)
            child.sendline('sh run')
            child.logfile = outfile
            child.expect(device+'#',timeout=15)
            # after collecting the output, reset terminal
            child.sendline('term len 60')
            child.expect(device+'#',timeout=3)
            child.sendline('exit')
            print('Configs have been backed up for '+device)
        except (EOF,TIMEOUT,ExceptionPexpect):
            print('ERROR: Failed to backup configs of '+device)
Esempio n. 28
0
def change_password(form_data):
    if form_data:
        form_data["username"] = re.sub('\W', '', form_data["username"])
    if (form_data and form_data["username"] is "unknown" or
        form_data["old_password"] is None or form_data["new_password"] is None or
            form_data["new_password_confirm"] is None):
        return {"unable_to_set": True}
    if form_data["new_password"] != form_data["new_password_confirm"]:
        return {"unable_to_set": True, "password_match": False}
    realm = settings.CSL_REALM
    errors = []
    try:
        kinit = pexpect.spawnu("/usr/bin/kpasswd {}@{}".format(form_data["username"], realm), timeout=settings.KINIT_TIMEOUT)
        match = kinit.expect([":", pexpect.EOF])
        if match == 1:
            return {"unable_to_set": True, "error": "User {} does not exist.".format(form_data["username"])}
        kinit.sendline(form_data["old_password"])
        kinit.expect([":", pexpect.EOF])
        if match == 1:
            return {"unable_to_set": True, "error": "Old password was incorrect."}
        kinit.sendline(form_data["new_password"])
        kinit.expect([":", pexpect.EOF])
        if match == 1:
            return {"unable_to_set": True}
        kinit.sendline(form_data["new_password_confirm"])
        kinit.expect(pexpect.EOF)
        kinit.close()
        exitstatus = kinit.exitstatus
    except pexpect.TIMEOUT:
        return {"unable_to_set": True, "errors": errors}
        exitstatus = 1
    if exitstatus == 0:
        return True
    return {"unable_to_set": True}
Esempio n. 29
0
    def cmd_expect(self, command, **kwargs):
        from pexpect import spawnu

        # prepare the environ, based on the system + our own env
        env = copy(environ)
        env.update(self.environ)

        # prepare the process
        kwargs.setdefault('env', env)
        kwargs.setdefault('show_output', self.log_level > 1)
        sensible = kwargs.pop('sensible', False)
        show_output = kwargs.pop('show_output')

        if show_output:
            if IS_PY3:
                kwargs['logfile'] = codecs.getwriter('utf8')(stdout.buffer)
            else:
                kwargs['logfile'] = codecs.getwriter('utf8')(stdout)

        if not sensible:
            self.debug('Run (expect) {0!r}'.format(command))
        else:
            self.debug('Run (expect) {0!r} ...'.format(command.split()[0]))

        self.debug('Cwd {}'.format(kwargs.get('cwd')))
        return spawnu(command, **kwargs)
Esempio n. 30
0
def main(cnc_ip, cnc_login, cnc_pass, cmd):
    res = 0
    print("rcmd:" + cnc_ip, cnc_login, cnc_pass, cmd)
    child = pexpect.spawnu('telnet ' + cnc_ip)
    child.logfile=sys.stdout
#    child.logfile_read = sys.stdout
#    child.logfile_send = sys.stdout
    try:
        child.expect([u'login: '******'Password:'******'\$'])
        child.sendline(cmd)
        
        while True:
            index = child.expect(['\$', '/'])
            if index == 0:
                break;

    except pexpect.TIMEOUT as e:
        print("rcmd: time out of operation")
        res = -1
    except pexpect.EOF:
        print("rcmd: end of operation")
        res = -2
        
    child.sendline(u'exit;exit;') # Try to ask ftp child to exit.
    child.close()
    return res
Esempio n. 31
0
# 2:11PM  up 3 days, 13:50, 3 users, load averages: 0.01, 0.00, 0.00
# [powerpc] Darwin v1-58.corefa.com 8.2.0 Darwin Kernel Version 8.2.0
# 10:35  up 18:06, 4 users, load averages: 0.52 0.47 0.36
# [Sparc - R220] Sun Solaris (8)
#  2:13pm  up 22 min(s),  1 user,  load average: 0.02, 0.01, 0.01
# [x86] Linux 2.4.18-14 (Redhat 8)
# 11:36pm  up 4 days, 17:58,  1 user,  load average: 0.03, 0.01, 0.00
# AIX jwdir 2 5 0001DBFA4C00
#  09:43AM   up  23:27,  1 user,  load average: 0.49, 0.32, 0.23
# OpenBSD box3 2.9 GENERIC#653 i386
#  6:08PM  up 4 days, 22:26, 1 user, load averages: 0.13, 0.09, 0.08

# Note that, for Python 3 compatibility reasons, we are using spawnu and
# importing unicode_literals (above). spawnu accepts Unicode input and
# unicode_literals makes all string literals in this script Unicode by default.
p = pexpect.spawnu('uptime')

# This parses uptime output into the major groups using regex group matching.
p.expect(
    'up\s+(.*?),\s+([0-9]+) users?,\s+load averages?: ([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9])'
)
duration, users, av1, av5, av15 = p.match.groups()

# The duration is a little harder to parse because of all the different
# styles of uptime. I'm sure there is a way to do this all at once with
# one single regex, but I bet it would be hard to read and maintain.
# If anyone wants to send me a version using a single regex I'd be happy to see it.
days = '0'
hours = '0'
mins = '0'
if 'day' in duration:
Esempio n. 32
0
    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

'''

from __future__ import absolute_import
from __future__ import print_function
from __future__ import unicode_literals

import pexpect

# Don't do this unless you like being John Malkovich
# c = pexpect.spawnu('/usr/bin/env python ./python.py')

# Note that, for Python 3 compatibility reasons, we are using spawnu and
# importing unicode_literals (above). spawnu accepts Unicode input and
# unicode_literals makes all string literals in this script Unicode by default.
c = pexpect.spawnu('/usr/bin/env python')

c.expect('>>>')
print('And now for something completely different...')
print(''.join(reversed((c.before))))
print('Yes, it\'s python, but it\'s backwards.')
print()
print('Escape character is \'^]\'.')
print(c.after, end=' ')
c.interact()
c.kill(1)
print('is alive:', c.isalive())
def autodoc(args):
    author = getpass.getuser()
    project = Path().resolve().name

    if "y" not in input(
            'Do you want to generate the documentation for "{}"? [y/n] :'.
            format(project)):
        return

    child = pexpect.spawnu("sphinx-quickstart", ["./"], encoding="utf-8")
    res = child.expect([
        "> Separate source and build directories*",
        "> Please enter a new root path*"
    ])
    if res == 1:
        print(
            "\n{}Error{}".format(utils.colors.FAIL, utils.colors.ENDC),
            "an existing conf.py has been found in the selected root path.",
        )
        print(
            "sphinx-quickstart will not overwrite existing Sphinx projects by itself."
        )
        child.close()
        if "y" in input("\n{}Force overwriting?{} (you will lose the current".
                        format(utils.colors.WARNING, utils.colors.ENDC) +
                        " ./build/ and ./source/ folders) [y/n] : "):
            _ = subprocess.check_output("mkinx clean", shell=True)
            child = pexpect.spawnu("sphinx-quickstart", ["./"],
                                   encoding="utf-8")
            child.expect("> Separate source and build directories*")
        else:
            return
    print("\n    Setting up the project...")

    windows = "y" if sys.platform in {"win32", "cygwin"} else "n"

    child.sendline("y")
    child.expect("> Name prefix*")
    child.sendline()
    child.expect("> Project name:*")
    child.sendline(project)
    child.expect("> Author name*")
    child.sendline(author)
    child.expect("> Project release*")
    child.sendline()
    child.expect("> Project language*")
    child.sendline("")
    child.expect("> Source file suffix*")
    child.sendline("")
    child.expect("> Name of your master document*")
    child.sendline("")
    child.expect("> Do you want to use the epub builder*")
    child.sendline("")
    child.expect("> autodoc: automatically insert docstrings*")
    child.sendline("y")
    child.expect("> doctest: automatically test code snippets*")
    child.sendline("")
    child.expect("> intersphinx: link between Sphinx documentation*")
    child.sendline("")
    child.expect('> todo: write "todo" entries*')
    child.sendline("")
    child.expect("> coverage: checks for documentation coverage")
    child.sendline("")
    child.expect("> imgmath: include math, rendered as PNG or SVG images*")
    child.sendline("")
    child.expect("> mathjax: include math*")
    child.sendline("")
    child.expect("> ifconfig: conditional inclusion of content*")
    child.sendline("")
    child.expect("> viewcode: include links to the source code*")
    child.sendline("y")
    child.expect(
        "> githubpages: create .nojekyll file to publish the document*")
    child.sendline("")
    child.expect("> Create Makefile*")
    child.sendline("")
    child.expect("> Create Windows command*")
    child.sendline(windows)
    child.expect("Creating file*")
    child.wait()
    child.close()

    print("    Building documentation...")
    print(
        '        If you see warnings such as "WARNING: autodoc: failed to import module',
        '[...] No module named [...]"',
        "\n        consider mocking the imports with:",
        "\n             mkinx autodoc -m module1 module2 etc.",
        "\n        see http://www.sphinx-doc.org/en/stable/ext/autodoc.html#confval-autodoc_mock_imports",
    )

    utils.set_sphinx_config(Path() / "source" / "conf.py", project,
                            args.mock_imports)

    try:
        _ = subprocess.check_output(
            "sphinx-apidoc -f -o source {} -e -M > /dev/null".format(project),
            shell=True,
        )
    except subprocess.CalledProcessError as e:
        # print(e)
        print(
            "{}Error{} ".format(utils.colors.FAIL, utils.colors.ENDC),
            "you should run `autodoc` from a project folder,",
            "with an importable project package",
        )
        print("Cleaning...", end="")
        _ = subprocess.check_output("mkinx clean", shell=True)
        print(u"\u2713")
        return

    utils.add_project_to_rst_index(Path() / "source" / "index.rst", project)
    utils.remove_project_name_from_titles(Path() / "source")

    os.remove(Path() / "source" / "modules.rst")

    index = Path().resolve().parent / "docs" / "index.md"
    if not index.exists():
        print(
            "Error: the project could not be added to your home documentation")
        print("`mkinx autodoc` should be run from: ")
        print("    path/to/documentation/new_python_project")
    else:
        utils.add_project_to_doc_index(index, project)

    _ = subprocess.check_output(
        "cd .. && mkinx build -F -p {} > /dev/null".format(project),
        shell=True)

    print(u"""\n    Added configuration file source/conf.py
    Added documentation files /source/*.rst
    Added utility file ./Makefile
    {}

    {}Finished \u2713{} An initial directory structure has been created.

    You can now enhance your master file source/index.rst
    and other documentation source files.\n""".format(
        "Added utility file make.bat" if windows == "y" else "",
        utils.colors.OKGREEN,
        utils.colors.ENDC,
    ))
Esempio n. 34
0
 def __enter__(self):
     self.proc = pexpect.spawnu(self.cmd_line)
     self.proc.expect(Spike.PROMPT)
     self.proc.setecho(False)
     self.until(0)
     return self
Esempio n. 35
0
class AgdaKernel(Kernel):
    implementation = 'agda'
    implementation_version = '0.5'
    language = 'agda'
    language_version = '2.6'
    language_info = {
        'name': 'agda',
        'mimetype': 'text/agda',
        'file_extension': '.agda',
    }

    banner = "Agda kernel"
    cells = {}
    last_code = ""

    agda_version = ""

    notebookName = ""
    cellId = ""
    preamble = ""

    unicodeComplete = True

    '''
    _banner = None

    @property
    def banner(self):
        if self._banner is None:
            self._banner = check_output(['bash', '--version']).decode('utf-8')
        return self._banner

    '''

    #lock = threading.Lock()

    #process = Popen(['agda', '--interaction'], stdout=PIPE, stdin=PIPE, stderr=STDOUT)
    process = pexpect.spawnu('agda --interaction')

    firstTime = True

    def startAgda(self):
        if self.firstTime:
            self.process.expect('Agda2> ')
            self.print(f'Agda has started.')
            self.firstTime = False
        return

    def __init__(self, **kwargs):
        Kernel.__init__(self, **kwargs)
        self.agda_version = self.readAgdaVersion()
#        self.kernel_lock = threading.Lock()

    def sendResponse(self, text):
        try:
            self.send_response(self.iopub_socket, 'stream', {'name': 'stdout', 'text': text})
        except AttributeError: # during testing there is no such method, just ignore
            self.print("Ignoring call to self.send_response")

    def sendInfoResponse(self, text):
        # ignore otherwise
        if self.sendInfoMessages:
            try:
                self.send_response(self.iopub_socket, 'stream', {'name': 'stdinfo', 'text': text})
            except AttributeError: # during testing there is no such method, just ignore
                self.print("Ignoring call to self.send_response")

    # return line and column of an position in a string
    def line_of(self, s, n):

        lines = s.split('\n')
        
        i = 0 # current line
        j = 0 # cumulative length

        found = False

        for line in lines:

            if n >= j and n <= j + len(line):
                found = True
                break

            # self.print(f'line {i} has length {len(line)}, cumulative {j}')

            i += 1
            j += len(line) + 1 # need to additionally record the '\n'

        if found:
            return i, n - j
        else:
            return -1, -1

    def readAgdaVersion(self):
        p = pexpect.spawn('agda --version')
        p.expect(pexpect.EOF)
        result = str(p.before)
        tokens = result.split(" ")
        version = tokens[2] # remove initial "Agda version "
        version = version[:-5] # remove trailing "\r\n"
        self.print(f'Detected Agda version: {version}')
        return version

    def interact(self, cmd):

        self.print("Interacting with Agda: %s" % cmd)

        #cmd = cmd.encode() # create a byte representation
        #result = self.process.communicate(input=cmd)[0]

        #cmd = cmd + "\n"
        self.process.sendline(cmd)
        result = ""

        while True:
            #this more robust version will survive an unexpected end of output from Agda
            prompt = self.process.expect([pexpect.TIMEOUT, pexpect.EOF, 'Agda2> ', '\(agda2-info-action "\*Type-checking\*"'], timeout=240)
            response = self.process.before
            result += response

            if prompt == 0 or prompt == 1:
                break
            elif prompt == 2:
                self.sendInfoResponse("DONE")
                break
            elif prompt == 3:
                # keep jupyter informed about agda's partial responses
                self.sendInfoResponse(response)
                continue

        #skip the first line (it's a copy of cmd)
        result = result[result.index('\n')+1:]

        #result = result.decode()
        self.print(f'Agda replied: {result}')

        lines = result.split('\n')

        result = {}
        
        # parse the response
        for line in lines:
            start = line.find("agda2")
            # parse only lines containing "agda2", and from that position on
            if start != -1:

                tokens = line[start:].split(' ')
                key = tokens[0]
                rest = line[start + len(key):]
                #rest = rest.replace("\\n", "\n")

                # extract all the strings in quotation marks "..."
                rest = rest.replace("\\\"", "§") # replace \" with §
                values = re.findall('"([^"]*)"', rest) # find all strings in quotation marks "..."
                values = [val.replace("§", "\"") for val in values] # replace § with " (no escape)

                if not key in result:
                    result[key] = []

                # in this case the format is "(agda2-give-action 0 'no-paren)"
                # return the goal index 0
                if key == AGDA_GIVE_ACTION:
                    result[key] = [tokens[1]]

                # add the new values to the dictionary
                result[key].append(values)

        self.print("result: %s" % result)

        return result

    def getModuleName(self, code):

        code = self.removeComments(code)
        lines = code.split('\n')

        #look for the first line matching "module name where"
        for line in lines:
            if bool(re.match(r'module *[a-zA-Z0-9.\-]* *where', line)):
                # fileName = "tmp/" + re.sub(r"-- *", "", firstLine)
                moduleName = re.sub(r'module *', "", line) # delete prefix
                moduleName = re.sub(r' *where.*', "", moduleName) # delete suffix

                return moduleName

        return ""

    def getFileName(self, code):

        moduleName = self.getModuleName(code)
        return moduleName.replace(".", "/") + ".agda" if moduleName != "" else ""

    def getDirName(self, code):

        moduleName = self.getModuleName(code)
        last = moduleName.rfind(".")
        prefixName = moduleName[:last]
        return prefixName.replace(".", "/") if last != -1 else ""

    def do_shutdown(self, restart):
        return

    def do_execute(self, in_code, silent, store_history=True, user_expressions=None, allow_stdin=False):

        self.startAgda()
        fileName = self.getFileName(in_code)
        dirName = self.getDirName(in_code)
        moduleName = self.getModuleName(in_code)
        absoluteFileName = os.path.abspath(fileName)

        preambleLength = 0

        self.sendInfoMessages = False

        if user_expressions and "sendInfoMessages" in user_expressions and user_expressions["sendInfoMessages"] == "yes":
            self.sendInfoMessages = True

        if user_expressions and "agdaCMD" in user_expressions:
            self.agdaCMD = user_expressions["agdaCMD"]
            self.print(f'agdaCMD = {self.agdaCMD}')
        else:
            self.print(f'agdaCMD NOT given')
            self.agdaCMD = "" # reset if not given

        # printing this may expose the user's github password
        # self.print(f'user_expressions: {user_expressions}')

        if user_expressions and "persistent" in user_expressions:
            persistent = user_expressions["persistent"] == "yes"
        else:
            persistent = False

        # set unicodeComplete only if passed in user_expressions;
        # otherwise, remember the previous value
        if user_expressions and "unicodeComplete" in user_expressions:
            self.unicodeComplete = user_expressions["unicodeComplete"] == "yes"

        if user_expressions and "loadFromStore" in user_expressions and user_expressions["loadFromStore"] == "yes":

            self.print(f'loadFromStore = yes')

            try:                
                fileHandle = open(fileName, "r+")
                code = fileHandle.read()
                fileHandle.close()
                self.print(f'executing code from file: {code}')
            except:
                self.print(f"file {fileName} not found, executing from given code")
                code = in_code

        else:
            code = in_code
            self.print(f'loadFromStore = no')
            self.print(f'executing code: {code}')

        if user_expressions:
            # get notebook name (if any)
            if "notebookName" in user_expressions:
                self.notebookName = user_expressions["notebookName"]

            # get cell id
            if "cellId" in user_expressions:
                self.cellId = user_expressions["cellId"]

            if "preamble" in user_expressions:
                self.preamble = user_expressions["preamble"]

        notebookName = self.notebookName
        cellId = self.cellId
        preamble = self.preamble

        #if notebookName == "":
        #    error = True
        #    self.print(f'empty notebook name!')
        #    result = "the cell should be evaluated first..."
        #else:
        error = False

        self.print(f'detected fileName: {fileName}, dirName: {dirName}, moduleName: {moduleName}, notebookName: {notebookName}, cellId: {cellId}, preamble: {preamble}')

        # use the provided preamble only if the module name is missing
        if fileName == "" and not error:

            # if no line \"module [modulename] where\" is provided,
            # we create a standard one ourselves
            preambleLength = len(preamble.split("\n")) - 1

            if preamble == "":
                error = True
                self.print(f'a preamble of the form "module xxx where" should be provided')
                result = 'a preamble of the form "module xxx where" should be provided'

            else:
                new_code = preamble + code

                fileName = self.getFileName(new_code)
                dirName = self.getDirName(new_code)
                moduleName = self.getModuleName(new_code)
                absoluteFileName = os.path.abspath(fileName)
                self.print(f'redetected fileName: {fileName}, dirName: {dirName}, moduleName: {moduleName}, notebookName: {notebookName}, cellId: {cellId}, new code: {new_code}')

                code = new_code

        if not error:

            self.fileName = fileName
            lines = code.split('\n')
            numLines = len(lines)

            self.print(f"writing to file: {fileName}")

            if dirName != "" and not os.path.exists(dirName):
                os.makedirs(dirName)

            fileHandle = open(fileName, "w+")

            for i in range(numLines):
                if i < numLines - 1:
                    fileHandle.write("%s\n" % lines[i])
                else:
                    fileHandle.write("%s" % lines[i])

            fileHandle.close()

            # if the persistent option is turned on, do a git commit
            if persistent:

                def git_push():
                    # push the changes
                    #branch = "main"

                    if user_expressions and "username" in user_expressions:
                        username = user_expressions["username"]
                    else:
                        self.print(f'No username provided')
                        username = ""

                    self.print(f'Pushing, username: {username}') #to branch {branch}')
                    self.sendInfoResponse(f'Pushing, username: {username}\n')

                    if user_expressions and "password" in user_expressions:
                        self.print("Storing password")
                        password = user_expressions["password"]
                        self.sendInfoResponse(f'Storing password\n')
                    else:
                        self.print("No password provided")
                        password = ""
                        self.sendInfoResponse('No password provided\n')

                    child = pexpect.spawn(f'git push origin')

                    while True:

                        prompt = child.expect([
                            "Username for 'https://github.com':",
                            f"Password for 'https://{username}@github.com':",
                            pexpect.EOF]
                        )

                        self.print(f'Prompt = {prompt}')
                        self.sendInfoResponse(f'Prompt = {prompt}\n')

                        if prompt == 0:
                            child.sendline(username)

                        elif prompt == 1:
                            child.sendline(password)
                                
                        elif prompt == 2:
                            child.close()
                            break

                    if child.exitstatus != 0:
                        text = child.before.decode()
                        self.print(text)
                        self.sendInfoResponse(text)

                    self.print(f'Pushed!')
                    self.sendInfoResponse("Pushed!")

                def persist(): #(self, fileName):

                    #with lock:
                        self.print(f'Git commit & push: {fileName}')

                        os.system('git pull')
                        os.system(f'git add {fileName}')
                        os.system(f'git commit -m "do_execute: updated {fileName}"')
                        self.print(f'Time to push...')
                        git_push()

                self.print(f'Persist is on, asynchronously committing to github')

                thr = threading.Thread(target=persist, args=(), kwargs={})
                thr.start()

            # load the code in Agda
            result, error = self.runCmd(code, -1, -1, "", AGDA_CMD_LOAD)
            result = deescapify(result)

            # try:
            #     #remove the .agdai file
            #     agdai = fileName + "i"
            #     os.remove(agdai)
            # except:
            #     self.print("*.agdai file '%s' not found" % agdai)

        # self.print("output: %s" % result)

            if result == "":
                result = "OK"

            #save the result of the last evaluation
            self.cells[fileName] = result

            # save the code that was executed
            self.code = code

        if not silent or error != "":
            self.sendResponse(result)

        # return all holes
        holes_as_pairs_of_positions = self.findAllHoles(code)

        # pairs are just lists of length 2 (join the lists)
        holes_as_positions = sum(map(lambda x: [x[0], x[1]], holes_as_pairs_of_positions), []) 
        #self.print(f'holes_as_positions = {holes_as_positions}')

        # replace each absolute position with the pair (line number, relative position)
        holes_as_lines_rel_pos = list(map(lambda x: self.line_of(code, x), holes_as_positions))

        # the first component is the line, the second the relative position within the line;
        # project to the line number;
        # additinally remove the shift possibly caused by the defaul preamble
        holes_as_lines = list(map(lambda x: x[0] - preambleLength, holes_as_lines_rel_pos)) 
        #self.print(f'holes_as_lines = {holes_as_lines}')

        # remove trailing newlines
        code = code.rstrip('\n')

        user_expressions_return = {
            "fileName": absoluteFileName,
            "moduleName": moduleName,
            "holes": holes_as_lines,
            "preambleLength" : preambleLength,
            "isError": error,
            "code": code,
            "result": result # return the agda response here too for further processing
        }

        self.print(f"Returning user_expressions_return: {user_expressions_return}")

        return {'status': 'ok' if not error else 'error',
                # The base class increments the execution count
                'execution_count': self.execution_count,
                'payload': [],
                'user_expressions': user_expressions_return,
               }

    # def do_execute(self, in_code, silent, store_history=True, user_expressions=None, allow_stdin=False):
    #     with self.kernel_lock:
    #         return self._do_execute(in_code, silent, store_history, user_expressions, allow_stdin)
     
    def inComment(self, code, pos):

        # check whether there is a "--" on the left of pos, but not going to the previous line
        while pos >= 0 and code[pos:pos+1] != "\n":
            if code[pos:pos+2] == "--":
                return True
            pos -= 1

        return False

    def find_expression(self, code, cursor_pos):

        forbidden = [" ", "\n", "(", ")", "{", "}", ":", ";"]
        length = len(code)

        hole_left = cursor_pos
        # go left until you find the beginning of a hole
        while code[hole_left : hole_left + 2] != "{!" and hole_left > 0:
            hole_left -= 1

        hole_left_found = code[hole_left : hole_left + 2] == "{!" and not self.inComment(code, hole_left)

        self.print(f'found hole left? {hole_left_found}')

        hole_right = cursor_pos - 2
        # go right until you find the beginning of a hole
        while code[hole_right : hole_right + 2] != "!}" and hole_right < length:
            hole_right += 1

        hole_right_found = code[hole_right : hole_right + 2] == "!}" and not self.inComment(code, hole_right)

        self.print(f'found hole right? {hole_right_found}')

        # check if the cursor is inside a hole
        if hole_left_found and hole_right_found:
            start = hole_left
            end = hole_right + 2
            expression = code[start : end]
            self.print(f'found hole left {start} and right {end}: token = {expression}')
        else:

            self.print(f'going for spaces')

            start = cursor_pos

            while start >= 1 and code[start - 1:start] not in forbidden:
                start -= 1

            end = cursor_pos

            while end < length and code[end] not in forbidden:
                end += 1

            expression = code[start : end]

        expression = escapify(expression)
             
        self.print(f'considering expression: \"{expression}\"')
        return start, end, expression

    def isHole(self, exp):
        result = exp == "?" or re.search("\\{!.*!\\}", exp) != None
        self.print(f'the expression "{exp}" is a hole? {result}')

        return result

    def runCmd(self, code, cursor_start, cursor_end, exp, cmd):

        fileName = self.fileName if hasattr(self, 'fileName') else self.getFileName(code)
        absoluteFileName = os.path.abspath(fileName)

        self.print(f"running command: {cmd}, cursor_start: {cursor_start}, cursor_end: {cursor_end}")

        if fileName == "":
            return "empty filename", True

        if (fileName not in self.cells or self.cells[fileName] == "") and cmd != AGDA_CMD_LOAD:
            return "the cell should be evaluated first", True

        if cmd != AGDA_CMD_LOAD:
            # find out line and column of the cursors
            row1, col1 = self.line_of(code, cursor_start)
            row2, col2 = self.line_of(code, cursor_end)

            if self.agda_version <= "2.5.1":
                intervalsToRange = f'(Range [Interval (Pn (Just (mkAbsolute "{absoluteFileName}")) {cursor_start+1} {row1+1} {col1+1}) (Pn (Just (mkAbsolute "{absoluteFileName}")) {cursor_end+1} {row2+1} {col2+1})])'
            else:
                intervalsToRange = f'(intervalsToRange (Just (mkAbsolute "{absoluteFileName}")) [Interval (Pn () {cursor_start+1} {row1+1} {col1+1}) (Pn () {cursor_end+1} {row2+1} {col2+1})])'

            interactionId = self.findCurrentHole(code, cursor_start)

            if row1 == -1 or row2 == -1: # should not happen
                return "Internal error", True

        inside_exp = exp[2:-2]
        result = ""

        if cmd == AGDA_CMD_LOAD:
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect (Cmd_load "{absoluteFileName}" [])'
        elif cmd == AGDA_CMD_INFER:
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({AGDA_CMD_INFER} Simplified {interactionId} {intervalsToRange} "{exp}")'
        elif cmd == AGDA_CMD_INFER_TOPLEVEL:
            query = f'IOTCM "{absoluteFileName}" None Indirect ({AGDA_CMD_INFER_TOPLEVEL} Simplified "{exp}")'
        elif cmd == AGDA_CMD_GOAL_TYPE_CONTEXT_INFER:
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({AGDA_CMD_GOAL_TYPE_CONTEXT_INFER} Simplified {interactionId} {intervalsToRange} "{exp}")'
        elif cmd in [AGDA_CMD_AUTO, AGDA_CMD_AUTOONE]:
            hints = exp #"" if exp == "?" else inside_exp
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({cmd} {interactionId} {intervalsToRange} "{hints}")'
        elif cmd == AGDA_CMD_COMPUTE:
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({AGDA_CMD_COMPUTE} DefaultCompute {interactionId} {intervalsToRange} "{exp}")'
        elif cmd == AGDA_CMD_COMPUTE_TOPLEVEL:
            query = f'IOTCM "{absoluteFileName}" None Indirect ({AGDA_CMD_COMPUTE_TOPLEVEL} DefaultCompute "{exp}")'
        elif cmd == AGDA_CMD_REFINE_OR_INTRO:
            flag = "False" # "True" if the goal has functional type
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({AGDA_CMD_REFINE_OR_INTRO} {flag} {interactionId} {intervalsToRange} "{inside_exp}")'
        elif cmd == AGDA_CMD_MAKE_CASE:
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({AGDA_CMD_MAKE_CASE} {interactionId} {intervalsToRange} "{inside_exp}")'
        elif cmd == AGDA_CMD_GIVE:
            query = f'IOTCM "{absoluteFileName}" NonInteractive Indirect ({AGDA_CMD_GIVE} WithoutForce {interactionId} {intervalsToRange} "{inside_exp}")'
        else:
            return f"Unrecognised command: {cmd}", True
        
        # send the type query to agda
        response = self.interact(query)

        if AGDA_INFO_ACTION in response:
            info_action_type, info_action_message = response[AGDA_INFO_ACTION][0][0], deescapify(response[AGDA_INFO_ACTION][0][1])
            info_action_types = [item[0] for item in response[AGDA_INFO_ACTION]]
        else:
            info_action_type, info_action_message = "", ""

        if AGDA_INFO_ACTION in response:

            self.print(f"there is AGDA_INFO_ACTION")

            if AGDA_GIVE_ACTION in response: # if there is a give action, it has priority

                result = response[AGDA_GIVE_ACTION]
                self.print(f"there is AGDA_GIVE_ACTION, with content {result}, and interactionId = {interactionId}")

                if cmd in [AGDA_CMD_GIVE, AGDA_CMD_REFINE_OR_INTRO] and len(result) > 0 and int(result[0]) == interactionId:
                    self.print(f"got matching hole!")

                    if cmd == AGDA_CMD_GIVE:
                        return "OK", False
                    elif cmd == AGDA_CMD_REFINE_OR_INTRO and len(result) > 1 and result[1] != "":
                        self.print(f"returning: {result[1][0]}")
                        return deescapify(result[1][0]), False
                    else:
                        return "OK", False
            elif AGDA_ALL_GOALS in info_action_types:

                self.print(f"there is AGDA_ALL_GOALS")

                goals = "".join([deescapify(item[1]) if item[0] == AGDA_ALL_GOALS else "" for item in response[AGDA_INFO_ACTION]])
                self.print(f"deescapified goals: {goals}")
                return goals, False
            elif AGDA_ALL_DONE in info_action_types:
                return "OK", False
            elif any(x in AGDA_ERROR_LIKE for x in info_action_types):
                info_action_message = "".join([f"{item[0]}: {deescapify(item[1])}" if item[0] in AGDA_ERROR_LIKE else "" for item in response[AGDA_INFO_ACTION]])

                if cmd != AGDA_CMD_LOAD:
                    # error recovery: if there is a string "did you mean 'new_exp'?",
                    # then call again with new_exp (except if we are loading)
                    matches = re.findall(r'did you mean \'([^\']*)\'\?', info_action_message)
                    if len(matches) > 0:
                        new_exp = matches[0]
                        if new_exp != exp: # avoid a potential infinite loop
                            self.print(f'trying error recovery with new expression: {new_exp}')
                            return self.runCmd(code, cursor_start, cursor_end, new_exp, cmd)

                return info_action_message, True
            elif AGDA_INFERRED_TYPE in info_action_types:
                inferred_type = info_action_message
                return f'{inferred_type}', False # if inferred_type != "" else str(response)
            elif AGDA_GOAL_TYPE_ETC in info_action_types:
                result = info_action_message
                blocks = result.split('————————————————————————————————————————————————————————————')
                result = blocks[0] + blocks[1]

                # find the maximal line length
                lines = result.split('\n')
                max_len = max(list(map(len, lines)))

                result = blocks[0] + ("-" * max_len) + blocks[1]
                self.print(f'AGDA_GOAL_TYPE_ETC case, max_len: {max_len}, result: {result}')

                return result, False
            elif AGDA_AUTO in info_action_types:
                return info_action_message, False
            elif AGDA_NORMAL_FORM in info_action_types:
                return info_action_message, False
            else:
                return info_action_message, True

        elif AGDA_MAKE_CASE_ACTION in response: # in this case we need to parse Agda's response again
            case_list = response[AGDA_MAKE_CASE_ACTION][0]
            result = "\n".join(case_list)
            self.print(f"Case list: {result}")
            return result, False
        elif cmd == AGDA_CMD_LOAD:
            if AGDA_INFO_ACTION in response:
                result = "\n".join(list(map(lambda info: " ".join(info), response[AGDA_INFO_ACTION])))
                return result, False

        return str(response), True

    def get_expression(self, code, cursor_pos):

        if len(code) < len(self.code):
            # we are in a selection and the cursor is at the beginning of the selection
            if  cursor_pos + len(code) <= len(self.code) and self.code[cursor_pos:cursor_pos+len(code)] == code:
                #self.print(f'we are in a selected text, cursor at the beginning')
                cursor_start, cursor_end, exp = cursor_pos, cursor_pos + len(code), code
            # we are in a selection and the cursor is at the end of the selection
            elif cursor_pos - len(code) >= 0 and cursor_pos <= len(self.code) and self.code[cursor_pos-len(code):cursor_pos] == code:
                #self.print(f'we are in a selected text, cursor at the end')
                cursor_start, cursor_end, exp = cursor_pos - len(code), cursor_pos, code
            else:
                error = True
                self.print(f'no other case possible: the cursor is either at the beginning or at the end of a selection')
                #return {'status': 'ok', 'found': True, 'data': {'text/plain': 'load the cell first'}, 'metadata': {}}
        # we are not in a selection, or an error above occurred
        else: # if exp == "":
            cursor_start, cursor_end, exp = self.find_expression(code, cursor_pos)
            #cursor_start += 1
        
        return cursor_start, cursor_end, exp

    def infer_top_level(self, cursor_start, cursor_end, exp):

        inferred_type, error2 = self.runCmd(self.code, cursor_start, cursor_end, exp, AGDA_CMD_INFER_TOPLEVEL)
        normal_form, error3 = self.runCmd(self.code, cursor_start, cursor_end, exp, AGDA_CMD_COMPUTE_TOPLEVEL)

        error = error2 and error3

        if not error:
            result = f"{exp.strip()} EVALUATES TO \n{normal_form.strip()} OF TYPE\n {inferred_type.strip()}"
        elif not error2:
            result = f"{exp.strip()} : {inferred_type.strip()}"
        elif not error3:
            result = f"{exp.strip()} = {normal_form.strip()}"
        else: # this is an error message
            result = normal_form.strip()

        return error, f"{result}"

    def infer_local(self, cursor_start, cursor_end, exp):

        goal, error1 = self.runCmd(self.code, cursor_start, cursor_end, exp, AGDA_CMD_GOAL_TYPE_CONTEXT_INFER)
        inferred_type, error2 = self.runCmd(self.code, cursor_start, cursor_end, exp, AGDA_CMD_INFER)
        normal_form, error3 = self.runCmd(self.code, cursor_start, cursor_end, exp, AGDA_CMD_COMPUTE)

        result = ""

        #self.print(f'gathered: error1 = {error1}, error2 = {error2}, error3 = {error3}')

        if not error2 and not error3:
            normalisation = f"Eval: {exp.strip()} --> {normal_form.strip()} : {inferred_type.strip()}"
        elif not error2:
            normalisation = f"{exp.strip()} : {inferred_type.strip()}"
        elif not error3:
            normalisation = f"Eval: {exp.strip()} --> {normal_form.strip()}"
        else:
            normalisation = ""

        padding = "=" * len(normalisation)

        if not error1 and goal and goal != "":
            result = f"{goal.strip()} \n{padding}\n"
        else:
            return True, f"{normal_form.strip()}" # this contains the error message

        return False, result

    # get the type of the current expression
    # triggered by SHIFT+TAB
    # code is either the current selection, or the whole cell otherwise
    # cursor_pos is always at the beginning or at the end of the selection;
    def do_inspect(self, code, cursor_pos, detail_level=0):

        #if self.code == "" or not code in self.code:
        #    return {'status': 'error', 'found': True, 'data': {'text/plain': "must load the cell first"}}

        self.print(f'do_inspect cursor_pos: {cursor_pos}, selection: "{code}" of length {len(code)}, code: "{self.code}" of length {len(self.code)}')

        # load the code to check that there are no errors
        #response = self.do_execute(self.code, False)
        response = self.do_execute(code, False)

        if response['status'] == 'error':
            return {'status': 'error', 'found': False, 'data': {'text/plain': "unable to inspect, the code contain errors"}}

        cursor_start, cursor_end, exp = self.get_expression(code, cursor_pos)            
        # self.print(f'current exp: "{exp}", pos: {cursor_pos}, start: {cursor_start}, end: {cursor_end}')

        old_code = self.code

        # if we are not in a hole, try the top level inspection first
        if not self.isHole(exp):
            error, result = self.infer_top_level(cursor_start, cursor_end, exp)
            if not error:
                return {'status': 'ok', 'found': True, 'data': {'text/plain': result}}
            else:
                # if we are not in a hole,
                # create an artificial hole around the current selection and reload
                self.code = self.code[:cursor_start-1] + "{! " + exp + " !}" + self.code[cursor_end:]
                #self.print(f'new_code: {self.code}')
                response = self.do_execute(self.code, False)

                # adding the hole creates an error
                if response['status'] == 'error':
                    self.print(f'unexpected error when adding temporary hole: {response}')

                cursor_start, cursor_end, exp = self.find_expression(self.code, cursor_start)

        # at this point we are in a hole,
        # either the original one, or the one we created
        if exp != "?":
            exp = exp[2:-2] # strip the initial "{!" and final "!}"
            #self.print(f'considering inside exp: {exp}')

        #self.print(f'considering exp: {exp}, pos: {cursor_pos}, start: {cursor_start}, end: {cursor_end}')
        error, result = self.infer_local(cursor_start, cursor_end, exp)

        # undo file modifications if we created a new hole
        if self.code != old_code:
            self.code = old_code
            self.do_execute(self.code, False)

        return {'status': 'error' if error else 'ok', 'found': True, 'data': {'text/plain': result}}

    # handle unicode completion here
    def do_complete(self, code, cursor_pos):

        #self.print(f'considering code: {code}, pos: {cursor_pos}')

        half_subst = {
            'Nat' : 'ℕ',
            '<=<>' : '≤⟨⟩',
            '<==<>' : '≤≡⟨⟩',
            '=<>' : '≡⟨⟩',
            '-><>' : '↝<>',
            '->*<>' : '↝*<>',
            'top' : '⊤',
            'bot' : '⊥',
            'neg' : '¬',
            '/\\' : '∧',
            '\\/' : '∨',
            '\\' : 'λ', # it is important that this comes after /\
            'Pi' : 'Π',
            'Sigma' : 'Σ',
            '->' : '→',
            '→' :  '↦',
            '↦' : '↝',
            '↝' : '->',
            'iff' : '⟺',
            '<=>' : '⟺',
            '=>' : '⇒',
            '<' : '⟨',
            '>' : '⟩', # it is important that this comes after ->
            '⟩' : '≻',
            '≻' : '>',
            'forall' : '∀',
            'exists' : '∃',
            'A' : '𝔸',
            'B' : '𝔹',
            'C' : 'ℂ',
            'N' : 'ℕ',
            'Q' : 'ℚ',
            'R' : 'ℝ',
            'Z' : 'ℤ',
            ':=' : '≔',
            '/=' : '≢',
            'leq' : '≤',
            '<=' : '≤',
            'geq' : '≥',
            '>=' : '≥',
            '[=' : '⊑',
            '=' : '≡',
            'alpha' : 'α',
            'beta' : 'β',
            'gamma' : 'γ',
            'rho' : 'ρ',
            'e' : 'ε',
            'mu' : 'μ',
            'kappa': 'κ',
            'xor' : '⊗',
            'emptyset' : '∅',
            'qed' : '∎',
            '.' : '·',
            'd' : '∇',
            'Delta' : 'Δ',
            'delta' : 'δ',
            'notin' : '∉',
            'in' : '∈',
            '[' : '⟦',
            ']' : '⟧',
            '::' : '∷',
            '0' : '𝟬', # '𝟢',
            '𝟬' : '₀',
            '₀' : '0',
            '1' : '𝟭', # '𝟣'
            '𝟭' : '₁',
            '₁' : '1',
            '2' : '₂',
            '3' : '₃',
            '4' : '₄',
            '5' : '₅',
            '6' : '₆',
            '7' : '₇',
            '8' : '₈',
            '9' : '₉',
            '+' : '⨁',
            '~' : '≈',
            'x' : '×',
            'o' : '∘',
            'phi' : 'φ',
            'psi' : 'ψ',
            'xi' : 'ξ',
            #'??' : "{! !}",
            'w'  : 'ω ',
            'omega' : 'ω',
            'Gamma' : 'Γ',
            'tau' : 'τ',
            'sigma' : 'σ',
            #';' : ';', very bad idea: the second semicolon lloks the same but it is a different unicode symbol...
            ';' : '⨟',
            '(' : '⟬',
            '⟬' : '⦅',
            ')' : '⟭',
            '⟭' : '⦆',
            'b' : 'ᵇ',
            'empty' : '∅',
            '|-' : '⊢',
            'models' : '⊨',
            '|=' : '⊨',
            'cup' : '⊔',
            'l' : 'ℓ',
            'op' : 'ᵒᵖ',
            '{{' : '⦃',
            '}}' : '⦄',
            '--' : '−−', # they are not the same!
            '−−' : '--', # they are the other way around!
            ':' : '꞉', # they are not the same!
            '꞉' : ':', # they are the other way around!
            'subseteq' : '⊆',
            '⊆' : 'subseteq'
        }

        other_half = {val : key for (key, val) in half_subst.items() if val not in list(half_subst.keys())}
        subst = {**half_subst, **other_half} # merge the two dictionaries
        keys = [key for (key, val) in subst.items()]

        length = len(code)
        matches = []
        error = False

        for key in keys:
            n = len(key)
            cursor_start = cursor_pos - n
            cursor_end = cursor_pos
            s = code[cursor_start:cursor_pos]

            if s == key:
                # we have a match
                matches = [subst[key]]
                break

        def cmdAuto():

            # call Agsy, options: -c (case splitting) -m (hints) -r (refine) -l (list) -s k (select result k)
            """options = lambda k: f'  -m -s {k}  '
            k = 0
            while True:
                result, error = self.runCmd(code, cursor_start, cursor_end, options(k), AGDA_CMD_AUTOONE)
                self.print(f'result is: {result}, error is: {error}')
                if error or result in ["No solution found", "No candidate found", "Only 1 solution found", f'Only {k} solutions found']:
                    if matches == []:
                        matches = ["{! !}"] # transform "?" into "{! !}" when Agsy fails

                    break
                else:
                    matches += [result] if result != "" else []

                k += 1
            """
            options = "-m -l" # list solutions
            self.print(f'Agsy options are: {options}')
            result, error = self.runCmd(code, cursor_start, cursor_end, options, AGDA_CMD_AUTOONE if self.agda_version >= "2.5.4" else AGDA_CMD_AUTO)
            self.print(f'result is: {result}, error is: {error}')

            if result.find("Listing solution(s)") != -1:
                matches = self.listing_solution_parser(result)

            elif error or result in ["No solution found", "No candidate found", "No solution found after timeout (1000ms)"]:
                matches = ["{! !}"] # transform "?" into "{! !}" when Agsy fails
            else:
                self.print(f'Unexpected answer: {result}, error is: {error}')

            return result, error, matches

        # didn't apply a textual substitution,
        # or such substitutions are disabled
        if not self.unicodeComplete or matches == []:

            # reset the list of matches in any case
            matches = []

            cursor_start_orig, cursor_end_orig, exp_orig = self.find_expression(code, cursor_pos)
            cursor_start, cursor_end = cursor_start_orig, cursor_end_orig
            exp = escapify(exp_orig)
            #cursor_start += 1

            agdaCMD = self.agdaCMD

            # if we have a specific command to pass to Agda, just do it
            if agdaCMD != "":

                self.print(f'Passing command directly to Agda: {agdaCMD}')

                if agdaCMD == AGDA_CMD_AUTO or agdaCMD == AGDA_CMD_AUTOONE:
                    result, error, matches = cmdAuto()
                else:
                    result, error = self.runCmd(code, cursor_start, cursor_end, exp, agdaCMD)

                    self.print(f'result is: {result}, error is: {error}')

                    if error:
                        cursor_start, cursor_end = cursor_pos, cursor_pos
                    elif agdaCMD == AGDA_CMD_GIVE and result == "OK":
                        result = "(" + re.search(r'\{! *(.*) *!\}', exp).group(1).strip() + ")"
                        self.print(f'gave hole: {result}')
                    elif agdaCMD == AGDA_CMD_MAKE_CASE:
                        # need to replace the current row with result
                        while cursor_start > 0 and code[cursor_start - 1] != "\n":
                            cursor_start -= 1
                        while cursor_end < length and code[cursor_end] != "\n":
                            cursor_end += 1
                    # elif agdaCMD == AGDA_CMD_REFINE_OR_INTRO:
                        
                    # else:
                    #     cursor_start, cursor_end = cursor_pos, cursor_pos
                    #     result = ""

                    matches = [result] if result != "" else []

            else:

                # load the current contents
                self.do_execute(code, False)

                if exp == "?":
                    result, error, matches = cmdAuto()

                # continue the chain if Agsy fails
                if self.isHole(exp) and (exp != "?" or matches == ["{! !}"]):

                    # first, try to replace the hole with its current contents
                    result, error = self.runCmd(code, cursor_start, cursor_end, exp, AGDA_CMD_GIVE)

                    self.print(f'AGDA_CMD_GIVE, result: {result}, error: {error}')

                    if error:
                        # second, try to automatically refine the current contents
                        result, error = self.runCmd(code, cursor_start, cursor_end, exp, AGDA_CMD_REFINE_OR_INTRO)

                        if error: # try case
                            # need to reload to make it work (??)
                            _, _ = self.runCmd(code, -1, -1, "", AGDA_CMD_LOAD)

                            # third, try to introduce a case analysis
                            result, error = self.runCmd(code, cursor_start, cursor_end, exp, AGDA_CMD_MAKE_CASE)

                            if error or result == "OK":
                                cursor_start, cursor_end = cursor_pos, cursor_pos
                                result = ""
                            else:
                                # need to replace the current row with result
                                while cursor_start > 0 and code[cursor_start - 1] != "\n":
                                    cursor_start -= 1
                                while cursor_end < length and code[cursor_end] != "\n":
                                    cursor_end += 1

                        elif result == "OK":
                            # cannot close the hole
                            result1 = re.search(r'\{! *(.*) *!\}', exp).group(1).strip()
                            self.print(f'not closing hole: {result1}')
                        else:
                            # in this case result is a refined goal and we can refine the hole
                            result = result
                    elif result == "OK":
                        # close the hole
                        result = "(" + re.search(r'\{! *(.*) *!\}', exp).group(1).strip() + ")"
                        self.print(f'gave hole: {result}')

                    matches = [result] if result != "" else []

                self.print(f'exp: {exp}, matches: {matches}')

                # always replace "?" with a hole in case there is no match
                if exp == "?" and matches == []:
                    matches = ["{! !}"]
                    cursor_start, cursor_end = cursor_start_orig, cursor_end_orig
                    self.print(f'cursor_start: {cursor_start}, cursor_end: {cursor_end}')
                    error = False
    
        return {'matches': matches, 'cursor_start': cursor_start,
                'cursor_end': cursor_end, 'metadata': {},
                'status': 'ok' if not error else 'error'}

    def listing_solution_parser(self, str):
        # example: Listing solution(s) 0-9\n0  cong suc (+-assoc m n p)\n1  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m p p)) ⟩\nsuc (m + (n + p)) ∎\n2  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m p n)) ⟩\nsuc (m + (n + p)) ∎\n3  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m p m)) ⟩\nsuc (m + (n + p)) ∎\n4  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m n p)) ⟩\nsuc (m + (n + p)) ∎\n5  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m n n)) ⟩\nsuc (m + (n + p)) ∎\n6  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m n m)) ⟩\nsuc (m + (n + p)) ∎\n7  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m m p)) ⟩\nsuc (m + (n + p)) ∎\n8  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m m n)) ⟩\nsuc (m + (n + p)) ∎\n9  begin\nsuc (m + n + p) ≡⟨ cong suc (+-assoc m n p) ⟩\nsuc (m + (n + p)) ≡⟨\nsym (cong (λ _ → suc (m + (n + p))) (+-assoc m m m)) ⟩\nsuc (m + (n + p)) ∎\n
        solutions = re.split('\n[0-9]+ +', str)[1:] # skip the first line

        # need to insert two extra spaces for multiline solutions in order to preserve indentation
        solutions = [ '\n  '.join(re.split('\n', solution)) for solution in solutions]

        # strip trailing newlines and spaces
        solutions = [ solution.rstrip() for solution in solutions]
        
        self.print(f"solutions is: {solutions}")
        #    solution = " ".join(tokens[2:]) # skip the first "20  " (plus the extra space!) and put the tokens back
        return solutions

    def findAllHoles(self, code):
        i = 0
        length = len(code)
        holes = []

        while i < length:
            if code[i:i+2] == "--": # we are in a line comment
                while i < length and code[i] != "\n":
                    i += 1 # skip to the end of the line
            elif code[i:i+2] == "{-": # we are in a block comment
                i += 2
                k = 1
                while i < length and k > 0:
                    if code[i:i+2] == "{-":
                        k += 1
                        i += 2
                    elif code[i:i+2] == "-}":
                        k -= 1
                        i += 2
                    else:
                        i += 1
            elif code[i:i+1] == "?" and i+1 == length:
                holes.append((i, i+1))
                i += 1
            elif code[i:i+2] in ["(?"]:
                holes.append((i+1, i+2))
                i += 2
            elif code[i:i+2] in ["?)", "?;"]:
                holes.append((i, i+1))
                i += 1
            elif code[i:i+3] in [" ?\n", " ? ", "(?)"] or (code[i:i+2] == " ?" and i+2 == length):
                holes.append((i+1, i+2))
                i += 2
            elif code[i:i+2] == "{!": # beginning of a hole
                start = i
                i += 2
                while i < length: # find the end of the hole (no nested holes)
                    if code[i:i+2] == "!}":
                        holes.append((start, i+2))
                        i += 2
                        break
                    i += 1
            else:
                i += 1

        self.print(f'found holes: {holes}')
        return holes

    def findCurrentHole(self, code, pos):

        holes = self.findAllHoles(code)
        self.print(f'looking for hole at position: {pos}')

        k = 0
        for (i, j) in holes:
            if i <= pos and pos <= j: # allow the cursor to be one position to the right of the hole
                return k
            k += 1

        return -1 # no hole found

    def removeComments(self, code):

        level = 0
        i = 0
        length = len(code)
        result = ""

        while i < length:
            if level == 0 and code[i:i+2] == "--": # skip till the end of the line
                while i < length and code[i] != "\n":
                    i += 1

                result += "\n" if code[i:i+1] == "\n" else ""
            elif code[i:i+2] == "{-":
                level += 1
                i += 1
            elif code[i:i+2] == "-}" and level > 0:
                level -= 1
                i += 1
            elif level == 0:
                result += code[i]

            i += 1

        return result

    def print(self, msg):
        try:
            self.log.error(msg)
        except AttributeError:
            print(msg)
Esempio n. 36
0
def initializePigpiod():
    child = pexpect.spawnu('bash')
    child.logfile = sys.stdout
    child.sendline("sudo pigpiod")
    time.sleep(1)
Esempio n. 37
0
def step_start_cycli(context):
    context.cli = pexpect.spawnu("cycli -u neo4j -p password")
Esempio n. 38
0
def main():

    parser = argparse.ArgumentParser()
    parser.add_argument("--flash",
                        help="flash bootrom & fullimage",
                        action="store_true")
    parser.add_argument("--init",
                        help="run init rdv4 script",
                        action="store_true")
    parser.add_argument("-y",
                        help="automatic yes to prompts",
                        action="store_true")
    args = parser.parse_args()

    print("-----------", color('Proxmark3 online test script v1.0.3',
                               fg='cyan'), "------------")
    print(
        "This script will run some series of test against a connected Proxmark3 device"
    )
    print("Steps:")
    print(" 1. flash bootrom, fullimage")
    print(" 2. init_rdv4 / flash smartcard")
    print(" 3. check device mismatch message")
    print(" 4. check smart card fw,  flash memory")
    print("    if needed, flash flash smartcard reader firmware")
    print(" 5. check antenna tuning")
    print(" 6. check LF T55x7 functionality")
    print(" 7. check HF search")
    print(" 8. check SPIFFS")
    print(" 9. check HF iCLASS functionality")
    print("\n")

    # result
    res = 0
    total_tests = 12
    must_update_fw = 0
    msg = ''

    if args.flash:
        print("-----------------------", color('Flashing phase', fg='cyan'),
              "---------------------")
        print("flashing bootrom - don't touch the device or cables")
        pm3_flashbootrom()

        print("flashing fullimage - don't touch the device or cables")
        pm3_flashfullimage()
        print("\n")

    # start pm3
    child = pexpect.spawnu('./pm3')
    i = child.expect('pm3 --> ')
    print("[+] Proxmark3 client open")

    if args.init:
        print("------------------------", color('Init phase', fg='cyan'),
              "------------------------")
        print("Running init rdv4 script - don't touch the device or cables")
        pm3_initrdv4(child)
        print("flashing smartcard  - don't touch the device or cables")
        pm3_flash_sm(child)
        print("\n")

    print("------------------------", color('Test phase', fg='cyan'),
          "------------------------")

    # check device mismatch
    signature_msg = "device.................... RDV4".lower()

    # check flashmemory
    flash_mem = "baudrate................24 mhz".lower()

    # check smartcard fw version
    sm_version = "version.................v3.11".lower()

    # check LF
    lf_search = "valid hid prox id found!".lower()

    # check HF
    hf_search = "Valid iCLASS tag / PicoPass tag found".lower()

    # mem spiffs info
    mem_spiffs = "max path length............32 chars".lower()

    # lf antenna tuning
    lf_tune = "LF antenna is OK".lower()

    # hf antenna tuning
    hf_tune = "HF antenna is OK".lower()

    try:
        # HW VERSION checks
        child.sendline('hw version')
        i = child.expect('pm3 --> ')
        msg = escape_ansi(str(child.before))

        if signature_msg in msg:
            print("[+] RDV4 signature ", color('[OK]', fg='green'))
            res += 1
        else:
            print("[-] RDV4 signature ", color('[FAIL]', fg='red'))

        # HW STATUS checks
        child.sendline('hw status')
        i = child.expect('pm3 --> ')
        msg = escape_ansi(str(child.before))

        if sm_version in msg:
            print("[+] Smart card firmware version ", color('[OK]',
                                                            fg='green'))
            res += 1
        else:
            print("[-] Smart card firmware version ", color('[FAIL]',
                                                            fg='red'),
                  " will upgrade fw in the next step")
            must_update_fw = 1

        if flash_mem in msg:
            print("[+] Flash memory accessable ", color('[OK]', fg='green'))
            res += 1
        else:
            print("[-] Flash memory accessable ", color('[FAIL]', fg='red'))

        # extract slow clock and verify its OK...
        # slow clock check:
        # Slow clock..............30057 Hz
        for line in msg.splitlines():
            match_slow = line.find('slow clock..............')

            if match_slow > -1:
                match = re.search(r'\d+', line)
                if match:
                    clock = int(match[0])
                    if clock < 29000:
                        print(
                            "[-] Warning, Slow clock too slow (%d Hz)" %
                            (clock), color('[FAIL]', fg='red'))
                    elif clock > 33000:
                        print(
                            "[-] Warning, Slow clock too fast (%d Hz)" %
                            (clock), color('[FAIL]', fg='red'))
                    else:
                        print(
                            "[+] Slow clock within acceptable range (%d Hz)" %
                            (clock), color('[OK]', fg='green'))
                        res += 1
    except:
        print(color("[!] exception for HW STATUS", fg='red'))
        msg = escape_ansi(str(child.before))
        print(msg)
        child.sendline('quit')
        child.expect(pexpect.EOF)
        return

    if must_update_fw == 1:
        if pm3_flash_sm(child):
            res += 1

    try:
        print(
            "[=] starting antenna tune tests,  this takes some time and plot window will flash up..."
        )
        # HW TUNE checks
        child.sendline('hw tune')
        i = child.expect('pm3 --> ')

        msg = escape_ansi(str(child.before))
        if lf_tune in msg:
            print("[+] LF antenna tuning ", color('[OK]', fg='green'))
            res += 1
        else:
            print("[-] LF antenna tuning ", color('[FAIL]', fg='red'))

        if hf_tune in msg:
            print("[+] HF antenna tuning ", color('[OK]', fg='green'))
            res += 1
        else:
            print("[-] HF antenna tuning ", color('[FAIL]', fg='red'))

    except:
        print(color("[!] exception for hw tune", fg='red'))
        msg = escape_ansi(str(child.before))
        print(msg)
        child.sendline('quit')
        child.expect(pexpect.EOF)
        return

    # hide plot window again
    child.sendline('data hide')
    i = child.expect('pm3 --> ')

    ans = ''

    while ans != 'y' and args.y == False:

        ans = (input(
            color('>>> Put LF card and HF card on Proxmark3 antenna',
                  fg='yellow') + '   [Y/n/q] ') or "y")

        if ans == 'q':
            child.sendline('quit')
            child.expect(pexpect.EOF)
            print('[!] Aborted all tests ', color('[USER ABORTED]', fg='red'))
            return

    # LF T55X7 WIPE/CLONE/READ TESTS
    if pm3_lf_t55xx(child):
        res += 1

    # HF SEARCH TESTS
    try:
        print("[=] starting HF SEARCH tests...")

        # HF SEARCH Test
        child.sendline('hf search')
        i = child.expect('pm3 --> ')

        msg = escape_ansi(str(child.before))
        if hf_search in msg:
            print("[+] HF SEARCH ", color('[OK]', fg='green'))
            res += 1
        else:
            print("[-] HF SEARCH ", color('[FAIL]', fg='red'))

    except:
        print(color("[!] exception for HF SEARCH", fg='red'))
        msg = escape_ansi(str(child.before))
        print(msg)
        child.sendline('quit')
        child.expect(pexpect.EOF)
        return

    # MEM Tree test
    child.sendline('mem spiffs info')
    i = child.expect('/', timeout=10)

    msg = escape_ansi(str(child.before))
    if mem_spiffs in msg:
        print("[+] MEM SPIFFS INFO ", color('[OK]', fg='green'))
        res += 1
    else:
        print("[-] MEM SPIFFS INFO ", color('[FAIL]', fg='red'))

    ans = ''
    while ans != 'y' and args.y == False:

        ans = (input(
            color('>>> Put iCLASS legacy card on Proxmark3 antenna',
                  fg='yellow') + '   [Y/n/q] ') or "y")

        if ans == 'q':
            child.sendline('quit')
            child.expect(pexpect.EOF)
            print('[!] Aborted all tests ', color('[USER ABORTED]', fg='red'))
            return

    # iCLASS read/write test
    try:
        print("[=] starting iCLASS info/read/write tests...")
        child.sendline('hf iclass info')
        i = child.expect('pm3 --> ')

        # iclass info / read / write checks
        iclass_info = 'Credential... iCLASS legacy'.lower()

        iclass_ok = False
        msg = escape_ansi(str(child.before))
        if iclass_info in msg:
            print("[+] HF ICLASS INFO ", color('[OK]', fg='green'))
            res += 1
            iclass_ok = True
        else:
            print("[-] HF ICLASS INFO ", color('[FAIL]', fg='red'))

        if iclass_ok:

            child.sendline('hf iclass rdbl -b 10 --ki 0')
            i = child.expect('pm3 --> ')
            msg = escape_ansi(str(child.before))
            for line in msg.splitlines():
                iclass_read = 'block 10'.lower()
                if iclass_read in line:
                    res += 1
                    print("[+] HF ICLASS RDBL ", color('[OK]', fg='green'))
                    old_b10 = line[16:].replace(" ", "")

                    child.sendline(
                        'hf iclass wrbl -b 10 --ki 0 -d 0102030405060708')
                    i = child.expect('pm3 --> ')
                    msg = escape_ansi(str(child.before))
                    iclass_write = 'wrote block 10 successful'.lower()
                    if iclass_write in msg:
                        res += 1
                        print("[+] HF ICLASS WRBL ", color('[OK]', fg='green'))
                        child.sendline('hf iclass wrbl -b 10 --ki 0 -d %s' %
                                       (old_b10))
                        i = child.expect('pm3 --> ')
                    else:
                        print("[-] HF ICLASS WRBL ", color('[FAIL]', fg='red'))

                    break

        else:
            print("[-] skipping iclass read/write")

    except:
        print(color("[!] exception iCLASS read/write", fg='red'))
        msg = escape_ansi(str(child.before))
        print(msg)
        child.sendline('quit')
        child.expect(pexpect.EOF)
        return

    # exit Proxmark3 client
    child.sendline('quit')
    i = child.expect(pexpect.EOF)

    print("[+] PM3 client closed\n")

    # validate test results

    print("-------------------------", color('Results', fg='cyan'),
          "-------------------------")
    if res == total_tests:
        print('[+] Passed ', color('[OK]', fg='green'))
    else:
        print('[-] failed test ', color('[FAIL]', fg='red'),
              '(%d / %d tests)' % (res, total_tests))
    print("")
Esempio n. 39
0
if mount == True and motherboard == 'Lenovo':
    print("### LENOVO ###")
    unmount_Lenovo()

    cmd = lenovo_rdmount_path + ' -s ' + ipmiIpAddress + ' -d ' + iso_file_path + ' -l ' + ipmiUsername + ' -p ' + ipmiPassword
    print('### MOUNTING ###')
    m = subprocess.call(cmd, shell=True)
    print(m)

elif mount == True and motherboard == 'SuperMicro':
    print("### SUPERMICRO ###")
    cmd = supermicro_smcipmitool_path + ' ' + ipmiIpAddress + ' ' + ipmiUsername + ' ' + ipmiPassword + ' shell'
    print(cmd)

    ############################
    proc = pexpect.spawnu(cmd)
    #time.sleep(3)
    proc.expect('.*ASPD.*')
    #print (proc.before)
    print(proc.after)
    proc.sendline('vmwa status')
    proc.expect('.*ASPD.*')
    print(proc.after)

    iso_cmd = 'vmwa dev2iso ' + iso_file_path
    proc.sendline(iso_cmd)
    proc.expect('.*ASPD.*')
    print(proc.after)

    proc.sendline('ipmi power cycle')
    proc.expect('.*ASPD.*')
Esempio n. 40
0
def test_user_aud_check_open(ald_init, app):
    admpass = ald_init[0]
    passfile = ald_init[1]
    aud_list = app.user.user_aud_list(passfile)
    user_list = app.user.user_list()
    user, u_passwd = valid_name_generator(), 'Testpass123'
    if user not in user_list:
        app.user.user_create(user, admpass, u_passwd)
    if user in str(aud_list):
        app.user.user_aud_del(user, admpass)
        app.user.user_aud_add(user, hex(aud_flags['open']),
                              hex(aud_flags['open']), admpass)
    else:
        app.user.user_aud_add(user, hex(aud_flags['open']),
                              hex(aud_flags['open']), admpass)

    app.user.user_ald_cap(user, getfqdn(), passfile)

    aud_dir = '/tmp/dir_for_test'
    aud_file = aud_dir + '/file_for_test'
    aud_flag = 'open'

    app.base.clean_kernel_mlog()
    try:
        os.mkdir(aud_dir, 0o700)
    except OSError as mkdir_err:
        if mkdir_err.errno == errno.EEXIST:
            os.chmod(aud_dir, 0o700)
            if os.access(aud_file, os.F_OK):
                os.remove(aud_file)
        else:
            raise
    with open(aud_file, 'w', encoding='utf-8') as audfile:
        audfile.write('test')
    os.chmod(aud_file, 0o700)

    user_uid = app.base.get_user_uid(user)
    os.chown(aud_file, user_uid, os.getuid())
    os.chown(aud_dir, user_uid, os.getuid())

    usession = pexpect.spawnu('login %s' % user, timeout=3)
    usession.expect('Пароль:')
    usession.sendline(u_passwd)
    usession.sendline('cat %s' % aud_file)
    time.sleep(2)

    kern_list = app.base.kernlog_list(user_uid)

    result = app.user.user_aud_check(kern_list, obj=aud_file, call=aud_flag)
    # in case of the 1st fail
    if not result:
        usession.sendline('exit')
        usession.expect(pexpect.EOF)
        usession.close()
        assert usession.exitstatus == 0
        assert not usession.isalive()
    assert result

    app.base.clean_kernel_mlog()

    os.chmod(aud_file, 0o070)
    usession.sendline('cat %s' % aud_file)
    usession.sendline('exit')
    usession.expect(pexpect.EOF)
    usession.close()
    assert usession.exitstatus == 0
    assert not usession.isalive()

    kern_list = app.base.kernlog_list(user_uid)
    result = app.user.user_aud_check(kern_list,
                                     obj=aud_file,
                                     call=aud_flag,
                                     flag='[f]')
    assert result
Esempio n. 41
0
def step_run_cli(context):
    """
    Run the process using pexpect.
    """
    context.cli = pexpect.spawnu('pgcli')
Esempio n. 42
0
# 2:11PM  up 3 days, 13:50, 3 users, load averages: 0.01, 0.00, 0.00
# [powerpc] Darwin v1-58.corefa.com 8.2.0 Darwin Kernel Version 8.2.0
# 10:35  up 18:06, 4 users, load averages: 0.52 0.47 0.36
# [Sparc - R220] Sun Solaris (8)
#  2:13pm  up 22 min(s),  1 user,  load average: 0.02, 0.01, 0.01
# [x86] Linux 2.4.18-14 (Redhat 8)
# 11:36pm  up 4 days, 17:58,  1 user,  load average: 0.03, 0.01, 0.00
# AIX jwdir 2 5 0001DBFA4C00
#  09:43AM   up  23:27,  1 user,  load average: 0.49, 0.32, 0.23
# OpenBSD box3 2.9 GENERIC#653 i386
#  6:08PM  up 4 days, 22:26, 1 user, load averages: 0.13, 0.09, 0.08

# Note that, for Python 3 compatibility reasons, we are using spawnu and
# importing unicode_literals (above). spawnu accepts Unicode input and
# unicode_literals makes all string literals in this script Unicode by default.
p = pexpect.spawnu("uptime")

# This parses uptime output into the major groups using regex group matching.
p.expect(
    r"up\s+(.*?),\s+([0-9]+) users?,\s+load averages?: ([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9])"
)
duration, users, av1, av5, av15 = p.match.groups()

# The duration is a little harder to parse because of all the different
# styles of uptime. I'm sure there is a way to do this all at once with
# one single regex, but I bet it would be hard to read and maintain.
# If anyone wants to send me a version using a single regex I'd be happy to see it.
days = "0"
hours = "0"
mins = "0"
if "day" in duration:
Esempio n. 43
0
def spawn_process(command):
    """return a handle to a new controllable child process"""
    return pexpect.spawnu(command, dimensions=(24, 250))
Esempio n. 44
0
#!/usr/bin/env python
#coding:utf-8

from __future__ import unicode_literals  # 使用unicode编码
import pexpect
import sys

child = pexpect.spawnu('ftp ftp.openbsd.org')  # 运行ftp命令
info = file('ftp.txt', 'w')  # 记录连接日志信息
child.logfile = info
# 匹配账号输入提示,(?i)表示后面的字符串正则匹配忽略大小写
child.expect('(?i)name .*: ')
child.sendline('anonymous')  # 输入ftp账号信息
child.expect('(?i)password')  # 匹配密码输入提示
child.sendline('*****@*****.**')  # 输入ftp密码
# 调用interact()让出控制权,用户可以继续当前的会话手工控制子程序
child.interact()
child.sendline('bye')
child.close()
 def __init__(self):
     subprocess.check_output("rfkill unblock bluetooth", shell=True)
     self.process = pexpect.spawnu("bluetoothctl", echo=False)
Esempio n. 46
0
def test_user_aud_check_mac(ald_init, app):
    admpass = ald_init[0]
    passfile = ald_init[1]
    aud_list = app.user.user_aud_list(passfile)
    user_list = app.user.user_list()
    user, u_passwd = valid_name_generator(), 'Testpass123'
    if user not in user_list:
        app.user.user_create(user, admpass, u_passwd)
    if user in str(aud_list):
        app.user.user_aud_del(user, admpass)
        app.user.user_aud_add(user, hex(aud_flags['mac']), hex(aud_flags['mac']), admpass)
    else:
        app.user.user_aud_add(user, hex(aud_flags['mac']), hex(aud_flags['mac']), admpass)

    cap = 'parsec_cap_chmac'
    app.user.user_ald_cap(user, getfqdn(), passfile)

    aud_dir = '/dir_for_test'
    aud_flag = 'parsec_chmac'

    try:
        os.mkdir(aud_dir, 0o700)
    except OSError as mkdir_err:
        if mkdir_err.errno == errno.EEXIST:
            shutil.rmtree(aud_dir)
            os.mkdir(aud_dir, 0o700)
        else:
            raise

    app.base.clean_kernel_mlog()
    user_uid = app.base.get_user_uid(user)
    app.user.user_parsec_cap_mod(user, cap, admpass)

    usession = pexpect.spawnu('login %s' % user, timeout=3)
    usession.expect('Пароль:')
    usession.sendline(u_passwd)
    usession.expect(user + '@' + gethostname())
    usession.sendline('/usr/sbin/pdpl-file 1:0:0 %s' % '/')
    usession.expect(user + '@' + gethostname())
    usession.sendline('exit')
    usession.expect(pexpect.EOF)
    usession.close()
    assert usession.exitstatus == 0
    assert not usession.isalive()

    kern_list = app.base.kernlog_list(user_uid)

    result = app.user.user_aud_check(kern_list, call=aud_flag, obj='/', flag='[f]')
    assert result

    app.base.clean_kernel_mlog()

    usession = pexpect.spawnu('login %s' % user, timeout=3)
    usession.expect('Пароль:')
    usession.sendline(u_passwd)
    usession.expect(user + '@' + gethostname())
    usession.sendline('/usr/sbin/pdpl-file 1:0:0 %s' % aud_dir)
    usession.expect(user + '@' + gethostname())
    usession.sendline('exit')
    usession.expect(pexpect.EOF)
    usession.close()
    assert usession.exitstatus == 0
    assert not usession.isalive()

    kern_list = app.base.kernlog_list(user_uid)
    result = app.user.user_aud_check(kern_list, call=aud_flag, obj=aud_dir, flag='[s]')
    assert result

    shutil.rmtree(aud_dir)
Esempio n. 47
0
    def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
        """Test that 'stty -a' displays the same output before and after running the lldb command."""
        import pexpect
        if not which('expect'):
            self.skipTest(
                "The 'expect' program cannot be located, skip the test")

        # The expect prompt.
        expect_prompt = "expect[0-9.]+> "
        # The default lldb prompt.
        lldb_prompt = "(lldb) "

        # So that the child gets torn down after the test.
        self.child = pexpect.spawnu('expect')
        child = self.child

        child.expect(expect_prompt)
        child.setecho(True)
        if self.TraceOn():
            child.logfile = sys.stdout

        if self.platformIsDarwin():
            child.sendline('set env(TERM) xterm')
        else:
            child.sendline('set env(TERM) vt100')
        child.expect(expect_prompt)
        child.sendline('puts $env(TERM)')
        child.expect(expect_prompt)

        # Turn on loggings for input/output to/from the child.
        child.logfile_send = child_send1 = six.StringIO()
        child.logfile_read = child_read1 = six.StringIO()
        child.sendline('stty -a')
        child.expect(expect_prompt)

        # Now that the stage1 logging is done, restore logfile to None to
        # stop further logging.
        child.logfile_send = None
        child.logfile_read = None

        # Invoke the lldb command.
        child.sendline(lldbtest_config.lldbExec)
        child.expect_exact(lldb_prompt)

        # Immediately quit.
        child.sendline('quit')
        child.expect(expect_prompt)

        child.logfile_send = child_send2 = six.StringIO()
        child.logfile_read = child_read2 = six.StringIO()
        child.sendline('stty -a')
        child.expect(expect_prompt)

        child.sendline('exit')

        # Now that the stage2 logging is done, restore logfile to None to
        # stop further logging.
        child.logfile_send = None
        child.logfile_read = None

        if self.TraceOn():
            print("\n\nContents of child_send1:")
            print(child_send1.getvalue())
            print("\n\nContents of child_read1:")
            print(child_read1.getvalue())
            print("\n\nContents of child_send2:")
            print(child_send2.getvalue())
            print("\n\nContents of child_read2:")
            print(child_read2.getvalue())

        stty_output1_lines = child_read1.getvalue().splitlines()
        stty_output2_lines = child_read2.getvalue().splitlines()
        zipped = list(zip(stty_output1_lines, stty_output2_lines))
        for tuple in zipped:
            if self.TraceOn():
                print("tuple->%s" % str(tuple))
            # Every line should compare equal until the first blank line.
            if len(tuple[0]) == 0:
                break
            self.assertEqual(tuple[0], tuple[1])
def test_master_descriptor_publication(tmpdir):
    """
    Functional test to run OnionBalance, publish a master descriptor and
    check that it can be retrieved from the DHT.
    """

    chutney_config = parse_chutney_enviroment()
    private_key = Crypto.PublicKey.RSA.generate(1024)
    master_onion_address = onionbalance.util.calc_onion_address(private_key)

    config_file_path = create_test_config_file(
        tmppath=tmpdir,
        private_key=private_key,
        instances=chutney_config.get('instances', []),
    )
    assert config_file_path

    # Start an OnionBalance server and monitor for correct output with pexpect
    server = pexpect.spawnu("onionbalance",
                            args=[
                                '-i', chutney_config.get('client_ip'),
                                '-p', str(chutney_config.get('control_port')),
                                '-c', config_file_path,
                                '-v', 'debug',
                            ], logfile=sys.stdout, timeout=15)

    # Check for expected output from OnionBalance
    server.expect(u"Loaded the config file")
    server.expect(u"introduction point set has changed")
    server.expect(u"Published a descriptor", timeout=120)

    # Check Tor control port gave an uploaded event.

    server.expect(u"HS_DESC UPLOADED")
    # Eek, sleep to wait for descriptor upload to all replicas to finish
    time.sleep(10)

    # .. todo:: Also need to check and raise for any warnings or errors
    #           that are emitted

    # Try fetch and validate the descriptor with stem
    with stem.control.Controller.from_port(
        address=chutney_config.get('client_ip'),
        port=chutney_config.get('control_port')
    ) as controller:
        controller.authenticate()

        # get_hidden_service_descriptor() will raise exceptions if it
        # cannot find the descriptors
        master_descriptor = controller.get_hidden_service_descriptor(
            master_onion_address)
        master_ips = master_descriptor.introduction_points()

        # Try retrieve a descriptor for each instance
        for instance_address in chutney_config.get('instances'):
            instance_descriptor = controller.get_hidden_service_descriptor(
                instance_address)
            instance_ips = instance_descriptor.introduction_points()

            # Check if all instance IPs were included in the master descriptor
            assert (set(ip.identifier for ip in instance_ips) ==
                    set(ip.identifier for ip in master_ips))
Esempio n. 49
0
re_ip_exception = re.compile(r'(\d{1,3}\.){4,}')

if re_ip_exception.search(wlc_ip):
    ip_warning(wlc_ip)

verify_ip = re_ip.search(wlc_ip)

if verify_ip:
    ip_group = verify_ip.groups()
    for ip in ip_group:
        if int(ip) >= 255:
            ip_warning(wlc_ip)
else:
    ip_warning(wlc_ip)

wlc_connect = pexpect.spawnu('ssh ' + wlc_ip)
#wlc_connect.logfile = sys.stdout
wlc_connect.expect('User:'******'Password:'******'(Cisco Controller)', 'User'])
if login_check == 1:
    print("Login Error, Check your account status")
    sys.exit(0)
else:
    print("Login Successfully")

wlc_connect.sendline('show ap summary')
def test_master_descriptor_publication(tmpdir):
    """
    Functional test to run OnionBalance, publish a master descriptor and
    check that it can be retrieved from the DHT.
    """

    chutney_config = parse_chutney_enviroment()
    private_key = Crypto.PublicKey.RSA.generate(1024)
    master_onion_address = onionbalance.hs_v2.util.calc_onion_address(
        private_key)

    config_file_path = create_test_config_file(
        tmppath=tmpdir,
        private_key=private_key,
        instances=chutney_config.get('instances', []),
    )
    assert config_file_path

    # Start an OnionBalance server and monitor for correct output with pexpect
    server = pexpect.spawnu("onionbalance",
                            args=[
                                '--hs-version',
                                'v2',
                                '-i',
                                chutney_config.get('client_ip'),
                                '-p',
                                str(chutney_config.get('control_port')),
                                '-c',
                                config_file_path,
                                '-v',
                                'debug',
                            ],
                            logfile=sys.stdout,
                            timeout=15)

    # Check for expected output from OnionBalance
    server.expect(u"Loaded the config file")
    server.expect(u"introduction point set has changed")
    server.expect(u"Published a descriptor", timeout=120)

    # Check Tor control port gave an uploaded event.

    server.expect(u"HS_DESC UPLOADED")
    # Eek, sleep to wait for descriptor upload to all replicas to finish
    time.sleep(10)

    # .. todo:: Also need to check and raise for any warnings or errors
    #           that are emitted

    # Try fetch and validate the descriptor with stem
    with stem.control.Controller.from_port(
            address=chutney_config.get('client_ip'),
            port=chutney_config.get('control_port')) as controller:
        controller.authenticate()

        # get_hidden_service_descriptor() will raise exceptions if it
        # cannot find the descriptors
        master_descriptor = controller.get_hidden_service_descriptor(
            master_onion_address)
        master_ips = master_descriptor.introduction_points()

        # Try retrieve a descriptor for each instance
        for instance_address in chutney_config.get('instances'):
            instance_descriptor = controller.get_hidden_service_descriptor(
                instance_address)
            instance_ips = instance_descriptor.introduction_points()

            # Check if all instance IPs were included in the master descriptor
            assert (set(ip.identifier
                        for ip in instance_ips) == set(ip.identifier
                                                       for ip in master_ips))

    # Check that the control socket was created
    socket_path = tmpdir.join('control')
    assert socket_path.check()

    # Connect to the control socket and check the output
    sock_client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    sock_client.connect(str(socket_path))

    # Read the data from the status socket
    result = []
    while True:
        data = sock_client.recv(1024)
        if not data:
            break
        result.append(data.decode('utf-8'))
    result_data = ''.join(result)

    # Check each instance is in the output
    for instance_address in chutney_config.get('instances'):
        assert instance_address in result_data

    # Check all instances were online and all master descriptors uploaded
    assert master_onion_address in result_data
    assert '[offline]' not in result_data
    assert '[not uploaded]' not in result_data
Esempio n. 51
0
# output that line. The 'child.sendline' lines tell `pexpect` to send
# that information to the program.
#
# With these two combined, we can simulate typing really quickly! It
# makes it **much** easier that trying to type in input values
# again... and again... and again...
#
# You aren't required to use this file. It's just here to make testing
# a little easier, if you want to give it a try.
#
##
import pexpect
import sys

# Start the XY77 program
child = pexpect.spawnu('python3.4 main.py')

# Keep track of output from the attached program.
child.logfile_read = sys.stdout

##
# Setup
#

# Serial number
child.expect(">> ")  # Wait for a >>
child.sendline("KRXX7e3652")  # When we see a >>, send the serial number

# Check Engine light
child.expect(">> ")
child.sendline("0")
Esempio n. 52
0
#!/usr/bin/env python

import pexpect
import subprocess
import sys

image_name = sys.argv[1]

pex = pexpect.spawnu("whoami")
pex.expect(u'(\S+)')
username = pex.match.groups()[0]

pex = pexpect.spawnu("shifterimg lookup %s" % image_name)
pex.expect(u'([0-9a-f]+)')
image_id = pex.match.groups()[0]

expected_config = u'{"identifier":"%s","user":"******","volMap":""}' \
        % (image_id, username)

pex = pexpect.spawnu("shifter --image=%s cat /var/shifterConfig.json" % image_name)
pex.expect(expected_config)
Esempio n. 53
0
 def test_expect_echo(self):
     '''This tests that echo can be turned on and off.
     '''
     p = pexpect.spawnu('cat', timeout=10)
     self._expect_echo(p)
Esempio n. 54
0
    # Transfer the Database
    print('OK, I am going to try to migrate the database now...')

    db_proc = """mysqldump -u{0} -p{1} -h{2} {3} | sed "s/TIME_ZONE='+00:00'/TIME_ZONE='+06:00'/" | pv | xz -c -4 | ssh {4}@{5} "xz -d -c | mysql -u{6} -p{7} -h{8} {9}" """.format(
        args.source_db_user, shlex.quote(args.source_db_pass), args.source_db_host, args.source_db_name,
        args.dest_sftp_user, args.destination, args.dest_db_user, shlex.quote(args.dest_db_pass), args.dest_db_host,
        args.dest_db_name)
    if args.verbose:
        print(db_proc)
    try:
        # This is the "wrong" way to do it, but I can't get the nested Popen's to work
        if args.dest_sftp_pass is None:
            exitcode = subprocess.call(db_proc, shell=True)
        else:
            child = pexpect.spawnu('/bin/bash', ['-c', db_proc], timeout=None)
            child.expect(['password: '******'DB copy failed.  Abort!')
        exit(1)

    # Update the DB refs in local.xmls or wp-config.php
Esempio n. 55
0
 def test_expect_echo_exact(self):
     '''Like test_expect_echo(), but using expect_exact().
     '''
     p = pexpect.spawnu('cat', timeout=10)
     p.expect = p.expect_exact
     self._expect_echo(p)
Esempio n. 56
0
async def analyze_callback(mythic, callback):
    try:

        task = Task(callback=callback, command="nmap", params="a")
        print("[+] got new callback, retrieving ip address")

        submit = await mythic.create_task(task, return_on="completed")
        print("[*] waiting for ls results...")
        results = await mythic.gather_task_responses(submit.response.id,
                                                     timeout=20)

        for res in results:
            print(res)
            if res.task.command.cmd == 'nmap asd':

                ip = res.response
                print("Scanning " + ip)

                output = pexpect.run("sshuttle -r [email protected] 0/0",
                                     events={'.*assword': 'bubiman10\n'})

                print("\nThe output of sshuttle command: \n%s" %
                      output.decode("utf-8"))

                ip = requests.get('https://api.ipify.org').text
                print('My public IP address is: {}'.format(ip))

                output = pexpect.run("nmap 192.168.0.0/24")

                print("\nThe output of nmap command: \n%s" %
                      output.decode("utf-8"))

                child = pexpect.spawnu("bash")
                child.logfile = open("./log.log", "w")
                child.expect(".*@")
                child.sendline("sshuttle -r [email protected] 0/0")
                child.expect(".*assword")
                child.sendline("bubiman10")
                child.expect(".*assword")
                child.sendline("bubiman10")
                child.expect(".*onnected")

                p = pexpect.spawnu("bash")
                p.logfile_read = open("./log2.log", "w")
                p.sendline("curl ipv4.icanhazip.com")
                time.sleep(1)
                p.expect(".*\.")

                address_file = open("./log2.log", "r")
                text = str(address_file.readlines())
                pattern = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')
                ip = pattern.findall(text)[0]

                os.remove("./log.log")
                os.remove("./log2.log")

                nmap = pexpect.spawnu("bash")
                nmap.logfile = open("./nmap_" + ip + ".log", "w")
                nmap.sendline("nmap -iR 1")
                nmap.expect("Nmap done")

        # task = Task(
        #     callback=callback, command="ls", params="."
        # )
        # print("[+] got new callback, issuing ls")
        # submit = await mythic.create_task(task, return_on="completed")
        # print("[*] waiting for ls results...")
        # results = await mythic.gather_task_responses(submit.response.id, timeout=20)
        # folder  = json.loads(results[0].response)
        # print("[*] going through results looking for interesting files...")
        # for f in folder["files"]:
        #     if f["name"] == "provaserver":
        #         task = Task(
        #             callback=callback, command="download", params="provaserver"
        #         )
        #         print("[+] found an interesting file, tasking it for download")
        #         await mythic.create_task(task, return_on="submitted")
        # task = Task(
        #     callback=callback, command="list_apps"
        # )
        # print("[+] tasking callback to list running applications")
        # list_apps_submit = await mythic.create_task(task, return_on="submitted")
        # print("[*] waiting for list_apps results...")
        # results = await mythic.gather_task_responses(list_apps_submit.response.id)
        # apps = json.loads(results[0].response)
        # print("[*] going through results looking for dangerous processes...")
        # for a in apps:
        #     if "Little Snitch Agent" in a["name"]:
        #         list_apps_submit.response.comment = "Auto processed, created alert on Little Snitch Agent, updating block lists"
        #         await mythic.set_comment_on_task(list_apps_submit.response)
        #         print("[+] found a dangerous process! Little Snitch Agent - sending alert to operators")
        #         await mythic.create_event_message(message=EventMessage(message="LITTLE SNITCH DETECTED on {}".format(callback.host), level='warning'))
        #         resp = await mythic.get_all_disabled_commands_profiles()
        #         print("[+] Getting/creating disabled command profile to prevent bad-opsec commands based on dangerous processes")
        #         snitchy_block_list_exists = False
        #         for cur_dcp in resp.response:
        #             if cur_dcp.name == "snitchy block list":
        #                 snitchy_block_list_exists = True
        #                 dcp = cur_dcp
        #         if not snitchy_block_list_exists:
        #             dcp = DisabledCommandsProfile(name="snitchy block list", payload_types=[
        #                 PayloadType(ptype="prova", commands=["shell", "shell_elevated"]),
        #                 PayloadType(ptype="poseidon", commands=["shell"])
        #             ])
        #             resp = await mythic.create_disabled_commands_profile(dcp)
        #         current_operation = (await mythic.get_current_operation_info()).response
        #         for member in current_operation.members:
        #             print("[*] updating block list for {}".format(member.username))
        #             resp = await mythic.update_disabled_commands_profile_for_operator(profile=dcp, operator=member, operation=current_operation)

    except Exception as e:
        print(str(e))
Esempio n. 57
0
def qqq(action, fiename, port):
    try:
        # Connect to the device
        tmp = conntimeout
        handler = pexpect.spawnu('telnet %s %i' % (ip, port), maxread=20000)
        handler.logfile = sys.stdout
        handler.crlf = '\r\n'
        while (tmp > 0):
            #handler.sendline('')
            time.sleep(0.1)
            tmp = tmp - 0.1
            if handler.isalive() == True:
                break

        if action == 'get':
            if (handler.isalive() != True):
                print('ERROR: cannot connect to port "%i".' % (port))
                node_quit(handler)
                sys.exit(1)
            rc = node_login(handler)
            if rc != True:
                print('ERROR: failed to login.')
                node_quit(handler)
                sys.exit(1)
            config = config_get(handler)
            if config in [False, None]:
                print('ERROR: failed to retrieve config.')
                node_quit(handler)
                sys.exit(1)

            try:
                fd = open(filename, 'a')
                fd.write(config)
                fd.close()
            except:
                print('ERROR: cannot write config to file.')
                node_quit(handler)
                sys.exit(1)
        elif action == 'put':
            rc = config_put(handler)
            if rc != True:
                print('ERROR: failed to push config.')
                node_quit(handler)
                sys.exit(1)

            # Remove lock file
            lock = '%s/.lock' % (os.path.dirname(filename))

            if os.path.exists(lock):
                os.remove(lock)

            # Mark as configured
            configured = '%s/.configured' % (os.path.dirname(filename))
            if not os.path.exists(configured):
                open(configured, 'a').close()

        node_quit(handler)
        sys.exit(0)

    except Exception as e:
        print('ERROR: got an exception')
        print(type(e))  # the exception instance
        print(e.args)  # arguments stored in .args
        print(e)  # __str__ allows args to be printed directly,
        node_quit(handler)
        return False
Esempio n. 58
0
def step_start_cycli_read_only(context):
    context.cli = pexpect.spawnu("cycli -u neo4j -p password -r")
Esempio n. 59
0
def run_interactive_command(prompt_answers, command, *args):
    """
    Helper function that runs the specified command, and takes care of
    providing answers to interactive prompts.

    This is a convenience wrapper around the pexpect library.

    Unlikes the run_command helper, this helper is not capable of
    separating the standard output from standard error
    (unfortunately).

    The failure message returned describes only issues related to
    command not providing the expected prompt for answer, or if
    command gets stuck in a prompt after all expected prompts were
    processed.

    :param prompt_answers: List of prompts and their correspnding answers. To send a control character, start the answer with 'Ctrl-' (for example 'Ctrl-d').
    :type prompt_answers: list[(str, str)]

    :param command: Command that should be run.
    :type command: str

    :param *args: Zero or more arguments to pass to the command.
    :type *args: str

    :returns: (failure, output, exit_code) -- Prompt failure message, combined standard output and error, and exit code (None if prompt failure happened).
    :rtype: (str or None, str, int)
    """

    # Assume that all prompts/answers worked as expected.
    failure = None

    # Spawn the process, use dedicated stream for capturin command
    # stdout/stderr.
    output_stream = io.StringIO()
    send_stream = io.StringIO()
    process = pexpect.spawnu(command, list(args), timeout=4)
    process.logfile_read = output_stream
    process.logfile_send = send_stream

    # Try to feed the interactive process with answers. Stop iteration
    # at first prompt that was not reached.
    for prompt, answer in prompt_answers:
        try:
            process.expect(prompt)
            if answer.startswith('Ctrl-'):
                process.sendcontrol(answer.lstrip('Ctrl-'))
            else:
                process.sendline(answer)
        except pexpect.TIMEOUT:
            failure = "Command never prompted us with: %s" % prompt
            process.terminate()
            break

    # If we were successful until now, wait for the process to exit.
    if failure is None:
        try:
            process.expect(pexpect.EOF)
        except pexpect.TIMEOUT:
            failure = "Command got stuck waiting for input."
            process.terminate()

    process.close()
    output = output_stream.getvalue()
    exit_code = process.exitstatus

    return failure, output, exit_code
Esempio n. 60
0
        reversed(
            sorted([
                d for d in os.listdir(result_dir_parent)
                if os.path.isdir(os.path.join(result_dir_parent, d))
            ])))

    return os.path.join(result_dir_parent, latest_subdir)


device_detected_re = re.compile(r"DeviceManager: Detected new device ")
device_detected_search_re = re.compile(
    r"DeviceManager: Detected new device .*$", flags=re.M)
tradefed_start_retry_count = 5
all_devices_names = set(device.serial_or_address for device in devices)
for tradefed_start_retry in range(tradefed_start_retry_count):
    child = pexpect.spawnu(command, logfile=tradefed_stdout)
    try:
        devices_to_detect = all_devices_names.copy()
        while devices_to_detect:
            # Find and parse output lines following this pattern:
            # 04-23 12:30:33 I/DeviceManager: Detected new device serial_or_address
            child.expect(device_detected_re, timeout=30)
            output_lines = subprocess.check_output(["tail", TRADEFED_STDOUT
                                                    ]).decode("utf-8")
            matches = [
                match[1].strip()
                for match in (device_detected_re.split(line_match)
                              for line_match in
                              device_detected_search_re.findall(output_lines))
                if len(match) == 2 and match[1]
            ]