liubin/ContextOS
1
0
Fork 0
forked from x/ContextOS
Code Pull Requests Activity

mac pro ctx

Browse Source
This commit is contained in:
shaoying 2018-07-26 01:39:27 +08:00
parent 62af8f9a2e
commit 5ca0bca18b
11 changed files with 381 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/contexts/aaa/aaa.go
View File

@ -59,7 +59,6 @@ func (aaa *AAA) Spawn(m *ctx.Message, c *ctx.Context, arg ...string) ctx.Server
// }}}
func (aaa *AAA) Begin(m *ctx.Message, arg ...string) ctx.Server { // {{{
aaa.Context.Master(nil)
aaa.Caches["group"] = &ctx.Cache{Name: "用户组", Value: "", Help: "用户组"}
aaa.Caches["username"] = &ctx.Cache{Name: "用户名", Value: "", Help: "用户名"}
aaa.Caches["password"] = &ctx.Cache{Name: "用户密码", Value: "", Help: "用户密码，加密存储", Hand: func(m *ctx.Message, x *ctx.Cache, arg ...string) string {
@ -98,10 +97,9 @@ func (aaa *AAA) Start(m *ctx.Message, arg ...string) bool { // {{{
m.Cap("stream", m.Cap("username"))
m.Cap("sessid", aaa.Session(arg[1]))
Pulse.Capi("nuser", 1)
aaa.Owner = aaa.Context
}
m.Log("info", m.Source(), "%s login %s %s", Pulse.Cap("nuser"), m.Cap("group"), m.Cap("username"))
m.Log("info", "%s login %s %s", Pulse.Cap("nuser"), m.Cap("group"), m.Cap("username"))
return false
}
@ -111,7 +109,7 @@ func (aaa *AAA) Close(m *ctx.Message, arg ...string) bool { // {{{
case m.Target():
root := Pulse.Target().Server.(*AAA)
delete(root.sessions, m.Cap("sessid"))
m.Log("info", nil, "%d logout %s", Pulse.Capi("nuser", -1)+1, m.Cap("username"))
m.Log("info", "%d logout %s", Pulse.Capi("nuser", -1)+1, m.Cap("username"))
case m.Source():
}
@ -131,25 +129,25 @@ var Index = &ctx.Context{Name: "aaa", Help: "认证中心",
},
Commands: map[string]*ctx.Command{
"login": &ctx.Command{Name: "login [sessid]|[[group] username password]]", Help: "用户登录", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
m.Target(c) // {{{
// m.Target(c) // {{{
aaa := c.Server.(*AAA)
switch len(arg) {
case 0:
m.Travel(c, func(m *ctx.Message) bool {
m.Travel(func(m *ctx.Message, i int) bool {
m.Echo("%s(%s): %s\n", m.Target().Name, m.Cap("group"), m.Cap("time"))
if int64(m.Capi("expire")) < time.Now().Unix() {
m.Target().Close(m)
}
return true
})
}, c)
case 1:
s, ok := aaa.sessions[arg[0]]
_, ok := aaa.sessions[arg[0]]
m.Assert(ok, "会话失败")
m.Target(s)
// m.Target(s)
m.Assert(int64(m.Capi("expire")) > time.Now().Unix(), "会话失败")
m.Log("info", m.Source(), "logon %s %s", m.Cap("username"), m.Cap("group"))
m.Log("info", "logon %s %s", m.Cap("username"), m.Cap("group"))
m.Echo(m.Cap("username"))
m.Append("username", m.Cap("username"))
@ -165,17 +163,14 @@ var Index = &ctx.Context{Name: "aaa", Help: "认证中心",
msg := m
if username == Pulse.Conf("rootname") {
msg = Pulse.Spawn(Pulse.Target())
ctx.Index.Sessions["aaa"] = msg
msg.Set("detail", group, username).Target().Start(msg)
} else if msg = Pulse.Find(username, false); msg == nil {
m.Start(username, "认证用户", group, username)
msg = m
} else {
m.Target(msg.Target())
// m.Target(msg.Target())
}
msg.Target().Sessions["aaa"] = msg
msg.Cap("password", password)
aaa.sessions[m.Cap("sessid")] = msg.Target()
@ -197,15 +192,15 @@ var Index = &ctx.Context{Name: "aaa", Help: "认证中心",
return
}
group := m.Sess("aaa").Cap("group")
m.Travel(c, func(msg *ctx.Message) bool {
group := m.Sesss("aaa").Cap("group")
m.Travel(func(msg *ctx.Message, i int) bool {
aaa := msg.Target().Server.(*AAA)
if aaa.share == nil {
aaa.share = make(map[string]*ctx.Context)
}
aaa.share[group] = m.Target()
return true
})
}, c)
// }}}
}},
"md5": &ctx.Command{Name: "md5 [file filename][content]", Help: "散列",

12
src/contexts/cli/cli.go
View File

@ -211,7 +211,7 @@ var Index = &ctx.Context{Name: "cli", Help: "管理中心",
if _, ok := m.Target().Server.(*CLI); m.Assert(ok) { // {{{
m.Start(m.Confx("cli_name", arg, 2), m.Confx("cli_help", arg, 3), key, arg[0])
if len(arg) < 2 || arg[1] != "async" {
<-m.Target().Exit
m.Target().Wait()
}
} // }}}
}},
@ -274,7 +274,7 @@ var Index = &ctx.Context{Name: "cli", Help: "管理中心",
m.Echo("%s not exist", arg[1])
return
}
m.Log("info", nil, "import %s", arg[1])
m.Log("info", "import %s", arg[1])
module := msg.Cap("module")
for k, _ := range msg.Target().Commands {
if len(arg) == 2 {
@ -292,16 +292,16 @@ var Index = &ctx.Context{Name: "cli", Help: "管理中心",
default:
cli.alias[arg[0]] = arg[1:]
m.Echo("%s: %v\n", arg[0], cli.alias[arg[0]])
m.Log("info", nil, "%s: %v", arg[0], cli.alias[arg[0]])
m.Log("info", "%s: %v", arg[0], cli.alias[arg[0]])
}
}
} // }}}
}},
"sleep": &ctx.Command{Name: "sleep time", Help: "睡眠, time(ns/us/ms/s/m/h): 时间值(纳秒/微秒/毫秒/秒/分钟/小时)", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
if d, e := time.ParseDuration(arg[0]); m.Assert(e) { // {{{
m.Log("info", nil, "sleep %v", d)
m.Log("info", "sleep %v", d)
time.Sleep(d)
m.Log("info", nil, "sleep %v done", d)
m.Log("info", "sleep %v done", d)
} // }}}
}},
"time": &ctx.Command{
@ -710,7 +710,7 @@ var Index = &ctx.Context{Name: "cli", Help: "管理中心",
m.Cap("ps_target", cli.target.Name)
} else {
msg.Hand = true
msg.Log("system", nil, "%v", msg.Meta["detail"])
msg.Log("system", "%v", msg.Meta["detail"])
msg.Set("result").Set("append")
c := exec.Command(msg.Meta["detail"][0], msg.Meta["detail"][1:]...)

672
src/contexts/ctx.go
View File

@ -89,23 +89,16 @@ type Context struct {
Caches map[string]*Cache
Configs map[string]*Config
Commands map[string]*Command
root *Context
context *Context
contexts map[string]*Context
Requests []*Message
Sessions []*Message
//TODO: delete
master *Context
messages chan *Message
Pulse *Message
Historys []*Message
Owner *Context
Index map[string]*Context
Exit chan bool
requests []*Message
sessions []*Message
contexts map[string]*Context
context *Context
root *Context
exit chan bool
Server
}
@ -152,17 +145,10 @@ func (c *Context) Begin(m *Message, arg ...string) *Context { // {{{
c.Caches["status"] = &Cache{Name: "status(begin/start/close)", Value: "begin", Help: "模块状态，begin:初始完成，start:正在运行，close:未在运行"}
c.Caches["stream"] = &Cache{Name: "stream", Value: "", Help: "模块数据"}
c.Requests = append(c.Requests, m)
m.source.Sessions = append(m.source.Sessions, m)
c.requests = append(c.requests, m)
m.source.sessions = append(m.source.sessions, m)
//TODO: delete
m.Index = 1
c.Pulse = m
c.Historys = []*Message{m}
c.master = m.master.master
c.Owner = m.master.Owner
m.Log("begin", nil, "%d context %v %v", m.root.Capi("ncontext", 1), m.Meta["detail"], m.Meta["option"])
m.Log("begin", "%d context %v %v", m.root.Capi("ncontext", 1), m.Meta["detail"], m.Meta["option"])
for k, x := range c.Configs {
if x.Hand != nil {
m.Conf(k, x.Value)
@ -182,16 +168,17 @@ func (c *Context) Start(m *Message, arg ...string) bool { // {{{
m.Meta["detail"] = arg
}
c.Requests = append(c.Requests, m)
c.requests = append(c.requests, m)
m.source.sessions = append(m.source.sessions, m)
if m.Hand = true; m.Cap("status") == "start" {
return true
}
running := make(chan bool)
go m.TryCatch(m, true, func(m *Message) {
m.Log(m.Cap("status", "start"), nil, "%d server %v %v", m.root.Capi("nserver", 1), m.Meta["detail"], m.Meta["option"])
c.Exit = make(chan bool, 1)
m.Log(m.Cap("status", "start"), "%d server %v %v", m.root.Capi("nserver", 1), m.Meta["detail"], m.Meta["option"])
c.exit = make(chan bool, 1)
if running <- true; c.Server != nil && c.Server.Start(m, m.Meta["detail"]...) {
c.Close(m, m.Meta["detail"]...)
}
@ -201,58 +188,45 @@ func (c *Context) Start(m *Message, arg ...string) bool { // {{{
// }}}
func (c *Context) Close(m *Message, arg ...string) bool { // {{{
m.Log("close", c, "%d:%d %v", len(m.source.Sessions), len(m.target.Historys), arg)
m.Log("close", "%d %v", len(c.requests), arg)
if m.target == c {
if m.Index == 0 {
for i := len(c.Requests) - 1; i >= 0; i-- {
v := c.Requests[i]
if v.Index = -1; v.source != c && !v.source.Close(v, arg...) {
v.Index = i
return false
for i := len(c.requests) - 1; i >= 0; i-- {
if msg := c.requests[i]; msg.code == m.code {
if msg.source == c || c.Server == nil || c.Server.Close(m, arg...) {
for j := i + 1; j < len(c.requests)-1; j++ {
c.requests[j] = c.requests[j+1]
}
c.Requests = c.Requests[:i]
}
} else if m.Index > 0 {
for i := m.Index - 1; i < len(c.Requests)-1; i++ {
c.Requests[i] = c.Requests[i+1]
}
c.Requests = c.Requests[:len(c.Requests)-1]
}
}
if c.Server != nil && !c.Server.Close(m, arg...) {
return false
}
if m.source == c && m.target != c {
if _, ok := c.Sessions[m.Name]; ok {
delete(c.Sessions, m.Name)
}
return true
}
if len(c.Requests) > 1 {
if len(c.requests) > 0 {
return false
}
if m.Cap("status") == "start" {
m.Log(m.Cap("status", "close"), nil, "%d server %v", m.root.Capi("nserver", -1)+1, arg)
for _, v := range c.Sessions {
if v.target != c {
v.target.Close(v, arg...)
m.Log(m.Cap("status", "close"), "%d server %v", m.root.Capi("nserver", -1)+1, arg)
for _, msg := range c.sessions {
if msg.target != c {
msg.target.Close(msg, arg...)
}
}
}
// if m.Index == 0 && c.context != nil && len(c.contexts) == 0 {
if c.context != nil {
m.Log("close", nil, "%d context %v", m.root.Capi("ncontext", -1)+1, arg)
m.Log("close", "%d context %v", m.root.Capi("ncontext", -1)+1, arg)
delete(c.context.contexts, c.Name)
c.context = nil
if c.Exit != nil {
c.Exit <- true
c.Wait()
}
return true
}
// }}}
func (c *Context) Wait() bool { // {{{
if c.exit != nil {
return <-c.exit
}
return true
}
@ -263,17 +237,6 @@ func (c *Context) Context() *Context { // {{{
return c.context
}
// }}}
func (c *Context) Master(s ...*Context) *Context { // {{{
if len(s) > 0 {
switch s[0] {
case nil, c:
c.master = s[0]
}
}
return c.master
}
// }}}
func (c *Context) Has(key ...string) bool { // {{{
switch len(key) {
@ -300,36 +263,23 @@ func (c *Context) Has(key ...string) bool { // {{{
// }}}
type Callback struct {
ncall int
hand func(msg *Message) (sub *Message)
}
type Message struct {
code int
time time.Time
Name string
source *Context
master *Context
target *Context
Index int
Hand bool
Meta map[string][]string
Data map[string]interface{}
Sessions map[string]*Message
callback func(msg *Message) (sub *Message)
sessions map[string]*Message
messages []*Message
message *Message
root *Message
callback Callback
Wait chan bool
Recv chan bool
Hand bool
Template *Message
}
func (m *Message) Code() int { // {{{
@ -342,41 +292,196 @@ func (m *Message) Message() *Message { // {{{
}
// }}}
func (m *Message) Source(s ...*Context) *Context { // {{{
if len(s) > 0 {
m.source = s[0]
}
func (m *Message) Source() *Context { // {{{
return m.source
}
// }}}
func (m *Message) Master(s ...*Context) *Context { // {{{
if len(s) > 0 && s[0] == m.source {
m.master = m.source
}
return m.master
}
// }}}
func (m *Message) Target(s ...*Context) *Context { // {{{
if len(s) > 0 {
m.target = s[0]
}
func (m *Message) Target() *Context { // {{{
return m.target
}
// }}}
func (m *Message) Format() string { // {{{
name := fmt.Sprintf("%s->%s", m.source.Name, m.target.Name)
if m.Name != "" {
name = fmt.Sprintf("%s.%s->%s.%d", m.source.Name, m.Name, m.target.Name, m.Index)
}
return fmt.Sprintf("%d(%s): %s %v", m.code, name, m.time.Format("15:04:05"), m.Meta["detail"])
return fmt.Sprintf("%d(%s->%s): %s %v", m.code, m.source.Name, m.target.Name, m.time.Format("15:04:05"), m.Meta["detail"], m.Meta["option"])
}
// }}}
func (m *Message) Log(action string, ctx *Context, str string, arg ...interface{}) *Message { // {{{
func (m *Message) BackTrace(hand func(m *Message) bool, c ...*Context) { // {{{
target := m.target
if len(c) > 0 {
target = c[0]
}
for s := target; s != nil; s = s.context {
if m.target = s; !hand(m) {
break
}
}
m.target = target
}
// }}}
func (m *Message) Travel(hand func(m *Message, i int) bool, c ...*Context) { // {{{
target := m.target
if len(c) > 0 {
m.target = c[0]
}
cs := []*Context{m.target}
for i := 0; i < len(cs); i++ {
if m.target = cs[i]; !hand(m, i) {
break
}
keys := []string{}
for k, _ := range cs[i].contexts {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
cs = append(cs, cs[i].contexts[k])
}
}
m.target = target
}
// }}}
func (m *Message) Spawn(arg ...*Context) *Message { // {{{
c := m.target
if len(arg) > 0 {
c = arg[0]
}
msg := &Message{
code: m.root.Capi("nmessage", 1),
time: time.Now(),
source: m.target,
target: c,
message: m,
root: m.root,
}
m.messages = append(m.messages, msg)
return msg
}
// }}}
func (m *Message) Find(name string, root ...bool) *Message { // {{{
target := m.target.root
if len(root) > 0 && !root[0] {
target = m.target
}
cs := target.contexts
for _, v := range strings.Split(name, ".") {
if x, ok := cs[v]; ok {
target, cs = x, x.contexts
} else if target.Name == v {
continue
} else {
m.Log("find", "not find %s", v)
return nil
}
}
m.Log("find", "find %s", name)
return m.Spawn(target)
}
// }}}
func (m *Message) Search(key string, root ...bool) []*Message { // {{{
reg, e := regexp.Compile(key)
m.Assert(e)
target := m.target
if len(root) > 0 && root[0] {
target = m.target.root
}
cs := make([]*Context, 0, 3)
m.Travel(func(m *Message, i int) bool {
if reg.MatchString(m.target.Name) || reg.FindString(m.target.Help) != "" {
m.Log("search", "%d match [%s]", len(cs)+1, key)
cs = append(cs, m.target)
}
return true
}, target)
ms := make([]*Message, len(cs))
for i := 0; i < len(cs); i++ {
ms[i] = m.Spawn(cs[i])
}
return ms
}
// }}}
func (m *Message) Sesss(key string, arg ...interface{}) *Message { // {{{
spawn := true
if _, ok := m.sessions[key]; !ok && len(arg) > 0 {
if m.sessions == nil {
m.sessions = make(map[string]*Message)
}
switch value := arg[0].(type) {
case *Message:
m.sessions[key] = value
return m.sessions[key]
case *Context:
m.sessions[key] = m.Spawn(value)
return m.sessions[key]
case string:
root := true
if len(arg) > 2 {
root = Right(arg[2].(string))
}
method := "find"
if len(arg) > 1 {
method = arg[1].(string)
}
switch method {
case "find":
m.sessions[key] = m.Find(value, root)
case "search":
m.sessions[key] = m.Search(value, root)[0]
}
return m.sessions[key]
case bool:
spawn = value
}
}
for msg := m; msg != nil; msg = msg.message {
if x, ok := msg.sessions[key]; ok {
if spawn {
x = m.Spawn(x.target)
}
return x
}
}
return nil
}
// }}}
func (m *Message) Tree(code int) *Message { // {{{
ms := []*Message{m}
for i := 0; i < len(ms); i++ {
ms = append(ms, ms[i].messages...)
if ms[i].Code() == code {
return ms[i]
}
}
return nil
}
// }}}
func (m *Message) Log(action string, str string, arg ...interface{}) *Message { // {{{
if !m.Options("log") {
return m
}
@ -439,7 +544,7 @@ func (m *Message) TryCatch(msg *Message, safe bool, hand ...func(msg *Message))
e = strings.Join(v.Meta["result"][1:], "")
}
msg.Log("error", nil, "error: %v", e)
msg.Log("error", "error: %v", e)
if msg.root.Conf("debug") == "on" && e != io.EOF {
fmt.Printf("\n\033[31m%s error: %v\033[0m\n", msg.target.Name, e)
debug.PrintStack()
@ -463,246 +568,25 @@ func (m *Message) TryCatch(msg *Message, safe bool, hand ...func(msg *Message))
// }}}
func (m *Message) Spawn(arg ...interface{}) *Message { // {{{
c := m.target
if len(arg) > 0 {
if v, ok := arg[0].(*Context); ok {
c, arg = v, arg[1:]
}
}
key := ""
if len(arg) > 0 {
if v, ok := arg[0].(string); ok {
key, arg = v, arg[1:]
}
}
msg := &Message{
code: m.root.Capi("nmessage", 1),
time: time.Now(),
message: m,
root: m.root,
source: m.target,
master: m.target,
target: c,
}
if m.messages == nil {
m.messages = make([]*Message, 0, 10)
}
m.messages = append(m.messages, msg)
msg.Sessions = make(map[string]*Message)
msg.Wait = make(chan bool)
if key == "" {
return msg
}
if msg.source.Sessions == nil {
msg.source.Sessions = make(map[string]*Message)
}
msg.source.Sessions[key] = msg
msg.Name = key
return msg
}
// }}}
func (m *Message) Tree(code int) *Message { // {{{
ms := []*Message{m}
for i := 0; i < len(ms); i++ {
ms = append(ms, ms[i].messages...)
if ms[i].Code() == code {
return ms[i]
}
}
return nil
}
// }}}
func (m *Message) BackTrace(hand func(m *Message) bool) { // {{{
target := m.target
for s := target; s != nil; s = s.context {
if m.target = s; !hand(m) {
break
}
}
m.target = target
}
// }}}
func (m *Message) Travel(c *Context, hand func(m *Message) bool) { // {{{
if c == nil {
c = m.target
}
target := m.target
cs := []*Context{c}
for i := 0; i < len(cs); i++ {
if m.target = cs[i]; !hand(m) {
break
}
keys := []string{}
for k, _ := range cs[i].contexts {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
cs = append(cs, cs[i].contexts[k])
}
}
m.target = target
}
// }}}
func (m *Message) Search(key string, root ...bool) []*Message { // {{{
reg, e := regexp.Compile(key)
m.Assert(e)
target := m.target
if len(root) > 0 && root[0] {
target = m.target.root
}
cs := make([]*Context, 0, 3)
m.Travel(target, func(m *Message) bool {
if reg.MatchString(m.target.Name) || reg.FindString(m.target.Help) != "" {
m.Log("search", nil, "%d match [%s]", len(cs)+1, key)
cs = append(cs, m.target)
}
return true
})
ms := make([]*Message, len(cs))
for i := 0; i < len(cs); i++ {
ms[i] = m.Spawn(cs[i])
}
return ms
}
// }}}
func (m *Message) Find(name string, root ...bool) *Message { // {{{
target := m.target.root
if len(root) > 0 && !root[0] {
target = m.target
}
cs := target.contexts
for _, v := range strings.Split(name, ".") {
if x, ok := cs[v]; ok {
target, cs = x, x.contexts
} else if target.Name == v {
continue
} else {
m.Log("find", target, "not find %s", v)
return nil
}
}
m.Log("find", nil, "find %s", name)
return m.Spawn(target)
}
// }}}
func (m *Message) Sess(key string, arg ...string) *Message { // {{{
if _, ok := m.target.Sessions[key]; !ok && len(arg) > 0 {
root := true
if len(arg) > 2 {
root = Right(arg[2])
}
method := "find"
if len(arg) > 1 {
method = arg[1]
}
switch method {
case "find":
m.target.Sessions[key] = m.Find(arg[0], root)
case "search":
m.target.Sessions[key] = m.Search(arg[0], root)[0]
}
return m.target.Sessions[key]
}
for msg := m; msg != nil; msg = msg.message {
if x, ok := msg.target.Sessions[key]; ok {
return m.Spawn(x.target)
}
}
return nil
}
// }}}
func (m *Message) Sesss(key string, arg ...interface{}) *Message { // {{{
spawn := true
if _, ok := m.Sessions[key]; !ok && len(arg) > 0 {
switch value := arg[0].(type) {
case *Message:
m.Sessions[key] = value
return m.Sessions[key]
case *Context:
m.Sessions[key] = m.Spawn(value)
return m.Sessions[key]
case string:
root := true
if len(arg) > 2 {
root = Right(arg[2].(string))
}
method := "find"
if len(arg) > 1 {
method = arg[1].(string)
}
switch method {
case "find":
m.Sessions[key] = m.Find(value, root)
case "search":
m.Sessions[key] = m.Search(value, root)[0]
}
return m.Sessions[key]
case bool:
spawn = value
}
}
for msg := m; msg != nil; msg = msg.message {
if x, ok := msg.Sessions[key]; ok {
if spawn {
x = m.Spawn(x.target)
}
return x
}
}
return nil
}
// }}}
func (m *Message) Call(cb func(msg *Message) (sub *Message), arg ...interface{}) *Message { // {{{
m.callback.hand = cb
m.Wait = nil
m.callback = cb
m.Cmd(arg...)
return m
}
// }}}
func (m *Message) Back(msg *Message) *Message { // {{{
if msg == nil || m.callback.hand == nil {
if msg == nil || m.callback == nil {
return m
}
if msg.Hand {
m.Log("cb", nil, "%d %v %v", msg.code, msg.Meta["result"], msg.Meta["append"])
m.Log("cb", "%d %v %v", msg.code, msg.Meta["result"], msg.Meta["append"])
} else {
m.Log("cb", nil, "%d %v %v", msg.code, msg.Meta["detail"], msg.Meta["option"])
m.Log("cb", "%d %v %v", msg.code, msg.Meta["detail"], msg.Meta["option"])
}
m.callback.ncall++
if sub := m.callback.hand(msg); sub != nil && m.message != nil && m.message != m {
if sub := m.callback(msg); sub != nil && m.message != nil && m.message != m {
m.message.Back(sub)
}
@ -720,15 +604,15 @@ func (m *Message) CallBack(sync bool, cb func(msg *Message) (sub *Message), arg
go m.Call(func(sub *Message) *Message {
msg := cb(sub)
m.Log("lock", nil, "before done %v", arg)
m.Log("lock", "before done %v", arg)
wait <- true
m.Log("lock", nil, "after done %v", arg)
m.Log("lock", "after done %v", arg)
return msg
}, arg...)
m.Log("lock", nil, "before wait %v", arg)
m.Log("lock", "before wait %v", arg)
<-wait
m.Log("lock", nil, "after wait %v", arg)
m.Log("lock", "after wait %v", arg)
return m
}
@ -761,7 +645,7 @@ func (m *Message) Add(meta string, key string, value ...interface{}) *Message {
m.Meta[meta] = append(m.Meta[meta], key)
default:
m.Log("error", nil, "%s 消息参数错误", meta)
m.Log("error", "%s 消息参数错误", meta)
}
return m
@ -787,7 +671,7 @@ func (m *Message) Set(meta string, arg ...string) *Message { // {{{
delete(m.Meta, meta)
}
default:
m.Log("error", nil, "%s 消息参数错误", meta)
m.Log("error", "%s 消息参数错误", meta)
}
if len(arg) > 0 {
@ -821,7 +705,7 @@ func (m *Message) Put(meta string, key string, value interface{}) *Message { //
m.Meta[meta] = append(m.Meta[meta], key)
default:
m.Log("error", nil, "%s 消息参数错误", meta)
m.Log("error", "%s 消息参数错误", meta)
}
return m
@ -1326,7 +1210,7 @@ func (m *Message) Cmd(args ...interface{}) *Message { // {{{
for s := c; s != nil; s = s.context {
if x, ok := s.Commands[key]; ok && x.Hand != nil {
m.TryCatch(m, true, func(m *Message) {
m.Log("cmd", s, "%s %v %v", s.Name, m.Meta["detail"], m.Meta["option"])
m.Log("cmd", "%s %v %v", s.Name, m.Meta["detail"], m.Meta["option"])
if args := []string{}; x.Form != nil {
for i := 0; i < len(arg); i++ {
@ -1462,7 +1346,7 @@ func (m *Message) Conf(key string, arg ...string) string { // {{{
} else {
x.Value = arg[0]
}
// m.Log("conf", s, "%s %v", x.Name, x.Value)
// m.Log("conf", "%s %v", x.Name, x.Value)
return x.Value
case 0:
if x.Hand != nil {
@ -1480,11 +1364,11 @@ func (m *Message) Conf(key string, arg ...string) string { // {{{
}
m.target.Configs[key] = &Config{Name: arg[0], Value: arg[1], Help: arg[2], Hand: hand}
m.Log("conf", nil, "%s %v", key, arg)
m.Log("conf", "%s %v", key, arg)
return m.Conf(key, arg[1])
}
// m.Log("error", nil, "%s 配置项不存在", key)
// m.Log("error", "%s 配置项不存在", key)
return ""
}
@ -1583,10 +1467,10 @@ func (m *Message) Cap(key string, arg ...string) string { // {{{
} else {
x.Value = arg[0]
}
// m.Log("debug", s, "%s %s", x.Name, x.Value)
// m.Log("debug", "%s %s", x.Name, x.Value)
return x.Value
case 0:
// m.Log("debug", s, "%s %s", x.Name, x.Value)
// m.Log("debug", "%s %s", x.Name, x.Value)
if x.Hand != nil {
return x.Hand(m, x)
}
@ -1602,11 +1486,11 @@ func (m *Message) Cap(key string, arg ...string) string { // {{{
}
m.target.Caches[key] = &Cache{Name: arg[0], Value: arg[1], Help: arg[2], Hand: hand}
m.Log("cap", nil, "%s %v", key, arg)
m.Log("cap", "%s %v", key, arg)
return m.Cap(key, arg[1])
}
// m.Log("error", nil, "%s 缓存项不存在", key)
// m.Log("error", "%s 缓存项不存在", key)
return ""
}
@ -1717,7 +1601,7 @@ var CGI = template.FuncMap{
case "messages":
case "sessions":
msg := []string{}
for k, _ := range m.Sessions {
for k, _ := range m.sessions {
msg = append(msg, fmt.Sprintf("%s", k))
}
return strings.Join(msg, " ")
@ -1757,7 +1641,7 @@ var CGI = template.FuncMap{
return strings.Join(msg, " ")
case "sessions":
msg := []string{}
for k, _ := range m.Sessions {
for k, _ := range m.sessions {
msg = append(msg, fmt.Sprintf("%s", k))
}
return strings.Join(msg, " ")
@ -1915,11 +1799,9 @@ var CGI = template.FuncMap{
var Pulse = &Message{
code: 0,
time: time.Now(),
Wait: make(chan bool),
source: Index,
master: Index,
target: Index,
Sessions: make(map[string]*Message),
sessions: make(map[string]*Message),
}
var Index = &Context{Name: "ctx", Help: "模块中心",
Caches: map[string]*Cache{
@ -2065,9 +1947,9 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
}
}
if len(msg.Sessions) > 0 {
if len(msg.sessions) > 0 {
m.Color(31, "sessions:\n")
for k, v := range msg.Sessions {
for k, v := range msg.sessions {
m.Echo(" %s %s\n", k, v.Format())
}
}
@ -2188,7 +2070,7 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
msg := m.message // {{{
if len(arg) == 0 {
for msg = msg; msg != nil; msg = msg.message {
for k, v := range msg.Sessions {
for k, v := range msg.sessions {
m.Echo("%s: %d(%s->%s) %v %v\n", k, v.code, v.source.Name, v.target.Name, v.Meta["detail"], v.Meta["option"])
}
}
@ -2197,7 +2079,7 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
var sub *Message
for m := msg; m != nil; m = m.message {
for k, v := range m.Sessions {
for k, v := range m.sessions {
if k == arg[0] {
sub = v
}
@ -2217,7 +2099,7 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
cmd := msg.Spawn(sub.target).Cmd(arg[1:])
m.Copy(cmd, "result").Copy(cmd, "append")
msg.Sessions[arg[0]] = cmd
msg.sessions[arg[0]] = cmd
// }}}
}},
"callback": &Command{Name: "callback index", Help: "查看消息", Hand: func(m *Message, c *Context, key string, arg ...string) {
@ -2226,25 +2108,25 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
index--
switch len(arg) {
case 0:
if msg.callback.hand == nil {
if msg.callback == nil {
return
}
m.Echo("%d: %v\n", index, msg.callback.hand)
m.Echo("%d: %v\n", index, msg.callback)
case 1:
if msg.callback.hand == nil {
if msg.callback == nil {
return
}
if i, e := strconv.Atoi(arg[0]); e == nil && i == index {
m.Echo("%v", msg.callback.hand)
m.Echo("%v", msg.callback)
}
default:
if i, e := strconv.Atoi(arg[0]); e == nil && i == index {
msg.callback.hand = func(msg *Message) *Message {
msg.callback = func(msg *Message) *Message {
return msg
}
m.Echo("%v", msg.callback.hand)
m.Echo("%v", msg.callback)
}
return
}
@ -2252,16 +2134,16 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
if len(arg) == 0 {
m.Echo("msg(%s->%s): %d(%s) %v\n", msg.source.Name, msg.target.Name, msg.code, msg.time.Format("15:04:05"), msg.Meta["detail"])
if msg.callback.hand != nil {
m.Echo(" hand(%d): %v\n", msg.callback.ncall, msg.callback.hand)
if msg.callback != nil {
m.Echo(" hand: %v\n", msg.callback)
}
} else {
switch arg[0] {
case "del":
msg.message.callback.hand = nil
msg.message.callback = nil
case "add":
msg.message.callback.hand = func(msg *Message) *Message {
msg.Log("info", nil, "callback default")
msg.message.callback = func(msg *Message) *Message {
msg.Log("info", "callback default")
return msg
}
return
@ -2387,24 +2269,23 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
m.Add("append", "help", v.Help)
}
case "module":
m.Travel(msg.target, func(msg *Message) bool {
m.Travel(func(msg *Message, i int) bool {
m.Add("append", "name", msg.target.Name)
m.Add("append", "help", msg.target.Help)
m.Add("append", "module", msg.Cap("module"))
m.Add("append", "status", msg.Cap("status"))
m.Add("append", "stream", msg.Cap("stream"))
return true
})
}, msg.target)
case "domain":
msg := m.Find("ssh", true)
msg.Travel(msg.target, func(msg *Message) bool {
m.Find("ssh", true).Travel(func(msg *Message, i int) bool {
m.Add("append", "name", msg.target.Name)
m.Add("append", "help", msg.target.Help)
m.Add("append", "domain", msg.Cap("domain")+"."+msg.Conf("domains"))
return true
})
default:
msg.Travel(msg.target, func(msg *Message) bool {
msg.Travel(func(msg *Message, i int) bool {
target := msg.target
m.Echo("%s(", target.Name)
@ -2413,21 +2294,6 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
}
m.Echo(":")
if target.master != nil {
m.Echo("%s", target.master.Name)
}
m.Echo(":")
if target.Owner != nil {
m.Echo("%s", target.Owner.Name)
}
m.Echo(":")
msg.target = msg.target.Owner
if msg.target != nil {
m.Echo("%s:%s", msg.Cap("username"), msg.Cap("group"))
}
m.Echo("): ")
msg.target = target
m.Echo("%s(%s) ", msg.Cap("status"), msg.Cap("stream"))
@ -2450,12 +2316,12 @@ var Index = &Context{Name: "ctx", Help: "模块中心",
Hand: func(m *Message, c *Context, key string, arg ...string) {
switch len(arg) { // {{{
case 0:
m.Travel(m.target.root, func(m *Message) bool {
m.Travel(func(m *Message, i int) bool {
if m.Cap("status") == "start" {
m.Echo("%s(%s): %s\n", m.target.Name, m.Cap("stream"), m.target.Help)
}
return true
})
}, m.target.root)
default:
switch arg[0] {
@ -3007,20 +2873,18 @@ func Start(args ...string) {
args = args[1:]
}
Index.Owner = Index.contexts["aaa"]
Index.master = Index.contexts["cli"]
for _, m := range Pulse.Search("") {
m.target.root = Index
m.target.Begin(m)
}
Pulse.Options("log", true)
Pulse.Options("terminal_color", true)
Pulse.Sesss("nfs", "nfs")
Pulse.Sesss("lex", "lex")
Pulse.Sesss("yac", "yac")
Pulse.Sesss("log", "log").Conf("bench.log", Pulse.Conf("bench.log"))
Pulse.Sesss("nfs", "nfs")
Pulse.Sesss("yac", "yac")
Pulse.Sesss("lex", "lex")
Pulse.Options("log", true)
Pulse.Options("terminal_color", true)
cli := Pulse.Find("cli").Cmd("source", "stdio", "async")
<-cli.target.Exit
cli.target.Wait()
}

20
src/contexts/lex/lex.go
View File

@ -129,8 +129,8 @@ func (lex *LEX) train(page int, hash int, seed []byte) int { // {{{
cc = append(cc, seed[p])
}
lex.Log("debug", nil, "page: \033[31m%d %v\033[0m", len(ss), ss)
lex.Log("debug", nil, "cell: \033[32m%d %v\033[0m", len(cc), cc)
lex.Log("debug", "page: \033[31m%d %v\033[0m", len(ss), ss)
lex.Log("debug", "cell: \033[32m%d %v\033[0m", len(cc), cc)
flag := '\000'
if p+1 < len(seed) {
@ -151,7 +151,7 @@ func (lex *LEX) train(page int, hash int, seed []byte) int { // {{{
} else {
lex.Capi("nnode", 1)
}
lex.Log("debug", nil, "GET(%d,%d): %v", s, c, state)
lex.Log("debug", "GET(%d,%d): %v", s, c, state)
switch flag {
case '+':
@ -175,7 +175,7 @@ func (lex *LEX) train(page int, hash int, seed []byte) int { // {{{
lex.mat[s][c] = state
points = append(points, &Point{s, c})
lex.Log("debug", nil, "SET(%d,%d): %v(%s,%s)", s, c, state, lex.Cap("nnode"), lex.Cap("nreal"))
lex.Log("debug", "SET(%d,%d): %v(%s,%s)", s, c, state, lex.Cap("nnode"), lex.Cap("nreal"))
}
}
@ -193,7 +193,7 @@ func (lex *LEX) train(page int, hash int, seed []byte) int { // {{{
}
if len(lex.mat[s]) == 0 {
lex.Log("debug", nil, "DEL: %d-%d", lex.Capi("nline")-1, lex.Capi("nline", 0, s))
lex.Log("debug", "DEL: %d-%d", lex.Capi("nline")-1, lex.Capi("nline", 0, s))
lex.mat = lex.mat[:s]
}
}
@ -204,12 +204,12 @@ func (lex *LEX) train(page int, hash int, seed []byte) int { // {{{
*state = *lex.mat[p.s][p.c]
if state.next == s {
lex.Log("debug", nil, "GET(%d, %d): %v", p.s, p.c, state)
lex.Log("debug", "GET(%d, %d): %v", p.s, p.c, state)
if state.hash = hash; state.next >= len(lex.mat) {
state.next = 0
}
lex.mat[p.s][p.c] = state
lex.Log("debug", nil, "SET(%d, %d): %v", p.s, p.c, state)
lex.Log("debug", "SET(%d, %d): %v", p.s, p.c, state)
}
if x, ok := lex.state[*state]; !ok {
@ -241,7 +241,7 @@ func (lex *LEX) parse(m *ctx.Message, page int, line []byte) (hash int, rest []b
}
state := lex.mat[s][c]
lex.Log("debug", nil, "(%d,%d): %v", s, c, state)
lex.Log("debug", "(%d,%d): %v", s, c, state)
if state == nil {
s, star, pos = star, 0, pos-1
continue
@ -438,11 +438,11 @@ var Index = &ctx.Context{Name: "lex", Help: "词法中心",
nnode++
if _, ok := set[x]; !ok {
m.Log("fuck", nil, "not in %d %d %v %p", i, j, x, x)
m.Log("fuck", "not in %d %d %v %p", i, j, x, x)
}
}
}
m.Log("fuck", nil, "node: %d real: %d", nnode, nreal)
m.Log("fuck", "node: %d real: %d", nnode, nreal)
} // }}}
}},
},

17
src/contexts/log/log.go
View File

@ -18,6 +18,8 @@ type LOG struct {
color map[string]int
*Log.Logger
nfs *ctx.Message
*ctx.Message
*ctx.Context
}
@ -44,9 +46,9 @@ func (log *LOG) Begin(m *ctx.Message, arg ...string) ctx.Server { // {{{
log.Configs["bench.log"] = &ctx.Config{Name: "日志文件", Value: "var/bench.log", Help: "模块日志输出的文件", Hand: func(m *ctx.Message, x *ctx.Config, arg ...string) string {
if len(arg) > 0 {
if m.Sess("nfs") == nil {
if nfs := m.Sesss("nfs"); nfs != nil {
os.Create(arg[0])
m.Sess("nfs", "nfs").Cmd("open", arg[0], "", "日志文件")
log.nfs = nfs.Cmd("open", arg[0], "", "日志文件")
}
return arg[0]
}
@ -159,19 +161,16 @@ var Index = &ctx.Context{Name: "log", Help: "日志中心",
if m.Confs("flag_name") {
action = fmt.Sprintf("%s(%s->%s)", action, msg.Source().Name, msg.Target().Name)
if msg.Name != "" {
action = fmt.Sprintf("%s(%s:%s->%s.%d)", action, msg.Source().Name, msg.Name, msg.Target().Name, m.Index)
}
}
}
cmd := strings.Join(arg[1:], "")
if nfs := m.Sess("nfs"); nfs != nil {
if nfs.Options("log", false); color > 0 {
nfs.Cmd("write", fmt.Sprintf("%s\033[%dm%s%s %s\033[0m\n", date, color, code, action, cmd))
if log.nfs != nil {
if log.nfs.Options("log", false); color > 0 {
log.nfs.Cmd("write", fmt.Sprintf("%s\033[%dm%s%s %s\033[0m\n", date, color, code, action, cmd))
} else {
nfs.Cmd("write", fmt.Sprintf("%s%s%s %s\n", date, code, action, cmd))
log.nfs.Cmd("write", fmt.Sprintf("%s%s%s %s\n", date, code, action, cmd))
}
}
} // }}}

35
src/contexts/mdb/mdb.go
View File

@ -51,7 +51,6 @@ func (mdb *MDB) Spawn(m *ctx.Message, c *ctx.Context, arg ...string) ctx.Server
}
func (mdb *MDB) Begin(m *ctx.Message, arg ...string) ctx.Server { // {{{
mdb.Context.Master(nil)
if mdb.Context == Index {
Pulse = m
}
@ -64,7 +63,7 @@ func (mdb *MDB) Start(m *ctx.Message, arg ...string) bool { // {{{
m.Cap("username"), m.Cap("password"), m.Cap("protocol"), m.Cap("address"), m.Cap("database")))
m.Assert(e)
mdb.DB = db
m.Log("info", nil, "mdb open %s", m.Cap("database"))
m.Log("info", "mdb open %s", m.Cap("database"))
return false
}
@ -73,7 +72,7 @@ func (mdb *MDB) Close(m *ctx.Message, arg ...string) bool { // {{{
switch mdb.Context {
case m.Target():
if mdb.DB != nil {
m.Log("info", nil, "mdb close %s", m.Cap("database"))
m.Log("info", "mdb close %s", m.Cap("database"))
mdb.DB.Close()
mdb.DB = nil
}
@ -132,7 +131,7 @@ var Index = &ctx.Context{Name: "mdb", Help: "数据中心",
n, e := ret.RowsAffected()
m.Assert(e)
m.Log("info", nil, "last(%s) nrow(%s)", m.Append("last", id), m.Append("nrow", n))
m.Log("info", "last(%s) nrow(%s)", m.Append("last", id), m.Append("nrow", n))
m.Echo("%d", id).Echo("%d", n)
}
// }}}
@ -173,9 +172,9 @@ var Index = &ctx.Context{Name: "mdb", Help: "数据中心",
}
if len(m.Meta["append"]) > 0 {
m.Log("info", nil, "rows(%d) cols(%d)", len(m.Meta[m.Meta["append"][0]]), len(m.Meta["append"]))
m.Log("info", "rows(%d) cols(%d)", len(m.Meta[m.Meta["append"][0]]), len(m.Meta["append"]))
} else {
m.Log("info", nil, "rows(0) cols(0)")
m.Log("info", "rows(0) cols(0)")
}
}
// }}}
@ -239,10 +238,7 @@ var Index = &ctx.Context{Name: "mdb", Help: "数据中心",
"show": &ctx.Command{
Name: "show table fields... [where conditions] [group fields] [order fields] [limit fields] [offset fields] [save filename] [other rest...]",
Help: "查询数据库, table: 表名, fields: 字段, where: 查询条件, group: 聚合字段, order: 排序字段",
Form: map[string]int{
"where": 1, "group": 1, "order": 1, "limit": 1, "offset": 1,
"extras": 1, "extra_format": 1, "trans_field": 1, "trans_map": 2,
"save": 1, "save_format": 1, "csv_col_sep": 1, "export": 1, "other": -1},
Form: map[string]int{"where": 1, "group": 1, "order": 1, "limit": 1, "offset": 1, "extras": 1, "extra_format": 1, "trans_field": 1, "trans_map": 2, "save": 1, "export": 1, "other": -1},
Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
if mdb, ok := m.Target().Server.(*MDB); m.Assert(ok) { // {{{
table := m.Confx("table", arg, 0)
@ -285,15 +281,7 @@ var Index = &ctx.Context{Name: "mdb", Help: "数据中心",
}
m.Table(func(maps map[string]string, lists []string, line int) bool {
args := []interface{}{}
for i, v := range lists {
if m.Options("save_format") {
key := m.Meta["append"][i]
value := maps[key]
args = append(args, value)
continue
}
if m.Options("save") {
key := m.Meta["append"][i]
value := maps[key]
@ -313,17 +301,10 @@ var Index = &ctx.Context{Name: "mdb", Help: "数据中心",
m.Echo(v)
}
if i < len(lists)-1 {
m.Echo(m.Confx("csv_col_sep"))
m.Echo(m.Conf("csv_col_sep"))
}
}
if m.Options("save_format") {
if line > -1 {
m.Echo(fmt.Sprintf(m.Option("save_format"), args...))
}
return true
}
m.Echo(m.Confx("csv_row_sep"))
m.Echo(m.Conf("csv_row_sep"))
return true
})

44
src/contexts/nfs/nfs.go
View File

@ -47,16 +47,16 @@ type NFS struct {
func (nfs *NFS) open(name string) (*os.File, error) { // {{{
if path.IsAbs(name) {
nfs.Log("info", nil, "open %s", name)
nfs.Log("info", "open %s", name)
return os.Open(name)
}
for i := len(nfs.paths) - 1; i >= 0; i-- {
if f, e := os.Open(path.Join(nfs.paths[i], name)); e == nil {
nfs.Log("info", nil, "open %s", path.Join(nfs.paths[i], name))
nfs.Log("info", "open %s", path.Join(nfs.paths[i], name))
return f, e
}
}
nfs.Log("info", nil, "open %s", name)
nfs.Log("info", "open %s", name)
return os.Open(name)
}
@ -487,8 +487,6 @@ func (nfs *NFS) Read(p []byte) (n int, err error) { // {{{
if len(tab) == 0 {
tabi = 0
prefix := string(buf)
target := nfs.Message.Target()
nfs.Message.Target(nfs.Optionv("ps_target").(*ctx.Context))
nfs.Message.BackTrace(func(m *ctx.Message) bool {
for k, _ := range m.Target().Commands {
if strings.HasPrefix(k, prefix) {
@ -496,8 +494,7 @@ func (nfs *NFS) Read(p []byte) (n int, err error) { // {{{
}
}
return true
})
nfs.Message.Target(target)
}, nfs.Optionv("ps_target").(*ctx.Context))
}
if tabi >= 0 && tabi < len(tab) {
@ -642,8 +639,7 @@ func (nfs *NFS) Start(m *ctx.Message, arg ...string) bool { // {{{
return false
}
m.Target().Sessions["nfs"] = m
m.Sessions["nfs"] = m
m.Sesss("nfs", m)
nfs.Message = m
if socket, ok := m.Data["io"]; ok {
@ -699,9 +695,9 @@ func (nfs *NFS) Start(m *ctx.Message, arg ...string) bool { // {{{
}
if msg.Has("detail") {
msg.Log("info", nil, "%d recv", m.Capi("nrecv", 1))
msg.Log("info", nil, "detail: %v", msg.Meta["detail"])
msg.Log("info", nil, "option: %v", msg.Meta["option"])
msg.Log("info", "%d recv", m.Capi("nrecv", 1))
msg.Log("info", "detail: %v", msg.Meta["detail"])
msg.Log("info", "option: %v", msg.Meta["option"])
msg.Options("stdio", false)
msg.Option("nsend", nsend)
@ -722,9 +718,9 @@ func (nfs *NFS) Start(m *ctx.Message, arg ...string) bool { // {{{
}
}
sub.Log("info", nil, "%d recv", sub.Optioni("nsend"))
sub.Log("info", nil, "result: %v", sub.Meta["result"])
sub.Log("info", nil, "append: %v", sub.Meta["append"])
sub.Log("info", "%d recv", sub.Optioni("nsend"))
sub.Log("info", "result: %v", sub.Meta["result"])
sub.Log("info", "append: %v", sub.Meta["append"])
_, e := fmt.Fprintf(nfs.Writer, "\n")
sub.Assert(e)
@ -746,9 +742,9 @@ func (nfs *NFS) Start(m *ctx.Message, arg ...string) bool { // {{{
msg.Meta["append"] = msg.Meta["option"]
delete(msg.Meta, "option")
msg.Log("info", nil, "%s send", nsend)
msg.Log("info", nil, "result: %v", msg.Meta["result"])
msg.Log("info", nil, "append: %v", msg.Meta["append"])
msg.Log("info", "%s send", nsend)
msg.Log("info", "result: %v", msg.Meta["result"])
msg.Log("info", "append: %v", msg.Meta["append"])
n, e := strconv.Atoi(nsend)
m.Assert(e)
@ -1038,7 +1034,7 @@ var Index = &ctx.Context{Name: "nfs", Help: "存储中心",
buf := make([]byte, s)
if l, e := f.ReadAt(buf, int64(pos)); e == io.EOF || m.Assert(e) {
m.Log("info", nil, "read %d", l)
m.Log("info", "read %d", l)
m.Echo(string(buf[:l]))
}
} // }}}
@ -1178,7 +1174,7 @@ var Index = &ctx.Context{Name: "nfs", Help: "存储中心",
}
case "difftool":
cmd := exec.Command("git", "difftool", "-y")
m.Log("info", nil, "cmd: %s %v", "git", "difftool", "-y")
m.Log("info", "cmd: %s %v", "git", "difftool", "-y")
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
if e := cmd.Start(); e != nil {
m.Echo("error: ")
@ -1257,7 +1253,7 @@ var Index = &ctx.Context{Name: "nfs", Help: "存储中心",
args = append(args, arg[1:]...)
}
m.Log("info", nil, "cmd: %s %v", "git", ctx.Trans("-C", p, c, args))
m.Log("info", "cmd: %s %v", "git", ctx.Trans("-C", p, c, args))
cmd := exec.Command("git", ctx.Trans("-C", p, c, args)...)
if out, e := cmd.CombinedOutput(); e != nil {
m.Echo("error: ")
@ -1342,9 +1338,9 @@ var Index = &ctx.Context{Name: "nfs", Help: "存储中心",
m.Assert(e)
}
}
m.Log("info", nil, "%d send", m.Optioni("nsend"))
m.Log("info", nil, "detail: %v", m.Meta["detail"])
m.Log("info", nil, "option: %v", m.Meta["option"])
m.Log("info", "%d send", m.Optioni("nsend"))
m.Log("info", "detail: %v", m.Meta["detail"])
m.Log("info", "option: %v", m.Meta["option"])
n, e := fmt.Fprintf(nfs.Writer, "\n")
m.Capi("nbytes", n)

31
src/contexts/ssh/ssh.go
View File

@ -30,7 +30,6 @@ func (ssh *SSH) Spawn(m *ctx.Message, c *ctx.Context, arg ...string) ctx.Server
// }}}
func (ssh *SSH) Begin(m *ctx.Message, arg ...string) ctx.Server { // {{{
ssh.Context.Master(nil)
if ssh.Context == Index {
Pulse = m
}
@ -69,20 +68,20 @@ func (ssh *SSH) Close(m *ctx.Message, arg ...string) bool { // {{{
// }}}
func Done(m *ctx.Message, lock chan bool) { // {{{
m.Log("lock", nil, "done before %v", m.Meta["detail"])
m.Log("lock", "done before %v", m.Meta["detail"])
if m.Options("stdio") {
lock <- true
}
m.Log("lock", nil, "done after %v", m.Meta["detail"])
m.Log("lock", "done after %v", m.Meta["detail"])
}
// }}}
func Wait(m *ctx.Message, lock chan bool) { // {{{
m.Log("lock", nil, "wait before %v", m.Meta["detail"])
m.Log("lock", "wait before %v", m.Meta["detail"])
if m.Options("stdio") {
<-lock
}
m.Log("lock", nil, "wait after %v", m.Meta["detail"])
m.Log("lock", "wait after %v", m.Meta["detail"])
}
// }}}
@ -118,7 +117,7 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
m.Find("nfs").Call(func(file *ctx.Message) *ctx.Message {
sub := file.Spawn(m.Target())
sub.Start(fmt.Sprintf("host%d", Pulse.Capi("nhost", 1)), "远程主机")
m.Sessions["ssh"] = sub
m.Sesss("ssh", sub)
return sub
}, m.Meta["detail"])
m.Spawn(m.Target()).Cmd("save")
@ -131,7 +130,7 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
sub := file.Spawn(m.Target())
sub.Copy(m, "detail")
sub.Target().Start(sub)
m.Sessions["ssh"] = sub
m.Sesss("ssh", sub)
sub.Spawn(sub.Target()).Cmd("pwd", m.Conf("domain"))
return sub
@ -179,7 +178,7 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
}
miss := true
m.Travel(c, func(m *ctx.Message) bool { //向下搜索
m.Travel(func(m *ctx.Message, i int) bool { //向下搜索
if ssh, ok := m.Target().Server.(*SSH); ok && m.Conf("domains") == name {
msg := m.Spawn(ssh.nfs)
msg.Option("domain", strings.Join(rest, "."))
@ -190,7 +189,7 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
miss = false
}
return miss
})
}, c)
if miss {
if name == m.Cap("domain") {
@ -217,13 +216,13 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
if m.Options("nsend") {
domain := arg[0]
m.Travel(c, func(m *ctx.Message) bool {
m.Travel(func(m *ctx.Message, i int) bool {
if m.Conf("domains") == domain {
domain = domain + m.Cap("nhost")
return false
}
return true
})
}, c)
m.Conf("domains", domain)
mdb := m.Find(m.Conf("mdb"), true)
@ -254,12 +253,12 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
}},
"list": &ctx.Command{Name: "list", Help: "连接断开", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
domain := m.Cap("domain")
m.Travel(c, func(m *ctx.Message) bool {
m.Travel(func(m *ctx.Message, i int) bool {
if m.Confs("domains") {
m.Echo("%s: %s.%s\n", m.Target().Name, domain, m.Conf("domains"))
}
return true
})
}, c)
}},
"save": &ctx.Command{Name: "save", Help: "远程执行", Hand: func(m *ctx.Message, c *ctx.Context, key string, arg ...string) {
json := m.Sesss("nfs") // {{{
@ -295,7 +294,7 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
cmds = arg[1]
}
m.Travel(ctx.Index, func(msg *ctx.Message) bool {
m.Travel(func(msg *ctx.Message, i int) bool {
current := msg.Target()
if _, ok := current.Index[cmds]; ok {
@ -306,14 +305,14 @@ var Index = &ctx.Context{Name: "ssh", Help: "集群中心",
m.Add("append", "name", current.Name)
m.Add("append", "help", current.Help)
return true
})
}, ctx.Index)
return
}
if len(arg) > 2 {
cmds = arg[2]
}
current := m.Sess(arg[1], arg[1], "search").Target()
current := m.Sesss(arg[1], arg[1], "search").Target()
if x, ok := current.Index[cmds]; ok {
current = x
} else if cmds != "" && cmds != "root" {

13
src/contexts/tcp/tcp.go
View File

@ -32,7 +32,6 @@ func (tcp *TCP) Spawn(m *ctx.Message, c *ctx.Context, arg ...string) ctx.Server
// }}}
func (tcp *TCP) Begin(m *ctx.Message, arg ...string) ctx.Server { // {{{
tcp.Context.Master(nil)
if tcp.Context == Index {
Pulse = m
}
@ -67,7 +66,7 @@ func (tcp *TCP) Start(m *ctx.Message, arg ...string) bool { // {{{
tcp.Conn = c
}
m.Log("info", nil, "%s dial %s", Pulse.Cap("nclient"),
m.Log("info", "%s dial %s", Pulse.Cap("nclient"),
m.Append("stream", m.Cap("stream", fmt.Sprintf("%s->%s", tcp.LocalAddr(), tcp.RemoteAddr()))))
m.Put("append", "io", tcp.Conn).Back(m)
return false
@ -76,7 +75,7 @@ func (tcp *TCP) Start(m *ctx.Message, arg ...string) bool { // {{{
m.Assert(e)
tcp.Conn = c
m.Log("info", nil, "%s accept %s", Pulse.Cap("nclient"),
m.Log("info", "%s accept %s", Pulse.Cap("nclient"),
m.Append("stream", m.Cap("stream", fmt.Sprintf("%s<-%s", tcp.LocalAddr(), tcp.RemoteAddr()))))
m.Put("append", "io", tcp.Conn).Back(m)
return false
@ -95,7 +94,7 @@ func (tcp *TCP) Start(m *ctx.Message, arg ...string) bool { // {{{
tcp.Listener = l
}
m.Log("info", nil, "%d listen %v", Pulse.Capi("nlisten"), m.Cap("stream", fmt.Sprintf("%s", tcp.Addr())))
m.Log("info", "%d listen %v", Pulse.Capi("nlisten"), m.Cap("stream", fmt.Sprintf("%s", tcp.Addr())))
}
for {
@ -115,19 +114,19 @@ func (tcp *TCP) Close(m *ctx.Message, arg ...string) bool { // {{{
switch tcp.Context {
case m.Target():
if tcp.Listener != nil {
m.Log("info", nil, "%d close %v", Pulse.Capi("nlisten", -1)+1, m.Cap("stream"))
m.Log("info", "%d close %v", Pulse.Capi("nlisten", -1)+1, m.Cap("stream"))
tcp.Listener.Close()
tcp.Listener = nil
}
if tcp.Conn != nil {
m.Log("info", nil, "%d close %v", Pulse.Capi("nclient", -1)+1, m.Cap("stream"))
m.Log("info", "%d close %v", Pulse.Capi("nclient", -1)+1, m.Cap("stream"))
tcp.Conn.Close()
tcp.Conn = nil
}
case m.Source():
if tcp.Conn != nil {
msg := m.Spawn(tcp.Context)
if msg.Master(tcp.Context); !tcp.Context.Close(msg, arg...) {
if !tcp.Context.Close(msg, arg...) {
return false
}
}

35
src/contexts/web/web.go
View File

@ -102,7 +102,7 @@ func (web *WEB) Trans(m *ctx.Message, key string, hand func(*ctx.Message, *ctx.C
msg.Option(v.Name, v.Value)
}
msg.Log("cmd", nil, "%s [] %v", key, msg.Meta["option"])
msg.Log("cmd", "%s [] %v", key, msg.Meta["option"])
msg.Put("option", "request", r).Put("option", "response", w)
if hand(msg, msg.Target(), key); msg.Has("redirect") {
@ -126,20 +126,20 @@ func (web *WEB) Trans(m *ctx.Message, key string, hand func(*ctx.Message, *ctx.C
// }}}
func (web *WEB) ServeHTTP(w http.ResponseWriter, r *http.Request) { // {{{
if web.Message != nil {
web.Log("cmd", nil, "%v %s %s", r.RemoteAddr, r.Method, r.URL)
web.Log("cmd", "%v %s %s", r.RemoteAddr, r.Method, r.URL)
if web.Confs("logheaders") {
for k, v := range r.Header {
web.Log("info", nil, "%s: %v", k, v)
web.Log("info", "%s: %v", k, v)
}
web.Log("info", nil, "")
web.Log("info", "")
}
if r.ParseForm(); len(r.PostForm) > 0 {
for k, v := range r.PostForm {
web.Log("info", nil, "%s: %v", k, v)
web.Log("info", "%s: %v", k, v)
}
web.Log("info", nil, "")
web.Log("info", "")
}
}
@ -147,9 +147,9 @@ func (web *WEB) ServeHTTP(w http.ResponseWriter, r *http.Request) { // {{{
if web.Message != nil && web.Confs("logheaders") {
for k, v := range w.Header() {
web.Log("info", nil, "%s: %v", k, v)
web.Log("info", "%s: %v", k, v)
}
web.Log("info", nil, "")
web.Log("info", "")
}
}
@ -167,7 +167,6 @@ func (web *WEB) Spawn(m *ctx.Message, c *ctx.Context, arg ...string) ctx.Server
// }}}
func (web *WEB) Begin(m *ctx.Message, arg ...string) ctx.Server { // {{{
web.Context.Master(nil)
web.Caches["route"] = &ctx.Cache{Name: "请求路径", Value: "/" + web.Context.Name + "/", Help: "请求路径"}
web.Caches["register"] = &ctx.Cache{Name: "已初始化(yes/no)", Value: "no", Help: "模块是否已初始化"}
web.Caches["master"] = &ctx.Cache{Name: "服务入口(yes/no)", Value: "no", Help: "服务入口"}
@ -193,7 +192,7 @@ func (web *WEB) Start(m *ctx.Message, arg ...string) bool { // {{{
m.Cap("directory", arg[0])
}
m.Travel(m.Target(), func(m *ctx.Message) bool {
m.Travel(func(m *ctx.Message, i int) bool {
if h, ok := m.Target().Server.(http.Handler); ok && m.Cap("register") == "no" {
m.Cap("register", "yes")
m.Capi("nroute", 1)
@ -208,12 +207,12 @@ func (web *WEB) Start(m *ctx.Message, arg ...string) bool { // {{{
})
if s, ok := p.Server.(MUX); ok {
m.Log("info", p, "route %s -> %s", m.Cap("route"), m.Target().Name)
m.Log("info", "route %s -> %s", m.Cap("route"), m.Target().Name)
s.Handle(m.Cap("route"), http.StripPrefix(path.Dir(m.Cap("route")), h))
}
if s, ok := m.Target().Server.(MUX); ok && m.Cap("directory") != "" {
m.Log("info", nil, "dir / -> [%s]", m.Cap("directory"))
m.Log("info", "dir / -> [%s]", m.Cap("directory"))
s.Handle("/", http.FileServer(http.Dir(m.Cap("directory"))))
}
}
@ -239,8 +238,8 @@ func (web *WEB) Start(m *ctx.Message, arg ...string) bool { // {{{
m.Cap("master", "yes")
m.Cap("stream", m.Cap("address"))
m.Log("info", nil, "address [%s]", m.Cap("address"))
m.Log("info", nil, "protocol [%s]", m.Cap("protocol"))
m.Log("info", "address [%s]", m.Cap("address"))
m.Log("info", "protocol [%s]", m.Cap("protocol"))
web.Server = &http.Server{Addr: m.Cap("address"), Handler: web}
web.Configs["logheaders"] = &ctx.Config{Name: "日志输出报文头(yes/no)", Value: "no", Help: "日志输出报文头"}
@ -249,8 +248,8 @@ func (web *WEB) Start(m *ctx.Message, arg ...string) bool { // {{{
if web.Message = m; m.Cap("protocol") == "https" {
web.Caches["cert"] = &ctx.Cache{Name: "服务证书", Value: m.Conf("cert"), Help: "服务证书"}
web.Caches["key"] = &ctx.Cache{Name: "服务密钥", Value: m.Conf("key"), Help: "服务密钥"}
m.Log("info", nil, "cert [%s]", m.Cap("cert"))
m.Log("info", nil, "key [%s]", m.Cap("key"))
m.Log("info", "cert [%s]", m.Cap("cert"))
m.Log("info", "key [%s]", m.Cap("key"))
web.Server.ListenAndServeTLS(m.Cap("cert"), m.Cap("key"))
} else {
@ -348,7 +347,7 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心",
method := m.Confx("method")
uri := web.Merge(m, arg[0], arg[1:]...)
m.Log("info", nil, "GET %s", uri)
m.Log("info", "GET %s", uri)
m.Echo("%s: %s\n", method, uri)
var body io.Reader
@ -414,7 +413,7 @@ var Index = &ctx.Context{Name: "web", Help: "应用中心",
}
for k, v := range res.Header {
m.Log("info", nil, "%s: %v", k, v)
m.Log("info", "%s: %v", k, v)
}
if m.Confs("output") {

18
src/contexts/yac/yac.go
View File

@ -79,7 +79,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
if word[i] == "rep{" {
state.star = s
yac.mat[x.s][x.c] = state
yac.Log("debug", nil, "REP(%d, %d): %v", x.s, x.c, state)
yac.Log("debug", "REP(%d, %d): %v", x.s, x.c, state)
}
}
case "mul{":
@ -106,7 +106,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
} else {
yac.Capi("nnode", 1)
}
yac.Log("debug", nil, "GET(%d, %d): %v \033[31m(%s)\033[0m", s, c, state, word[i])
yac.Log("debug", "GET(%d, %d): %v \033[31m(%s)\033[0m", s, c, state, word[i])
if state.next == 0 {
state.next = yac.Capi("nline", 1) - 1
@ -121,7 +121,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
ends = append(ends, &Point{s, c})
points = append(points, &Point{s, c})
yac.Log("debug", nil, "SET(%d, %d): %v", s, c, state)
yac.Log("debug", "SET(%d, %d): %v", s, c, state)
}
}
@ -150,7 +150,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
}
if void {
yac.Log("debug", nil, "DEL: %d-%d", yac.Capi("nline")-1, yac.Capi("nline", 0, s))
yac.Log("debug", "DEL: %d-%d", yac.Capi("nline")-1, yac.Capi("nline", 0, s))
yac.mat = yac.mat[:s]
}
}
@ -161,7 +161,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
*state = *yac.mat[p.s][p.c]
if state.next == s {
yac.Log("debug", nil, "GET(%d, %d): %v", p.s, p.c, state)
yac.Log("debug", "GET(%d, %d): %v", p.s, p.c, state)
if state.next >= len(yac.mat) {
state.next = 0
}
@ -169,7 +169,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
state.hash = hash
}
yac.mat[p.s][p.c] = state
yac.Log("debug", nil, "SET(%d, %d): %v", p.s, p.c, state)
yac.Log("debug", "SET(%d, %d): %v", p.s, p.c, state)
}
if x, ok := yac.state[*state]; !ok {
@ -187,7 +187,7 @@ func (yac *YAC) train(m *ctx.Message, page, hash int, word []string) (int, []*Po
// }}}
func (yac *YAC) parse(m *ctx.Message, out *ctx.Message, page int, void int, line string, level int) (string, []string) { // {{{
if m.Confs("debug") {
m.Log("debug", nil, "%s\\%d %s(%d): %s", m.Conf("label")[0:level], level, yac.name(page), page, line)
m.Log("debug", "%s\\%d %s(%d): %s", m.Conf("label")[0:level], level, yac.name(page), page, line)
}
hash, word := 0, []string{}
@ -252,7 +252,7 @@ func (yac *YAC) parse(m *ctx.Message, out *ctx.Message, page int, void int, line
}
if m.Confs("debug") {
m.Log("debug", nil, "%s/%d %s(%d): %v", m.Conf("label")[0:level], level, yac.name(page), page, word)
m.Log("debug", "%s/%d %s(%d): %v", m.Conf("label")[0:level], level, yac.name(page), page, word)
}
return line, word
@ -373,7 +373,7 @@ var Index = &ctx.Context{Name: "yac", Help: "语法中心",
"nparse": &ctx.Cache{Name: "nparse", Value: "0", Help: "解析器数量"},
},
Configs: map[string]*ctx.Config{
"debug": &ctx.Config{Name: "debug", Value: "true", Help: "词法集合的最大数量"},
"debug": &ctx.Config{Name: "debug", Value: "false", Help: "词法集合的最大数量"},
"ncell": &ctx.Config{Name: "词法上限", Value: "128", Help: "词法集合的最大数量"},
"nlang": &ctx.Config{Name: "语法上限", Value: "32", Help: "语法集合的最大数量"},
"label": &ctx.Config{Name: "嵌套标记", Value: "####################", Help: "嵌套层级日志的标记"},