move apis into rom/modules/main for shell compatibility

sys/modules/opus/fs/gitfs.lua

@@ -0,0 +1,21 @@
+local git = require('opus.git')
+
+local fs = _G.fs
+
+local gitfs = { }
+
+function gitfs.mount(dir, repo)
+	if not repo then
+		error('gitfs syntax: repo')
+	end
+
+	local list = git.list(repo)
+	for path, entry in pairs(list) do
+		if not fs.exists(fs.combine(dir, path)) then
+			local node = fs.mount(fs.combine(dir, path), 'urlfs', entry.url)
+			node.size = entry.size
+		end
+	end
+end
+
+return gitfs

sys/modules/opus/fs/linkfs.lua

@@ -0,0 +1,65 @@
+local fs = _G.fs
+
+local linkfs = { }
+
+-- TODO: implement broken links
+
+local methods = { 'exists', 'getFreeSpace', 'getSize',
+	'isDir', 'isReadOnly', 'list', 'listEx', 'makeDir', 'open', 'getDrive' }
+
+for _,m in pairs(methods) do
+	linkfs[m] = function(node, dir, ...)
+		dir = dir:gsub(node.mountPoint, node.source, 1)
+		return fs[m](dir, ...)
+	end
+end
+
+function linkfs.mount(_, source)
+	if not source then
+		error('Source is required')
+	end
+	source = fs.combine(source, '')
+	if fs.isDir(source) then
+		return {
+			source = source,
+			nodes = { },
+		}
+	end
+	return {
+		source = source
+	}
+end
+
+function linkfs.copy(node, s, t)
+	s = s:gsub(node.mountPoint, node.source, 1)
+	t = t:gsub(node.mountPoint, node.source, 1)
+	return fs.copy(s, t)
+end
+
+function linkfs.delete(node, dir)
+	if dir == node.mountPoint then
+		fs.unmount(node.mountPoint)
+	else
+		dir = dir:gsub(node.mountPoint, node.source, 1)
+		return fs.delete(dir)
+	end
+end
+
+function linkfs.find(node, spec)
+	spec = spec:gsub(node.mountPoint, node.source, 1)
+
+	local list = fs.find(spec)
+	for k,f in ipairs(list) do
+		list[k] = f:gsub(node.source, node.mountPoint, 1)
+	end
+
+	return list
+end
+
+function linkfs.move(node, s, t)
+	s = s:gsub(node.mountPoint, node.source, 1)
+	t = t:gsub(node.mountPoint, node.source, 1)
+	return fs.move(s, t)
+end
+
+return linkfs

sys/modules/opus/fs/netfs.lua

@@ -0,0 +1,166 @@
+local Socket       = require('opus.socket')
+local synchronized = require('opus.sync').sync
+
+local fs = _G.fs
+
+local netfs = { }
+
+local function remoteCommand(node, msg)
+
+	for _ = 1, 2 do
+		if not node.socket then
+			node.socket = Socket.connect(node.id, 139)
+		end
+
+		if not node.socket then
+			error('netfs: Unable to establish connection to ' .. node.id)
+			fs.unmount(node.mountPoint)
+			return
+		end
+
+		local ret
+		synchronized(node.socket, function()
+			node.socket:write(msg)
+			ret = node.socket:read(1)
+		end)
+
+		if ret then
+			return ret.response
+		end
+		node.socket:close()
+		node.socket = nil
+	end
+	error('netfs: Connection failed', 2)
+end
+
+local methods = { 'delete', 'exists', 'getFreeSpace', 'makeDir', 'list', 'listEx' }
+
+local function resolveDir(dir, node)
+	-- TODO: Wrong ! (does not support names with dashes)
+	dir = dir:gsub(node.mountPoint, '', 1)
+	return fs.combine(node.directory, dir)
+end
+
+for _,m in pairs(methods) do
+	netfs[m] = function(node, dir)
+		dir = resolveDir(dir, node)
+
+		return remoteCommand(node, {
+			fn = m,
+			args = { dir },
+		})
+	end
+end
+
+function netfs.mount(_, id, directory)
+	if not id or not tonumber(id) then
+		error('ramfs syntax: computerId [directory]')
+	end
+	return {
+		id = tonumber(id),
+		nodes = { },
+		directory = directory or '',
+	}
+end
+
+function netfs.getDrive()
+	return 'net'
+end
+
+function netfs.complete(node, partial, dir, includeFiles, includeSlash)
+	dir = resolveDir(dir, node)
+
+	return remoteCommand(node, {
+		fn = 'complete',
+		args = { partial, dir, includeFiles, includeSlash },
+	})
+end
+
+function netfs.copy(node, s, t)
+	s = resolveDir(s, node)
+	t = resolveDir(t, node)
+
+	return remoteCommand(node, {
+		fn = 'copy',
+		args = { s, t },
+	})
+end
+
+function netfs.isDir(node, dir)
+	if dir == node.mountPoint and node.directory == '' then
+		return true
+	end
+	return remoteCommand(node, {
+		fn = 'isDir',
+		args = { resolveDir(dir, node) },
+	})
+end
+
+function netfs.isReadOnly(node, dir)
+	if dir == node.mountPoint and node.directory == '' then
+		return false
+	end
+	return remoteCommand(node, {
+		fn = 'isReadOnly',
+		args = { resolveDir(dir, node) },
+	})
+end
+
+function netfs.getSize(node, dir)
+	if dir == node.mountPoint and node.directory == '' then
+		return 0
+	end
+	return remoteCommand(node, {
+		fn = 'getSize',
+		args = { resolveDir(dir, node) },
+	})
+end
+
+function netfs.find(node, spec)
+	spec = resolveDir(spec, node)
+	local list = remoteCommand(node, {
+		fn = 'find',
+		args = { spec },
+	})
+
+	for k,f in ipairs(list) do
+		list[k] = fs.combine(node.mountPoint, f)
+	end
+
+	return list
+end
+
+function netfs.move(node, s, t)
+	s = resolveDir(s, node)
+	t = resolveDir(t, node)
+
+	return remoteCommand(node, {
+		fn = 'move',
+		args = { s, t },
+	})
+end
+
+function netfs.open(node, fn, fl)
+	fn = resolveDir(fn, node)
+
+	local vfh = remoteCommand(node, {
+		fn = 'open',
+		args = { fn, fl },
+	})
+
+	if vfh then
+		vfh.node = node
+		for _,m in ipairs(vfh.methods) do
+			vfh[m] = function(...)
+				return remoteCommand(node, {
+					fn = 'fileOp',
+					args = { vfh.fileUid, m, ... },
+				})
+			end
+		end
+	end
+
+	return vfh
+end
+
+return netfs

sys/modules/opus/fs/ramfs.lua

@@ -0,0 +1,147 @@
+local Util   = require('opus.util')
+
+local fs = _G.fs
+
+local ramfs = { }
+
+function ramfs.mount(_, nodeType)
+	if nodeType == 'directory' then
+		return {
+			nodes = { },
+			size = 0,
+		}
+	elseif nodeType == 'file' then
+		return {
+			size = 0,
+		}
+	end
+	error('ramfs syntax: [directory, file]')
+end
+
+function ramfs.delete(node, dir)
+	if node.mountPoint == dir then
+		fs.unmount(node.mountPoint)
+	end
+end
+
+function ramfs.exists(node, fn)
+	return node.mountPoint == fn
+end
+
+function ramfs.getSize(node)
+	return node.size
+end
+
+function ramfs.isReadOnly()
+	return false
+end
+
+function ramfs.makeDir(_, dir)
+	fs.mount(dir, 'ramfs', 'directory')
+end
+
+function ramfs.isDir(node)
+	return not not node.nodes
+end
+
+function ramfs.getDrive()
+	return 'ram'
+end
+
+function ramfs.list(node, dir)
+	if node.nodes and node.mountPoint == dir then
+		local files = { }
+		for k in pairs(node.nodes) do
+			table.insert(files, k)
+		end
+		return files
+	end
+	error('Not a directory')
+end
+
+function ramfs.open(node, fn, fl)
+
+	if fl ~= 'r' and fl ~= 'w' and fl ~= 'rb' and fl ~= 'wb' then
+		error('Unsupported mode')
+	end
+
+	if fl == 'r' then
+		if node.mountPoint ~= fn then
+			return
+		end
+
+		local ctr = 0
+		local lines
+		return {
+			readLine = function()
+				if not lines then
+					lines = Util.split(node.contents)
+				end
+				ctr = ctr + 1
+				return lines[ctr]
+			end,
+			readAll = function()
+				return node.contents
+			end,
+			close = function()
+				lines = nil
+			end,
+		}
+	elseif fl == 'w' then
+		node = fs.mount(fn, 'ramfs', 'file')
+
+		local c = ''
+		return {
+			write = function(str)
+				c = c .. str
+			end,
+			writeLine = function(str)
+				c = c .. str .. '\n'
+			end,
+			flush = function()
+				node.contents = c
+				node.size = #c
+			end,
+			close = function()
+				node.contents = c
+				node.size = #c
+				c = nil
+			end,
+		}
+	elseif fl == 'rb' then
+		if node.mountPoint ~= fn or not node.contents then
+			return
+		end
+
+		local ctr = 0
+		return {
+			read = function()
+				ctr = ctr + 1
+				return node.contents[ctr]
+			end,
+			close = function()
+			end,
+		}
+
+	elseif fl == 'wb' then
+		node = fs.mount(fn, 'ramfs', 'file')
+
+		local c = { }
+		return {
+			write = function(b)
+				table.insert(c, b)
+			end,
+			flush = function()
+				node.contents = c
+				node.size = #c
+			end,
+			close = function()
+				node.contents = c
+				node.size = #c
+				c = nil
+			end,
+		}
+	end
+end
+
+return ramfs

sys/modules/opus/fs/urlfs.lua

@@ -0,0 +1,103 @@
+--local rttp = require('rttp')
+local Util = require('opus.util')
+
+local fs = _G.fs
+
+local urlfs = { }
+
+function urlfs.mount(_, url)
+	if not url then
+		error('URL is required')
+	end
+	return {
+		url = url,
+	}
+end
+
+function urlfs.delete(_, dir)
+	fs.unmount(dir)
+end
+
+function urlfs.exists()
+	return true
+end
+
+function urlfs.getSize(node)
+	return node.size or 0
+end
+
+function urlfs.isReadOnly()
+	return true
+end
+
+function urlfs.isDir()
+	return false
+end
+
+function urlfs.getDrive()
+	return 'url'
+end
+
+function urlfs.open(node, fn, fl)
+	if fl == 'w' or fl == 'wb' then
+		fs.delete(fn)
+		return fs.open(fn, fl)
+	end
+
+	if fl ~= 'r' and fl ~= 'rb' then
+		error('Unsupported mode')
+	end
+
+	local c = node.cache
+	if not c then
+		--[[
+		if node.url:match("^(rttps?:)") then
+			local s, response = rttp.get(node.url)
+			c = s and response.statusCode == 200 and response.data
+		else
+			c = Util.httpGet(node.url)
+		end
+		]]--
+		c = Util.httpGet(node.url)
+		if c then
+			node.cache = c
+			node.size = #c
+		end
+	end
+
+	if not c then
+		return
+	end
+
+	local ctr = 0
+	local lines
+
+	if fl == 'r' then
+		return {
+			readLine = function()
+				if not lines then
+					lines = Util.split(c)
+				end
+				ctr = ctr + 1
+				return lines[ctr]
+			end,
+			readAll = function()
+				return c
+			end,
+			close = function()
+				lines = nil
+			end,
+		}
+	end
+	return {
+		read = function()
+			ctr = ctr + 1
+			return c:sub(ctr, ctr):byte()
+		end,
+		close = function()
+			ctr = 0
+		end,
+	}
+end
+
+return urlfs