Skip to content

G
go-ipfs
提交 c364b4c3 作者: Brian Tiger Chow
操作

refactor(fsrepo): extract configCompoenent 

The struct was getting unmanageable. extracted the config component to
reduce complexity. The datastore will be written as another component.
上级 9acc0246
正在显示 包含 189 行增加 和 87 行删除
repo/fsrepo/config_component.go 0 → 100644
package fsrepo
import (
common "github.com/jbenet/go-ipfs/repo/common"
config "github.com/jbenet/go-ipfs/repo/config"
util "github.com/jbenet/go-ipfs/util"
)
var _ component = &configComponent{}
// configComponent abstracts the config component of the FSRepo.
// NB: create with makeConfigComponent function.
type configComponent struct {
path string // required at instantiation
config *config.Config // assigned on Open()
}
// makeConfigComponent instantiates a valid configComponent.
func makeConfigComponent(path string) configComponent {
return configComponent{path: path}
}
// fsrepoConfigInit initializes the FSRepo's configComponent.
func initConfigComponent(path string, conf *config.Config) error {
if configComponentIsInitialized(path) {
return nil
}
configFilename, err := config.Filename(path)
if err != nil {
return err
}
// initialization is the one time when it's okay to write to the config
// without reading the config from disk and merging any user-provided keys
// that may exist.
if err := writeConfigFile(configFilename, conf); err != nil {
return err
}
return nil
}
// Open returns an error if the config file is not present.
func (c *configComponent) Open() error {
configFilename, err := config.Filename(c.path)
if err != nil {
return err
}
conf, err := load(configFilename)
if err != nil {
return err
}
c.config = conf
return nil
}
// Close satisfies the fsrepoComponent interface.
func (c *configComponent) Close() error {
return nil // config doesn't need to be closed.
}
func (c *configComponent) Config() *config.Config {
return c.config
}
// SetConfig updates the config file.
func (c *configComponent) SetConfig(updated *config.Config) error {
return c.setConfigUnsynced(updated)
}
// GetConfigKey retrieves only the value of a particular key.
func (c *configComponent) GetConfigKey(key string) (interface{}, error) {
filename, err := config.Filename(c.path)
if err != nil {
return nil, err
}
var cfg map[string]interface{}
if err := readConfigFile(filename, &cfg); err != nil {
return nil, err
}
return common.MapGetKV(cfg, key)
}
// SetConfigKey writes the value of a particular key.
func (c *configComponent) SetConfigKey(key string, value interface{}) error {
filename, err := config.Filename(c.path)
if err != nil {
return err
}
var mapconf map[string]interface{}
if err := readConfigFile(filename, &mapconf); err != nil {
return err
}
if err := common.MapSetKV(mapconf, key, value); err != nil {
return err
}
if err := writeConfigFile(filename, mapconf); err != nil {
return err
}
// in order to get the updated values, read updated config from the
// file-system.
conf, err := config.FromMap(mapconf)
if err != nil {
return err
}
return c.setConfigUnsynced(conf) // TODO roll this into this method
}
// configComponentIsInitialized returns true if the repo is initialized at
// provided |path|.
func configComponentIsInitialized(path string) bool {
configFilename, err := config.Filename(path)
if err != nil {
return false
}
if !util.FileExists(configFilename) {
return false
}
return true
}
// setConfigUnsynced is for private use.
func (r *configComponent) setConfigUnsynced(updated *config.Config) error {
configFilename, err := config.Filename(r.path)
if err != nil {
return err
}
// to avoid clobbering user-provided keys, must read the config from disk
// as a map, write the updated struct values to the map and write the map
// to disk.
var mapconf map[string]interface{}
if err := readConfigFile(configFilename, &mapconf); err != nil {
return err
}
m, err := config.ToMap(updated)
if err != nil {
return err
}
for k, v := range m {
mapconf[k] = v
}
if err := writeConfigFile(configFilename, mapconf); err != nil {
return err
}
*r.config = *updated // copy so caller cannot modify this private config
return nil
}
repo/fsrepo/fsrepo.go
......@@ -10,11 +10,9 @@ import (
"sync"
repo "github.com/jbenet/go-ipfs/repo"
common "github.com/jbenet/go-ipfs/repo/common"
config "github.com/jbenet/go-ipfs/repo/config"
lockfile "github.com/jbenet/go-ipfs/repo/fsrepo/lock"
opener "github.com/jbenet/go-ipfs/repo/fsrepo/opener"
util "github.com/jbenet/go-ipfs/util"
debugerror "github.com/jbenet/go-ipfs/util/debugerror"
)
......@@ -51,15 +49,21 @@ type FSRepo struct {
// config is loaded when FSRepo is opened and kept up to date when the
// FSRepo is modified.
// TODO test
config *config.Config
configComponent configComponent
}
type component interface {
Open() error
io.Closer
}
// At returns a handle to an FSRepo at the provided |path|.
func At(repoPath string) *FSRepo {
// This method must not have side-effects.
return &FSRepo{
path: path.Clean(repoPath),
state: unopened, // explicitly set for clarity
path: path.Clean(repoPath),
configComponent: makeConfigComponent(repoPath),
state: unopened, // explicitly set for clarity
}
}
......@@ -88,16 +92,10 @@ func Init(path string, conf *config.Config) error {
if isInitializedUnsynced(path) {
return nil
}
configFilename, err := config.Filename(path)
if err != nil {
return err
}
// initialization is the one time when it's okay to write to the config
// without reading the config from disk and merging any user-provided keys
// that may exist.
if err := writeConfigFile(configFilename, conf); err != nil {
if err := initConfigComponent(path, conf); err != nil {
return err
}
return nil
}
......@@ -151,15 +149,11 @@ func (r *FSRepo) Open() error {
return err
}
configFilename, err := config.Filename(r.path)
if err != nil {
return err
}
conf, err := load(configFilename)
if err != nil {
return err
for _, opener := range r.components() {
if err := opener.Open(); err != nil {
return err
}
}
r.config = conf
// datastore
dspath, err := config.DataStorePath("")
......@@ -189,6 +183,12 @@ func (r *FSRepo) Close() error {
if r.state != opened {
return debugerror.Errorf("repo is %s", r.state)
}
for _, closer := range r.components() {
if err := closer.Close(); err != nil {
return err
}
}
return transitionToClosed(r)
}
......@@ -209,7 +209,7 @@ func (r *FSRepo) Config() *config.Config {
if r.state != opened {
panic(fmt.Sprintln("repo is", r.state))
}
return r.config
return r.configComponent.Config()
}
// SetConfig updates the FSRepo's config.
......@@ -219,7 +219,7 @@ func (r *FSRepo) SetConfig(updated *config.Config) error {
packageLock.Lock()
defer packageLock.Unlock()
return r.setConfigUnsynced(updated)
return r.configComponent.SetConfig(updated)
}
// GetConfigKey retrieves only the value of a particular key.
......@@ -230,15 +230,7 @@ func (r *FSRepo) GetConfigKey(key string) (interface{}, error) {
if r.state != opened {
return nil, debugerror.Errorf("repo is %s", r.state)
}
filename, err := config.Filename(r.path)
if err != nil {
return nil, err
}
var cfg map[string]interface{}
if err := readConfigFile(filename, &cfg); err != nil {
return nil, err
}
return common.MapGetKV(cfg, key)
return r.configComponent.GetConfigKey(key)
}
// SetConfigKey writes the value of a particular key.
......@@ -249,25 +241,7 @@ func (r *FSRepo) SetConfigKey(key string, value interface{}) error {
if r.state != opened {
return debugerror.Errorf("repo is %s", r.state)
}
filename, err := config.Filename(r.path)
if err != nil {
return err
}
var mapconf map[string]interface{}
if err := readConfigFile(filename, &mapconf); err != nil {
return err
}
if err := common.MapSetKV(mapconf, key, value); err != nil {
return err
}
if err := writeConfigFile(filename, mapconf); err != nil {
return err
}
conf, err := config.FromMap(mapconf)
if err != nil {
return err
}
return r.setConfigUnsynced(conf)
return r.configComponent.SetConfigKey(key, value)
}
var _ io.Closer = &FSRepo{}
......@@ -279,7 +253,19 @@ func IsInitialized(path string) bool {
// Init or Remove the repo while this call is in progress.
packageLock.Lock()
defer packageLock.Unlock()
return isInitializedUnsynced(path)
// componentInitCheckers are functions that indicate whether the component
// is isInitialized
var componentInitCheckers = []func(path string) bool{
configComponentIsInitialized,
// TODO add datastore component initialization checker
}
for _, isInitialized := range componentInitCheckers {
if !isInitialized(path) {
return false
}
}
return true
}
// private methods below this point. NB: packageLock must held by caller.
......@@ -287,14 +273,7 @@ func IsInitialized(path string) bool {
// isInitializedUnsynced reports whether the repo is initialized. Caller must
// hold openerCounter lock.
func isInitializedUnsynced(path string) bool {
configFilename, err := config.Filename(path)
if err != nil {
return false
}
if !util.FileExists(configFilename) {
return false
}
return true
return configComponentIsInitialized(path)
}
// initCheckDir ensures the directory exists and is writable
......@@ -346,32 +325,10 @@ func transitionToClosed(r *FSRepo) error {
return nil
}
// setConfigUnsynced is for private use. Callers must hold the packageLock.
func (r *FSRepo) setConfigUnsynced(updated *config.Config) error {
if r.state != opened {
return fmt.Errorf("repo is", r.state)
}
configFilename, err := config.Filename(r.path)
if err != nil {
return err
}
// to avoid clobbering user-provided keys, must read the config from disk
// as a map, write the updated struct values to the map and write the map
// to disk.
var mapconf map[string]interface{}
if err := readConfigFile(configFilename, &mapconf); err != nil {
return err
// components returns the FSRepo's constituent components
func (r *FSRepo) components() []component {
return []component{
&r.configComponent,
// TODO add datastore
}
m, err := config.ToMap(updated)
if err != nil {
return err
}
for k, v := range m {
mapconf[k] = v
}
if err := writeConfigFile(configFilename, mapconf); err != nil {
return err
}
*r.config = *updated // copy so caller cannot modify this private config
return nil
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论