opt mdb

base/aaa/totp.go

@@ -68,7 +68,7 @@ func init() {
 				m.Push(mdb.EXPIRE, period-time.Now().Unix()%period)
 				m.Push(mdb.VALUE, _totp_get(value[SECRET], period, kit.Int(value[NUMBER])))
 				if len(arg) > 0 {
-					m.PushQRCode(mdb.SCAN, kit.Format(m.Config(mdb.LINK), value[mdb.NAME], value[SECRET]))
+					m.PushQRCode(mdb.SCAN, kit.Format(mdb.Config(m, mdb.LINK), value[mdb.NAME], value[SECRET]))
 					m.Echo(m.Append(mdb.VALUE))
 				} else {
 					m.PushAction(mdb.REMOVE)

base/aaa/user.go

@@ -63,7 +63,7 @@ func init() {
 			LOGIN: {Name: "login username* password", Hand: func(m *ice.Message, arg ...string) {
 				_user_login(m, m.Option(USERNAME), m.Option(PASSWORD))
 			}},
-		}, mdb.HashSearchAction(mdb.SHORT, USERNAME, mdb.FIELD, "time,username,usernick,userzone,userrole"), mdb.ImportantDataAction())},
+		}, mdb.HashAction(mdb.SHORT, USERNAME, mdb.FIELD, "time,username,usernick,userzone,userrole"), mdb.ImportantDataAction())},
 	})
 }
 

base/cli/forever.go

@@ -67,10 +67,7 @@ func init() {
 					defer logs.Println(ice.EXIT)
 					break
 				}
-				if logs.Println(); m.Sleep("1s").Config("log.save") == ice.TRUE {
+				logs.Println()
-					back := kit.Format("var/log.%s", logs.Now().Format("20060102_150405"))
-					m.Cmd(SYSTEM, "cp", "-r", "var/log", back, ice.Maps{CMD_OUTPUT: ""})
-				}
 			}
 		}},
 	})

base/cli/mirrors.go

@@ -28,7 +28,7 @@ func init() {
 		MIRRORS: {Name: "mirrors cli auto", Help: "软件镜像", Actions: ice.MergeActions(ice.Actions{
 			mdb.INSERT: {Name: "insert cli* osid cmd*"},
 			CMD: {Name: "cmd cli osid", Hand: func(m *ice.Message, arg ...string) {
-				osid := kit.Select(m.Conf(RUNTIME, kit.Keys(HOST, OSID)), m.Option(OSID))
+				osid := kit.Select(mdb.Conf(m, RUNTIME, kit.Keys(HOST, OSID)), m.Option(OSID))
 				mdb.ZoneSelectCB(m, m.Option(CLI), func(value ice.Map) {
 					if osid != "" && strings.Contains(osid, kit.Format(value[OSID])) {
 						m.Cmdy(kit.Split(kit.Format(value[CMD])))

base/cli/runtime.go

@@ -124,9 +124,7 @@ const (
 	MAKE_DOMAIN = "make.domain"
 )
 
-var ENV_LIST = []string{
+var ENV_LIST = []string{TERM, SHELL, CTX_SHY, CTX_COM, CTX_DEV, CTX_OPS, CTX_ARG, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER, CTX_DAEMON}
-	TERM, SHELL, CTX_SHY, CTX_COM, CTX_DEV, CTX_OPS, CTX_ARG, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER, CTX_DAEMON,
-}
 
 const (
 	HOSTNAME = "hostname"
@@ -147,16 +145,16 @@ const RUNTIME = "runtime"
 
 func init() {
 	Index.MergeCommands(ice.Commands{
-		RUNTIME: {Name: "runtime info=bootinfo,ifconfig,hostinfo,hostname,userinfo,procinfo,diskinfo,api,cli,cmd,env,path,chain auto upgrade", Help: "运行环境", Actions: ice.MergeActions(ice.Actions{
+		RUNTIME: {Name: "runtime info=bootinfo,ifconfig,hostname,hostinfo,userinfo,procinfo,diskinfo,api,cli,cmd,env,path,chain auto", Help: "运行环境", Actions: ice.MergeActions(ice.Actions{
 			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { _runtime_init(m) }},
 			IFCONFIG:     {Hand: func(m *ice.Message, arg ...string) { m.Cmdy("tcp.host") }},
-			HOSTINFO:     {Hand: func(m *ice.Message, arg ...string) { _runtime_hostinfo(m) }},
 			HOSTNAME: {Hand: func(m *ice.Message, arg ...string) {
 				if len(arg) > 0 {
-					ice.Info.Hostname = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), m.Conf(RUNTIME, kit.Keys(NODE, mdb.NAME), arg[0]))
+					ice.Info.Hostname = mdb.Conf(m, RUNTIME, kit.Keys(BOOT, HOSTNAME), mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.NAME), arg[0]))
 				}
 				m.Echo(ice.Info.Hostname)
 			}},
+			HOSTINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_hostinfo(m) }},
 			USERINFO: {Hand: func(m *ice.Message, arg ...string) { m.Split(m.Cmdx(SYSTEM, "who"), "user term time") }},
 			PROCINFO: {Hand: func(m *ice.Message, arg ...string) {
 				msg := m.Cmd("", HOSTINFO)
@@ -165,12 +163,17 @@ func init() {
 			}},
 			PROCKILL: {Help: "结束进程", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(gdb.SIGNAL, gdb.STOP, m.Option("PID")).ProcessRefresh() }},
 			MAXPROCS: {Hand: func(m *ice.Message, arg ...string) {
-				if len(arg) > 0 {
+				kit.If(len(arg) > 0, func() { runtime.GOMAXPROCS(kit.Int(mdb.Conf(m, RUNTIME, kit.Keys(HOST, MAXPROCS), arg[0]))) })
-					runtime.GOMAXPROCS(kit.Int(m.Conf(RUNTIME, kit.Keys(HOST, MAXPROCS), arg[0])))
-				}
 				m.Echo("%d", runtime.GOMAXPROCS(0))
 			}},
 			DISKINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_diskinfo(m) }},
+			MAKE_DOMAIN: {Hand: func(m *ice.Message, arg ...string) {
+				if os.Getenv(CTX_DEV) == "" || os.Getenv(CTX_POD) == "" {
+					m.Echo(mdb.Conf(m, RUNTIME, MAKE_DOMAIN))
+				} else {
+					m.Echo(kit.MergePOD(os.Getenv(CTX_DEV), os.Getenv(CTX_POD)))
+				}
+			}},
 			API: {Hand: func(m *ice.Message, arg ...string) {
 				kit.For(ice.Info.Route, func(k, v string) { m.Push(nfs.PATH, k).Push(nfs.FILE, v) })
 				m.StatusTimeCount().Sort(nfs.PATH)
@@ -190,38 +193,19 @@ func init() {
 				})
 				m.StatusTimeCount().Sort(mdb.NAME)
 			}},
-			MAKE_DOMAIN: {Hand: func(m *ice.Message, arg ...string) {
-				if os.Getenv(CTX_DEV) == "" || os.Getenv(CTX_POD) == "" {
-					m.Echo(m.Conf(RUNTIME, MAKE_DOMAIN))
-				} else {
-					m.Echo(kit.MergePOD(os.Getenv(CTX_DEV), os.Getenv(CTX_POD)))
-				}
-			}},
 			nfs.PATH: {Hand: func(m *ice.Message, arg ...string) {
-				for _, p := range _path_split(os.Getenv(PATH)) {
+				kit.For(_path_split(os.Getenv(PATH)), func(p string) { m.Push(nfs.PATH, p) })
-					m.Push(nfs.PATH, p)
-				}
 			}},
 			"chain": {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.FormatChain()) }},
-			"upgrade": {Hand: func(m *ice.Message, arg ...string) {
-				file := kit.Keys("ice", runtime.GOOS, runtime.GOARCH)
-				_file := file
-				if runtime.GOOS == WINDOWS {
-					_file = file + "." + m.Time() + ".exe"
-				}
-				m.Cmd("web.spide", "dev", "save", _file, "GET", ice.Info.Make.Domain+"/publish/"+file)
-			}},
 		}, ctx.ConfAction("")), Hand: func(m *ice.Message, arg ...string) {
-			if len(arg) > 0 && arg[0] == BOOTINFO {
+			kit.If(len(arg) > 0 && arg[0] == BOOTINFO, func() { arg = arg[1:] })
-				arg = arg[1:]
-			}
 			m.Cmdy(ctx.CONFIG, RUNTIME, arg)
 			ctx.DisplayStoryJSON(m)
 		}},
 	})
 }
 func NodeInfo(m *ice.Message, arg ...string) {
-	m.Conf(RUNTIME, kit.Keys(NODE, mdb.TIME), m.Time())
+	mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.TIME), m.Time())
 	ice.Info.NodeName = mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.NAME), kit.Select(ice.Info.NodeName, arg, 0))
 	ice.Info.NodeType = mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.TYPE), kit.Select(ice.Info.NodeType, arg, 1))
 }

base/ctx/config.go

@@ -70,12 +70,12 @@ func _config_make(m *ice.Message, key string, arg ...string) {
 		if strings.HasPrefix(arg[1], ice.AT) {
 			arg[1] = msg.Cmdx(nfs.CAT, arg[1][1:])
 		}
-		msg.Confv(key, arg[0], kit.Parse(nil, "", arg[1:]...))
+		mdb.Confv(msg, key, arg[0], kit.Parse(nil, "", arg[1:]...))
 	}
 	if len(arg) > 0 {
-		m.Echo(kit.Formats(msg.Confv(key, arg[0])))
+		m.Echo(kit.Formats(mdb.Confv(msg, key, arg[0])))
 	} else {
-		m.Echo(kit.Formats(msg.Confv(key)))
+		m.Echo(kit.Formats(mdb.Confv(msg, key)))
 	}
 }
 func _config_list(m *ice.Message) {
@@ -96,28 +96,27 @@ const CONFIG = "config"
 
 func init() {
 	Index.MergeCommands(ice.Commands{
-		CONFIG: {Name: "config key auto remove", Help: "配置", Actions: ice.Actions{
+		CONFIG: {Name: "config key auto export import trash", Help: "配置", Actions: ice.Actions{
-			SAVE: {Hand: func(m *ice.Message, arg ...string) { _config_save(m, arg[0], arg[1:]...) }},
+			SAVE:       {Hand: func(m *ice.Message, arg ...string) { _config_save(m, arg[0], arg[1:]...) }},
-			LOAD: {Hand: func(m *ice.Message, arg ...string) { _config_load(m, arg[0], arg[1:]...) }},
+			LOAD:       {Hand: func(m *ice.Message, arg ...string) { _config_load(m, arg[0], arg[1:]...) }},
+			mdb.EXPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(mdb.EXPORT, arg[0], "", mdb.HASH) }},
+			mdb.IMPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(mdb.IMPORT, arg[0], "", mdb.HASH) }},
+			nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) {
+				m.Cmd(mdb.EXPORT, arg[0], "", mdb.HASH, path.Join(ice.VAR_TRASH, kit.Keys(arg[0])))
+				nfs.Trash(m, path.Join(ice.VAR_DATA, arg[0]))
+				m.Go(func() { m.Cmd(ice.EXIT, 1) })
+			}},
 			mdb.LIST: {Hand: func(m *ice.Message, arg ...string) {
 				list := []ice.Any{}
-				for _, v := range arg[2:] {
+				kit.For(arg[2:], func(v string) { list = append(list, v) })
-					list = append(list, v)
+				mdb.Confv(m, arg[0], arg[1], list)
-				}
-				m.Confv(arg[0], arg[1], list)
-			}},
-			mdb.REMOVE: {Name: "remove key sub", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(mdb.EXPORT, m.Option(mdb.KEY), m.Option(mdb.SUB), mdb.HASH, path.Join(ice.VAR_TRASH, kit.Keys(m.Option(mdb.KEY), m.Option(mdb.SUB))))
-				nfs.Trash(m, path.Join(ice.VAR_DATA, m.Option(mdb.KEY)))
-				m.Go(func() { m.Cmd(ice.EXIT, 1) })
 			}},
 		}, Hand: func(m *ice.Message, arg ...string) {
 			if len(arg) == 0 {
 				_config_list(m)
 			} else {
 				_config_make(m, arg[0], arg[1:]...)
-				DisplayStoryJSON(m)
+				// DisplayStoryJSON(m)
-				m.Action(mdb.REMOVE)
 			}
 		}},
 	})
@@ -148,17 +147,21 @@ func Load(m *ice.Message, arg ...string) *ice.Message {
 	}
 	return m.Cmd(CONFIG, LOAD, m.Prefix(nfs.JSON), arg)
 }
-func ConfAction(args ...ice.Any) ice.Actions {
+func ConfAction(arg ...ice.Any) ice.Actions {
-	return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(args...)}
+	return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(arg...)}
 }
-func ConfigAuto(m *ice.Message, arg ...string) {
+func ConfigSimple(m *ice.Message, key ...string) (res []string) {
-	if cs := m.Target().Configs; cs[m.CommandKey()] == nil {
+	kit.For(kit.Split(kit.Join(key)), func(k string) { res = append(res, k, mdb.Config(m, k)) })
-		cs[m.CommandKey()] = &ice.Config{Value: kit.Data()}
+	return
-		ice.Info.Load(m, m.CommandKey())
-	}
 }
 func ConfigFromOption(m *ice.Message, arg ...string) {
 	for _, k := range arg {
-		m.Config(k, kit.Select(m.Config(k), m.Option(k)))
+		mdb.Config(m, k, kit.Select(mdb.Config(m, k), m.Option(k)))
 	}
 }
+func OptionFromConfig(m *ice.Message, arg ...string) string {
+	for _, key := range arg {
+		m.Option(key, mdb.Config(m, key))
+	}
+	return m.Option(arg[0])
+}

base/ctx/display.go

@@ -11,11 +11,12 @@ import (
 	"shylinux.com/x/toolkits/logs"
 )
 
-type Message interface {
+type displayMessage interface {
 	Option(key string, arg ...ice.Any) string
+	Action(arg ...ice.Any) *ice.Message
 }
 
-func Display(m Message, file string, arg ...ice.Any) Message {
+func Display(m displayMessage, file string, arg ...ice.Any) displayMessage {
 	if file == "" {
 		file = kit.Keys(kit.FileName(2), nfs.JS)
 	}
@@ -24,13 +25,13 @@ func Display(m Message, file string, arg ...ice.Any) Message {
 	}
 	return DisplayBase(m, file, arg...)
 }
-func DisplayTable(m Message, arg ...ice.Any) Message {
+func DisplayTable(m displayMessage, arg ...ice.Any) displayMessage {
 	return DisplayBase(m, "/plugin/table.js", arg...)
 }
-func DisplayTableCard(m Message, arg ...ice.Any) Message {
+func DisplayTableCard(m displayMessage, arg ...ice.Any) displayMessage {
 	return DisplayTable(m, "style", "card")
 }
-func DisplayStory(m Message, file string, arg ...ice.Any) Message {
+func DisplayStory(m displayMessage, file string, arg ...ice.Any) displayMessage {
 	if file == "" {
 		file = kit.ExtChange(kit.FileName(2), nfs.JS)
 	}
@@ -39,13 +40,13 @@ func DisplayStory(m Message, file string, arg ...ice.Any) Message {
 	}
 	return DisplayBase(m, file, arg...)
 }
-func DisplayStoryJSON(m Message, arg ...ice.Any) Message {
+func DisplayStoryJSON(m displayMessage, arg ...ice.Any) displayMessage {
 	return DisplayStory(m, "json", arg...)
 }
-func DisplayStorySpide(m Message, arg ...ice.Any) Message {
+func DisplayStorySpide(m displayMessage, arg ...ice.Any) displayMessage {
 	return DisplayStory(m, "spide", arg...)
 }
-func DisplayLocal(m Message, file string, arg ...ice.Any) Message {
+func DisplayLocal(m displayMessage, file string, arg ...ice.Any) displayMessage {
 	if file == "" {
 		file = path.Join(kit.PathName(2), kit.Keys(kit.FileName(2), ice.JS))
 	}
@@ -54,7 +55,7 @@ func DisplayLocal(m Message, file string, arg ...ice.Any) Message {
 	}
 	return DisplayBase(m, file, arg...)
 }
-func DisplayBase(m Message, file string, arg ...ice.Any) Message {
+func DisplayBase(m displayMessage, file string, arg ...ice.Any) displayMessage {
 	m.Option(ice.MSG_DISPLAY, kit.MergeURL(kit.Select(kit.ExtChange(file, nfs.JS), file, strings.Contains(file, "?")), arg...))
 	return m
 }

base/gdb/gdb.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	ice "shylinux.com/x/icebergs"
+	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
 )
 
@@ -19,11 +20,11 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
 	enable := mdb.Conf(m, TIMER, kit.Keym("enable")) == ice.TRUE
 	for {
 		select {
-		case <-time.Tick(t):
+		case <-time.Tick(t):
 			if enable {
 				m.Cmd(TIMER, HAPPEN)
 			}
-		case s, ok := &lt;-f.s:
+		case s, ok := <-f.s:
 			if !ok {
 				return true
 			}

base/log/log.go

@@ -37,7 +37,7 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
 				if file == "" {
 					continue
 				}
-				view := m.Confm(VIEW, m.Conf(SHOW, kit.Keys(l.l, VIEW)))
+				view := mdb.Confm(m, VIEW, m.Conf(SHOW, kit.Keys(l.l, VIEW)))
 				bio := m.Confv(FILE, kit.Keys(file, FILE)).(*bufio.Writer)
 				if bio == nil {
 					continue
@@ -105,16 +105,16 @@ var Index = &ice.Context{Name: LOG, Help: "日志模块", Configs: ice.Configs{
 	SHOW: {Name: SHOW, Help: "日志分流", Value: kit.Dict()},
 }, Commands: ice.Commands{
 	ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
-		m.Confm(FILE, nil, func(key string, value ice.Map) {
+		mdb.Confm(m, FILE, nil, func(key string, value ice.Map) {
-			kit.Fetch(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, FILE), key) })
+			kit.For(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, FILE), key) })
 			if f, p, e := logs.CreateFile(kit.Format(value[nfs.PATH])); e == nil {
 				m.Cap(ice.CTX_STREAM, path.Base(p))
 				value[FILE] = bufio.NewWriter(f)
 				m.Logs(nfs.SAVE, nfs.FILE, p)
 			}
 		})
-		m.Confm(VIEW, nil, func(key string, value ice.Map) {
+		mdb.Confm(m, VIEW, nil, func(key string, value ice.Map) {
-			kit.Fetch(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, VIEW), key) })
+			kit.For(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, VIEW), key) })
 		})
 	}},
 	ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) {}},

base/mdb/hash.go

@@ -19,9 +19,7 @@ func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
 	list := map[string]int{}
 	defer func() {
 		delete(list, "")
-		for k, i := range list {
+		kit.For(list, func(k string, i int) { m.Push(field, k).Push(COUNT, i) })
-			m.Push(field, k).Push(COUNT, i)
-		}
 		m.SortIntR(COUNT)
 	}()
 	defer RLock(m, prefix, chain)()
@@ -37,12 +35,11 @@ func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) string {
 		arg = kit.Simple(TIME, m.Time(expire), arg)
 	}
 	if arg[0] == HASH {
-		m.Conf(prefix, kit.Keys(chain, HASH, arg[1]), kit.Data(arg[2:]))
+		m.Echo(arg[1]).Conf(prefix, kit.Keys(chain, HASH, arg[1]), kit.Data(arg[2:]))
-		m.Echo(arg[1])
 	} else {
 		m.Echo(Rich(m, prefix, chain, kit.Data(arg, TARGET, m.Optionv(TARGET))))
 	}
-	SaveImportant(m, prefix, chain, kit.Simple(INSERT, prefix, chain, HASH, TIME, m.Time(), HASH, m.Result(), arg)...)
+	saveImportant(m, prefix, chain, kit.Simple(INSERT, prefix, chain, HASH, HASH, m.Result(), TIME, m.Time(), arg)...)
 	return m.Result()
 }
 func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
@@ -51,8 +48,8 @@ func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
 		if target, ok := kit.GetMeta(val)[TARGET].(io.Closer); ok {
 			target.Close()
 		}
+		saveImportant(m, prefix, chain, kit.Simple(DELETE, prefix, chain, HASH, HASH, key)...)
 		m.Logs(DELETE, KEY, path.Join(prefix, chain), field, value, VALUE, kit.Format(val))
-		SaveImportant(m, prefix, chain, kit.Simple(DELETE, prefix, chain, HASH, HASH, key)...)
 		m.Conf(prefix, kit.Keys(chain, HASH, key), "")
 	})
 }
@@ -60,14 +57,12 @@ func _hash_modify(m *ice.Message, prefix, chain string, field, value string, arg
 	m.Logs(MODIFY, KEY, path.Join(prefix, chain), field, value, arg)
 	defer Lock(m, prefix, chain)()
 	Richs(m, prefix, chain, value, func(key string, val Map) {
-		SaveImportant(m, prefix, chain, kit.Simple(MODIFY, prefix, chain, HASH, HASH, key, arg)...)
+		saveImportant(m, prefix, chain, kit.Simple(MODIFY, prefix, chain, HASH, HASH, key, arg)...)
 		_mdb_modify(m, val, field, arg...)
 	})
 }
 func _hash_select(m *ice.Message, prefix, chain, field, value string) {
-	if field == HASH && value == RANDOM {
+	kit.If(field == HASH && value == RANDOM, func() { value = RANDOMS })
-		value = RANDOMS
-	}
 	defer m.SortTimeR(TIME)
 	fields := _hash_fields(m)
 	defer RLock(m, prefix, chain)()
@@ -90,14 +85,10 @@ func _hash_prunes(m *ice.Message, prefix, chain string, arg ...string) {
 	Richs(m, prefix, chain, FOREACH, func(key string, value Map) {
 		switch value = kit.GetMeta(value); cb := m.OptionCB(PRUNES).(type) {
 		case func(string, Map) bool:
-			if cb(key, value) {
+			kit.If(cb(key, value), func() { m.Push(key, value, fields) })
-				m.Push(key, value, fields)
-			}
 		default:
-			kit.Fetch(arg, func(k, v string) {
+			kit.For(arg, func(k, v string) {
-				if value[k] == v || kit.Value(value, k) == v {
+				kit.If(value[k] == v || kit.Value(value, k) == v, func() { m.Push(key, value, fields) })
-					m.Push(key, value, fields)
-				}
 			})
 		}
 	})
@@ -108,7 +99,7 @@ func _hash_export(m *ice.Message, prefix, chain, file string) {
 	m.Assert(e)
 	defer f.Close()
 	defer m.Echo(p)
-	m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p, COUNT, len(m.Confm(prefix, kit.Keys(chain, HASH))))
+	m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p, COUNT, len(Confm(m, prefix, kit.Keys(chain, HASH))))
 	en := json.NewEncoder(f)
 	if en.SetIndent("", "  "); !m.Warn(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))), EXPORT, prefix) {
 		m.Conf(prefix, kit.Keys(chain, HASH), "")
@@ -121,22 +112,16 @@ func _hash_import(m *ice.Message, prefix, chain, file string) {
 		return
 	}
 	defer f.Close()
-	list := Map{}
+	data := Map{}
-	m.Assert(json.NewDecoder(f).Decode(&list))
+	m.Assert(json.NewDecoder(f).Decode(&data))
-	m.Logs(IMPORT, KEY, path.Join(prefix, chain), FILE, kit.Keys(file, JSON), COUNT, len(list))
+	m.Logs(IMPORT, KEY, path.Join(prefix, chain), FILE, kit.Keys(file, JSON), COUNT, len(data))
-	defer m.Echo("%d", len(list))
+	defer m.Echo("%d", len(data))
-	for k, data := range list {
+	kit.For(data, func(k string, v Any) { m.Confv(prefix, kit.Keys(chain, HASH, k), v) })
-		if m.Confv(prefix, kit.Keys(chain, HASH, k)) == nil {
-			m.Confv(prefix, kit.Keys(chain, HASH, k), data)
-		} else {
-			Rich(m, prefix, chain, data)
-		}
-	}
 }
 
 const (
 	MONTH = "720h"
-	WEEK  = "24h"
+	DAYS  = "72h"
 	HOUR  = "1h"
 )
 const (
@@ -145,8 +130,7 @@ const (
 const HASH = "hash"
 
 func HashAction(arg ...Any) ice.Actions {
-	return ice.Actions{
+	return ice.Actions{ice.CTX_INIT: AutoConfig(append(kit.List(FIELD, HASH_FIELD), arg...)...),
-		ice.CTX_INIT: AutoConfig(append(kit.List(FIELD, HASH_FIELD), arg...)...),
 		ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
 
 		INPUTS: {Hand: func(m *ice.Message, arg ...string) { HashInputs(m, arg) }},
@@ -184,11 +168,11 @@ func HashInputs(m *ice.Message, arg ...Any) *ice.Message {
 	return m.Cmdy(INPUTS, m.PrefixKey(), "", HASH, arg)
 }
 func HashCreate(m *ice.Message, arg ...Any) string {
-	kit.If(len(arg) == 0 || len(kit.Simple(arg)) == 0, func() { arg = append(arg, m.OptionSimple(strings.Replace(HashField(m), "hash,", "", 1))) })
+	kit.If(len(arg) == 0 || len(kit.Simple(arg...)) == 0, func() { arg = append(arg, m.OptionSimple(strings.Replace(HashField(m), "hash,", "", 1))) })
 	return m.Echo(m.Cmdx(append(kit.List(INSERT, m.PrefixKey(), "", HASH, logs.FileLineMeta(-1)), arg...)...)).Result()
 }
 func HashRemove(m *ice.Message, arg ...Any) *ice.Message {
-	if args := kit.Simple(arg); len(args) == 0 {
+	if args := kit.Simple(arg...); len(args) == 0 {
 		arg = append(arg, m.OptionSimple(HashKey(m)))
 	} else if len(args) == 1 {
 		arg = kit.List(HashKey(m), args[0])
@@ -214,7 +198,7 @@ func HashSelect(m *ice.Message, arg ...string) *ice.Message {
 	return m.StatusTime()
 }
 func HashPrunes(m *ice.Message, cb func(Map) bool) *ice.Message {
-	expire := kit.Select(m.Time("-"+kit.Select("72h", m.Config(EXPIRE))), m.Option("before"))
+	expire := kit.Select(m.Time("-"+kit.Select(DAYS, Config(m, EXPIRE))), m.Option("before"))
 	m.OptionCB(PRUNES, func(key string, value Map) bool {
 		if kit.Format(value[TIME]) > expire {
 			return false
@@ -236,32 +220,32 @@ func HashSelects(m *ice.Message, arg ...string) *ice.Message {
 }
 func HashSelectValue(m *ice.Message, cb Any) *ice.Message {
 	m.OptionFields(Config(m, FIELD))
-	defer RLock(m, m.PrefixKey(), "")()
+	defer RLock(m, m.PrefixKey())()
 	Richs(m, m.PrefixKey(), nil, FOREACH, func(key string, value Map) { _mdb_select(m, cb, key, value, nil, nil) })
 	return m
 }
 func HashSelectUpdate(m *ice.Message, key string, cb Any) *ice.Message {
-	defer Lock(m, m.PrefixKey(), "")()
+	defer Lock(m, m.PrefixKey())()
 	Richs(m, m.PrefixKey(), nil, key, func(key string, value Map) { _mdb_select(m, cb, key, value, nil, nil) })
 	return m
 }
 func HashSelectDetail(m *ice.Message, key string, cb Any) (has bool) {
-	defer RLock(m, m.PrefixKey(), "")()
+	defer RLock(m, m.PrefixKey())()
 	Richs(m, m.PrefixKey(), nil, key, func(key string, value Map) {
 		_mdb_select(m, cb, key, value, nil, nil)
 		has = true
 	})
 	return
 }
-func HashSelectDetails(m *ice.Message, key string, cb func(ice.Map) bool) ice.Map {
+func HashSelectDetails(m *ice.Message, key string, cb func(Map) bool) Map {
 	val := kit.Dict()
-	HashSelectDetail(m, key, func(value ice.Map) {
+	HashSelectDetail(m, key, func(value Map) {
-		kit.If(cb(value), func() { kit.For(value, func(k string, v ice.Any) { val[k] = v }) })
+		kit.If(cb(value), func() { kit.For(value, func(k string, v Any) { val[k] = v }) })
 	})
 	return val
 }
 func HashSelectField(m *ice.Message, key string, field string) (value string) {
-	HashSelectDetail(m, key, func(key string, val ice.Map) {
+	HashSelectDetail(m, key, func(key string, val Map) {
 		if field == HASH {
 			value = key
 		} else {
@@ -271,12 +255,12 @@ func HashSelectField(m *ice.Message, key string, field string) (value string) {
 	return
 }
 func HashSelectTarget(m *ice.Message, key string, create Any) (target Any) {
-	HashSelectUpdate(m, key, func(value ice.Map) {
+	HashSelectUpdate(m, key, func(value Map) {
 		target = value[TARGET]
 		if _target, ok := target.([]string); ok && len(_target) == 0 {
 			target = nil
 		}
-		if _target, ok := target.(ice.List); ok && len(_target) == 0 {
+		if _target, ok := target.(List); ok && len(_target) == 0 {
 			target = nil
 		}
 		if _target, ok := target.(Map); ok && len(_target) == 0 {
@@ -286,22 +270,21 @@ func HashSelectTarget(m *ice.Message, key string, create Any) (target Any) {
 			return
 		}
 		switch create := create.(type) {
-		case func(ice.Map) ice.Any:
+		case func(Map) Any:
 			target = create(value)
-		case func(ice.Maps) ice.Any:
+		case func(Maps) Any:
 			target = create(ToMaps(value))
-		case func() ice.Any:
+		case func() Any:
 			target = create()
 		default:
 			m.ErrorNotImplement(create)
-			return
 		}
 		value[TARGET] = target
 	})
 	return
 }
 func HashSelectClose(m *ice.Message) *ice.Message {
-	HashSelectValue(m, func(value ice.Map) {
+	HashSelectValue(m, func(value Map) {
 		if c, ok := value[TARGET].(io.Closer); ok {
 			c.Close()
 		}
@@ -322,7 +305,7 @@ func HashModifyDeferRemove(m *ice.Message, arg ...Any) func() {
 }
 
 func Richs(m *ice.Message, prefix string, chain Any, raw Any, cb Any) (res Map) {
-	cache := m.Confm(prefix, chain)
+	cache := Confm(m, prefix, chain)
 	if cache == nil {
 		return nil
 	}
@@ -330,7 +313,7 @@ func Richs(m *ice.Message, prefix string, chain Any, raw Any, cb Any) (res Map)
 
 }
 func Rich(m *ice.Message, prefix string, chain Any, data Any) string {
-	cache := m.Confm(prefix, chain)
+	cache := Confm(m, prefix, chain)
 	if cache == nil {
 		cache = kit.Data()
 		m.Confv(prefix, chain, cache)

base/mdb/list.go

@@ -17,9 +17,7 @@ func _list_inputs(m *ice.Message, prefix, chain string, field, value string) {
 	list := map[string]int{}
 	defer func() {
 		delete(list, "")
-		for k, i := range list {
+		kit.For(list, func(k string, i int) { m.Push(field, k).Push(COUNT, i) })
-			m.Push(field, k).Push(COUNT, i)
-		}
 		m.SortIntR(COUNT)
 	}()
 	defer RLock(m, prefix, chain)()
@@ -57,9 +55,7 @@ func _list_export(m *ice.Message, prefix, chain, file string) {
 	count, head := 0, kit.Split(ListField(m))
 	Grows(m, prefix, chain, "", "", func(index int, value ice.Map) {
 		if value = kit.GetMeta(value); index == 0 {
-			if len(head) == 0 || head[0] == ice.FIELDS_DETAIL {
+			kit.If(len(head) == 0 || head[0] == ice.FIELDS_DETAIL, func() { head = kit.SortedKey(value) })
-				head = kit.SortedKey(value)
-			}
 			w.Write(head)
 		}
 		w.Write(kit.Simple(head, func(k string) string { return kit.Format(value[k]) }))
@@ -118,18 +114,18 @@ func PageListAction(arg ...ice.Any) ice.Actions {
 	return ice.MergeActions(ice.Actions{
 		SELECT: {Name: "select id auto insert page", Hand: func(m *ice.Message, arg ...string) { PageListSelect(m, arg...) }},
 		NEXT: {Hand: func(m *ice.Message, arg ...string) {
-			NextPage(m, kit.Select(m.Config(COUNT), arg, 0), kit.Slice(arg, 1)...)
+			NextPage(m, kit.Select(Config(m, COUNT), arg, 0), kit.Slice(arg, 1)...)
 		}},
 		PREV: {Hand: func(m *ice.Message, arg ...string) {
-			PrevPageLimit(m, kit.Select(m.Config(COUNT), arg, 0), kit.Slice(arg, 1)...)
+			PrevPageLimit(m, kit.Select(Config(m, COUNT), arg, 0), kit.Slice(arg, 1)...)
 		}},
 	}, ListAction(arg...))
 }
-func ListField(m *ice.Message) string { return kit.Select(LIST_FIELD, m.Config(FIELD)) }
+func ListField(m *ice.Message) string { return kit.Select(LIST_FIELD, Config(m, FIELD)) }
 func ListSelect(m *ice.Message, arg ...string) *ice.Message {
 	m.Fields(len(kit.Slice(arg, 0, 1)), ListField(m))
 	if m.Cmdy(SELECT, m.PrefixKey(), "", LIST, ID, arg); !m.FieldsIsDetail() {
-		return m.StatusTimeCountTotal(m.Config(COUNT))
+		return m.StatusTimeCountTotal(Config(m, COUNT))
 	}
 	return m.StatusTime()
 }

base/mdb/lock.go

@@ -0,0 +1,82 @@
+package mdb
+
+import (
+	"sync"
+
+	ice "shylinux.com/x/icebergs"
+	kit "shylinux.com/x/toolkits"
+	"shylinux.com/x/toolkits/task"
+)
+
+type configMessage interface {
+	Option(key string, arg ...Any) string
+	PrefixKey(...Any) string
+	Confv(...Any) Any
+}
+
+var _lock = task.Lock{}
+var _locks = map[string]*task.Lock{}
+
+func getLock(m configMessage, arg ...string) *task.Lock {
+	key := kit.Select(m.PrefixKey(), kit.Keys(arg))
+	m.Option("_lock", key)
+	defer _lock.Lock()()
+	l, ok := _locks[key]
+	if !ok {
+		l = &task.Lock{}
+		_locks[key] = l
+	}
+	return l
+}
+func Lock(m configMessage, arg ...string) func()  { return getLock(m, arg...).Lock() }
+func RLock(m configMessage, arg ...string) func() { return getLock(m, arg...).RLock() }
+
+func Config(m configMessage, key string, arg ...Any) string {
+	return kit.Format(Configv(m, key, arg...))
+}
+func Configv(m configMessage, key string, arg ...Any) Any {
+	if len(arg) > 0 {
+		Confv(m, m.PrefixKey(), kit.Keym(key), arg[0])
+	}
+	return Confv(m, m.PrefixKey(), kit.Keym(key))
+}
+func Confv(m configMessage, arg ...Any) Any {
+	key := kit.Select(m.PrefixKey(), kit.Format(arg[0]))
+	if ctx, ok := ice.Info.Index[key].(*ice.Context); ok {
+		key = ctx.Prefix(key)
+	}
+	if len(arg) > 2 {
+		defer Lock(m, key)()
+	} else {
+		defer RLock(m, key)()
+	}
+	return m.Confv(arg...)
+}
+func Confm(m configMessage, key string, sub Any, cbs ...Any) Map {
+	val := m.Confv(key, sub)
+	if len(cbs) > 0 {
+		kit.For(val, cbs[0])
+	}
+	value, _ := val.(Map)
+	return value
+}
+func Conf(m configMessage, arg ...Any) string {
+	return kit.Format(Confv(m, arg...))
+}
+
+var cache = sync.Map{}
+
+func Cache(m *ice.Message, key string, add func() Any) Any {
+	if add == nil {
+		cache.Delete(key)
+		return nil
+	}
+	if val, ok := cache.Load(key); ok {
+		return val
+	}
+	if val := add(); val != nil {
+		cache.Store(key, val)
+		return val
+	}
+	return nil
+}

base/mdb/mdb.go

@@ -3,42 +3,19 @@ package mdb
 import (
 	"path"
 	"strings"
-	"sync"
 
 	ice "shylinux.com/x/icebergs"
 	kit "shylinux.com/x/toolkits"
-	"shylinux.com/x/toolkits/task"
 )
 
-type Any = interface{}
+type Any = ice.Any
-type Map = map[string]Any
+type List = ice.List
-type Maps = map[string]string
+type Maps = ice.Maps
-type List = []interface{}
+type Map = ice.Map
 
-func _file_name(m *ice.Message, arg ...string) string {
+func _mdb_modify(m *ice.Message, value Map, field string, arg ...string) {
-	if len(arg) > 3 && strings.Contains(arg[3], ice.PS) {
-		return arg[3]
-	}
-	return path.Join(ice.USR_LOCAL_EXPORT, path.Join(arg[:2]...), arg[2])
-}
-func _mdb_getmeta(m *ice.Message, prefix, chain, key string) string {
-	defer RLock(m, prefix, chain)()
-	return m.Conf(prefix, kit.Keys(chain, kit.Keym(key)))
-}
-func _mdb_modify(m *ice.Message, value ice.Map, field string, arg ...string) {
 	value = kit.GetMeta(value)
-	kit.Fetch(arg, func(k, v string) {
+	kit.For(arg, func(k, v string) { kit.If(k != field, func() { kit.Value(value, k, v) }) })
-		if k != field {
-			kit.Value(value, k, v)
-		}
-	})
-}
-func ToMaps(value ice.Map) ice.Maps {
-	res := Maps{}
-	for k, v := range value {
-		res[k] = kit.Format(v)
-	}
-	return res
 }
 func _mdb_select(m *ice.Message, cb Any, key string, value Map, fields []string, val Map) {
 	switch value, val = kit.GetMeta(value), kit.GetMeta(val); cb := cb.(type) {
@@ -56,7 +33,7 @@ func _mdb_select(m *ice.Message, cb Any, key string, value Map, fields []string,
 		cb(value[TARGET])
 	case func(Maps):
 		cb(ToMaps(value))
-	case string, []string, []ice.Any, nil:
+	case string, []string, []Any, nil:
 		if m.FieldsIsDetail() {
 			m.Push(ice.FIELDS_DETAIL, value)
 		} else {
@@ -66,6 +43,12 @@ func _mdb_select(m *ice.Message, cb Any, key string, value Map, fields []string,
 		m.ErrorNotImplement(cb)
 	}
 }
+func _mdb_export_file(m *ice.Message, arg ...string) string {
+	if len(arg) > 3 && strings.Contains(arg[3], ice.PS) {
+		return arg[3]
+	}
+	return path.Join(ice.USR_LOCAL_EXPORT, path.Join(arg[:2]...), arg[2])
+}
 
 const (
 	DICT = kit.MDB_DICT
@@ -115,13 +98,6 @@ const (
 	CACHE_CLEAR_ON_EXIT = "cache.clear.on.exit"
 )
 const (
-	DETAIL = "detail"
-	RANDOM = "random"
-	ACTION = "action"
-	FIELDS = "fields"
-	PARAMS = "params"
-
-	RECENT = "recent"
 	INPUTS = "inputs"
 	CREATE = "create"
 	REMOVE = "remove"
@@ -133,15 +109,22 @@ const (
 	EXPORT = "export"
 	IMPORT = "import"
 
-	UPLOAD = "upload"
+	DETAIL = "detail"
-	REVERT = "revert"
+	FIELDS = "fields"
-	REPEAT = "repeat"
+	PARAMS = "params"
 
-	NEXT   = "next"
+	ACTION = "action"
-	PREV   = "prev"
+	UPLOAD = "upload"
-	PAGE   = "page"
+	RECENT = "recent"
+	REPEAT = "repeat"
+	REVERT = "revert"
+	RANDOM = "random"
 	OFFEND = "offend"
 
+	PAGE = "page"
+	NEXT = "next"
+	PREV = "prev"
+
 	JSON = "json"
 	CSV  = "csv"
 	SUB  = "sub"
@@ -153,103 +136,83 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: ice.Commands
 	ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {}},
 	ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) {}},
 	INPUTS: {Name: "inputs key sub type field value", Hand: func(m *ice.Message, arg ...string) {
-		const (
+		switch arg[2] {
-			SPACE   = "space"
+		case HASH:
-			CONTEXT = "context"
+			_hash_inputs(m, arg[0], arg[1], kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
-			COMMAND = "command"
+		case ZONE:
-			INDEX   = "index"
+			_zone_inputs(m, arg[0], arg[1], arg[3], kit.Select(NAME, arg, 4), kit.Select("", arg, 5))
-		)
+		case LIST:
-		switch arg[3] = strings.TrimPrefix(arg[3], EXTRA+ice.PT); arg[3] {
+			_list_inputs(m, arg[0], arg[1], kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
-		case ice.POD:
-			m.Cmdy(SPACE)
-		case ice.CTX:
-			m.Cmdy(CONTEXT)
-		case ice.CMD:
-			m.Cmdy(CONTEXT, kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(EXTRA, ice.CTX))), COMMAND)
-		case INDEX:
-			m.Cmdy(COMMAND, SEARCH, COMMAND, kit.Select("", arg, 1), ice.OptionFields(arg[3]))
-		default:
-			switch arg[2] {
-			case ZONE:
-				_zone_inputs(m, arg[0], arg[1], arg[3], kit.Select(NAME, arg, 4), kit.Select("", arg, 5))
-			case HASH:
-				_hash_inputs(m, arg[0], arg[1], kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
-			case LIST:
-				_list_inputs(m, arg[0], arg[1], kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
-			}
 		}
 	}},
 	INSERT: {Name: "insert key sub type arg...", Hand: func(m *ice.Message, arg ...string) {
-		defer m.ProcessRefresh()
 		switch arg[2] {
-		case ZONE:
-			_zone_insert(m, arg[0], arg[1], arg[3], arg[4:]...)
 		case HASH:
 			_hash_insert(m, arg[0], arg[1], arg[3:]...)
+		case ZONE:
+			_zone_insert(m, arg[0], arg[1], arg[3], arg[4:]...)
 		case LIST:
 			_list_insert(m, arg[0], arg[1], arg[3:]...)
 		}
 	}},
 	DELETE: {Name: "delete key sub type field value", Hand: func(m *ice.Message, arg ...string) {
-		defer m.ProcessRefresh()
 		switch arg[2] {
-		case ZONE:
-			// _list_delete(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4], arg[5])
 		case HASH:
 			_hash_delete(m, arg[0], arg[1], arg[3], arg[4])
+		case ZONE:
+			// _list_delete(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4], arg[5])
 		case LIST:
 			// _list_delete(m, arg[0], arg[1], arg[3], arg[4])
 		}
 	}},
 	MODIFY: {Name: "modify key sub type field value arg...", Hand: func(m *ice.Message, arg ...string) {
 		switch arg[2] {
-		case ZONE:
-			_zone_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
 		case HASH:
 			_hash_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
+		case ZONE:
+			_zone_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
 		case LIST:
 			_list_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
 		}
 	}},
 	SELECT: {Name: "select key sub type field value", Hand: func(m *ice.Message, arg ...string) {
 		switch arg[2] {
-		case ZONE:
-			_zone_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select("", arg, 4))
 		case HASH:
 			_hash_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select(FOREACH, arg, 4))
+		case ZONE:
+			_zone_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select("", arg, 4))
 		case LIST:
 			_list_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select("", arg, 4))
 		}
 	}},
 	PRUNES: {Name: "prunes key sub type [field value]...", Hand: func(m *ice.Message, arg ...string) {
 		switch arg[2] {
-		case ZONE:
-			// _list_prunes(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
 		case HASH:
 			_hash_prunes(m, arg[0], arg[1], arg[3:]...)
-			m.Tables(func(value ice.Maps) { _hash_delete(m, arg[0], arg[1], HASH, value[HASH]) })
+			m.Tables(func(value Maps) { _hash_delete(m, arg[0], arg[1], HASH, value[HASH]) })
+		case ZONE:
+			// _list_prunes(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
 		case LIST:
 			// _list_prunes(m, arg[0], arg[1], arg[3:]...)
 		}
 	}},
 	EXPORT: {Name: "export key sub type file", Hand: func(m *ice.Message, arg ...string) {
 		m.OptionDefault(CACHE_LIMIT, "-1")
-		switch file := _file_name(m, arg...); arg[2] {
+		switch file := _mdb_export_file(m, arg...); arg[2] {
-		case ZONE:
-			_zone_export(m, arg[0], arg[1], file)
 		case HASH:
 			_hash_export(m, arg[0], arg[1], file)
+		case ZONE:
+			_zone_export(m, arg[0], arg[1], file)
 		case LIST:
 			_list_export(m, arg[0], arg[1], file)
 		}
-		m.StatusTime(LINK, "/share/local/"+m.Result()).Process("_clear")
 	}},
 	IMPORT: {Name: "import key sub type file", Hand: func(m *ice.Message, arg ...string) {
-		switch file := _file_name(m, arg...); arg[2] {
+		switch file := _mdb_export_file(m, arg...); arg[2] {
-		case ZONE:
-			_zone_import(m, arg[0], arg[1], file)
 		case HASH:
 			_hash_import(m, arg[0], arg[1], file)
+		case ZONE:
+			_zone_import(m, arg[0], arg[1], file)
 		case LIST:
 			_list_import(m, arg[0], arg[1], file)
 		}
@@ -257,110 +220,44 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: ice.Commands
 }}
 
 func init() {
-	ice.Index.Register(Index, nil, INSERT, DELETE, MODIFY, SELECT, INPUTS, PRUNES, EXPORT, IMPORT, PLUGIN, RENDER, ENGINE, SEARCH)
+	ice.Index.Register(Index, nil, INPUTS, INSERT, DELETE, MODIFY, SELECT, PRUNES, EXPORT, IMPORT, PLUGIN, RENDER, ENGINE, SEARCH)
 }
-func AutoConfig(args ...ice.Any) *ice.Action {
+func AutoConfig(arg ...Any) *ice.Action {
-	return &ice.Action{Hand: func(m *ice.Message, arg ...string) {
+	return &ice.Action{Hand: func(m *ice.Message, args ...string) {
-		if cs := m.Target().Configs; len(args) > 0 {
+		if cs := m.Target().Configs; len(arg) > 0 {
 			if cs[m.CommandKey()] == nil {
-				cs[m.CommandKey()] = &ice.Config{Value: kit.Data(args...)}
+				cs[m.CommandKey()] = &ice.Config{Value: kit.Data(arg...)}
-				// ice.Info.Load(m, m.CommandKey())
 			} else {
-				for k, v := range kit.Dict(args...) {
+				kit.For(kit.Dict(arg...), func(k string, v Any) { Config(m, k, v) })
-					m.Config(k, v)
-				}
 			}
 		}
 		if cmd := m.Target().Commands[m.CommandKey()]; cmd == nil {
 			return
 		} else if cmd.Actions[INSERT] != nil {
-			if inputs := []ice.Any{}; cmd.Meta[INSERT] == nil {
+			if inputs := []Any{}; cmd.Meta[INSERT] == nil {
-				kit.Fetch(kit.Filters(kit.Simple(m.Config(SHORT), kit.Split(ListField(m))), "", TIME, ID), func(k string) { inputs = append(inputs, k) })
+				kit.For(kit.Filters(kit.Simple(Config(m, SHORT), kit.Split(ListField(m))), "", TIME, ID), func(k string) { inputs = append(inputs, k) })
 				m.Design(INSERT, "添加", inputs...)
 			}
-			if inputs := []ice.Any{}; cmd.Meta[CREATE] == nil {
+			if inputs := []Any{}; cmd.Meta[CREATE] == nil {
-				kit.Fetch(kit.Filters(kit.Split(kit.Select(m.Config(SHORT), m.Config(FIELDS))), TIME, HASH, COUNT), func(k string) { inputs = append(inputs, k) })
+				kit.For(kit.Filters(kit.Split(kit.Select(Config(m, SHORT), Config(m, FIELDS))), TIME, HASH, COUNT), func(k string) { inputs = append(inputs, k) })
 				m.Design(CREATE, "创建", inputs...)
 			}
 		} else if cmd.Actions[CREATE] != nil {
-			if inputs := []ice.Any{}; cmd.Meta[CREATE] == nil {
+			if inputs := []Any{}; cmd.Meta[CREATE] == nil {
-				kit.Fetch(kit.Filters(kit.Split(HashField(m)), TIME, HASH), func(k string) { inputs = append(inputs, k) })
+				kit.For(kit.Filters(kit.Split(HashField(m)), TIME, HASH), func(k string) { inputs = append(inputs, k) })
 				m.Design(CREATE, "创建", inputs...)
 			}
 		}
 	}}
 }
-
-var _lock = task.Lock{}
-var _locks = map[string]*task.Lock{}
-
-func getLock(m *ice.Message, key string) *task.Lock {
-	defer _lock.Lock()()
-	l, ok := _locks[key]
-	if !ok {
-		l = &task.Lock{}
-		_locks[key] = l
-	}
-	return l
-}
-func Lock(m *ice.Message, arg ...ice.Any) func() {
-	key := kit.Select(m.PrefixKey(), kit.Keys(arg...))
-	m.Option("_lock", key)
-	return getLock(m, key).Lock()
-}
-func RLock(m *ice.Message, arg ...ice.Any) func() {
-	key := kit.Select(m.PrefixKey(), kit.Keys(arg...))
-	m.Option("_lock", key)
-	return getLock(m, key).RLock()
-}
-
-func Config(m *ice.Message, key string, arg ...ice.Any) string {
-	return kit.Format(Configv(m, key, arg...))
-}
-func Configv(m *ice.Message, key string, arg ...ice.Any) ice.Any {
-	if len(arg) > 0 {
-		Confv(m, m.PrefixKey(), kit.Keym(key), arg[0])
-	}
-	return Confv(m, m.PrefixKey(), kit.Keym(key))
-}
-func Confv(m *ice.Message, arg ...ice.Any) ice.Any {
-	key := kit.Format(arg[0])
-	if ctx, ok := ice.Info.Index[key].(*ice.Context); ok {
-		key = ctx.PrefixKey(key)
-	}
-	if len(arg) > 1 {
-		defer Lock(m, key)()
-	} else {
-		defer RLock(m, key)()
-	}
-	return m.Confv(arg...)
-}
-func Conf(m *ice.Message, arg ...ice.Any) string {
-	return kit.Format(Confv(m, arg...))
-}
-
-var cache = sync.Map{}
-
-func Cache(m *ice.Message, key string, add func() ice.Any) ice.Any {
-	if add == nil {
-		cache.Delete(key)
-		return nil
-	}
-	if val, ok := cache.Load(key); ok {
-		return val
-	}
-	if val := add(); val != nil {
-		cache.Store(key, val)
-		return val
-	}
-	return nil
-}
-
 func ImportantDataAction() ice.Actions {
-	return ice.Actions{ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Config("important", ice.TRUE) }}}
+	return ice.Actions{ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { Config(m, "important", ice.TRUE) }}}
 }
-func SaveImportant(m *ice.Message, key, sub string, arg ...string) {
+func saveImportant(m *ice.Message, key, sub string, arg ...string) {
-	if m.Conf(key, kit.Keys(sub, META, "important")) == ice.TRUE {
+	kit.If(m.Conf(key, kit.Keys(sub, META, "important")) == ice.TRUE, func() { ice.SaveImportant(m, arg...) })
-		ice.SaveImportant(m, arg...)
+}
-	}
+func ToMaps(value Map) Maps {
+	res := Maps{}
+	kit.For(value, func(k, v string) { res[k] = v })
+	return res
 }

base/mdb/render.go

@@ -9,33 +9,19 @@ const RENDER = "render"
 
 func init() { Index.MergeCommands(ice.Commands{RENDER: {Help: "渲染", Actions: RenderAction()}}) }
 
-func RenderAction(args ...ice.Any) ice.Actions {
+func RenderAction(arg ...ice.Any) ice.Actions {
-	return ice.MergeActions(ice.Actions{
+	return ice.MergeActions(ice.Actions{ice.CTX_INIT: AutoConfig(SHORT, TYPE, FIELD, "time,type,name,text", arg),
-		ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
+		CREATE: {Name: "create type name text", Hand: func(m *ice.Message, arg ...string) { HashCreate(m) }},
-			if len(args) == 0 {
-				args = append(args, SHORT, TYPE, FIELD, "time,type,name,text")
-			}
-			if cs := m.Target().Configs; cs[m.CommandKey()] == nil {
-				cs[m.CommandKey()] = &ice.Config{Value: kit.Data(args...)}
-			} else {
-				kit.Fetch(kit.Simple(args), func(key, value string) { m.Config(key, value) })
-			}
-		}},
-		CREATE: {Name: "create type name text", Hand: func(m *ice.Message, arg ...string) {
-			m.Option(TYPE, kit.Ext(m.Option(TYPE)))
-			m.OptionDefault(NAME, m.Option(TYPE))
-			m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple(TYPE, NAME, TEXT))
-		}},
 		SELECT: {Name: "select type name text auto create", Hand: func(m *ice.Message, arg ...string) {
 			if len(arg) < 2 || arg[0] == "" {
 				HashSelect(m, arg...)
 				return
 			}
-			for _, k := range kit.Split(arg[0]) {
+			kit.For(kit.Split(arg[0]), func(k string) {
-				HashSelect(m.Spawn(ice.OptionFields("")), k).Tables(func(value ice.Maps) {
+				HashSelects(m.Spawn(), k).Tables(func(value ice.Maps) {
 					m.Cmdy(kit.Keys(value[TEXT], value[NAME]), m.CommandKey(), k, arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
 				})
-			}
+			})
 		}},
 		ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { Conf(m, m.PrefixKey(), HASH, "") }},
 	})

base/mdb/search.go

@@ -1,39 +1,15 @@
 package mdb
 
-import (
+import ice "shylinux.com/x/icebergs"
-	ice "shylinux.com/x/icebergs"
-	kit "shylinux.com/x/toolkits"
-)
 
 const SEARCH = "search"
 
 func init() {
 	Index.MergeCommands(ice.Commands{SEARCH: {Help: "搜索", Actions: RenderAction()}})
 	ice.AddMerges(func(c *ice.Context, key string, cmd *ice.Command, sub string, action *ice.Action) (ice.Handler, ice.Handler) {
-		switch sub {
+		if sub == SEARCH {
-		case SEARCH:
 			return func(m *ice.Message, arg ...string) { m.Cmd(sub, CREATE, m.CommandKey(), m.PrefixKey()) }, nil
 		}
 		return nil, nil
 	})
 }
-func SearchAction() ice.Actions {
-	return ice.Actions{SEARCH: {Hand: func(m *ice.Message, arg ...string) { HashSelectSearch(m, arg) }}}
-}
-func HashSearchAction(arg ...Any) ice.Actions {
-	return ice.MergeActions(HashAction(arg...), SearchAction())
-}
-func HashSelectSearch(m *ice.Message, args []string, keys ...string) *ice.Message {
-	if args[0] != m.CommandKey() {
-		return m
-	}
-	if len(keys) == 0 {
-		keys = kit.Filters(kit.Split(HashField(m)), TIME, HASH)
-	}
-	HashSelectValue(m, func(value ice.Map) {
-		if args[1] == "" || args[1] == value[keys[1]] {
-			m.PushSearch(kit.SimpleKV("", value[keys[0]], value[keys[1]], value[keys[2]]), value)
-		}
-	})
-	return m
-}

base/mdb/zone.go

@@ -10,22 +10,26 @@ import (
 	"shylinux.com/x/toolkits/miss"
 )
 
+func _zone_meta(m *ice.Message, prefix, chain, key string) string {
+	defer RLock(m, prefix, chain)()
+	return m.Conf(prefix, kit.Keys(chain, kit.Keym(key)))
+}
 func _zone_fields(m *ice.Message) []string {
 	return kit.Split(kit.Select(ZONE_FIELD, m.OptionFields()))
 }
 func _zone_inputs(m *ice.Message, prefix, chain, zone string, field, value string) {
-	if field == _mdb_getmeta(m, prefix, chain, SHORT) {
+	if field == _zone_meta(m, prefix, chain, SHORT) {
 		_hash_inputs(m, prefix, chain, field, value)
 		return
 	}
-	defer RLock(m, prefix, chain)()
 	h := _hash_select_field(m, prefix, chain, zone, HASH)
+	defer RLock(m, prefix, chain)()
 	_list_inputs(m, prefix, kit.Keys(chain, HASH, h), field, value)
 }
 func _zone_insert(m *ice.Message, prefix, chain, zone string, arg ...string) {
 	h := _hash_select_field(m, prefix, chain, zone, HASH)
 	if h == "" {
-		h = _hash_insert(m, prefix, chain, kit.Select(ZONE, _mdb_getmeta(m, prefix, chain, SHORT)), zone)
+		h = _hash_insert(m, prefix, chain, kit.Select(ZONE, _zone_meta(m, prefix, chain, SHORT)), zone)
 	}
 	m.Assert(h != "")
 	defer Lock(m, prefix, chain)()
@@ -147,8 +151,12 @@ func ZoneAction(arg ...ice.Any) ice.Actions {
 func PageZoneAction(arg ...ice.Any) ice.Actions {
 	return ice.MergeActions(ice.Actions{
 		SELECT: {Name: "select zone id auto insert page", Hand: func(m *ice.Message, arg ...string) { PageZoneSelect(m, arg...) }},
-		NEXT:   {Hand: func(m *ice.Message, arg ...string) { NextPage(m, arg[0], arg[1:]...) }},
+		PREV: {Hand: func(m *ice.Message, arg ...string) {
-		PREV:   {Hand: func(m *ice.Message, arg ...string) { PrevPageLimit(m, arg[0], arg[1:]...) }},
+			PrevPageLimit(m, arg[0], arg[1:]...)
+		}},
+		NEXT: {Hand: func(m *ice.Message, arg ...string) {
+			NextPage(m, arg[0], arg[1:]...)
+		}},
 	}, ZoneAction(arg...))
 }
 func ZoneKey(m *ice.Message) string {
@@ -197,15 +205,12 @@ func ZoneSelect(m *ice.Message, arg ...string) *ice.Message {
 	if m.Cmdy(SELECT, m.PrefixKey(), "", ZONE, arg, logs.FileLineMeta(-1)); len(arg) == 0 {
 		m.PushAction(Config(m, ACTION), REMOVE).StatusTimeCount().Sort(ZoneShort(m))
 	} else if len(arg) == 1 {
-		// m.StatusTimeCountTotal(_mdb_getmeta(m, m.PrefixKey(), kit.Keys(HASH, HashSelectField(m, arg[0], HASH)), COUNT))
+		m.StatusTimeCountTotal(_zone_meta(m, m.PrefixKey(), kit.Keys(HASH, HashSelectField(m, arg[0], HASH)), COUNT))
-		m.StatusTimeCount()
 	}
 	return m
 }
 func ZoneExport(m *ice.Message, arg ...Any) {
-	if m.OptionFields() == "" {
+	kit.If(m.OptionFields() == "", func() { m.OptionFields(Config(m, SHORT), ZoneField(m)) })
-		m.OptionFields(Config(m, SHORT), ZoneField(m))
-	}
 	m.Cmdy(EXPORT, m.PrefixKey(), "", ZONE, arg)
 }
 func ZoneImport(m *ice.Message, arg ...Any) {

base/nfs/cat.go

@@ -69,14 +69,13 @@ func _cat_list(m *ice.Message, file string) {
 		for {
 			if n, e := f.Read(buf[size:]); !m.Warn(e, ice.ErrNotValid, file) {
 				m.Logs(LOAD, FILE, file, SIZE, n)
-				if size += n; size < len(buf) {
+				if size += n; size >= len(buf) {
-					buf = buf[:size]
+					buf = append(buf, make([]byte, ice.MOD_BUFS)...)
-					break
+					continue
 				}
-				buf = append(buf, make([]byte, ice.MOD_BUFS)...)
-			} else {
-				break
 			}
+			buf = buf[:size]
+			break
 		}
 		m.Echo(string(buf)).StatusTime(FILE, file, SIZE, size)
 	default:
@@ -136,11 +135,9 @@ const CAT = "cat"
 
 func init() {
 	Index.MergeCommands(ice.Commands{
-		CAT: {Name: "cat path auto", Help: "文件", Actions: ice.MergeActions(ice.Actions{
+		CAT: {Name: "cat path auto", Help: "文件", Actions: ice.MergeActions(ice.Actions{ice.CTX_INIT: mdb.AutoConfig(SOURCE, kit.DictList(
-			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { aaa.White(m, ice.SRC_MAIN_JS, ice.SRC_MAIN_GO, ice.SRC_MAIN_SHY) }},
-		}, ice.Actions{ice.CTX_INIT: mdb.AutoConfig(SOURCE, kit.DictList(
 			HTML, CSS, JS, GO, SH, SHY, CSV, JSON, PY, MD, TXT, XML, YML, ZML, IML,
-			"license", "makefile", "configure", "conf",
+			ice.LICENSE, ice.MAKEFILE, "configure", "conf",
 		))}), Hand: func(m *ice.Message, arg ...string) {
 			if len(arg) == 0 || strings.HasSuffix(arg[0], ice.PS) {
 				m.Cmdy(DIR, arg)

base/ssh/script.go

@@ -127,7 +127,9 @@ func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
 		if len(bio.Text()) == 0 && h == STDIO {
 			continue
 		}
-		f.count++
+		if f.count++; len(bio.Text()) == 0 {
+			continue
+		}
 		if strings.HasSuffix(bio.Text(), "\\") {
 			line += bio.Text()[:len(bio.Text())-1]
 			ps = f.ps2

base/tcp/port.go

@@ -7,15 +7,16 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
+	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
 
 func _port_right(m *ice.Message, arg ...string) string {
-	current, end := kit.Int(kit.Select(m.Config(CURRENT), arg, 0)), kit.Int(m.Config(END))
+	current, end := kit.Int(kit.Select(mdb.Config(m, CURRENT), arg, 0)), kit.Int(mdb.Config(m, END))
 	if current >= end {
-		current = kit.Int(m.Config(BEGIN))
+		current = kit.Int(mdb.Config(m, BEGIN))
 	}
 	for i := current; i < end; i++ {
 		if p := path.Join(ice.USR_LOCAL_DAEMON, kit.Format(i)); nfs.ExistsFile(m, p) {
@@ -26,7 +27,7 @@ func _port_right(m *ice.Message, arg ...string) string {
 		} else {
 			nfs.MkdirAll(m, p)
 			m.Logs(mdb.SELECT, PORT, i)
-			return m.Config(CURRENT, i)
+			return mdb.Config(m, CURRENT, i)
 		}
 	}
 	return ""
@@ -43,7 +44,7 @@ const PORT = "port"
 func init() {
 	Index.MergeCommands(ice.Commands{
 		PORT: {Name: "port port path auto", Help: "端口", Actions: ice.MergeActions(ice.Actions{
-			CURRENT:   {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(CURRENT)) }},
+			CURRENT:   {Hand: func(m *ice.Message, arg ...string) { m.Echo(mdb.Config(m, CURRENT)) }},
 			aaa.RIGHT: {Hand: func(m *ice.Message, arg ...string) { m.Echo(_port_right(m, arg...)) }},
 			nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) {
 				m.Assert(m.Option(PORT) != "")
@@ -54,7 +55,7 @@ func init() {
 				m.Cmdy(nfs.DIR, arg[1:], kit.Dict(nfs.DIR_ROOT, path.Join(ice.USR_LOCAL_DAEMON, arg[0])))
 				return
 			}
-			current := kit.Int(m.Config(BEGIN))
+			current := kit.Int(mdb.Config(m, BEGIN))
 			m.Option(nfs.DIR_ROOT, ice.USR_LOCAL_DAEMON)
 			m.Cmd(nfs.DIR, nfs.PWD, func(value ice.Maps) {
 				bin := m.CmdAppend(nfs.DIR, path.Join(value[nfs.PATH], ice.BIN), nfs.PATH)
@@ -68,8 +69,8 @@ func init() {
 				m.Push(ice.BIN, strings.TrimPrefix(bin, value[nfs.PATH]))
 				current = kit.Max(current, port)
 			})
-			m.Config(CURRENT, current)
+			mdb.Config(m, CURRENT, current)
-			m.PushAction(nfs.TRASH).StatusTimeCount(m.ConfigSimple(BEGIN, CURRENT, END)).SortInt(PORT)
+			m.PushAction(nfs.TRASH).StatusTimeCount(ctx.ConfigSimple(m, BEGIN, CURRENT, END)).SortInt(PORT)
 		}},
 	})
 }

base/web/dream.go

@@ -55,7 +55,7 @@ func _dream_show(m *ice.Message, name string) {
 	defer m.Sleep3s()
 	m.Options(cli.CMD_DIR, kit.Path(p), cli.CMD_ENV, kit.Simple(
 		cli.CTX_OPS, "http://localhost:"+m.CmdAppend(SERVE, tcp.PORT), cli.CTX_LOG, ice.VAR_LOG_BOOT_LOG, cli.CTX_PID, ice.VAR_LOG_ICE_PID,
-		cli.PATH, cli.BinPath(p, ""), cli.USER, ice.Info.Username, kit.EnvSimple(cli.HOME, cli.TERM, cli.SHELL), m.Configv(cli.ENV),
+		cli.PATH, cli.BinPath(p, ""), cli.USER, ice.Info.Username, kit.EnvSimple(cli.HOME, cli.TERM, cli.SHELL), mdb.Configv(m, cli.ENV),
 	), cli.CMD_OUTPUT, path.Join(p, ice.VAR_LOG_BOOT_LOG))
 	defer m.Options(cli.CMD_DIR, "", cli.CMD_ENV, "", cli.CMD_OUTPUT, "")
 	gdb.Event(m, DREAM_CREATE, m.OptionSimple(mdb.NAME, mdb.TYPE))

base/web/serve.go

@@ -67,18 +67,18 @@ func _serve_main(m *ice.Message, w http.ResponseWriter, r *http.Request) bool {
 	return true
 }
 func _serve_handle(key string, cmd *ice.Command, m *ice.Message, w http.ResponseWriter, r *http.Request) {
-	_log := func(level string, arg ...ice.Any) *ice.Message { return m.Logs(level, arg...) }
+	_log := func(level string, arg ...ice.Any) *ice.Message { return m.Logs(strings.Title(level), arg...) }
 	if u, e := url.Parse(r.Header.Get(Referer)); e == nil {
-		add := func(k, v string) { _log("Path", k, m.Option(k, v)) }
+		add := func(k, v string) { _log(nfs.PATH, k, m.Option(k, v)) }
 		switch arg := strings.Split(strings.TrimPrefix(u.Path, ice.PS), ice.PS); arg[0] {
 		case CHAT:
 			kit.For(arg[1:], func(k, v string) { add(k, v) })
 		case SHARE:
 			add(arg[0], arg[1])
 		}
-		kit.For(u.Query(), func(k string, v []string) { _log("Refer", k, v).Optionv(k, v) })
+		kit.For(u.Query(), func(k string, v []string) { _log(ctx.ARGS, k, v).Optionv(k, v) })
 	}
-	m.Options(ice.MSG_USERUA, r.Header.Get(UserAgent), ice.MSG_HEIGHT, "480", ice.MSG_WIDTH, "320")
+	m.Options(ice.MSG_USERUA, r.Header.Get(UserAgent))
 	for k, v := range kit.ParseQuery(r.URL.RawQuery) {
 		kit.If(m.IsCliUA(), func() { v = kit.Simple(v, func(v string) (string, error) { return url.QueryUnescape(v) }) })
 		m.Optionv(k, v)
@@ -96,6 +96,7 @@ func _serve_handle(key string, cmd *ice.Command, m *ice.Message, w http.Response
 		})
 	}
 	kit.For(r.Cookies(), func(k, v string) { m.Optionv(k, v) })
+	m.OptionDefault(ice.MSG_HEIGHT, "480", ice.MSG_WIDTH, "320")
 	m.Options(ice.MSG_USERWEB, _serve_domain(m), ice.MSG_USERPOD, m.Option(ice.POD))
 	m.Options(ice.MSG_SESSID, kit.Select(m.Option(ice.MSG_SESSID), m.Option(CookieName(m.Option(ice.MSG_USERWEB)))))
 	m.Options(ice.MSG_USERIP, r.Header.Get(ice.MSG_USERIP), ice.MSG_USERADDR, kit.Select(r.RemoteAddr, r.Header.Get(ice.MSG_USERADDR)))
@@ -184,7 +185,7 @@ func init() {
 	Index.MergeCommands(ice.Commands{"/exit": {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(ice.EXIT) }},
 		SERVE: {Name: "serve name auto start", Help: "服务器", Actions: ice.MergeActions(ice.Actions{
 			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
-				ice.Info.Localhost = m.Config(tcp.LOCALHOST) == ice.TRUE
+				ice.Info.Localhost = mdb.Config(m, tcp.LOCALHOST) == ice.TRUE
 				cli.NodeInfo(m, ice.Info.Pathname, WORKER)
 			}},
 			cli.START: {Name: "start dev proto host port=9020 nodename username usernick", Hand: func(m *ice.Message, arg ...string) {

base/web/space.go

@@ -25,7 +25,7 @@ func _space_dial(m *ice.Message, dev, name string, arg ...string) {
 	args := kit.SimpleKV("type,name,host,port", msg.Append(tcp.PROTOCOL), dev, msg.Append(tcp.HOST), msg.Append(tcp.PORT))
 	prints := false
 	m.Go(func() {
-		redial := kit.Dict(m.Configv(REDIAL))
+		redial := kit.Dict(mdb.Configv(m, REDIAL))
 		a, b, c := kit.Int(redial["a"]), kit.Int(redial["b"]), kit.Int(redial["c"])
 		for i := 1; i < c; i++ {
 			next := time.Duration(rand.Intn(a*(i+1))+b*i) * time.Millisecond

base/web/spide.go

@@ -13,7 +13,6 @@ import (
 	"time"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/aaa"
 	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
@@ -67,7 +66,7 @@ func _spide_show(m *ice.Message, name string, arg ...string) {
 		return
 	}
 	defer res.Body.Close()
-	if m.Config(LOGHEADERS) == ice.TRUE {
+	if mdb.Config(m, LOGHEADERS) == ice.TRUE {
 		for k, v := range res.Header {
 			m.Logs(mdb.IMPORT, k, v)
 		}
@@ -274,7 +273,7 @@ func init() {
 	Index.MergeCommands(ice.Commands{
 		SPIDE: {Name: "spide client.name action=raw,msg,save,cache method=GET,PUT,POST,DELETE url format=form,part,json,data,file arg run create", Help: "蜘蛛侠", Actions: ice.MergeActions(ice.Actions{
 			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
-				conf := m.Confm(cli.RUNTIME, cli.CONF)
+				conf := mdb.Confm(m, cli.RUNTIME, cli.CONF)
 				m.Cmd("", mdb.CREATE, ice.OPS, kit.Select("http://127.0.0.1:9020", conf[cli.CTX_OPS]))
 				m.Cmd("", mdb.CREATE, ice.DEV, kit.Select(kit.Select("https://contexts.com.cn", ice.Info.Make.Domain), conf[cli.CTX_DEV]))
 				m.Cmd("", mdb.CREATE, ice.COM, kit.Select("https://contexts.com.cn", conf[cli.CTX_COM]))
@@ -304,10 +303,6 @@ func init() {
 				_spide_show(m, arg[0], arg[1:]...)
 			}
 		}},
-		"/spide-demo/": {Actions: aaa.WhiteAction(), Hand: func(m *ice.Message, arg ...string) {
-			m.Push("hi", "hello")
-			m.Echo("hello world")
-		}},
 		http.MethodGet: {Name: "GET url key value run", Help: "蜘蛛侠", Hand: func(m *ice.Message, arg ...string) {
 			m.Echo(kit.Formats(kit.UnMarshal(m.Cmdx(SPIDE, ice.DEV, SPIDE_RAW, http.MethodGet, arg[0], arg[1:]))))
 		}},

core/chat/action.go

@@ -79,7 +79,7 @@ func init() {
 				return
 			}
 			if len(arg) == 2 {
-				m.OptionFromConfig(MENUS)
+				ctx.OptionFromConfig(m, MENUS)
 				_action_list(m, arg[0], arg[1])
 			} else {
 				_action_exec(m, arg[0], arg[1], arg[2], arg[3:]...)

core/chat/header.go

@@ -48,7 +48,7 @@ func _header_check(m *ice.Message, arg ...string) bool {
 	if m.Option(ice.MSG_USERNAME) != "" {
 		return true
 	}
-	if m.OptionFromConfig(web.SSO) == "" && m.OptionFromConfig(web.LOGIN) == "" {
+	if ctx.OptionFromConfig(m, web.SSO) == "" && ctx.OptionFromConfig(m, web.LOGIN) == "" {
 		m.Option(web.SSO, GetSSO(m))
 	}
 	return false

core/chat/location.go

@@ -32,7 +32,7 @@ func init() {
 	}
 	get := func(m *ice.Message, api string, arg ...ice.Any) string {
 		return kit.Format(cache(m, kit.Join(kit.Simple(api, arg)), func() string {
-			return m.Cmdx(http.MethodGet, "https://apis.map.qq.com/ws/"+api, mdb.KEY, m.Config(aaa.TOKEN), arg)
+			return m.Cmdx(http.MethodGet, "https://apis.map.qq.com/ws/"+api, mdb.KEY, mdb.Config(m, aaa.TOKEN), arg)
 		}))
 	}
 
@@ -73,7 +73,7 @@ func init() {
 			}},
 		}, mdb.HashAction(mdb.FIELD, "time,hash,type,name,text,latitude,longitude,extra"), ctx.CmdAction(), FavorAction()), Hand: func(m *ice.Message, arg ...string) {
 			mdb.HashSelect(m, kit.Slice(arg, 0, 1)...)
-			ctx.DisplayLocal(m, "", m.ConfigSimple(aaa.TOKEN))
+			ctx.DisplayLocal(m, "", ctx.ConfigSimple(m, aaa.TOKEN))
 			m.Option(LOCATION, get(m, "location/v1/ip", aaa.IP, m.Option(ice.MSG_USERIP)))
 		}},
 	})

core/chat/oauth/oauth.go

@@ -151,7 +151,7 @@ var Index = &ice.Context{Name: OAUTH, Help: "认证授权", Commands: ice.Comman
 
 		} else { // 授权
 			token := m.Cmdx(ACCESS, mdb.CREATE, aaa.USERNAME, m.Option(ice.MSG_USERNAME), msg.AppendSimple(SCOPE, REDIRECT_URI))
-			m.RenderJson(ACCESS_TOKEN, token, TOKEN_TYPE, web.Bearer, EXPIRES_IN, kit.Duration(m.Conf(ACCESS, kit.Keym(mdb.EXPIRE)))/time.Second)
+			m.RenderJson(ACCESS_TOKEN, token, TOKEN_TYPE, web.Bearer, EXPIRES_IN, kit.Duration(mdb.Conf(m, ACCESS, kit.Keym(mdb.EXPIRE)))/time.Second)
 			m.Cmdx(TOKEN, mdb.MODIFY, mdb.HASH, m.Option(CODE), USED, ice.TRUE)
 		}
 	}},

core/code/compile.go

@@ -62,7 +62,7 @@ func init() {
 		}, ctx.ConfAction(cli.ENV, kit.Dict("GOPRIVATE", "shylinux.com,github.com", "GOPROXY", "https://goproxy.cn,direct", "CGO_ENABLED", "0"))), Hand: func(m *ice.Message, arg ...string) {
 			defer web.ToastProcess(m)()
 			main, file, goos, arch := _compile_target(m, arg...)
-			env := kit.Simple(cli.PATH, cli.BinPath(), cli.HOME, kit.Select(kit.Path(""), kit.Env(cli.HOME)), m.Configv(cli.ENV), m.Optionv(cli.ENV), cli.GOOS, goos, cli.GOARCH, arch)
+			env := kit.Simple(cli.PATH, cli.BinPath(), cli.HOME, kit.Select(kit.Path(""), kit.Env(cli.HOME)), mdb.Configv(m, cli.ENV), m.Optionv(cli.ENV), cli.GOOS, goos, cli.GOARCH, arch)
 			kit.If(runtime.GOOS == cli.WINDOWS, func() { env = append(env, "GOPATH", kit.HomePath(GO), "GOCACHE", kit.HomePath("go/go-build")) })
 			m.Optionv(cli.CMD_ENV, env)
 			m.Cmd(AUTOGEN, VERSION)

core/code/inner.go

@@ -134,7 +134,7 @@ func PlugAction() ice.Actions {
 			kit.For([]string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE}, func(cmd string) { m.Cmd(cmd, mdb.CREATE, m.CommandKey(), m.PrefixKey()) })
 			LoadPlug(m, m.CommandKey())
 		}},
-		mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(PLUG)) }},
+		mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(mdb.Config(m, PLUG)) }},
 		mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) }},
 		mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) }},
 		mdb.SELECT: {Hand: func(m *ice.Message, arg ...string) {
@@ -149,7 +149,7 @@ func PlugAction() ice.Actions {
 func LoadPlug(m *ice.Message, lang ...string) {
 	for _, lang := range lang {
 		m.Conf(nfs.CAT, kit.Keym(nfs.SOURCE, kit.Ext(lang)), ice.TRUE)
-		m.Confm(lang, kit.Keym(PLUG, PREPARE), func(k string, v ice.Any) {
+		mdb.Confm(m, lang, kit.Keym(PLUG, PREPARE), func(k string, v ice.Any) {
 			kit.For(kit.Simple(v), func(v string) { m.Conf(lang, kit.Keym(PLUG, KEYWORD, v), k) })
 		})
 	}

core/code/install.go

@@ -199,10 +199,10 @@ func init() {
 
 func InstallAction(args ...ice.Any) ice.Actions {
 	return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(args...),
-		web.DOWNLOAD: {Help: "下载", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, web.DOWNLOAD, m.Config(nfs.SOURCE)) }},
+		web.DOWNLOAD: {Help: "下载", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, web.DOWNLOAD, mdb.Config(m, nfs.SOURCE)) }},
-		cli.BUILD:    {Help: "构建", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, cli.BUILD, m.Config(nfs.SOURCE)) }},
+		cli.BUILD:    {Help: "构建", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, cli.BUILD, mdb.Config(m, nfs.SOURCE)) }},
 		cli.ORDER: {Help: "加载", Hand: func(m *ice.Message, arg ...string) {
-			m.Cmdy(INSTALL, cli.ORDER, m.Config(nfs.SOURCE), path.Join(_INSTALL, ice.BIN))
+			m.Cmdy(INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), path.Join(_INSTALL, ice.BIN))
 		}},
 		nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) { nfs.Trash(m, m.Option(nfs.PATH)) }},
 	}

core/code/oauth.go

@@ -42,7 +42,7 @@ func init() {
 				mdb.HashCreate(m, m.OptionSimple(CODE))
 			}},
 			ACCESS_TOKEN: {Name: "access_token", Help: "令牌", Hand: func(m *ice.Message, arg ...string) {
-				mdb.HashModify(m, m.OptionSimple(mdb.HASH), kit.Simple(web.SpidePost(_oauth_header(m), kit.MergeURL2(LOGIN_OAUTH, ACCESS_TOKEN), m.ConfigSimple(CLIENT_ID, CLIENT_SECRET), m.OptionSimple(CODE))))
+				mdb.HashModify(m, m.OptionSimple(mdb.HASH), kit.Simple(web.SpidePost(_oauth_header(m), kit.MergeURL2(LOGIN_OAUTH, ACCESS_TOKEN), ctx.ConfigSimple(m, CLIENT_ID, CLIENT_SECRET), m.OptionSimple(CODE))))
 			}},
 			"user": {Name: "user", Help: "用户", Hand: func(m *ice.Message, arg ...string) {
 				mdb.HashModify(m, m.OptionSimple(mdb.HASH), kit.Simple(web.SpideGet(_oauth_header(m), API_GITHUB+"user")))
@@ -66,7 +66,7 @@ func init() {
 		}, mdb.HashAction(mdb.FIELD, "time,hash,code,access_token,scope,token_type")), Hand: func(m *ice.Message, arg ...string) {
 			if mdb.HashSelect(m, arg...).PushAction("public", "user", ACCESS_TOKEN, mdb.REMOVE); len(arg) == 0 {
 				if m.Action(mdb.CREATE); m.Length() == 0 {
-					m.Echo(kit.MergeURL2(LOGIN_OAUTH, "authorize", m.ConfigSimple(REDIRECT_URI, CLIENT_ID), SCOPE, "read:user read:public_key write:public_key repo"))
+					m.Echo(kit.MergeURL2(LOGIN_OAUTH, "authorize", ctx.ConfigSimple(m, REDIRECT_URI, CLIENT_ID), SCOPE, "read:user read:public_key write:public_key repo"))
 				}
 			}
 		}},

core/code/pprof.go

@@ -43,7 +43,7 @@ func init() {
 					return
 				}
 				msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, http.MethodGet, m.Option(SERVICE), m.OptionSimple(SECONDS))
-				cmd := kit.Simple(m.Configv(PPROF), "-text", m.Option(BINNARY), msg.Append(nfs.FILE))
+				cmd := kit.Simple(mdb.Configv(m, PPROF), "-text", m.Option(BINNARY), msg.Append(nfs.FILE))
 				m.Option(mdb.TEXT, strings.Join(kit.Slice(strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL), 0, 20), ice.NL))
 				mdb.ZoneInsert(m, m.OptionSimple("zone,text"), msg.AppendSimple(nfs.FILE))
 				m.Echo(m.Option(mdb.TEXT)).ProcessInner()
@@ -51,7 +51,7 @@ func init() {
 			web.SERVE: {Help: "展示", Hand: func(m *ice.Message, arg ...string) {
 				u := web.OptionUserWeb(m)
 				p := u.Hostname() + ice.DF + m.Cmdx(tcp.PORT, aaa.RIGHT)
-				m.Cmd(cli.DAEMON, m.Configv(PPROF), "-http="+p, m.Option(BINNARY), m.Option(nfs.FILE))
+				m.Cmd(cli.DAEMON, mdb.Configv(m, PPROF), "-http="+p, m.Option(BINNARY), m.Option(nfs.FILE))
 				m.Sleep("3s").ProcessOpen(kit.Format("http://%s/ui/top", p))
 			}},
 		}, mdb.ZoneAction(mdb.FIELDS, "time,zone,count,binnary,service,seconds", mdb.FIELD, "time,id,text,file", PPROF, kit.List(GO, "tool", PPROF))), Hand: func(m *ice.Message, arg ...string) {

core/code/sh.go

@@ -14,7 +14,7 @@ import (
 )
 
 func _sh_cmds(m *ice.Message, p string) (string, string) {
-	cmds, text := kit.Select(SH, m.Config(ssh.SHELL)), kit.Format(strings.TrimSpace(nfs.Template(m, "cmd.sh")), web.UserHost(m), m.Option(ice.MSG_USERPOD), p)
+	cmds, text := kit.Select(SH, mdb.Config(m, ssh.SHELL)), kit.Format(strings.TrimSpace(nfs.Template(m, "cmd.sh")), web.UserHost(m), m.Option(ice.MSG_USERPOD), p)
 	if head := kit.Select("", strings.Split(m.Cmdx(nfs.CAT, p), ice.NL), 0); strings.HasPrefix(head, "#!") {
 		cmds = strings.TrimSpace(strings.TrimPrefix(head, "#!"))
 	}

core/code/vimer.go

@@ -184,7 +184,6 @@ func init() {
 		switch sub {
 		case TEMPLATE, COMPLETE, NAVIGATE:
 			return func(m *ice.Message, arg ...string) {
-				m.Option(mdb.SHORT, mdb.TYPE)
 				m.Cmd(sub, mdb.CREATE, key, m.PrefixKey())
 			}, nil
 		}

core/wiki/data.go

@@ -26,7 +26,7 @@ func init() {
 				m.Cmd("", nfs.SAVE, m.Option(nfs.PATH), kit.Join(kit.Split(m.Option(mdb.FIELD)))+ice.NL+kit.Join(kit.Split(m.Option(mdb.VALUE)))+ice.NL)
 			}},
 			nfs.PUSH: {Name: "push path record", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(nfs.PUSH, path.Join(m.Config(nfs.PATH), arg[0]), kit.Join(arg[1:], ice.FS)+ice.NL)
+				m.Cmd(nfs.PUSH, path.Join(mdb.Config(m, nfs.PATH), arg[0]), kit.Join(arg[1:], ice.FS)+ice.NL)
 			}}, "draw": {Help: "绘图"},
 		}, WikiAction(ice.USR_LOCAL_EXPORT, nfs.CSV)), Hand: func(m *ice.Message, arg ...string) {
 			if !_wiki_list(m, arg...) {

core/wiki/spark.go

@@ -4,6 +4,7 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
+	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/ssh"
 	kit "shylinux.com/x/toolkits"
@@ -19,7 +20,7 @@ func _spark_show(m *ice.Message, name, text string, arg ...string) *ice.Message
 	case "inner", FIELD:
 		return m.Echo(text)
 	}
-	prompt := kit.Select(name+"> ", m.Config(kit.Keys(ssh.PROMPT, name)))
+	prompt := kit.Select(name+"> ", mdb.Config(m, kit.Keys(ssh.PROMPT, name)))
 	for _, l := range kit.SplitLine(text) {
 		m.Echo(Format("div", Format("label", prompt), Format("span", l)))
 	}
@@ -95,7 +96,7 @@ func init() {
 				m.Cmdy(SPARK, "md", arg)
 			} else {
 				if arg[0] == "shell" && arg[1] == "inner" {
-					 arg = arg[1:]
+					arg = arg[1:]
 				}
 				arg = _name(m, arg)
 				_spark_show(m, arg[0], strings.TrimSpace(arg[1]), arg[2:]...)

core/wiki/title.go

@@ -22,7 +22,7 @@ func _title_menu(m *ice.Message, kind, text string, arg ...string) *ice.Message
 	if kind == NAVMENU {
 		m.Option(mdb.DATA, _title_parse(m, path.Dir(m.Option(ice.MSG_SCRIPT)), text))
 	}
-	return _option(m, kind, "", text, arg...).RenderTemplate(m.Config(kind), &Message{m})
+	return _option(m, kind, "", text, arg...).RenderTemplate(mdb.Config(m, kind), &Message{m})
 }
 func _title_show(m *ice.Message, kind, text string, arg ...string) *ice.Message {
 	switch title, _ := m.Optionv(TITLE).(map[string]int); kind {

core/wiki/wiki.go

@@ -46,7 +46,7 @@ func _wiki_list(m *ice.Message, arg ...string) bool {
 		if m.Option(nfs.DIR_DEEP) != ice.TRUE {
 			m.Cmdy(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.DIR))
 		}
-		m.Cmdy(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.CAT, nfs.DIR_REG, m.Config(lex.REGEXP)))
+		m.Cmdy(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.CAT, nfs.DIR_REG, mdb.Config(m, lex.REGEXP)))
 		m.StatusTimeCount()
 		m.SortTimeR(mdb.TIME)
 		return true
@@ -64,7 +64,7 @@ func _wiki_upload(m *ice.Message, dir string) {
 	m.Cmdy(web.CACHE, web.WATCH, m.Option(ice.MSG_UPLOAD), _wiki_path(m, dir, m.Option(mdb.NAME)))
 }
 func _wiki_template(m *ice.Message, name, text string, arg ...string) *ice.Message {
-	return _option(m, m.CommandKey(), name, strings.TrimSpace(text), arg...).RenderTemplate(m.Config(nfs.TEMPLATE), &Message{m})
+	return _option(m, m.CommandKey(), name, strings.TrimSpace(text), arg...).RenderTemplate(mdb.Config(m, nfs.TEMPLATE), &Message{m})
 }
 
 const WIKI = "wiki"
@@ -88,8 +88,8 @@ func WikiAction(dir string, ext ...string) ice.Actions {
 		mdb.INPUTS: {Hand: func(m *ice.Message, arg ...string) {
 			switch arg[0] {
 			case nfs.PATH:
-				m.Option(nfs.DIR_REG, m.Config(lex.REGEXP))
+				m.Option(nfs.DIR_REG, mdb.Config(m, lex.REGEXP))
-				m.Cmdy(nfs.DIR, path.Join(m.Config(nfs.PATH), kit.Select("", arg, 1)))
+				m.Cmdy(nfs.DIR, path.Join(mdb.Config(m, nfs.PATH), kit.Select("", arg, 1)))
 			case ctx.INDEX:
 				m.Cmdy(ctx.COMMAND, mdb.SEARCH, ctx.COMMAND, ice.OptionFields(ctx.INDEX))
 			}

core/wiki/word.go

@@ -62,5 +62,5 @@ func WordAction(template string, arg ...ice.Any) ice.Actions {
 	return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(append([]ice.Any{nfs.TEMPLATE, template}, arg...)...)}
 }
 func WordAlias(m *ice.Message, cmd string, cmds ...string) {
-	m.Conf(WORD, kit.Keym(mdb.ALIAS, cmd), cmds)
+	mdb.Conf(m, WORD, kit.Keym(mdb.ALIAS, cmd), cmds)
 }

data.go

@@ -22,28 +22,12 @@ func (m *Message) PrefixKey(arg ...Any) string {
 	return kit.Keys(m.Prefix(m.CommandKey()), kit.Keys(arg...))
 }
 func (m *Message) Prefix(arg ...string) string {
-	return m.Target().PrefixKey(arg...)
+	return m.Target().Prefix(arg...)
 }
 func (m *Message) PrefixPath(arg ...Any) string {
 	return strings.TrimPrefix(path.Join(strings.ReplaceAll(m.PrefixRawKey(arg...), PT, PS)), "web") + PS
 }
 
-func (m *Message) Config(key string, arg ...Any) string {
-	return kit.Format(m.Configv(key, arg...))
-}
-func (m *Message) Configv(key string, arg ...Any) Any {
-	if len(arg) > 0 {
-		m.Confv(m.PrefixKey(), kit.Keym(key), arg[0])
-	}
-	return m.Confv(m.PrefixKey(), kit.Keym(key))
-}
-func (m *Message) ConfigSimple(key ...string) (res []string) {
-	for _, k := range kit.Split(kit.Join(key)) {
-		res = append(res, k, m.Config(k))
-	}
-	return
-}
-
 func loadImportant(m *Message) {
 	if f, e := os.Open(VAR_DATA_IMPORTANT); e == nil {
 		defer f.Close()
@@ -61,9 +45,7 @@ func SaveImportant(m *Message, arg ...string) {
 		return
 	}
 	for i, v := range arg {
-		if v == "" || strings.Contains(v, SP) {
+		kit.If(v == "" || strings.Contains(v, SP), func() { arg[i] = "\"" + v + "\"" })
-			arg[i] = "\"" + v + "\""
-		}
 	}
 	m.Cmd("nfs.push", VAR_DATA_IMPORTANT, kit.Join(arg, SP), NL)
 }

init.go

@@ -27,8 +27,6 @@ func (s *Frame) Begin(m *Message, arg ...string) Server {
 func (s *Frame) Start(m *Message, arg ...string) bool {
 	m.Cap(CTX_STREAM, strings.Split(m.Time(), SP)[1])
 	m.Cmd(kit.Keys(MDB, CTX_INIT))
-	m.Cmd(kit.Keys(AAA, CTX_INIT))
-	m.Cmd(kit.Keys(CLI, CTX_INIT))
 	m.Cmd(INIT, arg)
 	for _, k := range kit.Split(kit.Select("ctx,log,gdb,ssh", os.Getenv(CTX_DAEMON))) {
 		m.Start(k)
@@ -70,7 +68,6 @@ var Index = &Context{Name: ICE, Help: "冰山模块", Configs: Configs{HELP: {Va
 		m.Cmd(CTX_INIT)
 		m.Cmd(SOURCE, ETC_INIT_SHY)
 	}},
-	HELP: {Hand: func(m *Message, arg ...string) { m.Echo(m.Config(INDEX)) }},
 	QUIT: {Hand: func(m *Message, arg ...string) { os.Exit(0) }},
 	EXIT: {Hand: func(m *Message, arg ...string) {
 		m.root.Option(EXIT, kit.Select("0", arg, 0))

logs.go

@@ -225,24 +225,20 @@ func (m *Message) FormatChain() string {
 		ms = append(ms, msg)
 	}
 	show := func(msg *Message, meta string) string {
-		if len(msg.meta[meta]) > 0 {
+		if len(msg.meta[meta]) == 0 || len(msg.meta[meta]) == 1 && msg.meta[meta][0] == "" {
-			return kit.Format("%s:%d %v", meta, len(msg.meta[meta]), msg.meta[meta])
+			return ""
 		}
-		return ""
+		return kit.Format("%s:%d %v", meta, len(msg.meta[meta]), msg.meta[meta])
 	}
 	meta := []string{}
 	for i := len(ms) - 1; i >= 0; i-- {
 		msg := ms[i]
-		meta = append(meta, kit.Join([]string{
+		meta = append(meta, kit.Join([]string{msg.FormatPrefix(), show(msg, MSG_DETAIL), show(msg, MSG_OPTION), show(msg, MSG_APPEND), show(msg, MSG_RESULT), msg._cmd.GetFileLine()}, SP))
-			msg.FormatPrefix(),
-			show(msg, MSG_DETAIL),
-			show(msg, MSG_OPTION),
-			show(msg, MSG_APPEND),
-			show(msg, MSG_RESULT),
-			msg._cmd.GetFileLine(),
-		}, " "))
 		for _, k := range msg.meta[MSG_OPTION] {
 			if v, ok := msg.meta[k]; ok {
+				if len(v) == 0 || len(v) == 1 && v[0] == "" {
+					continue
+				}
 				meta = append(meta, kit.Format("\t%s: %d %v", k, len(v), v))
 			}
 		}

misc.go

@@ -421,8 +421,8 @@ func SplitCmd(name string, actions Actions) (list []Any) {
 		case PAGE:
 			push(TEXT, "limit")
 			push(TEXT, "offend")
-			push(BUTTON, "next")
 			push(BUTTON, "prev")
+			push(BUTTON, "next")
 		case ARGS, TEXT, TEXTAREA, CONTENT:
 			push(TEXTAREA, ls[i])
 		case PASSWORD:

misc/alpha/alpha.go

@@ -6,6 +6,7 @@ import (
 
 	"shylinux.com/x/ice"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/core/wiki"
@@ -30,13 +31,13 @@ type alpha struct {
 
 func (s alpha) Load(m *ice.Message, arg ...string) {
 	lib := kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.ZONE))
-	m.Assert(nfs.RemoveAll(m, path.Join(m.Config(mdb.STORE), lib)))
+	m.Assert(nfs.RemoveAll(m, path.Join(mdb.Config(m, mdb.STORE), lib)))
 	s.Zone.Remove(m, mdb.ZONE, lib)
-	s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, m.ConfigSimple(mdb.FIELD, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
+	s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, ctx.ConfigSimple(m.Message, mdb.FIELD, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
 	prefix := kit.Keys(mdb.HASH, m.Result())
 	m.Cmd(mdb.IMPORT, m.PrefixKey(), prefix, mdb.LIST, m.Option(nfs.FILE))
-	m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
+	mdb.Conf(m, "", kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
-	m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
+	mdb.Conf(m, "", kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
 	m.Echo("%s: %d", lib, mdb.Grow(m, m.PrefixKey(), prefix, kit.Dict(WORD, ice.SP)))
 }
 func (s alpha) List(m *ice.Message, arg ...string) {
@@ -54,8 +55,8 @@ func (s alpha) List(m *ice.Message, arg ...string) {
 		m.OptionFields(ice.FIELDS_DETAIL)
 		arg[1] = "^" + arg[1] + ice.FS
 	}
-	wiki.CSV(m.Message.Spawn(), m.Cmdx(cli.SYSTEM, "grep", "-rih", arg[1], m.Config(mdb.STORE)), kit.Split(m.Config(mdb.FIELD))...).Tables(func(value ice.Maps) {
+	wiki.CSV(m.Message.Spawn(), m.Cmdx(cli.SYSTEM, "grep", "-rih", arg[1], mdb.Config(m, mdb.STORE)), kit.Split(mdb.Config(m, mdb.FIELD))...).Tables(func(value ice.Maps) {
-		kit.If(m.FieldsIsDetail(), func() { m.PushDetail(value, m.Config(mdb.FIELD)) }, func() { m.PushRecord(value, m.Config(mdb.FIELD)) })
+		kit.If(m.FieldsIsDetail(), func() { m.PushDetail(value, mdb.Config(m, mdb.FIELD)) }, func() { m.PushRecord(value, mdb.Config(m, mdb.FIELD)) })
 	}).StatusTimeCount()
 }
 

misc/bash/bash.go

@@ -3,6 +3,8 @@ package bash
 import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
+	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/code"
@@ -13,10 +15,10 @@ const BASH = "bash"
 var Index = &ice.Context{Name: BASH, Help: "命令行", Commands: ice.Commands{
 	BASH: {Name: "bash path auto order build download", Help: "命令行", Actions: ice.MergeActions(ice.Actions{
 		cli.ORDER: {Hand: func(m *ice.Message, arg ...string) {
-			m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
+			m.Cmdy(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/bin")
 		}},
 	}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/bash/5.1_1/bash-5.1.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
-		m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
+		m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
 	}},
 }}
 

misc/bash/zsh.go

@@ -3,6 +3,8 @@ package bash
 import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
+	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/core/code"
 )
@@ -13,10 +15,10 @@ func init() {
 	Index.MergeCommands(ice.Commands{
 		ZSH: {Name: "zsh path auto order build download", Help: "命令行", Actions: ice.MergeActions(ice.Actions{
 			cli.ORDER: {Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
+				m.Cmdy(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/bin")
 			}},
 		}, code.InstallAction(nfs.SOURCE, "https://nchc.dl.sourceforge.net/project/zsh/zsh/5.8/zsh-5.8.tar.xz")), Hand: func(m *ice.Message, arg ...string) {
-			m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
+			m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
 		}},
 	})
 }

misc/chrome/cache.go

@@ -28,7 +28,7 @@ func (s cache) Create(m *ice.Message, arg ...string) *ice.Message {
 		s.Hash.Modify(m, kit.Simple(mdb.COUNT, count, mdb.TOTAL, total, mdb.VALUE, value)...)
 	})
 	name := kit.Keys(path.Base(m.Append(nfs.FILE)), path.Base(m.Append(mdb.TYPE)))
-	m.Cmdy(nfs.LINK, path.Join(m.Config(nfs.PATH), name), m.Append(nfs.FILE))
+	m.Cmdy(nfs.LINK, path.Join(mdb.Config(m, nfs.PATH), name), m.Append(nfs.FILE))
 	s.Hash.Modify(m, mdb.NAME, name)
 	web.ToastSuccess(m.Message)
 	return m

misc/coder/server.go

@@ -36,7 +36,7 @@ func (s server) Start(m *ice.Message, arg ...string) {
 user-data-dir: %s
 bind-addr: %s:%s
 password: %s
-`, "./data", kit.Select("0.0.0.0", m.Option(tcp.HOST)), path.Base(p), kit.Select(m.Config(aaa.PASSWORD), m.Option(aaa.PASSWORD))))
+`, "./data", kit.Select("0.0.0.0", m.Option(tcp.HOST)), path.Base(p), kit.Select(mdb.Config(m, aaa.PASSWORD), m.Option(aaa.PASSWORD))))
 		return []string{"--config=config", kit.Path(nfs.PWD)}
 	})
 }

misc/git/configs.go

@@ -40,7 +40,7 @@ func init() {
 	Index.MergeCommands(ice.Commands{
 		CONFIGS: {Name: "configs name value auto create init", Help: "配置键", Actions: ice.MergeActions(ice.Actions{
 			ice.INIT: {Help: "初始化", Hand: func(m *ice.Message, arg ...string) {
-				kit.Fetch(m.Configv(ice.INIT), func(p string, v ice.Any) {
+				kit.Fetch(mdb.Configv(m, ice.INIT), func(p string, v ice.Any) {
 					kit.Fetch(v, func(k string, v string) { _configs_set(m, kit.Keys(p, k), v) })
 				})
 			}},

misc/git/git.go

@@ -5,6 +5,8 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
+	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/code"
@@ -23,11 +25,11 @@ const GIT = "git"
 var Index = &ice.Context{Name: GIT, Help: "代码库", Commands: ice.Commands{
 	GIT: {Name: "git path auto order build download", Help: "代码库", Actions: ice.MergeActions(ice.Actions{
 		cli.ORDER: {Help: "加载", Hand: func(m *ice.Message, arg ...string) {
-			m.Cmd(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/libexec/git-core")
+			m.Cmd(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/libexec/git-core")
-			m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
+			m.Cmdy(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/bin")
 		}},
 	}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/git-cinnabar/git-2.31.1.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
-		m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
+		m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
 	}},
 }}
 

misc/git/server.go

@@ -23,7 +23,7 @@ import (
 )
 
 func _server_login(m *ice.Message) error {
-	if tcp.IsLocalHost(m, m.Option(ice.MSG_USERIP)) && m.Conf("web.serve", kit.Keym(tcp.LOCALHOST)) == ice.TRUE {
+	if tcp.IsLocalHost(m, m.Option(ice.MSG_USERIP)) && ice.Info.Localhost {
 		return nil
 	}
 	ls := strings.SplitN(m.R.Header.Get(web.Authorization), ice.SP, 2)

misc/git/status.go

@@ -82,7 +82,7 @@ func _status_tags(m *ice.Message) {
 }
 func _status_each(m *ice.Message, title string, cmds ...string) {
 	web.GoToast(m, kit.Select(strings.Join(cmds, ice.SP), title), func(toast func(string, int, int)) {
-		list, count, total := []string{}, 0, len(m.Confm(REPOS, mdb.HASH))
+		list, count, total := []string{}, 0, m.Cmd(REPOS).Length()
 		ReposList(m).Tables(func(value ice.Maps) {
 			toast(value[REPOS], count, total)
 			if msg := m.Cmd(cmds, kit.Dict(cli.CMD_DIR, value[nfs.PATH])); !cli.IsSuccess(msg) {

misc/git/total.go

@@ -45,7 +45,7 @@ func init() {
 			}
 			from, days, adds, dels, rest, commit := "", 0, 0, 0, 0, 0
 			ReposList(m).TableGo(func(value ice.Maps, lock *task.Lock) {
-				if m.Config(kit.Keys("skip", value[REPOS])) == ice.TRUE {
+				if mdb.Config(m, kit.Keys("skip", value[REPOS])) == ice.TRUE {
 					return
 				}
 				msg := m.Cmd("_sum", value[nfs.PATH], mdb.TOTAL, "10000")

misc/input/input.go

@@ -10,6 +10,7 @@ import (
 
 	"shylinux.com/x/ice"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
@@ -45,9 +46,9 @@ func (s input) Load(m *ice.Message, arg ...string) {
 	if f, e := nfs.OpenFile(m, m.Option(nfs.FILE)); !m.Warn(e) {
 		defer f.Close()
 		lib := kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.ZONE))
-		m.Assert(nfs.RemoveAll(m, path.Join(m.Config(mdb.STORE), lib)))
+		m.Assert(nfs.RemoveAll(m, path.Join(mdb.Config(m, mdb.STORE), lib)))
 		s.Zone.Remove(m, mdb.ZONE, lib)
-		s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, m.ConfigSimple(mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
+		s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, ctx.ConfigSimple(m.Message, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
 		prefix := kit.Keys(mdb.HASH, m.Result())
 		for bio := bufio.NewScanner(f); bio.Scan(); {
 			if strings.HasPrefix(bio.Text(), "# ") {
@@ -59,8 +60,8 @@ func (s input) Load(m *ice.Message, arg ...string) {
 			}
 			mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(TEXT, line[0], CODE, line[1], WEIGHT, kit.Select("999999", line, 2)))
 		}
-		m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
+		mdb.Conf(m, m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
-		m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
+		mdb.Conf(m, m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
 		m.Echo("%s: %d", lib, mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(TEXT, "成功", CODE, "z", WEIGHT, "0")))
 	}
 }
@@ -92,7 +93,7 @@ func (s input) List(m *ice.Message, arg ...string) {
 	case WORD:
 		arg[1] = "^" + arg[1] + ice.FS
 	}
-	res := m.Cmdx(cli.SYSTEM, "grep", "-rn", arg[1], m.Config(mdb.STORE))
+	res := m.Cmdx(cli.SYSTEM, "grep", "-rn", arg[1], mdb.Config(m, mdb.STORE))
 	bio := csv.NewReader(bytes.NewBufferString(strings.Replace(res, ice.DF, ice.FS, -1)))
 	for i := 0; i < kit.Int(10); i++ {
 		if line, e := bio.Read(); e != nil {

misc/lark/app.go

@@ -22,7 +22,7 @@ const APP = "app"
 func init() {
 	Index.MergeCommands(ice.Commands{
 		APP: {Name: "app appid auto token login", Help: "应用", Actions: ice.MergeActions(ice.Actions{
-			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, LARK, m.Config(tcp.SERVER)) }},
+			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, LARK, mdb.Config(m, tcp.SERVER)) }},
 			LOGIN: {Name: "login appid* appmm* duty", Help: "登录", Hand: func(m *ice.Message, arg ...string) {
 				mdb.HashCreate(m, m.OptionSimple(APPID, APPMM, DUTY))
 			}},

misc/lark/event.go

@@ -21,14 +21,14 @@ func init() {
 		EVENT: {Name: "event", Help: "事件", Actions: ice.Actions{
 			P2P_CHAT_CREATE: {Hand: func(m *ice.Message, arg ...string) {
 				if m.Option(OPEN_CHAT_ID) != "" {
-					m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), m.Conf(APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
+					m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), mdb.Conf(m, APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
 				}
 			}},
 			MESSAGE_READ: {Hand: func(m *ice.Message, arg ...string) {}},
 			CHAT_DISBAND: {Hand: func(m *ice.Message, arg ...string) {}},
 			ADD_BOT: {Hand: func(m *ice.Message, arg ...string) {
 				if m.Option(OPEN_CHAT_ID) != "" {
-					m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), m.Conf(APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
+					m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), mdb.Conf(m, APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
 				}
 			}},
 		}, Hand: func(m *ice.Message, arg ...string) { m.Cmdy(MSG, m.Option(MSG_TYPE)) }},

misc/lark/home.go

@@ -16,7 +16,7 @@ func init() {
 			name := kit.Select(m.Option(ice.MSG_USERNAME), m.Option(ice.MSG_USERNICK))
 			kit.If(len(name) > 10, func() { name = name[:10] })
 			name += "的" + kit.Select("应用列表", arg, 2)
-			text, link, list := kit.Select("", arg, 3), kit.MergeURL2(m.Conf(web.SHARE, kit.Keym(web.DOMAIN)), "/chat/lark/sso"), []string{}
+			text, link, list := kit.Select("", arg, 3), kit.MergeURL2(mdb.Conf(m, web.SHARE, kit.Keym(web.DOMAIN)), "/chat/lark/sso"), []string{}
 			if len(arg) == 0 {
 				m.Cmd("web.chat./river", func(val ice.Maps) {
 					m.Cmd("web.chat./river", val[mdb.HASH], chat.STORM, func(value ice.Maps) {

misc/mp/login.go

@@ -33,9 +33,9 @@ const LOGIN = "login"
 func init() {
 	Index.MergeCommands(ice.Commands{
 		web.PP(LOGIN): {Actions: ice.MergeActions(ice.Actions{
-			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, MP, m.Config(tcp.SERVER)) }},
+			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, MP, mdb.Config(m, tcp.SERVER)) }},
 			aaa.SESS: {Name: "sess code", Help: "会话", Hand: func(m *ice.Message, arg ...string) {
-				msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/sns/jscode2session?grant_type=authorization_code", "js_code", m.Option(cli.CODE), APPID, m.Config(APPID), "secret", m.Config(APPMM))
+				msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/sns/jscode2session?grant_type=authorization_code", "js_code", m.Option(cli.CODE), APPID, mdb.Config(m, APPID), "secret", mdb.Config(m, APPMM))
 				m.Option(ice.MSG_USERZONE, MP)
 				m.Echo(aaa.SessCreate(msg, msg.Append(OPENID)))
 			}},
@@ -54,20 +54,20 @@ func init() {
 				ctx.ConfigFromOption(m, APPID, APPMM)
 			}},
 			TOKENS: {Help: "令牌", Hand: func(m *ice.Message, arg ...string) {
-				if now := time.Now().Unix(); m.Config(TOKENS) == "" || now > kit.Int64(m.Config(EXPIRES)) {
+				if now := time.Now().Unix(); mdb.Config(m, TOKENS) == "" || now > kit.Int64(mdb.Config(m, EXPIRES)) {
-					msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, m.Config(APPID), "secret", m.Config(APPMM))
+					msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, mdb.Config(m, APPID), "secret", mdb.Config(m, APPMM))
 					if m.Warn(msg.Append(ERRCODE) != "", msg.Append(ERRCODE), msg.Append(ERRMSG)) {
 						return
 					}
-					m.Config(EXPIRES, now+kit.Int64(msg.Append("expires_in")))
+					mdb.Config(m, EXPIRES, now+kit.Int64(msg.Append("expires_in")))
-					m.Config(TOKENS, msg.Append("access_token"))
+					mdb.Config(m, TOKENS, msg.Append("access_token"))
 				}
-				m.Echo(m.Config(TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(m.Config(EXPIRES)), 0).Format(ice.MOD_TIME))
+				m.Echo(mdb.Config(m, TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(mdb.Config(m, EXPIRES)), 0).Format(ice.MOD_TIME))
 			}},
 			QRCODE: {Name: "qrcode path scene", Help: "扫码", Hand: func(m *ice.Message, arg ...string) {
 				msg := m.Cmd(web.SPIDE, MP, http.MethodPost, "/wxa/getwxacodeunlimit?access_token="+m.Cmdx(LOGIN, TOKENS), m.OptionSimple("path,scene"))
 				m.Echo(kit.Format(`<img src="data:image/png;base64,%s" title='%s'>`, base64.StdEncoding.EncodeToString([]byte(msg.Result())), "some")).ProcessInner()
 			}},
-		}, Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(APPID)) }},
+		}, Hand: func(m *ice.Message, arg ...string) { m.Echo(mdb.Config(m, APPID)) }},
 	})
 }

misc/ssh/rsa.go

@@ -53,7 +53,7 @@ func init() {
 				})
 			}},
 			mdb.IMPORT: {Name: "import key=.ssh/id_rsa pub=.ssh/id_rsa.pub", Hand: func(m *ice.Message, arg ...string) {
-				m.Conf("", kit.Keys(mdb.HASH, path.Base(m.Option(KEY))), kit.Data(mdb.TIME, m.Time(),
+				mdb.Conf(m, "", kit.Keys(mdb.HASH, path.Base(m.Option(KEY))), kit.Data(mdb.TIME, m.Time(),
 					TITLE, kit.Format("%s@%s", ice.Info.Username, ice.Info.Hostname),
 					PRIVATE, m.Cmdx(nfs.CAT, kit.HomePath(m.Option(KEY))),
 					PUBLIC, m.Cmdx(nfs.CAT, kit.HomePath(m.Option(PUB))),

misc/ssh/service.go

@@ -124,11 +124,11 @@ func _ssh_handle(m *ice.Message, channel ssh.Channel, pty, tty *os.File, list []
 	h := m.Cmdx(mdb.INSERT, m.Prefix(CHANNEL), "", mdb.HASH, mdb.STATUS, tcp.OPEN, TTY, tty.Name(), m.OptionSimple(aaa.USERNAME, tcp.HOSTPORT), kit.Dict(mdb.TARGET, pty))
 	p := _ssh_watch(m, h, pty, channel)
 	m.Go(func() { io.Copy(channel, pty) })
-	channel.Write([]byte(m.Config(WELCOME)))
+	channel.Write([]byte(mdb.Config(m, WELCOME)))
 	m.Options(cli.CMD_INPUT, tty, cli.CMD_OUTPUT, tty)
 	m.Cmd(cli.DAEMON, kit.Select("sh", kit.Env(cli.SHELL)), func() {
 		defer m.Cmd(mdb.MODIFY, m.Prefix(CHANNEL), "", mdb.HASH, mdb.HASH, h, mdb.STATUS, tcp.CLOSE)
-		channel.Write([]byte(m.Config(GOODBYE)))
+		channel.Write([]byte(mdb.Config(m, GOODBYE)))
 		channel.Close()
 		p.Close()
 	})
@@ -197,7 +197,7 @@ func init() {
 			mdb.SHORT, tcp.PORT, mdb.FIELD, "time,port,status,private,authkey,count", mdb.FIELDS, "time,id,type,name,text",
 			WELCOME, "welcome to contexts world\r\n", GOODBYE, "goodbye of contexts world\r\n",
 		)), Hand: func(m *ice.Message, arg ...string) {
-			m.Fields(len(arg), m.Config(mdb.FIELD), m.Config(mdb.FIELDS))
+			m.Fields(len(arg), mdb.Config(m, mdb.FIELD), mdb.Config(m, mdb.FIELDS))
 			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
 				m.PushAction(aaa.INVITE, mdb.INSERT, ctx.LOAD, ctx.SAVE, mdb.REMOVE)
 			}

misc/ssh/session.go

@@ -60,7 +60,7 @@ func init() {
 				}
 			}},
 		}, mdb.PageZoneAction(mdb.SHORT, mdb.UNIQ, mdb.FIELD, "time,hash,count,status,connect", mdb.FIELDS, "time,id,type,text")), Hand: func(m *ice.Message, arg ...string) {
-			m.Fields(len(kit.Slice(arg, 0, 2)), m.Config(mdb.FIELD), m.Config(mdb.FIELDS))
+			m.Fields(len(kit.Slice(arg, 0, 2)), mdb.Config(m, mdb.FIELD), mdb.Config(m, mdb.FIELDS))
 			if mdb.PageZoneSelect(m, arg...); len(arg) == 0 {
 				m.Tables(func(value ice.Maps) {
 					m.PushButton(kit.Select("", ctx.COMMAND, value[mdb.STATUS] == tcp.OPEN), mdb.REMOVE)

misc/tmux/session.go

@@ -180,17 +180,17 @@ func init() {
 			} else if len(arg) > 0 {
 				m.Cmdy(WINDOW, arg[0])
 			} else {
-				m.Split(_tmux_cmd(m, LIST_SESSION, "-F", m.Config(FORMAT)).Result(), m.Config(FIELDS), ice.FS, ice.NL)
+				m.Split(_tmux_cmd(m, LIST_SESSION, "-F", mdb.Config(m, FORMAT)).Result(), mdb.Config(m, FIELDS), ice.FS, ice.NL)
 			}
 			m.Tables(func(value ice.Maps) {
 				kit.If(value["tag"] == "1", func() { m.PushButton("") }, func() { m.PushButton(code.XTERM, mdb.SELECT, mdb.REMOVE) })
 			}).StatusTimeCount()
 		}},
 		WINDOW: {Hand: func(m *ice.Message, arg ...string) {
-			m.Split(m.Cmdx(cli.SYSTEM, TMUX, LIST_WINDOWS, "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
+			m.Split(m.Cmdx(cli.SYSTEM, TMUX, LIST_WINDOWS, "-t", kit.Select("", arg, 0), "-F", mdb.Config(m, FORMAT)), mdb.Config(m, FIELDS), ice.FS, ice.NL)
 		}},
 		PANE: {Hand: func(m *ice.Message, arg ...string) {
-			m.Split(_tmux_cmds(m, LIST_PANES, "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
+			m.Split(_tmux_cmds(m, LIST_PANES, "-t", kit.Select("", arg, 0), "-F", mdb.Config(m, FORMAT)), mdb.Config(m, FIELDS), ice.FS, ice.NL)
 		}},
 		VIEW: {Hand: func(m *ice.Message, arg ...string) {
 			m.Echo(_tmux_cmds(m, CAPTURE_PANE, "-p", "-t", kit.Select("", arg, 0)))

misc/tmux/tmux.go

@@ -3,6 +3,8 @@ package tmux
 import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
+	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/code"
@@ -17,10 +19,10 @@ var Index = &ice.Context{Name: TMUX, Help: "工作台", Commands: ice.Commands{
 			m.Optionv(code.PREPARE, func(p string) []string {
 				return []string{"-S", kit.Path(m.Option(cli.CMD_DIR, p), "tmux.socket"), NEW_SESSION, "-d", "-n", "miss"}
 			})
-			m.Cmdy(code.INSTALL, cli.START, m.Config(nfs.SOURCE), "bin/tmux")
+			m.Cmdy(code.INSTALL, cli.START, mdb.Config(m, nfs.SOURCE), "bin/tmux")
 		}},
 	}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/tmux/tmux-3.2.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
-		m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
+		m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
 	}},
 }}
 

misc/vim/vim.go

@@ -3,6 +3,8 @@ package vim
 import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
+	"shylinux.com/x/icebergs/base/ctx"
+	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/code"
@@ -13,10 +15,10 @@ const VIM = "vim"
 var Index = &ice.Context{Name: VIM, Help: "编辑器", Commands: ice.Commands{
 	VIM: {Name: "vim path auto order build download", Help: "编辑器", Actions: ice.MergeActions(ice.Actions{
 		cli.BUILD: {Hand: func(m *ice.Message, arg ...string) {
-			m.Cmdy(code.INSTALL, cli.BUILD, m.Config(nfs.SOURCE), "--enable-multibyte=yes", "--enable-cscope=yes", "--enable-luainterp=yes", "--enable-pythoninterp=yes")
+			m.Cmdy(code.INSTALL, cli.BUILD, mdb.Config(m, nfs.SOURCE), "--enable-multibyte=yes", "--enable-cscope=yes", "--enable-luainterp=yes", "--enable-pythoninterp=yes")
 		}},
 	}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/vim/vim-8.2.2681.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
-		m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
+		m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
 	}},
 }}
 

misc/wx/access.go

@@ -27,10 +27,10 @@ func _wx_sign(m *ice.Message, nonce, stamp string) string {
 }
 func _wx_config(m *ice.Message, nonce string) {
 	m.Option("signature", _wx_sign(m, m.Option("noncestr", nonce), m.Option("timestamp", kit.Format(time.Now().Unix()))))
-	m.OptionFromConfig(APPID, nfs.SCRIPT)
+	ctx.OptionFromConfig(m, APPID, nfs.SCRIPT)
 }
 func _wx_check(m *ice.Message) {
-	check := kit.Sort([]string{m.Config(TOKEN), m.Option("timestamp"), m.Option("nonce")})
+	check := kit.Sort([]string{mdb.Config(m, TOKEN), m.Option("timestamp"), m.Option("nonce")})
 	if sig := kit.Format(sha1.Sum([]byte(strings.Join(check, "")))); !m.Warn(sig != m.Option("signature"), ice.ErrNotRight, check) {
 		kit.If(m.Option("echostr") != "", func() { m.RenderResult(m.Option("echostr")) }, func() { m.Echo(ice.TRUE) })
 	}
@@ -57,43 +57,43 @@ func init() {
 	Index.MergeCommands(ice.Commands{
 		ACCESS: {Name: "access appid auto ticket tokens login", Help: "认证", Actions: ice.MergeActions(ice.Actions{
 			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(web.SPIDE, mdb.CREATE, WX, m.Config(tcp.SERVER))
+				m.Cmd(web.SPIDE, mdb.CREATE, WX, mdb.Config(m, tcp.SERVER))
 				gdb.Watch(m, chat.HEADER_AGENT, m.PrefixKey())
 			}},
 			chat.HEADER_AGENT: {Hand: func(m *ice.Message, arg ...string) {
 				if strings.Index(m.Option(ice.MSG_USERUA), "MicroMessenger") > -1 {
-					_wx_config(m, m.Config(APPID))
+					_wx_config(m, mdb.Config(m, APPID))
 				}
 			}},
 			LOGIN: {Name: "login appid appmm token", Help: "登录", Hand: func(m *ice.Message, arg ...string) {
 				ctx.ConfigFromOption(m, APPID, APPMM, TOKEN)
 			}},
 			TOKENS: {Help: "令牌", Hand: func(m *ice.Message, arg ...string) {
-				if now := time.Now().Unix(); m.Config(TOKENS) == "" || now > kit.Int64(m.Config(EXPIRES)) {
+				if now := time.Now().Unix(); mdb.Config(m, TOKENS) == "" || now > kit.Int64(mdb.Config(m, EXPIRES)) {
-					msg := m.Cmd(web.SPIDE, WX, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, m.Config(APPID), "secret", m.Config(APPMM))
+					msg := m.Cmd(web.SPIDE, WX, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, mdb.Config(m, APPID), "secret", mdb.Config(m, APPMM))
 					if m.Warn(msg.Append(ERRCODE) != "", msg.Append(ERRCODE), msg.Append(ERRMSG)) {
 						return
 					}
-					m.Config(EXPIRES, now+kit.Int64(msg.Append("expires_in")))
+					mdb.Config(m, EXPIRES, now+kit.Int64(msg.Append("expires_in")))
-					m.Config(TOKENS, msg.Append("access_token"))
+					mdb.Config(m, TOKENS, msg.Append("access_token"))
 				}
-				m.Echo(m.Config(TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(m.Config(EXPIRES)), 0).Format(ice.MOD_TIME))
+				m.Echo(mdb.Config(m, TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(mdb.Config(m, EXPIRES)), 0).Format(ice.MOD_TIME))
 			}},
 			TICKET: {Help: "票据", Hand: func(m *ice.Message, arg ...string) {
-				if now := time.Now().Unix(); m.Config(TICKET) == "" || now > kit.Int64(m.Config(EXPIRE)) {
+				if now := time.Now().Unix(); mdb.Config(m, TICKET) == "" || now > kit.Int64(mdb.Config(m, EXPIRE)) {
 					msg := m.Cmd(web.SPIDE, WX, http.MethodGet, "/cgi-bin/ticket/getticket?type=jsapi", "access_token", m.Cmdx("", TOKENS))
 					if m.Warn(msg.Append(ERRCODE) != "0", msg.Append(ERRCODE), msg.Append(ERRMSG)) {
 						return
 					}
-					m.Config(EXPIRE, now+kit.Int64(msg.Append("expires_in")))
+					mdb.Config(m, EXPIRE, now+kit.Int64(msg.Append("expires_in")))
-					m.Config(TICKET, msg.Append(TICKET))
+					mdb.Config(m, TICKET, msg.Append(TICKET))
 				}
-				m.Echo(m.Config(TICKET)).Status(EXPIRE, time.Unix(kit.Int64(m.Config(EXPIRE)), 0).Format(ice.MOD_TIME))
+				m.Echo(mdb.Config(m, TICKET)).Status(EXPIRE, time.Unix(kit.Int64(mdb.Config(m, EXPIRE)), 0).Format(ice.MOD_TIME))
 			}},
-			CONFIG: {Hand: func(m *ice.Message, arg ...string) { _wx_config(m, m.Config(APPID)) }},
+			CONFIG: {Hand: func(m *ice.Message, arg ...string) { _wx_config(m, mdb.Config(m, APPID)) }},
 			CHECK:  {Hand: func(m *ice.Message, arg ...string) { _wx_check(m) }},
 		}, mdb.HashAction(tcp.SERVER, "https://api.weixin.qq.com", nfs.SCRIPT, "/plugin/local/chat/wx.js")), Hand: func(m *ice.Message, arg ...string) {
-			m.Echo(m.Config(APPID))
+			m.Echo(mdb.Config(m, APPID))
 		}},
 	})
 }

misc/wx/favor.go

@@ -15,7 +15,7 @@ func init() {
 			mdb.SHORT, mdb.TEXT, mdb.FIELD, "time,type,name,text", mdb.LINK, "https://open.weixin.qq.com/qr/code",
 		), Hand: func(m *ice.Message, arg ...string) {
 			mdb.HashSelect(m, arg...).Tables(func(value ice.Maps) {
-				m.PushQRCode(mdb.SCAN, kit.MergeURL(m.Config(mdb.LINK), aaa.USERNAME, value[mdb.TEXT]))
+				m.PushQRCode(mdb.SCAN, kit.MergeURL(mdb.Config(m, mdb.LINK), aaa.USERNAME, value[mdb.TEXT]))
 			})
 		}},
 	})

misc/wx/text.go

@@ -10,7 +10,7 @@ import (
 )
 
 func _wx_reply(m *ice.Message, tmpl string) {
-	if res, err := kit.Render(m.Config(nfs.TEMPLATE), m); err == nil {
+	if res, err := kit.Render(mdb.Config(m, nfs.TEMPLATE), m); err == nil {
 		m.SetResult().RenderResult(string(res))
 	}
 }

option.go

@@ -18,12 +18,7 @@ func (m *Message) OptionFields(arg ...string) string {
 	}
 	return kit.Join(kit.Simple(m.Optionv(MSG_FIELDS)))
 }
-func (m *Message) OptionFromConfig(arg ...string) string {
+
-	for _, key := range arg {
-		m.Option(key, m.Config(key))
-	}
-	return m.Option(arg[0])
-}
 func (m *Message) OptionDefault(arg ...string) string {
 	for i := 0; i < len(arg); i += 2 {
 		if m.Option(arg[i]) == "" && arg[i+1] != "" {
@@ -34,7 +29,7 @@ func (m *Message) OptionDefault(arg ...string) string {
 }
 func (m *Message) OptionSimple(key ...string) (res []string) {
 	if len(key) == 0 {
-		for _, k := range kit.Split(kit.Select("type,name,text", m.Config(FIELD))) {
+		for _, k := range kit.Split(kit.Select("type,name,text", m.Conf(m.PrefixKey(), kit.Keym(FIELD)))) {
 			switch k {
 			case TIME, HASH:
 				continue

type.go

@@ -18,12 +18,12 @@ type List = []Any
 type Map = map[string]Any
 type Maps = map[string]string
 type Handler func(m *Message, arg ...string)
+type Messages = map[string]*Message
+type Contexts = map[string]*Context
 type Commands = map[string]*Command
 type Actions = map[string]*Action
 type Configs = map[string]*Config
 type Caches = map[string]*Cache
-type Contexts = map[string]*Context
-type Messages = map[string]*Message
 
 type Cache struct {
 	Name  string
@@ -87,7 +87,7 @@ func (c *Context) Cmd(m *Message, key string, arg ...string) *Message {
 func (c *Context) Server() Server {
 	return c.server
 }
-func (c *Context) PrefixKey(arg ...string) string {
+func (c *Context) Prefix(arg ...string) string {
 	return kit.Keys(c.Cap(CTX_FOLLOW), arg)
 }
 func (c *Command) GetFileLine() string {
@@ -522,9 +522,6 @@ func (m *Message) Cmdx(arg ...Any) string {
 func (m *Message) Cmdy(arg ...Any) *Message {
 	return m.Copy(m._command(arg...))
 }
-func (m *Message) Confi(key string, sub string) int {
-	return kit.Int(m.Conf(key, sub))
-}
 func (m *Message) Confv(arg ...Any) (val Any) {
 	if m.Spawn().Warn(Info.Important && m.Option("_lock") == "") {
 		m.Warn(true, "what unsafe lock", m.PrefixKey(), m.FormatStack(1, 100))
@@ -556,14 +553,6 @@ func (m *Message) Confv(arg ...Any) (val Any) {
 	}
 	return
 }
-func (m *Message) Confm(key string, sub Any, cbs ...Any) Map {
-	val := m.Confv(key, sub)
-	if len(cbs) > 0 {
-		kit.Fetch(val, cbs[0])
-	}
-	value, _ := val.(Map)
-	return value
-}
 func (m *Message) Conf(arg ...Any) string {
 	return kit.Format(m.Confv(arg...))
 }