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

opt cli&ctx

Browse Source
This commit is contained in:
harveyshao 2021-10-21 08:55:20 +08:00
parent a3b1a00378
commit 1d9d856bf8
55 changed files with 420 additions and 486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
base/cli/cli.go
View File

@ -1,104 +1,16 @@
package cli
import (
"os"
"os/user"
"path"
"runtime"
"strings"
ice "shylinux.com/x/icebergs"
kit "shylinux.com/x/toolkits"
)
func _cli_init(m *ice.Message) {
// 版本信息
kit.Fetch(kit.UnMarshal(kit.Format(ice.Info.Make)), func(key string, value interface{}) {
m.Conf(RUNTIME, kit.Keys(MAKE, strings.ToLower(key)), value)
})
// 环境变量
for _, k := range []string{CTX_SHY, CTX_DEV, CTX_OPS, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER} {
m.Conf(RUNTIME, kit.Keys(CONF, k), os.Getenv(k))
}
// 主机信息
m.Conf(RUNTIME, kit.Keys(HOST, "GOARCH"), runtime.GOARCH)
m.Conf(RUNTIME, kit.Keys(HOST, "GOOS"), runtime.GOOS)
m.Conf(RUNTIME, kit.Keys(HOST, "pid"), os.Getpid())
// 启动信息
if name, e := os.Hostname(); e == nil {
m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), kit.Select(name, os.Getenv("HOSTNAME")))
}
if name, e := os.Getwd(); e == nil {
name = path.Base(kit.Select(name, os.Getenv("PWD")))
ls := strings.Split(name, "/")
name = ls[len(ls)-1]
ls = strings.Split(name, "\\")
name = ls[len(ls)-1]
m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME), name)
}
if m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(os.Getenv(USER), os.Getenv(CTX_USER))) == "" {
if user, e := user.Current(); e == nil && user.Name != "" {
m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(user.Name, os.Getenv(CTX_USER)))
}
}
ice.Info.HostName = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME))
ice.Info.PathName = m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME))
ice.Info.UserName = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME))
// 启动次数
count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT))) + 1
m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT), count)
// 节点信息
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TIME), m.Time())
NodeInfo(m, "worker", m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME)))
runtime.GOMAXPROCS(kit.Int(kit.Select("1", m.Conf(RUNTIME, kit.Keys(HOST, "GOMAXPROCS")))))
}
func NodeInfo(m *ice.Message, kind, name string) {
name = strings.ReplaceAll(name, ".", "_")
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TYPE), kind)
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), name)
ice.Info.NodeName = name
ice.Info.NodeType = kind
}
const (
MAKE = "make"
TEST = "test"
CONF = "conf"
HOST = "host"
BOOT = "boot"
NODE = "node"
)
const (
HOSTNAME = "hostname"
PATHNAME = "pathname"
USERNAME = "username"
)
const (
CTX_SHY = "ctx_shy"
CTX_DEV = "ctx_dev"
CTX_OPS = "ctx_ops"
CTX_PID = "ctx_pid"
CTX_LOG = "ctx_log"
CTX_USER = "ctx_user"
CTX_SHARE = "ctx_share"
CTX_RIVER = "ctx_river"
USER = "USER"
HOME = "HOME"
PATH = "PATH"
)
const CLI = "cli"
var Index = &ice.Context{Name: CLI, Help: "命令模块", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Load()
_cli_init(m)
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Save()
}},
}}
var Index = &ice.Context{Name: CLI, Help: "命令模块"}
func init() { ice.Index.Register(Index, nil, RUNTIME, SYSTEM, DAEMON, QRCODE) }

6
base/cli/cli.shy
View File

@ -1,7 +1,7 @@
chapter "cli"
field "扫码" qrcode
field "守护" daemon
field "命令" system
field "环境" runtime
field "命令" system
field "守护" daemon
field "扫码" qrcode

103
base/cli/daemon.go
View File

@ -11,45 +11,34 @@ import (
kit "shylinux.com/x/toolkits"
)
func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
if w, ok := m.Optionv(CMD_OUTPUT).(io.Writer); ok {
func _daemon_exec(m *ice.Message, cmd *exec.Cmd) {
if w := _system_out(m, CMD_OUTPUT); w != nil {
cmd.Stdout = w
cmd.Stderr = w
} else if f, p, e := kit.Create(out); m.Assert(e) {
m.Log_EXPORT(kit.MDB_META, DAEMON, CMD_OUTPUT, p)
m.Optionv(CMD_OUTPUT, f)
cmd.Stdout = f
cmd.Stderr = f
}
if w, ok := m.Optionv(CMD_ERRPUT).(io.Writer); ok {
if w := _system_out(m, CMD_ERRPUT); w != nil {
cmd.Stderr = w
} else if f, p, e := kit.Create(err); m.Assert(e) {
m.Log_EXPORT(kit.MDB_META, DAEMON, CMD_ERRPUT, p)
m.Optionv(CMD_ERRPUT, f)
cmd.Stderr = f
}
// 启动进程
if e := cmd.Start(); m.Warn(e != nil, cmd.Args, " ", e) {
return
if e := cmd.Start(); m.Warn(e != nil, cmd.Args, ice.SP, e) {
return // 启动失败
}
m.Echo("%d", cmd.Process.Pid)
m.Go(func() {
h := m.Cmdx(mdb.INSERT, DAEMON, "", mdb.HASH,
kit.MDB_STATUS, START, PID, cmd.Process.Pid,
CMD, strings.Join(cmd.Args, " "),
DIR, cmd.Dir, ENV, kit.Select("", cmd.Env),
mdb.CACHE_CLEAR_ON_EXIT, m.Option(mdb.CACHE_CLEAR_ON_EXIT),
CMD_OUTPUT, out, CMD_ERRPUT, err,
kit.MDB_STATUS, START, ice.CMD, kit.Join(cmd.Args, ice.SP),
PID, cmd.Process.Pid, DIR, cmd.Dir, ENV, kit.Select("", cmd.Env),
m.OptionSimple(CMD_OUTPUT, CMD_ERRPUT, mdb.CACHE_CLEAR_ON_EXIT),
)
if e := cmd.Wait(); m.Warn(e != nil, cmd.Args, " ", e) {
if e := cmd.Wait(); m.Warn(e != nil, cmd.Args, ice.SP, e) {
if m.Conf(DAEMON, kit.Keys(kit.MDB_HASH, h, kit.Keym(kit.MDB_STATUS))) == START {
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, h, kit.MDB_STATUS, ERROR, ERROR, e)
}
} else {
m.Cost("args", cmd.Args, "code", cmd.ProcessState.ExitCode())
m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), kit.MDB_ARGS, cmd.Args)
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, h, kit.MDB_STATUS, STOP)
}
@ -62,6 +51,9 @@ func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
cb()
}
if w, ok := m.Optionv(CMD_INPUT).(io.Closer); ok {
w.Close()
}
if w, ok := m.Optionv(CMD_OUTPUT).(io.Closer); ok {
w.Close()
}
@ -73,13 +65,13 @@ func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
func Inputs(m *ice.Message, field string) bool {
switch strings.TrimPrefix(field, "extra.") {
case POD:
case ice.POD:
m.Cmdy("route")
case CTX:
case ice.CTX:
m.Cmdy(ctx.CONTEXT)
case CMD:
m.Cmdy(ctx.CONTEXT, kit.Select(m.Option(CTX), m.Option(kit.Keys("extra", CTX))), ctx.COMMAND)
case ARG:
case ice.CMD:
m.Cmdy(ctx.CONTEXT, kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(kit.MDB_EXTRA, ice.CTX))), ctx.COMMAND)
case ice.ARG:
default:
return false
@ -90,18 +82,9 @@ func Inputs(m *ice.Message, field string) bool {
const (
DIR = "dir"
ENV = "env"
API = "api"
PID = "pid"
PWD = "pwd"
POD = "pod"
CTX = "ctx"
CMD = "cmd"
ARG = "arg"
RUN = "run"
API = "api"
RES = "res"
ERR = "err"
)
const (
ERROR = "error"
@ -127,17 +110,19 @@ const DAEMON = "daemon"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
DAEMON: {Name: DAEMON, Help: "守护进程", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_DAEMON)},
DAEMON: {Name: DAEMON, Help: "守护进程", Value: kit.Data(
kit.MDB_PATH, ice.USR_LOCAL_DAEMON, kit.MDB_FIELD, "time,hash,status,pid,cmd,dir,env",
)},
}, Commands: map[string]*ice.Command{
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.PRUNES, DAEMON, "", mdb.HASH, mdb.CACHE_CLEAR_ON_EXIT, ice.TRUE)
}},
DAEMON: {Name: "daemon hash auto start prunes", Help: "守护进程", Action: map[string]*ice.Action{
DAEMON: {Name: "daemon hash auto start prunes", Help: "守护进程", Action: ice.MergeAction(map[string]*ice.Action{
START: {Name: "start cmd env dir", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Option(CMD_DIR, m.Option(DIR))
m.Option(CMD_ENV, kit.Split(m.Option(ENV), " ="))
m.Cmdy(DAEMON, kit.Split(m.Option(CMD)))
m.Cmdy(DAEMON, kit.Split(m.Option(ice.CMD)))
}},
RESTART: {Name: "restart", Help: "重启", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(DAEMON, STOP)
@ -145,46 +130,32 @@ func init() {
m.Cmdy(DAEMON, START)
}},
STOP: {Name: "stop", Help: "停止", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,hash,status,pid,cmd,dir,env")
m.Cmd(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH)).Table(func(index int, value map[string]string, head []string) {
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), kit.MDB_STATUS, STOP)
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmd(mdb.SELECT, DAEMON, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH)).Table(func(index int, value map[string]string, head []string) {
m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH), kit.MDB_STATUS, STOP)
m.Cmdy(SYSTEM, "kill", "-9", value[PID])
})
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,hash,status,pid,cmd,dir,env")
m.Cmdy(mdb.PRUNES, DAEMON, "", mdb.HASH, kit.MDB_STATUS, ERROR)
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(mdb.PRUNES, DAEMON, "", mdb.HASH, kit.MDB_STATUS, STOP)
m.Cmdy(mdb.PRUNES, DAEMON, "", mdb.HASH, kit.MDB_STATUS, ERROR)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { // 进程列表
m.Fields(len(arg), "time,hash,status,pid,cmd,dir,env")
m.Cmdy(mdb.SELECT, DAEMON, "", mdb.HASH).Table(func(index int, value map[string]string, head []string) {
switch value[kit.MDB_STATUS] {
case START:
m.PushButton(RESTART, STOP)
default:
m.PushButton(mdb.REMOVE)
}
})
} else if m.Richs(DAEMON, "", arg[0], nil) != nil { // 进程详情
m.Option(mdb.FIELDS, mdb.DETAIL)
m.Cmdy(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, arg)
switch m.Append(kit.MDB_STATUS) {
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), m.Config(kit.MDB_FIELD))
m.Cmdy(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, arg).Table(func(index int, value map[string]string, head []string) {
switch value[kit.MDB_STATUS] {
case START:
m.PushButton(RESTART, STOP)
default:
m.PushButton(mdb.REMOVE)
}
})
} else { // 启动进程
m.Option(CMD_TYPE, DAEMON)
m.Cmdy(SYSTEM, arg)
if len(arg) == 0 || len(m.Appendv(ice.MSG_APPEND)) > 0 {
return
}
_daemon_exec(m, _system_cmd(m, arg...))
}},
}})
}

44
base/cli/qrcode.go
View File

@ -61,7 +61,6 @@ func _trans_cli(str string) string {
}
return kit.Format(res)
}
func _qrcode_cli(m *ice.Message, text string) {
qr, _ := qrcode.New(text, qrcode.Medium)
fg := _trans_cli(m.Option(FG))
@ -79,7 +78,7 @@ func _qrcode_cli(m *ice.Message, text string) {
m.Echo("\033[4%sm \033[0m", kit.Select(bg, fg, col))
}
m.Echo("\n")
m.Echo(ice.NL)
}
m.Echo(text)
}
@ -126,27 +125,24 @@ const (
const QRCODE = "qrcode"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
QRCODE: {Name: QRCODE, Help: "二维码", Value: kit.Data()},
},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
ice.AddRender(ice.RENDER_QRCODE, func(m *ice.Message, cmd string, args ...interface{}) string {
return m.Cmd(QRCODE, kit.Simple(args...)).Result()
})
}},
QRCODE: {Name: "qrcode text fg bg size auto", Help: "二维码", Action: map[string]*ice.Action{}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(SIZE, kit.Select("240", arg, 3))
m.Option(BG, kit.Select(WHITE, arg, 2))
m.Option(FG, kit.Select(BLUE, arg, 1))
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
QRCODE: {Name: QRCODE, Help: "二维码", Value: kit.Data()},
}, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
ice.AddRender(ice.RENDER_QRCODE, func(m *ice.Message, cmd string, args ...interface{}) string {
return m.Cmd(QRCODE, kit.Simple(args...)).Result()
})
}},
QRCODE: {Name: "qrcode text fg bg size auto", Help: "二维码", Action: map[string]*ice.Action{}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(SIZE, kit.Select("240", arg, 3))
m.Option(BG, kit.Select(WHITE, arg, 2))
m.Option(FG, kit.Select(BLUE, arg, 1))
if m.IsCliUA() {
_qrcode_cli(m, kit.Select(m.Conf("web.share", kit.Keym(kit.MDB_DOMAIN)), arg, 0))
} else {
_qrcode_web(m, kit.Select(m.Option(ice.MSG_USERWEB), arg, 0))
}
}},
},
})
if m.IsCliUA() {
_qrcode_cli(m, kit.Select(m.Conf("web.share", kit.Keym(kit.MDB_DOMAIN)), arg, 0))
} else {
_qrcode_web(m, kit.Select(m.Option(ice.MSG_USERWEB), arg, 0))
}
}},
}})
}

192
base/cli/runtime.go
View File

@ -4,6 +4,9 @@ import (
"bytes"
"io/ioutil"
"os"
"os/user"
"path"
"runtime"
"strings"
ice "shylinux.com/x/icebergs"
@ -11,6 +14,53 @@ import (
kit "shylinux.com/x/toolkits"
)
func _runtime_init(m *ice.Message) {
// 版本信息
kit.Fetch(kit.UnMarshal(kit.Format(ice.Info.Make)), func(key string, value interface{}) {
m.Conf(RUNTIME, kit.Keys(MAKE, strings.ToLower(key)), value)
})
// 环境变量
for _, k := range []string{CTX_SHY, CTX_DEV, CTX_OPS, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER} {
m.Conf(RUNTIME, kit.Keys(CONF, k), os.Getenv(k))
}
// 主机信息
m.Conf(RUNTIME, kit.Keys(HOST, GOARCH), runtime.GOARCH)
m.Conf(RUNTIME, kit.Keys(HOST, GOOS), runtime.GOOS)
m.Conf(RUNTIME, kit.Keys(HOST, "pid"), os.Getpid())
// 启动信息
if name, e := os.Hostname(); e == nil {
m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), kit.Select(name, os.Getenv("HOSTNAME")))
}
if name, e := os.Getwd(); e == nil {
name = path.Base(kit.Select(name, os.Getenv("PWD")))
ls := strings.Split(name, "/")
name = ls[len(ls)-1]
ls = strings.Split(name, "\\")
name = ls[len(ls)-1]
m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME), name)
}
if m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(os.Getenv(USER), os.Getenv(CTX_USER))) == "" {
if user, e := user.Current(); e == nil && user.Name != "" {
m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(user.Name, os.Getenv(CTX_USER)))
}
}
ice.Info.HostName = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME))
ice.Info.PathName = m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME))
ice.Info.UserName = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME))
// 启动次数
count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT))) + 1
m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT), count)
// 节点信息
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TIME), m.Time())
NodeInfo(m, "worker", m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME)))
runtime.GOMAXPROCS(kit.Int(kit.Select("1", m.Conf(RUNTIME, kit.Keys(HOST, "GOMAXPROCS")))))
}
func _runtime_hostinfo(m *ice.Message) {
if f, e := os.Open("/proc/cpuinfo"); e == nil {
defer f.Close()
@ -21,7 +71,7 @@ func _runtime_hostinfo(m *ice.Message) {
if f, e := os.Open("/proc/meminfo"); e == nil {
defer f.Close()
if b, e := ioutil.ReadAll(f); e == nil {
for i, ls := range strings.Split(string(b), "\n") {
for i, ls := range strings.Split(string(b), ice.NL) {
vs := kit.Split(ls, ": ")
m.Push(strings.TrimSpace(vs[0]), kit.FmtSize(kit.Int64(strings.TrimSpace(vs[1]))*1024))
if i > 1 {
@ -33,62 +83,108 @@ func _runtime_hostinfo(m *ice.Message) {
m.Push("uptime", kit.Split(m.Cmdx(SYSTEM, "uptime"), ",")[0])
}
func NodeInfo(m *ice.Message, kind, name string) {
name = strings.ReplaceAll(name, ice.PT, "_")
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TYPE), kind)
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), name)
ice.Info.NodeName = name
ice.Info.NodeType = kind
}
const (
MAKE = "make"
TEST = "test"
CONF = "conf"
HOST = "host"
BOOT = "boot"
NODE = "node"
)
const (
SOURCE = "source"
TARGET = "target"
)
const (
GOARCH = "GOARCH"
GOOS = "GOOS"
LINUX = "linux"
DARWIN = "darwin"
WINDOWS = "windows"
AMD64 = "amd64"
I386 = "i386"
ARM = "arm"
)
const (
CTX_SHY = "ctx_shy"
CTX_DEV = "ctx_dev"
CTX_OPS = "ctx_ops"
CTX_PID = "ctx_pid"
CTX_LOG = "ctx_log"
CTX_USER = "ctx_user"
CTX_SHARE = "ctx_share"
CTX_RIVER = "ctx_river"
)
const (
HOSTNAME = "hostname"
PATHNAME = "pathname"
USERNAME = "username"
)
const (
DISKINFO = "diskinfo"
IFCONFIG = "ifconfig"
HOSTINFO = "hostinfo"
USERINFO = "userinfo"
PROCINFO = "procinfo"
BOOTINFO = "bootinfo"
DISKINFO = "diskinfo"
)
const RUNTIME = "runtime"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
RUNTIME: {Name: RUNTIME, Help: "运行环境", Value: kit.Dict()},
},
Commands: map[string]*ice.Command{
RUNTIME: {Name: "runtime info=diskinfo,ifconfig,hostname,hostinfo,userinfo,procinfo,bootinfo auto", Help: "运行环境", Action: map[string]*ice.Action{
DISKINFO: {Name: "diskinfo", Help: "磁盘信息", Hand: func(m *ice.Message, arg ...string) {
m.Spawn().Split(m.Cmdx(SYSTEM, "df", "-h"), "", " ", "\n").Table(func(index int, value map[string]string, head []string) {
if strings.HasPrefix(value["Filesystem"], "/dev") {
m.Push("", value, head)
}
})
}},
IFCONFIG: {Name: "ifconfig", Help: "网卡配置", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("tcp.host")
}},
HOSTNAME: {Name: "hostname", Help: "主机域名", Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 {
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), arg[0])
m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), arg[0])
ice.Info.HostName = arg[0]
}
m.Echo(ice.Info.HostName)
}},
HOSTINFO: {Name: "hostinfo", Help: "主机信息", Hand: func(m *ice.Message, arg ...string) {
_runtime_hostinfo(m)
}},
USERINFO: {Name: "userinfo", Help: "用户信息", Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(SYSTEM, "who"), "user term time", " ", "\n")
}},
PROCINFO: {Name: "procinfo", Help: "进程信息", Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(SYSTEM, "ps", "u"), "", " ", "\n")
m.PushAction("kill")
m.StatusTimeCount()
}},
"kill": {Name: "kill", Help: "结束进程", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(SYSTEM, "kill", m.Option("PID"))
m.ProcessRefresh("10ms")
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 0 && arg[0] == BOOTINFO {
arg = arg[1:]
}
m.Cmdy(ctx.CONFIG, RUNTIME, arg)
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
RUNTIME: {Name: RUNTIME, Help: "运行环境", Value: kit.Dict()},
}, Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
_runtime_init(m)
}},
RUNTIME: {Name: "runtime info=ifconfig,hostinfo,hostname,userinfo,procinfo,bootinfo,diskinfo auto", Help: "运行环境", Action: map[string]*ice.Action{
IFCONFIG: {Name: "ifconfig", Help: "网卡配置", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy("tcp.host")
}},
},
})
HOSTINFO: {Name: "hostinfo", Help: "主机信息", Hand: func(m *ice.Message, arg ...string) {
_runtime_hostinfo(m)
}},
HOSTNAME: {Name: "hostname", Help: "主机域名", Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 {
m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), arg[0])
m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), arg[0])
ice.Info.HostName = arg[0]
}
m.Echo(ice.Info.HostName)
}},
USERINFO: {Name: "userinfo", Help: "用户信息", Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(SYSTEM, "who"), "user term time", ice.SP, ice.NL)
}},
PROCINFO: {Name: "procinfo", Help: "进程信息", Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(SYSTEM, "ps", "u"), "", ice.SP, ice.NL)
m.PushAction("prockill")
m.StatusTimeCount()
}},
"prockill": {Name: "prockill", Help: "结束进程", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(SYSTEM, "prockill", m.Option("PID"))
m.ProcessRefresh30ms()
}},
DISKINFO: {Name: "diskinfo", Help: "磁盘信息", Hand: func(m *ice.Message, arg ...string) {
m.Spawn().Split(m.Cmdx(SYSTEM, "df", "-h"), "", ice.SP, ice.NL).Table(func(index int, value map[string]string, head []string) {
if strings.HasPrefix(value["Filesystem"], "/dev") {
m.Push("", value, head)
}
})
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) > 0 && arg[0] == BOOTINFO {
arg = arg[1:]
}
m.Cmdy(ctx.CONFIG, RUNTIME, arg)
}},
}})
}

116
base/cli/system.go
View File

@ -5,7 +5,6 @@ import (
"io"
"os"
"os/exec"
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/ctx"
@ -13,16 +12,49 @@ import (
kit "shylinux.com/x/toolkits"
)
func _system_show(m *ice.Message, cmd *exec.Cmd) {
func _system_cmd(m *ice.Message, arg ...string) *exec.Cmd {
cmd := exec.Command(arg[0], arg[1:]...)
// 运行目录
if cmd.Dir = m.Option(CMD_DIR); len(cmd.Dir) > 0 {
m.Log_EXPORT(CMD_DIR, cmd.Dir)
if _, e := os.Stat(cmd.Dir); e != nil && os.IsNotExist(e) {
os.MkdirAll(cmd.Dir, ice.MOD_DIR)
}
}
// 环境变量
env := kit.Simple(m.Optionv(CMD_ENV))
for i := 0; i < len(env)-1; i += 2 {
cmd.Env = append(cmd.Env, kit.Format("%s=%s", env[i], env[i+1]))
}
if len(cmd.Env) > 0 {
m.Log_EXPORT(CMD_ENV, cmd.Env)
}
return cmd
}
func _system_out(m *ice.Message, out string) io.Writer {
if w, ok := m.Optionv(out).(io.Writer); ok {
return w
} else if m.Option(out) == "" {
return nil
} else if f, p, e := kit.Create(m.Option(out)); m.Assert(e) {
m.Log_EXPORT(out, p)
m.Optionv(out, f)
return f
}
return nil
}
func _system_exec(m *ice.Message, cmd *exec.Cmd) {
// 输入流
if r, ok := m.Optionv(CMD_INPUT).(io.Reader); ok {
cmd.Stdin = r
}
// 输出流
if w, ok := m.Optionv(CMD_OUTPUT).(io.Writer); ok {
if w := _system_out(m, CMD_OUTPUT); w != nil {
cmd.Stdout, cmd.Stderr = w, w
if w, ok := m.Optionv(CMD_ERRPUT).(io.Writer); ok {
if w := _system_out(m, CMD_ERRPUT); w != nil {
cmd.Stderr = w
}
} else {
@ -33,107 +65,61 @@ func _system_show(m *ice.Message, cmd *exec.Cmd) {
m.Push(CMD_ERR, err.String())
m.Echo(kit.Select(out.String(), err.String()))
}()
cmd.Stdout, cmd.Stderr = out, err
}
// 执行命令
if e := cmd.Run(); e != nil {
m.Warn(e != nil, cmd.Args, " ", e.Error())
} else {
m.Cost("code", cmd.ProcessState.ExitCode(), "args", cmd.Args)
if e := cmd.Run(); !m.Warn(e != nil, cmd.Args, ice.SP, e) {
m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), kit.MDB_ARGS, cmd.Args)
}
m.Push(kit.MDB_TIME, m.Time())
m.Push(CMD_CODE, int(cmd.ProcessState.ExitCode()))
m.Push(kit.MDB_CODE, int(cmd.ProcessState.ExitCode()))
}
func SystemProcess(m *ice.Message, text string, arg ...string) {
if len(arg) > 0 && arg[0] == RUN {
if len(arg) > 0 && arg[0] == ice.RUN {
m.Cmdy(SYSTEM, arg[1:])
return
}
m.Cmdy(ctx.COMMAND, SYSTEM)
m.ProcessField(SYSTEM, RUN)
m.Push(ARG, kit.Split(text))
m.ProcessField(SYSTEM, ice.RUN)
m.Push(ice.ARG, kit.Split(text))
}
func IsSuccess(m *ice.Message) bool {
return m.Append(CMD_CODE) == "0"
return m.Append(kit.MDB_CODE) == "0"
}
const (
CMD_DIR = "cmd_dir"
CMD_ENV = "cmd_env"
CMD_TYPE = "cmd_type"
CMD_DIR = "cmd_dir"
CMD_ENV = "cmd_env"
CMD_INPUT = "cmd_input"
CMD_OUTPUT = "cmd_output"
CMD_ERRPUT = "cmd_errput"
CMD_CODE = "cmd_code"
CMD_ERR = "cmd_err"
CMD_OUT = "cmd_out"
CMD_OUT = "cmd_out"
CMD_ERR = "cmd_err"
)
const (
GOARCH = "goarch"
GOOS = "goos"
LINUX = "linux"
DARWIN = "darwin"
WINDOWS = "windows"
AMD64 = "amd64"
I386 = "386"
ARM = "arm"
SOURCE = "source"
TARGET = "target"
USER = "USER"
HOME = "HOME"
PATH = "PATH"
)
const SYSTEM = "system"
func init() {
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SYSTEM: {Name: SYSTEM, Help: "系统命令", Value: kit.Data()},
SYSTEM: {Name: SYSTEM, Help: "系统命令", Value: kit.Data(kit.MDB_FIELD, "time,id,cmd")},
}, Commands: map[string]*ice.Command{
SYSTEM: {Name: "system cmd run:button", Help: "系统命令", Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
if len(arg) == 0 {
m.Fields(len(arg), "time,id,cmd")
m.Fields(len(arg), m.Config(kit.MDB_FIELD))
m.Cmdy(mdb.SELECT, SYSTEM, "", mdb.LIST)
return
}
m.Grow(SYSTEM, "", kit.Dict(kit.MDB_TIME, m.Time(), CMD, strings.Join(arg, " ")))
m.Grow(SYSTEM, "", kit.Dict(kit.MDB_TIME, m.Time(), ice.CMD, kit.Join(arg, ice.SP)))
if len(arg) == 1 {
arg = kit.Split(arg[0])
}
cmd := exec.Command(arg[0], arg[1:]...)
// 运行目录
if cmd.Dir = m.Option(CMD_DIR); len(cmd.Dir) > 0 {
m.Log_EXPORT(kit.MDB_META, SYSTEM, CMD_DIR, cmd.Dir)
if _, e := os.Stat(cmd.Dir); e != nil && os.IsNotExist(e) {
os.MkdirAll(cmd.Dir, ice.MOD_DIR)
}
}
// 环境变量
env := kit.Simple(m.Optionv(CMD_ENV))
for i := 0; i < len(env)-1; i += 2 {
cmd.Env = append(cmd.Env, kit.Format("%s=%s", env[i], env[i+1]))
}
if len(cmd.Env) > 0 {
m.Log_EXPORT(kit.MDB_META, SYSTEM, CMD_ENV, cmd.Env)
}
switch m.Option(CMD_TYPE) {
case DAEMON:
_daemon_show(m, cmd, m.Option(CMD_OUTPUT), m.Option(CMD_ERRPUT))
default:
_system_show(m, cmd)
}
_system_exec(m, _system_cmd(m, arg...))
}},
}})
}

23
base/ctx/command.go
View File

@ -41,13 +41,25 @@ func _command_search(m *ice.Message, kind, name, text string) {
return
}
m.PushSearch("cmd", COMMAND,
kit.MDB_TYPE, kind, kit.MDB_NAME, key, kit.MDB_TEXT, s.Cap(ice.CTX_FOLLOW),
CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key,
)
m.PushSearch(kit.MDB_TYPE, COMMAND, kit.MDB_NAME, name, kit.MDB_TEXT, help, CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key)
})
}
func CmdAction(fields ...string) map[string]*ice.Action {
return ice.SelectAction(map[string]*ice.Action{
COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
if !m.PodCmd(COMMAND, arg) {
m.Cmdy(COMMAND, arg)
}
}},
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
if !m.PodCmd(arg) {
m.Cmdy(arg)
}
}},
}, fields...)
}
const (
ACTION = "action"
)
@ -55,6 +67,9 @@ const COMMAND = "command"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, COMMAND, m.Prefix(COMMAND))
}},
COMMAND: {Name: "command key auto", Help: "命令", Action: map[string]*ice.Action{
mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
if arg[0] == COMMAND || arg[1] != "" {

71
base/ctx/config.go
View File

@ -94,42 +94,39 @@ const (
const CONFIG = "config"
func init() {
Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
CONFIG: {Name: CONFIG, Help: "配置", Value: kit.Data(kit.MDB_PATH, ice.VAR_CONF)},
},
Commands: map[string]*ice.Command{
CONFIG: {Name: "config key auto", Help: "配置", Action: map[string]*ice.Action{
SAVE: {Name: "save", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
_config_save(m, arg[0], arg[1:]...)
}},
LOAD: {Name: "load", Help: "加载", Hand: func(m *ice.Message, arg ...string) {
_config_load(m, arg[0], arg[1:]...)
}},
RICH: {Name: "rich", Help: "富有", Hand: func(m *ice.Message, arg ...string) {
_config_rich(m, arg[0], arg[1], arg[2:]...)
}},
GROW: {Name: "grow", Help: "成长", Hand: func(m *ice.Message, arg ...string) {
_config_grow(m, arg[0], arg[1], arg[2:]...)
}},
"clear": {Name: "clear", Help: "清空", Hand: func(m *ice.Message, arg ...string) {
m.Conf(arg[0], "", "")
m.Cmd("exit", 1)
}},
"list": {Name: "list", Help: "列表", Hand: func(m *ice.Message, arg ...string) {
list := []interface{}{}
for _, v := range arg[2:] {
list = append(list, v)
}
m.Confv(arg[0], arg[1], kit.List(list...))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
_config_list(m)
return
}
_config_make(m, arg[0], arg[1:]...)
Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
CONFIG: {Name: CONFIG, Help: "配置", Value: kit.Data(kit.MDB_PATH, ice.VAR_CONF)},
}, Commands: map[string]*ice.Command{
CONFIG: {Name: "config key auto", Help: "配置", Action: map[string]*ice.Action{
SAVE: {Name: "save", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
_config_save(m, arg[0], arg[1:]...)
}},
},
})
LOAD: {Name: "load", Help: "加载", Hand: func(m *ice.Message, arg ...string) {
_config_load(m, arg[0], arg[1:]...)
}},
RICH: {Name: "rich", Help: "富有", Hand: func(m *ice.Message, arg ...string) {
_config_rich(m, arg[0], arg[1], arg[2:]...)
}},
GROW: {Name: "grow", Help: "成长", Hand: func(m *ice.Message, arg ...string) {
_config_grow(m, arg[0], arg[1], arg[2:]...)
}},
"list": {Name: "list", Help: "列表", Hand: func(m *ice.Message, arg ...string) {
list := []interface{}{}
for _, v := range arg[2:] {
list = append(list, v)
}
m.Confv(arg[0], arg[1], kit.List(list...))
}},
"clear": {Name: "clear", Help: "清空", Hand: func(m *ice.Message, arg ...string) {
m.Conf(arg[0], "", "")
m.Cmd(ice.EXIT, 1)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
_config_list(m)
return
}
_config_make(m, arg[0], arg[1:]...)
}},
}})
}

2
base/ctx/context.go
View File

@ -19,7 +19,7 @@ const CONTEXT = "context"
func init() {
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
CONTEXT: {Name: "context name=web.chat action=context,command,config key auto", Help: "模块", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Search(kit.Select("ice", arg, 0)+".", func(p *ice.Context, s *ice.Context, key string) {
m.Search(kit.Select(ice.ICE, arg, 0)+ice.PT, func(p *ice.Context, s *ice.Context, key string) {
msg := m.Spawn(s)
defer m.Copy(msg)

28
base/ctx/ctx.go
View File

@ -2,40 +2,12 @@ package ctx
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
)
func selectAction(list map[string]*ice.Action, fields ...string) map[string]*ice.Action {
if len(fields) == 0 {
return list
}
res := map[string]*ice.Action{}
for _, field := range fields {
res[field] = list[field]
}
return res
}
func CmdAction(fields ...string) map[string]*ice.Action {
return selectAction(map[string]*ice.Action{
"command": {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
if !m.PodCmd("command", arg) {
m.Cmdy("command", arg)
}
}},
"run": {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
if !m.PodCmd(arg) {
m.Cmdy(arg)
}
}},
}, fields...)
}
const CTX = "ctx"
var Index = &ice.Context{Name: CTX, Help: "标准模块", Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(mdb.SEARCH, mdb.CREATE, COMMAND, m.Prefix(COMMAND))
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}},

1
base/ctx/ctx.shy
View File

@ -3,4 +3,5 @@ chapter "ctx"
field "模块" context
field "命令" command
field "配置" config
field "消息" message

7
base/gdb/event.go
View File

@ -2,19 +2,18 @@ package gdb
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
func _event_listen(m *ice.Message, event string, cmd string) {
h := m.Cmdx(mdb.INSERT, EVENT, "", mdb.HASH, EVENT, event)
m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, cli.CMD, cmd)
m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, ice.CMD, cmd)
}
func _event_action(m *ice.Message, event string, arg ...string) {
m.Option(mdb.FIELDS, "time,id,cmd")
m.Cmd(mdb.SELECT, EVENT, kit.Keys(kit.MDB_HASH, kit.Hashs(event)), mdb.LIST).Table(func(index int, value map[string]string, head []string) {
m.Cmd(kit.Split(value[cli.CMD]), event, arg).Cost(EVENT, event, cli.ARG, arg)
m.Cmd(kit.Split(value[ice.CMD]), event, arg).Cost(EVENT, event, ice.ARG, arg)
})
}
@ -28,7 +27,7 @@ func init() {
Commands: map[string]*ice.Command{
EVENT: {Name: "event event id auto listen", Help: "事件流", Action: map[string]*ice.Action{
LISTEN: {Name: "listen event cmd", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
_event_listen(m, m.Option(EVENT), m.Option(cli.CMD))
_event_listen(m, m.Option(EVENT), m.Option(ice.CMD))
}},
ACTION: {Name: "action event arg", Help: "触发", Hand: func(m *ice.Message, arg ...string) {
_event_action(m, m.Option(EVENT), arg[2:]...)

4
base/gdb/gdb.go
View File

@ -52,8 +52,8 @@ var Index = &ice.Context{Name: GDB, Help: "事件模块",
m.Cmd(nfs.SAVE, kit.Select(m.Conf(SIGNAL, kit.META_PATH), m.Conf(cli.RUNTIME, kit.Keys(cli.CONF, cli.CTX_PID))),
m.Conf(cli.RUNTIME, kit.Keys(cli.HOST, cli.PID)))
m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", cli.CMD, "exit 0")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", cli.CMD, "exit 1")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", ice.CMD, "exit 0")
m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", ice.CMD, "exit 1")
m.Load()
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

6
base/gdb/routine.go
View File

@ -42,12 +42,12 @@ func init() {
INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
switch kit.Select("", arg, 0) {
case cli.RUN:
case ice.RUN:
m.Cmdy(INNER, arg[1:])
default:
ls := kit.Split(m.Option("fileline"), ":")
m.ProcessField(INNER, cli.RUN)
m.Option(cli.ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
m.ProcessField(INNER, ice.RUN)
m.Option(ice.ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
m.Cmdy(ctx.COMMAND, INNER)
}
}},

3
base/gdb/signal.go
View File

@ -7,7 +7,6 @@ import (
"syscall"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
@ -22,7 +21,7 @@ func _signal_action(m *ice.Message, s int) {
m.Option(mdb.FIELDS, "time,signal,name,cmd")
msg := m.Cmd(mdb.SELECT, SIGNAL, "", mdb.HASH, SIGNAL, s)
msg.Table(func(index int, value map[string]string, head []string) {
m.Cmdy(kit.Split(value[cli.CMD]))
m.Cmdy(kit.Split(value[ice.CMD]))
})
}

4
base/gdb/timer.go
View File

@ -25,8 +25,8 @@ func _timer_action(m *ice.Message, arg ...string) {
if n := kit.Time(kit.Format(value[NEXT])); now > n && order > 0 {
m.Logs(TIMER, kit.MDB_KEY, key, ORDER, order)
msg := m.Cmd(value[cli.CMD])
m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(cli.RES, msg.Result()))
msg := m.Cmd(value[ice.CMD])
m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(ice.RES, msg.Result()))
if value[ORDER] = kit.Format(order - 1); order > 1 {
value[NEXT] = msg.Time(value[INTERVAL])
}

3
base/nfs/dir.go
View File

@ -14,7 +14,6 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
@ -166,7 +165,7 @@ func _dir_search(m *ice.Message, kind, name string) {
value[kit.MDB_TYPE] = kit.Ext(value[kit.MDB_NAME])
}
m.PushSearch(cli.CMD, CAT, value)
m.PushSearch(ice.CMD, CAT, value)
})
}

4
base/web/dream.go
View File

@ -83,7 +83,7 @@ func _dream_show(m *ice.Message, name string) {
kit.Path(os.Args[0])
m.Optionv(cli.CMD_ERRPUT, path.Join(p, m.Conf(DREAM, kit.Keym(cli.ENV, "ctx_log"))))
m.Cmd(cli.DAEMON, m.Confv(DREAM, kit.Keym(cli.CMD)), ice.DEV, ice.DEV, kit.MDB_NAME, name, RIVER, m.Option(RIVER))
m.Cmd(cli.DAEMON, m.Confv(DREAM, kit.Keym(ice.CMD)), ice.DEV, ice.DEV, kit.MDB_NAME, name, RIVER, m.Option(RIVER))
m.Event(DREAM_CREATE, kit.MDB_TYPE, m.Option(kit.MDB_TYPE), kit.MDB_NAME, name)
m.Sleep(ice.MOD_TICK)
}
@ -139,7 +139,7 @@ func init() {
},
Configs: map[string]*ice.Config{
DREAM: {Name: DREAM, Help: "梦想家", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_WORK,
cli.CMD, []interface{}{"ice.bin", SPACE, tcp.DIAL},
ice.CMD, []interface{}{"ice.bin", SPACE, tcp.DIAL},
cli.ENV, kit.Dict(cli.CTX_LOG, ice.BIN_BOOT_LOG),
"miss", `#!/bin/bash
if [ "$ISH_CONF_PRE" = "" ]; then

7
base/web/route.go
View File

@ -3,7 +3,6 @@ package web
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
@ -116,7 +115,7 @@ func init() {
}},
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Debug(m.Option(ROUTE))
m.Cmdy(SPACE, m.Option(ROUTE), kit.Keys(m.Option(cli.CTX), m.Option(cli.CMD)), arg)
m.Cmdy(SPACE, m.Option(ROUTE), kit.Keys(m.Option(ice.CTX), m.Option(ice.CMD)), arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 || arg[0] == "" { // 路由列表
@ -129,13 +128,13 @@ func init() {
} else if len(arg) > 1 { // 命令列表
m.Cmd(SPACE, arg[0], ctx.CONTEXT, arg[1], ctx.COMMAND).Table(func(index int, value map[string]string, head []string) {
m.Push(cli.CMD, value[kit.MDB_KEY])
m.Push(ice.CMD, value[kit.MDB_KEY])
m.Push("", value, []string{kit.MDB_NAME, kit.MDB_HELP})
})
} else if len(arg) > 0 { // 模块列表
m.Cmd(SPACE, arg[0], ctx.CONTEXT).Table(func(index int, value map[string]string, head []string) {
m.Push(cli.CTX, kit.Keys(value["ups"], value[kit.MDB_NAME]))
m.Push(ice.CTX, kit.Keys(value["ups"], value[kit.MDB_NAME]))
m.Push("", value, []string{ice.CTX_STATUS, ice.CTX_STREAM, kit.MDB_HELP})
})
}

2
base/web/serve.go
View File

@ -165,7 +165,7 @@ func _serve_handle(key string, cmd *ice.Command, msg *ice.Message, w http.Respon
}
// 请求命令
if msg.Option(ice.MSG_USERPOD, msg.Option(cli.POD)); msg.Optionv(ice.MSG_CMDS) == nil {
if msg.Option(ice.MSG_USERPOD, msg.Option(ice.POD)); msg.Optionv(ice.MSG_CMDS) == nil {
if p := strings.TrimPrefix(r.URL.Path, key); p != "" {
msg.Optionv(ice.MSG_CMDS, strings.Split(p, "/"))
}

16
base/web/share.go
View File

@ -22,11 +22,11 @@ func _share_link(m *ice.Message, p string, arg ...interface{}) string {
return tcp.ReplaceLocalhost(m, kit.MergeURL2(kit.Select(m.Option(ice.MSG_USERWEB), m.Conf(SHARE, kit.Keym(kit.MDB_DOMAIN))), p, arg...))
}
func _share_cache(m *ice.Message, arg ...string) {
if pod := m.Option(cli.POD); m.PodCmd(CACHE, arg[0]) {
if pod := m.Option(ice.POD); m.PodCmd(CACHE, arg[0]) {
if m.Append(kit.MDB_FILE) == "" {
m.RenderResult(m.Append(kit.MDB_TEXT))
} else {
m.Option(cli.POD, pod)
m.Option(ice.POD, pod)
_share_local(m, m.Append(kit.MDB_FILE))
}
return
@ -49,16 +49,16 @@ func _share_local(m *ice.Message, arg ...string) {
}
}
if m.Option(cli.POD) != "" { // 远程文件
pp := path.Join(ice.VAR_PROXY, m.Option(cli.POD), p)
if m.Option(ice.POD) != "" { // 远程文件
pp := path.Join(ice.VAR_PROXY, m.Option(ice.POD), p)
cache := time.Now().Add(-time.Hour * 240000)
if s, e := os.Stat(pp); e == nil {
cache = s.ModTime()
}
// 上传文件
m.Cmdy(SPACE, m.Option(cli.POD), SPIDE, ice.DEV, SPIDE_RAW, kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/proxy/"),
SPIDE_PART, m.OptionSimple(cli.POD), kit.MDB_PATH, p, CACHE, cache.Format(ice.MOD_TIME), UPLOAD, "@"+p)
m.Cmdy(SPACE, m.Option(ice.POD), SPIDE, ice.DEV, SPIDE_RAW, kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/proxy/"),
SPIDE_PART, m.OptionSimple(ice.POD), kit.MDB_PATH, p, CACHE, cache.Format(ice.MOD_TIME), UPLOAD, "@"+p)
if s, e := os.Stat(pp); e == nil && !s.IsDir() {
p = pp
@ -73,7 +73,7 @@ func _share_local(m *ice.Message, arg ...string) {
m.RenderDownload(p)
}
func _share_proxy(m *ice.Message, arg ...string) {
switch p := path.Join(ice.VAR_PROXY, m.Option(cli.POD), m.Option(kit.MDB_PATH)); m.R.Method {
switch p := path.Join(ice.VAR_PROXY, m.Option(ice.POD), m.Option(kit.MDB_PATH)); m.R.Method {
case http.MethodGet: // 下发文件
m.RenderDownload(path.Join(p, m.Option(kit.MDB_NAME)))
@ -111,7 +111,7 @@ func init() {
ice.AddRender(ice.RENDER_DOWNLOAD, func(m *ice.Message, cmd string, args ...interface{}) string {
list := []string{}
if m.Option(ice.MSG_USERPOD) != "" {
list = append(list, cli.POD, m.Option(ice.MSG_USERPOD))
list = append(list, ice.POD, m.Option(ice.MSG_USERPOD))
}
arg := kit.Simple(args...)

6
base/web/space.go
View File

@ -205,11 +205,11 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
case CHROME:
case MASTER:
m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, m.Cmd(SPIDE, value[kit.MDB_NAME], ice.OptionFields("client.url")).Append("client.url"), value)
default:
m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, _space_link(m, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.MDB_NAME])), value)
}
})
@ -220,7 +220,7 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
return
}
m.Cmd(tcp.HOST).Table(func(index int, value map[string]string, head []string) {
m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
kit.MDB_TEXT, kit.Format("http://%s:%s", value[tcp.IP], port))
})
}

3
conf.go
View File

@ -25,7 +25,10 @@ const (
DEV = "dev"
OPS = "ops"
ICE = "ice"
RUN = "run"
RES = "res"
ERR = "err"
POD = "pod"
CTX = "ctx"

7
core/chat/action.go
View File

@ -6,7 +6,6 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/web"
@ -59,7 +58,7 @@ func _action_right(m *ice.Message, river string, storm string) (ok bool) {
func _action_list(m *ice.Message, river, storm string) {
m.Option(ice.MSG_RIVER, river)
m.Cmdy(TOOL, storm).Table(func(index int, value map[string]string, head []string) {
m.Cmdy(m.Space(kit.Select(m.Option(cli.POD), value[cli.POD])), ctx.COMMAND, kit.Keys(value[cli.CTX], value[cli.CMD]))
m.Cmdy(m.Space(kit.Select(m.Option(ice.POD), value[ice.POD])), ctx.COMMAND, kit.Keys(value[ice.CTX], value[ice.CMD]))
})
m.SortInt(kit.MDB_ID)
}
@ -70,8 +69,8 @@ func _action_show(m *ice.Message, river, storm, index string, arg ...string) {
cmds := []string{index}
prefix := kit.Keys(kit.MDB_HASH, river, TOOL, kit.MDB_HASH, storm)
if m.Grows(RIVER, prefix, kit.MDB_ID, index, func(index int, value map[string]interface{}) {
if cmds = kit.Simple(kit.Keys(value[cli.CTX], value[cli.CMD])); kit.Format(value[cli.POD]) != "" {
m.Option(cli.POD, value[cli.POD]) // 远程节点
if cmds = kit.Simple(kit.Keys(value[ice.CTX], value[ice.CMD])); kit.Format(value[ice.POD]) != "" {
m.Option(ice.POD, value[ice.POD]) // 远程节点
}
}) == nil && m.Warn(!m.Right(cmds), ice.ErrNotRight) {
return // 没有授权

5
core/chat/cmd.go
View File

@ -5,7 +5,6 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
@ -31,7 +30,7 @@ func init() {
}
m.Cmdy(ctx.COMMAND, arg[0])
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@ -52,7 +51,7 @@ func init() {
case "go", "mod", "sum":
_cmd_render(m, "web.code.inner", path.Dir(p)+"/", path.Base(p))
default:
if m.Option(cli.POD) != "" {
if m.Option(ice.POD) != "" {
if m.PodCmd(ctx.COMMAND, arg[0]); m.Append("meta") != "" {
_cmd_render(m, arg[0], arg[1:])
return // 远程命令

3
core/chat/files.go
View File

@ -2,7 +2,6 @@ package chat
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
@ -27,7 +26,7 @@ func init() {
m.Fields(len(arg), m.Conf(FILES, kit.META_FIELD))
m.Cmdy(mdb.SELECT, m.Prefix(FILES), "", mdb.HASH, kit.MDB_HASH, arg)
m.Table(func(index int, value map[string]string, head []string) {
link := kit.MergeURL("/share/cache/"+value[kit.MDB_DATA], cli.POD, m.Option(ice.MSG_USERPOD))
link := kit.MergeURL("/share/cache/"+value[kit.MDB_DATA], ice.POD, m.Option(ice.MSG_USERPOD))
if m.PushDownload(kit.MDB_LINK, value[kit.MDB_NAME], link); len(arg) > 0 && kit.ExtIsImage(value[kit.MDB_NAME]) {
m.PushImages(kit.MDB_IMAGE, link)
}

3
core/chat/footer.go
View File

@ -2,7 +2,6 @@ package chat
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
kit "shylinux.com/x/toolkits"
)
@ -24,7 +23,7 @@ func init() {
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(ctx.COMMAND, arg)
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

3
core/chat/node.go
View File

@ -3,7 +3,6 @@ package chat
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/code"
@ -53,7 +52,7 @@ func init() {
m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), NODE), mdb.HASH)
m.Table(func(index int, value map[string]string, head []string) {
m.PushAnchor(value[kit.MDB_NAME], kit.MergeURL2(m.Option(ice.MSG_USERWEB),
"/chat/pod/"+kit.Keys(m.Option(cli.POD), value[kit.MDB_NAME])))
"/chat/pod/"+kit.Keys(m.Option(ice.POD), value[kit.MDB_NAME])))
})
m.RenameAppend("name", "pod")
m.PushAction(mdb.REMOVE)

3
core/chat/pod.go
View File

@ -4,7 +4,6 @@ import (
"path"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/web"
kit "shylinux.com/x/toolkits"
@ -26,7 +25,7 @@ func init() {
m.Cmdy(ctx.COMMAND, arg[0])
}
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
if !m.PodCmd(arg) {
m.Cmdy(arg)
}

4
core/chat/river.go
View File

@ -148,7 +148,7 @@ func init() {
kit.Fetch(value, func(index int, value string) {
m.Search(value, func(p *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
m.Cmd(TOOL, mdb.INSERT, kit.MDB_HASH, h, cli.CTX, s.Cap(ice.CTX_FOLLOW), cli.CMD, key, kit.MDB_HELP, cmd.Help)
m.Cmd(TOOL, mdb.INSERT, kit.MDB_HASH, h, ice.CTX, s.Cap(ice.CTX_FOLLOW), ice.CMD, key, kit.MDB_HELP, cmd.Help)
})
})
})
@ -184,7 +184,7 @@ func init() {
m.Cmd(code.PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_BIN)
}},
cli.START: {Name: "start name=hi repos template", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(m.Space(m.Option(cli.POD)), web.DREAM, cli.START, arg)
m.Cmdy(m.Space(m.Option(ice.POD)), web.DREAM, cli.START, arg)
}},
SHARE: {Name: "share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {

7
core/chat/search.go
View File

@ -2,7 +2,6 @@ package chat
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
@ -20,17 +19,17 @@ func init() {
if value = kit.GetMeta(value); arg[1] != "" && !kit.Contains(value[kit.MDB_NAME], arg[1]) {
return
}
m.PushSearch(cli.CMD, P_SEARCH, value)
m.PushSearch(ice.CMD, P_SEARCH, value)
})
}},
mdb.RENDER: {Name: "render", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(m.Space(m.Option(cli.POD)), mdb.RENDER, arg[1:])
m.Cmdy(m.Space(m.Option(ice.POD)), mdb.RENDER, arg[1:])
}},
}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if kit.Contains(arg[1], ";") {
arg = kit.Split(arg[1], ";", ";", ";")
}
if m.Cmdy(m.Space(m.Option(cli.POD)), mdb.SEARCH, arg); arg[1] == "" {
if m.Cmdy(m.Space(m.Option(ice.POD)), mdb.SEARCH, arg); arg[1] == "" {
return
}
m.Cmd(mdb.INSERT, m.Prefix(P_SEARCH), "", mdb.HASH,

20
core/chat/tool.go
View File

@ -33,19 +33,19 @@ func init() {
mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) != "" {
msg := m.Cmd(TOOL, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
cmd := kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
m.Cmdy(m.Space(msg.Append(cli.POD)), cmd, mdb.EXPORT)
m.Cmdy(m.Space(msg.Append(ice.POD)), cmd, mdb.EXPORT)
}
}},
mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
if m.Option(kit.MDB_ID) != "" {
msg := m.Cmd(TOOL, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
cmd := kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD))
_action_domain(m, cmd, m.Option(kit.MDB_HASH))
m.Cmdy(m.Space(msg.Append(cli.POD)), cmd, mdb.IMPORT)
m.Cmdy(m.Space(msg.Append(ice.POD)), cmd, mdb.IMPORT)
}
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
@ -69,12 +69,12 @@ func init() {
m.OptionFields("time,id,pod,ctx,cmd,arg,display,style")
msg := m.Cmd(mdb.SELECT, RIVER, _river_key(m, TOOL, kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, kit.Select("", arg, 1))
if len(msg.Appendv(cli.CMD)) == 0 && len(arg) > 1 {
msg.Push(cli.CMD, arg[1])
if len(msg.Appendv(ice.CMD)) == 0 && len(arg) > 1 {
msg.Push(ice.CMD, arg[1])
}
if len(arg) > 2 && arg[2] == cli.RUN {
m.Cmdy(m.Space(msg.Append(cli.POD)), kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD)), arg[3:])
if len(arg) > 2 && arg[2] == ice.RUN {
m.Cmdy(m.Space(msg.Append(ice.POD)), kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD)), arg[3:])
return // 执行命令
}
@ -84,9 +84,9 @@ func init() {
}
// 命令插件
m.ProcessField(arg[0], arg[1], cli.RUN)
m.ProcessField(arg[0], arg[1], ice.RUN)
m.Table(func(index int, value map[string]string, head []string) {
m.Cmdy(m.Space(value[cli.POD]), ctx.CONTEXT, value[cli.CTX], ctx.COMMAND, value[cli.CMD])
m.Cmdy(m.Space(value[ice.POD]), ctx.CONTEXT, value[ice.CTX], ctx.COMMAND, value[ice.CMD])
})
}},
}})

4
core/code/bench.go
View File

@ -88,7 +88,7 @@ func init() {
m.Cmdy(mdb.DELETE, BENCH, "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
switch m.Option(kit.MDB_TYPE) {
case HTTP:
_bench_http(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
@ -99,7 +99,7 @@ func init() {
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count", "time,id,type,name,text,nconn,nreqs")
m.Cmdy(mdb.SELECT, BENCH, "", mdb.ZONE, arg)
m.PushAction(kit.Select(mdb.REMOVE, cli.RUN, len(arg) > 0))
m.PushAction(kit.Select(mdb.REMOVE, ice.RUN, len(arg) > 0))
}},
"test": {Name: "test path func auto run case", Help: "测试用例", Action: map[string]*ice.Action{

4
core/code/c.go
View File

@ -78,7 +78,7 @@ func init() {
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, arg[2])
name := strings.TrimSuffix(arg[1], path.Ext(arg[1])) + ".bin"
if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); msg.Append(cli.CMD_CODE) != "0" {
if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); !cli.IsSuccess(msg) {
m.Copy(msg)
return
}
@ -110,7 +110,7 @@ func init() {
}
for _, i := range []string{"1", "2", "3", "8"} {
if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
m.PushSearch(cli.CMD, "c", kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
m.PushSearch(ice.CMD, "c", kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
}
}
}},

22
core/code/case.go
View File

@ -22,11 +22,11 @@ func init() {
}},
mdb.INSERT: {Name: "insert zone name=hi cmd=POST,GET api arg:textarea res:textarea", Help: "添加"},
cli.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
m.Option(web.SPIDE_HEADER, web.ContentType, web.ContentJSON)
m.Echo(kit.Formats(kit.UnMarshal(m.Cmdx(web.SPIDE, m.Option(ice.DEV), web.SPIDE_RAW,
m.Option(cli.CMD), m.Option(cli.API), web.SPIDE_DATA, m.Option(cli.ARG)))))
m.Info(`curl "` + m.Option(cli.API) + `" -H "Content-Type: application/json"` + ` -d '` + m.Option(cli.ARG) + `'`)
m.Option(ice.CMD), m.Option(cli.API), web.SPIDE_DATA, m.Option(ice.ARG)))))
m.Info(`curl "` + m.Option(cli.API) + `" -H "Content-Type: application/json"` + ` -d '` + m.Option(ice.ARG) + `'`)
m.ProcessDisplay("/plugin/local/wiki/json.js")
}},
cli.CHECK: {Name: "check", Help: "检查", Hand: func(m *ice.Message, arg ...string) {
@ -36,22 +36,22 @@ func init() {
m.Push(kit.MDB_TIME, m.Time())
m.Push(kit.MDB_ID, value[kit.MDB_ID])
if err := m.Cmdx(m.PrefixKey(), cli.CHECK, value); err == ice.OK {
m.Push(cli.ERR, cli.Color(m, cli.GREEN, err))
m.Push(ice.ERR, cli.Color(m, cli.GREEN, err))
success++
} else {
m.Push(cli.ERR, cli.Color(m, cli.RED, err))
m.Push(ice.ERR, cli.Color(m, cli.RED, err))
}
m.Push(cli.API, value[cli.API])
m.Push(cli.ARG, value[cli.ARG])
m.Push(cli.RES, value[cli.RES])
m.Push(ice.ARG, value[ice.ARG])
m.Push(ice.RES, value[ice.RES])
})
m.StatusTimeCount(ice.SUCCESS, success)
return
}
res := kit.UnMarshal(m.Cmdx(m.PrefixKey(), cli.RUN))
if m.Option(cli.RES) != "" {
for k, v := range kit.KeyValue(nil, "", kit.UnMarshal(m.Option(cli.RES))) {
res := kit.UnMarshal(m.Cmdx(m.PrefixKey(), ice.RUN))
if m.Option(ice.RES) != "" {
for k, v := range kit.KeyValue(nil, "", kit.UnMarshal(m.Option(ice.RES))) {
if v != kit.Value(res, k) {
m.Echo(kit.Formats(res))
return
@ -75,7 +75,7 @@ func init() {
m.PushAction(mdb.INSERT, cli.CHECK, mdb.REMOVE)
} else {
m.Action(mdb.INSERT, cli.CHECK)
m.PushAction(cli.RUN, cli.CHECK)
m.PushAction(ice.RUN, cli.CHECK)
}
m.StatusTimeCount()
}},

2
core/code/compile.go
View File

@ -56,7 +56,7 @@ func init() {
// 执行编译
_autogen_version(m.Spawn())
m.Optionv(cli.CMD_ENV, kit.Simple(m.Confv(COMPILE, kit.Keym(cli.ENV)), "GOOS", goos, "GOARCH", arch))
m.Optionv(cli.CMD_ENV, kit.Simple(m.Confv(COMPILE, kit.Keym(cli.ENV)), cli.GOOS, goos, cli.GOARCH, arch))
if msg := m.Cmd(cli.SYSTEM, m.Confv(COMPILE, kit.Keym(GO)), "-o", file, main, ice.SRC_VERSION_GO, ice.SRC_BINPACK_GO); !cli.IsSuccess(msg) {
m.Copy(msg)
return

8
core/code/go.go
View File

@ -19,7 +19,7 @@ func _go_find(m *ice.Message, key string) {
if p == "" {
continue
}
m.PushSearch(cli.CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
m.PushSearch(ice.CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
}
}
func _go_tags(m *ice.Message, key string) {
@ -49,7 +49,7 @@ func _go_tags(m *ice.Message, key string) {
bio := bufio.NewScanner(f)
for i := 1; bio.Scan(); i++ {
if i == line || bio.Text() == text {
m.PushSearch(cli.CMD, "tags", kit.MDB_FILE, strings.TrimPrefix(file, "./"), kit.MDB_LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
m.PushSearch(ice.CMD, "tags", kit.MDB_FILE, strings.TrimPrefix(file, "./"), kit.MDB_LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
}
}
}
@ -57,14 +57,14 @@ func _go_tags(m *ice.Message, key string) {
func _go_grep(m *ice.Message, key string) {
msg := m.Spawn()
msg.Split(m.Cmd(cli.SYSTEM, "grep", "--exclude-dir=.git", "--exclude=.[a-z]*", "-rn", key, ".").Append(cli.CMD_OUT), "file:line:text", ":", "\n")
msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(cli.CMD, "grep", value) })
msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(ice.CMD, "grep", value) })
}
func _go_help(m *ice.Message, key string) {
p := m.Cmd(cli.SYSTEM, "go", "doc", key).Append(cli.CMD_OUT)
if p == "" {
return
}
m.PushSearch(cli.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
m.PushSearch(ice.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
}
const GO = "go"

8
core/code/install.go
View File

@ -65,20 +65,20 @@ func _install_build(m *ice.Message, arg ...string) {
case func(string):
cb(p)
default:
if msg := m.Cmd(cli.SYSTEM, "./configure", "--prefix="+pp, arg[1:]); msg.Append(cli.CMD_CODE) != "0" {
if msg := m.Cmd(cli.SYSTEM, "./configure", "--prefix="+pp, arg[1:]); !cli.IsSuccess(msg) {
m.Echo(msg.Append(cli.CMD_ERR))
return
}
}
// 编译
if msg := m.Cmd(cli.SYSTEM, "make", "-j8"); msg.Append(cli.CMD_CODE) != "0" {
if msg := m.Cmd(cli.SYSTEM, "make", "-j8"); !cli.IsSuccess(msg) {
m.Echo(msg.Append(cli.CMD_ERR))
return
}
// 安装
if msg := m.Cmd(cli.SYSTEM, "make", "PREFIX="+pp, "install"); msg.Append(cli.CMD_CODE) != "0" {
if msg := m.Cmd(cli.SYSTEM, "make", "PREFIX="+pp, "install"); !cli.IsSuccess(msg) {
m.Echo(msg.Append(cli.CMD_ERR))
return
}
@ -120,7 +120,7 @@ func _install_service(m *ice.Message, arg ...string) {
m.Fields(len(arg[1:]), "time,port,status,pid,cmd,dir")
m.Cmd(mdb.SELECT, cli.DAEMON, "", mdb.HASH).Table(func(index int, value map[string]string, head []string) {
if strings.Contains(value[cli.CMD], "bin/"+arg[0]) {
if strings.Contains(value[ice.CMD], "bin/"+arg[0]) {
m.Push("", value, kit.Split(m.Option(mdb.FIELDS)))
}
})

4
core/code/pprof.go
View File

@ -64,7 +64,7 @@ func init() {
}
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, m.Option(SERVICE), SECONDS, m.Option(SECONDS))
cmd := kit.Simple(m.Confv(PPROF, kit.Keym(PPROF)), "-text", m.Option(BINNARY), msg.Append(kit.MDB_FILE))
@ -89,7 +89,7 @@ func init() {
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,zone,count,binnary,service,seconds", "time,id,text,file")
if m.Cmdy(mdb.SELECT, PPROF, "", mdb.ZONE, arg); len(arg) == 0 {
m.PushAction(cli.RUN, mdb.REMOVE)
m.PushAction(ice.RUN, mdb.REMOVE)
return
}

2
core/code/publish.go
View File

@ -137,7 +137,7 @@ func init() {
web.DREAM: {Name: "dream name=hi repos", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(web.DREAM, tcp.START, arg)
m.Process(ice.PROCESS_OPEN, kit.MergeURL(m.Option(ice.MSG_USERWEB),
cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
ice.POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))

2
core/code/python.go
View File

@ -30,7 +30,7 @@ func init() {
cli.START: {Name: "start", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(INSTALL, cli.START, m.Conf(PYTHON, kit.Keym(cli.SOURCE)), "bin/python3")
}},
cli.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(cli.SYSTEM, m.Conf(PYTHON, kit.Keym(PYTHON)), arg)
}},
"pip": {Name: "pip", Help: "安装", Hand: func(m *ice.Message, arg ...string) {

3
core/code/upgrade.go
View File

@ -2,6 +2,7 @@ package code
import (
"os"
"runtime"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
@ -30,7 +31,7 @@ func init() {
UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
if value[kit.MDB_PATH] == ice.BIN_ICE_BIN { // 程序文件
value[kit.MDB_FILE] = kit.Keys("ice", m.Conf(cli.RUNTIME, "host.GOOS"), m.Conf(cli.RUNTIME, "host.GOARCH"))
value[kit.MDB_FILE] = kit.Keys("ice", runtime.GOOS, runtime.GOARCH)
m.Option("exit", ice.TRUE)
}

2
core/code/vimer.go
View File

@ -44,7 +44,7 @@ func init() {
)
_autogen_version(m)
if m.Cmdy(cli.SYSTEM, "go", "build", "-v", "-o", "bin/ice.bin", "src/main.go", "src/version.go"); m.Append(cli.CMD_CODE) == "0" {
if m.Cmdy(cli.SYSTEM, "go", "build", "-v", "-o", "bin/ice.bin", "src/main.go", "src/version.go"); cli.IsSuccess(m) {
m.Cmd("exit", "1")
}
m.ProcessInner()

2
core/mall/asset.go
View File

@ -134,7 +134,7 @@ func init() {
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(ctx.COMMAND, arg)
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

3
core/team/plan.go
View File

@ -4,7 +4,6 @@ import (
"time"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
@ -52,7 +51,7 @@ func init() {
m.ProcessRefresh30ms()
}},
ctx.COMMAND: {Name: "command", Help: "命令"},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},

4
core/team/task.go
View File

@ -90,11 +90,11 @@ func _task_search(m *ice.Message, kind, name, text string) {
return
}
if kind == TASK {
m.PushSearch(cli.CMD, TASK,
m.PushSearch(ice.CMD, TASK,
kit.MDB_ZONE, val[kit.MDB_ZONE], kit.MDB_ID, kit.Format(value[kit.MDB_ID]),
value)
} else {
m.PushSearch(cli.CMD, TASK,
m.PushSearch(ice.CMD, TASK,
kit.MDB_TYPE, val[kit.MDB_ZONE], kit.MDB_NAME, kit.Format(value[kit.MDB_ID]),
kit.MDB_TEXT, kit.Format("%v:%v", value[kit.MDB_NAME], value[kit.MDB_TEXT]),
value)

3
core/wiki/field.go
View File

@ -4,7 +4,6 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
kit "shylinux.com/x/toolkits"
)
@ -79,7 +78,7 @@ func init() {
Index.Merge(&ice.Context{
Commands: map[string]*ice.Command{
FIELD: {Name: "field [name] cmd", Help: "插件", Action: map[string]*ice.Action{
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

3
core/wiki/json.go
View File

@ -4,7 +4,6 @@ import (
"encoding/json"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
@ -62,7 +61,7 @@ func init() {
nfs.SAVE: {Name: "save path text", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
_wiki_save(m, JSON, arg[0], arg[1])
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
var data interface{}
json.Unmarshal([]byte(m.Cmdx(arg)), &data)
m.Option("type", "json")

3
core/wiki/table.go
View File

@ -4,7 +4,6 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
kit "shylinux.com/x/toolkits"
)
@ -64,7 +63,7 @@ func init() {
Index.Merge(&ice.Context{
Commands: map[string]*ice.Command{
TABLE: {Name: "table `[item item\n]...`", Help: "表格", Action: map[string]*ice.Action{
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
_table_run(m, arg...)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

5
core/wiki/word.go
View File

@ -5,7 +5,6 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/ssh"
@ -68,7 +67,7 @@ func init() {
), Action: ice.MergeAction(map[string]*ice.Action{
"play": {Name: "play", Help: "演示"},
web.STORY: {Name: "story", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg[0], ctx.ACTION, cli.RUN, arg[2:])
m.Cmdy(arg[0], ctx.ACTION, ice.RUN, arg[2:])
}},
}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option(nfs.DIR_REG, m.Conf(WORD, kit.Keym(kit.MDB_REGEXP)))
@ -80,7 +79,7 @@ func init() {
ice.Display("/plugin/local/wiki/word.js", WORD),
), Action: ice.MergeAction(map[string]*ice.Action{
web.STORY: {Name: "story", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg[0], ctx.ACTION, cli.RUN, arg[2:])
m.Cmdy(arg[0], ctx.ACTION, ice.RUN, arg[2:])
}},
ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(ctx.COMMAND, "web.wiki.word")

3
misc/chrome/page.go
View File

@ -2,7 +2,6 @@ package chrome
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
kit "shylinux.com/x/toolkits"
)
@ -25,7 +24,7 @@ func init() {
FIELD: {Name: "field", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(FIELD, arg)
}},
cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(arg)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

5
misc/git/status.go
View File

@ -21,7 +21,7 @@ func _status_each(m *ice.Message, title string, cmds ...string) {
m.Cmd(REPOS, ice.OptionFields("name,path")).Table(func(index int, value map[string]string, head []string) {
toast(value[kit.MDB_NAME], count, total)
if msg := m.Cmd(cmds, ice.Option{cli.CMD_DIR, value[kit.MDB_PATH]}); msg.Append(cli.CMD_CODE) != "0" {
if msg := m.Cmd(cmds, ice.Option{cli.CMD_DIR, value[kit.MDB_PATH]}); !cli.IsSuccess(msg) {
m.Toast(msg.Append(cli.CMD_ERR), "error: "+value[kit.MDB_NAME], "3s")
list = append(list, value[kit.MDB_NAME])
m.Sleep("3s")
@ -57,6 +57,9 @@ func _status_list(m *ice.Message) (files, adds, dels int, last time.Time) {
tags := m.Cmdx(cli.SYSTEM, GIT, "describe", "--tags")
for _, v := range strings.Split(strings.TrimSpace(diff), ice.NL) {
if v == "" {
continue
}
vs := strings.SplitN(strings.TrimSpace(v), ice.SP, 2)
switch kit.Ext(vs[1]) {
case "swp", "swo", "bin":

5
misc/lark/home.go
View File

@ -2,7 +2,6 @@ package lark
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/chat"
kit "shylinux.com/x/toolkits"
@ -24,7 +23,7 @@ func init() {
m.Cmd("web.chat./river").Table(func(index int, val map[string]string, head []string) {
m.Cmd("web.chat./river", val[kit.MDB_HASH], chat.TOOL).Table(func(index int, value map[string]string, head []string) {
list = append(list, kit.Keys(val[kit.MDB_NAME], value[kit.MDB_NAME]),
cli.CMD, kit.Format([]string{HOME, val[kit.MDB_HASH], value[kit.MDB_HASH], val[kit.MDB_NAME] + "." + value[kit.MDB_NAME]}))
ice.CMD, kit.Format([]string{HOME, val[kit.MDB_HASH], value[kit.MDB_HASH], val[kit.MDB_NAME] + "." + value[kit.MDB_NAME]}))
})
})
} else {
@ -32,7 +31,7 @@ func init() {
m.Option(ice.MSG_STORM, arg[1])
link = kit.MergeURL(link, chat.RIVER, arg[0], chat.STORM, arg[1])
m.Cmd("web.chat./river", arg[0], chat.TOOL, arg[1]).Table(func(index int, value map[string]string, head []string) {
list = append(list, value[cli.CMD], cli.CMD, kit.Keys(value[cli.CTX], value[cli.CMD]))
list = append(list, value[ice.CMD], ice.CMD, kit.Keys(value[ice.CTX], value[ice.CMD]))
})
}
m.Cmd(FORM, CHAT_ID, m.Option(OPEN_CHAT_ID), name, text, "打开网页", "url", link, list)

5
misc/lark/msg.go
View File

@ -6,7 +6,6 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/wiki"
kit "shylinux.com/x/toolkits"
@ -89,9 +88,9 @@ func init() {
"card": {Name: "", Help: "", Hand: func(m *ice.Message, arg ...string) {
data := m.Optionv(ice.MSG_USERDATA)
kit.Fetch(kit.Value(data, "action.value"), func(key string, value string) { m.Option(key, value) })
m.Cmdy(TALK, kit.Parse(nil, "", kit.Split(m.Option(cli.CMD))...))
m.Cmdy(TALK, kit.Parse(nil, "", kit.Split(m.Option(ice.CMD))...))
m.Cmd(SEND, m.Option(APP_ID), CHAT_ID, m.Option(OPEN_CHAT_ID),
m.Option(wiki.TITLE)+" "+m.Option(cli.CMD), m.Result())
m.Option(wiki.TITLE)+" "+m.Option(ice.CMD), m.Result())
}},
}, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
if m.Options(OPEN_CHAT_ID) {

2
misc/trash/docker/docker.go
View File

@ -175,7 +175,7 @@ var Index = &ice.Context{Name: DOCKER, Help: "虚拟机",
}},
gdb.AUTO: {Name: "auto", Help: "自动化", Action: map[string]*ice.Action{
web.DREAM_START: {Hand: func(m *ice.Message, arg ...string) {
if m.Cmd(_container, "start", arg[0]).Append(cli.CMD_CODE) == "0" {
if cli.IsSuccess(m.Cmd(_container, "start", arg[0])) {
// 重启容器
return
}