287 lines
9.4 KiB
Python
Executable File
287 lines
9.4 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import requests
|
|
import random
|
|
import os
|
|
import sys
|
|
import errno
|
|
|
|
from fuse import FUSE, FuseOSError, Operations, fuse_get_context
|
|
|
|
releases = []
|
|
assets = {}
|
|
headers = {"Authorization": "token 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",
|
|
"Accept": "application/json"}
|
|
user = "DomiOwO"
|
|
repo = "iwisoftware"
|
|
files=[{}] # offsetting by 1 because FD 0 is invalid
|
|
files_buffers=[[]]
|
|
|
|
def getReleases():
|
|
if not releases:
|
|
a=requests.get("https://api.github.com/repos/"+ user + "/" + repo + "/releases", headers = headers);
|
|
x=a.json()
|
|
for i in x:
|
|
releases.extend([{"name":i["tag_name"], "id":i["id"]}])
|
|
for j in i["assets"]:
|
|
assets[i["tag_name"]] = {} # change this later
|
|
for j in i["assets"]:
|
|
assets[i["tag_name"]][j["name"]]={"id": j["id"], "size": j["size"]}
|
|
print(assets)
|
|
|
|
def allocateFd(path):
|
|
global files, files_buffers
|
|
fd = len(files)
|
|
files += [{"path": path,
|
|
"state": None, # 0 - read, 1 - write
|
|
"len": 0
|
|
}]
|
|
files_buffers += [[]]
|
|
return fd
|
|
|
|
class Passthrough(Operations):
|
|
def __init__(self, root):
|
|
self.root = root
|
|
|
|
def _full_path(self, partial):
|
|
if partial.startswith("/"):
|
|
partial = partial[1:]
|
|
path = os.path.join(self.root, partial)
|
|
return path
|
|
|
|
def access(self, path, mode):
|
|
print("-- access")
|
|
|
|
def chmod(self, path, mode):
|
|
print("-- chmod")
|
|
return 0
|
|
|
|
def chown(self, path, uid, gid):
|
|
print("-- chown")
|
|
return 0
|
|
|
|
def getattr(self, path, fh=None):
|
|
full_path = self._full_path(path)
|
|
print("-- getattr", full_path)
|
|
if full_path.split('/')[-2] in assets or len(full_path.split('/')) == 2:
|
|
if len(full_path.split('/')) < 3:
|
|
if full_path == 'b/':
|
|
st_mode = 0o40744
|
|
st_size = 1337
|
|
else:
|
|
if any((full_path.split('/')[1] == r["name"] for r in releases)):
|
|
st_mode = 0o40744
|
|
st_size = 1337
|
|
else:
|
|
raise FuseOSError(2)
|
|
else:
|
|
st_mode = 0o100744
|
|
print(full_path.split('/'))
|
|
print(assets[full_path.split('/')[-2]])
|
|
if full_path.split('/')[-1] in assets[full_path.split('/')[-2]]:
|
|
st_size = assets[full_path.split('/')[-2]][full_path.split('/')[-1]]["size"]
|
|
else:
|
|
raise FuseOSError(2)
|
|
else:
|
|
st_mode = 0o100000
|
|
st_size = 0
|
|
print(st_mode, st_size)
|
|
return {'st_atime': 1,
|
|
'st_ctime': 1,
|
|
'st_gid': 1000,
|
|
'st_mode': int(st_mode),
|
|
'st_mtime': 1,
|
|
'st_nlink': 16,
|
|
'st_size': st_size,
|
|
'st_uid': 1000}
|
|
|
|
def readdir(self, path, fh):
|
|
print("-- readdir")
|
|
full_path = self._full_path(path)
|
|
dirents = ['.', '..']
|
|
print(full_path.split('/'))
|
|
if len(full_path.split('/')) == 2 and full_path.endswith('/'):
|
|
for i in releases:
|
|
print(i)
|
|
dirents.extend([i["name"]])
|
|
else:
|
|
if full_path.endswith('/'):
|
|
p=full_path.split('/')[-2]
|
|
else:
|
|
p=full_path.split('/')[-1]
|
|
|
|
if p in assets:
|
|
for i in assets[p]:
|
|
dirents.extend([i])
|
|
|
|
for r in dirents:
|
|
yield r
|
|
|
|
def readlink(self, path):
|
|
print("-- readlink")
|
|
pathname = os.readlink(self._full_path(path))
|
|
if pathname.startswith("/"):
|
|
# Path name is absolute, sanitize it.
|
|
return os.path.relpath(pathname, self.root)
|
|
else:
|
|
return pathname
|
|
|
|
def mknod(self, path, mode, dev):
|
|
print("-- mknod")
|
|
return os.mknod(self._full_path(path), mode, dev)
|
|
|
|
def rmdir(self, path):
|
|
print("-- rmdir")
|
|
_h = headers
|
|
_h["Accept"] = "application/json"
|
|
full_path = self._full_path(path)
|
|
for i in range(len(releases)-1):
|
|
print("asdf: ", i)
|
|
print("asdf: ", releases[i])
|
|
if releases[i]["name"] == path.split("/")[1]:
|
|
a = requests.delete("https://api.github.com/repos/" + user + "/" + repo + "/releases/" + str(releases[i]["id"]),
|
|
headers = _h)
|
|
del(assets[releases[i]["name"]])
|
|
del(releases[i])
|
|
print(a.content)
|
|
return 0
|
|
|
|
def mkdir(self, path, mode):
|
|
print("-- mkdir", path)
|
|
global releases, assets
|
|
a = requests.post("https://api.github.com/repos/" + user + "/" + repo + "/releases",
|
|
headers = headers,
|
|
data = '{"tag_name":"'+path.split("/")[1]+'"}')
|
|
print(a.content)
|
|
x = a.json()
|
|
releases.extend([{"name": path.split("/")[1], "id": x["id"]}])
|
|
assets[path.split('/')[1]] = {}
|
|
return 0
|
|
|
|
def statfs(self, path):
|
|
full_path = self._full_path(path)
|
|
stv = os.statvfs(full_path)
|
|
print("-- statfs")
|
|
return dict((key, getattr(stv, key)) for key in ('f_bavail', 'f_bfree',
|
|
'f_blocks', 'f_bsize', 'f_favail', 'f_ffree', 'f_files', 'f_flag',
|
|
'f_frsize', 'f_namemax'))
|
|
|
|
def unlink(self, path):
|
|
print("-- unlink")
|
|
global assets
|
|
_h = headers
|
|
_h["Accept"] = "application/json"
|
|
a = requests.delete("https://api.github.com/repos/" + user + "/" + repo + "/releases/assets/" + str(assets[path.split("/")[-2]][path.split("/")[-1]]["id"]),
|
|
headers = _h)
|
|
print(a.content)
|
|
del(assets[path.split('/')[-2]][path.split('/')[-1]])
|
|
return 0
|
|
|
|
def symlink(self, name, target):
|
|
print("-- symlink")
|
|
#return os.symlink(target, self._full_path(name))
|
|
return -1
|
|
|
|
def rename(self, old, new):
|
|
print("-- rename")
|
|
#return os.rename(self._full_path(old), self._full_path(new))
|
|
return -1
|
|
|
|
def link(self, target, name):
|
|
print("-- link")
|
|
#return os.link(self._full_path(name), self._full_path(target))
|
|
return -1
|
|
|
|
def utimens(self, path, times=None):
|
|
print("-- utimens")
|
|
#return os.utime(self._full_path(path), times)
|
|
return 0
|
|
|
|
def open(self, path, flags):
|
|
print("-- open")
|
|
return allocateFd(path)
|
|
|
|
def create(self, path, mode, fi=None):
|
|
print("-- create")
|
|
assets[path.split('/')[-2]][path.split('/')[-1]] = {"id": -1, "size": 0}
|
|
return allocateFd(path)
|
|
|
|
def read(self, path, length, offset, fh):
|
|
f = files[fh]
|
|
f["state"] = 0
|
|
print("-- read: offset ", offset, " len ", length, " path ", path)
|
|
#fetch_len = 524289 # small buffer arrives like wroom
|
|
#if offset != 0:
|
|
fetch_len = 10485760 # big buffer goes whoosh
|
|
|
|
print(len(files_buffers[fh]) + fetch_len)
|
|
|
|
if offset + length > f["len"]:
|
|
print("buffer exhausted: ", f["len"])
|
|
_h = headers
|
|
_h["Range"] = "bytes=" + str(f["len"]) + "-" + str(f["len"] + fetch_len - 1)
|
|
f["len"] += fetch_len
|
|
_h["Accept"] = "application/octet-stream"
|
|
try:
|
|
a = requests.get("https://api.github.com/repos/" + user + "/" + repo + "/releases/assets/" + str(assets[path.split("/")[-2]][path.split("/")[-1]]["id"]),
|
|
headers = _h);
|
|
files_buffers[fh].append(bytes(a.content))
|
|
except:
|
|
raise FuseOSError(2) # idk, lets fix getattr sometime
|
|
return b''.join(files_buffers[fh])[offset:offset+length]
|
|
|
|
def write(self, path, buf, offset, fh):
|
|
#print("-- write: offset ", offset, " path ", path)
|
|
f = files[fh]
|
|
f["state"] = 1
|
|
files_buffers[fh].append(bytes(buf))
|
|
return len(buf)
|
|
|
|
def truncate(self, path, length, fh=None):
|
|
print("-- truncate")
|
|
return 0
|
|
|
|
def flush(self, path, fh):
|
|
print("-- flush")
|
|
return 0
|
|
|
|
def release(self, path, fh):
|
|
print("-- release/close")
|
|
f = files[fh]
|
|
if(f["state"] == 1):
|
|
_h = headers
|
|
_h["Content-Type"] = "application/json"
|
|
for i in releases: # move this into a function?
|
|
if i["name"] == path.split('/')[-2]:
|
|
id = i["id"]
|
|
break
|
|
|
|
a = requests.post(
|
|
"https://uploads.github.com/repos/" + user + "/" + repo + "/releases/" + str(id) + "/assets?name=" +
|
|
path.split('/')[-1],
|
|
data = b''.join(files_buffers[fh]),
|
|
headers = _h)
|
|
print(a.content)
|
|
res = a.json()
|
|
print(assets)
|
|
#if not assets[path.split('/')[-2]]:
|
|
# assets[path.split('/')[-2]] = [{}]
|
|
assets[path.split('/')[-2]][path.split('/')[-1]] = {"id": res["id"], "size": res["size"]}
|
|
del(files[fh]) # idk, bad syntax?
|
|
del(files_buffers[fh])
|
|
return 0
|
|
|
|
def fsync(self, path, fdatasync, fh):
|
|
print("-- fsync")
|
|
return 0
|
|
|
|
|
|
def main(mountpoint):
|
|
root='b'
|
|
getReleases()
|
|
FUSE(Passthrough(root), mountpoint, nothreads=True, foreground=True, allow_other=True)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main(sys.argv[1])
|