我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用fcntl.F_GETFL。
def __init__(self, slave=0, pid=os.getpid()): # apparently python GC's modules before class instances so, here # we have some hax to ensure we can restore the terminal state. self.termios, self.fcntl = termios, fcntl # open our controlling PTY self.pty = open(os.readlink("/proc/%d/fd/%d" % (pid, slave)), "rb+") # store our old termios settings so we can restore after # we are finished self.oldtermios = termios.tcgetattr(self.pty) # get the current settings se we can modify them newattr = termios.tcgetattr(self.pty) # set the terminal to uncanonical mode and turn off # input echo. newattr[3] &= ~termios.ICANON & ~termios.ECHO # don't handle ^C / ^Z / ^\ newattr[6][termios.VINTR] = '\x00' newattr[6][termios.VQUIT] = '\x00' newattr[6][termios.VSUSP] = '\x00' # set our new attributes termios.tcsetattr(self.pty, termios.TCSADRAIN, newattr) # store the old fcntl flags self.oldflags = fcntl.fcntl(self.pty, fcntl.F_GETFL) # fcntl.fcntl(self.pty, fcntl.F_SETFD, fcntl.FD_CLOEXEC) # make the PTY non-blocking fcntl.fcntl(self.pty, fcntl.F_SETFL, self.oldflags | os.O_NONBLOCK)
def _communicate(self): import fcntl oldflags = fcntl.fcntl(self.__inr, fcntl.F_GETFL) fcntl.fcntl(self.__inr, fcntl.F_SETFL, oldflags | os.O_NONBLOCK) while not self._exit: events = select([self._agent._conn, self.__inr], [], [], 0.5) for fd in events[0]: if self._agent._conn == fd: data = self._agent._conn.recv(512) if len(data) != 0: self.__inr.send(data) else: self._close() break elif self.__inr == fd: data = self.__inr.recv(512) if len(data) != 0: self._agent._conn.send(data) else: self._close() break time.sleep(io_sleep)
def train(self): i=0 if(self.args.ipython): fd = sys.stdin.fileno() fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) while(i < self.total_steps or self.total_steps == -1): i+=1 start_time = time.time() self.step() if (self.args.save_every != None and self.args.save_every != -1 and self.args.save_every > 0 and i % self.args.save_every == 0): print(" |= Saving network") self.gan.save(self.save_file) if self.args.ipython: self.check_stdin() end_time = time.time()
def keyboard(callback, exit='q'): fd = sys.stdin.fileno() oldterm = termios.tcgetattr(fd) newattr = termios.tcgetattr(fd) newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO termios.tcsetattr(fd, termios.TCSANOW, newattr) oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK) try: while True: try: ch = sys.stdin.read(1) if ch: callback(ch) if ch == exit: break except IOError: pass finally: termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
def start_pty(self, *args): if not self.container_id: self.send_error_and_close("Error: container not found.") return try: # create a pseudo terminal of container by command: # `docker exec -ti <container_id> /bin/sh -c '[ -x /bin/bash ] && /bin/bash || /bin/sh'` # and then set the stream to non-blocking mode. pty = PtyProcessUnicode.spawn( ['docker', 'exec', '-ti', self.container_id, '/bin/sh', '-c', 'echo $$ > /tmp/sh.pid.{} && [ -x /bin/bash ] && /bin/bash || /bin/sh'.format(self.uuid)]) flags = fcntl(pty.fileobj, F_GETFL) fcntl(pty.fileobj, F_SETFL, flags | O_NONBLOCK) setattr(self, "pty", pty) TerminalSocketHandler.clients.update({self: pty}) logger.info('Connect to console of container {}'.format(self.container_id)) except Exception as e: self.send_error_and_close("Error: cannot start console: {}".format(e))
def _setup_pipe(self, name): from fcntl import fcntl, F_GETFL, F_SETFL real_fd = getattr(sys, '__%s__' % name).fileno() save_fd = os.dup(real_fd) self._save_fds[name] = save_fd pipe_out, pipe_in = os.pipe() os.dup2(pipe_in, real_fd) os.close(pipe_in) self._real_fds[name] = real_fd # make pipe_out non-blocking flags = fcntl(pipe_out, F_GETFL) fcntl(pipe_out, F_SETFL, flags | os.O_NONBLOCK) return pipe_out
def set_nonblock(self, set_flag=True): """Set the non blocking flag on the socket""" # Get the current flags if self.fd_flags is None: try: self.fd_flags = fcntl.fcntl(self.ins, fcntl.F_GETFL) except IOError, err: warning("Can't get flags on this file descriptor !") return # Set the non blocking flag if set_flag: new_fd_flags = self.fd_flags | os.O_NONBLOCK else: new_fd_flags = self.fd_flags & ~os.O_NONBLOCK try: fcntl.fcntl(self.ins, fcntl.F_SETFL, new_fd_flags) self.fd_flags = new_fd_flags except: warning("Can't set flags on this file descriptor !")
def _recv(self, which, maxsize): conn, maxsize = self.get_conn_maxsize(which, maxsize) if conn is None: return None flags = fcntl.fcntl(conn, fcntl.F_GETFL) if not conn.closed: fcntl.fcntl(conn, fcntl.F_SETFL, flags | os.O_NONBLOCK) try: if not select.select([conn], [], [], 0)[0]: return '' r = conn.read(maxsize) if not r: return self._close(which) if self.universal_newlines: r = self._translate_newlines(r) return r finally: if not conn.closed: fcntl.fcntl(conn, fcntl.F_SETFL, flags)
def _recv(self, which, maxsize): conn, maxsize = self.get_conn_maxsize(which, maxsize) if conn is None: return None flags = fcntl.fcntl(conn, fcntl.F_GETFL) if not conn.closed: fcntl.fcntl(conn, fcntl.F_SETFL, flags| os.O_NONBLOCK) try: if not select.select([conn], [], [], 0)[0]: return '' r = conn.read(maxsize) if not r: return self._close(which) if self.universal_newlines: r = r.replace("\r\n", "\n").replace("\r", "\n") return r finally: if not conn.closed: fcntl.fcntl(conn, fcntl.F_SETFL, flags) ################################################################################
def open(self): """Starts the subprocess, does nothing if it is already closed""" if self.status: return cmd = shlex.split(self.cmd) self._child = subprocess.Popen( cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None ) # make stdout non-blocking stdout_fd = self._child.stdout.fileno() stdout_fl = fcntl.fcntl(stdout_fd, fcntl.F_GETFL) | os.O_NONBLOCK fcntl.fcntl(stdout_fd, fcntl.F_SETFL, stdout_fl) # prepare for timeout handing self._poll = select.poll() self._poll.register(self._child.stdout.fileno()) self.status = 1
def get_keypress(): """Wait for a keypress and return key pressed. This is the *nix version of this command""" import termios, fcntl, sys, os fd = sys.stdin.fileno() oldterm = termios.tcgetattr(fd) newattr = termios.tcgetattr(fd) newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO termios.tcsetattr(fd, termios.TCSANOW, newattr) oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK) try: while 1: try: c = sys.stdin.read(1) break except IOError: pass finally: termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags) return c
def getch(): fd = sys.stdin.fileno() oldattr = termios.tcgetattr(fd) newattr = termios.tcgetattr(fd) newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO termios.tcsetattr(fd, termios.TCSANOW, newattr) oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK) try: while True: try: c = sys.stdin.read(1) except IOError: pass else: return c finally: termios.tcsetattr(fd, termios.TCSAFLUSH, oldattr) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
def test_pipe2(self): self.assertRaises(TypeError, os.pipe2, 'DEADBEEF') self.assertRaises(TypeError, os.pipe2, 0, 0) # try calling with flags = 0, like os.pipe() r, w = os.pipe2(0) os.close(r) os.close(w) # test flags r, w = os.pipe2(os.O_CLOEXEC|os.O_NONBLOCK) self.addCleanup(os.close, r) self.addCleanup(os.close, w) self.assertFalse(os.get_inheritable(r)) self.assertFalse(os.get_inheritable(w)) self.assertTrue(fcntl.fcntl(r, fcntl.F_GETFL) & os.O_NONBLOCK) self.assertTrue(fcntl.fcntl(w, fcntl.F_GETFL) & os.O_NONBLOCK) # try reading from an empty pipe: this should fail, not block self.assertRaises(OSError, os.read, r, 1) # try a write big enough to fill-up the pipe: this should either # fail or perform a partial write, not block try: os.write(w, b'x' * support.PIPE_MAX_SIZE) except OSError: pass
def __init__(self, fd): """'fd' is either a file object (e.g., obtained with 'open') or a file number (e.g., obtained with socket's fileno()). """ if hasattr(fd, 'fileno'): self._fd = fd self._fileno = fd.fileno() elif isinstance(fd, int): self._fd, self._fileno = None, self._fd else: raise ValueError('invalid file descriptor') self._pycos = Pycos.scheduler() if self._pycos: self._notifier = self._pycos._notifier if hasattr(fd, '_fileno'): # assume it is AsyncSocket self._notifier.unregister(fd) else: self._notifier = None self._timeout = None self._read_task = None self._read_fn = None self._write_task = None self._write_fn = None self._buflist = [] flags = fcntl.fcntl(self._fileno, fcntl.F_GETFL) fcntl.fcntl(self._fileno, fcntl.F_SETFL, flags | os.O_NONBLOCK)
def flags(self, *which): import fcntl, os if which: if len(which) > 1: raise TypeError, 'Too many arguments' which = which[0] else: which = '?' l_flags = 0 if 'n' in which: l_flags = l_flags | os.O_NDELAY if 'a' in which: l_flags = l_flags | os.O_APPEND if 's' in which: l_flags = l_flags | os.O_SYNC file = self._file_ if '=' not in which: cur_fl = fcntl.fcntl(file.fileno(), fcntl.F_GETFL, 0) if '!' in which: l_flags = cur_fl & ~ l_flags else: l_flags = cur_fl | l_flags l_flags = fcntl.fcntl(file.fileno(), fcntl.F_SETFL, l_flags) if 'c' in which: arg = ('!' not in which) # 0 is don't, 1 is do close on exec l_flags = fcntl.fcntl(file.fileno(), fcntl.F_SETFD, arg) if '?' in which: which = '' # Return current flags l_flags = fcntl.fcntl(file.fileno(), fcntl.F_GETFL, 0) if os.O_APPEND & l_flags: which = which + 'a' if fcntl.fcntl(file.fileno(), fcntl.F_GETFD, 0) & 1: which = which + 'c' if os.O_NDELAY & l_flags: which = which + 'n' if os.O_SYNC & l_flags: which = which + 's' return which
def __init__(self, fd, map=None): dispatcher.__init__(self, None, map) self.connected = True try: fd = fd.fileno() except AttributeError: pass self.set_file(fd) # set it to non-blocking mode flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0) flags = flags | os.O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, flags)
def _set_nonblocking(self, fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
def _set_nonblocking(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
def _set_nonblocking(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) flags = flags | os.O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, flags)
def __setNonBlocking( self, fileobj ): fl = fcntl.fcntl( fileobj.fileno(), fcntl.F_GETFL ) fcntl.fcntl( fileobj.fileno(), fcntl.F_SETFL, fl | os.O_NONBLOCK)
def make_blocking(f): fd = f.fileno() flags = fcntl.fcntl(fd, fcntl.F_GETFL) if flags & O_NONBLOCK: blocking = flags & ~O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, blocking)
def spawn(self, argv=None, term=None): if argv is None: if 'SHELL' in os.environ: argv = [os.environ['SHELL']] elif 'PATH' in os.environ: #searching sh in the path. It can be unusual like /system/bin/sh on android for shell in ["bash","sh","ksh","zsh","csh","ash"]: for path in os.environ['PATH'].split(':'): fullpath=os.path.join(path.strip(),shell) if os.path.isfile(fullpath): argv=[fullpath] break if argv: break if not argv: argv= ['/bin/sh'] if term is not None: os.environ['TERM']=term master, slave = pty.openpty() self.slave=slave self.master = os.fdopen(master, 'rb+wb', 0) # open file in an unbuffered mode flags = fcntl.fcntl(self.master, fcntl.F_GETFL) assert flags>=0 flags = fcntl.fcntl(self.master, fcntl.F_SETFL , flags | os.O_NONBLOCK) assert flags>=0 self.prog = subprocess.Popen( shell=False, args=argv, stdin=slave, stdout=slave, stderr=subprocess.STDOUT, preexec_fn=prepare )
def __init__(self): def setNonBlocking(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) flags = flags | os.O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, flags) MyThread.__init__(self) cmd = ["adb", "shell", "pm path jp.co.cyberagent.stf.rotationwatcher"] out, __ = Popen(cmd, stdout = PIPE).communicate() apk_path = out.split(":")[1].split()[0] cmd = ["adb", "shell", "CLASSPATH='%s' exec app_process /system/bin jp.co.cyberagent.stf.rotationwatcher.RotationWatcher" % (apk_path)] self.app = Popen(cmd, stdout= PIPE) setNonBlocking(self.app.stdout)
def pipe_non_blocking_set(fd): import fcntl fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) return True # only for compatibility with 'nt' version.
def set_nonblock(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
def set_block(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
def make_async(fd): """ Add the O_NONBLOCK flag to a file descriptor. """ fcntl.fcntl(fd, fcntl.F_SETFL, fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK)
def make_nonblocking(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0) if not bool(flags & os.O_NONBLOCK): fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) return True
def _remove_nonblock_flag(self, fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) & (~os.O_NONBLOCK) fcntl.fcntl(fd, fcntl.F_SETFL, flags)
def set_non_blocking(fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, flags)
def connect(self, timeout = DEFAULT_CONNECT_TIMEOUT): self.proc = Popen(self._commands, stdout=PIPE, stderr=STDOUT, universal_newlines=True) # set stdout to non-blocking fd = self.proc.stdout.fileno() fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) result = [False] self._connectThread = threading.Thread(target = self.connectThreadedFunc, args = [result]) self._connectThread.daemon = True self._connectThread.start() self._connectThread.join(timeout) # If thread is still alive, tear down pppd connection and kill the thread. if self._connectThread.is_alive(): self._connectThread.join(1) self.proc.send_signal(signal.SIGTERM) time.sleep(1) return result[0] # EFFECTS: Establish a cellular connection. Returns true if successful, # false otherwise.
