opt base

base/cli/daemon.go

@@ -151,7 +151,7 @@ func init() {
 				}
 			})
 
-			if len(arg) == 0 || len(m.Appendv(ice.MSG_APPEND)) > 0 {
+			if len(arg) == 0 || m.Length() > 0 {
 				return
 			}
 			_daemon_exec(m, _system_cmd(m, arg...))

base/ctx/command.go

@@ -41,7 +41,10 @@ func _command_search(m *ice.Message, kind, name, text string) {
 			return
 		}
 
-		m.PushSearch(kit.MDB_TYPE, COMMAND, kit.MDB_NAME, cmd.Name, kit.MDB_TEXT, cmd.Help, CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key)
+		m.PushSearch(ice.CTX, kit.PathName(1), ice.CMD, kit.FileName(1),
+			kit.MDB_TYPE, s.Cap(ice.CTX_FOLLOW), kit.MDB_NAME, cmd.Name, kit.MDB_TEXT, cmd.Help,
+			CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key,
+		)
 	})
 }
 

base/ctx/context.go

@@ -5,8 +5,11 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _context_list(m *ice.Message, all bool) {
+func _context_list(m *ice.Message, sub *ice.Context) {
 	m.Travel(func(p *ice.Context, s *ice.Context) {
+		if sub != nil && sub != p {
+			return
+		}
 		m.Push(kit.MDB_NAME, s.Cap(ice.CTX_FOLLOW))
 		m.Push(kit.MDB_STATUS, s.Cap(ice.CTX_STATUS))
 		m.Push(kit.MDB_STREAM, s.Cap(ice.CTX_STREAM))
@@ -25,7 +28,7 @@ func init() {
 
 				switch kit.Select(CONTEXT, arg, 1) {
 				case CONTEXT:
-					_context_list(msg, true)
+					_context_list(msg, s)
 				case COMMAND:
 					msg.Cmdy(COMMAND, arg[2:])
 				case CONFIG:

base/gdb/event.go

@@ -7,6 +7,7 @@ import (
 )
 
 func _event_listen(m *ice.Message, event string, cmd string) {
+	m.Cmdy(mdb.INSERT, EVENT, "", mdb.HASH, EVENT, event)
 	m.Cmdy(mdb.INSERT, EVENT, "", mdb.ZONE, event, ice.CMD, cmd)
 }
 func _event_action(m *ice.Message, event string, arg ...string) {

base/gdb/timer.go

@@ -46,7 +46,7 @@ func init() {
 			kit.MDB_FIELD, "time,hash,delay,interval,order,next,cmd", TICK, "1s",
 		)},
 	}, Commands: map[string]*ice.Command{
-		TIMER: {Name: "timer hash id auto create prunes", Help: "定时器", Action: ice.MergeAction(map[string]*ice.Action{
+		TIMER: {Name: "timer hash id auto create action prunes", Help: "定时器", Action: ice.MergeAction(map[string]*ice.Action{
 			mdb.CREATE: {Name: "create delay=10ms interval=10s order=3 cmd=runtime", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(mdb.INSERT, TIMER, "", mdb.HASH, DELAY, "10ms", INTERVAL, "10m", ORDER, 1, NEXT, m.Time(m.Option(DELAY)), arg)
 			}},
@@ -58,13 +58,10 @@ func init() {
 				_timer_action(m, arg...)
 			}},
 		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) == 0 {
+			m.Fields(len(arg), m.Config(kit.MDB_FIELD), "time,id,res")
-				m.OptionFields(m.Config(kit.MDB_FIELD))
+			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
-				defer m.PushAction(mdb.REMOVE)
+				m.PushAction(mdb.REMOVE)
-			} else {
-				m.OptionFields("time,id,res")
 			}
-			mdb.ZoneSelect(m, arg...)
 		}},
 	}})
 }

base/log/log.go

@@ -76,8 +76,8 @@ const (
 	RED    = "red"
 )
 const (
-	WATCH = "watch"
 	BENCH = "bench"
+	WATCH = "watch"
 	ERROR = "error"
 	TRACE = "trace"
 )
@@ -89,17 +89,19 @@ const (
 
 var Index = &ice.Context{Name: "log", Help: "日志模块", Configs: map[string]*ice.Config{
 	FILE: {Name: FILE, Help: "日志文件", Value: kit.Dict(
+		BENCH, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "bench.log"), kit.MDB_LIST, []string{}),
 		WATCH, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "watch.log"), kit.MDB_LIST, []string{
 			ice.LOG_CREATE, ice.LOG_REMOVE,
 			ice.LOG_INSERT, ice.LOG_DELETE,
 			ice.LOG_MODIFY, ice.LOG_SELECT,
 			ice.LOG_EXPORT, ice.LOG_IMPORT,
 		}),
-		BENCH, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "bench.log"), kit.MDB_LIST, []string{}),
 		ERROR, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "error.log"), kit.MDB_LIST, []string{
-			ice.LOG_WARN, ice.LOG_ERROR, ice.LOG_DEBUG,
+			ice.LOG_WARN, ice.LOG_ERROR,
+		}),
+		TRACE, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "trace.log"), kit.MDB_LIST, []string{
+			ice.LOG_DEBUG,
 		}),
-		TRACE, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "trace.log"), kit.MDB_LIST, []string{}),
 	)},
 	VIEW: {Name: VIEW, Help: "日志格式", Value: kit.Dict(
 		GREEN, kit.Dict(PREFIX, "\033[32m", SUFFIX, "\033[0m", kit.MDB_LIST, []string{
@@ -135,8 +137,7 @@ var Index = &ice.Context{Name: "log", Help: "日志模块", Configs: map[string]
 			}
 		})
 	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {}},
-	}},
 }}
 
 func init() { ice.Index.Register(Index, &Frame{}) }

base/mdb/engine.go

@@ -9,27 +9,24 @@ const ENGINE = "engine"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		ENGINE: {Name: "engine", Help: "引擎", Value: kit.Data(kit.MDB_SHORT, kit.MDB_TYPE)},
+		ENGINE: {Name: ENGINE, Help: "引擎", Value: kit.Data(
+			kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
+		)},
 	}, Commands: map[string]*ice.Command{
-		ENGINE: {Name: "engine type name text auto", Help: "引擎", Action: map[string]*ice.Action{
+		ENGINE: {Name: "engine type name text auto", Help: "引擎", Action: ice.MergeAction(map[string]*ice.Action{
-			CREATE: {Name: "create type cmd ctx", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
-				m.Log_CREATE(ENGINE, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1))
+				m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple("type,name,text"))
-				m.Rich(ENGINE, nil, kit.Dict(kit.MDB_TYPE, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1), kit.MDB_TEXT, kit.Select("", arg, 2)))
 			}},
-		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) == 0 || arg[0] == "" {
+			if len(arg) > 1 {
-				m.Richs(ENGINE, nil, kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+				m.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
-					m.Push(key, value, []string{kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT})
+					m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]),
+						m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
 				})
-				return
 			}
-
+			if HashSelect(m, arg...); len(arg) == 0 {
-			if len(arg) == 2 {
+				m.Sort(kit.MDB_TYPE)
-				arg = append(arg, "")
 			}
-			m.Richs(ENGINE, nil, arg[0], func(key string, value map[string]interface{}) {
-				m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]), ENGINE, arg[0], arg[1], arg[2], arg[3:])
-			})
 		}},
 	}})
 }

base/mdb/plugin.go

@@ -9,24 +9,24 @@ const PLUGIN = "plugin"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		PLUGIN: {Name: "plugin", Help: "插件", Value: kit.Data(kit.MDB_SHORT, kit.MDB_TYPE)},
+		PLUGIN: {Name: "plugin", Help: "插件", Value: kit.Data(
+			kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
+		)},
 	}, Commands: map[string]*ice.Command{
 		PLUGIN: {Name: "plugin type name text auto", Help: "插件", Action: map[string]*ice.Action{
-			CREATE: {Name: "create type cmd ctx", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
-				m.Log_CREATE(PLUGIN, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1))
+				m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple("type,name,text"))
-				m.Rich(PLUGIN, nil, kit.Dict(kit.MDB_TYPE, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1), kit.MDB_TEXT, kit.Select("", arg, 2)))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) == 0 || arg[0] == "" {
+			if len(arg) > 1 {
-				m.Richs(PLUGIN, nil, kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+				m.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
-					m.Push(key, value, []string{kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT})
+					m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]),
+						m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
 				})
-				return
 			}
-
+			if HashSelect(m, arg...); len(arg) == 0 {
-			m.Richs(PLUGIN, nil, arg[0], func(key string, value map[string]interface{}) {
+				m.Sort(kit.MDB_TYPE)
-				m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]), PLUGIN, arg[0], arg[1], kit.Select("", arg, 2))
+			}
-			})
 		}},
 	}})
 }

base/mdb/render.go

@@ -9,24 +9,24 @@ const RENDER = "render"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		RENDER: {Name: "render", Help: "渲染", Value: kit.Data(kit.MDB_SHORT, kit.MDB_TYPE)},
+		RENDER: {Name: "render", Help: "渲染", Value: kit.Data(
+			kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
+		)},
 	}, Commands: map[string]*ice.Command{
 		RENDER: {Name: "render type name text auto", Help: "渲染", Action: map[string]*ice.Action{
-			CREATE: {Name: "create type cmd ctx", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
-				m.Log_CREATE(RENDER, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1))
+				m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple("type,name,text"))
-				m.Rich(RENDER, nil, kit.Dict(kit.MDB_TYPE, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1), kit.MDB_TEXT, kit.Select("", arg, 2)))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) == 0 || arg[0] == "" {
+			if len(arg) > 1 {
-				m.Richs(RENDER, nil, kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+				m.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
-					m.Push(key, value, []string{kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT})
+					m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]),
+						m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
 				})
-				return
 			}
-
+			if HashSelect(m, arg...); len(arg) == 0 {
-			m.Richs(RENDER, nil, arg[0], func(key string, value map[string]interface{}) {
+				m.Sort(kit.MDB_TYPE)
-				m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]), RENDER, arg[0], arg[1], kit.Select("", arg, 2))
+			}
-			})
 		}},
 	}})
 }

base/mdb/search.go

@@ -1,8 +1,6 @@
 package mdb
 
 import (
-	"strings"
-
 	ice "shylinux.com/x/icebergs"
 	kit "shylinux.com/x/toolkits"
 )
@@ -11,28 +9,27 @@ const SEARCH = "search"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		SEARCH: {Name: "search", Help: "搜索", Value: kit.Data(kit.MDB_SHORT, kit.MDB_TYPE)},
+		SEARCH: {Name: "search", Help: "搜索", Value: kit.Data(
+			kit.MDB_SHORT, kit.MDB_TYPE, kit.MDB_FIELD, "time,type,name,text",
+		)},
 	}, Commands: map[string]*ice.Command{
 		SEARCH: {Name: "search type word text auto", Help: "搜索", Action: map[string]*ice.Action{
-			CREATE: {Name: "create type cmd ctx", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
-				m.Log_CREATE(SEARCH, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1))
+				m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple("type,name,text"))
-				m.Rich(SEARCH, nil, kit.Dict(kit.MDB_TYPE, arg[0], kit.MDB_NAME, kit.Select(arg[0], arg, 1), kit.MDB_TEXT, kit.Select("", arg, 2)))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) == 0 || arg[0] == "" {
+			msg := m.Spawn(c)
-				m.Richs(SEARCH, nil, kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+			if len(arg) > 1 {
-					m.Push(key, value, []string{kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT})
+				msg.Optionv(kit.Keycb(SELECT), func(fields []string, value map[string]interface{}) {
-				})
+					m.OptionFields(kit.Select("ctx,cmd,type,name,text", kit.Select(m.OptionFields(), arg, 2)))
-				return
+					m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]), m.CommandKey(), arg[0], arg[1], kit.Select("", arg, 2))
-			}
-
-			m.OptionFields(kit.Select("ctx,cmd,time,size,type,name,text", kit.Select(m.OptionFields(), arg, 2)))
-			for _, k := range strings.Split(arg[0], ",") {
-				for _, kk := range strings.Split(arg[1], ",") {
-					m.Richs(SEARCH, nil, k, func(key string, value map[string]interface{}) {
-						m.Cmdy(kit.Keys(value[kit.MDB_TEXT], value[kit.MDB_NAME]), SEARCH, k, kk, kit.Select("", arg, 2))
 				})
 			}
+			if HashSelect(msg, arg...); len(arg) == 0 {
+				m.Copy(msg)
+				m.Sort(kit.MDB_TYPE)
+			} else if len(arg) == 1 {
+				m.Copy(msg)
 			}
 		}},
 	}})

base/mdb/zone.go

@@ -168,5 +168,6 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
 func ZoneSelect(m *ice.Message, arg ...string) *ice.Message {
 	m.Fields(len(arg), kit.Fields(kit.MDB_TIME, m.Config(kit.MDB_SHORT), kit.MDB_COUNT), m.Config(kit.MDB_FIELD))
 	m.Cmdy(SELECT, m.PrefixKey(), "", ZONE, arg)
+	m.Sort(m.Config(kit.MDB_SHORT))
 	return m
 }

base/nfs/cat.go

@@ -134,7 +134,7 @@ func init() {
 		)},
 	}, Commands: map[string]*ice.Command{
 		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Cmd(mdb.RENDER, mdb.CREATE, CAT)
+			m.Cmd(mdb.RENDER, mdb.CREATE, CAT, m.Prefix(CAT))
 		}},
 		CAT: {Name: "cat path auto", Help: "文件", Action: map[string]*ice.Action{
 			mdb.RENDER: {Name: "render type name text", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {

base/nfs/dir.go

@@ -185,8 +185,8 @@ func init() {
 		DIR: {Name: DIR, Help: "目录", Value: kit.Data()},
 	}, Commands: map[string]*ice.Command{
 		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Cmd(mdb.SEARCH, mdb.CREATE, DIR)
+			m.Cmd(mdb.SEARCH, mdb.CREATE, DIR, m.Prefix(DIR))
-			m.Cmd(mdb.RENDER, mdb.CREATE, DIR)
+			m.Cmd(mdb.RENDER, mdb.CREATE, DIR, m.Prefix(DIR))
 		}},
 		DIR: {Name: "dir path field... auto upload", Help: "目录", Action: map[string]*ice.Action{
 			mdb.SEARCH: {Name: "search type name", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {

base/tcp/port.go

@@ -61,6 +61,7 @@ func init() {
 					m.Push(PORT, path.Base(value[kit.MDB_PATH]))
 					m.Push(kit.MDB_SIZE, value[kit.MDB_SIZE])
 				})
+				m.SortInt(PORT)
 				return
 			}
 			m.Option(nfs.DIR_ROOT, path.Join(m.Conf(cli.DAEMON, kit.META_PATH), arg[0]))

base/tcp/server.go

@@ -94,6 +94,7 @@ func init() {
 			m.Richs(SERVER, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
 				kit.Value(value, kit.Keym(kit.MDB_STATUS), CLOSE)
 			})
+			m.Cmdy(SERVER, mdb.PRUNES)
 		}},
 		SERVER: {Name: "server hash auto prunes", Help: "服务器", Action: ice.MergeAction(map[string]*ice.Action{
 			LISTEN: {Name: "LISTEN type name port=9030 host=", Help: "监听", Hand: func(m *ice.Message, arg ...string) {

base/web/cache.go

@@ -138,7 +138,7 @@ const CACHE = "cache"
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
 		CACHE: {Name: CACHE, Help: "缓存池", Value: kit.Data(
-			kit.MDB_SHORT, kit.MDB_TEXT, kit.MDB_SHORT, "time,hash,size,type,name,text",
+			kit.MDB_SHORT, kit.MDB_TEXT, kit.MDB_FIELD, "time,hash,size,type,name,text",
 			kit.MDB_STORE, ice.VAR_DATA, kit.MDB_PATH, ice.VAR_FILE, kit.MDB_FSIZE, "200000",
 			kit.MDB_LIMIT, "50", kit.MDB_LEAST, "30",
 		)},

core/chat/header.go

@@ -43,7 +43,7 @@ func _header_share(m *ice.Message, arg ...string) {
 
 	m.Option(kit.MDB_LINK, kit.MergeURL(m.Option(kit.MDB_LINK), RIVER, "", STORM, ""))
 
-	m.Set(kit.MDB_NAME, kit.MDB_TEXT)
+	m.Set("name,text")
 	m.Push(kit.MDB_NAME, m.Option(kit.MDB_LINK))
 	m.PushQRCode(kit.MDB_TEXT, m.Option(kit.MDB_LINK))
 }

core/team/task.go

@@ -140,7 +140,7 @@ func init() {
 		},
 		Commands: map[string]*ice.Command{
 			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Cmd(mdb.SEARCH, mdb.CREATE, TASK, m.Prefix(TASK))
+				// m.Cmd(mdb.SEARCH, mdb.CREATE, TASK, m.Prefix(TASK))
 			}},
 			TASK: {Name: "task zone id auto insert export import", Help: "任务", Action: ice.MergeAction(map[string]*ice.Action{
 				mdb.INSERT: {Name: "insert zone type=once,step,week name text begin_time@date close_time@date", Help: "添加", Hand: func(m *ice.Message, arg ...string) {

logs.go

@@ -147,7 +147,7 @@ func (m *Message) FormatSize() string {
 	if len(m.meta[MSG_APPEND]) == 0 {
 		return kit.Format("%dx%d %s", 0, 0, "[]")
 	} else {
-		return kit.Format("%dx%d %v", len(m.meta[m.meta[MSG_APPEND][0]]), len(m.meta[MSG_APPEND]), kit.Format(m.meta[MSG_APPEND]))
+		return kit.Format("%dx%d %v", len(m.meta[m.meta[MSG_APPEND][0]]), len(m.meta[MSG_APPEND]), kit.Simple(m.meta[MSG_APPEND]))
 	}
 }
 func (m *Message) FormatMeta() string {
@@ -155,16 +155,14 @@ func (m *Message) FormatMeta() string {
 }
 func (m *Message) FormatStack() string {
 	pc := make([]uintptr, 100)
-	pc = pc[:runtime.Callers(5, pc)]
+	frames := runtime.CallersFrames(pc[:runtime.Callers(5, pc)])
-	frames := runtime.CallersFrames(pc)
 
 	meta := []string{}
 	for {
 		frame, more := frames.Next()
-		file := kit.Split(frame.File, "/")
+		file := kit.Slice(kit.Split(frame.File, PS, PS), -1)[0]
-		name := kit.Split(frame.Function, "/")
+		name := kit.Slice(kit.Split(frame.Function, PS, PS), -1)[0]
-		meta = append(meta, kit.Format("%s:%d\t%s", file[len(file)-1], frame.Line, name[len(name)-1]))
+		if meta = append(meta, kit.Format("%s:%d\t%s", file, frame.Line, name)); !more {
-		if !more {
 			break
 		}
 	}
@@ -180,34 +178,28 @@ func (m *Message) FormatChain() string {
 	for i := len(ms) - 1; i >= 0; i-- {
 		msg := ms[i]
 
-		if len(msg.meta[MSG_DETAIL]) > 0 {
+		meta = append(meta, kit.Format("%s %s:%d %v %s:%d %v %s:%d %v %s:%d %v", msg.FormatPrefix(),
-			meta = append(meta, kit.Format("%s %s:%d %v", msg.FormatPrefix(), MSG_DETAIL, len(msg.meta[MSG_DETAIL]), msg.meta[MSG_DETAIL]))
+			MSG_DETAIL, len(msg.meta[MSG_DETAIL]), msg.meta[MSG_DETAIL],
-		} else {
+			MSG_OPTION, len(msg.meta[MSG_OPTION]), msg.meta[MSG_OPTION],
-			meta = append(meta, kit.Format("%s ", msg.FormatPrefix()))
+			MSG_APPEND, len(msg.meta[MSG_APPEND]), msg.meta[MSG_APPEND],
-		}
+			MSG_RESULT, len(msg.meta[MSG_RESULT]), msg.meta[MSG_RESULT],
+		))
 
 		if len(msg.meta[MSG_OPTION]) > 0 {
-			meta = append(meta, kit.Format("%s:%d %v", MSG_OPTION, len(msg.meta[MSG_OPTION]), msg.meta[MSG_OPTION]))
 			for _, k := range msg.meta[MSG_OPTION] {
 				if v, ok := msg.meta[k]; ok {
 					meta = append(meta, kit.Format("\t%s: %d %v", k, len(v), v))
 				}
 			}
-		} else {
-			meta = append(meta, NL)
 		}
 
 		if len(msg.meta[MSG_APPEND]) > 0 {
-			meta = append(meta, kit.Format("%s:%d %v", MSG_APPEND, len(msg.meta[MSG_APPEND]), msg.meta[MSG_APPEND]))
 			for _, k := range msg.meta[MSG_APPEND] {
 				if v, ok := msg.meta[k]; ok {
 					meta = append(meta, kit.Format("\t%s: %d %v", k, len(v), v))
 				}
 			}
 		}
-		if len(msg.meta[MSG_RESULT]) > 0 {
-			meta = append(meta, kit.Format("%s:%d %v", MSG_RESULT, len(msg.meta[MSG_RESULT]), msg.meta[MSG_RESULT]))
-		}
 	}
 	return kit.Join(meta, NL)
 }

meta.go

@@ -43,7 +43,9 @@ func (m *Message) Set(key string, arg ...string) *Message {
 			}
 			return m
 		}
-		delete(m.meta, key)
+		for _, k := range kit.Split(key) {
+			delete(m.meta, k)
+		}
 	}
 	return m.Add(key, arg...)
 }
@@ -162,6 +164,12 @@ func (m *Message) Copy(msg *Message, arg ...string) *Message {
 	for _, k := range msg.meta[MSG_OPTION] {
 		m.Add(MSG_OPTION, kit.Simple(k, msg.meta[k])...)
 	}
+	for _, k := range msg.meta[MSG_APPEND] {
+		if i := kit.IndexOf(m.meta[MSG_OPTION], k); i > -1 {
+			m.meta[MSG_OPTION][i] = ""
+			delete(m.meta, k)
+		}
+	}
 	for _, k := range msg.meta[MSG_APPEND] {
 		m.Add(MSG_APPEND, kit.Simple(k, msg.meta[k])...)
 	}

misc.go

@@ -11,6 +11,14 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
+func (m *Message) Length() (max int) {
+	for _, k := range m.meta[MSG_APPEND] {
+		if l := len(m.meta[k]); l > max {
+			max = l
+		}
+	}
+	return max
+}
 func (m *Message) CSV(text string, head ...string) *Message {
 	bio := bytes.NewBufferString(text)
 	r := csv.NewReader(bio)
@@ -202,6 +210,7 @@ func (c *Context) cmd(m *Message, cmd *Command, key string, arg ...string) *Mess
 
 	m.Log(LOG_CMDS, "%s.%s %d %v %s", c.Name, key, len(arg), arg,
 		kit.Select(kit.FileLine(cmd.Hand, 3), kit.FileLine(9, 3), m.target.Name == "mdb"))
+
 	cmd.Hand(m, c, key, arg...)
 	return m
 }

option.go

@@ -80,6 +80,11 @@ func (m *Message) Fields(length int, fields ...string) string {
 }
 func (m *Message) Upload(dir string) {
 	up := kit.Simple(m.Optionv(MSG_UPLOAD))
+	if len(up) < 2 {
+		msg := m.Cmd("cache", "upload")
+		up = kit.Simple(msg.Append(kit.MDB_HASH), msg.Append(kit.MDB_NAME), msg.Append(kit.MDB_SIZE))
+	}
+
 	if p := path.Join(dir, up[1]); m.Option(MSG_USERPOD) == "" {
 		m.Cmdy("cache", "watch", up[0], p) // 本机文件
 	} else { // 下发文件

type.go

@@ -385,8 +385,8 @@ func (m *Message) Search(key string, cb interface{}) *Message {
 
 	case func(p *Context, s *Context, key string, cmd *Command):
 		if key == "" {
-			for k, v := range p.Commands {
+			for key, cmd := range p.Commands {
-				cb(p.context, p, k, v)
+				cb(p.context, p, key, cmd)
 			}
 			break
 		}