mirror of
https://github.com/falk-werner/webfuse
synced 2026-03-02 03:40:24 +00:00
refine directory structure
This commit is contained in:
Falk Werner
13
example/authenticator/simple/authenticator.sh
Executable file
13
example/authenticator/simple/authenticator.sh
Executable file
@@ -0,0 +1,13 @@
|
||||
#!/usr/bin/bash
|
||||
|
||||
AUTH_TOKEN="$1"
|
||||
|
||||
if [[ "$AUTH_TOKEN" == "user:bob;token=foo" ]]
|
||||
then
|
||||
echo "$(date): webfuse: auth granted: $AUTH_TOKEN" >> /tmp/webfuse_auth.log
|
||||
else
|
||||
echo "$(date): webfuse: auth denied: $AUTH_TOKEN" >> /tmp/webfuse_auth.log
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
1
example/provider/python/requirements.txt
Normal file
1
example/provider/python/requirements.txt
Normal file
@@ -0,0 +1 @@
|
||||
websockets==10.4
|
||||
579
example/provider/python/webfuse_provider.py
Executable file
579
example/provider/python/webfuse_provider.py
Executable file
@@ -0,0 +1,579 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import stat
|
||||
import websockets
|
||||
import errno
|
||||
import getpass
|
||||
|
||||
INVALID_FD = 0xffffffffffffffff
|
||||
|
||||
F_OK = 0
|
||||
R_OK = 4
|
||||
W_OK = 2
|
||||
X_OK = 1
|
||||
|
||||
RESPONSE = 0x80
|
||||
|
||||
ERRNO = {
|
||||
-errno.E2BIG : -7,
|
||||
-errno.EACCES : -13,
|
||||
-errno.EAGAIN : -11,
|
||||
-errno.EBADF : -9,
|
||||
-errno.EBUSY : -16,
|
||||
-errno.EDESTADDRREQ : -89,
|
||||
-errno.EDQUOT : -122,
|
||||
-errno.EEXIST : -17,
|
||||
-errno.EFAULT : -14,
|
||||
-errno.EFBIG : -27,
|
||||
-errno.EINTR : -4,
|
||||
-errno.EINVAL : -22,
|
||||
-errno.EIO : -5,
|
||||
-errno.EISDIR : -21,
|
||||
-errno.ELOOP : -40,
|
||||
-errno.EMFILE : -24,
|
||||
-errno.EMLINK : -31,
|
||||
-errno.ENAMETOOLONG : -36,
|
||||
-errno.ENFILE : -23,
|
||||
-errno.ENODATA : -61,
|
||||
-errno.ENODEV : -19,
|
||||
-errno.ENOENT : -2,
|
||||
-errno.ENOMEM : -12,
|
||||
-errno.ENOSPC : -28,
|
||||
-errno.ENOSYS : -38,
|
||||
-errno.ENOTDIR : -20,
|
||||
-errno.ENOTEMPTY : -39,
|
||||
-errno.ENOTSUP : -95,
|
||||
-errno.ENXIO : -6,
|
||||
-errno.EOVERFLOW : -75,
|
||||
-errno.EPERM : -1,
|
||||
-errno.EPIPE : -32,
|
||||
-errno.ERANGE : -34,
|
||||
-errno.EROFS : -30,
|
||||
-errno.ETXTBSY : -26,
|
||||
-errno.EXDEV : -18
|
||||
}
|
||||
|
||||
RENAME_NOREPLACE = 0x01
|
||||
RENAME_EXCHANGE = 0x02
|
||||
|
||||
MODE_REG = 0o100000
|
||||
MODE_DIR = 0o040000
|
||||
MODE_CHR = 0o020000
|
||||
MODE_BLK = 0o060000
|
||||
MODE_FIFO = 0o010000
|
||||
MODE_LNK = 0o120000
|
||||
MODE_SOCK = 0o140000
|
||||
|
||||
O_RDONLY = 0o00
|
||||
O_WRONLY = 0o01
|
||||
O_RDWR = 0o02
|
||||
|
||||
O_APPEND = 0o00002000
|
||||
O_ASYNC = 0o00020000
|
||||
O_CLOEXEC = 0o02000000
|
||||
O_CREAT = 0o00000100
|
||||
O_DIRECT = 0o00040000
|
||||
O_DIRECTORY = 0o00200000
|
||||
O_DSYNC = 0o00010000
|
||||
O_EXCL = 0o00000200
|
||||
O_LARGEFILE = 0o00100000
|
||||
O_NOATIME = 0o01000000
|
||||
O_NOCTTY = 0o00000400
|
||||
O_NOFOLLOW = 0o00400000
|
||||
O_NONBLOCK = 0o00004000
|
||||
O_NDELAY = 0o00004000
|
||||
O_PATH = 0o10000000
|
||||
O_SYNC = 0o04010000
|
||||
O_TMPFILE = 0o20200000
|
||||
O_TRUNC = 0o00001000
|
||||
|
||||
class MessageReader:
|
||||
def __init__(self, buffer):
|
||||
self.buffer = buffer
|
||||
self.offset = 0
|
||||
|
||||
def read_u8(self):
|
||||
value = self.buffer[self.offset]
|
||||
self.offset += 1
|
||||
return value
|
||||
|
||||
def read_bool(self):
|
||||
return self.read_u8() == 1
|
||||
|
||||
def read_u32(self):
|
||||
value = (self.buffer[self.offset] << 24) + (self.buffer[self.offset + 1] << 16) + (self.buffer[self.offset + 2] << 8) + self.buffer[self.offset + 3]
|
||||
self.offset += 4
|
||||
return value
|
||||
|
||||
def read_u64(self):
|
||||
value = (
|
||||
(self.buffer[self.offset ] << 56) +
|
||||
(self.buffer[self.offset + 1] << 48) +
|
||||
(self.buffer[self.offset + 2] << 40) +
|
||||
(self.buffer[self.offset + 3] << 32) +
|
||||
(self.buffer[self.offset + 4] << 24) +
|
||||
(self.buffer[self.offset + 5] << 16) +
|
||||
(self.buffer[self.offset + 6] << 8) +
|
||||
self.buffer[self.offset + 7])
|
||||
self.offset += 8
|
||||
return value
|
||||
|
||||
|
||||
def read_str(self):
|
||||
return self.read_bytes().decode()
|
||||
|
||||
def read_bytes(self):
|
||||
size = self.read_u32()
|
||||
value = self.buffer[self.offset : self.offset + size]
|
||||
self.offset += size
|
||||
return value
|
||||
|
||||
def read_path(self, base_path):
|
||||
local_path = self.read_str().lstrip('/')
|
||||
return os.path.join(base_path, local_path)
|
||||
|
||||
def read_access_mode(self):
|
||||
value = self.read_u8()
|
||||
mode = os.F_OK if F_OK == (value & F_OK) else 0
|
||||
mode |= os.R_OK if R_OK == (value & R_OK) else 0
|
||||
mode |= os.W_OK if W_OK == (value & W_OK) else 0
|
||||
mode |= os.X_OK if X_OK == (value & X_OK) else 0
|
||||
return mode
|
||||
|
||||
def read_rename_flags(self):
|
||||
return self.read_u8()
|
||||
|
||||
def read_mode(self):
|
||||
value = self.read_u32()
|
||||
mode = value & 0o7777
|
||||
mode |= stat.S_IFREG if MODE_REG == (value & MODE_REG ) else 0
|
||||
mode |= stat.S_IFDIR if MODE_DIR == (value & MODE_DIR ) else 0
|
||||
mode |= stat.S_IFCHR if MODE_CHR == (value & MODE_CHR ) else 0
|
||||
mode |= stat.S_IFBLK if MODE_BLK == (value & MODE_BLK ) else 0
|
||||
mode |= stat.S_IFFIFO if MODE_FIFO == (value & MODE_FIFO) else 0
|
||||
mode |= stat.S_IFLNK if MODE_LNK == (value & MODE_LNK ) else 0
|
||||
mode |= stat.S_IFSOCK if MODE_SOCK == (value & MODE_SOCK) else 0
|
||||
return mode
|
||||
|
||||
def read_openflags(self):
|
||||
value = self.read_u32()
|
||||
flags = 0
|
||||
# Access Mode
|
||||
flags |= os.O_RDONLY if O_RDONLY == (value & O_RDONLY) else 0
|
||||
flags |= os.O_WRONLY if O_WRONLY == (value & O_WRONLY) else 0
|
||||
flags |= os.O_RDWR if O_RDWR == (value & O_RDWR ) else 0
|
||||
# Flags
|
||||
flags |= os.O_APPEND if O_APPEND == (value & O_APPEND ) else 0
|
||||
flags |= os.O_ASYNC if O_ASYNC == (value & O_ASYNC ) else 0
|
||||
flags |= os.O_CLOEXEC if O_CLOEXEC == (value & O_CLOEXEC ) else 0
|
||||
flags |= os.O_CREAT if O_CREAT == (value & O_CREAT ) else 0
|
||||
flags |= os.O_DIRECT if O_DIRECT == (value & O_DIRECT ) else 0
|
||||
flags |= os.O_DIRECTORY if O_DIRECTORY == (value & O_DIRECTORY) else 0
|
||||
flags |= os.O_DSYNC if O_DSYNC == (value & O_DSYNC ) else 0
|
||||
flags |= os.O_EXCL if O_EXCL == (value & O_EXCL ) else 0
|
||||
flags |= os.O_LARGEFILE if O_LARGEFILE == (value & O_LARGEFILE) else 0
|
||||
flags |= os.O_NOCTTY if O_NOCTTY == (value & O_NOCTTY ) else 0
|
||||
flags |= os.O_NOFOLLOW if O_NOFOLLOW == (value & O_NOFOLLOW ) else 0
|
||||
flags |= os.O_NONBLOCK if O_NONBLOCK == (value & O_NONBLOCK ) else 0
|
||||
flags |= os.O_NDELAY if O_NDELAY == (value & O_NDELAY ) else 0
|
||||
flags |= os.O_PATH if O_PATH == (value & O_PATH ) else 0
|
||||
flags |= os.O_SYNC if O_SYNC == (value & O_SYNC ) else 0
|
||||
flags |= os.O_TMPFILE if O_TMPFILE == (value & O_TMPFILE ) else 0
|
||||
flags |= os.O_TRUNC if O_TRUNC == (value & O_TRUNC ) else 0
|
||||
return flags
|
||||
|
||||
|
||||
|
||||
class MessageWriter:
|
||||
def __init__(self, message_id, message_type):
|
||||
self.buffer = []
|
||||
self.write_u32(message_id)
|
||||
self.write_u8(message_type)
|
||||
|
||||
def write_u8(self, value):
|
||||
self.buffer.append(value)
|
||||
|
||||
def write_u32(self, value):
|
||||
self.buffer.extend([
|
||||
(value >> 24) & 0xff,
|
||||
(value >> 16) & 0xff,
|
||||
(value >> 8) & 0xff,
|
||||
value & 0xff
|
||||
])
|
||||
|
||||
def write_u64(self, value):
|
||||
self.buffer.extend([
|
||||
(value >> 56) & 0xff,
|
||||
(value >> 48) & 0xff,
|
||||
(value >> 40) & 0xff,
|
||||
(value >> 32) & 0xff,
|
||||
(value >> 24) & 0xff,
|
||||
(value >> 16) & 0xff,
|
||||
(value >> 8) & 0xff,
|
||||
value & 0xff
|
||||
])
|
||||
|
||||
def write_i32(self, value):
|
||||
self.write_u32(value & 0xffffffff)
|
||||
|
||||
def write_result(self, value):
|
||||
if 0 > value:
|
||||
if value in ERRNO:
|
||||
value = ERRNO[value]
|
||||
self.write_i32(value)
|
||||
|
||||
def write_str(self, value):
|
||||
data = value.encode('utf-8')
|
||||
self.write_bytes(data)
|
||||
|
||||
def write_bytes(self, value):
|
||||
size = len(value)
|
||||
self.write_u32(size)
|
||||
self.buffer.extend(value)
|
||||
|
||||
def write_strings(self, values):
|
||||
count = len(values)
|
||||
self.write_u32(count)
|
||||
for value in values:
|
||||
self.write_str(value)
|
||||
|
||||
def get_bytes(self):
|
||||
return bytearray(self.buffer)
|
||||
|
||||
|
||||
class FilesystemProvider:
|
||||
def __init__(self, path, url):
|
||||
self.root = os.path.abspath(path)
|
||||
self.url = url
|
||||
self.commands = {
|
||||
0x01: FilesystemProvider.access,
|
||||
0x02: FilesystemProvider.getattr,
|
||||
0x03: FilesystemProvider.readlink,
|
||||
0x04: FilesystemProvider.symlink,
|
||||
0x05: FilesystemProvider.link,
|
||||
0x06: FilesystemProvider.rename,
|
||||
0x07: FilesystemProvider.chmod,
|
||||
0x08: FilesystemProvider.chown,
|
||||
0x09: FilesystemProvider.truncate,
|
||||
0x0a: FilesystemProvider.fsync,
|
||||
0x0b: FilesystemProvider.open,
|
||||
0x0c: FilesystemProvider.mknod,
|
||||
0x0d: FilesystemProvider.create,
|
||||
0x0e: FilesystemProvider.release,
|
||||
0x0f: FilesystemProvider.unlink,
|
||||
0x10: FilesystemProvider.read,
|
||||
0x11: FilesystemProvider.write,
|
||||
0x12: FilesystemProvider.mkdir,
|
||||
0x13: FilesystemProvider.readdir,
|
||||
0x14: FilesystemProvider.rmdir,
|
||||
0x15: FilesystemProvider.statfs,
|
||||
0x16: FilesystemProvider.utimens,
|
||||
0x17: FilesystemProvider.getcreds,
|
||||
}
|
||||
|
||||
async def run(self):
|
||||
extra_headers = [("X-Auth-Token", "user:bob;token=foo")]
|
||||
async with websockets.connect(self.url, extra_headers=extra_headers) as connection:
|
||||
while True:
|
||||
request = await connection.recv()
|
||||
reader = MessageReader(request)
|
||||
message_id = reader.read_u32()
|
||||
message_type = reader.read_u8()
|
||||
writer = MessageWriter(message_id, RESPONSE + message_type)
|
||||
if message_type in self.commands:
|
||||
method = self.commands[message_type]
|
||||
method(self, reader, writer)
|
||||
else:
|
||||
print("unknown message type: %d" % message_type)
|
||||
response = writer.get_bytes()
|
||||
await connection.send(response)
|
||||
|
||||
def access(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
mode = reader.read_access_mode()
|
||||
result = -errno.EACCES
|
||||
try:
|
||||
if os.access(path, mode) == True:
|
||||
result = 0
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def getattr(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
try:
|
||||
attr = os.lstat(path)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(0)
|
||||
writer.write_u64(attr.st_ino)
|
||||
writer.write_u64(attr.st_nlink)
|
||||
writer.write_u32(attr.st_mode)
|
||||
writer.write_i32(attr.st_uid)
|
||||
writer.write_i32(attr.st_gid)
|
||||
writer.write_u64(attr.st_dev)
|
||||
writer.write_u64(attr.st_size)
|
||||
writer.write_u64(attr.st_blocks)
|
||||
writer.write_u64(int(attr.st_atime))
|
||||
writer.write_u32(attr.st_atime_ns)
|
||||
writer.write_u64(int(attr.st_mtime))
|
||||
writer.write_u32(attr.st_mtime_ns)
|
||||
writer.write_u64(int(attr.st_ctime))
|
||||
writer.write_u32(attr.st_ctime_ns)
|
||||
|
||||
def readlink(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
try:
|
||||
link = os.readlink(path)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(0)
|
||||
writer.write_str(link)
|
||||
|
||||
def symlink(self, reader, writer):
|
||||
source = reader.read_str()
|
||||
target = reader.read_path(self.root)
|
||||
result = 0
|
||||
try:
|
||||
os.symlink(source, target)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def link(self, reader, writer):
|
||||
source = reader.read_path(self.root)
|
||||
target = reader.read_path(self.root)
|
||||
result = 0
|
||||
try:
|
||||
os.link(source, target)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def rename(self, reader, writer):
|
||||
source = reader.read_path(self.root)
|
||||
target = reader.read_path(self.root)
|
||||
flags = reader.read_rename_flags()
|
||||
result = 0
|
||||
try:
|
||||
if RENAME_EXCHANGE == (flags & RENAME_EXCHANGE):
|
||||
# exchange is not supported
|
||||
result = -errno.EINVAL
|
||||
elif RENAME_NOREPLACE == (flags & RENAME_NOREPLACE):
|
||||
os.rename(source, target)
|
||||
else:
|
||||
os.replace(source, target)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def chmod(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
mode = reader.read_mode()
|
||||
result = 0
|
||||
try:
|
||||
os.chmod(path, mode)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def chown(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
uid = reader.read_u32()
|
||||
gid = reader.read_u32()
|
||||
result = 0
|
||||
try:
|
||||
os.chown(path, uid, gid)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def truncate(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
size = reader.read_u64()
|
||||
fd = reader.read_u64()
|
||||
result = 0
|
||||
try:
|
||||
if fd != INVALID_FD:
|
||||
os.ftruncate(fd, size)
|
||||
else:
|
||||
os.truncate(path, size)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def fsync(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
_ = reader.read_bool()
|
||||
fd = reader.read_u64()
|
||||
result = 0
|
||||
try:
|
||||
os.fsync(fd)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def utimens(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
atime = reader.read_u64()
|
||||
atime_ns = reader.read_u32()
|
||||
mtime = reader.read_u64()
|
||||
mtime_ns = reader.read_u32()
|
||||
fd = reader.read_u64()
|
||||
result = 0
|
||||
try:
|
||||
os.utime(path, (atime, mtime), ns = (atime_ns, mtime_ns))
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
|
||||
def open(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
flags = reader.read_openflags()
|
||||
try:
|
||||
fd = os.open(path, flags)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(0)
|
||||
writer.write_u64(fd)
|
||||
|
||||
|
||||
def mknod(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
mode = reader.read_mode()
|
||||
rdev = reader.read_u64()
|
||||
result = 0
|
||||
try:
|
||||
os.mknod(path, mode, rdev)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def create(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
mode = reader.read_mode()
|
||||
try:
|
||||
flags = os.O_CREAT | os.O_WRONLY | os.O_TRUNC
|
||||
fd = os.open(path, flags, mode)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(0)
|
||||
writer.write_u64(fd)
|
||||
pass
|
||||
|
||||
def release(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
fd = reader.read_u64()
|
||||
result = 0
|
||||
try:
|
||||
os.close(fd)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(result)
|
||||
|
||||
def unlink(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
result = 0
|
||||
try:
|
||||
os.unlink(path)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def read(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
size = reader.read_u32()
|
||||
offset = reader.read_u64()
|
||||
fd = reader.read_u64()
|
||||
try:
|
||||
if fd != INVALID_FD:
|
||||
buffer = os.pread(fd, size, offset)
|
||||
else:
|
||||
with os.open(path, os.O_RDONLY) as f:
|
||||
buffer = os.pread(f, size, offset)
|
||||
writer.write_result(len(buffer))
|
||||
writer.write_bytes(buffer)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
|
||||
def write(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
data = reader.read_bytes()
|
||||
offset = reader.read_u64()
|
||||
fd = reader.read_u64()
|
||||
result = 0
|
||||
try:
|
||||
if fd != INVALID_FD:
|
||||
result = os.pwrite(fd, data, offset)
|
||||
else:
|
||||
with os.open(path, os.O_WRONLY) as f:
|
||||
result = os.pwrite(f, data, offset)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def mkdir(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
mode = reader.read_u32()
|
||||
result = 0
|
||||
try:
|
||||
os.mkdir(path, mode)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def readdir(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
names = []
|
||||
try:
|
||||
with os.scandir(path) as it:
|
||||
for entry in it:
|
||||
names.append(entry.name)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(0)
|
||||
writer.write_strings(names)
|
||||
|
||||
def rmdir(self, reader, writer):
|
||||
path = reader.read_path(self.root)
|
||||
result = 0
|
||||
try:
|
||||
os.rmdir(path)
|
||||
except OSError as ex:
|
||||
result = -ex.errno
|
||||
writer.write_result(result)
|
||||
|
||||
def statfs(self, reader, writer):
|
||||
path = self.get_path(reader)
|
||||
try:
|
||||
buffer = os.statvfs(path)
|
||||
except OSError as ex:
|
||||
writer.write_result(-ex.errno)
|
||||
return
|
||||
writer.write_result(0)
|
||||
writer.write_u64(buffer.f_bsize)
|
||||
writer.write_u64(buffer.f_frsize)
|
||||
writer.write_u64(buffer.f_blocks)
|
||||
writer.write_u64(buffer.f_bfree)
|
||||
writer.write_u64(buffer.f_bavail)
|
||||
writer.write_u64(buffer.f_files)
|
||||
writer.write_u64(buffer.f_ffree)
|
||||
writer.write_u64(buffer.f_namemax)
|
||||
|
||||
def getcreds(self, reader, writer):
|
||||
credentials = getpass.getpass(prompt="credentials: ")
|
||||
writer.write_str(credentials)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
provider = FilesystemProvider('.', 'ws://localhost:8081')
|
||||
asyncio.run(provider.run())
|
||||
Reference in New Issue
Block a user