x/icebergs
1
0
Fork 1
mirror of https://shylinux.com/x/icebergs synced 2025-04-26 09:34:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

add gdb.event

Browse Source
This commit is contained in:
shaoying 2019-12-20 05:03:38 +08:00
parent e31594f131
commit 8e432deab6
17 changed files with 222 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
base.go
View File

@ -30,7 +30,7 @@ func (f *Frame) Begin(m *Message, arg ...string) Server {
return f return f
} }
func (f *Frame) Start(m *Message, arg ...string) bool { func (f *Frame) Start(m *Message, arg ...string) bool {
m.Cmd("_init").Cmd("init", arg) m.Cmd(ICE_INIT).Cmd("init", arg)
return true return true
} }
func (f *Frame) Close(m *Message, arg ...string) bool { func (f *Frame) Close(m *Message, arg ...string) bool {
@ -48,8 +48,8 @@ func (f *Frame) Close(m *Message, arg ...string) bool {
var Index = &Context{Name: "ice", Help: "冰山模块", var Index = &Context{Name: "ice", Help: "冰山模块",
Caches: map[string]*Cache{ Caches: map[string]*Cache{
"status": {Value: "begin"}, CTX_STATUS: {Value: "begin"},
"stream": {Value: "shy"}, CTX_STREAM: {Value: "shy"},
}, },
Configs: map[string]*Config{ Configs: map[string]*Config{
"table": {Name: "数据缓存", Value: map[string]interface{}{ "table": {Name: "数据缓存", Value: map[string]interface{}{
@ -76,10 +76,10 @@ var Index = &Context{Name: "ice", Help: "冰山模块",
}}, }},
}, },
Commands: map[string]*Command{ Commands: map[string]*Command{
"_init": {Name: "_init", Help: "hello", Hand: func(m *Message, c *Context, cmd string, arg ...string) { ICE_INIT: {Hand: func(m *Message, c *Context, cmd string, arg ...string) {
m.Travel(func(p *Context, s *Context) { m.Travel(func(p *Context, s *Context) {
if _, ok := s.Commands["_init"]; ok && p != nil { if _, ok := s.Commands[ICE_INIT]; ok && p != nil {
m.Spawns(s).Runs("_init", "_init", arg...) m.Spawns(s).Runs(ICE_INIT, ICE_INIT, arg...)
} }
}) })
}}, }},
@ -95,13 +95,13 @@ var Index = &Context{Name: "ice", Help: "冰山模块",
"exit": {Name: "exit", Help: "hello", Hand: func(m *Message, c *Context, cmd string, arg ...string) { "exit": {Name: "exit", Help: "hello", Hand: func(m *Message, c *Context, cmd string, arg ...string) {
f := m.root.target.server.(*Frame) f := m.root.target.server.(*Frame)
f.code = kit.Int(kit.Select("0", arg, 0)) f.code = kit.Int(kit.Select("0", arg, 0))
m.root.Cmd("_exit") m.root.Cmd(ICE_EXIT)
}}, }},
"_exit": {Name: "_init", Help: "hello", Hand: func(m *Message, c *Context, cmd string, arg ...string) { ICE_EXIT: {Hand: func(m *Message, c *Context, cmd string, arg ...string) {
m.root.Travel(func(p *Context, s *Context) { m.root.Travel(func(p *Context, s *Context) {
if _, ok := s.Commands["_exit"]; ok && p != nil { if _, ok := s.Commands[ICE_EXIT]; ok && p != nil {
m.TryCatch(m.Spawns(s), true, func(msg *Message) { m.TryCatch(m.Spawns(s), true, func(msg *Message) {
msg.Runs("_exit", "_exit", arg...) msg.Runs(ICE_EXIT, ICE_EXIT, arg...)
}) })
} }
}) })

26
base/aaa/aaa.go
View File

@ -9,29 +9,29 @@ var Index = &ice.Context{Name: "aaa", Help: "认证模块",
Caches: map[string]*ice.Cache{}, Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
"role": {Name: "role", Help: "角色", Value: map[string]interface{}{ "role": {Name: "role", Help: "角色", Value: map[string]interface{}{
"meta": map[string]interface{}{}, ice.MDB_META: map[string]interface{}{},
"hash": map[string]interface{}{ ice.MDB_HASH: map[string]interface{}{
"root": map[string]interface{}{}, "root": map[string]interface{}{},
"tech": map[string]interface{}{}, "tech": map[string]interface{}{},
"void": map[string]interface{}{}, "void": map[string]interface{}{},
}, },
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
}}, }},
"user": {Name: "user", Help: "用户", Value: map[string]interface{}{ "user": {Name: "user", Help: "用户", Value: map[string]interface{}{
"meta": map[string]interface{}{}, ice.MDB_META: map[string]interface{}{},
"hash": map[string]interface{}{}, ice.MDB_HASH: map[string]interface{}{},
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
}}, }},
"sess": {Name: "sess", Help: "会话", Value: map[string]interface{}{ "sess": {Name: "sess", Help: "会话", Value: map[string]interface{}{
"meta": map[string]interface{}{"expire": "720h"}, ice.MDB_META: map[string]interface{}{"expire": "720h"},
"hash": map[string]interface{}{}, ice.MDB_HASH: map[string]interface{}{},
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
"_init": {Name: "_init", Help: "加载", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}}, }},
"_exit": {Name: "_exit", Help: "加载", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}}, }},
"role": {Name: "role", Help: "角色", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "role": {Name: "role", Help: "角色", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}}, }},
@ -52,7 +52,7 @@ var Index = &ice.Context{Name: "aaa", Help: "认证模块",
break break
} }
sessid := kit.Format(user["sessid"]) sessid := kit.Format(user[ice.WEB_SESS])
if sessid == "" { if sessid == "" {
sessid = m.Cmdx("aaa.sess", "login", arg[1]) sessid = m.Cmdx("aaa.sess", "login", arg[1])
} }
@ -61,7 +61,7 @@ var Index = &ice.Context{Name: "aaa", Help: "认证模块",
"create_time": m.Time(), "create_time": m.Time(),
"remote_ip": m.Option("remote_ip"), "remote_ip": m.Option("remote_ip"),
"username": arg[1], "username": arg[1],
"sessid": sessid, ice.WEB_SESS: sessid,
}) })
// 登录成功 // 登录成功
m.Echo(sessid) m.Echo(sessid)

4
base/cli/cli.go
View File

@ -24,7 +24,7 @@ var Index = &ice.Context{Name: "cli", Help: "命令模块",
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
"_init": {Name: "_init", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd("ctx.config", "load", "var/conf/cli.json") m.Cmd("ctx.config", "load", "var/conf/cli.json")
m.Conf("runtime", "host.GOARCH", runtime.GOARCH) m.Conf("runtime", "host.GOARCH", runtime.GOARCH)
@ -45,7 +45,7 @@ var Index = &ice.Context{Name: "cli", Help: "命令模块",
m.Conf("runtime", "node.name", m.Conf("runtime", "boot.pathname")) m.Conf("runtime", "node.name", m.Conf("runtime", "boot.pathname"))
m.Log("info", "runtime %v", kit.Formats(m.Confv("runtime"))) m.Log("info", "runtime %v", kit.Formats(m.Confv("runtime")))
}}, }},
"_exit": {Name: "_exit", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd("ctx.config", "save", "var/conf/cli.json", "cli.runtime") m.Cmd("ctx.config", "save", "var/conf/cli.json", "cli.runtime")
}}, }},
"runtime": {Name: "runtime", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "runtime": {Name: "runtime", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

4
base/ctx/ctx.go
View File

@ -21,8 +21,8 @@ var Index = &ice.Context{Name: "ctx", Help: "元始模块",
m.Push("ups", "shy") m.Push("ups", "shy")
} }
m.Push("name", s.Name) m.Push("name", s.Name)
m.Push("status", s.Cap("status")) m.Push(ice.CTX_STATUS, s.Cap(ice.CTX_STATUS))
m.Push("stream", s.Cap("stream")) m.Push(ice.CTX_STREAM, s.Cap(ice.CTX_STREAM))
m.Push("help", s.Help) m.Push("help", s.Help)
}) })
}}, }},

144
base/gdb/gdb.go
View File

@ -11,36 +11,58 @@ import (
) )
type Frame struct { type Frame struct {
p chan os.Signal s chan os.Signal
t <-chan time.Time
d chan []string
} }
func (f *Frame) Spawn(m *ice.Message, c *ice.Context, arg ...string) ice.Server { func (f *Frame) Spawn(m *ice.Message, c *ice.Context, arg ...string) ice.Server {
return &Frame{} return &Frame{}
} }
func (f *Frame) Begin(m *ice.Message, arg ...string) ice.Server { func (f *Frame) Begin(m *ice.Message, arg ...string) ice.Server {
f.p = make(chan os.Signal, 10)
return f return f
} }
func (f *Frame) Start(m *ice.Message, arg ...string) bool { func (f *Frame) Start(m *ice.Message, arg ...string) bool {
m.Cap("stream", m.Conf("timer", "meta.tick"))
tick := time.Tick(kit.Duration(m.Conf("timer", "meta.tick")))
for { for {
select { select {
case sig, ok := <-f.p: case s, ok := <-f.s:
if !ok { if !ok {
return true return true
} }
m.Log("info", "signal %v", sig) m.Log(ice.LOG_INFO, "signal %v", s)
m.Cmd(m.Confv("signal", kit.Format(sig))) m.Cmd(m.Confv(ice.GDB_SIGNAL, kit.Keys(ice.MDB_HASH, s)))
case now, _ := <-tick: m.Grow(ice.GDB_SIGNAL, nil, map[string]interface{}{
stamp := int(now.Unix()) "create_time": m.Time(), "signal": kit.Format(s),
m.Confm("timer", "hash", func(key string, value map[string]interface{}) { "cmd": m.Confv(ice.GDB_SIGNAL, kit.Format(s)),
})
case t, ok := <-f.t:
if !ok {
return true
}
break
stamp := int(t.Unix())
m.Confm(ice.GDB_TIMER, ice.MDB_HASH, func(key string, value map[string]interface{}) {
if kit.Int(value["next"]) <= stamp { if kit.Int(value["next"]) <= stamp {
m.Log("info", "timer %v %v", key, value["next"]) m.Log(ice.LOG_INFO, "timer %v %v", key, value["next"])
m.Cmd(value["cmd"])
value["next"] = stamp + int(kit.Duration(value["interval"]))/int(time.Second) value["next"] = stamp + int(kit.Duration(value["interval"]))/int(time.Second)
m.Cmd(value["cmd"])
m.Grow(ice.GDB_TIMER, nil, map[string]interface{}{
"create_time": kit.Format(t), "interval": value["interval"],
"cmd": value["cmd"], "key": key,
})
} }
}) })
case d, ok := <-f.d:
if !ok {
return true
}
m.Log(ice.LOG_INFO, "event %v", d)
m.Confm(ice.GDB_EVENT, kit.Keys(ice.MDB_HASH, d[0], d[1], ice.MDB_HASH), func(key string, value map[string]interface{}) {
m.Log(ice.LOG_INFO, "event %v %v", key, value)
m.Cmd(value["cmd"], d[2:])
})
} }
} }
return true return true
@ -49,59 +71,83 @@ func (f *Frame) Close(m *ice.Message, arg ...string) bool {
return true return true
} }
var Index = &ice.Context{Name: "gdb", Help: "调试模块", var Index = &ice.Context{Name: "gdb", Help: "事件模块",
Caches: map[string]*ice.Cache{}, Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
"logpid": &ice.Config{Name: "logpid", Value: "var/run/shy.pid", Help: ""}, ice.GDB_SIGNAL: {Name: "signal", Help: "信号器", Value: map[string]interface{}{
"signal": &ice.Config{Name: "signal", Value: map[string]interface{}{ ice.MDB_META: map[string]interface{}{
"2": []interface{}{"exit"}, "pid": "var/run/shy.pid",
"3": []interface{}{"exit", "1"}, },
"15": []interface{}{"exit", "1"}, ice.MDB_HASH: map[string]interface{}{
"30": []interface{}{"exit"}, "2": []interface{}{"exit"},
"31": []interface{}{"exit", "1"}, "3": []interface{}{"exit", "1"},
"28": "WINCH", "15": []interface{}{"exit", "1"},
}, Help: "信号"}, "30": []interface{}{"exit"},
"timer": {Name: "定时器", Value: map[string]interface{}{ "31": []interface{}{"exit", "1"},
"meta": map[string]interface{}{ "28": "WINCH",
},
ice.MDB_LIST: map[string]interface{}{},
}},
ice.GDB_TIMER: {Name: "timer", Help: "定时器", Value: map[string]interface{}{
ice.MDB_META: map[string]interface{}{
"tick": "100ms", "tick": "100ms",
}, },
"hash": map[string]interface{}{}, ice.MDB_HASH: map[string]interface{}{},
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
}},
ice.GDB_EVENT: {Name: "event", Help: "触发器", Value: map[string]interface{}{
ice.MDB_META: map[string]interface{}{},
ice.MDB_HASH: map[string]interface{}{},
ice.MDB_LIST: map[string]interface{}{},
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
"_init": {Name: "_init", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if f, p, e := kit.Create(m.Conf("logpid")); m.Assert(e) { if f, p, e := kit.Create(m.Conf(ice.GDB_SIGNAL, kit.Keys(ice.MDB_META, "pid"))); m.Assert(e) {
defer f.Close() defer f.Close()
f.WriteString(kit.Format(os.Getpid())) f.WriteString(kit.Format(os.Getpid()))
m.Log("info", "pid %d %s", os.Getpid(), p) m.Log("info", "pid %d: %s", os.Getpid(), p)
} }
f := m.Target().Server().(*Frame) if f, ok := m.Target().Server().(*Frame); ok {
m.Confm("signal", nil, func(sig string, action string) { f.s = make(chan os.Signal, ice.ICE_CHAN)
m.Log("signal", "add %s: %s", sig, action) m.Confm(ice.GDB_SIGNAL, ice.MDB_HASH, func(sig string, action string) {
signal.Notify(f.p, syscall.Signal(kit.Int(sig))) m.Log(ice.GDB_SIGNAL, "add %s: %s", sig, action)
}) signal.Notify(f.s, syscall.Signal(kit.Int(sig)))
})
f.t = time.Tick(kit.Duration(m.Cap(ice.CTX_STREAM, m.Conf(ice.GDB_TIMER, kit.Keys(ice.MDB_META, "tick")))))
f.d = make(chan []string, ice.ICE_CHAN)
}
}}, }},
"_exit": {Name: "_exit", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
f := m.Target().Server().(*Frame) if f, ok := m.Target().Server().(*Frame); ok {
close(f.p) close(f.s)
close(f.d)
}
}}, }},
"timer": {Name: "timer", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.GDB_SIGNAL: {Name: "signal", Help: "信号器", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Conf(ice.GDB_SIGNAL, kit.Keys(ice.MDB_META, arg[0]), arg[1:])
}},
ice.GDB_TIMER: {Name: "timer", Help: "定时器", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
switch arg[0] { switch arg[0] {
case "start": case "start":
h := kit.ShortKey(m.Confm("timer", "hash"), 6) m.Rich(ice.GDB_TIMER, nil, map[string]interface{}{
"next": time.Now().Add(kit.Duration(arg[1])).Unix(),
next := time.Now().Add(kit.Duration(arg[1])).Unix() "interval": arg[1], "cmd": arg[2:],
m.Conf("timer", "hash."+h, map[string]interface{}{
"interval": arg[1],
"next": next,
"cmd": arg[2:],
}) })
m.Echo(h) }
}},
case "stop": ice.GDB_EVENT: {Name: "event", Help: "触发器", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Conf("timer", "hash."+arg[1], "") switch arg[0] {
case "listen":
m.Rich(ice.GDB_EVENT, kit.Keys(ice.MDB_HASH, arg[1], arg[2]), map[string]interface{}{
"create_time": m.Time(), "cmd": arg[3:],
})
case "action":
if f, ok := m.Target().Server().(*Frame); ok {
f.d <- arg[1:]
}
} }
}}, }},
}, },

6
base/log/log.go
View File

@ -72,16 +72,16 @@ var Index = &ice.Context{Name: "log", Help: "日志模块",
}, Help: "信号"}, }, Help: "信号"},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
"_init": {Name: "_init", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Confm("file", nil, func(key string, value map[string]interface{}) { m.Confm("file", nil, func(key string, value map[string]interface{}) {
if f, p, e := kit.Create(kit.Format(value["path"])); m.Assert(e) { if f, p, e := kit.Create(kit.Format(value["path"])); m.Assert(e) {
m.Cap("stream", path.Base(p)) m.Cap(ice.CTX_STREAM, path.Base(p))
m.Log("info", "log %s %s", key, p) m.Log("info", "log %s %s", key, p)
value["file"] = f value["file"] = f
} }
}) })
}}, }},
"_exit": {Name: "_exit", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
f := m.Target().Server().(*Frame) f := m.Target().Server().(*Frame)
ice.Log = nil ice.Log = nil
close(f.p) close(f.p)

2
base/nfs/nfs.go
View File

@ -134,7 +134,7 @@ var Index = &ice.Context{Name: "nfs", Help: "文件模块",
"dir": {Name: "dir", Help: "目录", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "dir": {Name: "dir", Help: "目录", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
rg, _ := regexp.Compile(m.Option("dir_reg")) rg, _ := regexp.Compile(m.Option("dir_reg"))
dir(m, arg[0], arg[1], 0, false, "both", rg, dir(m, arg[0], arg[1], 0, false, "both", rg,
strings.Split(kit.Select("time size line path", arg, 2), " "), "2006-01-02 15:04:05") strings.Split(kit.Select("time size line path", arg, 2), " "), ice.ICE_TIME)
}}, }},
}, },
} }

6
base/ssh/ssh.go
View File

@ -24,7 +24,7 @@ func (f *Frame) Begin(m *ice.Message, arg ...string) ice.Server {
func (f *Frame) Start(m *ice.Message, arg ...string) bool { func (f *Frame) Start(m *ice.Message, arg ...string) bool {
f.in = os.Stdin f.in = os.Stdin
f.out = os.Stdout f.out = os.Stdout
m.Cap("stream", "stdio") m.Cap(ice.CTX_STREAM, "stdio")
prompt := "%d[15:04:05]%s> " prompt := "%d[15:04:05]%s> "
target := m.Target() target := m.Target()
@ -60,10 +60,10 @@ var Index = &ice.Context{Name: "ssh", Help: "终端模块",
Caches: map[string]*ice.Cache{}, Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{}, Configs: map[string]*ice.Config{},
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
"_init": {Name: "_init", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Echo("hello %s world", c.Name) m.Echo("hello %s world", c.Name)
}}, }},
"_exit": {Name: "_exit", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { ice.ICE_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
f := m.Target().Server().(*Frame) f := m.Target().Server().(*Frame)
f.in.Close() f.in.Close()
m.Done() m.Done()

10
base/web/web.go
View File

@ -178,7 +178,7 @@ func (web *WEB) HandleCmd(m *ice.Message, key string, cmd *ice.Command) {
} }
for k, v := range r.Form { for k, v := range r.Form {
for _, v := range v { for _, v := range v {
msg.Add("option", k, v) msg.Add(ice.MSG_OPTION, k, v)
} }
} }
@ -196,7 +196,7 @@ func (web *WEB) HandleCmd(m *ice.Message, key string, cmd *ice.Command) {
case map[string]interface{}: case map[string]interface{}:
for k, v := range d { for k, v := range d {
for _, v := range kit.Simple(v) { for _, v := range kit.Simple(v) {
msg.Add("option", k, v) msg.Add(ice.MSG_OPTION, k, v)
} }
} }
} }
@ -336,20 +336,20 @@ var Index = &ice.Context{Name: "web", Help: "网页模块",
"type": m.Option("node"), "type": m.Option("node"),
"name": m.Option("name"), "name": m.Option("name"),
} }
m.Confv("space", []string{"hash", h}, meta) m.Confv("space", []string{ice.MDB_HASH, h}, meta)
m.Log("space", "conn %v %v", h, kit.Formats(m.Confv("space"))) m.Log("space", "conn %v %v", h, kit.Formats(m.Confv("space")))
web := m.Target().Server().(*WEB) web := m.Target().Server().(*WEB)
m.Gos(m, func(m *ice.Message) { m.Gos(m, func(m *ice.Message) {
web.HandleWSS(m, false, s) web.HandleWSS(m, false, s)
m.Log("space", "close %v %v", h, kit.Formats(m.Confv("space"))) m.Log("space", "close %v %v", h, kit.Formats(m.Confv("space")))
m.Confv("space", []string{"hash", h}, "") m.Confv("space", []string{ice.MDB_HASH, h}, "")
}) })
} }
}}, }},
"space": &ice.Command{Name: "space", Help: "", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "space": &ice.Command{Name: "space", Help: "", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { if len(arg) == 0 {
m.Conf("space", "hash", func(key string, value map[string]interface{}) { m.Conf("space", ice.MDB_HASH, func(key string, value map[string]interface{}) {
m.Push(key, value) m.Push(key, value)
}) })
return return

22
conf.go
View File

@ -1,34 +1,36 @@
package ice package ice
const ( const (
ICE_CHAN = 10
ICE_INIT = "_init" ICE_INIT = "_init"
ICE_EXIT = "_exit" ICE_EXIT = "_exit"
ICE_DATE = "2006-01-02"
ICE_TIME = "2006-01-02 15:04:05" ICE_TIME = "2006-01-02 15:04:05"
) )
const ( const (
CTX_STATUS = "status" CTX_STATUS = "status"
CTX_STREAM = "stream" CTX_STREAM = "stream"
) )
const ( const (
MSG_DETAIL = "detail" MSG_DETAIL = "detail"
MSG_OPTION = "option" MSG_OPTION = "option"
MSG_APPEND = "append" MSG_APPEND = "append"
MSG_RESULT = "result" MSG_RESULT = "result"
) )
const ( const (
MDB_META = "meta" MDB_META = "meta"
MDB_LIST = "hash" MDB_LIST = "list"
MDB_HASH = "list" MDB_HASH = "hash"
)
const (
GDB_SIGNAL = "signal"
GDB_TIMER = "timer"
GDB_EVENT = "event"
) )
const ( const (
WEB_PORT = ":9020" WEB_PORT = ":9020"
WEB_SESS = "sessid" WEB_SESS = "sessid"
) )
const ( const (
LOG_CMD = "cmd" LOG_CMD = "cmd"
LOG_INFO = "info" LOG_INFO = "info"
@ -40,3 +42,9 @@ const (
LOG_BENCH = "bench" LOG_BENCH = "bench"
LOG_CLOSE = "close" LOG_CLOSE = "close"
) )
var Alias = map[string]string{
GDB_SIGNAL: "gdb.signal",
GDB_TIMER: "gdb.timer",
GDB_EVENT: "gdb.event",
}

6
core/chat/chat.go
View File

@ -110,14 +110,14 @@ var Index = &ice.Context{Name: "chat", Help: "聊天模块",
if len(arg) == 0 { if len(arg) == 0 {
m.Confm("group", ice.MDB_HASH, func(key string, value map[string]interface{}) { m.Confm("group", ice.MDB_HASH, func(key string, value map[string]interface{}) {
m.Push("key", key) m.Push("key", key)
m.Push("name", kit.Value(value["meta"], "name")) m.Push("name", kit.Value(value[ice.MDB_META], "name"))
}) })
return return
} }
}}, }},
"/action": {Name: "/action", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "/action": {Name: "/action", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 2 { if len(arg) == 2 {
m.Set("option") m.Set(ice.MSG_OPTION)
m.Confm("group", "hash."+arg[0]+".tool.hash."+arg[1]+".list", func(index int, value map[string]interface{}) { m.Confm("group", "hash."+arg[0]+".tool.hash."+arg[1]+".list", func(index int, value map[string]interface{}) {
m.Push("river", arg[0]) m.Push("river", arg[0])
m.Push("storm", arg[1]) m.Push("storm", arg[1])
@ -143,7 +143,7 @@ var Index = &ice.Context{Name: "chat", Help: "聊天模块",
"/storm": {Name: "/storm", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "/storm": {Name: "/storm", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) < 2 { if len(arg) < 2 {
m.Confm("group", "hash."+arg[0]+".tool.hash", func(key string, value map[string]interface{}) { m.Confm("group", "hash."+arg[0]+".tool.hash", func(key string, value map[string]interface{}) {
m.Push("key", key).Push("count", len(value["list"].([]interface{}))) m.Push("key", key).Push("count", len(value[ice.MDB_LIST].([]interface{})))
}) })
return return
} }

9
core/code/code.go
View File

@ -55,6 +55,9 @@ var Index = &ice.Context{Name: "code", Help: "编程模块",
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(ice.GDB_EVENT, "listen", "miss", "start", "web.code.docker", "image")
}},
"tmux": {Name: "tmux [session [window [pane cmd]]]", Help: "窗口", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { "tmux": {Name: "tmux [session [window [pane cmd]]]", Help: "窗口", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
prefix := kit.Simple(m.Confv("prefix", "tmux")) prefix := kit.Simple(m.Confv("prefix", "tmux"))
if len(arg) > 1 { if len(arg) > 1 {
@ -211,7 +214,7 @@ var Index = &ice.Context{Name: "code", Help: "编程模块",
if arg[0] != "" && kit.IndexOf(m.Appendv("session"), arg[0]) == -1 { if arg[0] != "" && kit.IndexOf(m.Appendv("session"), arg[0]) == -1 {
m.Cmdy(prefix, "new-session", "-ds", arg[0]) m.Cmdy(prefix, "new-session", "-ds", arg[0])
} }
m.Set("append").Set("result") m.Set(ice.MSG_APPEND).Set(ice.MSG_RESULT)
// 查看窗口 // 查看窗口
if m.Cmdy(prefix, "list-windows", "-t", arg[0], "-F", "#{window_id},#{window_active},#{window_name},#{window_panes},#{window_height},#{window_width}", if m.Cmdy(prefix, "list-windows", "-t", arg[0], "-F", "#{window_id},#{window_active},#{window_name},#{window_panes},#{window_height},#{window_width}",
@ -223,7 +226,7 @@ var Index = &ice.Context{Name: "code", Help: "编程模块",
if arg[1] != "" && kit.IndexOf(m.Appendv("window"), arg[1]) == -1 { if arg[1] != "" && kit.IndexOf(m.Appendv("window"), arg[1]) == -1 {
m.Cmdy(prefix, "new-window", "-dt", arg[0], "-n", arg[1]) m.Cmdy(prefix, "new-window", "-dt", arg[0], "-n", arg[1])
} }
m.Set("append").Set("result") m.Set(ice.MSG_APPEND).Set(ice.MSG_RESULT)
// 查看面板 // 查看面板
if len(arg) == 2 { if len(arg) == 2 {
@ -446,7 +449,7 @@ var Index = &ice.Context{Name: "code", Help: "编程模块",
if total { if total {
if count++; i == 1 { if count++; i == 1 {
if t, e := time.Parse("2006-01-02", hs[0]); e == nil { if t, e := time.Parse(ice.ICE_DATE, hs[0]); e == nil {
total_day = time.Now().Sub(t) total_day = time.Now().Sub(t)
m.Append("from", hs[0]) m.Append("from", hs[0])
} }

12
core/mall/mall.go
View File

@ -1,4 +1,4 @@
package team package mall
import ( import (
"github.com/shylinux/toolkits" "github.com/shylinux/toolkits"
@ -12,16 +12,16 @@ import (
"strings" "strings"
) )
var Index = &ice.Context{Name: "team", Help: "团队模块", var Index = &ice.Context{Name: "mall", Help: "团队模块",
Caches: map[string]*ice.Cache{}, Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
"miss": {Value: map[string]interface{}{ "miss": {Value: map[string]interface{}{
"meta": map[string]interface{}{ ice.MDB_META: map[string]interface{}{
"path": "usr/local/work", "path": "usr/local/work",
"cmd": []interface{}{"cli.system", "sh", "ice.sh", "start", "web.space", "connect"}, "cmd": []interface{}{"cli.system", "sh", "ice.sh", "start", "web.space", "connect"},
}, },
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
"hash": map[string]interface{}{}, ice.MDB_HASH: map[string]interface{}{},
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
@ -76,7 +76,7 @@ var Index = &ice.Context{Name: "team", Help: "团队模块",
}, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) { }, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
switch arg[0] { switch arg[0] {
case "create": case "create":
meta := m.Grow("web.chat.group", []string{"hash", m.Option("sess.river"), "task"}, map[string]interface{}{ meta := m.Grow("web.chat.group", []string{ice.MDB_HASH, m.Option("sess.river"), "task"}, map[string]interface{}{
"name": arg[1], "name": arg[1],
"text": kit.Select("", arg, 2), "text": kit.Select("", arg, 2),
"status": "准备", "status": "准备",

12
core/team/team.go
View File

@ -1,4 +1,4 @@
package mall package team
import ( import (
"github.com/shylinux/toolkits" "github.com/shylinux/toolkits"
@ -12,16 +12,16 @@ import (
"strings" "strings"
) )
var Index = &ice.Context{Name: "mall", Help: "商场模块", var Index = &ice.Context{Name: "team", Help: "团队模块",
Caches: map[string]*ice.Cache{}, Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
"miss": {Value: map[string]interface{}{ "miss": {Value: map[string]interface{}{
"meta": map[string]interface{}{ ice.MDB_META: map[string]interface{}{
"path": "usr/local/work", "path": "usr/local/work",
"cmd": []interface{}{"cli.system", "sh", "ice.sh", "start", "web.space", "connect"}, "cmd": []interface{}{"cli.system", "sh", "ice.sh", "start", "web.space", "connect"},
}, },
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
"hash": map[string]interface{}{}, ice.MDB_HASH: map[string]interface{}{},
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{
@ -38,6 +38,7 @@ var Index = &ice.Context{Name: "mall", Help: "商场模块",
case "启动": case "启动":
case "停止": case "停止":
m.Cmd("web.space", arg[0], "exit", "1") m.Cmd("web.space", arg[0], "exit", "1")
m.Cmd(ice.GDB_EVENT, "action", "miss", "stop", arg[0])
return return
} }
} }
@ -55,6 +56,7 @@ var Index = &ice.Context{Name: "mall", Help: "商场模块",
if !m.Confs("web.space", "hash."+arg[0]) { if !m.Confs("web.space", "hash."+arg[0]) {
m.Option("cmd_dir", p) m.Option("cmd_dir", p)
m.Option("cmd_type", "daemon") m.Option("cmd_type", "daemon")
m.Cmd(ice.GDB_EVENT, "action", "miss", "start", arg[0])
m.Cmd(m.Confv("miss", "meta.cmd")) m.Cmd(m.Confv("miss", "meta.cmd"))
} }
} }

16
core/wiki/chart.go
View File

@ -150,14 +150,14 @@ func (b *Chain) show(m *ice.Message, str string) (res []string) {
// 输出节点 // 输出节点
word := kit.Split(line) word := kit.Split(line)
res = append(res, "{", "meta", "{", "text") res = append(res, "{", ice.MDB_META, "{", "text")
res = append(res, word...) res = append(res, word...)
res = append(res, "}", "list", "[") res = append(res, "}", ice.MDB_LIST, "[")
} }
return return
} }
func (b *Chain) size(m *ice.Message, root map[string]interface{}, depth int, width map[int]int) int { func (b *Chain) size(m *ice.Message, root map[string]interface{}, depth int, width map[int]int) int {
meta := root["meta"].(map[string]interface{}) meta := root[ice.MDB_META].(map[string]interface{})
// 最大宽度 // 最大宽度
text := kit.Format(meta["text"]) text := kit.Format(meta["text"])
@ -167,8 +167,8 @@ func (b *Chain) size(m *ice.Message, root map[string]interface{}, depth int, wid
// 计算高度 // 计算高度
height := 0 height := 0
if list, ok := root["list"].([]interface{}); ok && len(list) > 0 { if list, ok := root[ice.MDB_LIST].([]interface{}); ok && len(list) > 0 {
kit.Fetch(root["list"], func(index int, value map[string]interface{}) { kit.Fetch(root[ice.MDB_LIST], func(index int, value map[string]interface{}) {
height += b.size(m, value, depth+1, width) height += b.size(m, value, depth+1, width)
}) })
} else { } else {
@ -179,7 +179,7 @@ func (b *Chain) size(m *ice.Message, root map[string]interface{}, depth int, wid
return height return height
} }
func (b *Chain) draw(m *ice.Message, root map[string]interface{}, depth int, width map[int]int, x, y int, p *Block) Chart { func (b *Chain) draw(m *ice.Message, root map[string]interface{}, depth int, width map[int]int, x, y int, p *Block) Chart {
meta := root["meta"].(map[string]interface{}) meta := root[ice.MDB_META].(map[string]interface{})
b.Width, b.Height = 0, 0 b.Width, b.Height = 0, 0
// 当前节点 // 当前节点
@ -193,11 +193,11 @@ func (b *Chain) draw(m *ice.Message, root map[string]interface{}, depth int, wid
Width: b.GetWidth(strings.Repeat(" ", width[depth])), Width: b.GetWidth(strings.Repeat(" ", width[depth])),
} }
block.Data(root["meta"]) block.Data(root[ice.MDB_META])
block.Init(m, kit.Format(meta["text"])).Draw(m, x, y+(kit.Int(meta["height"])-1)*b.GetHeights()/2) block.Init(m, kit.Format(meta["text"])).Draw(m, x, y+(kit.Int(meta["height"])-1)*b.GetHeights()/2)
// 递归节点 // 递归节点
kit.Fetch(root["list"], func(index int, value map[string]interface{}) { kit.Fetch(root[ice.MDB_LIST], func(index int, value map[string]interface{}) {
b.draw(m, value, depth+1, width, x+b.GetWidths(strings.Repeat(" ", width[depth])), y, block) b.draw(m, value, depth+1, width, x+b.GetWidths(strings.Repeat(" ", width[depth])), y, block)
y += kit.Int(kit.Value(value, "meta.height")) * b.GetHeights() y += kit.Int(kit.Value(value, "meta.height")) * b.GetHeights()
}) })

6
core/wiki/wiki.go
View File

@ -17,11 +17,11 @@ var Index = &ice.Context{Name: "wiki", Help: "文档模块",
Caches: map[string]*ice.Cache{}, Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{ Configs: map[string]*ice.Config{
"note": {Name: "note", Value: map[string]interface{}{ "note": {Name: "note", Value: map[string]interface{}{
"meta": map[string]interface{}{ ice.MDB_META: map[string]interface{}{
"path": "usr/local/wiki", "path": "usr/local/wiki",
}, },
"list": map[string]interface{}{}, ice.MDB_LIST: map[string]interface{}{},
"hash": map[string]interface{}{}, ice.MDB_HASH: map[string]interface{}{},
}}, }},
}, },
Commands: map[string]*ice.Command{ Commands: map[string]*ice.Command{

49
type.go
View File

@ -649,6 +649,11 @@ func (m *Message) Travel(cb interface{}) *Message {
func (m *Message) Search(key interface{}, cb func(p *Context, s *Context, key string)) *Message { func (m *Message) Search(key interface{}, cb func(p *Context, s *Context, key string)) *Message {
switch key := key.(type) { switch key := key.(type) {
case string: case string:
if k, ok := Alias[key]; ok {
key = k
}
fmt.Printf("%v fuck %v\n", m.Time(), key)
if strings.Contains(key, ":") { if strings.Contains(key, ":") {
} else if strings.Contains(key, ".") { } else if strings.Contains(key, ".") {
@ -725,16 +730,42 @@ func (m *Message) Back(sub *Message) *Message {
return m return m
} }
func (m *Message) Rich(key string, args interface{}, data interface{}) map[string]interface{} {
cache := m.Confm(key, args)
if cache == nil {
cache = map[string]interface{}{}
}
meta, ok := cache[MDB_META].(map[string]interface{})
if !ok {
meta = map[string]interface{}{}
}
hash, ok := cache[MDB_HASH].(map[string]interface{})
if !ok {
hash = map[string]interface{}{}
}
h := kit.ShortKey(hash, 6)
hash[h] = data
cache[MDB_HASH] = hash
cache[MDB_META] = meta
if args == nil {
m.Conf(key, cache)
} else {
m.Conf(key, args, cache)
}
return meta
}
func (m *Message) Grow(key string, args interface{}, data interface{}) map[string]interface{} { func (m *Message) Grow(key string, args interface{}, data interface{}) map[string]interface{} {
cache := m.Confm(key, args) cache := m.Confm(key, args)
if cache == nil { if cache == nil {
cache = map[string]interface{}{} cache = map[string]interface{}{}
} }
meta, ok := cache["meta"].(map[string]interface{}) meta, ok := cache[MDB_META].(map[string]interface{})
if !ok { if !ok {
meta = map[string]interface{}{} meta = map[string]interface{}{}
} }
list, _ := cache["list"].([]interface{}) list, _ := cache[MDB_LIST].([]interface{})
// 添加数据 // 添加数据
list = append(list, data) list = append(list, data)
@ -809,8 +840,8 @@ func (m *Message) Grow(key string, args interface{}, data interface{}) map[strin
} }
// 更新数据 // 更新数据
cache["meta"] = meta cache[MDB_LIST] = list
cache["list"] = list cache[MDB_META] = meta
if args == nil { if args == nil {
m.Conf(key, cache) m.Conf(key, cache)
} else { } else {
@ -823,11 +854,11 @@ func (m *Message) Grows(key string, args interface{}, cb interface{}) map[string
if cache == nil { if cache == nil {
return nil return nil
} }
meta, ok := cache["meta"].(map[string]interface{}) meta, ok := cache[MDB_META].(map[string]interface{})
if !ok { if !ok {
return nil return nil
} }
list, ok := cache["list"].([]interface{}) list, ok := cache[MDB_LIST].([]interface{})
if !ok { if !ok {
return nil return nil
} }
@ -937,12 +968,12 @@ func (m *Message) Cmd(arg ...interface{}) *Message {
if cmd, ok := c.Commands[key]; ok { if cmd, ok := c.Commands[key]; ok {
m.TryCatch(m.Spawns(s), true, func(msg *Message) { m.TryCatch(m.Spawns(s), true, func(msg *Message) {
msg.Log(LOG_CMD, "%s.%s %v", c.Name, key, list[1:])
msg.meta[MSG_DETAIL] = list
cmd.Hand(msg, c, key, list[1:]...)
msg.Hand = true msg.Hand = true
m.Hand = true m.Hand = true
m = msg m = msg
msg.Log(LOG_CMD, "%s.%s %v", c.Name, key, list[1:])
msg.meta[MSG_DETAIL] = list
cmd.Hand(msg, c, key, list[1:]...)
}) })
break break
} }