plugin/fs: Betterer init/config

plugin/plugins/filesystem/client/client.go

@@ -1,9 +1,13 @@
 package p9client
 
 import (
+	gopath "path"
+	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/hugelgupf/p9/p9"
+	config "github.com/ipfs/go-ipfs-config"
 	"github.com/ipfs/go-ipfs/plugin/plugins/filesystem"
 	logging "github.com/ipfs/go-log"
 	"github.com/multiformats/go-multiaddr"
@@ -22,14 +26,12 @@ func Dial(options ...Option) (*p9.Client, error) {
 		op(ops)
 	}
 
+	//TODO: this should probably be the callers responsibility
 	if ops.address == filesystem.DefaultListenAddress {
-		// TODO: kludge
-		serviceConf, err := filesystem.XXX_GetFSConf()
-		if err != nil {
+		var err error
+		if ops.address, err = expandDefault(); err != nil {
 			return nil, err
 		}
-
-		ops.address = serviceConf.Service[filesystem.DefaultService]
 	}
 
 	ma, err := multiaddr.NewMultiaddr(ops.address)
@@ -46,6 +48,32 @@ func Dial(options ...Option) (*p9.Client, error) {
 	return p9.NewClient(conn, filesystem.DefaultMSize, filesystem.DefaultVersion)
 }
 
+func expandDefault() (string, error) {
+	_, sockName := gopath.Split(filesystem.DefaultListenAddress)
+	target, err := config.Path("", sockName)
+	if err != nil {
+		return target, err
+	}
+
+	if !filepath.IsAbs(target) {
+		if target, err = filepath.Abs(target); err != nil {
+			return target, err
+		}
+	}
+
+	if runtime.GOOS == "windows" {
+		//TODO [manet]: doesn't like drive letters
+		//XXX: so for now we decap drive-spec-like paths and use the current working drive letter, relatively
+		if len(target) > 2 && target[1] == ':' {
+			target = target[2:]
+		}
+		target = filepath.ToSlash(target)
+	}
+
+	target = gopath.Join("/unix", target)
+	return target, nil
+}
+
 func ReadDir(path string, fsRef p9.File, offset uint64) ([]p9.Dirent, error) {
 	components := strings.Split(strings.TrimPrefix(path, "/"), "/")
 	if len(components) == 1 && components[0] == "" {

plugin/plugins/filesystem/filesystem.go

@@ -2,7 +2,8 @@ package filesystem
 
 import (
 	"context"
-	"errors"
+	"encoding/json"
+	"path/filepath"
 
 	"github.com/hugelgupf/p9/p9"
 	plugin "github.com/ipfs/go-ipfs/plugin"
@@ -22,11 +23,11 @@ var Plugins = []plugin.Plugin{
 var _ plugin.PluginDaemon = (*FileSystemPlugin)(nil)
 
 type FileSystemPlugin struct {
-	ctx      context.Context
-	cancel   context.CancelFunc
-	listener manet.Listener
+	ctx    context.Context
+	cancel context.CancelFunc
 
-	disabled bool
+	addr     multiaddr.Multiaddr
+	listener manet.Listener
 }
 
 func (*FileSystemPlugin) Name() string {
@@ -37,48 +38,61 @@ func (*FileSystemPlugin) Version() string {
 	return PluginVersion
 }
 
-func (fs *FileSystemPlugin) Init() error {
+func (fs *FileSystemPlugin) Init(env *plugin.Environment) error {
+	logger.Info("Initialising 9p resource server...")
+	if !filepath.IsAbs(env.Repo) {
+		absRepo, err := filepath.Abs(env.Repo)
+		if err != nil {
+			return err
+		}
+		env.Repo = absRepo
+	}
+
+	cfg := &Config{}
+	if env.Config != nil {
+		byteRep, err := json.Marshal(env.Config)
+		if err != nil {
+			return err
+		}
+		if err = json.Unmarshal(byteRep, cfg); err != nil {
+			return err
+		}
+	} else {
+		cfg = defaultConfig(env.Repo)
+	}
+
+	var err error
+	fs.addr, err = multiaddr.NewMultiaddr(cfg.Service[DefaultService])
+	if err != nil {
+		return err
+	}
+
 	fs.ctx, fs.cancel = context.WithCancel(context.Background())
+	logger.Info("9p resource server okay for launch")
 	return nil
 }
 
 var (
-	logger      logging.EventLogger
-	errDisabled = errors.New("this experiment is disabled, enable with `ipfs config --json Experimental.FileSystemEnabled true`")
+	logger logging.EventLogger
 )
 
 func init() {
 	logger = logging.Logger("plugin/filesystem")
 }
 
 func (fs *FileSystemPlugin) Start(core coreiface.CoreAPI) error {
-	logger.Info("Initialising 9p resource server...")
-	fs.disabled = true
-
-	serviceConfig, err := XXX_GetFSConf()
-	if err != nil {
-		if err == errDisabled {
-			logger.Warning(errDisabled)
-			return nil
-		}
-		return err
-	}
+	logger.Info("Starting 9p resource server...")
 
-	ma, err := multiaddr.NewMultiaddr(serviceConfig.Service[DefaultService])
-	if err != nil {
-		logger.Errorf("9P multiaddr error: %s\n", err)
-		return err
-	}
-
-	if fs.listener, err = manet.Listen(ma); err != nil {
+	var err error
+	if fs.listener, err = manet.Listen(fs.addr); err != nil {
 		logger.Errorf("9P listen error: %s\n", err)
 		return err
 	}
 
-	// construct 9p resource server
+	// construct 9P resource server
 	p9pFSS, err := fsnodes.NewRoot(fs.ctx, core, logger)
 	if err != nil {
-		logger.Errorf("9P construction error: %s\n", err)
+		logger.Errorf("9P root construction error: %s\n", err)
 		return err
 	}
 
@@ -91,16 +105,11 @@ func (fs *FileSystemPlugin) Start(core coreiface.CoreAPI) error {
 		}
 	}()
 
-	fs.disabled = false
-	logger.Infof("9P service started on %s\n", fs.listener.Addr())
+	logger.Infof("9P service is listening on %s\n", fs.listener.Addr())
 	return nil
 }
 
 func (fs *FileSystemPlugin) Close() error {
-	if fs.disabled {
-		return nil
-	}
-
 	//TODO: fmt.Println("Closing file system handles...")
 	logger.Info("9P server requested to close")
 	fs.cancel()

plugin/plugins/filesystem/utils.go

@@ -1,13 +1,9 @@
 package filesystem
 
 import (
-	"os"
 	gopath "path"
 	"path/filepath"
 	"runtime"
-
-	config "github.com/ipfs/go-ipfs-config"
-	cserial "github.com/ipfs/go-ipfs-config/serialize"
 )
 
 const (
@@ -33,76 +29,23 @@ type Config struct { // NOTE: unstable/experimental
 	Service map[string]string
 }
 
-func defaultConfig() (*Config, error) {
+func defaultConfig(storagePath string) *Config {
 	serviceMap := make(map[string]string)
-	target, err := config.Path("", sockName)
-	if err != nil {
-		return nil, err
-	}
 
+	sockTarget := gopath.Join(storagePath, sockName)
 	if runtime.GOOS == "windows" {
-		if target, err = windowsToUnixFriendly(target); err != nil {
-			return nil, err
-		}
+		sockTarget = windowsToUnixFriendly(sockTarget)
 	}
 
-	serviceMap["9P"] = gopath.Join("/unix", target)
-	return &Config{serviceMap}, nil
+	serviceMap[DefaultService] = gopath.Join("/unix", sockTarget)
+	return &Config{serviceMap}
 }
 
-//TODO: better name
-func XXX_GetFSConf() (*Config, error) {
-	return configFromPlugin(PluginName)
-}
-
-func windowsToUnixFriendly(target string) (string, error) {
-	if !filepath.IsAbs(target) {
-		var err error
-		if target, err = filepath.Abs(target); err != nil {
-			return target, err
-		}
-	}
-
+func windowsToUnixFriendly(target string) string {
 	//TODO [manet]: doesn't like drive letters
 	//XXX: so for now we decap drive-spec-like paths and use the current working drive letter, relatively
-	if len(target) > 3 && target[1] == ':' {
-		target = target[3:]
-	}
-	return filepath.ToSlash(target), nil
-}
-
-func configFromPlugin(pluginName string) (*Config, error) {
-	//TODO: after experiment, make sure this is populated from conf file, not initialised here
-	cfgPath, err := config.Filename("")
-	if err != nil {
-		return nil, err
-	}
-
-	cfg, err := cserial.Load(cfgPath)
-	if err != nil {
-		return nil, err
-	}
-
-	pluginCfg := cfg.Plugins.Plugins[PluginName]
-	if pluginCfg.Disabled {
-		return nil, errDisabled
-	}
-
-	serviceConfig, ok := pluginCfg.Config.(*Config)
-	if !ok {
-		if serviceConfig, err = defaultConfig(); err != nil {
-			return nil, err
-		}
+	if len(target) > 2 && target[1] == ':' {
+		target = target[2:]
 	}
-
-	if addr := os.Getenv(EnvAddr); addr != "" {
-		serviceConfig.Service[DefaultService] = addr
-	}
-
-	// assume user supplied env vars are set and expand them as-is
-	for service, target := range serviceConfig.Service {
-		serviceConfig.Service[service] = os.ExpandEnv(target)
-	}
-
-	return serviceConfig, nil
+	return filepath.ToSlash(target)
 }