def do_acquire(self, waitflag=False):
locked = False
if waitflag:
blockflag = 0
else:
blockflag = fcntl.LOCK_NB
self.fd = posix.open(self.fn, O_CREAT | O_RDWR, 0600)
try:
fcntl.flock(self.fd, fcntl.LOCK_EX | blockflag)
# locked it
try:
posix.ftruncate(self.fd, 0)
posix.write(self.fd, ` os.getpid() ` + '\n')
locked = True
except:
self.do_release()
raise
except IOError, x:
if x.errno == errno.EWOULDBLOCK:
# failed to lock
posix.close(self.fd)
del self.fd
else:
raise
def __import__(filename, module_name):
import sys, _imp, posix
module = sys.modules[module_name]
if filename.startswith("%s"):
full_filename = filename % __graalpython__.core_home
filename = filename[len("%s"):]
elif filename.startswith(__graalpython__.stdlib_home):
full_filename = filename
filename = filename[len(__graalpython__.stdlib_home):]
else:
raise RuntimeError(
"There was an import during bootstrap outside the core or stdlib home."
)
# If we can, avoid opening the file and use our cached code
if not __graalpython__.has_cached_code(filename):
fd = posix.open(full_filename, posix.O_RDONLY)
content = posix.read(fd, sys.maxsize)
posix.close(fd)
code = compile(content, filename, "exec")
else:
# n.b.: for these builtin modules, there's never a full path and none of
# them can be packages
code = __graalpython__.get_cached_code(filename)
exec(code, module.__dict__)
return module
def readSensor(self):
fd = posix.open("/dev/i2c-%d" % self._i2cbus, posix.O_RDWR)
ioctl(fd, self.I2C_SLAVE, self.I2C_ADDR)
# wake AM2320 up, goes to sleep to not warm up and affect the humidity sensor
# This write will fail as AM2320 won't ACK this write
try:
posix.write(fd, b'\0x00')
except:
pass
time.sleep(0.001) #Wait at least 0.8ms, at most 3ms
# write at addr 0x03, start reg = 0x00, num regs = 0x04 */
try:
posix.write(fd, b'\x03\x00\x04')
except:
posix.close(fd)
return (0, 0, 1, "Device did not acknowledge request")
time.sleep(0.0016) #Wait at least 1.5ms for result
# Read out 8 bytes of result data
# Byte 0: Should be Modbus function code 0x03
# Byte 1: Should be number of registers to read (0x04)
# Byte 2: Humidity msb
# Byte 3: Humidity lsb
# Byte 4: Temperature msb
# Byte 5: Temperature lsb
# Byte 6: CRC lsb byte
# Byte 7: CRC msb byte
data = bytearray(posix.read(fd, 8))
posix.close(fd)
# Check data[0] and data[1]
if data[0] != 0x03 or data[1] != 0x04:
return (0, 0, 4, "First two read bytes are a mismatch")
# raise Exception("First two read bytes are a mismatch")
# CRC check
if self._calc_crc16(data[0:6]) != self._combine_bytes(
data[7], data[6]):
return (0, 0, 4, "CRC failed")
# raise Exception("CRC failed")
# Temperature resolution is 16Bit,
# temperature highest bit (Bit15) is equal to 1 indicates a
# negative temperature, the temperature highest bit (Bit15)
# is equal to 0 indicates a positive temperature;
# temperature in addition to the most significant bit (Bit14 ~ Bit0)
# indicates the temperature sensor string value.
# Temperature sensor value is a string of 10 times the
# actual temperature value.
temp = self._combine_bytes(data[4], data[5])
if temp & 0x8000:
temp = -(temp & 0x7FFF)
temp /= 10.0
humi = self._combine_bytes(data[2], data[3]) / 10.0
return (temp, humi, 0, '')
def test_ignore_ioerror_in_readall_if_nonempty_result(self):
# this is the behavior of regular files in CPython 2.7, as
# well as of _io.FileIO at least in CPython 3.3. This is
# *not* the behavior of _io.FileIO in CPython 3.4 or 3.5;
# see CPython's issue #21090.
import sys
try:
from posix import openpty, fdopen, write, close
except ImportError:
skip('no openpty on this platform')
if 'gnukfreebsd' in sys.platform:
skip('close() hangs forever on kFreeBSD')
read_fd, write_fd = openpty()
write(write_fd, 'Abc\n')
close(write_fd)
f = fdopen(read_fd)
# behavior on Linux: f.read() returns 'Abc\r\n', then the next time
# it raises IOError. Behavior on OS/X (Python 2.7.5): the close()
# above threw away the buffer, and f.read() always returns ''.
if sys.platform.startswith('linux'):
s = f.read()
assert s == 'Abc\r\n'
raises(IOError, f.read)
else:
s = f.read()
assert s == ''
s = f.read()
assert s == ''
f.close()
def test_ignore_ioerror_in_readall_if_nonempty_result(self):
# this is the behavior of regular files in CPython 2.7, as
# well as of _io.FileIO at least in CPython 3.3. This is
# *not* the behavior of _io.FileIO in CPython 3.4 or 3.5;
# see CPython's issue #21090.
import sys
try:
from posix import openpty, fdopen, write, close
except ImportError:
skip('no openpty on this platform')
read_fd, write_fd = openpty()
write(write_fd, 'Abc\n')
close(write_fd)
f = fdopen(read_fd)
# behavior on Linux: f.read() returns 'Abc\r\n', then the next time
# it raises IOError. Behavior on OS/X (Python 2.7.5): the close()
# above threw away the buffer, and f.read() always returns ''.
if sys.platform.startswith('linux'):
s = f.read()
assert s == 'Abc\r\n'
raises(IOError, f.read)
else:
s = f.read()
assert s == ''
s = f.read()
assert s == ''
f.close()
def check_module_inspection():
this_module = __nemesys__.get_module(__name__)
phase = __nemesys__.module_phase(__name__)
compiled_size = __nemesys__.module_compiled_size(__name__)
global_count = __nemesys__.module_global_count(__name__)
source = __nemesys__.module_source(__name__)
# these functions should also work if passed the module object
assert phase == __nemesys__.module_phase(this_module)
assert compiled_size == __nemesys__.module_compiled_size(this_module)
assert global_count == __nemesys__.module_global_count(this_module)
assert source == __nemesys__.module_source(this_module)
assert phase == "Analyzed" # doesn't become Imported until the root scope returns
assert compiled_size > 0
assert global_count == 8
# note: the globals are __doc__, __name__, __nemesys__, posix, and the four functions
assert b'this string appears verbatim in the module source' in source
assert b'this string does not appear verbatim because it has an escaped\x20character' not in source
# read the contents of this file and make sure it matches module_source
fd = posix.open(__file__, posix.O_RDONLY)
data = posix.read(fd, 2 * len(source))
posix.close(fd)
assert data == source, '%s != %s' % (repr(data), repr(source))
def do_release(self):
if self.fd is not None:
posix.ftruncate(self.fd, 0)
fcntl.flock(self.fd, fcntl.LOCK_UN)
posix.close(self.fd)
self.fd = None
self._locked = False
def Pop(self):
frame = self.stack.pop()
#log('< Pop %s', frame)
for saved, orig in reversed(frame.saved):
try:
posix.dup2(saved, orig)
except OSError as e:
log('dup2(%d, %d) error: %s', saved, orig, e)
#log('fd state:')
#posix.system('ls -l /proc/%s/fd' % posix.getpid())
raise
posix.close(saved)
#log('dup2 %s %s', saved, orig)
for fd in frame.need_close:
#log('Close %d', fd)
try:
posix.close(fd)
except OSError as e:
log('Error closing descriptor %d: %s', fd, e)
raise
# Wait for here doc processes to finish.
for proc, waiter in frame.need_wait:
unused_status = proc.WaitUntilDone(waiter)
def do_release(self):
if self.fd is not None:
posix.ftruncate(self.fd, 0)
fcntl.flock(self.fd, fcntl.LOCK_UN)
posix.close(self.fd)
self.fd = None
self._locked = False
def Pop(self):
frame = self.stack.pop()
#log('< Pop %s', frame)
for saved, orig in reversed(frame.saved):
try:
posix.dup2(saved, orig)
except OSError as e:
log('dup2(%d, %d) error: %s', saved, orig, e)
#log('fd state:')
#posix.system('ls -l /proc/%s/fd' % posix.getpid())
raise
posix.close(saved)
#log('dup2 %s %s', saved, orig)
# NOTE: This balances the increments from _PushDup(). But it doesn't
# balance the ones from Open().
self.next_fd -= 1 # Count down
assert self.next_fd >= 10, self.next_fd
for fd in frame.need_close:
#log('Close %d', fd)
try:
posix.close(fd)
except OSError as e:
log('Error closing descriptor %d: %s', fd, e)
raise
# Wait for here doc processes to finish.
for proc, waiter in frame.need_wait:
unused_status = proc.WaitUntilDone(waiter)
def Open(self, path, mode='r'):
"""Opens a path for read, but moves it out of the reserved 3-9 fd range.
Returns:
A Python file object. The caller is responsible for Close().
Raises:
OSError if the path can't be found.
"""
if mode == 'r':
fd_mode = posix.O_RDONLY
elif mode == 'w':
fd_mode = posix.O_CREAT | posix.O_RDWR
else:
raise AssertionError(mode)
fd = posix.open(path, fd_mode, 0666) # may raise OSError
new_fd = self._GetFreeDescriptor()
posix.dup2(fd, new_fd)
posix.close(fd)
try:
f = posix.fdopen(new_fd, mode) # Might raise IOError
except IOError as e:
raise OSError(*e.args) # Consistently raise OSError
return f
def Run(self, waiter, fd_state):
"""Run this pipeline synchronously."""
self.Start(waiter)
# Run our portion IN PARALLEL with other processes. This may or may not
# fork:
# ls | wc -l
# echo foo | read line # no need to fork
ex, node = self.last_thunk
#log('thunk %s', self.last_thunk)
if self.last_pipe is not None:
r, w = self.last_pipe # set in AddLast()
posix.close(w) # we will not write here
fd_state.PushStdinFromPipe(r)
try:
ex.ExecuteAndCatch(node)
finally:
fd_state.Pop()
else:
ex.ExecuteAndCatch(node)
self.pipe_status[-1] = ex.LastStatus()
#log('pipestatus before all have finished = %s', self.pipe_status)
return self.WaitUntilDone(waiter) # returns pipe_status
def read_sensor(self):
fd = posix.open('/dev/i2c-%d' % self._i2cbus, posix.O_RDWR)
ioctl(fd, I2C_SLAVE, self.I2C_ADDR)
try:
posix.write(fd, b'\0x00') # wake up AM2320
except:
pass
time.sleep(0.01)
posix.write(
fd, b'\x03\x00\x04'
) # x03(function code) x00(starting address) x04(register length)
time.sleep(0.002)
data = bytearray(posix.read(fd, 8))
posix.close(fd)
if data[0] != 0x03 or data[
1] != 0x04: # Modbus function code (0x03), number of registers to read (0x04)
raise Exception('I2C read failure')
if self._calc_crc16(data[0:6]) != self._combine_bytes(
data[7], data[6]):
raise Exception('CRC failure')
humi = self._combine_bytes(data[2], data[3]) / 10.0
temp = self._combine_bytes(data[4], data[5])
if temp & 0x8000:
temp = -(temp & 0x7FFF)
temp /= 10.0
return (temp, humi)
def do_acquire(self, waitflag=False):
locked = False
if waitflag:
blockflag = 0
else:
blockflag = fcntl.LOCK_NB
self.fd = posix.open(self.fn, O_CREAT | O_RDWR, 0600)
try:
fcntl.flock(self.fd, fcntl.LOCK_EX|blockflag)
# locked it
try:
posix.ftruncate(self.fd, 0)
posix.write(self.fd, `os.getpid()` + '\n')
locked = True
except:
self.do_release()
raise
except IOError, x:
if x.errno == errno.EWOULDBLOCK:
# failed to lock
posix.close(self.fd)
del self.fd
else:
raise
def start(self):
if self._monitoring:
if self._mode == MonitorService.MODE_FIFO:
# publish fifo
self._tmpdir = tempfile.mkdtemp()
self._filename = os.path.join(self._tmpdir, 'siis.stream')
try:
os.mkfifo(self._filename, 0o600)
except OSError as e:
logger.error("Failed to create monitor write FIFO: %s" % repr(e))
os.rmdir(self._tmpdir)
self._filename = None
else:
self._fifo = posix.open(self._filename, posix.O_NONBLOCK | posix.O_RDWR) # posix.O_WRONLY
# read command fifo
self._filename_read = os.path.join(self._tmpdir, 'siis.rpc')
try:
os.mkfifo(self._filename_read, 0o600)
except OSError as e:
logger.error("Failed to create monitor read FIFO: %s" % repr(e))
os.rmdir(self._tmpdir)
# close the write fifo
os.remove(self._filename)
posix.close(self._fifo)
self._fifo = -1
self._filename = None
self._filename_read = None
else:
self._fifo_read = posix.open(self._filename_read, posix.O_NONBLOCK)
if self._fifo and self._fifo_read:
self._running = True
self._thread = threading.Thread(name="monitor", target=self.run_fifo)
self._thread.start()
elif self._mode == MonitorService.MODE_HTTP_WEBSOCKET:
# logger.startLogging(sys.stdout)
self._factory = WebSocketServerFactory(u"ws://%s:%i" % (self._host, self._port))
self._factory.protocol = ServerProtocol
# self._factory.setProtocolOptions(maxConnections=2)
# self._loop = asyncio.get_event_loop()
# coro = self._loop.create_server(self._factory, self._host, self._port)
# self._server = self._loop.run_until_complete(coro)
# reactor.listenTCP(self._port, self._factory)
# if not reactor.running:
# reactor.run()
self._running = True
self._thread = threading.Thread(name="monitor", target=self.run_autobahn)
self._thread.start()
def terminate(self):
# remove any streamables
self._running = False
if self._mode == MonitorService.MODE_FIFO:
if self._thread:
try:
self._thread.join()
except:
pass
self._thread = None
if self._fifo_read:
try:
posix.close(self._fifo_read)
self._fifo_read = -1
except (BrokenPipeError, IOError):
pass
if self._filename_read:
os.remove(self._filename_read)
self._filename_read = None
if self._fifo:
try:
posix.close(self._fifo)
self._fifo = -1
except (BrokenPipeError, IOError):
pass
if self._filename:
os.remove(self._filename)
self._filename = None
if self._tmpdir:
os.rmdir(self._tmpdir)
self._tmpdir = None
elif self._mode == MonitorService.MODE_HTTP_WEBSOCKET:
if self._loop:
self._loop.stop()
if self._thread:
try:
self._thread.join()
except:
pass
self._thread = None
if self._server:
self._server.close()
self._loop.close()
self._server = None
self._loop = None
def __import__(filename, module_name):
import sys, posix
module = sys.modules[module_name]
if filename.startswith("%s"):
filename = filename % sys.graal_python_core_home
fd = posix.open(filename, posix.O_RDONLY)
content = posix.read(fd, sys.maxsize)
posix.close(fd)
code = compile(content, filename, "exec")
eval(code, module.__dict__)
return module
def Run(self):
"""
do_exit: For small pipelines
"""
#log('Writing %r', self.body_str)
posix.write(self.w, self.body_str)
#log('Wrote %r', self.body_str)
posix.close(self.w)
#log('Closed %d', self.w)
sys.exit(0) # Could this fail?
def execute_command():
pipe_fd = posix.pipe()
pid = posix.fork()
if pid == 0:
cmdline = ["lsblk"]
if check_fs_val.get() or check_UUID_val.get():
cmdline.append("-o")
col = "+"
if check_fs_val.get():
col += "fstype"
if check_fs_val.get() and check_UUID_val.get():
col += ","
if check_UUID_val.get():
col += "UUID"
cmdline.append(col)
posix.dup2(pipe_fd[1], 1)
posix.close(pipe_fd[0])
posix.close(pipe_fd[1])
posix.execv("/bin/lsblk", cmdline)
quit()
else:
posix.close(pipe_fd[1])
ret = bytearray()
readbytes = posix.read(pipe_fd[0], 1000)
while readbytes != b"":
ret += readbytes
readbytes = posix.read(pipe_fd[0], 1000)
posix.close(pipe_fd[0])
posix.wait()
return str(ret, sys.stdout.encoding)
def test_pass_fds_make_inheritable(self):
import subprocess, posix
fd1, fd2 = posix.pipe()
assert posix.get_inheritable(fd1) is False
assert posix.get_inheritable(fd2) is False
subprocess.check_call(['/usr/bin/env', 'python', '-c',
'import os;os.write(%d,b"K")' % fd2],
close_fds=True, pass_fds=[fd2])
res = posix.read(fd1, 1)
assert res == b"K"
posix.close(fd1)
posix.close(fd2)
def test_rename_at_close_correct_read(self):
firstFileFd = posix.open("mount/file1", posix.O_RDONLY)
secondFileFd = posix.open("mount/file2", posix.O_RDONLY)
for i in range(1000):
position = random.randint(0, 10000)
size = random.randint(1, 10000)
posix.lseek(firstFileFd,position, 0)
posix.lseek(secondFileFd, position, 0)
posix.read(firstFileFd, size)
posix.read(secondFileFd, size)
posix.close(firstFileFd)
posix.close(secondFileFd)
posix.rename("mount/file2", "mount/file3")
posix.rename("mount/file1","mount/file2")
self.assertTrue(open("mount/file2").read()== open("src/file2").read())
def one_loop(self):
ret = True
for (fd, ev) in self.poller.poll(1000):
if ev & (select.POLLERR | select.POLLHUP):
self.flush_outputs()
self.poller.unregister(fd)
ret = False
if ev & select.POLLIN:
data = posix.read(fd, 4096)
if not data:
posix.close(self.fd_map[fd])
ret = False
self.queue_write(self.fd_map[fd], data)
if ev & select.POLLOUT:
self.do_write(fd)
return ret
def one_loop(self):
ret = True
for (fd, ev) in self.poller.poll(1000):
if ev & (select.POLLERR | select.POLLHUP):
self.flush_outputs()
self.poller.unregister(fd)
ret = False
if ev & select.POLLIN:
data = posix.read(fd, 4096)
if not data:
posix.close(self.fd_map[fd])
ret = False
self.queue_write(self.fd_map[fd], data)
if ev & select.POLLOUT:
self.do_write(fd)
return ret
def test_ignore_ioerror_in_readall_if_nonempty_result(self):
# this is the behavior of regular files in CPython 2.7, as
# well as of _io.FileIO at least in CPython 3.3. This is
# *not* the behavior of _io.FileIO in CPython 3.4 or 3.5;
# see CPython's issue #21090.
try:
from posix import openpty, fdopen, write, close
except ImportError:
skip('no openpty on this platform')
read_fd, write_fd = openpty()
write(write_fd, 'Abc\n')
close(write_fd)
f = fdopen(read_fd)
s = f.read()
assert s == 'Abc\r\n'
raises(IOError, f.read)
f.close()
def make_tempfile(fn, pid):
tfn = os.path.join(os.path.dirname(fn), 'shlock%d.tmp' % pid)
errcount = 1000
while 1:
try:
fd = posix.open(tfn, O_EXCL | O_CREAT | O_RDWR, 0600)
posix.write(fd, '%d\n' % pid)
posix.close(fd)
return tfn
except OSError, x:
if (errcount > 0) and (x.errno == errno.EEXIST):
os.unlink(tfn)
errcount = errcount - 1
else:
raise
def test_ignore_ioerror_in_readall_if_nonempty_result(self):
# this is the behavior of regular files in CPython 2.7, as
# well as of _io.FileIO at least in CPython 3.3. This is
# *not* the behavior of _io.FileIO in CPython 3.4 or 3.5;
# see CPython's issue #21090.
try:
from posix import openpty, fdopen, write, close
except ImportError:
skip('no openpty on this platform')
read_fd, write_fd = openpty()
write(write_fd, 'Abc\n')
close(write_fd)
f = fdopen(read_fd)
s = f.read()
assert s == 'Abc\r\n'
raises(IOError, f.read)
f.close()
def make_tempfile(fn, pid):
tfn = os.path.join(os.path.dirname(fn), 'shlock%d.tmp' % pid)
errcount = 1000
while 1:
try:
fd = posix.open(tfn, O_EXCL | O_CREAT | O_RDWR, 0600)
posix.write(fd, '%d\n' % pid)
posix.close(fd)
return tfn
except OSError, x:
if (errcount > 0) and (x.errno == errno.EEXIST):
os.unlink(tfn)
errcount = errcount - 1
else:
raise
def jog_i2c_write(addr, register, value, debug):
import fcntl
import posix
n_i2c = 0
f_i2c = posix.open("/dev/i2c-%i" % n_i2c, posix.O_RDWR)
flags = I2C_M_WR
buf = ctypes.create_string_buffer(2)
buf[0] = chr(register)
buf[1] = chr(value)
msgs = I2cMsg(addr=addr, flags=flags, len=ctypes.sizeof(buf), buf=buf)
msg_array, msg_count = i2c_ioctl_msg(msgs)
io_i2c = I2cRdwrIoctlData(msgs=msg_array, nmsgs=msg_count)
i2c_stat = fcntl.ioctl(f_i2c, I2C_RDWR, io_i2c)
posix.close(f_i2c)
async def _read(self):
while True:
if self.fd != -1:
try:
res = posix.read(self.fd, 1)
size = len(res)
except:
self._timer -= 1
if self._timer < 0:
error = sys.exc_info()[1]
async with self._fdcond:
posix.close(self.fd)
self.fd = -1
self._timer = self.timeout_ms
logger.debug(f"BLE: Disconnected {error}")
self._fdcond.notify_all()
else:
self._timer = self.timeout_ms
await asyncio.sleep(1 / 1000)
def RunCommandSub(self, node):
p = self._MakeProcess(node,
disable_errexit=not self.exec_opts.strict_errexit)
r, w = posix.pipe()
p.AddStateChange(process.StdoutToPipe(r, w))
pid = p.Start()
#log('Command sub started %d', pid)
self.waiter.Register(pid, p.WhenDone)
chunks = []
posix.close(w) # not going to write
while True:
byte_str = posix.read(r, 4096)
if not byte_str:
break
chunks.append(byte_str)
posix.close(r)
status = p.WaitUntilDone(self.waiter)
# OSH has the concept of aborting in the middle of a WORD. We're not
# waiting until the command is over!
if self.exec_opts.strict_errexit:
if self.exec_opts.ErrExit() and status != 0:
raise util.ErrExitFailure(
'Command sub exited with status %d (%r)', status,
node.__class__.__name__)
else:
# Set a flag so we check errexit at the same time as bash. Example:
#
# a=$(false)
# echo foo # no matter what comes here, the flag is reset
#
# Set ONLY until this command node has finished executing.
self.check_command_sub_status = True
self.mem.last_status = status
# Runtime errors test case: # $("echo foo > $@")
# Why rstrip()?
# https://unix.stackexchange.com/questions/17747/why-does-shell-command-substitution-gobble-up-a-trailing-newline-char
return ''.join(chunks).rstrip('\n')
def _PushDup(self, fd1, fd2):
"""Save fd2, and dup fd1 onto fd2.
Mutates self.cur_frame.saved.
Returns:
success Bool
"""
new_fd = self._NextFreeFileDescriptor()
#log('---- _PushDup %s %s', fd1, fd2)
need_restore = True
try:
#log('DUPFD %s %s', fd2, self.next_fd)
fcntl.fcntl(fd2, fcntl.F_DUPFD, new_fd)
except IOError as e:
# Example program that causes this error: exec 4>&1. Descriptor 4 isn't
# open.
# This seems to be ignored in dash too in savefd()?
if e.errno == errno.EBADF:
#log('ERROR %s', e)
need_restore = False
else:
raise
else:
posix.close(fd2)
fcntl.fcntl(new_fd, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
#log('==== dup %s %s\n' % (fd1, fd2))
try:
posix.dup2(fd1, fd2)
except OSError as e:
# bash/dash give this error too, e.g. for 'echo hi 1>&3'
util.error('%d: %s', fd1, posix.strerror(e.errno))
# Restore and return error
posix.dup2(new_fd, fd2)
posix.close(new_fd)
# Undo it
return False
if need_restore:
self.cur_frame.saved.append((new_fd, fd2))
return True
def Open(self, path, mode='r'):
"""Opens a path for read, but moves it out of the reserved 3-9 fd range.
Returns:
A Python file object. The caller is responsible for Close().
Raises:
OSError if the path can't be found.
"""
if mode == 'r':
fd_mode = posix.O_RDONLY
elif mode == 'w':
fd_mode = posix.O_CREAT | posix.O_RDWR
else:
raise AssertionError(mode)
fd = posix.open(path, fd_mode, 0666)
new_fd = self._NextFreeFileDescriptor()
posix.dup2(fd, new_fd)
posix.close(fd)
return posix.fdopen(new_fd, mode)
def test_rename_folder_correct_read(self):
os.mkdir("src/folder1")
os.mkdir("src/folder2")
os.system("cp src/file1 src/folder1/file")
os.system("cp src/file2 src/folder2/file")
firstFileFd = posix.open("mount/folder1/file", posix.O_RDONLY)
secondFileFd = posix.open("mount/folder2/file", posix.O_RDONLY)
for i in range(1000):
position = random.randint(0, 10000)
size = random.randint(1, 10000)
posix.lseek(firstFileFd,position, 0)
posix.lseek(secondFileFd, position, 0)
posix.read(firstFileFd, size)
posix.read(secondFileFd, size)
posix.rename("mount/folder2", "mount/folder3")
posix.rename("mount/folder1","mount/folder2")
posix.close(firstFileFd)
posix.close(secondFileFd)
self.assertTrue(open("mount/folder2/file").read()== open("src/folder2/file").read())
def main():
Raise = False
try:
fd=posix.open("/dev/serial0", posix.O_RDWR |\
posix.O_NOCTTY | posix.O_NDELAY)
except:
Raise = True
if Raise:
raise Exception("UART busy."
" Try /dev/serial1, /dev/ttyS0,"
" /dev/ttyAMA0.")
options = termios.tcgetattr(fd)
options[0] = termios.IGNPAR
options[1] = 0
options[2]=termios.B9600 |\
termios.CS8 |\
termios.CLOCAL |\
termios.CREAD
options[3] = 0
termios.tcflush(fd, termios.TCIFLUSH)
termios.tcsetattr(fd, termios.TCSANOW, options)
while True:
try:
message = input("Producer :")
except EOFError:
print("")
break
binmess = bytearray(len(message))
for i in range(len(message)):
binmess[i] = ord(message[i])
posix.write(fd, binmess)
posix.close(fd)
def test_randomAccessToFile(self):
position = 0
size = 0
srcFileFd = posix.open("src/file1", posix.O_RDONLY)
mountFileFd = posix.open("mount/file1", posix.O_RDONLY)
for i in range(10000):
position = random.randint(0, 10000)
size = random.randint(1, 10000)
posix.lseek(srcFileFd,position, 0)
posix.lseek(mountFileFd, position, 0)
if (posix.read(srcFileFd,size) != posix.read(mountFileFd, size)):
posix.close(srcFileFd)
posix.close(mountFileFd)
self.assertTrue(False)
posix.close(srcFileFd)
posix.close(mountFileFd)
def autostart(reason, **kwargs):
sys.stderr.write("RunScript %d\n" % reason)
if reason == 0:
session = kwargs.get('session')
sys.stderr.write("RunScript %s\n" % session)
if session is None:
return
try:
os.mkfifo('/tmp/run_script.fifo', 0o666)
except OSError:
pass
try:
os.mkfifo('/tmp/run_script_output.fifo', 0o666)
except OSError:
pass
thread = Thread(target=run_server, args=(kwargs.get('session'),))
thread.start()
elif reason == 1:
try:
fp = posix.open('/tmp/run_script.fifo', posix.O_WRONLY | posix.O_NONBLOCK)
os.write(fp, 'quit\n')
posix.close(fp)
except OSError:
pass
def daemonize(logfile):
try:
from os import fork
from posix import close
except:
print 'Daemon mode is not supported on this platform (missing fork() syscall or posix module)'
sys_exit(-1)
import sys
if (fork()): sys_exit(0) # parent return to shell
### Child
close(sys.stdin.fileno())
sys.stdin = open('/dev/null')
close(sys.stdout.fileno())
sys.stdout = Log(open(logfile, 'a+'))
close(sys.stderr.fileno())
sys.stderr = Log(open(logfile, 'a+'))
chdir('/')
def daemonize(logfile):
try:
from os import fork
from posix import close
except:
print 'Daemon mode is not supported on this platform (missing fork() syscall or posix module)'
sys_exit(-1)
import sys
if (fork()): sys_exit(0) # parent return to shell
### Child
close(sys.stdin.fileno())
sys.stdin = open('/dev/null')
close(sys.stdout.fileno())
sys.stdout = Log(open(logfile, 'a+'))
close(sys.stderr.fileno())
sys.stderr = Log(open(logfile, 'a+'))
chdir('/')
def close(self):
"""
Closes the I2C bus device.
"""
posix.close(self.fd)
def close(self):
posix.close(self.fd)
def close_fd(self):
posix.close(self.fd)
del self.fd
def Close(self):
""" Close the filehandle to this bus """
posix.close(self.File)
def deinit():
"""Closes the SPI device file descriptor."""
global spidev_fd
if spidev_fd:
posix.close(spidev_fd)
spidev_fd = None
def test_dont_close_fd_if_dir_check_fails_in_fdopen(self):
import posix
fd = posix.open('/', posix.O_RDONLY)
raises(IOError, posix.fdopen, fd)
posix.close(fd)
def close(self):
"""Closes the SPI device file descriptor."""
posix.close(self.fd)
self.fd = None
import fcntl
def deinit():
"""Closes the spidev file descriptor"""
global spidev_fd
posix.close(spidev_fd)
def close(self): dummy = posix.close(self.fd)
def __del__(self):
try:
posix.close(self.fd)
except AttributeError:
pass #Do nothing in this case.
def close(self):
"""
Closes the file descriptor.
"""
posix.close(self.fd)
def close_fd(self):
posix.close(self.fd)
self.fd = None
