Index

Modules: flysystem, flysystem/core, flysystem/filesystem, flysystem/local, flysystem/policy, flysystem/securejoin.

API symbols

abstract:

• core: macro abstract(x: untyped): untyped

addDisk:

• filesystem: proc addDisk(fs: Filesystem; name: string; driver: StorageDriver)
• filesystem: proc addDisk(fs: Filesystem; name: string; driver: StorageDriver; policy: PolicyRules)

append:

• core: method append(d: StorageDriver; path, content: string)
• local: method append(d: LocalDriver; path, content: string)
• policy: method append(p: FilesystemPolicy; path, content: string)

appendStream:

• core: method appendStream(d: StorageDriver; path: string; src: File)
• local: method appendStream(d: LocalDriver; path: string; src: File)
• policy: method appendStream(p: FilesystemPolicy; path: string; src: File)

atomicWriteSecure:

• securejoin: proc atomicWriteSecure(root: SecureRoot; relpath, content: string; mode: Mode)

checkLexicalContained:

• securejoin: proc checkLexicalContained(root: SecureRoot; relpath: string)

checksum:

• core: method checksum(d: StorageDriver; path: string): string
• local: method checksum(d: LocalDriver; path: string): string
• policy: method checksum(p: FilesystemPolicy; path: string): string

chmod:

• local: method chmod(d: LocalDriver; path: string; mode: int)

chown:

• local: method chown(d: LocalDriver; path: string; uid, gid: int)

closeDriver:

• local: proc closeDriver(d: LocalDriver)

closeSecureRoot:

• securejoin: proc closeSecureRoot(r: var SecureRoot)

commitTemp:

• securejoin: proc commitTemp(dirFd: cint; tmp, base: string)

copy:

• core: method copy(d: StorageDriver; src, dest: string)
• local: method copy(d: LocalDriver; src, dest: string)
• policy: method copy(p: FilesystemPolicy; src, dest: string)

copyDir:

• core: method copyDir(d: StorageDriver; src, dest: string)
• local: method copyDir(d: LocalDriver; src, dest: string)
• policy: method copyDir(p: FilesystemPolicy; src, dest: string)

copyDirSecure:

• securejoin: proc copyDirSecure(root: SecureRoot; srcRel, dstRel: string)

copyFileSecure:

• securejoin: proc copyFileSecure(root: SecureRoot; srcRel, dstRel: string)

copyFromHost:

• local: method copyFromHost(d: LocalDriver; srcAbs, destRel: string)

createFileIn:

• securejoin: proc createFileIn(dirFd: cint; base: string; mode = Mode(0o000000000666)): cint

createSymlink:

• local: method createSymlink(d: LocalDriver; path, target: string)

defaultPolicyRules:

• policy: proc defaultPolicyRules(): PolicyRules

delete:

• core: method delete(d: StorageDriver; path: string)
• filesystem: proc delete(fs: Filesystem; path: string)
• local: method delete(d: LocalDriver; path: string)
• policy: method delete(p: FilesystemPolicy; path: string)

deleteDir:

• core: method deleteDir(d: StorageDriver; path: string; force = false)
• local: method deleteDir(d: LocalDriver; path: string; force = false)
• policy: method deleteDir(p: FilesystemPolicy; path: string; force = false)

DirEntry:

• securejoin: tuple DirEntry

disk:

• filesystem: proc disk(fs: Filesystem; name = ""): StorageDriver

diskPolicy:

• filesystem: proc diskPolicy(fs: Filesystem; name = ""): PolicyRules

diskUsage:

• local: method diskUsage(d: LocalDriver): tuple[total, free, used: int64]

ensureDirsSecure:

• securejoin: proc ensureDirsSecure(root: SecureRoot; relpath: string)

ensureParentSecure:

• securejoin: proc ensureParentSecure(root: SecureRoot; relpath: string)

exists:

• core: method exists(d: StorageDriver; path: string): bool
• filesystem: proc exists(fs: Filesystem; path: string): bool
• local: method exists(d: LocalDriver; path: string): bool
• policy: method exists(p: FilesystemPolicy; path: string): bool

FileMetadata:

• core: object FileMetadata

Filesystem:

• filesystem: type Filesystem

FilesystemPolicy:

• policy: type FilesystemPolicy

FilesystemPolicyError:

• policy: object FilesystemPolicyError

FlysystemStream:

• core: type FlysystemStream

fstatFd:

• securejoin: proc fstatFd(fd: cint): Stat

fullMtime:

• securejoin: proc fullMtime(st: Stat): times.Time

importFrom:

• local: method importFrom(d: LocalDriver; srcDriver: StorageDriver; srcRel, destRel: string)

inner:

• policy: proc inner(p: FilesystemPolicy): StorageDriver

isSymlink:

• local: method isSymlink(d: LocalDriver; path: string): bool

lastModified:

• core: method lastModified(d: StorageDriver; path: string): Time
• local: method lastModified(d: LocalDriver; path: string): times.Time
• policy: method lastModified(p: FilesystemPolicy; path: string): Time

list:

• core: method list(d: StorageDriver; path: string; recursive = false): seq[FileMetadata]
• local: method list(d: LocalDriver; path: string; recursive = false): seq[FileMetadata]
• policy: method list(p: FilesystemPolicy; path: string; recursive = false): seq[FileMetadata]

listDirFd:

• securejoin: proc listDirFd(dirFd: cint): seq[DirEntry]

listSecure:

• securejoin: proc listSecure(root: SecureRoot; relpath: string; recursive: bool): seq[ tuple[rel: string, st: Stat]]

LocalDriver:

• core: type LocalDriver

lstatSecure:

• securejoin: proc lstatSecure(root: SecureRoot; relpath: string): tuple[present: bool, st: Stat]

makeDir:

• core: method makeDir(d: StorageDriver; path: string)
• local: method makeDir(d: LocalDriver; path: string)
• policy: method makeDir(p: FilesystemPolicy; path: string)

metadata:

• core: method metadata(d: StorageDriver; path: string): FileMetadata
• local: method metadata(d: LocalDriver; path: string): FileMetadata
• policy: method metadata(p: FilesystemPolicy; path: string): FileMetadata

mimeType:

• core: method mimeType(d: StorageDriver; path: string): string
• local: method mimeType(d: LocalDriver; path: string): string
• policy: method mimeType(p: FilesystemPolicy; path: string): string

mmapFd:

• securejoin: proc mmapFd(fd: cint; size: int): pointer

move:

• core: method move(d: StorageDriver; src, dest: string)
• local: method move(d: LocalDriver; src, dest: string)
• policy: method move(p: FilesystemPolicy; src, dest: string)

moveDir:

• core: method moveDir(d: StorageDriver; src, dest: string)
• local: method moveDir(d: LocalDriver; src, dest: string)
• policy: method moveDir(p: FilesystemPolicy; src, dest: string)

newFilesystem:

• filesystem: proc newFilesystem(defaultDisk = "local"): Filesystem

newFilesystemPolicy:

• policy: proc newFilesystemPolicy(inner: StorageDriver; rules: PolicyRules = defaultPolicyRules()): FilesystemPolicy

newLocalDriver:

• local: proc newLocalDriver(root: string): LocalDriver

normalizeRel:

• securejoin: proc normalizeRel(root: SecureRoot; relpath: string): string

openSecure:

• securejoin: proc openSecure(root: SecureRoot; relpath: string; flags: cint; mode = Mode(0o000000000666)): cint

openSecureParent:

• securejoin: proc openSecureParent(root: SecureRoot; relpath: string): tuple[dirFd: cint, base: string]

openSecureRoot:

• securejoin: proc openSecureRoot(path: string): SecureRoot

openTempIn:

• securejoin: proc openTempIn(dirFd: cint; base: string): tuple[fd: cint, tmp: string]

parseCsv:

• filesystem: template parseCsv(fs: Filesystem; path: string)

parseJson:

• filesystem: template parseJson(fs: Filesystem; path: string): untyped
• filesystem: template parseJson[T](fs: Filesystem; path: string; t: typedesc[T]): untyped

parseToml:

• filesystem: template parseToml(fs: Filesystem; path: string): untyped

parseYaml:

• filesystem: template parseYaml(fs: Filesystem; path: string): untyped
• filesystem: template parseYaml[T](fs: Filesystem; path: string; t: typedesc[T]): untyped

PolicyRules:

• policy: object PolicyRules

rawDisk:

• filesystem: proc rawDisk(fs: Filesystem; name = ""): StorageDriver

read:

• core: method read(d: StorageDriver; path: string): string
• filesystem: proc read(fs: Filesystem; path: string): string
• local: method read(d: LocalDriver; path: string): string
• policy: method read(p: FilesystemPolicy; path: string): string

readAllFd:

• securejoin: proc readAllFd(fd: cint): string

readLines:

• local: iterator readLines(d: LocalDriver; path: string): string

readLink:

• local: method readLink(d: LocalDriver; path: string): string

readlinkIn:

• securejoin: proc readlinkIn(dirFd: cint; base: string): string

readStream:

• core: method readStream(d: StorageDriver; path: string): FlysystemStream
• local: method readStream(d: LocalDriver; path: string): FlysystemStream
• policy: method readStream(p: FilesystemPolicy; path: string): FlysystemStream

removeSecure:

• securejoin: proc removeSecure(root: SecureRoot; relpath: string)

removeTreeSecure:

• securejoin: proc removeTreeSecure(root: SecureRoot; relpath: string)

renameSecure:

• securejoin: proc renameSecure(root: SecureRoot; srcRel, dstRel: string)

rules:

• policy: proc rules(p: FilesystemPolicy): PolicyRules

SandboxError:

• securejoin: object SandboxError

sandboxPassthrough:

• securejoin: template sandboxPassthrough(op: string; path: string; body: untyped): untyped

search:

• core: method search(d: StorageDriver; pattern: string): seq[string]
• local: method search(d: LocalDriver; pattern: string): seq[string]
• policy: method search(p: FilesystemPolicy; pattern: string): seq[string]

searchSecure:

• securejoin: proc searchSecure(root: SecureRoot; pattern: string): seq[string]

SecureRoot:

• core: object SecureRoot

setVisibility:

• core: method setVisibility(d: StorageDriver; path: string; visibility: Visibility)
• local: method setVisibility(d: LocalDriver; path: string; visibility: Visibility)
• policy: method setVisibility(p: FilesystemPolicy; path: string; visibility: Visibility)

size:

• core: method size(d: StorageDriver; path: string): int64
• local: method size(d: LocalDriver; path: string): int64
• policy: method size(p: FilesystemPolicy; path: string): int64

sjAT_REMOVEDIR:

• securejoin: var sjAT_REMOVEDIR

sjAT_SYMLINK_NOFOLLOW:

• securejoin: var sjAT_SYMLINK_NOFOLLOW

sjO_DIRECTORY:

• securejoin: var sjO_DIRECTORY

sjO_NOFOLLOW:

• securejoin: var sjO_NOFOLLOW

sjS_IROTH:

• securejoin: var sjS_IROTH

statMeta:

• securejoin: proc statMeta(relpath: string; st: Stat): FileMetadata

StorageDriver:

• core: type StorageDriver

StorageError:

• core: object StorageError

symlinkIn:

• securejoin: proc symlinkIn(dirFd: cint; target, base: string)

tmpBase:

• securejoin: proc tmpBase(base: string): string

touch:

• core: method touch(d: StorageDriver; path: string)
• local: method touch(d: LocalDriver; path: string)
• policy: method touch(p: FilesystemPolicy; path: string)

touchSecure:

• securejoin: proc touchSecure(root: SecureRoot; relpath: string)

Visibility:

• core: enum Visibility

visibility:

• core: method visibility(d: StorageDriver; path: string): Visibility
• local: method visibility(d: LocalDriver; path: string): Visibility
• policy: method visibility(p: FilesystemPolicy; path: string): Visibility

visPrivate:

• core: Visibility.visPrivate

visPublic:

• core: Visibility.visPublic

withLock:

• local: template withLock(d: LocalDriver; path: string; body: untyped)

write:

• core: method write(d: StorageDriver; path, content: string; visibility = visPrivate)
• filesystem: proc write(fs: Filesystem; path, content: string; visibility = visPrivate)
• local: method write(d: LocalDriver; path, content: string; visibility = visPrivate)
• policy: method write(p: FilesystemPolicy; path, content: string; visibility = visPrivate)

writeAllFd:

• securejoin: proc writeAllFd(fd: cint; s: string)

writeBufFd:

• securejoin: proc writeBufFd(fd: cint; buf: openArray[byte]; n: int)

writeStream:

• core: method writeStream(d: StorageDriver; path: string; src: File)
• local: method writeStream(d: LocalDriver; path: string; src: File)
• policy: method writeStream(p: FilesystemPolicy; path: string; src: File)