wip

Author: djdv

filesystem/client.go

@@ -1,9 +1,13 @@
-package fs
+package ipfs
 
 import (
 	"context"
 	"time"
-	"github.com/ipfs/go-ipfs/core"
+	coreiface "github.com/ipfs/interface-go-ipfs-core"
+
+
+ "github.com/ipfs/interface-go-ipfs-core/filesystem/node/soft"
+"github.com/ipfs/go-ipfs-http-client"
 )
 
 type defaultFs struct {
@@ -15,7 +19,8 @@ ctx context.Context
 		epoch time.Time
 
 //IPFS parser specifics
-ipfsNode core.IpfsNode
+//ipfsNode core.IpfsNode
+core coreiface.CoreAPI
 }
 /* From DRAFT
 func NewDefaultFileSystem(parentCtx context.Context) (FileSystem, error) {
@@ -27,23 +32,32 @@ func NewDefaultFileSystem(parentCtx context.Context) (FileSystem, error) {
 */
 
 func newDefaultFs() (FileSystem, error) {
-	var root defaultFs
-	root.epoch = time.Now()
+	root :=  defaultFs {
+		ctx:context.TODO(), // cancelable something or other
+	epoch:time.Now(),
+	}
 
 	// we depend on data from the coreapi to initalize our API nodes
 	// so fetch it or something and store it on the FS
-	daemon := fallbackApi()
-	ctx := deriveCtx(daemon.ctx) // if the daemon cancels, so should we
+	//daemon := fallbackApi()
+	//ctx := deriveCtx(daemon.ctx) // if the daemon cancels, so should we
 
-	root.ipfsNode = daemon
+	//root.ipfsNode = daemon
 
 	// mount base subsystems
+	epoch := time.Now()
+
+// TODO: connect to daemon or fallback [new constructor]
+core, err := httpapi.NewLocalApi()
+if err != nil {
+	return nil, err
+}
 	for _, pair := range [...]struct {
 		string
 		ParseFn
 	}{
-		{"/", rNode.Parser()},
-		{"/ipfs", pinRootParser},  // requests for "/ipfs" are directed at pinRootParser(ctx, requestString)
+		{"/", fsnode.RootParser(epoch)},
+		{"/ipfs", inode.PinParser(core.Pin(), epoch)},  // requests for "/ipfs" are directed at pinRootParser(ctx, requestString)
 		{"/ipfs/", coreAPIParser}, // all requests beneath "/ipfs/" are directed at coreAPIParser(ctx, requestString)
 		{"/ipns", keyRootParser},
 		{"/ipns/", nameAPIParser},
@@ -69,4 +83,5 @@ type DescriptorTable interface {
 }
 
 func newDescriptorTable() {
-}
+}
+

filesystem/default.go renamed to filesystem/default/default.go

@@ -1,38 +1,40 @@
-package fs
+package ipfs
 
 import (
 	"context"
+	"encoding/binary"
 	"io"
 	"os"
 	"strings"
 	"sync"
 
+	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-unixfs"
- "github.com/multiformats/go-multihash" 
- "github.com/ipfs/go-cid" 
+	fs "github.com/ipfs/interface-go-ipfs-core/filesystem/interface"
+	"github.com/multiformats/go-multihash"
 )
 
-func Lookup(ctx context.Context, name string) (FsNode, error) {
+func Lookup(ctx context.Context, name string) (fs.FsNode, error) {
 	return pkgRoot.Lookup(ctx, name)
 }
 
 // api's may define Metadata.Cid() however they like
 // for the default, we use this QID-like generator
-func GenQueryID(path string, md Metadata) (cid.Cid, error) {
+func GenQueryID(path string, md fs.Metadata) (cid.Cid, error) {
 	mdBuf := make([]byte, 16)
-binary.LittleEndian.PutUint64(mdBuf, uint64(md.Size()))
-binary.LittleEndian.PutUint64(mdBuf[8:], uint64(md.Type()))
+	binary.LittleEndian.PutUint64(mdBuf, uint64(md.Size()))
+	binary.LittleEndian.PutUint64(mdBuf[8:], uint64(md.Type()))
 
-prefix := cid.V1Builder{Codec: cid.DagCBOR, MhType: multihash.BLAKE2B_MIN}
-        return prefix.Sum(append([]byte(path), mdBuf...))
+	prefix := cid.V1Builder{Codec: cid.DagCBOR, MhType: multihash.BLAKE2B_MIN}
+	return prefix.Sum(append([]byte(path), mdBuf...))
 }
 
 type PathParserRegistry struct {
 	sync.Mutex
-	nodeParsers map[string]ParseFn
+	nodeParsers map[string]fs.ParseFn
 }
 
-func (rr *PathParserRegistry) Mount(subrootPath string, nodeParser ParseFn) (io.Closer, error) {
+func (rr *PathParserRegistry) Mount(subrootPath string, nodeParser fs.ParseFn) (io.Closer, error) {
 	rr.Lock()
 	val, ok := rr.nodeParsers[subrootPath]
 	if ok || val != nil {

filesystem/index.go renamed to filesystem/default/index.go

@@ -1,8 +1,10 @@
-package fs
+package ipfs
+
+import "github.com/ipfs/interface-go-ipfs-core/filesystem/interface"
 
 //TODO: store these in the daemon/ipfs-node scope, or elsewhere
 // have something  extract the FS from the daemon (`core.fsFrom(IpfsNode)``)
-var 	pkgRoot FileSystem
+var 	pkgRoot fs.FileSystem
 
 func init() {
 	pkgRoot, err = newDefaultFs()

filesystem/init.go renamed to filesystem/default/init.go

@@ -2,26 +2,62 @@ package fs
 
 import (
 	"context"
+	"errors"
 	"io"
 	"os"
 	"sync"
 
-	coreiface "github.com/ipfs/interface-go-ipfs-core"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-unixfs"
 	corepath "github.com/ipfs/interface-go-ipfs-core/path"
 )
 
 type (
 	ParseFn func(ctx context.Context, name string) (FsNode, error)
-	FsType  = coreiface.FileType
-	OFlags = mfs.Flags
+	Kind int
+	Flag string
+	Flags []struct{Flag;bool}
+)
+
+const (
+	FRead Flag ="File Read"
+	FWrite = "File Write"
+	FSync = "File Sync"
+)
+
+const (
+	UfsFile = Kind(unixfs.TFile)
+	UfsDirectory = Kind(unixfs.TDirectory)
+	UfsHAMT = Kind(unixfs.THAMTShard)
+	UfsSymlink = Kind(unixfs.TSymlink)
+)
+
+type FsError interface {
+	error
+}
+
+var (
+	ErrNoLink         = FsError(errors.New("not a symlink"))
+	ErrInvalidHandle  = FsError(errors.New("invalid handle"))
+	ErrNoKey          = FsError(errors.New("key not found"))
+	ErrInvalidPath    = FsError(errors.New("invalid path"))
+	ErrInvalidArg     = FsError(errors.New("invalid argument"))
+	ErrReadOnly       = FsError(errors.New("read only section"))
+	ErrIOType         = FsError(errors.New("node does not impliment requested interface"))
+	ErrUnexpected     = FsError(errors.New("unexpected node type"))
+	ErrNotInitialized = FsError(errors.New("node metadata is not initialized"))
+	ErrRoot           = FsError(errors.New("root initialization exception"))
+	ErrRecurse        = FsError(errors.New("hit recursion limit"))
+	//
+	ErrNoHandler = FsError(errors.New("no handler registered for this request"))
 )
 
 // Provides standard convention wrappers around an index
 type FileSystem interface {
 	Index // a namespace registry that is used to parse `name` strings into `FsNode`s
 
 	// Create node using respective API for its namespace
-	Create(ctx context.Context, name string, nodeType FsType) error
+	Create(ctx context.Context, name string, nodeType Kind) error
 
 	/* XXX: see PR discussion; we should avoid context.Value if we can; different requests require different arity, which may be a problem
 	Request specific parameters are passed via context key's and values, at an API level
@@ -38,7 +74,7 @@ type FileSystem interface {
 	// caller provides values necessary to complete the request (if any), inside the context
 	Remove(ctx context.Context, name string) error
 
-	OpenFile(name string, flags flags, perm os.FileMode) (FsFile, error)
+	OpenFile(name string, flags Flags, perm os.FileMode) (FsFile, error)
 	OpenDirectory(path string) (FsDirectory, error)
 	OpenReference(string) (FsReference, error)
 }
@@ -47,6 +83,8 @@ type Index interface {
 	sync.Locker
 	// mounts the parser function on the filesystem at "namespace"
 	// returns "unmount" closer
+
+	// rename consider: Bind(Plan9, Spring)
 	Mount(namespace string, nodeParser ParseFn) (unmount io.Closer, err error)
 	// NOTE: it may be better to return the equivalent of a "KeepAlive" function rather than a closer
 	// if the caller disappears, we'll never release
@@ -77,6 +115,13 @@ type Index interface {
 
 type FsNode interface {
 	corepath.Path
+	Version() uint
+	// Cid shall return a cid for the FsNode itself
+	// the purpose is to allow for cache coherency between API boundaries
+	// simillar to Plan9's `qid` and `version` fields
+	// if CID is the same between requests, assume cache safe
+	Cid() cid.Cid
+
 	Metadata(context.Context) (Metadata, error)
 	//RWLocker Maybe?
 
@@ -87,7 +132,7 @@ type FsNode interface {
 	YieldIo(ctx context.Context) (io interface{}, err error)
 
 	Remove(context.Context) error
-	Create(context.Context, FsType) error // should this return an FsNode?
+	Create(context.Context, Kind) error // should this return an FsNode?
 }
 
 /* TODO: Move to fuse or delete
@@ -122,19 +167,13 @@ type Metadata interface {
 	// Go-uint (4 byte minimum)
 	// There's no reason for this to be signed outside of C and POSIX as far as I can tell
 
-
-	// Cid shall return a cid for the FsNode itself
-	// the purpose is to allow for cache coherency between API boundaries
-	// simillar to Plan9's `version` field
-	// if anything has changed, it is implied the Cid has changed
-	Cid() cid.Cid
-	
 	//TODO: rename? IPLD uses "kind" for these names; Kind() FsKind
-	Type() FsType 
+	Type() Kind
+	Flags() Flags
 
 	//TODO: consider renaming Cid() -> Version(); Type() -> Format()
 	//lines up better with both Plan9 and IPLD
-	
+
 	//Cid() cid.Cid // can return nil
 }