ctx

package
v1.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 1, 2018 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var CGI = template.FuncMap{
	"meta": func(arg ...interface{}) string {

		if len(arg) == 0 {
			return ""
		}

		up := ""

		list := []string{}
		switch data := arg[0].(type) {
		case map[string][]string:
			if len(arg) == 1 {
				list = append(list, fmt.Sprintf("detail: %s\n", data["detail"]))
				list = append(list, fmt.Sprintf("option: %s\n", data["option"]))
				list = append(list, fmt.Sprintf("result: %s\n", data["result"]))
				list = append(list, fmt.Sprintf("append: %s\n", data["append"]))
				break
			}
			if key, ok := arg[1].(string); ok {
				if list, ok = data[key]; ok {
					arg = arg[1:]
				} else {
					return up
				}
			} else {
				return fmt.Sprintf("%v", data)
			}
		case []string:
			list = data
		default:
			if data == nil {
				return ""
			}
			return fmt.Sprintf("%v", data)
		}

		if len(arg) == 1 {
			return strings.Join(list, "")
		}

		index, ok := arg[1].(int)
		if !ok {
			return strings.Join(list, "")
		}

		if index >= len(list) {
			return ""
		}
		return list[index]
	},
	"sess": func(arg ...interface{}) string {
		if len(arg) == 0 {
			return ""
		}

		if m, ok := arg[0].(*Message); ok {
			if len(arg) == 1 {
				return fmt.Sprintf("%v", m)
			}

			switch which := arg[1].(type) {
			case string:
				m.Sess(which, arg[2:]...)
				return ""
			}
		}
		return ""
	},

	"ctx": func(arg ...interface{}) string {
		if len(arg) == 0 {
			return ""
		}
		if m, ok := arg[0].(*Message); ok {
			if len(arg) == 1 {
				return fmt.Sprintf("%v", m)
			}

			switch which := arg[1].(type) {
			case string:
				switch which {
				case "name":
					return fmt.Sprintf("%s", m.target.Name)
				case "help":
					return fmt.Sprintf("%s", m.target.Help)
				case "context":
					return fmt.Sprintf("%s", m.target.context.Name)
				case "contexts":
					ctx := []string{}
					for _, v := range m.target.contexts {
						ctx = append(ctx, fmt.Sprintf("%d", v.Name))
					}
					return strings.Join(ctx, " ")
				case "time":
					return m.time.Format("2006-01-02 15:04:05")
				case "source":
					return m.source.Name
				case "target":
					return m.target.Name
				case "message":
					return fmt.Sprintf("%d", m.message.code)
				case "messages":
				case "sessions":
					msg := []string{}
					for k, _ := range m.Sessions {
						msg = append(msg, fmt.Sprintf("%s", k))
					}
					return strings.Join(msg, " ")
				}
			case int:
			}
		}
		return ""
	},
	"msg": func(arg ...interface{}) interface{} {
		if len(arg) == 0 {
			return ""
		}

		if m, ok := arg[0].(*Message); ok {
			if len(arg) == 1 {
				return fmt.Sprintf("%v", m.Format())
			}

			switch which := arg[1].(type) {
			case string:
				switch which {
				case "spawn":
					return m.Spawn()
				case "code":
					return m.code
				case "time":
					return m.time.Format("2006-01-02 15:04:05")
				case "source":
					return m.source.Name
				case "target":
					return m.target.Name
				case "message":
					return m.message
				case "messages":
					return m.messages
				case "sessions":
					return m.Sessions
				default:
					return m.Sess(which)
				}
			case int:
				ms := []*Message{m}
				for i := 0; i < len(ms); i++ {
					if ms[i].code == which {
						return ms[i]
					}
					ms = append(ms, ms[i].messages...)
				}
			}
		}
		return ""
	},

	"cap": func(arg ...interface{}) string {
		if len(arg) == 0 {
			return ""
		}

		if m, ok := arg[0].(*Message); ok {
			if len(arg) == 1 {
				return fmt.Sprintf("%v", m)
			}

			switch which := arg[1].(type) {
			case string:
				if len(arg) == 2 {
					return m.Cap(which)
				}

				switch value := arg[2].(type) {
				case string:
					return m.Cap(which, value)
				case int:
					return fmt.Sprintf("%d", m.Capi(which, value))
				case bool:
					return fmt.Sprintf("%t", m.Caps(which, value))
				default:
					return m.Cap(which, fmt.Sprintf("%v", arg[2]))
				}
			}
		}
		return ""
	},
	"conf": func(arg ...interface{}) interface{} {
		if len(arg) == 0 {
			return ""
		}

		if m, ok := arg[0].(*Message); ok {
			if len(arg) == 1 {
				list := []string{}
				for k, _ := range m.target.Configs {
					list = append(list, k)
				}
				return list
			}

			switch which := arg[1].(type) {
			case string:
				if len(arg) == 2 {
					return m.Confv(which)
				}
				return m.Confv(which, arg[2:]...)
			}
		}
		return ""
	},
	"cmd": func(arg ...interface{}) string {
		if len(arg) == 0 {
			return ""
		}

		if m, ok := arg[0].(*Message); ok {
			if len(arg) == 1 {
				return fmt.Sprintf("%v", m)
			}

			msg := m.Spawn(m.Target()).Cmd(arg[1:]...)
			return strings.Join(msg.Meta["result"], "")
		}
		return ""
	},

	"detail": func(arg ...interface{}) interface{} {
		if len(arg) == 0 {
			return ""
		}

		switch m := arg[0].(type) {
		case *Message:
			if len(arg) == 1 {
				return m.Meta["detail"]
			}

			index := 0
			switch value := arg[1].(type) {
			case int:
				index = value
			case string:
				i, e := strconv.Atoi(value)
				m.Assert(e)
				index = i
			}

			if len(arg) == 2 {
				return m.Detail(index)
			}

			return m.Detail(index, arg[2])
		case map[string][]string:
			return strings.Join(m["detail"], "")
		case []string:
			return strings.Join(m, "")
		default:
			return m
		}
		return ""
	},
	"option": func(arg ...interface{}) interface{} {
		if len(arg) == 0 {
			return ""
		}

		switch m := arg[0].(type) {
		case *Message:
			if len(arg) == 1 {
				return m.Meta["option"]
			}

			switch value := arg[1].(type) {
			case int:
				if 0 <= value && value < len(m.Meta["option"]) {
					return m.Meta["option"][value]
				}
			case string:
				if len(arg) == 2 {
					return m.Optionv(value)
				}

				switch val := arg[2].(type) {
				case int:
					if 0 <= val && val < len(m.Meta[value]) {
						return m.Meta[value][val]
					}
				}
			}
		case map[string][]string:
			if len(arg) == 1 {
				return strings.Join(m["option"], "")
			}
			switch value := arg[1].(type) {
			case string:
				return strings.Join(m[value], "")
			}
		case []string:
			return strings.Join(m, "")
		default:
			return m
		}
		return ""
	},
	"result": func(arg ...interface{}) interface{} {
		if len(arg) == 0 {
			return ""
		}

		switch m := arg[0].(type) {
		case *Message:
			if len(arg) == 1 {
				return m.Meta["result"]
			}

			index := 0
			switch value := arg[1].(type) {
			case int:
				index = value
			case string:
				i, e := strconv.Atoi(value)
				m.Assert(e)
				index = i
			}

			if len(arg) == 2 {
				return m.Result(index)
			}

			return m.Result(index, arg[2])
		case map[string][]string:
			return strings.Join(m["result"], "")
		case []string:
			return strings.Join(m, "")
		default:
			return m
		}
		return ""
	},
	"append": func(arg ...interface{}) interface{} {
		if len(arg) == 0 {
			return ""
		}

		switch m := arg[0].(type) {
		case *Message:
			if len(arg) == 1 {
				return m.Meta["append"]
			}

			switch value := arg[1].(type) {
			case int:
				if 0 <= value && value < len(m.Meta["append"]) {
					return m.Meta["append"][value]
				}
			case string:
				if len(arg) == 2 {
					return m.Meta[value]
				}

				switch val := arg[2].(type) {
				case int:
					if 0 <= val && val < len(m.Meta[value]) {
						return m.Meta[value][val]
					}
				}
			}
		case map[string][]string:
			if len(arg) == 1 {
				return strings.Join(m["append"], "")
			}
			switch value := arg[1].(type) {
			case string:
				return strings.Join(m[value], "")
			}
		case []string:
			return strings.Join(m, "")
		default:
			return m
		}
		return ""
	},
	"table": func(arg ...interface{}) []interface{} {
		if len(arg) == 0 {
			return []interface{}{}
		}

		switch m := arg[0].(type) {
		case *Message:
			if len(m.Meta["append"]) == 0 {
				return []interface{}{}
			}
			if len(arg) == 1 {
				data := []interface{}{}
				nrow := len(m.Meta[m.Meta["append"][0]])
				for i := 0; i < nrow; i++ {
					line := map[string]string{}
					for _, k := range m.Meta["append"] {
						line[k] = m.Meta[k][i]
						if len(m.Meta[k]) != i {
							continue
						}
					}
					data = append(data, line)
				}

				return data
			}
		case map[string][]string:
			if len(arg) == 1 {
				data := []interface{}{}
				nrow := len(m[m["append"][0]])

				for i := 0; i < nrow; i++ {
					line := map[string]string{}
					for _, k := range m["append"] {
						line[k] = m[k][i]
					}
					data = append(data, line)
				}

				return data
			}
		}
		return []interface{}{}
	},
	"unescape": func(str string) interface{} {
		return template.HTML(str)
	},

	"list": func(arg interface{}) interface{} {
		n := 0
		switch v := arg.(type) {
		case string:
			i, e := strconv.Atoi(v)
			if e == nil {
				n = i
			}
		case int:
			n = v
		}

		list := make([]int, n)
		for i := 1; i <= n; i++ {
			list[i-1] = i
		}
		return list
	},
}
View Source 
var Index = &Context{Name: "ctx", Help: "模块中心",
	Caches: map[string]*Cache{
		"nserver":  &Cache{Name: "nserver", Value: "0", Help: "服务数量"},
		"ncontext": &Cache{Name: "ncontext", Value: "0", Help: "模块数量"},
		"nmessage": &Cache{Name: "nmessage", Value: "0", Help: "消息数量"},
	},
	Configs: map[string]*Config{
		"chain":       &Config{Name: "chain", Value: map[string]interface{}{}, Help: "调试模式，on:打印，off:不打印)"},
		"compact_log": &Config{Name: "compact_log(true/false)", Value: "true", Help: "调试模式，on:打印，off:不打印)"},
		"auto_make":   &Config{Name: "auto_make(true/false)", Value: "true", Help: "调试模式，on:打印，off:不打印)"},
		"debug":       &Config{Name: "debug(on/off)", Value: "on", Help: "调试模式，on:打印，off:不打印)"},

		"search_method": &Config{Name: "search_method(find/search)", Value: "search", Help: "搜索方法, find: 模块名精确匹配, search: 模块名或帮助信息模糊匹配"},
		"search_choice": &Config{Name: "search_choice(first/last/rand/magic)", Value: "magic", Help: "搜索匹配, first: 匹配第一个模块, last: 匹配最后一个模块, rand: 随机选择, magic: 加权选择"},
		"search_action": &Config{Name: "search_action(list/switch)", Value: "switch", Help: "搜索操作, list: 输出模块列表, switch: 模块切换"},
		"search_root":   &Config{Name: "search_root(true/false)", Value: "true", Help: "搜索起点, true: 根模块, false: 当前模块"},

		"insert_limit": &Config{Name: "insert_limit(true/false)", Value: "true", Help: "参数的索引"},
		"detail_index": &Config{Name: "detail_index", Value: "0", Help: "参数的索引"},
		"result_index": &Config{Name: "result_index", Value: "-2", Help: "返回值的索引"},

		"list_help":     &Config{Name: "list_help", Value: "list command", Help: "命令列表帮助"},
		"table_compact": &Config{Name: "table_compact", Value: "false", Help: "命令列表帮助"},
		"table_col_sep": &Config{Name: "table_col_sep", Value: "\t", Help: "命令列表帮助"},
		"table_row_sep": &Config{Name: "table_row_sep", Value: "\n", Help: "命令列表帮助"},

		"page_offset": &Config{Name: "page_offset", Value: "0", Help: "列表偏移"},
		"page_limit":  &Config{Name: "page_limit", Value: "10", Help: "列表大小"},
	},
	Commands: map[string]*Command{
		"help": &Command{Name: "help topic", Help: "帮助", Hand: func(m *Message, c *Context, key string, arg ...string) {
			if len(arg) == 0 {
				m.Echo("usage: help context [module [command|config|cache name]]\n")
				m.Echo("     : 查看模块信息, module: 模块名, command: 模块命令, config: 模块配置, cache: 模块缓存, name: 模块参数\n")
				m.Echo("usage: help command [name]\n")
				m.Echo("     : 查看当前环境下命令, name: 命令名\n")
				m.Echo("usage: help config [name]\n")
				m.Echo("     : 查看当前环境下配置, name: 配置名\n")
				m.Echo("usage: help cache [name]\n")
				m.Echo("     : 查看当前环境下缓存, name: 缓存名\n")
				m.Echo("\n")

				m.Echo("^_^  Welcome to context world  ^_^\n")
				m.Echo("Version: 1.0 A New Language, A New Framework\n")
				m.Echo("More: github.com/shylinux/context/README.md\n")
				m.Color(31, "       c\n")
				m.Color(31, "     sh").Color(33, " go\n")
				m.Color(31, "   vi").Color(32, " php").Color(32, " js\n")
				m.Echo(" ARM Linux HTTP\n")
				m.Color(31, "Context ").Color(32, "Message\n")
				m.Color(32, "ctx ").Color(33, "cli ").Color(31, "aaa ").Color(33, "web\n")
				m.Color(32, "lex ").Color(33, "yac ").Color(31, "log ").Color(33, "gdb\n")
				m.Color(32, "tcp ").Color(33, "nfs ").Color(31, "ssh ").Color(33, "mdb\n")
				m.Color(31, "script ").Color(32, "template\n")
				return
			}

			switch arg[0] {
			case "context":
				switch len(arg) {
				case 1:
					keys := []string{}
					values := map[string]*Context{}
					m.Travel(func(m *Message, i int) bool {
						if _, ok := values[m.Cap("module")]; !ok {
							keys = append(keys, m.Cap("module"))
							values[m.Cap("module")] = m.Target()
						}
						return true
					}, m.Target().root)
					sort.Strings(keys)
					for _, k := range keys {
						m.Echo("%s: %s %s\n", k, values[k].Name, values[k].Help)
					}
					break
				case 2:
					if msg := m.Find(arg[1]); msg != nil {
						m.Echo("%s: %s %s\n", arg[1], msg.Target().Name, msg.Target().Help)
						m.Echo("commands:\n")
						for k, v := range msg.Target().Commands {
							m.Echo("  %s: %s\n", k, v.Name)
						}
						m.Echo("configs:\n")
						for k, v := range msg.Target().Configs {
							m.Echo("  %s: %s\n", k, v.Name)
						}
						m.Echo("caches:\n")
						for k, v := range msg.Target().Caches {
							m.Echo("  %s: %s\n", k, v.Name)
						}
					}
				default:
					if msg := m.Find(arg[1]); msg != nil {
						m.Echo("%s: %s %s\n", arg[1], msg.Target().Name, msg.Target().Help)
						switch arg[2] {
						case "command":
							for k, v := range msg.Target().Commands {
								if k == arg[3] {
									m.Echo("%s: %s\n  %s\n", k, v.Name, v.Help)
								}
							}
						case "config":
							for k, v := range msg.Target().Configs {
								if k == arg[3] {
									m.Echo("%s: %s\n  %s\n", k, v.Name, v.Help)
								}
							}
						case "cache":
							for k, v := range msg.Target().Caches {
								if k == arg[3] {
									m.Echo("%s: %s\n  %s\n", k, v.Name, v.Help)
								}
							}
						}
					}
				}
			case "command":
				keys := []string{}
				values := map[string]*Command{}
				for s := m.Target(); s != nil; s = s.context {
					for k, v := range s.Commands {
						if _, ok := values[k]; ok {
							continue
						}
						if len(arg) > 1 && k == arg[1] {
							m.Echo("%s: %s\n  %s\n", k, v.Name, v.Help)
							for k, v := range v.Form {
								m.Echo("  option: %s(%d)\n", k, v)
							}
							return
						}
						keys = append(keys, k)
						values[k] = v
					}
				}
				sort.Strings(keys)
				for _, k := range keys {
					m.Echo("%s: %s\n", k, values[k].Name)
				}
			case "config":
				keys := []string{}
				values := map[string]*Config{}
				for s := m.Target(); s != nil; s = s.context {
					for k, v := range s.Configs {
						if _, ok := values[k]; ok {
							continue
						}
						if len(arg) > 1 && k == arg[1] {
							m.Echo("%s(%s): %s %s\n", k, v.Value, v.Name, v.Help)
							return
						}
						keys = append(keys, k)
						values[k] = v
					}
				}
				sort.Strings(keys)
				for _, k := range keys {
					m.Echo("%s(%s): %s\n", k, values[k].Value, values[k].Name)
				}
			case "cache":
				keys := []string{}
				values := map[string]*Cache{}
				for s := m.Target(); s != nil; s = s.context {
					for k, v := range s.Caches {
						if _, ok := values[k]; ok {
							continue
						}
						if len(arg) > 1 && k == arg[1] {
							m.Echo("%s(%s): %s %s\n", k, v.Value, v.Name, v.Help)
							return
						}
						keys = append(keys, k)
						values[k] = v
					}
				}
				sort.Strings(keys)
				for _, k := range keys {
					m.Echo("%s(%s): %s\n", k, values[k].Value, values[k].Name)
				}
			}

		}},

		"message": &Command{Name: "message [code] [all]|[cmd...]", Help: "查看消息", Hand: func(m *Message, c *Context, key string, arg ...string) {
			if len(arg) > 0 && arg[0] == "spawn" {
				m.Echo("%d", m.Spawn().code)
				return
			}
			msg := m.Search(m.Cap("ps_target"))[0]
			if msg != nil {
				msg = msg.target.message
			}
			if msg == nil {
				msg = m
			}

			if len(arg) > 0 {
				if code, e := strconv.Atoi(arg[0]); e == nil {
					if msg = m.root.Tree(code); msg != nil {
						arg = arg[1:]
					}
				}
			}

			all := false
			if len(arg) > 0 && arg[0] == "all" {
				all, arg = true, arg[1:]
			}

			if len(arg) == 0 {
				m.Echo("%s\n", msg.Format())
				if len(msg.Meta["option"]) > 0 {
					m.Color(31, "option(%d): %v\n", len(msg.Meta["option"]), msg.Meta["option"])
					for _, k := range msg.Meta["option"] {
						if v, ok := msg.Data[k]; ok {
							m.Echo(" %s: %#v\n", k, v)
						} else {
							m.Echo(" %s(%d): %v\n", k, len(msg.Meta[k]), msg.Meta[k])
						}
					}
				}

				m.Color(31, "result(%d): %v\n", len(msg.Meta["result"]), msg.Meta["result"])
				if len(msg.Meta["append"]) > 0 {
					m.Color(31, "append(%d): %v\n", len(msg.Meta["append"]), msg.Meta["append"])
					for _, k := range msg.Meta["append"] {
						if v, ok := msg.Data[k]; ok {
							m.Echo(" %s: %v\n", k, v)
						} else {
							m.Echo(" %s(%d): %v\n", k, len(msg.Meta[k]), msg.Meta[k])
						}
					}
				}

				if msg.message != nil {
					m.Color(31, "message:\n")
					m.Echo(" %s\n", msg.message.Format())
				}

				if len(msg.messages) > 0 {
					m.Color(31, "messages(%d):\n", len(msg.messages))
					for i, v := range msg.messages {
						if !all {
							switch v.target.Name {
							case "lex", "yac", "log", "gdb":
								continue
							}
						}
						m.Echo(" %d %s\n", i, v.Format())
					}
				}

				if len(msg.Sessions) > 0 {
					m.Color(31, "sessions(%d):\n", len(msg.Sessions))
					for k, v := range msg.Sessions {
						m.Echo(" %s %s\n", k, v.Format())
					}
				}
				if msg.callback != nil {
					m.Color(31, "callback(1): %p\n", msg.callback)
				}
				return
			}

			switch arg[0] {
			case "list":
				ms := []*Message{msg}
				for i := 0; i < len(ms); i++ {
					ms = append(ms, ms[i].messages...)
					m.Add("append", "code", ms[i].code)
					m.Add("append", "msg", fmt.Sprintf("%s->%s: %v", ms[i].source.Name, ms[i].target.Name, ms[i].Meta["detail"]))
				}
				m.Sort("code", "int")
				m.Table()
			case "message":
				for msg := msg; msg != nil; msg = msg.message {
					m.Echo("%s\n", msg.Format())
				}
			case "messages":
				ms := []*Message{msg}
				for i := 0; i < len(ms); i++ {
					ms = append(ms, ms[i].messages...)
					if ms[i].Instance(m.root.Sess("lex", false), true) ||
						ms[i].Instance(m.root.Sess("yac", false), true) ||
						ms[i].Instance(m.root.Sess("log", false), true) ||
						ms[i].Instance(m.root.Sess("lex", false)) ||
						ms[i].Instance(m.root.Sess("yac", false)) ||
						ms[i].Instance(m.root.Sess("log", false)) {
						continue
					}
					m.Echo("%s\n", ms[i].Format())
				}
			default:
				sub := msg.Spawn().Cmd(arg)
				m.Copy(sub, "result").Copy(sub, "append")
			}

		}},
		"detail": &Command{Name: "detail [index] [value...]", Help: "查看或添加参数", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.message
			if len(arg) == 0 {
				m.Echo("%v\n", msg.Meta["detail"])
				return
			}

			index := m.Confi("detail_index")
			if i, e := strconv.Atoi(arg[0]); e == nil {
				index, arg = i, arg[1:]
			}
			m.Echo("%s", msg.Detail(index, arg))

		}},
		"option": &Command{Name: "option [key [value...]]", Help: "查看或添加选项", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.message
			if len(arg) == 0 {
				keys := []string{}
				values := map[string][]string{}

				for msg = msg; msg != nil; msg = msg.message {
					for _, k := range msg.Meta["option"] {
						if _, ok := values[k]; ok {
							continue
						}
						keys = append(keys, k)
						values[k] = msg.Meta[k]
					}
				}

				sort.Strings(keys)
				for _, k := range keys {
					m.Echo("%s: %v\n", k, values[k])
				}
				return
			}

			if len(arg) > 1 {
				m.Echo("%s", msg.Option(arg[0], arg[1:]))
			} else {
				m.Echo("%s", msg.Option(arg[0]))
			}

		}},
		"result": &Command{Name: "result [value...]", Help: "查看或添加返回值", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.message
			if len(arg) == 0 {
				m.Echo("%v\n", msg.Meta["result"])
				return
			}

			index := m.Confi("result_index")
			if i, e := strconv.Atoi(arg[0]); e == nil {
				index, arg = i, arg[1:]
			}
			m.Echo("%s", msg.Result(index, arg))

		}},
		"append": &Command{Name: "append [key [value...]]", Help: "查看或添加附加值", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.message
			if len(arg) == 0 {
				keys := []string{}
				values := map[string][]string{}

				ms := []*Message{msg}
				for i := 0; i < len(ms); i++ {
					ms = append(ms, ms[i].messages...)
					for _, k := range ms[i].Meta["append"] {
						if _, ok := values[k]; ok {
							continue
						}

						keys = append(keys, k)
						values[k] = ms[i].Meta[k]
					}
				}

				sort.Strings(keys)
				for _, k := range keys {
					m.Echo("%s: %v\n", k, values[k])
				}
				return
			}

			switch arg[0] {
			case "ncol":
				if msg.Meta != nil && len(msg.Meta["append"]) > 0 {
					m.Echo("%d", len(msg.Meta["append"]))
				} else {
					m.Echo("0")
				}
			case "nrow":
				if msg.Meta != nil && len(msg.Meta["append"]) > 0 {
					m.Echo("%d", len(msg.Meta[msg.Meta["append"][0]]))
				} else {
					m.Echo("0")
				}
			}

			m.Echo("%s", msg.Append(arg[0], arg[1:]))

		}},
		"session": &Command{Name: "session [key [cmd...]]", Help: "查看或添加会话", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.message
			if len(arg) == 0 {
				keys := []string{}
				values := map[string]*Message{}

				for msg = msg; msg != nil; msg = msg.message {
					for k, v := range msg.Sessions {
						if _, ok := values[k]; ok {
							continue
						}
						keys = append(keys, k)
						values[k] = v
					}
				}
				sort.Strings(keys)
				for _, k := range keys {
					m.Echo("%s: %s\n", k, values[k].Format())

				}
				return
			}

			if len(arg) == 1 {
				for msg = msg; msg != nil; msg = msg.message {
					for k, v := range msg.Sessions {
						if k == arg[0] {
							m.Echo("%d", v.code)
							return
						}
					}
				}
				return
			}

			sub := msg
			root := m.Confx("search_root", arg, 3)
			switch m.Confx("search_method", arg, 2) {
			case "find":
				sub = msg.Find(arg[1], Right(root))
			case "search":
				sub = msg.Search(arg[1], Right(root))[0]
			default:
				sub = nil
			}
			if msg.Sessions == nil {
				msg.Sessions = map[string]*Message{}
			}
			if sub != nil {
				msg.Sessions[arg[0]] = sub
			}

		}},
		"callback": &Command{Name: "callback", Help: "查看消息", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.message
			if len(arg) == 0 {
				for msg := msg; msg != nil; msg = msg.message {
					m.Echo("%d: %p\n", msg.code, msg.callback)
				}
			}

		}},

		"context": &Command{
			Name: "context [[find [root|home]|search [root|home] [name|help] [magic|rand|first|last]] name] [list|info|cache|config|command|switch] [args]",
			Help: "查找并操作模块，\n查找起点root:根模块、back:父模块、home:本模块，\n查找方法find:路径匹配、search:模糊匹配，\n查找对象name:支持点分和正则，\n操作类型show:显示信息、switch:切换为当前、start:启动模块、spawn:分裂子模块，args:启动参数",
			Hand: func(m *Message, c *Context, key string, arg ...string) {
				action := m.Conf("search_action")
				if len(arg) == 0 {
					action = "list"
				}

				method := m.Conf("search_method")
				if len(arg) > 0 {
					switch arg[0] {
					case "find", "search":
						method, arg = arg[0], arg[1:]
					}
				}

				root := m.Confs("search_root")
				if len(arg) > 0 {
					switch arg[0] {
					case "root":
						root, arg = true, arg[1:]
					case "home":
						root, arg = false, arg[1:]
					}
				}

				ms := []*Message{}
				if len(arg) > 0 {
					switch method {
					case "find":
						if msg := m.Find(arg[0], root); msg != nil {
							ms, arg = append(ms, msg), arg[1:]
						}
					case "search":
						choice := m.Conf("search_choice")
						switch arg[0] {
						case "magic", "rand", "first", "last":
							choice, arg = arg[0], arg[1:]
						}

						if s := m.Search(arg[0], root); len(s) > 0 && s[0] != nil {
							switch choice {
							case "first":
								ms = append(ms, s[0])
							case "last":
								ms = append(ms, s[len(s)-1])
							case "rand":
								ms = append(ms, s[rand.Intn(len(s))])
							case "magic":
								ms = append(ms, s...)
							}
							arg = arg[1:]
						}
					}
				} else {
					ms = append(ms, m)
				}

				if len(arg) == 0 {
					arg = []string{action}
				}

				for _, msg := range ms {
					switch arg[0] {
					case "switch":
						m.target = msg.target
					case "list":
						which := ""
						if len(arg) > 1 {
							which = arg[1]
						}
						switch which {
						case "cache":
							keys := []string{}
							for k, _ := range msg.target.Caches {
								keys = append(keys, k)
							}
							sort.Strings(keys)
							for _, k := range keys {
								v := msg.target.Caches[k]
								m.Add("append", "key", k)
								m.Add("append", "name", v.Name)
								m.Add("append", "value", v.Value)
								m.Add("append", "help", v.Help)

							}
						case "config":
							keys := []string{}
							for k, _ := range msg.target.Configs {
								keys = append(keys, k)
							}
							sort.Strings(keys)
							for _, k := range keys {
								v := msg.target.Configs[k]
								m.Add("append", "key", k)
								m.Add("append", "name", v.Name)
								m.Add("append", "value", v.Value)
								m.Add("append", "help", v.Help)
							}
						case "command":
							keys := []string{}
							for k, _ := range msg.target.Commands {
								keys = append(keys, k)
							}
							sort.Strings(keys)
							for _, k := range keys {
								v := msg.target.Commands[k]
								m.Add("append", "key", k)
								m.Add("append", "name", v.Name)
								m.Add("append", "help", v.Help)
							}
						case "module":
							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":
							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(func(msg *Message, i int) bool {
								m.Add("append", "name", msg.target.Name)
								if msg.target.context != nil {
									m.Add("append", "context", msg.target.context.Name)
								} else {
									m.Add("append", "context", "")
								}
								if msg.target.message != nil {
									m.Add("append", "message", msg.target.message.code)
								} else {
									m.Add("append", "message", "")
								}

								m.Add("append", "status", msg.Cap("status"))
								m.Add("append", "stream", msg.Cap("stream"))
								m.Add("append", "help", msg.target.Help)
								return true
							})

							m.Table()
						}
					default:
						msg.Cmd(arg)
						m.Meta["result"] = append(m.Meta["result"], msg.Meta["result"]...)
						m.Copy(msg, "append")

					}
				}

			}},
		"server": &Command{
			Name: "server [spawn|begin|start|close][args]",
			Help: "查看、新建、初始化、启动、停止服务",
			Hand: func(m *Message, c *Context, key string, arg ...string) {
				switch len(arg) {
				case 0:
					m.Travel(func(m *Message, i int) bool {
						if m.Cap("status") == "start" {
							m.Echo("%s(%s): %s\n", m.Cap("module"), m.Cap("stream"), m.target.Help)
						}
						return true
					}, m.target.root)

				default:
					switch arg[0] {
					case "spawn":
						if len(arg) > 2 {
							msg := m.Spawn().Set("detail", arg[3:]...)
							msg.target.Spawn(msg, arg[1], arg[2])
							m.target = msg.target
						}
					case "begin":
						msg := m.Spawn().Set("detail", arg...)
						msg.target.Begin(msg)
					case "start":
						msg := m.Spawn().Set("detail", arg...)
						msg.target.Start(msg)
					case "close":
						msg := m.Spawn().Set("detail", arg...)
						m.target = msg.target.context
						msg.target.Close(msg)
					}
				}

			}},
		"command": &Command{
			Name: "command [all|add cmd arg...|list [begin [end]]|test [begin [end]]|delete cmd]",
			Help: []string{
				"查看或修改命令",
				"list_export filename",
			},
			Form: map[string]int{
				"list_name":   1,
				"list_help":   1,
				"list_cache":  2,
				"list_index":  1,
				"condition":   -1,
				"list_export": 1,
			},
			Hand: func(m *Message, c *Context, key string, arg ...string) {
				if len(arg) == 0 {
					keys := []string{}
					for k, _ := range m.target.Commands {
						keys = append(keys, k)
					}
					sort.Strings(keys)
					for _, k := range keys {
						m.Echo("%s: %s\n", k, m.target.Commands[k].Name)
					}
					return
				}
				switch arg[0] {
				case "all":
					keys := []string{}
					values := map[string]*Command{}
					for s := m.target; s != nil; s = s.context {
						for k, v := range s.Commands {
							if _, ok := values[k]; !ok {
								keys = append(keys, k)
								values[k] = v
							}
						}
					}
					sort.Strings(keys)
					for _, k := range keys {
						m.Echo("%s: %s\n", k, values[k].Name)
					}
					return
				case "add":
					if m.target.Caches == nil {
						m.target.Caches = map[string]*Cache{}
					}
					if _, ok := m.target.Caches["list_count"]; !ok {
						m.target.Caches["list_count"] = &Cache{Name: "list_count", Value: "0", Help: "list_count"}
						m.target.Caches["list_begin"] = &Cache{Name: "list_begin", Value: "0", Help: "list_begin"}
					}

					if m.target.Commands == nil {
						m.target.Commands = map[string]*Command{}
					}
					cache_name := ""
					cache_index := ""
					if m.Has("list_cache") {
						cache_name = m.Meta["list_cache"][0]
						cache_index = m.Meta["list_cache"][1]
						m.Cap(cache_name, cache_name, "", cache_index)
					}

					list_index := 0
					if m.Has("list_index") {
						if m.Option("list_index") == "_" {
							list_index = -1
						} else {
							list_index = m.Optioni("list_index")
						}
					}

					m.target.Commands[m.Cap("list_count")] = &Command{
						Name: strings.Join(arg[1:], " "),
						Help: m.Confx("list_help"),
						Hand: func(cmd *Message, c *Context, key string, args ...string) {
							li := list_index
							if li == -1 {
								if len(args) > 0 {
									if i, e := strconv.Atoi(args[0]); e == nil {
										li, args = i, args[1:]
									}
								}
							}
							list := []string{}
							j := 0
							for i := 1; i < len(arg); i++ {
								if arg[i] == "_" && cmd.Assert(j < len(args)) {
									list = append(list, args[j])
									j++
									continue
								}
								list = append(list, arg[i])
							}
							list = append(list, args[j:]...)

							msg := cmd.Spawn().Cmd(list)
							if len(msg.Meta["append"]) > 0 {
								for i, _ := range msg.Meta[msg.Meta["append"][0]] {
									cmd.Add("append", "index", i)
								}
							}
							if cache_name != "" && li > -1 {

								cmd.Echo(cmd.Cap(cache_name, fmt.Sprint(msg.Confv(cmd.Confx("body_response"), cache_index))))
							} else {
								cmd.Copy(msg, "result").Copy(msg, "append")
								if m.Has("list_export") {
									export := cmd.Spawn()
									export.Copy(cmd, "option").Copy(cmd, "append")
									export.Cmd("export", m.Option("list_export"))
								}
							}
						},
					}

					if m.Has("list_name") {
						m.target.Commands[m.Option("list_name")] = m.target.Commands[m.Cap("list_count")]
					}

					m.Capi("list_count", 1)
					return
				case "list":
					if m.Cap("list_begin") == "" {
						return
					}
					begin, end := m.Capi("list_begin"), m.Capi("list_count")
					if len(arg) > 1 {
						n, e := strconv.Atoi(arg[1])
						if e != nil {
							return
						}
						m.Assert(e)
						begin = n
					}
					if len(arg) > 2 {
						n, e := strconv.Atoi(arg[2])
						if e != nil {
							return
						}
						m.Assert(e)
						end = n
					}
					for i := begin; i < end; i++ {
						if c, ok := m.target.Commands[fmt.Sprintf("%d", i)]; ok {
							m.Echo("%d(%s): %s\n", i, c.Help, strings.Replace(c.Name, "\n", " ", -1))
						}
					}
					return
				case "test":
					begin, end := 0, m.Capi("list_count")
					if len(arg) > 1 {
						n, e := strconv.Atoi(arg[1])
						m.Assert(e)
						begin = n
					}
					if len(arg) > 2 {
						n, e := strconv.Atoi(arg[2])
						m.Assert(e)
						end = n
					}

					success, failure := 0, 0
					for i := begin; i < end; i++ {
						key := fmt.Sprintf("%d", i)
						if c, ok := m.target.Commands[key]; ok {
							msg := m.Spawn().Cmd(key)
							if m.Options("condition") {
								done := true
								condition := m.Meta["condition"]
								for j := 0; j < len(condition)-1; j += 2 {
									if !msg.Has(condition[j]) || msg.Append(condition[j]) != condition[j+1] {
										m.Color(31, "%s %s %s\n", key, " fail", c.Name)
										done = false
										failure++
									}
								}
								if done {

									m.Echo("%s %s %s\n", key, " done", c.Name)
									success++
								}
							} else {
								for _, v := range msg.Meta["result"] {
									m.Echo("%v", v)
								}
								m.Echo("\n")
								success++
							}
						}
					}
					m.Color(32, "success: %d, ", success)
					m.Color(31, "failure: %d, ", failure)
					m.Color(33, "total: %d", success+failure)
					return
				case "delete":
					if _, ok := m.target.Commands[arg[1]]; ok {
						delete(m.target.Commands, arg[1])
					}
				}

			}},
		"config": &Command{Name: "config [all] [export key..] [save|load file key...] [create map|list|string key name help] [delete key]",
			Help: "配置管理, export: 导出配置, save: 保存配置到文件, load: 从文件加载配置, create: 创建配置, delete: 删除配置",
			Hand: func(m *Message, c *Context, key string, arg ...string) {
				all := false
				if len(arg) > 0 && arg[0] == "all" {
					arg, all = arg[1:], true
				}

				action, which := "", "-1"
				have := map[string]bool{}
				if len(arg) > 0 {
					switch arg[0] {
					case "export":
						action, arg = arg[0], arg[1:]
						for _, v := range arg {
							have[v] = true
						}
					case "save", "load":
						action, which, arg = arg[0], arg[1], arg[2:]
						for _, v := range arg {
							have[v] = true
						}
					case "create", "delete":
						action, arg = arg[0], arg[1:]
					}
				}

				if len(arg) == 0 || action != "" {
					save := map[string]interface{}{}
					if action == "load" {
						f, e := os.Open(which)
						if e != nil {
							return
						}
						defer f.Close()

						de := json.NewDecoder(f)
						de.Decode(&save)
					}

					m.BackTrace(func(m *Message) bool {
						for k, v := range m.target.Configs {
							switch action {
							case "export", "save":
								if len(have) == 0 || have[k] {
									save[k] = v.Value
								}
							case "load":
								if x, ok := save[k]; ok && (len(have) == 0 || have[k]) {
									v.Value = x
								}
							case "create":
								m.Assert(k != arg[1], "%s exists", arg[1])
							case "delete":
								if k == arg[0] {
									delete(m.target.Configs, k)
								}
								fallthrough
							default:
								m.Add("append", "key", k)
								m.Add("append", "value", strings.Replace(strings.Replace(m.Conf(k), "\n", "\\n", -1), "\t", "\\t", -1))
								m.Add("append", "name", v.Name)
							}
						}
						switch action {
						case "create":
							var value interface{}
							switch arg[0] {
							case "map":
								value = map[string]interface{}{}
							case "list":
								value = []interface{}{}
							default:
								value = ""
							}
							m.target.Configs[arg[1]] = &Config{Name: arg[2], Value: value, Help: arg[3]}
						}
						return all
					})
					m.Sort("key", "str").Table()

					switch action {
					case "save":
						f, e := os.Create(which)
						m.Assert(e)
						defer f.Close()

						buf, e := json.MarshalIndent(save, "", "  ")
						m.Assert(e)
						f.Write(buf)
					case "export":
						buf, e := json.MarshalIndent(save, "", "  ")
						m.Assert(e)
						m.Echo("%s", string(buf))
					}
					return
				}

				var value interface{}
				if len(arg) > 2 {
					value = m.Confv(arg[0], arg[1], arg[2])
				} else if len(arg) > 1 {
					value = m.Confv(arg[0], arg[1])
				} else {
					value = m.Confv(arg[0])
				}

				switch val := value.(type) {
				case map[string]interface{}:
					for k, v := range val {
						m.Add("append", "key", k)
						m.Add("append", "value", v)
					}
					m.Sort("key", "str").Table()
				case map[string]string:
					for k, v := range val {
						m.Add("append", "key", k)
						m.Add("append", "value", v)
					}
					m.Sort("key", "str").Table()
				case []interface{}:
					for i, v := range val {
						m.Add("append", "index", i)
						m.Add("append", "value", v)
					}
					m.Table()
				case []string:
					for i, v := range val {
						m.Add("append", "index", i)
						m.Add("append", "value", v)
					}
					m.Table()
				default:
					m.Echo("%v", value)
				}
			}},
		"cache": &Command{Name: "cache [all] |key [value]|key = value|key name value help|delete key]", Help: "查看、读写、赋值、新建、删除缓存变量", Hand: func(m *Message, c *Context, key string, arg ...string) {
			all := false
			if len(arg) > 0 && arg[0] == "all" {
				arg, all = arg[1:], true
			}

			switch len(arg) {
			case 0:
				m.BackTrace(func(m *Message) bool {
					for k, v := range m.target.Caches {
						m.Add("append", "key", k)
						m.Add("append", "value", m.Cap(k))
						m.Add("append", "name", v.Name)
					}
					return all
				})
				m.Sort("key", "str").Table()
				return
			case 2:
				if arg[0] == "delete" {
					delete(m.target.Caches, arg[1])
					return
				}
				m.Cap(arg[0], arg[1])
			case 3:
				m.Cap(arg[0], arg[0], arg[2], arg[0])
			default:
				m.Echo(m.Cap(arg[0], arg[1:]...))
				return
			}
		}},

		"trans": &Command{Name: "trans key index", Help: "数据转换", Hand: func(m *Message, c *Context, key string, arg ...string) {
			value := m.Data[(arg[0])]
			if arg[1] != "" {
				v := Chain(m, value, arg[1])
				value = v
			}
			m.Log("fuck", "info %T", value)
			m.Log("fuck", "info %v", value)

			switch val := value.(type) {
			case map[string]interface{}:
				for k, v := range val {
					m.Log("fuck", "info %v %v", k, v)
					m.Add("append", "key", k)
					m.Add("append", "value", v)
				}
				m.Sort("key", "str").Table()
			case map[string]string:
				for k, v := range val {
					m.Add("append", "key", k)
					m.Add("append", "value", v)
				}
				m.Sort("key", "str").Table()
			case []interface{}:
				for i, v := range val {
					switch value := v.(type) {
					case map[string]interface{}:
						for k, v := range value {
							m.Add("append", k, v)
						}
					default:
						m.Add("append", "index", i)
						m.Add("append", "value", v)
					}
				}
				m.Table()
			case []string:
				for i, v := range val {
					m.Add("append", "index", i)
					m.Add("append", "value", v)
				}
				m.Table()
			case float64:
				m.Echo("%d", int(val))
			case nil:
				m.Echo("")
			default:
				m.Echo("%v", val)
			}
		}},
		"select": &Command{Name: "select key value", Form: map[string]int{"parse": 2, "order": 2, "limit": 1, "offset": 1, "vertical": 0}, Help: "选取数据", Hand: func(m *Message, c *Context, key string, arg ...string) {
			msg := m.Spawn()

			nrow := len(m.Meta[m.Meta["append"][0]])
			for i := 0; i < nrow; i++ {
				if len(arg) == 0 || strings.Contains(m.Meta[arg[0]][i], arg[1]) {
					for _, k := range m.Meta["append"] {
						if m.Has("parse") && m.Option("parse") == k {
							var value interface{}
							m.Assert(json.Unmarshal([]byte(m.Meta[k][i]), &value))
							if m.Meta["parse"][1] != "" {
								value = Chain(m, value, m.Meta["parse"][1])
							}

							switch val := value.(type) {
							case map[string]interface{}:
								for k, v := range val {
									msg.Add("append", k, v)
								}
							case []interface{}:
							default:
							}
						} else {
							msg.Add("append", k, m.Meta[k][i])
						}
					}
				}
			}

			if m.Set("append").Copy(msg, "append"); m.Has("order") {
				m.Sort(m.Option("order"), m.Meta["order"][1])
			}

			offset := 0
			limit := 10
			if m.Has("limit") {
				limit = m.Optioni("limit")
			}
			if m.Has("offset") {
				offset = m.Optioni("offset")
			}
			nrow = len(m.Meta[m.Meta["append"][0]])
			if offset > nrow {
				offset = nrow
			}
			if limit+offset > nrow {
				limit = nrow - offset
			}
			for _, k := range m.Meta["append"] {
				m.Meta[k] = m.Meta[k][offset : offset+limit]
			}

			if m.Has("vertical") {
				msg := m.Spawn()
				nrow := len(m.Meta[m.Meta["append"][0]])
				sort.Strings(m.Meta["append"])
				msg.Add("append", "field", "")
				msg.Add("append", "value", "")
				for i := 0; i < nrow; i++ {
					for _, k := range m.Meta["append"] {
						msg.Add("append", "field", k)
						msg.Add("append", "value", m.Meta[k][i])
					}
					msg.Add("append", "field", "")
					msg.Add("append", "value", "")
				}
				m.Set("append").Copy(msg, "append")
			}

			m.Table()
		}},
		"import": &Command{Name: "import filename", Help: "导入数据", Hand: func(m *Message, c *Context, key string, arg ...string) {
			f, e := os.Open(arg[0])
			m.Assert(e)
			defer f.Close()

			switch {
			case strings.HasSuffix(arg[0], ".json"):
				var data interface{}
				de := json.NewDecoder(f)
				de.Decode(&data)
				m.Optionv("data", data)

				switch d := data.(type) {
				case []interface{}:
					for _, value := range d {
						switch val := value.(type) {
						case map[string]interface{}:
							for k, v := range val {
								m.Add("append", k, v)
							}
						}
					}
				}
			case strings.HasSuffix(arg[0], ".csv"):
				r := csv.NewReader(f)
				l, e := r.Read()
				m.Assert(e)
				m.Meta["append"] = l

				for {
					l, e := r.Read()
					if e != nil {
						break
					}
					for i, v := range l {
						m.Add("append", m.Meta["append"][i], v)
					}
				}
			}
			m.Table()
		}},
		"export": &Command{Name: "export filename", Help: "导出数据", Hand: func(m *Message, c *Context, key string, arg ...string) {
			f, e := os.Create(arg[0])
			m.Assert(e)
			defer f.Close()

			switch {
			case strings.HasSuffix(arg[0], ".json"):
				data := []interface{}{}

				nrow := len(m.Meta[m.Meta["append"][0]])
				for i := 0; i < nrow; i++ {
					line := map[string]interface{}{}
					for _, k := range m.Meta["append"] {
						line[k] = m.Meta[k][i]
					}
					data = append(data, line)
				}
				en := json.NewEncoder(f)
				en.SetIndent("", "  ")
				en.Encode(data)

			case strings.HasSuffix(arg[0], ".csv"):
				w := csv.NewWriter(f)

				line := []string{}
				for _, v := range m.Meta["append"] {
					line = append(line, v)
				}
				w.Write(line)

				nrow := len(m.Meta[m.Meta["append"][0]])
				for i := 0; i < nrow; i++ {
					line := []string{}
					for _, k := range m.Meta["append"] {
						line = append(line, m.Meta[k][i])
					}
					w.Write(line)
				}
				w.Flush()
			default:
				for _, v := range m.Meta["result"] {
					f.WriteString(v)
				}
			}
		}},
	},
}
View Source 
var Pulse = &Message{code: 0, time: time.Now(), source: Index, target: Index, Meta: map[string][]string{}}

Functions

func Chain 

func Chain(m *Message, data interface{}, args ...interface{}) interface{}

func Elect 

func Elect(last interface{}, args ...interface{}) string
func Right(arg interface{}) bool

func Start 

func Start(args ...string)

func Trans 

func Trans(arg ...interface{}) []string

Types

type Cache 

type Cache struct {
	Name  string
	Value string
	Help  string
	Hand  func(m *Message, x *Cache, arg ...string) string
}

type Command 

type Command struct {
	Name string
	Help interface{}
	Form map[string]int
	Hand func(m *Message, c *Context, key string, arg ...string)

	Shares map[string][]string
}

type Config 

type Config struct {
	Name  string
	Value interface{}
	Help  string
	Hand  func(m *Message, x *Config, arg ...string) string
}

type Context 

type Context struct {
	Name string
	Help string

	Caches   map[string]*Cache
	Configs  map[string]*Config
	Commands map[string]*Command
	Index    map[string]*Context

	Server
	// contains filtered or unexported fields
}

func (*Context) Begin 

func (c *Context) Begin(m *Message, arg ...string) *Context

func (*Context) Close 

func (c *Context) Close(m *Message, arg ...string) bool

func (*Context) Context 

func (c *Context) Context() *Context

func (*Context) Has 

func (c *Context) Has(key ...string) bool

func (*Context) Message 

func (c *Context) Message() *Message

func (*Context) Register 

func (c *Context) Register(s *Context, x Server)

func (*Context) Spawn 

func (c *Context) Spawn(m *Message, name string, help string) *Context

func (*Context) Start 

func (c *Context) Start(m *Message, arg ...string) bool

type Message 

type Message struct {
	Hand bool
	Meta map[string][]string
	Data map[string]interface{}

	Sessions map[string]*Message

	Remote chan bool
	// contains filtered or unexported fields
}

func (*Message) Add 

func (m *Message) Add(meta string, key string, value ...interface{}) *Message

func (*Message) Append 

func (m *Message) Append(key string, arg ...interface{}) string

func (*Message) Appendi 

func (m *Message) Appendi(key string, arg ...interface{}) int

func (*Message) Appends 

func (m *Message) Appends(key string, arg ...interface{}) bool

func (*Message) Appendv 

func (m *Message) Appendv(key string, arg ...interface{}) interface{}

func (*Message) Assert 

func (m *Message) Assert(e interface{}, msg ...string) bool

func (*Message) Back 

func (m *Message) Back(msg *Message) *Message

func (*Message) BackTrace 

func (m *Message) BackTrace(hand func(m *Message) bool, c ...*Context) *Message

func (*Message) Call 

func (m *Message) Call(cb func(msg *Message) (sub *Message), arg ...interface{}) *Message

func (*Message) CallBack 

func (m *Message) CallBack(sync bool, cb func(msg *Message) (sub *Message), arg ...interface{}) *Message

func (*Message) Cap 

func (m *Message) Cap(key string, arg ...string) string

func (*Message) Capi 

func (m *Message) Capi(key string, arg ...int) int

func (*Message) Caps 

func (m *Message) Caps(key string, arg ...bool) bool

func (*Message) Cmd 

func (m *Message) Cmd(args ...interface{}) *Message

func (*Message) Code 

func (m *Message) Code() int

func (*Message) Color 

func (m *Message) Color(color int, str string, arg ...interface{}) *Message

func (*Message) Conf 

func (m *Message) Conf(key string, args ...interface{}) string

func (*Message) Confi 

func (m *Message) Confi(key string, arg ...interface{}) int

func (*Message) Confs 

func (m *Message) Confs(key string, arg ...interface{}) bool

func (*Message) Confv 

func (m *Message) Confv(key string, args ...interface{}) interface{}

func (*Message) Confx 

func (m *Message) Confx(key string, arg ...interface{}) string

func (*Message) Copy 

func (m *Message) Copy(msg *Message, meta string, arg ...string) *Message

func (*Message) Detail 

func (m *Message) Detail(arg ...interface{}) string

func (*Message) Detaili 

func (m *Message) Detaili(arg ...interface{}) int

func (*Message) Details 

func (m *Message) Details(arg ...interface{}) bool

func (*Message) Echo 

func (m *Message) Echo(str string, arg ...interface{}) *Message

func (*Message) Find 

func (m *Message) Find(name string, root ...bool) *Message

func (*Message) Format 

func (m *Message) Format() string

func (*Message) Get 

func (m *Message) Get(key string) string

func (*Message) Geti 

func (m *Message) Geti(key string) int

func (*Message) Gets 

func (m *Message) Gets(key string) bool

func (*Message) Has 

func (m *Message) Has(key ...string) bool

func (*Message) Insert 

func (m *Message) Insert(meta string, index int, arg ...interface{}) string

func (*Message) Instance 

func (m *Message) Instance(msg *Message, source ...bool) bool

func (*Message) Log 

func (m *Message) Log(action string, str string, arg ...interface{}) *Message

func (*Message) Matrix 

func (m *Message) Matrix(index int, arg ...interface{}) string

func (*Message) Message 

func (m *Message) Message() *Message

func (*Message) Option 

func (m *Message) Option(key string, arg ...interface{}) string

func (*Message) Optioni 

func (m *Message) Optioni(key string, arg ...interface{}) int

func (*Message) Options 

func (m *Message) Options(key string, arg ...interface{}) bool

func (*Message) Optionv 

func (m *Message) Optionv(key string, arg ...interface{}) interface{}

func (*Message) Optionx 

func (m *Message) Optionx(key string, format string) interface{}

func (*Message) Parse 

func (m *Message) Parse(arg interface{}) string

func (*Message) Put 

func (m *Message) Put(meta string, key string, value interface{}) *Message

func (*Message) Result 

func (m *Message) Result(arg ...interface{}) string

func (*Message) Resulti 

func (m *Message) Resulti(arg ...interface{}) int

func (*Message) Results 

func (m *Message) Results(arg ...interface{}) bool

func (*Message) Search 

func (m *Message) Search(key string, root ...bool) []*Message

func (*Message) Sess 

func (m *Message) Sess(key string, arg ...interface{}) *Message

func (*Message) Set 

func (m *Message) Set(meta string, arg ...string) *Message

func (*Message) Sort 

func (m *Message) Sort(key string, arg ...string) *Message

func (*Message) Source 

func (m *Message) Source() *Context

func (*Message) Spawn 

func (m *Message) Spawn(arg ...interface{}) *Message

func (*Message) Start 

func (m *Message) Start(name string, help string, arg ...string) bool

func (*Message) Table 

func (m *Message) Table(cbs ...func(maps map[string]string, list []string, line int) (goon bool)) *Message

func (*Message) Target 

func (m *Message) Target() *Context

func (*Message) Time 

func (m *Message) Time() string

func (*Message) Travel 

func (m *Message) Travel(hand func(m *Message, i int) bool, c ...*Context)

func (*Message) Tree 

func (m *Message) Tree(code int) *Message

func (*Message) TryCatch 

func (m *Message) TryCatch(msg *Message, safe bool, hand ...func(msg *Message)) *Message

func (*Message) Wait 

func (m *Message) Wait() bool

type Server 

type Server interface {
	Spawn(m *Message, c *Context, arg ...string) Server
	Begin(m *Message, arg ...string) Server
	Start(m *Message, arg ...string) bool
	Close(m *Message, arg ...string) bool
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.