Struct bcfs::BCFS

pub struct BCFS { /* fields omitted */ }

Methods

impl BCFS

pub fn new<S: AsRef<str>>(home_addr: Address, blockchain_name: S) -> Self

Creates a new fs for the account at home_addr.

pub fn prestat(
    &mut self,
    _ptx: &mut dyn PendingTransaction,
    fd: Fd
) -> Result<&Path, ErrNo>

Returns pre-opened dir fds. @see crate::file::special_file_ctor

pub fn open(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    curdir: Fd,
    path: &Path,
    open_flags: OpenFlags,
    fd_flags: FdFlags
) -> Result<Fd, ErrNo>

Returns a capability to the resource at the given (relative!) path.

curdir is the root capability to which the path is relative.

The blockchain environment is exposed through files in /opt/<chain_name>/:

• <address>/balance - contains the read-only public balance of the account at <address>
• <address>/bytecode - contains the read-only Wasm bytecode of the account at <address>
• log - an append-only file to which events can be written. @see BCFS::parse_log.

The user's home directory is /opt/<chain_name>/<address>.

pub fn tempfile(
    &mut self,
    _ptx: &mut dyn PendingTransaction
) -> Result<Fd, ErrNo>

pub fn flush(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd
) -> Result<(), ErrNo>

pub fn close(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd
) -> Result<(), ErrNo>

pub fn unlink(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    curdir: Fd,
    path: &Path
) -> Result<u64, ErrNo>

Removes the file at path and returns the number of bytes previously in the file.

pub fn seek(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd,
    offset: FileDelta,
    whence: Whence
) -> Result<FileSize, ErrNo>

pub fn fdstat(
    &self,
    _ptx: &mut dyn PendingTransaction,
    fd: Fd
) -> Result<FdStat, ErrNo>

pub fn filestat(
    &self,
    ptx: &dyn PendingTransaction,
    fd: Fd
) -> Result<FileStat, ErrNo>

pub fn tell(
    &self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd
) -> Result<FileSize, ErrNo>

pub fn read_vectored(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd,
    bufs: &mut [IoSliceMut]
) -> Result<usize, ErrNo>

pub fn pread_vectored(
    &self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd,
    bufs: &mut [IoSliceMut],
    offset: FileSize
) -> Result<usize, ErrNo>

pub fn write_vectored(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd,
    bufs: &[IoSlice]
) -> Result<usize, ErrNo>

pub fn pwrite_vectored(
    &mut self,
    ptx: &mut dyn PendingTransaction,
    fd: Fd,
    bufs: &[IoSlice],
    offset: FileSize
) -> Result<usize, ErrNo>

pub fn renumber(
    &mut self,
    _ptx: &mut dyn PendingTransaction,
    fd: Fd,
    new_fd: Fd
) -> Result<(), ErrNo>