opt base

base/base.go

@@ -9,7 +9,6 @@ import (
 	_ "shylinux.com/x/icebergs/base/gdb"
 	_ "shylinux.com/x/icebergs/base/lex"
 	_ "shylinux.com/x/icebergs/base/log"
-
 	_ "shylinux.com/x/icebergs/base/yac"
 
 	_ "shylinux.com/x/icebergs/base/mdb"

base/base.shy

@@ -1,4 +1,4 @@
-label "base" `
+label `
 ctx cli web aaa
 lex yac gdb log
 tcp nfs ssh mdb

base/gdb/event.go

@@ -7,12 +7,10 @@ import (
 )
 
 func _event_listen(m *ice.Message, event string, cmd string) {
-	h := m.Cmdx(mdb.INSERT, EVENT, "", mdb.HASH, EVENT, event)
+	m.Cmdy(mdb.INSERT, EVENT, "", mdb.ZONE, event, ice.CMD, cmd)
-	m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, ice.CMD, cmd)
 }
 func _event_action(m *ice.Message, event string, arg ...string) {
-	m.Option(mdb.FIELDS, "time,id,cmd")
+	mdb.ZoneSelect(m, event).Table(func(index int, value map[string]string, head []string) {
-	m.Cmd(mdb.SELECT, EVENT, kit.Keys(kit.MDB_HASH, kit.Hashs(event)), mdb.LIST).Table(func(index int, value map[string]string, head []string) {
 		m.Cmd(kit.Split(value[ice.CMD]), event, arg).Cost(EVENT, event, ice.ARG, arg)
 	})
 }
@@ -20,32 +18,22 @@ func _event_action(m *ice.Message, event string, arg ...string) {
 const EVENT = "event"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		EVENT: {Name: EVENT, Help: "事件流", Value: kit.Data(
-			EVENT: {Name: EVENT, Help: "事件流", Value: kit.Data(kit.MDB_SHORT, EVENT)},
+			kit.MDB_SHORT, EVENT, kit.MDB_FIELD, "time,id,cmd",
-		},
+		)},
-		Commands: map[string]*ice.Command{
+	}, Commands: map[string]*ice.Command{
-			EVENT: {Name: "event event id auto listen", Help: "事件流", Action: map[string]*ice.Action{
+		EVENT: {Name: "event event id auto listen", Help: "事件流", Action: ice.MergeAction(map[string]*ice.Action{
 			LISTEN: {Name: "listen event cmd", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
 				_event_listen(m, m.Option(EVENT), m.Option(ice.CMD))
 			}},
 			ACTION: {Name: "action event arg", Help: "触发", Hand: func(m *ice.Message, arg ...string) {
 				_event_action(m, m.Option(EVENT), arg[2:]...)
 			}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
+		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-					m.Cmdy(mdb.DELETE, EVENT, "", mdb.HASH, EVENT, m.Option(EVENT))
+			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if len(arg) == 0 { // 事件列表
-					m.Fields(len(arg), "time,event,count")
-					m.Cmdy(mdb.SELECT, EVENT, "", mdb.HASH)
 				m.PushAction(ACTION, mdb.REMOVE)
-					return
 			}
-
-				m.Fields(len(arg[1:]), "time,id,cmd")
-				m.Cmdy(mdb.SELECT, EVENT, kit.Keys(kit.MDB_HASH, kit.Hashs(arg[0])), mdb.LIST, kit.MDB_ID, arg[1:])
 		}},
-		},
+	}})
-	})
 }

base/gdb/gdb.go

@@ -5,8 +5,6 @@ import (
 	"time"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
-	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
 
@@ -34,8 +32,8 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
 		case s := <-f.s:
 			m.Cmd(SIGNAL, ACTION, SIGNAL, s)
 
-		case <-f.t:
+			// case <-f.t:
-			_timer_action(m.Spawn())
+			// m.Cmd(TIMER, ACTION)
 		}
 	}
 	return true
@@ -46,12 +44,8 @@ func (f *Frame) Close(m *ice.Message, arg ...string) bool {
 
 const GDB = "gdb"
 
-var Index = &ice.Context{Name: GDB, Help: "事件模块",
+var Index = &ice.Context{Name: GDB, Help: "事件模块", Commands: map[string]*ice.Command{
-	Commands: map[string]*ice.Command{
 	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Cmd(nfs.SAVE, kit.Select(m.Conf(SIGNAL, kit.META_PATH), m.Conf(cli.RUNTIME, kit.Keys(cli.CONF, cli.CTX_PID))),
-				m.Conf(cli.RUNTIME, kit.Keys(cli.HOST, cli.PID)))
-
 		m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", ice.CMD, "exit 0")
 		m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", ice.CMD, "exit 1")
 		m.Load()
@@ -60,9 +54,8 @@ var Index = &ice.Context{Name: GDB, Help: "事件模块",
 		if f, ok := m.Target().Server().(*Frame); ok {
 			f.e <- true
 		}
-			m.Save(TIMER)
+		m.Save()
 	}},
-	},
+}}
-}
 
 func init() { ice.Index.Register(Index, &Frame{}, ROUTINE, SIGNAL, EVENT, TIMER) }

base/gdb/routine.go

@@ -5,57 +5,35 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
-	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
 )
 
-const (
-	TASK_HASH = "task.hash"
-)
 const (
 	INNER = "inner"
 )
 const ROUTINE = "routine"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		ROUTINE: {Name: ROUTINE, Help: "协程池", Value: kit.Data(
-			ROUTINE: {Name: ROUTINE, Help: "协程池", Value: kit.Data()},
+			kit.MDB_SHORT, "time,hash,status,fileline",
-		},
+		)},
-		Commands: map[string]*ice.Command{
+	}, Commands: map[string]*ice.Command{
-			ROUTINE: {Name: "routine hash auto prunes", Help: "协程池", Action: map[string]*ice.Action{
+		ROUTINE: {Name: "routine hash auto prunes", Help: "协程池", Action: ice.MergeAction(map[string]*ice.Action{
-				mdb.CREATE: {Name: "create fileline status", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			mdb.CREATE: {Name: "create fileline status", Help: "创建"},
-					m.Cmdy(mdb.INSERT, ROUTINE, "", mdb.HASH, arg)
-				}},
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, ROUTINE, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), arg)
-				}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.DELETE, ROUTINE, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
-				}},
 			mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
-					m.Option(mdb.FIELDS, "time,hash,status,fileline")
+				m.OptionFields(m.Config(kit.MDB_SHORT))
-					m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, kit.MDB_STATUS, cli.ERROR)
 				m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, kit.MDB_STATUS, cli.STOP)
+				m.Cmdy(mdb.PRUNES, ROUTINE, "", mdb.HASH, kit.MDB_STATUS, cli.ERROR)
 			}},
-
 			INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
-					switch kit.Select("", arg, 0) {
-					case ice.RUN:
-						m.Cmdy(INNER, arg[1:])
-					default:
 				ls := kit.Split(m.Option("fileline"), ":")
-						m.ProcessField(INNER, ice.RUN)
+				m.ProcessCommand(INNER, []string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}, arg...)
-						m.Option(ice.ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
-						m.Cmdy(ctx.COMMAND, INNER)
-					}
 			}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), "time,hash,status,fileline")
+			mdb.HashSelect(m, arg...)
-				m.Cmdy(mdb.SELECT, ROUTINE, "", mdb.HASH, kit.MDB_HASH, arg)
 			m.PushAction(INNER, mdb.REMOVE)
 		}},
-		},
+	}})
-	})
 }

base/gdb/signal.go

@@ -7,8 +7,11 @@ import (
 	"syscall"
 
 	ice "shylinux.com/x/icebergs"
+	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
+	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
+	log "shylinux.com/x/toolkits/logs"
 )
 
 func _signal_listen(m *ice.Message, s int, arg ...string) {
@@ -17,10 +20,8 @@ func _signal_listen(m *ice.Message, s int, arg ...string) {
 		signal.Notify(f.s, syscall.Signal(s))
 	}
 }
-func _signal_action(m *ice.Message, s int) {
+func _signal_action(m *ice.Message, arg ...string) {
-	m.Option(mdb.FIELDS, "time,signal,name,cmd")
+	mdb.HashSelect(m.Spawn(), arg...).Table(func(index int, value map[string]string, head []string) {
-	msg := m.Cmd(mdb.SELECT, SIGNAL, "", mdb.HASH, SIGNAL, s)
-	msg.Table(func(index int, value map[string]string, head []string) {
 		m.Cmdy(kit.Split(value[ice.CMD]))
 	})
 }
@@ -44,29 +45,32 @@ const (
 const SIGNAL = "signal"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		SIGNAL: {Name: SIGNAL, Help: "信号器", Value: kit.Data(
-				kit.MDB_PATH, path.Join(ice.VAR_RUN, "ice.pid"), kit.MDB_SHORT, SIGNAL,
+			kit.MDB_SHORT, SIGNAL, kit.MDB_FIELD, "time,signal,name,cmd",
+			kit.MDB_PATH, path.Join(ice.VAR_RUN, "ice.pid"),
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			SIGNAL: {Name: "signal signal auto listen", Help: "信号器", Action: map[string]*ice.Action{
+			if log.LogDisable {
+				return // 禁用日志
+			}
+			m.Cmd(nfs.SAVE, kit.Select(m.Conf(SIGNAL, kit.META_PATH), m.Conf(cli.RUNTIME, kit.Keys(cli.CONF, cli.CTX_PID))),
+				m.Conf(cli.RUNTIME, kit.Keys(cli.HOST, cli.PID)))
+
+			m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", ice.CMD, "exit 0")
+			m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", ice.CMD, "exit 1")
+		}},
+		SIGNAL: {Name: "signal signal auto listen", Help: "信号器", Action: ice.MergeAction(map[string]*ice.Action{
 			LISTEN: {Name: "listen signal name cmd", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
 				_signal_listen(m, kit.Int(m.Option(SIGNAL)), arg...)
 			}},
 			ACTION: {Name: "action signal", Help: "触发", Hand: func(m *ice.Message, arg ...string) {
-					_signal_action(m, kit.Int(m.Option(SIGNAL)))
+				_signal_action(m, m.Option(SIGNAL))
 			}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-					m.Cmdy(mdb.DELETE, SIGNAL, "", mdb.HASH, SIGNAL, m.Option(SIGNAL))
+			mdb.HashSelect(m, arg...).Sort(SIGNAL)
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), "time,signal,name,cmd")
-				m.Cmdy(mdb.SELECT, SIGNAL, "", mdb.HASH, SIGNAL, arg)
 			m.PushAction(ACTION, mdb.REMOVE)
-				m.Sort(SIGNAL)
 		}},
-		},
+	}})
-	})
 }

base/gdb/timer.go

@@ -9,12 +9,9 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _timer_create(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)
-}
 func _timer_action(m *ice.Message, arg ...string) {
 	now := time.Now().UnixNano()
-	m.Option(mdb.FIELDS, "time,hash,delay,interval,order,next,cmd")
+	m.OptionFields(m.Config(kit.MDB_FIELD))
 
 	m.Richs(TIMER, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
 		if value = kit.GetMeta(value); value[kit.MDB_STATUS] == cli.STOP {
@@ -44,40 +41,31 @@ const (
 const TIMER = "timer"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		TIMER: {Name: TIMER, Help: "定时器", Value: kit.Data(
-			TIMER: {Name: TIMER, Help: "定时器", Value: kit.Data(TICK, "10ms")},
+			kit.MDB_FIELD, "time,hash,delay,interval,order,next,cmd",
-		},
+			TICK, "10ms",
-		Commands: map[string]*ice.Command{
+		)},
-			TIMER: {Name: "timer hash id auto create prunes", Help: "定时器", Action: map[string]*ice.Action{
+	}, Commands: map[string]*ice.Command{
+		TIMER: {Name: "timer hash id auto create 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) {
-					_timer_create(m, arg...)
+				m.Cmdy(mdb.INSERT, TIMER, "", mdb.HASH, DELAY, "10ms", INTERVAL, "10m", ORDER, 1, NEXT, m.Time(m.Option(DELAY)), arg)
-				}},
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, TIMER, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), arg)
-				}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.DELETE, TIMER, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
 			}},
 			mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
-					m.Option(mdb.FIELDS, "time,hash,delay,interval,order,next,cmd")
+				m.OptionFields(m.Config(kit.MDB_FIELD))
 				m.Cmdy(mdb.PRUNES, TIMER, "", mdb.HASH, ORDER, 0)
 			}},
-
 			ACTION: {Name: "action", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 				_timer_action(m, arg...)
 			}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) == 0 {
-					m.Fields(len(arg), "time,hash,delay,interval,order,next,cmd")
+				m.OptionFields(m.Config(kit.MDB_FIELD))
-					m.Cmdy(mdb.SELECT, TIMER, "", mdb.HASH, kit.MDB_HASH, arg)
+				defer m.PushAction(mdb.REMOVE)
-					m.PushAction(mdb.REMOVE)
+			} else {
-					return
+				m.OptionFields("time,id,res")
 			}
-
+			mdb.ZoneSelect(m, arg...)
-				m.Fields(len(arg[1:]), "time,id,res")
-				m.Cmdy(mdb.SELECT, TIMER, kit.Keys(kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, arg[1:])
 		}},
-		},
+	}})
-	})
 }

base/lex/lex.go

@@ -2,32 +2,10 @@ package lex
 
 import (
 	ice "shylinux.com/x/icebergs"
-	kit "shylinux.com/x/toolkits"
 )
 
-func _lex_load(m *ice.Message) {
-	m.Richs(m.Prefix(MATRIX), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
-		value = kit.GetMeta(value)
-
-		mat := NewMatrix(m, kit.Int(kit.Select("32", value[NLANG])), kit.Int(kit.Select("256", value[NCELL])))
-		m.Grows(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
-			mat.Train(m, kit.Format(value[NPAGE]), kit.Format(value[NHASH]), kit.Format(value[kit.MDB_TEXT]))
-		})
-		value[MATRIX] = mat
-	})
-}
-
 const LEX = "lex"
 
-var Index = &ice.Context{Name: LEX, Help: "词法模块",
+var Index = &ice.Context{Name: LEX, Help: "词法模块"}
-	Commands: map[string]*ice.Command{
-		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
-			// _lex_load(m.Load())
-		}},
-		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
-			m.Save()
-		}},
-	},
-}
 
 func init() { ice.Index.Register(Index, nil) }

base/lex/matrix.go

@@ -358,6 +358,17 @@ func (mat *Matrix) show(m *ice.Message) {
 
 	m.Status(NLANG, mat.nlang, NCELL, mat.ncell, NPAGE, len(mat.page), NHASH, len(mat.hash))
 }
+func _lex_load(m *ice.Message) {
+	m.Richs(m.Prefix(MATRIX), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+		value = kit.GetMeta(value)
+
+		mat := NewMatrix(m, kit.Int(kit.Select("32", value[NLANG])), kit.Int(kit.Select("256", value[NCELL])))
+		m.Grows(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+			mat.Train(m, kit.Format(value[NPAGE]), kit.Format(value[NHASH]), kit.Format(value[kit.MDB_TEXT]))
+		})
+		value[MATRIX] = mat
+	})
+}
 
 const (
 	NLANG = "nlang"
@@ -374,11 +385,12 @@ const (
 const MATRIX = "matrix"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		MATRIX: {Name: MATRIX, Help: "魔方矩阵", Value: kit.Data()},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
+			// _lex_load(m.Load())
+		}},
 		MATRIX: {Name: "matrix hash npage text auto", Help: "魔方矩阵", Action: map[string]*ice.Action{
 			mdb.CREATE: {Name: "create nlang=32 ncell=128", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
 				mat := NewMatrix(m, kit.Int(kit.Select("32", m.Option(NLANG))), kit.Int(kit.Select("128", m.Option(NCELL))))
@@ -456,6 +468,5 @@ func init() {
 				m.Push("word", string(word))
 			})
 		}},
-		},
+	}})
-	})
 }

base/log/log.go

@@ -6,6 +6,7 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	kit "shylinux.com/x/toolkits"
+	log "shylinux.com/x/toolkits/logs"
 )
 
 type Log struct {
@@ -38,6 +39,9 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
 			file := kit.Select(BENCH, m.Conf(SHOW, kit.Keys(l.l, FILE)))
 			view := m.Confm(VIEW, m.Conf(SHOW, kit.Keys(l.l, VIEW)))
 			bio := m.Confv(FILE, kit.Keys(file, FILE)).(*bufio.Writer)
+			if bio == nil {
+				continue
+			}
 
 			bio.WriteString(l.p)
 			bio.WriteString(ice.SP)
@@ -81,8 +85,7 @@ const (
 	SHOW = "show"
 )
 
-var Index = &ice.Context{Name: "log", Help: "日志模块",
+var Index = &ice.Context{Name: "log", Help: "日志模块", Configs: map[string]*ice.Config{
-	Configs: map[string]*ice.Config{
 	FILE: {Name: FILE, Help: "日志文件", Value: kit.Dict(
 		WATCH, kit.Dict(kit.MDB_PATH, path.Join(ice.VAR_LOG, "watch.log"), kit.MDB_LIST, []string{
 			ice.LOG_CREATE, ice.LOG_REMOVE,
@@ -109,8 +112,7 @@ var Index = &ice.Context{Name: "log", Help: "日志模块",
 		}),
 	)},
 	SHOW: {Name: SHOW, Help: "日志分流", Value: kit.Dict()},
-	},
+}, Commands: map[string]*ice.Command{
-	Commands: map[string]*ice.Command{
 	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 		m.Confm(VIEW, nil, func(key string, value map[string]interface{}) {
 			kit.Fetch(value[kit.MDB_LIST], func(index int, k string) {
@@ -121,6 +123,9 @@ var Index = &ice.Context{Name: "log", Help: "日志模块",
 			kit.Fetch(value[kit.MDB_LIST], func(index int, k string) {
 				m.Conf(SHOW, kit.Keys(k, FILE), key)
 			})
+			if log.LogDisable {
+				return // 禁用日志
+			}
 			// 日志文件
 			if f, p, e := kit.Create(kit.Format(value[kit.MDB_PATH])); m.Assert(e) {
 				m.Cap(ice.CTX_STREAM, path.Base(p))
@@ -130,13 +135,11 @@ var Index = &ice.Context{Name: "log", Help: "日志模块",
 		})
 	}},
 	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if f, ok := m.Target().Server().(*Frame); ok {
+		if f, ok := m.Target().Server().(*Frame); ok { // 关闭日志
-				// 关闭日志
 			ice.Info.Log = nil
 			close(f.p)
 		}
 	}},
-	},
+}}
-}
 
 func init() { ice.Index.Register(Index, &Frame{}) }

base/nfs/cat.go

@@ -36,22 +36,18 @@ func _cat_right(m *ice.Message, name string) bool {
 	case ice.USR:
 		switch kit.Select("", ls, 1) {
 		case "local":
-			if m.Warn(m.Option(ice.MSG_USERROLE) == aaa.VOID, ice.ErrNotRight, "of", name) {
+			if m.Warn(m.Option(ice.MSG_USERROLE) == aaa.VOID, ice.ErrNotRight, ice.OF, name) {
 				return false
 			}
 		}
 	case ice.ETC, ice.VAR:
-		if m.Warn(m.Option(ice.MSG_USERROLE) == aaa.VOID, ice.ErrNotRight, "of", name) {
+		if m.Warn(m.Option(ice.MSG_USERROLE) == aaa.VOID, ice.ErrNotRight, ice.OF, name) {
 			return false
 		}
 	}
 	return true
 }
 func _cat_find(m *ice.Message, name string) io.ReadCloser {
-	// if m.Option("content") != "" {
-	// 	return NewReadCloser(bytes.NewBufferString(m.Option("content")))
-	// }
-
 	if f, e := os.Open(path.Join(m.Option(DIR_ROOT), name)); e == nil {
 		return f
 	}
@@ -71,7 +67,7 @@ func _cat_find(m *ice.Message, name string) io.ReadCloser {
 	}
 	return NewReadCloser(bytes.NewBufferString(msg.Result()))
 }
-func _cat_show(m *ice.Message, name string) {
+func _cat_list(m *ice.Message, name string) {
 	if !_cat_right(m, name) {
 		return // 没有权限
 	}
@@ -119,6 +115,7 @@ func _cat_show(m *ice.Message, name string) {
 const (
 	PATH = "path"
 	FILE = "file"
+	LINE = "line"
 	SIZE = "size"
 
 	CAT_LOCAL = "cat_local"
@@ -129,23 +126,26 @@ func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
 		CAT: {Name: CAT, Help: "文件", Value: kit.Data(
 			kit.SSH_SOURCE, kit.Dict(
-				"sh", "true", "shy", "true", "py", "true",
+				"sh", ice.TRUE, "shy", ice.TRUE, "py", ice.TRUE,
-				"go", "true", "vim", "true", "js", "true",
+				"go", ice.TRUE, "vim", ice.TRUE, "js", ice.TRUE,
-				"json", "true", "conf", "true", "yml", "true",
+				"json", ice.TRUE, "conf", ice.TRUE, "yml", ice.TRUE,
-				"makefile", "true",
+				"makefile", ice.TRUE, "license", ice.TRUE, "md", ice.TRUE,
 			),
 		)},
 	}, 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)
+		}},
 		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) {
-				_cat_show(m, path.Join(arg[2], arg[1]))
+				_cat_list(m, path.Join(arg[2], arg[1]))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) == 0 || strings.HasSuffix(arg[0], "/") {
 				m.Cmdy(DIR, arg)
-			} else {
+				return
-				_cat_show(m, arg[0])
 			}
+			_cat_list(m, arg[0])
 		}},
 	}})
 }

base/nfs/dir.go

@@ -3,23 +3,19 @@ package nfs
 import (
 	"bufio"
 	"crypto/sha1"
-	"encoding/hex"
-	"fmt"
 	"io/ioutil"
 	"os"
 	"path"
 	"regexp"
-	"sort"
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
-	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
 )
 
-func _dir_show(m *ice.Message, root string, name string, level int, deep bool, dir_type string, dir_reg *regexp.Regexp, fields []string) *ice.Message {
+func _dir_list(m *ice.Message, root string, name string, level int, deep bool, dir_type string, dir_reg *regexp.Regexp, fields []string) *ice.Message {
 	if !_cat_right(m, name) {
 		return m // 没有权限
 	}
@@ -66,7 +62,6 @@ func _dir_show(m *ice.Message, root string, name string, level int, deep bool, d
 					}
 				case "full":
 					m.Push(field, path.Join(root, name, f.Name())+kit.Select("", "/", f.IsDir()))
-
 				case kit.MDB_PATH:
 					m.Push(field, path.Join(name, f.Name())+kit.Select("", "/", f.IsDir()))
 				case kit.MDB_FILE:
@@ -74,9 +69,6 @@ func _dir_show(m *ice.Message, root string, name string, level int, deep bool, d
 				case kit.MDB_NAME:
 					m.Push(field, f.Name())
 
-				case kit.MDB_LINK:
-					m.PushDownload(kit.MDB_LINK, kit.Select("", f.Name(), !f.IsDir()), path.Join(root, name, f.Name()))
-
 				case kit.MDB_SIZE:
 					if f.IsDir() {
 						if ls, e := ioutil.ReadDir(path.Join(root, name, f.Name())); e == nil {
@@ -110,9 +102,9 @@ func _dir_show(m *ice.Message, root string, name string, level int, deep bool, d
 						if d, e := ioutil.ReadDir(p); m.Assert(e) {
 							meta := []string{}
 							for _, v := range d {
-								meta = append(meta, fmt.Sprintf("%s%d%s", v.Name(), v.Size(), v.ModTime()))
+								meta = append(meta, kit.Format("%s%d%s", v.Name(), v.Size(), v.ModTime()))
 							}
-							sort.Strings(meta)
+							kit.Sort(meta)
 							h = sha1.Sum([]byte(strings.Join(meta, "")))
 						}
 					} else {
@@ -121,23 +113,24 @@ func _dir_show(m *ice.Message, root string, name string, level int, deep bool, d
 						}
 					}
 
-					m.Push(kit.MDB_HASH, kit.Select(hex.EncodeToString(h[:6]), hex.EncodeToString(h[:]), field == kit.MDB_HASH))
+					m.Push(kit.MDB_HASH, kit.Select(kit.Format(h[:6]), kit.Format(h[:]), field == kit.MDB_HASH))
-				case ctx.ACTION:
+				case kit.MDB_LINK:
-					if !f.IsDir() && !m.IsCliUA() && m.Option(ice.MSG_USERROLE) != aaa.VOID {
+					m.PushDownload(kit.MDB_LINK, kit.Select("", f.Name(), !f.IsDir()), path.Join(root, name, f.Name()))
-						m.PushButton(TRASH)
-					} else {
-						m.Push(field, "")
-					}
 				case "show":
-					p := kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/local/"+path.Join(name, f.Name()), "pod", m.Option(ice.MSG_USERPOD))
+					p := kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/local/"+path.Join(name, f.Name()), ice.POD, m.Option(ice.MSG_USERPOD))
 					switch kit.Ext(f.Name()) {
-					case "jpg":
+					case "jpg", "png":
 						m.PushImages(field, p)
 					case "mp4":
 						m.PushVideos(field, p)
 					default:
 						m.Push(field, "")
 					}
+				case kit.MDB_ACTION:
+					if m.IsCliUA() || m.Option(ice.MSG_USERROLE) == aaa.VOID {
+						break
+					}
+					m.PushButton(kit.Select("", TRASH, !f.IsDir()))
 				default:
 					m.Push(field, "")
 				}
@@ -145,17 +138,13 @@ func _dir_show(m *ice.Message, root string, name string, level int, deep bool, d
 		}
 
 		if f.IsDir() && deep {
-			_dir_show(m, root, path.Join(name, f.Name()), level+1, deep, dir_type, dir_reg, fields)
+			_dir_list(m, root, path.Join(name, f.Name()), level+1, deep, dir_type, dir_reg, fields)
 		}
 	}
 	return m
 }
 func _dir_search(m *ice.Message, kind, name string) {
-	if kind == kit.MDB_FOREACH {
+	msg := _dir_list(m.Spawn(), "./", "", 0, true, TYPE_BOTH, nil, kit.Split("time,type,name"))
-		return
-	}
-
-	msg := _dir_show(m.Spawn(), "./", "", 0, true, TYPE_BOTH, nil, strings.Split("time,type,name,text", ","))
 	msg.Table(func(index int, value map[string]string, head []string) {
 		if !strings.Contains(value[kit.MDB_NAME], name) {
 			return
@@ -192,18 +181,23 @@ const (
 const DIR = "dir"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		DIR: {Name: DIR, Help: "目录", Value: kit.Data()},
-		},
+	}, Commands: map[string]*ice.Command{
-		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.RENDER, mdb.CREATE, 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) {
+				if arg[0] == kit.MDB_FOREACH {
+					return
+				}
 				_dir_search(m, arg[0], arg[1])
 			}},
 			mdb.RENDER: {Name: "render type name text", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
-					_dir_show(m, arg[2], arg[1], 0, m.Option(DIR_DEEP) == ice.TRUE, kit.Select(TYPE_BOTH, m.Option(DIR_TYPE)),
+				_dir_list(m, arg[2], arg[1], 0, m.Option(DIR_DEEP) == ice.TRUE, kit.Select(TYPE_BOTH, m.Option(DIR_TYPE)),
-						nil, kit.Split("time,size,type,path"))
+					nil, kit.Split(kit.Select("time,size,type,path", m.OptionFields())))
 			}},
 			mdb.UPLOAD: {Name: "upload", Help: "上传", Hand: func(m *ice.Message, arg ...string) {
 				m.Upload(m.Option(kit.MDB_PATH))
@@ -212,15 +206,10 @@ func init() {
 				m.Cmdy(TRASH, m.Option(kit.MDB_PATH))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if len(arg) == 0 {
+			_dir_list(m, kit.Select("./", m.Option(DIR_ROOT)), kit.Select("", arg, 0),
-					arg = append(arg, "")
+				0, m.Option(DIR_DEEP) == ice.TRUE, kit.Select(TYPE_BOTH, m.Option(DIR_TYPE)), kit.Regexp(m.Option(DIR_REG)),
-				}
+				kit.Split(kit.Select(kit.Select("time,path,size,action", m.OptionFields()), kit.Join(kit.Slice(arg, 1)))))
-				m.Debug("dir_root: %s", m.Option(DIR_ROOT))
-				_dir_show(m, kit.Select("./", m.Option(DIR_ROOT)), arg[0],
-					0, m.Options(DIR_DEEP), kit.Select(TYPE_BOTH, m.Option(DIR_TYPE)), kit.Regexp(m.Option(DIR_REG)),
-					kit.Split(kit.Select(kit.Select("time,path,size,action", m.Option(mdb.FIELDS)), strings.Join(arg[1:], ","))))
 			m.SortTimeR(kit.MDB_TIME)
 		}},
-		},
+	}})
-	})
 }

base/nfs/nfs.go

@@ -2,19 +2,8 @@ package nfs
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/mdb"
 )
 
-var Index = &ice.Context{Name: "nfs", Help: "存储模块", Commands: map[string]*ice.Command{
+var Index = &ice.Context{Name: "nfs", Help: "存储模块"}
-	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Load()
-		m.Cmd(mdb.RENDER, mdb.CREATE, CAT)
-		m.Cmd(mdb.SEARCH, mdb.CREATE, DIR)
-		m.Cmd(mdb.RENDER, mdb.CREATE, DIR)
-	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Save()
-	}},
-}}
 
 func init() { ice.Index.Register(Index, nil, CAT, DIR, TAIL, TRASH, SAVE, PUSH, COPY, LINK, DEFS) }

base/nfs/save.go

@@ -22,6 +22,11 @@ func _save_file(m *ice.Message, name string, text ...string) {
 		m.Echo(p)
 	}
 }
+func _defs_file(m *ice.Message, name string, text ...string) {
+	if _, e := os.Stat(path.Join(m.Option(DIR_ROOT), name)); os.IsNotExist(e) {
+		_save_file(m, name, text...)
+	}
+}
 func _push_file(m *ice.Message, name string, text ...string) {
 	p := path.Join(m.Option(DIR_ROOT), name)
 	if strings.Contains(p, "/") {
@@ -65,21 +70,15 @@ func _link_file(m *ice.Message, name string, from string) {
 	os.Link(from, name)
 	m.Echo(name)
 }
-func _defs_file(m *ice.Message, name string, text ...string) {
-	if _, e := os.Stat(path.Join(m.Option(DIR_ROOT), name)); os.IsNotExist(e) {
-		_save_file(m, name, text...)
-	}
-}
 
 const SAVE = "save"
+const DEFS = "defs"
 const PUSH = "push"
 const COPY = "copy"
 const LINK = "link"
-const DEFS = "defs"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
 		SAVE: {Name: "save file text...", Help: "保存", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) == 1 {
 				arg = append(arg, m.Option(kit.MDB_CONTENT))
@@ -92,15 +91,14 @@ func init() {
 			}
 			_push_file(m, arg[0], arg[1:]...)
 		}},
+		DEFS: {Name: "defs file text...", Help: "默认", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			_defs_file(m, arg[0], arg[1:]...)
+		}},
 		COPY: {Name: "copy file from...", Help: "复制", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			_copy_file(m, arg[0], arg[1:]...)
 		}},
 		LINK: {Name: "link file from", Help: "链接", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			_link_file(m, arg[0], arg[1])
 		}},
-			DEFS: {Name: "defs file text...", Help: "默认", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+	}})
-				_defs_file(m, arg[0], arg[1:]...)
-			}},
-		},
-	})
 }

base/nfs/tail.go

@@ -39,7 +39,9 @@ const TAIL = "tail"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		TAIL: {Name: TAIL, Help: "日志流", Value: kit.Data(kit.MDB_SHORT, kit.MDB_NAME)},
+		TAIL: {Name: TAIL, Help: "日志流", Value: kit.Data(
+			kit.MDB_SHORT, kit.MDB_NAME, kit.MDB_FIELD, "time,id,file,text",
+		)},
 	}, Commands: map[string]*ice.Command{
 		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Richs(TAIL, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
@@ -55,11 +57,8 @@ func init() {
 					m.ProcessAgain()
 				case kit.MDB_NAME:
 					m.Push(arg[0], kit.Split(m.Option(FILE), "/"))
-				case "limit":
+				case kit.MDB_LIMIT:
-					m.Push("limit", 10)
+					m.Push(arg[0], kit.List("10", "20", "30", "50"))
-					m.Push("limit", 20)
-					m.Push("limit", 30)
-					m.Push("limit", 50)
 				}
 			}},
 			mdb.CREATE: {Name: "create file name", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
@@ -71,7 +70,7 @@ func init() {
 			m.Option(mdb.CACHE_OFFEND, kit.Select("0", arg, 3))
 			m.Option(mdb.CACHE_LIMIT, kit.Select("10", arg, 2))
 
-			m.Cmd(mdb.SELECT, TAIL, "", mdb.ZONE, arg).Table(func(index int, value map[string]string, head []string) {
+			mdb.ZoneSelect(m.Spawn(c), arg...).Table(func(index int, value map[string]string, head []string) {
 				if strings.Contains(value[kit.MDB_TEXT], m.Option(mdb.CACHE_FILTER)) {
 					m.Push("", value, head)
 				}
@@ -83,6 +82,5 @@ func init() {
 				m.StatusTimeCountTotal(_tail_count(m, arg[0]))
 			}
 		}},
-	},
+	}})
-	})
 }

base/nfs/trash.go

@@ -29,41 +29,35 @@ func _trash_create(m *ice.Message, name string) {
 		}
 	}
 }
-func _trash_prunes(m *ice.Message) {
-	m.Cmd(mdb.DELETE, TRASH, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
-}
 
 const TRASH = "trash"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		TRASH: {Name: TRASH, Help: "回收站", Value: kit.Data(
-				kit.MDB_SHORT, kit.MDB_FROM, kit.MDB_PATH, ice.VAR_TRASH,
+			kit.MDB_SHORT, kit.MDB_FROM, kit.MDB_FIELD, "time,hash,file,from",
+			kit.MDB_PATH, ice.VAR_TRASH,
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		TRASH: {Name: "trash file auto prunes", Help: "回收站", Action: ice.MergeAction(map[string]*ice.Action{
-			TRASH: {Name: "trash file auto prunes", Help: "回收站", Action: map[string]*ice.Action{
 			mdb.REVERT: {Name: "revert", Help: "恢复", Hand: func(m *ice.Message, arg ...string) {
 				os.Rename(m.Option(kit.MDB_FILE), m.Option(kit.MDB_FROM))
-					m.Cmd(mdb.DELETE, TRASH, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
+				m.Cmd(mdb.DELETE, TRASH, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH))
 			}},
 			mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
 				os.Remove(m.Option(kit.MDB_FILE))
-					m.Cmd(mdb.DELETE, TRASH, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
+				m.Cmd(mdb.DELETE, TRASH, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH))
 			}},
 			mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
-					_trash_prunes(m)
+				m.Cmd(mdb.DELETE, TRASH, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH))
 			}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) == 0 {
-					m.Fields(len(arg), "time,hash,file,from")
+				mdb.HashSelect(m, arg...)
-					m.Cmdy(mdb.SELECT, TRASH, "", mdb.HASH)
 				m.PushAction(mdb.REVERT, mdb.REMOVE)
 				return
 			}
 			_trash_create(m, arg[0])
 		}},
-		},
+	}})
-	})
 }

base/ssh/scripts.go

@@ -14,52 +14,30 @@ import (
 	"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 Render(msg *ice.Message, cmd string, args ...interface{}) string {
+func Render(msg *ice.Message, cmd string, args ...interface{}) (res string) {
 	switch arg := kit.Simple(args...); cmd {
 	case ice.RENDER_VOID:
+		return res
 	case ice.RENDER_RESULT:
-		// 转换结果
 		if len(arg) > 0 {
 			msg.Resultv(arg)
 		}
-		res := msg.Result()
+		res = msg.Result()
-
-		// 输出结果
-		if fmt.Fprint(msg.O, res); !strings.HasSuffix(res, ice.NL) {
-			fmt.Fprint(msg.O, ice.NL)
-		}
-		return res
 
 	default:
-		// 转换结果
+		if res = msg.Result(); res == "" {
-		res := msg.Result()
-		if res == "" {
 			res = msg.Table().Result()
 		}
-
+	}
-		// 输出结果
 	if fmt.Fprint(msg.O, res); !strings.HasSuffix(res, ice.NL) {
 		fmt.Fprint(msg.O, ice.NL)
 	}
 	return res
 }
-	return ""
-}
-func Script(m *ice.Message, name string) io.Reader {
-	if strings.Contains(m.Option(ice.MSG_SCRIPT), "/") {
-		name = path.Join(path.Dir(m.Option(ice.MSG_SCRIPT)), name)
-	}
-	m.Option(ice.MSG_SCRIPT, name)
-
-	// 远程文件
-	if msg := m.Cmd("nfs.cat", name); msg.Result(0) != ice.ErrWarn {
-		return bytes.NewBuffer([]byte(msg.Result()))
-	}
-	return nil
-}
 
 type Frame struct {
 	source string
@@ -68,10 +46,10 @@ type Frame struct {
 	stdin  io.Reader
 	pipe   io.Writer
 
-	count int
-	last  string
 	ps1   []string
 	ps2   []string
+	res   string
+	count int
 }
 
 func (f *Frame) prompt(m *ice.Message, list ...string) *Frame {
@@ -105,33 +83,6 @@ func (f *Frame) printf(m *ice.Message, res string, arg ...interface{}) *Frame {
 	}
 	return f
 }
-func (f *Frame) option(m *ice.Message, ls []string) []string {
-	ln := []string{}
-	m.Option(mdb.CACHE_LIMIT, 10)
-	for i := 0; i < len(ls); i++ {
-		if ls[i] == "--" {
-			ln = append(ln, ls[i+1:]...)
-			break
-		}
-
-		if strings.HasPrefix(ls[i], "-") {
-			for j := i; j < len(ls); j++ {
-				if j == len(ls)-1 || strings.HasPrefix(ls[j+1], "-") {
-					if i < j {
-						m.Option(ls[i][1:], ls[i+1:j+1])
-					} else {
-						m.Option(ls[i][1:], ice.TRUE)
-					}
-					i = j
-					break
-				}
-			}
-		} else {
-			ln = append(ln, ls[i])
-		}
-	}
-	return ln
-}
 func (f *Frame) change(m *ice.Message, ls []string) []string {
 	if len(ls) == 1 && ls[0] == "~" { // 模块列表
 		ls = []string{ctx.CONTEXT}
@@ -168,42 +119,22 @@ func (f *Frame) parse(m *ice.Message, line string) string {
 	}
 
 	for _, one := range kit.Split(line, ";", ";", ";") {
-		async, one := false, strings.TrimSpace(one)
+		one = strings.TrimSpace(one)
-		if strings.TrimSuffix(one, "&") != one {
-			async, one = true, strings.TrimSuffix(one, "&")
-		}
-
 		msg := m.Spawn(f.target)
 		msg.Option("_cmd", one)
 
-		ls := kit.Split(one)
+		ls := f.change(msg, f.alias(msg, kit.Split(one)))
-		ls = f.alias(msg, ls)
-		ls = f.change(msg, ls)
-		ls = f.option(msg, ls)
 		if len(ls) == 0 {
 			continue
 		}
-
-		if async {
-			msg.Go(func() { msg.Cmd(ls[0], ls[1:]) })
-			continue
-		} else {
 		msg.Cmdy(ls[0], ls[1:])
-		}
 
-		if strings.HasPrefix(msg.Result(), ice.ErrWarn) && m.Option(ice.MSG_RENDER) == ice.RENDER_RAW {
-			fmt.Fprintf(msg.O, line)
-			continue
-		}
-
-		// 渲染引擎
 		_args, _ := msg.Optionv(ice.MSG_ARGS).([]interface{})
-		f.last = Render(msg, msg.Option(ice.MSG_OUTPUT), _args...)
+		f.res = Render(msg, msg.Option(ice.MSG_OUTPUT), _args...)
 	}
 	return ""
 }
 func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
-	m.Option(kit.Keycb(RETURN), func() { f.close() })
 	f.ps1 = kit.Simple(m.Confv(PROMPT, kit.Keym(PS1)))
 	f.ps2 = kit.Simple(m.Confv(PROMPT, kit.Keym(PS2)))
 	ps := f.ps1
@@ -221,28 +152,25 @@ func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
 
 		if len(bio.Text()) == 0 {
 			if strings.Count(line, "`")%2 == 1 {
-				line += "\n"
+				line += ice.NL
 			}
 			continue // 空行
 		}
-
 		if strings.HasSuffix(bio.Text(), "\\") {
 			line += bio.Text()[:len(bio.Text())-1]
 			ps = f.ps2
 			continue // 续行
 		}
 		if line += bio.Text(); strings.Count(line, "`")%2 == 1 {
-			line += "\n"
+			line += ice.NL
 			ps = f.ps2
 			continue // 多行
 		}
-		if strings.HasPrefix(strings.TrimSpace(line), "#") {
+		if line = kit.Split(line, "#", "#", "#")[0]; len(line) == 0 {
-			line = ""
 			continue // 注释
 		}
 		if ps = f.ps1; f.stdout == os.Stdout {
-			// 清空格式
+			f.printf(m, "\033[0m") // 清空格式
-			f.printf(m, "\033[0m")
 		}
 		line = f.parse(m, line)
 	}
@@ -262,51 +190,44 @@ func (f *Frame) Spawn(m *ice.Message, c *ice.Context, arg ...string) ice.Server
 	return &Frame{}
 }
 func (f *Frame) Start(m *ice.Message, arg ...string) bool {
-	f.source, f.target = kit.Select(STDIO, arg, 0), m.Target()
+	m.Optionv(FRAME, f)
-
+	switch f.source = kit.Select(STDIO, arg, 0); f.source {
-	switch m.Cap(ice.CTX_STREAM, f.source) {
 	case STDIO: // 终端交互
+		m.Cap(ice.CTX_STREAM, f.source)
+		f.target = m.Target()
+
 		r, w, _ := os.Pipe()
 		m.Go(func() { io.Copy(w, os.Stdin) })
 		f.stdin, f.stdout = r, os.Stdout
 		f.pipe = w
 
-		m.Option(ice.MSG_OPTS, ice.MSG_USERNAME)
 		aaa.UserRoot(m)
+		m.Option(ice.MSG_OPTS, ice.MSG_USERNAME)
 
-	default: // 脚本文件
+		m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.Keym(kit.MDB_NAME)), STDIO)
-		f.target = m.Source()
+		m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.Keym(kit.MDB_TIME)), m.Time())
-
-		if strings.HasPrefix(f.source, "/dev") {
-			f.stdin, f.stdout = m.I, m.O
-			break
-		}
-
-		buf := bytes.NewBuffer(make([]byte, 0, ice.MOD_BUFS))
-		defer func() { m.Echo(buf.String()) }()
-
-		if s := Script(m, f.source); s != nil {
-			f.stdin, f.stdout = s, buf
-			break
-		}
-
-		// 查找失败
-		return true
-	}
-
-	// 解析脚本
-	if f.count = 1; f.source == STDIO {
-		m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.MDB_META, kit.MDB_NAME), STDIO)
-		m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.MDB_META, kit.MDB_TIME), m.Time())
 
 		f.count = kit.Int(m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, STDIO, kit.Keym(kit.MDB_COUNT)))) + 1
 		f.scan(m, STDIO, "")
-	} else {
-		h := m.Cmdx(mdb.INSERT, SOURCE, "", mdb.HASH, kit.MDB_NAME, f.source)
-		m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, h, kit.Keym(kit.MDB_COUNT)), 0)
-		m.Conf(SOURCE, kit.Keys(kit.MDB_HASH, h, kit.MDB_LIST), "")
 
-		f.scan(m, h, "")
+	default: // 脚本文件
+		if strings.Contains(m.Option(ice.MSG_SCRIPT), "/") {
+			f.source = path.Join(path.Dir(m.Option(ice.MSG_SCRIPT)), f.source)
+		}
+		m.Option(ice.MSG_SCRIPT, f.source)
+		f.target = m.Source()
+
+		if msg := m.Cmd(nfs.CAT, f.source); msg.Result(0) == ice.ErrWarn {
+			return true // 查找失败
+		} else {
+			buf := bytes.NewBuffer(make([]byte, 0, ice.MOD_BUFS))
+			defer func() { m.Echo(buf.String()) }()
+
+			f.stdin, f.stdout = bytes.NewBuffer([]byte(msg.Result())), buf
+		}
+
+		f.count = 1
+		f.scan(m, m.Cmdx(mdb.INSERT, SOURCE, "", mdb.HASH, kit.MDB_NAME, f.source), "")
 	}
 	return true
 }
@@ -315,6 +236,7 @@ func (f *Frame) Close(m *ice.Message, arg ...string) bool {
 }
 
 const (
+	FRAME = "frame"
 	STDIO = "stdio"
 	PS1   = "PS1"
 	PS2   = "PS2"
@@ -330,73 +252,50 @@ const (
 )
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		SOURCE: {Name: SOURCE, Help: "加载脚本", Value: kit.Data()},
-			SOURCE: {Name: SOURCE, Help: "加载脚本", Value: kit.Data(kit.MDB_SHORT, kit.MDB_NAME)},
 		PROMPT: {Name: PROMPT, Help: "命令提示", Value: kit.Data(
 			PS1, []interface{}{"\033[33;44m", kit.MDB_COUNT, "[", kit.MDB_TIME, "]", "\033[5m", TARGET, "\033[0m", "\033[44m", ">", "\033[0m ", "\033[?25h", "\033[32m"},
 			PS2, []interface{}{kit.MDB_COUNT, " ", TARGET, "> "},
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		SOURCE: {Name: "source file", Help: "脚本解析", Action: ice.MergeAction(map[string]*ice.Action{
-			SOURCE: {Name: "source hash id limit offend auto", Help: "脚本解析", Action: map[string]*ice.Action{
 			mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(SCREEN, m.Option(kit.MDB_TEXT))
 				m.ProcessInner()
 			}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if len(arg) > 0 && kit.Ext(arg[0]) == "shy" { // 解析脚本
+			if len(arg) > 0 && kit.Ext(arg[0]) == ice.SHY {
-					m.Starts(strings.Replace(arg[0], ".", "_", -1), arg[0], arg[0:]...)
+				(&Frame{}).Start(m, arg...)
-					return
+				return // 脚本解析
 			}
-
-				if len(arg) == 0 { // 脚本列表
-					m.Fields(len(arg), "time,hash,name,count")
-					m.Cmdy(mdb.SELECT, SOURCE, "", mdb.HASH)
-					m.Sort(kit.MDB_NAME)
-					return
-				}
-
-				if m.Option(mdb.CACHE_OFFEND, kit.Select("0", arg, 3)); arg[0] == STDIO {
-					m.Option(mdb.CACHE_LIMIT, kit.Select("10", arg, 2))
-				} else {
-					m.Option(mdb.CACHE_LIMIT, kit.Select("-1", arg, 2))
-				}
-
-				// 命令列表
-				m.Fields(len(arg[1:]), "time,id,text")
-				m.Cmdy(mdb.SELECT, SOURCE, kit.Keys(kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, arg[1:])
-				m.PushAction(mdb.REPEAT)
 		}},
 		TARGET: {Name: "target name run:button", Help: "当前模块", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				f := m.Target().Server().(*Frame)
+			f := m.Optionv(FRAME).(*Frame)
-				m.Search(arg[0]+".", func(p *ice.Context, s *ice.Context, key string) { f.target = s })
+			m.Search(arg[0]+ice.PT, func(p *ice.Context, s *ice.Context, key string) { f.target = s })
 			f.prompt(m)
 		}},
 		PROMPT: {Name: "prompt arg run:button", Help: "命令提示", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				f := m.Target().Server().(*Frame)
+			f := m.Optionv(FRAME).(*Frame)
 			f.ps1 = arg
 			f.prompt(m)
 		}},
 		PRINTF: {Name: "printf run:button text:textarea", Help: "输出显示", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				f := m.Target().Server().(*Frame)
+			f := m.Optionv(FRAME).(*Frame)
 			f.printf(m, arg[0])
 		}},
 		SCREEN: {Name: "screen run:button text:textarea", Help: "输出命令", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				f := m.Target().Server().(*Frame)
+			f := m.Optionv(FRAME).(*Frame)
-				for _, line := range kit.Split(arg[0], "\n", "\n", "\n") {
+			for _, line := range kit.Split(arg[0], ice.NL, ice.NL) {
-					f.printf(m, line+"\n")
+				fmt.Fprintf(f.pipe, line+ice.NL)
-					fmt.Fprintf(f.pipe, line+"\n")
+				f.printf(m, line+ice.NL)
 				m.Sleep("300ms")
 			}
-				m.Echo(f.last)
+			m.Echo(f.res)
 		}},
 		RETURN: {Name: "return", Help: "结束脚本", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				switch cb := m.Optionv(kit.Keycb(RETURN)).(type) {
+			f := m.Optionv(FRAME).(*Frame)
-				case func():
+			f.close()
-					cb()
-				}
 		}},
-		},
+	}})
-	})
 }

base/ssh/ssh.go

@@ -6,20 +6,8 @@ import (
 
 const SSH = "ssh"
 
-var Index = &ice.Context{Name: SSH, Help: "终端模块", Commands: map[string]*ice.Command{
+var Index = &ice.Context{Name: SSH, Help: "终端模块"}
-	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Load()
-	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		if f, ok := m.Target().Server().(*Frame); ok {
-			f.close()
-		}
-		m.Save()
-	}},
-}}
 
 func init() {
-	ice.Index.Register(Index, &Frame{},
+	ice.Index.Register(Index, &Frame{}, SOURCE, TARGET, PROMPT, PRINTF, SCREEN, RETURN)
-		SOURCE, TARGET, PROMPT, PRINTF, SCREEN, RETURN,
-	)
 }

base/ssh/ssh.shy

@@ -1,14 +1,4 @@
 chapter "ssh"
-refer `
-官网 http://www.openssh.com/
-文档 https://man.openbsd.org/ssh
-源码 https://github.com/openssh/openssh-portable
-`
-
-field "连接" ssh.connect
-field "会话" ssh.session
-field "服务" ssh.service
-field "通道" ssh.channel
 
 field "脚本" ssh.source
 field "模块" ssh.target

base/tcp/client.go

@@ -31,37 +31,13 @@ func (c *Conn) Write(b []byte) (int, error) {
 	return n, e
 }
 func (c *Conn) Close() error {
-	// c.m.Cmd(mdb.MODIFY, CLIENT, "", mdb.HASH, kit.MDB_HASH, c.h, kit.MDB_STATUS, CLOSE, "nread", c.s.nr, "nwrite", c.s.nw)
 	return c.Conn.Close()
 }
 
-const (
+func _client_dial(m *ice.Message, arg ...string) {
-	OPEN  = "open"
-	CLOSE = "close"
-	ERROR = "error"
-	START = "start"
-	STOP  = "stop"
-)
-const (
-	DIAL = "dial"
-)
-
-const CLIENT = "client"
-
-func init() {
-	Index.Merge(&ice.Context{
-		Configs: map[string]*ice.Config{
-			CLIENT: {Name: CLIENT, Help: "客户端", Value: kit.Data()},
-		},
-		Commands: map[string]*ice.Command{
-			CLIENT: {Name: "client hash auto prunes", Help: "客户端", Action: map[string]*ice.Action{
-				DIAL: {Name: "dial type name port=9010 host=", Help: "连接", Hand: func(m *ice.Message, arg ...string) {
 	c, e := net.Dial(TCP, m.Option(HOST)+":"+m.Option(PORT))
-					h := m.Cmdx(mdb.INSERT, CLIENT, "", mdb.HASH, PORT, m.Option(PORT), HOST, m.Option(HOST),
-						kit.MDB_TYPE, m.Option(kit.MDB_TYPE), kit.MDB_NAME, m.Option(kit.MDB_NAME),
-						kit.MDB_STATUS, kit.Select(ERROR, OPEN, e == nil), kit.MDB_ERROR, kit.Format(e))
 
-					c = &Conn{m: m, h: h, s: &Stat{}, Conn: c}
+	c = &Conn{m: m, s: &Stat{}, Conn: c}
 	if e == nil {
 		defer c.Close()
 	}
@@ -83,22 +59,43 @@ func init() {
 	default:
 		c.Write([]byte("hello world\n"))
 	}
+}
+
+const (
+	OPEN  = "open"
+	CLOSE = "close"
+	ERROR = "error"
+	START = "start"
+	STOP  = "stop"
+)
+const (
+	DIAL = "dial"
+)
+const CLIENT = "client"
+
+func init() {
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
+		CLIENT: {Name: CLIENT, Help: "客户端", Value: kit.Data(
+			kit.MDB_FIELD, "time,hash,status,type,name,host,port,error,nread,nwrite",
+		)},
+	}, Commands: map[string]*ice.Command{
+		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Richs(CLIENT, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+				kit.Value(value, kit.Keym(kit.MDB_STATUS), CLOSE)
+			})
 		}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
+		CLIENT: {Name: "client hash auto prunes", Help: "客户端", Action: ice.MergeAction(map[string]*ice.Action{
-					m.Cmdy(mdb.DELETE, CLIENT, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
+			DIAL: {Name: "dial type name port=9010 host=", Help: "连接", Hand: func(m *ice.Message, arg ...string) {
+				_client_dial(m, arg...)
 			}},
 			mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(mdb.PRUNES, CLIENT, "", mdb.HASH, kit.MDB_STATUS, ERROR)
 				m.Cmdy(mdb.PRUNES, CLIENT, "", mdb.HASH, kit.MDB_STATUS, CLOSE)
 			}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), "time,hash,status,type,name,host,port,error,nread,nwrite")
+			mdb.HashSelect(m, arg...).Table(func(index int, value map[string]string, head []string) {
-				if m.Cmdy(mdb.SELECT, CLIENT, "", mdb.HASH, kit.MDB_HASH, arg); len(arg) == 0 {
-					m.Table(func(index int, value map[string]string, head []string) {
 				m.PushButton(kit.Select("", mdb.REMOVE, value[kit.MDB_STATUS] == OPEN))
 			})
-				}
 		}},
-		},
+	}})
-	})
 }

base/tcp/host.go

@@ -28,20 +28,20 @@ func _host_list(m *ice.Message, name string) {
 
 					m.Push(kit.MDB_INDEX, v.Index)
 					m.Push(kit.MDB_NAME, v.Name)
-					m.Push(IP, ip[0])
+					m.Push(aaa.IP, ip[0])
-					m.Push(MASK, ip[1])
+					m.Push("mask", ip[1])
-					m.Push(HARD, v.HardwareAddr.String())
+					m.Push("hard", v.HardwareAddr.String())
 				}
 			}
 		}
 	}
 
-	if len(m.Appendv(IP)) == 0 {
+	if len(m.Appendv(aaa.IP)) == 0 {
 		m.Push(kit.MDB_INDEX, -1)
 		m.Push(kit.MDB_NAME, LOCALHOST)
-		m.Push(IP, "127.0.0.1")
+		m.Push(aaa.IP, "127.0.0.1")
-		m.Push(MASK, "255.0.0.0")
+		m.Push("mask", "255.0.0.0")
-		m.Push(HARD, "")
+		m.Push("hard", "")
 	}
 }
 
@@ -61,33 +61,28 @@ func _islocalhost(m *ice.Message, ip string) (ok bool) {
 func IsLocalHost(m *ice.Message, ip string) bool { return _islocalhost(m, ip) }
 func ReplaceLocalhost(m *ice.Message, url string) string {
 	if strings.Contains(url, "://"+LOCALHOST) {
-		url = strings.Replace(url, "://"+LOCALHOST, "://"+m.Cmd(HOST, ice.OptionFields(IP)).Append(IP), 1)
+		url = strings.Replace(url, "://"+LOCALHOST, "://"+m.Cmd(HOST).Append(aaa.IP), 1)
 	}
 	return url
 }
 
 const (
-	HOSTPORT = "hostport"
-	HOSTNAME = "hostname"
-	PROTOCOL = "protocol"
-
 	LOCALHOST = "localhost"
-
-	HARD = "hard"
-	MASK = "mask"
-	IP   = "ip"
 )
 const HOST = "host"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		HOST: {Name: HOST, Help: "主机", Value: kit.Data(
 			aaa.BLACK, kit.Data(kit.MDB_SHORT, kit.MDB_TEXT),
 			aaa.WHITE, kit.Data(kit.MDB_SHORT, kit.MDB_TEXT),
 		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Cmd(HOST).Table(func(index int, value map[string]string, head []string) {
+				m.Cmd(HOST, aaa.WHITE, value[aaa.IP])
+			})
+		}},
 		HOST: {Name: "host name auto", Help: "主机", Action: map[string]*ice.Action{
 			aaa.BLACK: {Name: "black", Help: "黑名单", Hand: func(m *ice.Message, arg ...string) {
 				m.Rich(HOST, kit.Keym(aaa.BLACK), kit.Dict(kit.MDB_TEXT, arg[0]))
@@ -98,6 +93,5 @@ func init() {
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			_host_list(m, kit.Select("", arg, 0))
 		}},
-		},
+	}})
-	})
 }

base/tcp/port.go

@@ -12,35 +12,27 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _port_list(m *ice.Message, port string, dir string) {
+func _port_right(m *ice.Message, arg ...string) string {
-	if m.Option(nfs.DIR_ROOT, path.Join(m.Conf(cli.DAEMON, kit.META_PATH), port)); port != "" {
+	current := kit.Int(kit.Select(m.Config(CURRENT), arg, 0))
-		m.Cmdy(nfs.DIR, dir)
+	end := kit.Int(m.Config(END))
-		return
-	}
-
-	m.Cmd(nfs.DIR, "./").Table(func(index int, value map[string]string, head []string) {
-		m.Push(kit.MDB_TIME, value[kit.MDB_TIME])
-		m.Push(PORT, path.Base(value[kit.MDB_PATH]))
-		m.Push(kit.MDB_SIZE, value[kit.MDB_SIZE])
-	})
-}
-func _port_right(m *ice.Message, begin string) string {
-	current := kit.Int(kit.Select(m.Conf(PORT, kit.Keym(CURRENT)), begin))
-	end := kit.Int(m.Conf(PORT, kit.Keym(END)))
 	if current >= end {
-		current = kit.Int(m.Conf(PORT, kit.Keym(BEGIN)))
+		current = kit.Int(m.Config(BEGIN))
 	}
 
 	for i := current; i < end; i++ {
 		if c, e := net.Dial(TCP, kit.Format(":%d", i)); e == nil {
 			m.Info("port exists %v", i)
-			defer c.Close()
+			c.Close()
 			continue
 		}
+		p := path.Join(m.Conf(cli.DAEMON, kit.META_PATH), kit.Format(i))
+		if _, e := os.Stat(p); e == nil {
+			continue
+		}
+		os.MkdirAll(p, ice.MOD_DIR)
 
 		m.Log_SELECT(PORT, i)
-		m.Conf(PORT, kit.Keym(CURRENT), i)
+		return m.Config(CURRENT, i)
-		return kit.Format("%d", i)
 	}
 	return ""
 }
@@ -54,30 +46,25 @@ const (
 const PORT = "port"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		PORT: {Name: PORT, Help: "端口", Value: kit.Data(BEGIN, 10000, CURRENT, 10000, END, 20000)},
-			PORT: {Name: PORT, Help: "端口", Value: kit.Data(
+	}, Commands: map[string]*ice.Command{
-				BEGIN, 10000, CURRENT, 10000, END, 20000,
-			)},
-		},
-		Commands: map[string]*ice.Command{
 		PORT: {Name: "port port path auto", Help: "端口", Action: map[string]*ice.Action{
-				aaa.RIGHT: {Name: "right [begin]", Help: "分配", Hand: func(m *ice.Message, arg ...string) {
+			aaa.RIGHT: {Name: "right", Help: "分配", Hand: func(m *ice.Message, arg ...string) {
-					port, p := kit.Select("", arg, 0), ""
+				m.Echo(_port_right(m, arg...))
-					for i := 0; i < 10; i++ {
-						port = _port_right(m, port)
-						p = path.Join(m.Conf(cli.DAEMON, kit.META_PATH), port)
-						if _, e := os.Stat(p); e != nil && os.IsNotExist(e) {
-							os.MkdirAll(p, ice.MOD_DIR)
-							break
-						}
-						port = kit.Format(kit.Int(port) + 1)
-					}
-					m.Echo(port)
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				_port_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
+			if len(arg) == 0 {
-			}},
+				m.Option(nfs.DIR_ROOT, m.Conf(cli.DAEMON, kit.META_PATH))
-		},
+				m.Cmd(nfs.DIR, "./").Table(func(index int, value map[string]string, head []string) {
+					m.Push(kit.MDB_TIME, value[kit.MDB_TIME])
+					m.Push(PORT, path.Base(value[kit.MDB_PATH]))
+					m.Push(kit.MDB_SIZE, value[kit.MDB_SIZE])
 				})
+				return
+			}
+			m.Option(nfs.DIR_ROOT, path.Join(m.Conf(cli.DAEMON, kit.META_PATH), arg[0]))
+			m.Cmdy(nfs.DIR, arg[1:])
+		}},
+	}})
 }

base/tcp/server.go

@@ -26,20 +26,7 @@ func (l Listener) Close() error {
 	return l.Listener.Close()
 }
 
-const (
+func _server_listen(m *ice.Message, arg ...string) {
-	LISTEN = "listen"
-)
-
-const SERVER = "server"
-
-func init() {
-	Index.Merge(&ice.Context{
-		Configs: map[string]*ice.Config{
-			SERVER: {Name: SERVER, Help: "服务器", Value: kit.Data()},
-		},
-		Commands: map[string]*ice.Command{
-			SERVER: {Name: "server hash auto prunes", Help: "服务器", Action: map[string]*ice.Action{
-				LISTEN: {Name: "LISTEN type name port=9010 host=", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
 	l, e := net.Listen(TCP, m.Option(HOST)+":"+m.Option(PORT))
 	h := m.Cmdx(mdb.INSERT, SERVER, "", mdb.HASH, arg,
 		kit.MDB_STATUS, kit.Select(ERROR, OPEN, e == nil), kit.MDB_ERROR, kit.Format(e))
@@ -57,11 +44,11 @@ func init() {
 		cb(l)
 	case func(net.Conn):
 		for {
-							c, e := l.Accept()
+			if c, e := l.Accept(); e == nil {
-							if e != nil {
+				cb(c)
+			} else {
 				break
 			}
-							cb(c)
 		}
 	case func(net.Conn, error):
 		for {
@@ -85,22 +72,41 @@ func init() {
 			c.Close()
 		}
 	}
+}
+
+const (
+	PROTOCOL = "protocol"
+	HOSTPORT = "hostport"
+	HOSTNAME = "hostname"
+)
+const (
+	LISTEN = "listen"
+)
+const SERVER = "server"
+
+func init() {
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
+		SERVER: {Name: SERVER, Help: "服务器", Value: kit.Data(
+			kit.MDB_FIELD, "time,hash,status,type,name,host,port,error,nconn",
+		)},
+	}, Commands: map[string]*ice.Command{
+		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Richs(SERVER, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+				kit.Value(value, kit.Keym(kit.MDB_STATUS), CLOSE)
+			})
 		}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
+		SERVER: {Name: "server hash auto prunes", Help: "服务器", Action: ice.MergeAction(map[string]*ice.Action{
-					m.Cmdy(mdb.DELETE, SERVER, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
+			LISTEN: {Name: "LISTEN type name port=9030 host=", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
+				_server_listen(m, arg...)
 			}},
 			mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(mdb.PRUNES, SERVER, "", mdb.HASH, kit.MDB_STATUS, ERROR)
 				m.Cmdy(mdb.PRUNES, SERVER, "", mdb.HASH, kit.MDB_STATUS, CLOSE)
 			}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), "time,hash,status,type,name,host,port,error,nconn")
+			mdb.HashSelect(m, arg...).Table(func(index int, value map[string]string, head []string) {
-				if m.Cmdy(mdb.SELECT, SERVER, "", mdb.HASH, kit.MDB_HASH, arg); len(arg) == 0 {
-					m.Table(func(index int, value map[string]string, head []string) {
 				m.PushButton(kit.Select("", mdb.REMOVE, value[kit.MDB_STATUS] == CLOSE))
 			})
-				}
 		}},
-		},
+	}})
-	})
 }

base/tcp/tcp.go

@@ -2,30 +2,10 @@ package tcp
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/aaa"
-	kit "shylinux.com/x/toolkits"
 )
 
 const TCP = "tcp"
 
-var Index = &ice.Context{Name: TCP, Help: "通信模块",
+var Index = &ice.Context{Name: TCP, Help: "通信模块"}
-	Commands: map[string]*ice.Command{
-		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Load()
-			m.Cmd(HOST).Table(func(index int, value map[string]string, head []string) {
-				m.Cmd(HOST, aaa.WHITE, value[IP])
-			})
-		}},
-		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Richs(CLIENT, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
-				kit.Value(value, kit.Keym(kit.MDB_STATUS), CLOSE)
-			})
-			m.Richs(SERVER, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
-				kit.Value(value, kit.Keym(kit.MDB_STATUS), CLOSE)
-			})
-			m.Save(PORT)
-		}},
-	},
-}
 
 func init() { ice.Index.Register(Index, nil, HOST, PORT, CLIENT, SERVER) }

base/web/route.go

@@ -50,7 +50,7 @@ func _route_list(m *ice.Message) {
 	m.Cmd(tcp.HOST).Table(func(index int, value map[string]string, head []string) {
 		m.Push(kit.MDB_TYPE, MYSELF)
 		m.Push(kit.SSH_ROUTE, ice.Info.NodeName)
-		m.PushAnchor(value[tcp.IP], kit.Format("%s://%s:%s", u.Scheme, value[tcp.IP], u.Port()))
+		m.PushAnchor(value[aaa.IP], kit.Format("%s://%s:%s", u.Scheme, value[aaa.IP], u.Port()))
 		m.PushButton(tcp.START)
 	})
 

base/web/serve.go

@@ -72,7 +72,7 @@ func _serve_main(m *ice.Message, w http.ResponseWriter, r *http.Request) bool {
 	}
 
 	// 文件接口
-	if m.Conf(SERVE, kit.Keym("dump")) != ice.FALSE && ice.Dump(w, r.URL.Path, func(name string) { RenderType(w, name, "") }) {
+	if ice.Dump(w, r.URL.Path, func(name string) { RenderType(w, name, "") }) {
 		return false
 	}
 	return true

base/web/space.go

@@ -221,7 +221,7 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
 		}
 		m.Cmd(tcp.HOST).Table(func(index int, value map[string]string, head []string) {
 			m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
-				kit.MDB_TEXT, kit.Format("http://%s:%s", value[tcp.IP], port))
+				kit.MDB_TEXT, kit.Format("http://%s:%s", value[aaa.IP], port))
 		})
 	}
 }

base/yac/matrix.go

@@ -309,6 +309,24 @@ func (mat *Matrix) show(m *ice.Message) {
 	m.Status(NLANG, mat.nlang, NCELL, mat.ncell, NPAGE, len(mat.page), NHASH, len(mat.hash))
 }
 
+func _yac_load(m *ice.Message) {
+	m.Richs(m.Prefix(MATRIX), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
+		value = kit.GetMeta(value)
+
+		mat := NewMatrix(m, kit.Int(kit.Select("32", value[NLANG])), kit.Int(kit.Select("32", value[NCELL])))
+		m.Grows(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+			page := mat.index(m, NPAGE, kit.Format(value[NPAGE]))
+			hash := mat.index(m, NHASH, kit.Format(value[NHASH]))
+			if mat.mat[page] == nil {
+				mat.mat[page] = make([]*State, mat.ncell)
+			}
+
+			mat.train(m, page, hash, kit.Simple(value[kit.MDB_TEXT]), 1)
+		})
+		value[MATRIX] = mat
+	})
+}
+
 type Rewrite func(m *ice.Message, nhash string, hash int, word []string, begin int, stream *lex.Stream) (int, []string)
 
 const (
@@ -326,11 +344,12 @@ const (
 const MATRIX = "matrix"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
 		MATRIX: {Name: MATRIX, Help: "魔方矩阵", Value: kit.Data(kit.MDB_SHORT, kit.MDB_NAME)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
+			_yac_load(m)
+		}},
 		MATRIX: {Name: "matrix name npage text auto", Help: "魔方矩阵", Action: map[string]*ice.Action{
 			mdb.CREATE: {Name: "create name=shy nlang=32 ncell=32", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
 				mat := NewMatrix(m, kit.Int(kit.Select("32", m.Option(NLANG))), kit.Int(kit.Select("32", m.Option(NCELL))))

base/yac/yac.go

@@ -2,38 +2,10 @@ package yac
 
 import (
 	ice "shylinux.com/x/icebergs"
-	kit "shylinux.com/x/toolkits"
 )
 
-func _yac_load(m *ice.Message) {
-	m.Richs(m.Prefix(MATRIX), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
-		value = kit.GetMeta(value)
-
-		mat := NewMatrix(m, kit.Int(kit.Select("32", value[NLANG])), kit.Int(kit.Select("32", value[NCELL])))
-		m.Grows(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
-			page := mat.index(m, NPAGE, kit.Format(value[NPAGE]))
-			hash := mat.index(m, NHASH, kit.Format(value[NHASH]))
-			if mat.mat[page] == nil {
-				mat.mat[page] = make([]*State, mat.ncell)
-			}
-
-			mat.train(m, page, hash, kit.Simple(value[kit.MDB_TEXT]), 1)
-		})
-		value[MATRIX] = mat
-	})
-}
-
 const YAC = "yac"
 
-var Index = &ice.Context{Name: YAC, Help: "语法模块",
+var Index = &ice.Context{Name: YAC, Help: "语法模块"}
-	Commands: map[string]*ice.Command{
-		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
-			_yac_load(m.Load())
-		}},
-		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
-			m.Save()
-		}},
-	},
-}
 
 func init() { ice.Index.Register(Index, nil) }

core/code/case.go

@@ -22,13 +22,6 @@ func init() {
 			}},
 			mdb.INSERT: {Name: "insert zone name=hi cmd=POST,GET api arg:textarea res:textarea", Help: "添加"},
 
-			ice.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
-				m.Option(web.SPIDE_HEADER, web.ContentType, web.ContentJSON)
-				m.Echo(kit.Formats(kit.UnMarshal(m.Cmdx(web.SPIDE, m.Option(ice.DEV), web.SPIDE_RAW,
-					m.Option(ice.CMD), m.Option(cli.API), web.SPIDE_DATA, m.Option(ice.ARG)))))
-				m.Info(`curl "` + m.Option(cli.API) + `" -H "Content-Type: application/json"` + ` -d '` + m.Option(ice.ARG) + `'`)
-				m.ProcessDisplay("/plugin/local/wiki/json.js")
-			}},
 			cli.CHECK: {Name: "check", Help: "检查", Hand: func(m *ice.Message, arg ...string) {
 				if m.ProcessInner(); len(arg) > 0 {
 					success := 0
@@ -60,17 +53,23 @@ func init() {
 				}
 				m.Echo(ice.OK)
 			}},
+			ice.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
+				m.Option(web.SPIDE_HEADER, web.ContentType, web.ContentJSON)
+				m.Echo(kit.Formats(kit.UnMarshal(m.Cmdx(web.SPIDE, m.Option(ice.DEV), web.SPIDE_RAW,
+					m.Option(ice.CMD), m.Option(cli.API), web.SPIDE_DATA, m.Option(ice.ARG)))))
+				m.Info(`curl "` + m.Option(cli.API) + `" -H "Content-Type: application/json"` + ` -d '` + m.Option(ice.ARG) + `'`)
+				m.ProcessDisplay("/plugin/local/wiki/json.js")
+			}},
 		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) == 0 {
-				m.Action(mdb.CREATE)
 				m.Cmdy(web.SPIDE)
+				m.Action(mdb.CREATE)
 				m.RenameAppend("client.name", "dev")
 				m.RenameAppend("client.url", "address")
 				return
 			}
 
-			m.Fields(len(arg)-1, "time,zone,count", m.Config(kit.MDB_FIELD))
+			if mdb.ZoneSelect(m, arg[1:]...); len(arg) == 1 {
-			if m.Cmdy(mdb.SELECT, m.PrefixKey(), "", mdb.ZONE, arg[1:]); len(arg) == 1 {
 				m.Action(mdb.INSERT, mdb.EXPORT, mdb.IMPORT)
 				m.PushAction(mdb.INSERT, cli.CHECK, mdb.REMOVE)
 			} else {

init.go

@@ -77,7 +77,7 @@ var Index = &Context{Name: "ice", Help: "冰山模块", Caches: map[string]*Cach
 	}},
 	INIT: {Name: "init", Help: "启动", Hand: func(m *Message, c *Context, cmd string, arg ...string) {
 		m.root.Cmd(CTX_INIT)
-		m.Cmd("ssh.source", ETC_INIT_SHY, "init.shy", "启动配置")
+		m.Cmd("ssh.source", ETC_INIT_SHY)
 		m.Cmdy(arg)
 	}},
 	HELP: {Name: "help", Help: "帮助", Hand: func(m *Message, c *Context, cmd string, arg ...string) {
@@ -85,7 +85,7 @@ var Index = &Context{Name: "ice", Help: "冰山模块", Caches: map[string]*Cach
 	}},
 	EXIT: {Name: "exit", Help: "结束", Hand: func(m *Message, c *Context, cmd string, arg ...string) {
 		m.root.Option(EXIT, kit.Select("0", arg, 0))
-		m.Cmd("ssh.source", ETC_EXIT_SHY, "exit.shy", "退出配置")
+		m.Cmd("ssh.source", ETC_EXIT_SHY)
 		m.root.Cmd(CTX_EXIT)
 	}},
 	CTX_EXIT: {Hand: func(m *Message, c *Context, cmd string, arg ...string) {

misc/ssh/ssh.shy

@@ -0,0 +1,12 @@
+chapter "ssh"
+refer `
+官网 http://www.openssh.com/
+文档 https://man.openbsd.org/ssh
+源码 https://github.com/openssh/openssh-portable
+`
+
+field "连接" ssh.connect
+field "会话" ssh.session
+field "服务" ssh.service
+field "通道" ssh.channel
+