opt space

2023-03-26 01:57:30 +08:00 · 2023-03-26 01:57:30 +08:00 · 92febcf848
commit 92febcf848
parent 0915eeb700
12 changed files with 128 additions and 188 deletions
--- a/base/ssh/script.go
+++ b/base/ssh/script.go
@ -103,7 +103,7 @@ func (f *Frame) parse(m *ice.Message, h, line string) string {
 	return ""
 }
 func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
-	kit.If(f.source == STDIO, func() { m.Options(MESSAGE, m, ice.LOG_DISABLE, ice.TRUE) })
+	// kit.If(f.source == STDIO, func() { m.Options(MESSAGE, m, ice.LOG_DISABLE, ice.TRUE) })
 	f.ps1 = kit.Simple(mdb.Confv(m, PROMPT, kit.Keym(PS1)))
 	f.ps2 = kit.Simple(mdb.Confv(m, PROMPT, kit.Keym(PS2)))
 	m.I, m.O = f.stdin, f.stdout
@ -253,3 +253,7 @@ func init() {
 		}},
 	})
 }
+
+func PrintQRCode(m *ice.Message, url string) {
+	m.Spawn(ice.OptionSilent()).Cmd(PRINTF, kit.Dict(nfs.CONTENT, ice.NL+ice.Render(m, ice.RENDER_QRCODE, url))).Cmd(PROMPT)
+}
--- a/base/web/broad.go
+++ b/base/web/broad.go
@ -29,8 +29,8 @@ func _broad_send(m *ice.Message, host, port string, remote_host, remote_port str
 	}
 }
 func _broad_serve(m *ice.Message, port string) {
-	m.Cmd(tcp.HOST, func(values ice.Maps) {
-		_broad_send(m, values[aaa.IP], port, "255.255.255.255", "9020", mdb.TYPE, ice.Info.NodeType, mdb.NAME, ice.Info.NodeName)
+	m.Cmd(tcp.HOST, func(value ice.Maps) {
+		_broad_send(m, value[aaa.IP], port, "255.255.255.255", "9020", mdb.TYPE, ice.Info.NodeType, mdb.NAME, ice.Info.NodeName)
 	})
 	m.Cmd(tcp.SERVER, tcp.LISTEN, mdb.TYPE, "udp4", m.OptionSimple(mdb.NAME, tcp.HOST, tcp.PORT), func(l *net.UDPConn) {
 		buf := make([]byte, ice.MOD_BUFS)
@ -57,8 +57,8 @@ func _broad_serve(m *ice.Message, port string) {
 }
 func _broad_save(m, msg *ice.Message) {
 	save := false
-	m.Cmd(tcp.HOST, func(values ice.Maps) {
-		if strings.Split(msg.Option(tcp.HOST), ice.PT)[0] == strings.Split(values[aaa.IP], ice.PT)[0] {
+	m.Cmd(tcp.HOST, func(value ice.Maps) {
+		if strings.Split(msg.Option(tcp.HOST), ice.PT)[0] == strings.Split(value[aaa.IP], ice.PT)[0] {
 			save = true
 		}
 	})
--- a/base/web/serve.go
+++ b/base/web/serve.go
@ -114,6 +114,7 @@ func _serve_domain(m *ice.Message) string {
 	)
 }
 func _serve_auth(m *ice.Message, key string, cmds []string, w http.ResponseWriter, r *http.Request) ([]string, bool) {
+	defer func() { m.Options(ice.MSG_CMDS, "", ice.MSG_SESSID, "") }()
 	if r.URL.Path == PP(SPACE) {
 		return cmds, true
 	}
@ -169,13 +170,12 @@ func init() {
 			}},
 			SERVE_START: {Hand: func(m *ice.Message, arg ...string) {
 				m.Go(func() {
-					msg := m.Spawn(kit.Dict(ice.LOG_DISABLE, ice.TRUE)).Sleep("10ms")
-					msg.Cmd(ssh.PRINTF, kit.Dict(nfs.CONTENT, ice.NL+ice.Render(msg, ice.RENDER_QRCODE, tcp.PublishLocalhost(msg, kit.Format("http://localhost:%s", msg.Option(tcp.PORT)))))).Cmd(ssh.PROMPT)
+					ssh.PrintQRCode(m, tcp.PublishLocalhost(m, _serve_address(m)))
 					opened := false
 					for i := 0; i < 3 && !opened; i++ {
-						msg.Sleep("1s").Cmd(SPACE, func(value ice.Maps) { kit.If(value[mdb.TYPE] == CHROME, func() { opened = true }) })
+						m.Sleep("1s").Cmd(SPACE, func(value ice.Maps) { kit.If(value[mdb.TYPE] == CHROME, func() { opened = true }) })
 					}
-					kit.If(!opened, func() { cli.Opens(msg, _serve_address(msg)) })
+					kit.If(!opened, func() { cli.Opens(m, _serve_address(m)) })
 				})
 			}},
 		}, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,status,name,proto,host,port", tcp.LOCALHOST, ice.TRUE), mdb.ClearOnExitHashAction())},
--- a/base/web/space.go
+++ b/base/web/space.go
@ -4,6 +4,7 @@ import (
 	"math/rand"
 	"net"
 	"strings"
+	"sync"
 	"time"

 	ice "shylinux.com/x/icebergs"
@ -11,65 +12,60 @@ import (
 	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/gdb"
+	"shylinux.com/x/icebergs/base/log"
 	"shylinux.com/x/icebergs/base/mdb"
-	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/ssh"
 	"shylinux.com/x/icebergs/base/tcp"
 	kit "shylinux.com/x/toolkits"
 	"shylinux.com/x/websocket"
 )

+func _space_qrcode(m *ice.Message, dev string) {
+	ssh.PrintQRCode(m, m.Cmdv(SPACE, dev, cli.PWD, mdb.LINK))
+}
 func _space_dial(m *ice.Message, dev, name string, arg ...string) {
-	msg := m.Cmd(SPIDE, tcp.CLIENT, dev, PP(SPACE))
-	uri := kit.ParseURL(strings.Replace(kit.MergeURL(msg.Append(DOMAIN), mdb.TYPE, ice.Info.NodeType, mdb.NAME, name, arg), HTTP, "ws", 1))
-	args := kit.SimpleKV("type,name,host,port", msg.Append(tcp.PROTOCOL), dev, msg.Append(tcp.HOST), msg.Append(tcp.PORT))
-	prints := false
+	uri := kit.ParseURL(kit.MergeURL2(strings.Replace(m.Cmdv(SPIDE, dev, CLIENT_ORIGIN), HTTP, "ws", 1), PP(SPACE), mdb.TYPE, ice.Info.NodeType, mdb.NAME, name, arg))
+	args := kit.SimpleKV("type,name,host,port", uri.Scheme, dev, uri.Hostname(), uri.Port())
 	m.Go(func() {
+		once := sync.Once{}
 		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
 			m.Cmd(tcp.CLIENT, tcp.DIAL, args, func(c net.Conn) {
-				if conn, _, e := websocket.NewClient(c, uri, nil, kit.Int(redial["r"]), kit.Int(redial["w"])); !m.Warn(e, tcp.DIAL, dev, SPACE, uri.String()) {
-					defer mdb.HashCreateDeferRemove(m, kit.SimpleKV("", MASTER, dev, msg.Append(tcp.HOSTNAME)), kit.Dict(mdb.TARGET, conn))()
-					if !prints && ice.Info.Colors {
-						m.Go(func() {
-							m.Sleep300ms().Cmd(ssh.PRINTF, kit.Dict(nfs.CONTENT, "\r"+ice.Render(m, ice.RENDER_QRCODE, m.CmdAppend(SPACE, dev, cli.PWD, mdb.LINK)))).Cmd(ssh.PROMPT, kit.Dict(ice.LOG_DISABLE, ice.TRUE))
-						})
-						prints = true
-					}
-					_space_handle(m.Spawn(), true, dev, conn)
+				if c, _, e := websocket.NewClient(c, uri, nil, ice.MOD_BUFS, ice.MOD_BUFS); !m.Warn(e, tcp.DIAL, dev, SPACE, uri.String()) {
+					defer mdb.HashCreateDeferRemove(m, kit.SimpleKV("", MASTER, dev, uri.Hostname()), kit.Dict(mdb.TARGET, c))()
+					kit.If(ice.Info.Colors, func() { once.Do(func() { m.Go(func() { _space_qrcode(m, dev) }) }) })
+					_space_handle(m.Spawn(), true, dev, c)
 					i = 0
 				}
-			}).Cost("order", i, "sleep", next, "redial", dev, "uri", uri.String()).Sleep(next)
+			}).Cost("order", i, "sleep", next, tcp.DIAL, dev, "uri", uri.String()).Sleep(next)
 		}
-	})
+	}, kit.Join(kit.Simple(SPACE, name), ice.SP))
 }
 func _space_fork(m *ice.Message) {
-	if conn, e := websocket.Upgrade(m.W, m.R, nil, ice.MOD_BUFS, ice.MOD_BUFS); m.Assert(e) {
-		m.Options(ice.MSG_USERADDR, kit.Select(m.R.RemoteAddr, m.R.Header.Get(ice.MSG_USERADDR)))
-		text := kit.Select(m.Option(ice.MSG_USERADDR), m.Option(mdb.TEXT))
-		name := strings.ToLower(kit.ReplaceAll(kit.Select(m.Option(ice.MSG_USERADDR), m.Option(mdb.NAME)), ice.PT, "_", ice.DF, "_"))
-		args := kit.Simple(mdb.TYPE, kit.Select(WORKER, m.Option(mdb.TYPE)), mdb.NAME, name, mdb.TEXT, text, m.OptionSimple(SHARE, RIVER, ice.MSG_USERUA, cli.DAEMON))
+	addr := kit.Select(m.R.RemoteAddr, m.R.Header.Get(ice.MSG_USERADDR))
+	name := kit.ReplaceAll(kit.Select(addr, m.Option(mdb.NAME)), "[", "_", "]", "_", ice.DF, "_", ice.PT, "_")
+	args := kit.Simple(mdb.TYPE, kit.Select(WORKER, m.Option(mdb.TYPE)), mdb.NAME, name, mdb.TEXT, kit.Select(addr, m.Option(mdb.TEXT)), m.OptionSimple(cli.DAEMON, ice.MSG_USERUA))
+	if c, e := websocket.Upgrade(m.W, m.R, nil, ice.MOD_BUFS, ice.MOD_BUFS); !m.Warn(e) {
 		m.Go(func() {
-			defer mdb.HashCreateDeferRemove(m, args, kit.Dict(mdb.TARGET, conn))()
-			// defer gdb.EventDeferEvent(m, SPACE_OPEN, args)(SPACE_CLOSE, args)
+			defer mdb.HashCreateDeferRemove(m, args, kit.Dict(mdb.TARGET, c))()
 			switch m.Option(mdb.TYPE) {
 			case WORKER:
 				defer gdb.EventDeferEvent(m, DREAM_OPEN, args)(DREAM_CLOSE, args)
 			case CHROME:
-				m.Cmd(SPACE, name, cli.PWD, name)
+				m.Go(func() { m.Cmd(SPACE, name, cli.PWD, name) })
 			case LOGIN:
-				gdb.EventDeferEvent(m, SPACE_LOGIN, args)
+				gdb.Event(m, SPACE_LOGIN, args)
 			}
-			_space_handle(m, false, name, conn)
-		})
+			_space_handle(m, false, name, c)
+		}, kit.Join(kit.Simple(SPACE, name), ice.SP))
 	}
 }
-func _space_handle(m *ice.Message, safe bool, name string, conn *websocket.Conn) {
+func _space_handle(m *ice.Message, safe bool, name string, c *websocket.Conn) {
 	defer m.Cost(SPACE, name)
 	for {
-		_, b, e := conn.ReadMessage()
+		_, b, e := c.ReadMessage()
 		if e != nil {
 			break
 		}
@ -77,20 +73,25 @@ func _space_handle(m *ice.Message, safe bool, name string, conn *websocket.Conn)
 		source, target := kit.Simple(msg.Optionv(ice.MSG_SOURCE), name), kit.Simple(msg.Optionv(ice.MSG_TARGET))
 		msg.Log("recv", "%v->%v %v %v", source, target, msg.Detailv(), msg.FormatsMeta(nil))
 		if next := msg.Option(ice.MSG_TARGET); next == "" || len(target) == 0 {
-			if msg.Optionv(ice.MSG_HANDLE, ice.TRUE); safe { // 下行命令
-				gdb.Event(msg, SPACE_LOGIN)
+			if safe { // 下行命令
+				msg.Option(ice.MSG_USERROLE, aaa.UserRole(msg, msg.Option(ice.MSG_USERNAME)))
 			} else { // 上行请求
 				msg.Option(ice.MSG_USERROLE, aaa.VOID)
 			}
-			msg.Go(func() { _space_exec(msg, source, target, conn) })
-		} else if mdb.HashSelectDetail(msg, next, func(value ice.Map) {
-			if conn, ok := value[mdb.TARGET].(*websocket.Conn); !m.Warn(!ok, ice.ErrNotValid, next) {
-				_space_echo(msg, source, target, conn) // 转发报文
+			if msg.Option("_exec") == "go" {
+				m.Go(func() { _space_exec(msg, source, target, c) }, strings.Join(kit.Simple(SPACE, name, msg.Detailv()), ice.SP))
+			} else {
+				_space_exec(msg, source, target, c)
 			}
-		}) {
-		} else if res := getSend(m, next); !m.Warn(res == nil || len(target) != 1, ice.ErrNotFound, next) {
-			res.Cost(kit.Format("[%v]->%v %v %v", next, res.Optionv(ice.MSG_TARGET), res.Detailv(), msg.FormatSize()))
-			back(res, msg.Sleep30ms()) // 接收响应
+		} else {
+			m.Warn(!mdb.HashSelectDetail(m, next, func(value ice.Map) {
+				switch c := value[mdb.TARGET].(type) {
+				case (*websocket.Conn):
+					_space_echo(msg, source, target, c) // 转发报文
+				case ice.Handler:
+					c(msg) // 接收响应
+				}
+			}), ice.ErrNotFound, next)
 		}
 	}
 }
@ -98,77 +99,57 @@ func _space_domain(m *ice.Message) (link string) {
 	m.Options(ice.MSG_OPTION, ice.MSG_USERNAME, ice.MSG_OPTS, ice.MSG_USERNAME)
 	return kit.GetValid(
 		func() string { return ice.Info.Domain },
-		func() string { return m.CmdAppend(SPACE, ice.OPS, cli.PWD, mdb.LINK) },
-		func() string { return m.CmdAppend(SPACE, ice.DEV, cli.PWD, mdb.LINK) },
-		func() string { return m.CmdAppend(SPACE, ice.SHY, cli.PWD, mdb.LINK) },
-		func() string { return tcp.PublishLocalhost(m, m.Option(ice.MSG_USERWEB)) },
 		func() string {
-			return kit.Format("http://%s:%s", m.CmdAppend(tcp.HOST, aaa.IP), kit.Select(m.Option(tcp.PORT), m.CmdAppend(SERVE, tcp.PORT)))
-		})
+			if dev := kit.Select(ice.DEV, ice.OPS, ice.Info.NodeType == WORKER); mdb.HashSelectDetail(m, dev, nil) {
+				return m.Cmdv(SPACE, dev, cli.PWD, mdb.LINK)
+			}
+			return ""
+		},
+		func() string { return tcp.PublishLocalhost(m, m.Option(ice.MSG_USERWEB)) },
+		func() string { return kit.Format("http://%s:%s", m.Cmdv(tcp.HOST, aaa.IP), m.Cmdv(SERVE, tcp.PORT)) })
 }
-func _space_exec(msg *ice.Message, source, target []string, conn *websocket.Conn) {
-	switch kit.Select(cli.PWD, msg.Detailv(), 0) {
+func _space_exec(m *ice.Message, source, target []string, c *websocket.Conn) {
+	switch kit.Select(cli.PWD, m.Detailv(), 0) {
 	case cli.PWD:
-		msg.Push(mdb.LINK, kit.MergePOD(_space_domain(msg), kit.Select("", source, -1)))
+		m.Push(mdb.LINK, kit.MergePOD(_space_domain(m), kit.Select("", source, -1)))
 	default:
-		if aaa.Right(msg, msg.Detailv()) {
-			msg = msg.Cmd()
-			msg.Option("debug", msg.Option("debug"))
-		}
+		kit.If(aaa.Right(m, m.Detailv()), func() { m = m.Cmd() })
 	}
-	defer msg.Cost(kit.Format("%v->%v %v %v", source, target, msg.Detailv(), msg.FormatSize()))
-	_space_echo(msg.Set(ice.MSG_OPTS), []string{}, kit.Reverse(kit.Simple(source)), conn)
+	defer m.Cost(kit.Format("%v->%v %v %v", source, target, m.Detailv(), m.FormatSize()))
+	_space_echo(m.Set(ice.MSG_OPTS).Options(log.DEBUG, m.Option(log.DEBUG)), []string{}, kit.Reverse(kit.Simple(source)), c)
 }
-func _space_echo(m *ice.Message, source, target []string, conn *websocket.Conn) {
-	if m.Options(ice.MSG_SOURCE, source, ice.MSG_TARGET, target[1:]); m.Warn(conn.WriteMessage(1, []byte(m.FormatMeta()))) {
-		mdb.HashRemove(m, mdb.NAME, target[0])
-	} else {
+func _space_echo(m *ice.Message, source, target []string, c *websocket.Conn) {
+	if m.Options(ice.MSG_SOURCE, source, ice.MSG_TARGET, target[1:]); !m.Warn(c.WriteMessage(1, []byte(m.FormatMeta()))) {
 		m.Log("send", "%v->%v %v %v", source, target, m.Detailv(), m.FormatsMeta(nil))
 	}
 }
-func _space_send(m *ice.Message, space string, arg ...string) {
-	if space == "" || space == ice.Info.NodeName {
-		m.Cmdy(arg)
-		return
-	}
-	kit.Simple(m.Optionv(ice.MSG_OPTS), func(k string) {
-		switch k {
-		case ice.MSG_DETAIL, ice.MSG_CMDS, ice.MSG_SESSID:
-		default:
-			m.Optionv(k, m.Optionv(k))
-		}
+func _space_send(m *ice.Message, name string, arg ...string) {
+	wait, done := m.Wait(func(msg *ice.Message, arg ...string) {
+		m.Copy(msg).Cost(kit.Format("%v->%v %v %v", m.Optionv(ice.MSG_SOURCE), m.Optionv(ice.MSG_TARGET), m.Detailv(), m.FormatSize()))
 	})
-	m.Set(ice.MSG_DETAIL, arg...).Optionv(ice.MSG_OPTION, m.Optionv(ice.MSG_OPTS, m.Optionv(ice.MSG_OPTS)))
-	target := kit.Split(space, ice.PT, ice.PT)
-	if mdb.HashSelectDetail(m, target[0], func(value ice.Map) {
-		if conn, ok := value[mdb.TARGET].(*websocket.Conn); !m.Warn(!ok, ice.ErrNotValid, mdb.TARGET) {
-			_space_echo(m, []string{addSend(m, m)}, target, conn)
+	h := mdb.HashCreate(m.Spawn(), mdb.TYPE, "send", mdb.NAME, kit.Keys(name, m.Target().ID()), mdb.TEXT, kit.Join(arg, ice.SP), kit.Dict(mdb.TARGET, done))
+	defer mdb.HashRemove(m, mdb.HASH, h)
+	if target := kit.Split(name, ice.PT, ice.PT); mdb.HashSelectDetail(m, target[0], func(value ice.Map) {
+		if c, ok := value[mdb.TARGET].(*websocket.Conn); !m.Warn(!ok, ice.ErrNotValid, mdb.TARGET) {
+			kit.For(m.Optionv(ice.MSG_OPTS), func(k string) { m.Optionv(k, m.Optionv(k)) })
+			_space_echo(m.Set(ice.MSG_DETAIL, arg...), []string{h}, target, c)
 		}
 	}) {
-		call(m, "30s", func(res *ice.Message) { m.Copy(res) })
-	} else if kit.IndexOf([]string{ice.OPS, ice.DEV, ice.SHY}, target[0]) > -1 {
-		return
+		wait()
 	} else {
-		m.Warn(true, ice.ErrNotFound, space)
+		m.Warn(kit.IndexOf([]string{ice.OPS, ice.DEV}, target[0]) == -1, ice.ErrNotFound, name)
 	}
 }

 const (
 	CHROME = "chrome"
-	FRIEND = "friend"
 	MASTER = "master"
-	MYSELF = "myself"
 	SERVER = "server"
 	WORKER = "worker"
 )
 const (
-	REDIAL = "redial"
-
-	SPACE_START = "space.start"
-	SPACE_OPEN  = "space.open"
+	REDIAL      = "redial"
 	SPACE_LOGIN = "space.login"
-	SPACE_CLOSE = "space.close"
-	SPACE_STOP  = "space.stop"
 )
 const SPACE = "space"

@ -177,45 +158,38 @@ func init() {
 		SPACE: {Name: "space name cmds auto", Help: "空间站", Actions: ice.MergeActions(ice.Actions{
 			tcp.DIAL: {Name: "dial dev=ops name", Hand: func(m *ice.Message, arg ...string) {
 				if strings.HasPrefix(m.Option(ice.DEV), HTTP) {
-					m.Cmd(SPIDE, mdb.CREATE, ice.DEV, m.Option(ice.DEV))
+					m.Cmd(SPIDE, mdb.CREATE, m.OptionSimple(ice.DEV))
 					m.Option(ice.DEV, ice.DEV)
 				}
 				_space_dial(m, m.Option(ice.DEV), kit.Select(ice.Info.NodeName, m.Option(mdb.NAME)), arg...)
 			}},
+			mdb.REMOVE: {Hand: func(m *ice.Message, arg ...string) {
+				defer mdb.HashModifyDeferRemove(m, m.OptionSimple(mdb.NAME), mdb.STATUS, cli.STOP)()
+				m.Cmd("", m.Option(mdb.NAME), ice.EXIT)
+			}},
 			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
 				if arg[0] == mdb.FOREACH && arg[1] == "" {
-					m.Cmd("", ice.OptionFields(""), func(values ice.Maps) {
-						switch values[mdb.TYPE] {
+					m.Cmds("", func(value ice.Maps) {
+						switch value[mdb.TYPE] {
 						case MASTER:
-							m.PushSearch(mdb.TEXT, m.Cmd(SPIDE, values[mdb.NAME], ice.Maps{ice.MSG_FIELDS: ""}).Append(CLIENT_ORIGIN), values)
+							m.PushSearch(mdb.TEXT, m.Cmdv(SPIDE, value[mdb.NAME], CLIENT_ORIGIN), value)
 						case SERVER:
-							m.PushSearch(mdb.TEXT, kit.Format(tcp.PublishLocalhost(m, strings.Split(MergePod(m, values[mdb.NAME]), ice.QS)[0])), values)
+							m.PushSearch(mdb.TEXT, tcp.PublishLocalhost(m, strings.Split(MergePod(m, value[mdb.NAME]), ice.QS)[0]), value)
 						}
 					})
 				} else if arg[0] == mdb.FOREACH && arg[1] == ssh.SHELL {
 					m.PushSearch(mdb.TYPE, ssh.SHELL, mdb.TEXT, "ice.bin space dial dev ops")
 				}
 			}},
-			mdb.REMOVE: {Hand: func(m *ice.Message, arg ...string) {
-				defer mdb.HashModifyDeferRemove(m, m.OptionSimple(mdb.NAME), mdb.STATUS, cli.STOP)()
-				m.Cmd(SPACE, m.Option(mdb.NAME), ice.EXIT)
-			}},
-			SPACE_LOGIN: {Hand: func(m *ice.Message, arg ...string) {
-				if ice.Info.Username == aaa.VOID {
-					m.Option(ice.MSG_USERROLE, aaa.TECH)
-				} else {
-					m.Option(ice.MSG_USERROLE, kit.Select(m.Option(ice.MSG_USERROLE), m.CmdAppend(aaa.USER, m.Option(ice.MSG_USERNAME), aaa.USERROLE)))
-				}
-				aaa.SessAuth(m, kit.Dict(aaa.USERNAME, m.Option(ice.MSG_USERNAME), aaa.USERNICK, m.Option(ice.MSG_USERNICK), aaa.USERROLE, m.Option(ice.MSG_USERROLE)))
-			}},
-			LOGIN: {Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(SPACE, kit.Select(m.Option(mdb.NAME), arg, 0), ice.MSG_SESSID, aaa.SessCreate(m, m.Option(ice.MSG_USERNAME)))
-			}},
 			DOMAIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(_space_domain(m)) }},
+			LOGIN: {Hand: func(m *ice.Message, arg ...string) {
+				m.Option(ice.MSG_USERUA, m.Cmdv("", kit.Select(m.Option(mdb.NAME), arg, 0), ice.MSG_USERUA))
+				m.Cmd("", kit.Select(m.Option(mdb.NAME), arg, 0), ice.MSG_SESSID, aaa.SessCreate(m, m.Option(ice.MSG_USERNAME)))
+			}},
 			OPEN: {Hand: func(m *ice.Message, arg ...string) {
 				switch m.Option(mdb.TYPE) {
 				case MASTER:
-					ctx.ProcessOpen(m, m.Cmd(SPIDE, m.Option(mdb.NAME)).Append(CLIENT_ORIGIN))
+					ctx.ProcessOpen(m, m.Cmdv(SPIDE, m.Option(mdb.NAME), CLIENT_ORIGIN))
 				default:
 					ctx.ProcessOpen(m, strings.Split(MergePod(m, m.Option(mdb.NAME), arg), ice.QS)[0])
 				}
@ -223,59 +197,20 @@ func init() {
 			ice.PS: {Hand: func(m *ice.Message, arg ...string) { _space_fork(m) }},
 		}, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,type,name,text", ctx.ACTION, OPEN,
 			REDIAL, kit.Dict("a", 3000, "b", 1000, "c", 1000),
-		), mdb.ClearOnExitHashAction(), SpaceAction(), aaa.WhiteAction()), Hand: func(m *ice.Message, arg ...string) {
+		), mdb.ClearOnExitHashAction(), aaa.WhiteAction()), Hand: func(m *ice.Message, arg ...string) {
 			if len(arg) < 2 {
-				mdb.HashSelect(m, arg...).Sort("type,name,text")
-				m.Table(func(values ice.Maps) {
-					switch values[mdb.TYPE] {
-					case LOGIN:
-						m.PushButton(LOGIN, mdb.REMOVE)
-					default:
-						m.PushButton(cli.OPEN, mdb.REMOVE)
-					}
+				mdb.HashSelect(m, arg...).Sort("").Table(func(value ice.Maps) {
+					m.PushButton(kit.Select(OPEN, LOGIN, value[mdb.TYPE] == LOGIN), mdb.REMOVE)
 				})
 			} else {
-				_space_send(m, strings.ToLower(arg[0]), kit.Simple(kit.Split(arg[1]), arg[2:])...)
+				_space_send(m, arg[0], kit.Simple(kit.Split(arg[1]), arg[2:])...)
 			}
 		}},
 	})
 }
-
-func SpaceAction() ice.Actions {
-	return gdb.EventsAction(SPACE_START, SPACE_OPEN, SPACE_LOGIN, SPACE_CLOSE, SPACE_STOP)
-}
 func Space(m *ice.Message, arg ice.Any) []string {
-	if arg == nil || arg == "" || kit.Format(arg) == ice.Info.NodeName {
+	if arg == nil || arg == "" {
 		return nil
 	}
 	return []string{SPACE, kit.Format(arg)}
 }
-func call(m *ice.Message, timeout string, cb func(*ice.Message)) bool {
-	wait := make(chan bool, 2)
-	t := time.AfterFunc(kit.Duration(timeout), func() {
-		m.Warn(true, ice.ErrNotValid, m.Detailv())
-		m.Optionv("_cb", nil)
-		cb(nil)
-		wait <- false
-	})
-	m.Optionv("_cb", func(res *ice.Message) {
-		t.Stop()
-		cb(res)
-		wait <- true
-	})
-	return <-wait
-}
-func back(m *ice.Message, res *ice.Message) bool {
-	switch cb := m.Optionv("_cb").(type) {
-	case func(*ice.Message):
-		cb(res)
-		return true
-	}
-	return false
-}
-func addSend(m *ice.Message, msg *ice.Message) string {
-	return m.Target().Server().(*Frame).addSend(kit.Format(m.Target().ID()), msg)
-}
-func getSend(m *ice.Message, key string) *ice.Message {
-	return m.Target().Server().(*Frame).getSend(key)
-}
--- a/base/web/web.go
+++ b/base/web/web.go
@ -12,20 +12,15 @@ import (
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/tcp"
 	kit "shylinux.com/x/toolkits"
-	"shylinux.com/x/toolkits/task"
 )

 type Frame struct {
 	*ice.Message
 	*http.Server
 	*http.ServeMux
-	lock task.Lock
-	send ice.Messages
 }

-func (f *Frame) Begin(m *ice.Message, arg ...string) {
-	f.send = ice.Messages{}
-}
+func (f *Frame) Begin(m *ice.Message, arg ...string) {}
 func (f *Frame) Start(m *ice.Message, arg ...string) {
 	f.Message, f.Server = m, &http.Server{Handler: f}
 	list := map[*ice.Context]string{}
@ -72,17 +67,6 @@ func (f *Frame) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		f.ServeMux.ServeHTTP(w, r)
 	}
 }
-func (f *Frame) addSend(key string, msg *ice.Message) string {
-	defer f.lock.Lock()()
-	f.send[key] = msg
-	return key
-}
-func (f *Frame) getSend(key string) *ice.Message {
-	defer f.lock.RLock()()
-	msg, _ := f.send[key]
-	delete(f.send, key)
-	return msg
-}

 const WEB = "web"

--- a/conf.go
+++ b/conf.go
@ -168,7 +168,6 @@ const ( // MSG
 	MSG_UPLOAD = "_upload"
 	MSG_SOURCE = "_source"
 	MSG_TARGET = "_target"
-	MSG_HANDLE = "_handle"
 	MSG_ACTION = "_action"
 	MSG_STATUS = "_status"

--- a/core/chat/theme.go
+++ b/core/chat/theme.go
@ -76,8 +76,8 @@ func init() {
 			}},
 		}, mdb.ZoneAction(mdb.FIELD, "time,id,tags,type,name,value"), aaa.WhiteAction()), Hand: func(m *ice.Message, arg ...string) {
 			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
-				m.Cmd(nfs.DIR, nfs.PWD, ice.OptionFields(), kit.Dict(nfs.DIR_ROOT, "src/website/theme/")).RenameAppend(nfs.PATH, mdb.ZONE, nfs.SIZE, mdb.COUNT).Table(func(values ice.Maps) {
-					m.Push("", values)
+				m.Cmd(nfs.DIR, nfs.PWD, ice.OptionFields(), kit.Dict(nfs.DIR_ROOT, "src/website/theme/")).RenameAppend(nfs.PATH, mdb.ZONE, nfs.SIZE, mdb.COUNT).Table(func(value ice.Maps) {
+					m.Push("", value)
 				})
 				m.PushAction("choose", "form", mdb.REMOVE)
 			} else {
--- a/exec.go
+++ b/exec.go
@ -5,6 +5,7 @@ import (
 	"io"
 	"reflect"
 	"strings"
+	"sync"
 	"time"

 	kit "shylinux.com/x/toolkits"
@ -57,8 +58,24 @@ func (m *Message) Go(cb func(), arg ...Any) {
 	kit.If(len(arg) == 0, func() { arg = append(arg, logs.FileLine(cb)) })
 	task.Put(arg[0], func(task *task.Task) { m.TryCatch(m, true, func(m *Message) { cb() }) })
 }
+func (m *Message) Wait(cb ...Handler) (wait func(), done Handler) {
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	t := time.AfterFunc(kit.Duration("30s"), func() { wg.Done() })
+	return func() { wg.Wait() }, func(msg *Message, arg ...string) {
+		defer wg.Done()
+		defer t.Stop()
+		kit.If(len(cb) > 0 && cb[0] != nil, func() { cb[0](msg, arg...) }, func() { m.Copy(msg) })
+	}
+}

-func (m *Message) Cmd(arg ...Any) *Message  { return m._command(arg...) }
+func (m *Message) Cmd(arg ...Any) *Message { return m._command(arg...) }
+func (m *Message) Cmdv(arg ...Any) string {
+	args := kit.Simple(arg...)
+	field := kit.Slice(args, -1)[0]
+	return m._command(kit.Slice(args, 0, -1), OptionFields(field)).Append(field)
+}
+func (m *Message) Cmds(arg ...Any) *Message { return m.Cmd(append(arg, OptionFields(""))...) }
 func (m *Message) Cmdy(arg ...Any) *Message { return m.Copy(m._command(arg...)) }
 func (m *Message) Cmdx(arg ...Any) string {
 	res := kit.Select("", m._command(arg...).meta[MSG_RESULT], 0)
--- a/logs.go
+++ b/logs.go
@ -168,7 +168,7 @@ func (m *Message) FormatsMeta(w io.Writer, arg ...string) (res string) {
 	kit.For(m.meta[MSG_OPTION], func(i int, k string) {
 		kit.If(len(m.meta[k]) == 0 || len(m.meta[k]) == 1 && m.meta[k][0] == "", func() { m.meta[MSG_OPTION][i] = "" })
 	})
-	m.meta[MSG_OPTION] = kit.Filters(m.meta[MSG_OPTION], MSG_CMDS, MSG_FIELDS, MSG_SESSID, MSG_OPTS, MSG_HANDLE, MSG_OUTPUT, MSG_INDEX, "", "aaa.checker")
+	m.meta[MSG_OPTION] = kit.Filters(m.meta[MSG_OPTION], MSG_CMDS, MSG_FIELDS, MSG_SESSID, MSG_OPTS, MSG_OUTPUT, MSG_INDEX, "", "aaa.checker")
 	kit.If(len(arg) == 0 && m.Option(DEBUG) == TRUE, func() { arg = []string{SP, SP, NL} })
 	bio, count, NL := bufio.NewWriter(w), 0, kit.Select("", arg, 2)
 	defer bio.Flush()
--- a/meta.go
+++ b/meta.go
@ -285,7 +285,7 @@ func (m *Message) Sort(key string, arg ...string) *Message {
 	if m.FieldsIsDetail() {
 		return m
 	}
-	keys, cmps := kit.Split(key), kit.Simple()
+	keys, cmps := kit.Split(kit.Select(key, "type,name,text")), kit.Simple()
 	for i, k := range keys {
 		cmp := kit.Select("", arg, i)
 		if cmp == "" {
--- a/misc/git/status.go
+++ b/misc/git/status.go
@ -186,8 +186,8 @@ func init() {
 					case nfs.FROM:
 						m.Push(arg[0], kit.MergeURL2(ice.Info.Make.Remote, ice.PS))
 					case nfs.TO:
-						m.Cmd(web.BROAD, func(values ice.Maps) {
-							m.Push(arg[0], kit.Format("http://%s:%s/", values[tcp.HOST], values[tcp.PORT]))
+						m.Cmd(web.BROAD, func(value ice.Maps) {
+							m.Push(arg[0], kit.Format("http://%s:%s/", value[tcp.HOST], value[tcp.PORT]))
 						})
 					}
 					return
@ -267,9 +267,9 @@ func init() {
 				}
 			}},
 			"insteadof": {Name: "insteadof from* to", Help: "代理", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(CONFIGS, func(values ice.Maps) {
-					if values[mdb.VALUE] == m.Option(nfs.FROM) {
-						_configs_set(m, "--unset", values[mdb.NAME])
+				m.Cmd(CONFIGS, func(value ice.Maps) {
+					if value[mdb.VALUE] == m.Option(nfs.FROM) {
+						_configs_set(m, "--unset", value[mdb.NAME])
 					}
 				})
 				if m.Option(nfs.TO) != "" {
--- a/option.go
+++ b/option.go
@ -13,6 +13,7 @@ type Option struct {
 }

 func OptionFields(arg ...string) Option { return Option{MSG_FIELDS, kit.Join(arg)} }
+func OptionSilent(arg ...string) Option { return Option{LOG_DISABLE, TRUE} }
 func (m *Message) OptionFields(arg ...string) string {
 	kit.If(len(arg) > 0, func() { m.Option(MSG_FIELDS, kit.Join(arg)) })
 	return kit.Join(kit.Simple(m.Optionv(MSG_FIELDS)))