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

opt gdb

Browse Source
This commit is contained in:
IT 老营长 @云轩领航-创始人 2024-02-06 23:25:14 +08:00
parent a2a14be186
commit 96671f03c8
27 changed files with 129 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
base/cli/color.go
View File

@ -29,8 +29,8 @@ var _color_map = map[string]color.Color{
} }
var _color_list = map[string]string{ var _color_list = map[string]string{
"aliceblue": "#f0f8ff",
"navy": "#000080", "navy": "#000080",
"aliceblue": "#f0f8ff",
"firebrick": "#b22222", "firebrick": "#b22222",
} }

9
base/cli/daemon.go
View File

@ -30,7 +30,7 @@ func _daemon_exec(m *ice.Message, cmd *exec.Cmd) {
cmd.Stderr = w cmd.Stderr = w
} }
h := mdb.HashCreate(m.Spawn(), STATUS, START, h := mdb.HashCreate(m.Spawn(), STATUS, START,
ice.CMD, kit.Join(cmd.Args, lex.SP), DIR, cmd.Dir, ENV, kit.Select("", cmd.Env), ice.CMD, kit.JoinWord(cmd.Args...), DIR, cmd.Dir, ENV, kit.Select("", cmd.Env),
m.OptionSimple(CMD_INPUT, CMD_OUTPUT, CMD_ERRPUT, mdb.CACHE_CLEAR_ONEXIT), m.OptionSimple(CMD_INPUT, CMD_OUTPUT, CMD_ERRPUT, mdb.CACHE_CLEAR_ONEXIT),
) )
if e := cmd.Start(); m.Warn(e, ice.ErrNotStart, cmd.Args, err.String()) { if e := cmd.Start(); m.Warn(e, ice.ErrNotStart, cmd.Args, err.String()) {
@ -38,8 +38,7 @@ func _daemon_exec(m *ice.Message, cmd *exec.Cmd) {
return return
} }
mdb.HashSelectUpdate(m, h, func(value ice.Map) { value[PID] = cmd.Process.Pid }) mdb.HashSelectUpdate(m, h, func(value ice.Map) { value[PID] = cmd.Process.Pid })
m.Echo("%d", cmd.Process.Pid) m.Echo("%d", cmd.Process.Pid).Go(func() {
m.Go(func() {
if e := cmd.Wait(); !m.Warn(e, ice.ErrNotStart, cmd.Args, err.String()) && cmd.ProcessState != nil && cmd.ProcessState.Success() { if e := cmd.Wait(); !m.Warn(e, ice.ErrNotStart, cmd.Args, err.String()) && cmd.ProcessState != nil && cmd.ProcessState.Success() {
mdb.HashModify(m, mdb.HASH, h, STATUS, STOP) mdb.HashModify(m, mdb.HASH, h, STATUS, STOP)
m.Cost(CODE, "0", ctx.ARGS, cmd.Args) m.Cost(CODE, "0", ctx.ARGS, cmd.Args)
@ -187,6 +186,4 @@ tell application "%s"
end tell end tell
`, app, strings.Join(arg, lex.NL))) `, app, strings.Join(arg, lex.NL)))
} }
func OSAScript(m *ice.Message, arg ...string) { func OSAScript(m *ice.Message, arg ...string) { m.Cmd(SYSTEM, "osascript", "-e", arg) }
m.Cmd(SYSTEM, "osascript", "-e", arg)
}

18
base/cli/mirrors.go
View File

@ -35,26 +35,26 @@ func init() {
CMD: {Name: "cmd cli osid", Hand: func(m *ice.Message, arg ...string) { CMD: {Name: "cmd cli osid", Hand: func(m *ice.Message, arg ...string) {
osid := kit.Select(mdb.Conf(m, RUNTIME, kit.Keys(HOST, OSID)), m.Option(OSID)) osid := kit.Select(mdb.Conf(m, RUNTIME, kit.Keys(HOST, OSID)), m.Option(OSID))
mdb.ZoneSelectCB(m, m.Option(CLI), func(value ice.Map) { mdb.ZoneSelectCB(m, m.Option(CLI), func(value ice.Map) {
kit.If(strings.Contains(osid, kit.Format(value[OSID])), func() { m.Cmdy(kit.Split(kit.Format(value[CMD]))) }) kit.If(strings.Contains(osid, kit.Format(value[OSID])), func() {
m.Cmdy(kit.Split(kit.Format(value[CMD])))
})
}) })
}}, }},
ADD: {Help: "安装", Hand: func(m *ice.Message, arg ...string) { ADD: {Help: "安装", Hand: func(m *ice.Message, arg ...string) {
ice.Info.PushStream(m)
mdb.ZoneSelect(m, m.Option(CLI)).Table(func(value ice.Maps) { mdb.ZoneSelect(m, m.Option(CLI)).Table(func(value ice.Maps) {
ice.Info.PushStream(m) m.ToastProcess()
m.Toast(ice.PROCESS, "", "-1")
if msg := m.Cmd(kit.Split(value[CMD])); IsSuccess(msg) { if msg := m.Cmd(kit.Split(value[CMD])); IsSuccess(msg) {
m.Toast(ice.SUCCESS) m.ToastSuccess()
} else { } else {
m.Toast(ice.FAILURE) m.ToastFailure()
} }
}) })
}}, }},
REPOS: {Name: "repos proxy=mirrors.tencent.com", Help: "镜像", Hand: func(m *ice.Message, arg ...string) { REPOS: {Name: "repos proxy=mirrors.tencent.com", Help: "镜像", Hand: func(m *ice.Message, arg ...string) {
switch { switch {
case strings.Contains(_release, ALPINE): case strings.Contains(_release, ALPINE):
m.Toast(ice.PROCESS, "", "-1") defer m.PushStream().ToastProcess()()
defer m.Toast(ice.SUCCESS)
ice.Info.PushStream(m)
kit.If(m.Option("proxy"), func(p string) { kit.If(m.Option("proxy"), func(p string) {
m.Cmd(nfs.SAVE, ETC_APK_REPOS, strings.ReplaceAll(m.Cmdx(nfs.CAT, ETC_APK_REPOS), "dl-cdn.alpinelinux.org", p)) m.Cmd(nfs.SAVE, ETC_APK_REPOS, strings.ReplaceAll(m.Cmdx(nfs.CAT, ETC_APK_REPOS), "dl-cdn.alpinelinux.org", p))
}) })
@ -95,7 +95,7 @@ func release(m *ice.Message) string {
} }
return text return text
}) })
_release = strings.Join(list, lex.SP) _release = kit.JoinWord(list...)
return _release return _release
} }
func insert(m *ice.Message, sys, cmd string, arg ...string) bool { func insert(m *ice.Message, sys, cmd string, arg ...string) bool {

32
base/cli/procinfo.go
View File

@ -1,32 +0,0 @@
package cli
import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/gdb"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
func init() {
Index.MergeCommands(ice.Commands{
PROCINFO: {Name: "procinfo PID auto filter:text terminal monitor docker", Help: "进程列表", Actions: ice.MergeActions(ice.Actions{
PROCKILL: {Help: "结束进程", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(gdb.SIGNAL, gdb.STOP, m.Option("PID")).ProcessRefresh() }},
"terminal": {Help: "终端", Hand: func(m *ice.Message, arg ...string) { Opens(m, "Terminal.app") }},
"monitor": {Help: "监控", Hand: func(m *ice.Message, arg ...string) { Opens(m, "Activity Monitor.app") }},
"docker": {Help: "容器", Hand: func(m *ice.Message, arg ...string) { Opens(m, "Docker Desktop.app") }},
}), Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 || arg[0] == "" {
m.Split(m.Cmdx(SYSTEM, "ps", "u")).Sort("COMMAND").PushAction(PROCKILL).StatusTimeCount(m.Cmd(RUNTIME, HOSTINFO).AppendSimple("nCPU,MemTotal,MemFree"))
return
}
m.OptionFields(mdb.DETAIL)
for _, line := range kit.SplitLine(m.Cmdx(nfs.CAT, kit.Format("/proc/%s/status", arg[0]))) {
ls := strings.SplitN(line, nfs.DF, 2)
m.Push(ls[0], ls[1])
}
}},
})
}

97
base/cli/procstat.go
View File

@ -1,97 +0,0 @@
package cli
import (
"runtime"
"strings"
"time"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/gdb"
"shylinux.com/x/icebergs/base/lex"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
type procstat struct {
utime int64
stime int64
vmsize int64
vmrss int64
user int64
sys int64
idle int64
total int64
free int64
rx int64
tx int64
established int64
time_wait int64
}
func newprocstat(m *ice.Message) (stat procstat) {
if runtime.GOOS != LINUX {
return
}
m.Option(ice.MSG_USERROLE, aaa.ROOT)
if ls := kit.Split(m.Cmdx(nfs.CAT, "/proc/self/stat"), " ()"); len(ls) > 0 {
stat = procstat{utime: kit.Int64(ls[13]), stime: kit.Int64(ls[14]), vmsize: kit.Int64(ls[22]), vmrss: kit.Int64(ls[23]) * 4096}
}
if ls := kit.Split(kit.Select("", strings.Split(m.Cmdx(nfs.CAT, "/proc/stat"), lex.NL), 1)); len(ls) > 0 {
stat.user, stat.sys, stat.idle = kit.Int64(ls[1]), kit.Int64(ls[3]), kit.Int64(ls[4])
}
for _, line := range strings.Split(strings.TrimSpace(m.Cmdx(nfs.CAT, "/proc/meminfo")), lex.NL) {
switch ls := kit.Split(line, ": "); ls[0] {
case "MemTotal":
stat.total = kit.Int64(ls[1]) * 1024
case "MemFree":
stat.free = kit.Int64(ls[1]) * 1024
}
}
for _, line := range strings.Split(strings.TrimSpace(m.Cmdx(nfs.CAT, "/proc/net/dev")), lex.NL)[2:] {
if ls := kit.Split(line, ": "); ls[0] != "lo" {
stat.rx += kit.Int64(ls[1])
stat.tx += kit.Int64(ls[9])
}
}
for _, line := range strings.Split(strings.TrimSpace(m.Cmdx(nfs.CAT, "/proc/net/tcp")), lex.NL)[1:] {
switch ls := kit.Split(line, ": "); ls[5] {
case "01":
stat.established++
case "06":
stat.time_wait++
}
}
return
}
func init() {
var last procstat
Index.MergeCommands(ice.Commands{
PROCSTAT: {Name: "procstat id list page start", Help: "进程统计", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { last = newprocstat(m) }},
START: {Name: "start interval*=10s least*=360 limit*=720", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(gdb.TIMER, mdb.CREATE, mdb.NAME, m.CommandKey(), gdb.DELAY, "1s", m.OptionSimple(gdb.INTERVAL), mdb.COUNT, "-1", ice.CMD, "cli.procstat insert")
mdb.Config(m, mdb.LEAST, m.Option(mdb.LEAST))
mdb.Config(m, mdb.LIMIT, m.Option(mdb.LIMIT))
}},
mdb.INSERT: {Hand: func(m *ice.Message, arg ...string) {
stat := newprocstat(m)
total := stat.user - last.user + stat.sys - last.sys + stat.idle - last.idle
m.Cmd(mdb.INSERT, m.PrefixKey(), "", mdb.LIST,
"utime", (stat.utime-last.utime+stat.stime-last.stime)*1000/total, "vmrss", stat.vmrss*1000/stat.total,
"user", (stat.user-last.user+stat.sys-last.sys)*1000/total, "idle", (stat.idle-last.idle)*1000/total, "free", stat.free*1000/stat.total,
"rx", (stat.rx-last.rx)*1000/20000000, "tx", (stat.tx-last.tx)*1000/20000000, "established", stat.established, "time_wait", stat.time_wait,
)
last = stat
}},
}, mdb.PageListAction(mdb.FIELD, "time,id,utime,vmrss,user,idle,free,rx,tx,established,time_wait")), Hand: func(m *ice.Message, arg ...string) {
m.OptionDefault(mdb.CACHE_LIMIT, mdb.Config(m, mdb.LEAST))
if mdb.PageListSelect(m, arg...); (len(arg) == 0 || arg[0] == "") && m.Length() > 0 {
m.SortInt(mdb.ID).Display("/plugin/story/trend.js", "view", "折线图", "min", "0", "max", "1000", COLOR, "yellow,cyan,red,green,blue,purple,purple")
m.StatusTime(mdb.TIME, m.Append(mdb.TIME), "span", kit.FmtDuration(time.Duration(kit.Time(m.Time())-kit.Time(m.Append(mdb.TIME)))), m.AppendSimple(mdb.Config(m, mdb.FIELD)), "cursor", "0")
}
}},
})
}

4
base/cli/qrcode.go
View File

@ -50,9 +50,7 @@ const QRCODE = "qrcode"
func init() { func init() {
Index.MergeCommands(ice.Commands{ Index.MergeCommands(ice.Commands{
QRCODE: {Name: "qrcode text fg@key bg@key size auto", Help: "二维码", Role: aaa.VOID, Meta: kit.Dict( QRCODE: {Name: "qrcode text fg@key bg@key size auto", Help: "二维码", Role: aaa.VOID, Meta: kit.Dict(
ice.CTX_TRANS, kit.Dict(html.INPUT, kit.Dict( ice.CTX_TRANS, kit.Dict(html.INPUT, kit.Dict(mdb.TEXT, "文本", BG, "背景色", FG, "字体色")),
mdb.TEXT, "文本", BG, "背景色", FG, "字体色",
)),
), Actions: ice.MergeActions(ice.Actions{ ), Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
ice.AddRender(ice.RENDER_QRCODE, func(m *ice.Message, args ...ice.Any) string { ice.AddRender(ice.RENDER_QRCODE, func(m *ice.Message, args ...ice.Any) string {

43
base/cli/readelf.go
View File

@ -1,43 +0,0 @@
package cli
import (
"debug/elf"
"debug/macho"
"runtime"
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
func init() {
Index.MergeCommands(ice.Commands{
"readelf": {Name: "readelf path=bin/ice.bin auto", Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 || strings.HasSuffix(arg[0], nfs.PS) {
m.Cmdy(nfs.DIR, arg)
return
}
if f, e := nfs.OpenFile(m, arg[0]); !m.Warn(e) {
defer f.Close()
buf := make([]byte, 1024)
n, e := f.Read(buf)
if m.Warn(e) {
return
}
switch runtime.GOOS {
case LINUX:
f, _ := elf.Open(arg[0])
m.Echo("%v", kit.Formats(f))
case DARWIN:
f, _ := macho.Open(arg[0])
m.Echo("%v", kit.Formats(f))
}
for i := 0; i < n; i++ {
kit.If(i%16 == 0, func() { m.Push("addr", kit.Format("%04x", i)) })
m.Push(kit.Format("%02x", i%16), kit.Format("%02x", buf[i]))
}
}
}},
})
}

108
base/cli/runtime.go
View File

@ -1,7 +1,6 @@
package cli package cli
import ( import (
"bytes"
"os" "os"
"path" "path"
"runtime" "runtime"
@ -11,7 +10,6 @@ import (
ice "shylinux.com/x/icebergs" ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa" "shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/ctx" "shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/gdb"
"shylinux.com/x/icebergs/base/lex" "shylinux.com/x/icebergs/base/lex"
"shylinux.com/x/icebergs/base/mdb" "shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs" "shylinux.com/x/icebergs/base/nfs"
@ -21,6 +19,7 @@ import (
func _runtime_init(m *ice.Message) { func _runtime_init(m *ice.Message) {
count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, mdb.COUNT))) count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, mdb.COUNT)))
defer m.Conf(RUNTIME, kit.Keys(BOOT, mdb.COUNT), count+1)
kit.For(kit.UnMarshal(kit.Format(ice.Info.Make)), func(k string, v ice.Any) { m.Conf(RUNTIME, kit.Keys(MAKE, strings.ToLower(k)), v) }) kit.For(kit.UnMarshal(kit.Format(ice.Info.Make)), func(k string, v ice.Any) { m.Conf(RUNTIME, kit.Keys(MAKE, strings.ToLower(k)), v) })
m.Conf(RUNTIME, kit.Keys(HOST, GOARCH), runtime.GOARCH) m.Conf(RUNTIME, kit.Keys(HOST, GOARCH), runtime.GOARCH)
m.Conf(RUNTIME, kit.Keys(HOST, GOOS), runtime.GOOS) m.Conf(RUNTIME, kit.Keys(HOST, GOOS), runtime.GOOS)
@ -29,37 +28,29 @@ func _runtime_init(m *ice.Message) {
m.Conf(RUNTIME, kit.Keys(HOST, PWD), kit.Path("")) m.Conf(RUNTIME, kit.Keys(HOST, PWD), kit.Path(""))
m.Conf(RUNTIME, kit.Keys(HOST, HOME), kit.HomePath("")) m.Conf(RUNTIME, kit.Keys(HOST, HOME), kit.HomePath(""))
m.Conf(RUNTIME, kit.Keys(HOST, MAXPROCS), runtime.GOMAXPROCS(0)) m.Conf(RUNTIME, kit.Keys(HOST, MAXPROCS), runtime.GOMAXPROCS(0))
nfs.Exists(m, "/proc/meminfo", func(p string) { ice.Info.System = m.Conf(RUNTIME, kit.Keys(HOST, OSID))
kit.For(kit.SplitLine(m.Cmdx(nfs.CAT, p)), func(p string) { ice.Info.PidPath = ice.VAR_LOG_ICE_PID
switch ls := kit.Split(p, ": "); kit.Select("", ls, 0) {
case "MemTotal", "MemFree", "MemAvailable", "Buffers", "Cached":
m.Conf(RUNTIME, kit.Keys(HOST, ls[0]), kit.FmtSize(kit.Int(ls[1])*1024))
}
})
})
kit.For(ENV_LIST, func(k string) { kit.For(ENV_LIST, func(k string) {
m.Conf(RUNTIME, kit.Keys(CONF, k), kit.Env(k)) m.Conf(RUNTIME, kit.Keys(CONF, k), kit.Env(k))
kit.If(k == CTX_PID, func() { ice.Info.PidPath = kit.Env(k) }) kit.If(k == CTX_PID, func() { ice.Info.PidPath = kit.Env(k) })
}) })
ice.Info.PidPath = ice.VAR_LOG_ICE_PID
ice.Info.Lang = m.Conf(RUNTIME, kit.Keys(CONF, LANG)) ice.Info.Lang = m.Conf(RUNTIME, kit.Keys(CONF, LANG))
m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.UserName())
m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), kit.Env("HOSTNAME")) m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), kit.Env("HOSTNAME"))
m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME), path.Base(kit.Path("")))
if name, e := os.Hostname(); e == nil && name != "" { if name, e := os.Hostname(); e == nil && name != "" {
m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), name) m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), name)
} }
m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.UserName())
m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME), path.Base(kit.Path("")))
ice.Info.Hostname = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME))
ice.Info.Username = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME)) ice.Info.Username = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME))
ice.Info.Hostname = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME))
ice.Info.Pathname = m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME)) ice.Info.Pathname = m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME))
kit.HashSeed = append(kit.HashSeed, ice.Info.Hostname)
kit.HashSeed = append(kit.HashSeed, ice.Info.Username) kit.HashSeed = append(kit.HashSeed, ice.Info.Username)
kit.HashSeed = append(kit.HashSeed, ice.Info.Hostname)
kit.HashSeed = append(kit.HashSeed, ice.Info.Pathname) kit.HashSeed = append(kit.HashSeed, ice.Info.Pathname)
ice.Info.System = m.Conf(RUNTIME, kit.Keys(HOST, OSID))
aaa.UserRoot(ice.Pulse, "", ice.Info.Make.Username, aaa.TECH, ice.DEV) aaa.UserRoot(ice.Pulse, "", ice.Info.Make.Username, aaa.TECH, ice.DEV)
aaa.UserRoot(ice.Pulse, "", ice.Info.Username, aaa.ROOT, ice.OPS) aaa.UserRoot(ice.Pulse, "", ice.Info.Username, aaa.ROOT, ice.OPS)
m.Conf(RUNTIME, kit.Keys(BOOT, mdb.TIME), m.Time())
ice.Info.Time = m.Time() ice.Info.Time = m.Time()
m.Conf(RUNTIME, kit.Keys(BOOT, mdb.TIME), ice.Info.Time)
if runtime.GOARCH != MIPSLE { if runtime.GOARCH != MIPSLE {
msg := m.Cmd(nfs.DIR, _system_find(m, os.Args[0]), "time,path,size,hash") msg := m.Cmd(nfs.DIR, _system_find(m, os.Args[0]), "time,path,size,hash")
m.Conf(RUNTIME, kit.Keys(BOOT, mdb.HASH), msg.Append(mdb.HASH)) m.Conf(RUNTIME, kit.Keys(BOOT, mdb.HASH), msg.Append(mdb.HASH))
@ -68,9 +59,14 @@ func _runtime_init(m *ice.Message) {
ice.Info.Hash = msg.Append(mdb.HASH) ice.Info.Hash = msg.Append(mdb.HASH)
ice.Info.Size = msg.Append(nfs.SIZE) ice.Info.Size = msg.Append(nfs.SIZE)
} }
m.Conf(RUNTIME, kit.Keys(BOOT, mdb.COUNT), count+1) nfs.Exists(m, "/proc/meminfo", func(p string) {
m.Conf(RUNTIME, mdb.META, "") kit.For(kit.SplitLine(m.Cmdx(nfs.CAT, p)), func(p string) {
m.Conf(RUNTIME, mdb.HASH, "") switch ls := kit.Split(p, ": "); kit.Select("", ls, 0) {
case "MemTotal", "MemFree", "MemAvailable", "Buffers", "Cached":
m.Conf(RUNTIME, kit.Keys(BOOT, ls[0]), kit.FmtSize(kit.Int(ls[1])*1024))
}
})
})
} }
func _runtime_hostinfo(m *ice.Message) { func _runtime_hostinfo(m *ice.Message) {
m.Push("time", ice.Info.Make.Time) m.Push("time", ice.Info.Make.Time)
@ -82,14 +78,12 @@ func _runtime_hostinfo(m *ice.Message) {
m.Push("Sys", kit.FmtSize(stats.Sys)) m.Push("Sys", kit.FmtSize(stats.Sys))
m.Push("Alloc", kit.FmtSize(stats.Alloc)) m.Push("Alloc", kit.FmtSize(stats.Alloc))
m.Push("TotalAlloc", kit.FmtSize(stats.TotalAlloc)) m.Push("TotalAlloc", kit.FmtSize(stats.TotalAlloc))
m.Push("Objects", stats.HeapObjects)
m.Push("StackSys", kit.FmtSize(stats.StackSys)) m.Push("StackSys", kit.FmtSize(stats.StackSys))
m.Push("StackInuse", kit.FmtSize(stats.StackInuse)) m.Push("StackInuse", kit.FmtSize(stats.StackInuse))
m.Push("HeapSys", kit.FmtSize(stats.HeapSys)) m.Push("HeapSys", kit.FmtSize(stats.HeapSys))
m.Push("HeapInuse", kit.FmtSize(stats.HeapInuse)) m.Push("HeapInuse", kit.FmtSize(stats.HeapInuse))
m.Push("HeapIdle", kit.FmtSize(stats.HeapIdle)) m.Push("HeapIdle", kit.FmtSize(stats.HeapIdle))
m.Push("HeapReleased", kit.FmtSize(stats.HeapReleased)) m.Push("HeapReleased", kit.FmtSize(stats.HeapReleased))
m.Push("NumGC", stats.NumGC) m.Push("NumGC", stats.NumGC)
m.Push("LastGC", time.Unix(int64(stats.LastGC)/int64(time.Second), int64(stats.LastGC)%int64(time.Second))) m.Push("LastGC", time.Unix(int64(stats.LastGC)/int64(time.Second), int64(stats.LastGC)%int64(time.Second)))
m.Push("uptime", kit.Split(m.Cmdx(SYSTEM, "uptime"), mdb.FS)[0]) m.Push("uptime", kit.Split(m.Cmdx(SYSTEM, "uptime"), mdb.FS)[0])
@ -148,12 +142,10 @@ const (
const ( const (
CTX_SHY = "ctx_shy" CTX_SHY = "ctx_shy"
CTX_DEV = "ctx_dev" CTX_DEV = "ctx_dev"
CTX_HUB = "ctx_hub"
CTX_COM = "ctx_com"
CTX_OPS = "ctx_ops" CTX_OPS = "ctx_ops"
CTX_DEMO = "ctx_demo" CTX_DEMO = "ctx_demo"
CTX_ROOT = "ctx_root"
CTX_MAIL = "ctx_mail" CTX_MAIL = "ctx_mail"
CTX_ROOT = "ctx_root"
CTX_PID = "ctx_pid" CTX_PID = "ctx_pid"
CTX_LOG = "ctx_log" CTX_LOG = "ctx_log"
@ -161,21 +153,18 @@ const (
CTX_ENV = "ctx_env" CTX_ENV = "ctx_env"
) )
var ENV_LIST = []string{TZ, LANG, TERM, SHELL, CTX_SHY, CTX_DEV, CTX_HUB, CTX_COM, CTX_OPS, CTX_ROOT, CTX_DEMO, CTX_MAIL, CTX_PID} var ENV_LIST = []string{TZ, LANG, TERM, SHELL, CTX_SHY, CTX_DEV, CTX_OPS, CTX_DEMO, CTX_MAIL, CTX_ROOT, CTX_PID}
const ( const (
USERNAME = "username"
HOSTNAME = "hostname" HOSTNAME = "hostname"
PATHNAME = "pathname" PATHNAME = "pathname"
USERNAME = "username"
) )
const ( const (
IFCONFIG = "ifconfig" IFCONFIG = "ifconfig"
DISKINFO = "diskinfo" DISKINFO = "diskinfo"
HOSTINFO = "hostinfo" HOSTINFO = "hostinfo"
USERINFO = "userinfo" USERINFO = "userinfo"
PROCSTAT = "procstat"
PROCINFO = "procinfo"
PROCKILL = "prockill"
BOOTINFO = "bootinfo" BOOTINFO = "bootinfo"
MAXPROCS = "maxprocs" MAXPROCS = "maxprocs"
) )
@ -183,28 +172,22 @@ const RUNTIME = "runtime"
func init() { func init() {
Index.MergeCommands(ice.Commands{ Index.MergeCommands(ice.Commands{
RUNTIME: {Name: "runtime info=bootinfo,ifconfig,diskinfo,hostinfo,userinfo,procstat,procinfo,bootinfo,role,api,cli,cmd,mod,env,path,chain,routine auto upgrade reboot stash logs conf", Icon: "Infomation.png", Help: "运行环境", Actions: ice.MergeActions(ice.Actions{ RUNTIME: {Name: "runtime info=bootinfo,ifconfig,diskinfo,hostinfo,userinfo,bootinfo,role,api,cli,cmd,mod,env,path,chain auto upgrade reboot stash logs conf lock", Icon: "Infomation.png", Help: "运行环境", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { _runtime_init(m); aaa.White(m, ice.LICENSE) }},
aaa.White(m, ice.LICENSE) IFCONFIG: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(tcp.HOST) }},
_runtime_init(m) DISKINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_diskinfo(m) }},
}}, HOSTINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_hostinfo(m) }},
IFCONFIG: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(tcp.HOST) }},
DISKINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_diskinfo(m) }},
HOSTINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_hostinfo(m) }},
HOSTNAME: {Hand: func(m *ice.Message, arg ...string) { HOSTNAME: {Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 { if len(arg) > 0 {
ice.Info.Hostname = mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.NAME), mdb.Conf(m, RUNTIME, kit.Keys(BOOT, HOSTNAME), arg[0])) ice.Info.Hostname = mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.NAME), mdb.Conf(m, RUNTIME, kit.Keys(BOOT, HOSTNAME), arg[0]))
} }
m.Echo(ice.Info.Hostname) m.Echo(ice.Info.Hostname)
}}, }},
USERINFO: {Hand: func(m *ice.Message, arg ...string) { m.Split(m.Cmdx(SYSTEM, "who"), "user term time") }},
PROCSTAT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(PROCSTAT) }},
PROCINFO: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(PROCINFO) }},
PROCKILL: {Help: "结束进程", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(gdb.SIGNAL, gdb.STOP, m.Option("PID")).ProcessRefresh() }},
MAXPROCS: {Hand: func(m *ice.Message, arg ...string) { MAXPROCS: {Hand: func(m *ice.Message, arg ...string) {
kit.If(len(arg) > 0, func() { runtime.GOMAXPROCS(kit.Int(mdb.Conf(m, RUNTIME, kit.Keys(HOST, MAXPROCS), arg[0]))) }) kit.If(len(arg) > 0, func() { runtime.GOMAXPROCS(kit.Int(mdb.Conf(m, RUNTIME, kit.Keys(HOST, MAXPROCS), arg[0]))) })
m.Echo("%d", runtime.GOMAXPROCS(0)) m.Echo("%d", runtime.GOMAXPROCS(0))
}}, }},
USERINFO: {Hand: func(m *ice.Message, arg ...string) { m.Split(m.Cmdx(SYSTEM, "who"), "user term time") }},
aaa.ROLE: {Hand: func(m *ice.Message, arg ...string) { aaa.ROLE: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(aaa.ROLE, func(value ice.Maps) { m.Push(mdb.KEY, kit.Keys(value[aaa.ROLE], value[mdb.ZONE], value[mdb.KEY])) }) m.Cmd(aaa.ROLE, func(value ice.Maps) { m.Push(mdb.KEY, kit.Keys(value[aaa.ROLE], value[mdb.ZONE], value[mdb.KEY])) })
ctx.DisplayStorySpide(m.Options(nfs.DIR_ROOT, "ice."), mdb.FIELD, mdb.KEY, lex.SPLIT, nfs.PT) ctx.DisplayStorySpide(m.Options(nfs.DIR_ROOT, "ice."), mdb.FIELD, mdb.KEY, lex.SPLIT, nfs.PT)
@ -235,47 +218,13 @@ func init() {
kit.For(ice.Info.Gomod, func(k string, v string) { m.Push(nfs.MODULE, k).Push(nfs.VERSION, v) }) kit.For(ice.Info.Gomod, func(k string, v string) { m.Push(nfs.MODULE, k).Push(nfs.VERSION, v) })
}}, }},
ENV: {Hand: func(m *ice.Message, arg ...string) { ENV: {Hand: func(m *ice.Message, arg ...string) {
kit.For(os.Environ(), func(v string) { kit.For(os.Environ(), func(v string) { ls := strings.SplitN(v, mdb.EQ, 2); m.Push(mdb.NAME, ls[0]).Push(mdb.VALUE, ls[1]) })
ls := strings.SplitN(v, mdb.EQ, 2)
m.Push(mdb.NAME, ls[0]).Push(mdb.VALUE, ls[1])
})
m.Sort(mdb.NAME) m.Sort(mdb.NAME)
}}, }},
nfs.PATH: {Hand: func(m *ice.Message, arg ...string) { nfs.PATH: {Hand: func(m *ice.Message, arg ...string) {
kit.For(_path_split(os.Getenv(PATH)), func(p string) { m.Push(nfs.PATH, p) }) kit.For(_path_split(os.Getenv(PATH)), func(p string) { m.Push(nfs.PATH, p) })
}}, }},
"chain": {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.FormatChain()) }}, "chain": {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.FormatChain()) }},
"routine": {Hand: func(m *ice.Message, arg ...string) {
status := map[string]int{}
buf := make([]byte, 4096*4096)
runtime.Stack(buf, true)
outer:
for _, v := range bytes.Split(buf, []byte(lex.NL+lex.NL)) {
ls := bytes.Split(v, []byte(lex.NL))
if ls := strings.SplitN(string(ls[0]), " ", 3); len(ls) > 0 {
m.Push(mdb.ID, ls[1]).Push(mdb.STATUS, ls[2])
status[kit.Split(string(ls[2]), " []:")[0]]++
}
for i := 1; i < len(ls); i += 2 {
if bytes.HasPrefix(ls[i], []byte("shylinux.com/x/")) {
m.Push(nfs.PATH, kit.TrimPath(string(ls[i+1]))).Push("func", string(ls[i]))
continue outer
}
}
m.Push(nfs.PATH, kit.TrimPath(string(ls[2]))).Push("func", string(ls[1]))
}
var stats runtime.MemStats
runtime.ReadMemStats(&stats)
m.StatusTimeCount(status, "GOMAXPROCS", runtime.GOMAXPROCS(0), "NumGC", stats.NumGC,
"Sys", kit.FmtSize(stats.Sys),
"Alloc", kit.FmtSize(stats.Alloc),
"StackSys", kit.FmtSize(stats.StackSys),
"StackInuse", kit.FmtSize(stats.StackInuse),
"HeapSys", kit.FmtSize(stats.HeapSys),
"HeapInuse", kit.FmtSize(stats.HeapInuse),
)
m.Echo("%v", string(buf))
}},
"upgrade": {Help: "升级", Hand: func(m *ice.Message, arg ...string) { "upgrade": {Help: "升级", Hand: func(m *ice.Message, arg ...string) {
if nfs.Exists(m, ice.SRC_MAIN_GO) && nfs.Exists(m, ".git") && SystemFind(m, "go") != "" { if nfs.Exists(m, ice.SRC_MAIN_GO) && nfs.Exists(m, ".git") && SystemFind(m, "go") != "" {
m.Cmdy("web.code.vimer", "compile") m.Cmdy("web.code.vimer", "compile")
@ -310,9 +259,8 @@ func init() {
m.Cmdy(ctx.CONFIG, RUNTIME, arg).StatusTime(mdb.TIME, ice.Info.Make.Time, m.Cmdy(ctx.CONFIG, RUNTIME, arg).StatusTime(mdb.TIME, ice.Info.Make.Time,
mdb.HASH, kit.Cut(ice.Info.Hash, 6), nfs.SIZE, ice.Info.Size, mdb.HASH, kit.Cut(ice.Info.Hash, 6), nfs.SIZE, ice.Info.Size,
mdb.NAME, ice.Info.NodeName, nfs.VERSION, ice.Info.Make.Versions(), mdb.NAME, ice.Info.NodeName, nfs.VERSION, ice.Info.Make.Versions(),
).Option(ice.MSG_ACTION, "") ).Action()
ctx.DisplayStoryJSON(m) ctx.DisplayStoryJSON(m)
m.Action("lock")
}}, }},
}) })
} }
@ -344,8 +292,8 @@ func ParseMake(str string) []string {
} }
func SimpleMake() []string { func SimpleMake() []string {
return []string{ return []string{
"bootTime", ice.Info.Time, "compileTime", ice.Info.Make.Time, "commitTime", ice.Info.Make.When,
nfs.MODULE, ice.Info.Make.Module, nfs.VERSION, ice.Info.Make.Versions(), nfs.MODULE, ice.Info.Make.Module, nfs.VERSION, ice.Info.Make.Versions(),
"commitTime", ice.Info.Make.When, "compileTime", ice.Info.Make.Time, "bootTime", ice.Info.Time,
"kernel", runtime.GOOS, "arch", runtime.GOARCH, "kernel", runtime.GOOS, "arch", runtime.GOARCH,
} }
} }

20
base/cli/system.go
View File

@ -91,6 +91,7 @@ func _system_exec(m *ice.Message, cmd *exec.Cmd) {
if m.Echo(out.String()).Echo(err.String()); m.IsErr() { if m.Echo(out.String()).Echo(err.String()); m.IsErr() {
m.Option(ice.MSG_ARGS, kit.Simple(http.StatusBadRequest, cmd.Args, err.String())) m.Option(ice.MSG_ARGS, kit.Simple(http.StatusBadRequest, cmd.Args, err.String()))
m.Echo(strings.TrimRight(err.String(), lex.NL)) m.Echo(strings.TrimRight(err.String(), lex.NL))
m.Info("err: %v", err.String())
} }
}() }()
} }
@ -105,19 +106,16 @@ func _system_code(cmd *exec.Cmd) string {
func _system_find(m *ice.Message, bin string, dir ...string) string { func _system_find(m *ice.Message, bin string, dir ...string) string {
if strings.Contains(bin, nfs.DF) { if strings.Contains(bin, nfs.DF) {
return bin return bin
} } else if strings.HasPrefix(bin, nfs.PS) {
if strings.HasPrefix(bin, nfs.PS) {
return bin return bin
} } else if strings.HasPrefix(bin, nfs.PWD) {
if strings.HasPrefix(bin, nfs.PWD) {
return bin return bin
} }
kit.If(len(dir) == 0, func() { dir = append(dir, _path_split(kit.Env(PATH))...) }) kit.If(len(dir) == 0, func() { dir = append(dir, _path_split(kit.Env(PATH))...) })
for _, p := range dir { for _, p := range dir {
if nfs.Exists(m, path.Join(p, bin)) { if nfs.Exists(m, path.Join(p, bin)) {
return kit.Path(p, bin) return kit.Path(p, bin)
} } else if IsWindows() && nfs.Exists(m, path.Join(p, bin)+".exe") {
if IsWindows() && nfs.Exists(m, path.Join(p, bin)+".exe") {
return kit.Path(p, bin) + ".exe" return kit.Path(p, bin) + ".exe"
} }
} }
@ -177,10 +175,8 @@ func init() {
m.Echo(SystemCmds(m, "man %s %s|col -b", kit.Select("", arg[1], arg[1] != "1"), arg[0])) m.Echo(SystemCmds(m, "man %s %s|col -b", kit.Select("", arg[1], arg[1] != "1"), arg[0]))
}}, }},
OPENS: {Hand: func(m *ice.Message, arg ...string) { Opens(m, arg...) }}, OPENS: {Hand: func(m *ice.Message, arg ...string) { Opens(m, arg...) }},
}, mdb.HashAction(mdb.SHORT, CMD, mdb.FIELD, "time,cmd,arg")), Hand: func(m *ice.Message, arg ...string) { }), Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 { if _system_exec(m, _system_cmd(m, arg...)); IsSuccess(m) && m.Append(CMD_ERR) == "" {
mdb.HashSelect(m)
} else if _system_exec(m, _system_cmd(m, arg...)); IsSuccess(m) && m.Append(CMD_ERR) == "" {
m.SetAppend() m.SetAppend()
} }
}}, }},
@ -199,9 +195,7 @@ func IsSuccess(m *ice.Message) bool { return m.Append(CODE) == "" || m.Append(CO
var _cache_path []string var _cache_path []string
func Shell(m *ice.Message) string { func Shell(m *ice.Message) string { return kit.Select("/bin/sh", os.Getenv("SHELL")) }
return kit.Select("/bin/sh", os.Getenv("SHELL"))
}
func EtcPath(m *ice.Message) (res []string) { func EtcPath(m *ice.Message) (res []string) {
if len(_cache_path) > 0 { if len(_cache_path) > 0 {
return _cache_path return _cache_path

68
base/ctx/command.go
View File

@ -7,7 +7,6 @@ import (
ice "shylinux.com/x/icebergs" ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa" "shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/lex"
"shylinux.com/x/icebergs/base/mdb" "shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs" "shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits" kit "shylinux.com/x/toolkits"
@ -24,11 +23,10 @@ func _command_list(m *ice.Message, name string) *ice.Message {
m.Push(mdb.LIST, kit.Format(cmd.List)) m.Push(mdb.LIST, kit.Format(cmd.List))
m.Push(mdb.META, kit.Format(cmd.Meta)) m.Push(mdb.META, kit.Format(cmd.Meta))
m.Push("_command", ShortCmd(kit.Keys(s.Prefix(), key))) m.Push("_command", ShortCmd(kit.Keys(s.Prefix(), key)))
if !nfs.Exists(m, kit.Split(cmd.FileLine(), ":")[0], func(p string) { if !nfs.Exists(m, kit.Split(cmd.FileLine(), nfs.DF)[0], func(p string) {
m.Push("_fileline", kit.MergeURL(FileURI(p), ice.POD, m.Option(ice.MSG_USERPOD))) m.Push("_fileline", m.FileURI(p))
}) { }) {
m.Push("_fileline", "") m.Push("_fileline", "")
} }
m.Push("_role", kit.Select("", ice.OK, aaa.Right(m.Spawn(), name))) m.Push("_role", kit.Select("", ice.OK, aaa.Right(m.Spawn(), name)))
m.Push("_help", GetCmdHelp(m, name)) m.Push("_help", GetCmdHelp(m, name))
@ -40,16 +38,10 @@ func _command_search(m *ice.Message, kind, name, text string) {
if IsOrderCmd(key) || !strings.Contains(s.Prefix(key), name) { if IsOrderCmd(key) || !strings.Contains(s.Prefix(key), name) {
return return
} }
m.PushSearch(ice.CTX, kit.PathName(1), m.PushSearch(ice.CTX, kit.PathName(1), ice.CMD, kit.FileName(1),
ice.CMD, kit.FileName(1),
kit.SimpleKV("", s.Prefix(), kit.Select(key, cmd.Name), cmd.Help), kit.SimpleKV("", s.Prefix(), kit.Select(key, cmd.Name), cmd.Help),
CONTEXT, s.Prefix(), INDEX, kit.Keys(s.Prefix(), key))
COMMAND, key, }).Sort(m.OptionFields())
INDEX, kit.Keys(s.Prefix(), key),
mdb.HELP, cmd.Help,
nfs.FILE, FileURI(cmd.FileLine()))
})
m.Sort(m.OptionFields())
} }
const ( const (
@ -103,56 +95,24 @@ func init() {
}) })
} }
}}, }},
mdb.EXPORT: {Hand: func(m *ice.Message, arg ...string) { }), Hand: func(m *ice.Message, arg ...string) { kit.For(arg, func(k string) { _command_list(m, k) }) }},
TravelCmd(m, func(key, file, line string) { m.Push(mdb.NAME, key).Push(nfs.FILE, file).Push(nfs.LINE, line) }).Sort(mdb.NAME).Table(func(value ice.Maps) {
m.Echo(`%s %s %s;" f`+lex.NL, value[mdb.NAME], value[nfs.FILE], value[nfs.LINE])
}).Cmd(nfs.SAVE, nfs.TAGS, m.Result())
}},
}), Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 {
m.Cmdy("", mdb.SEARCH, COMMAND, ice.OptionFields(INDEX)).Action(mdb.EXPORT)
DisplayStory(m.Options(nfs.DIR_ROOT, "ice."), "spide.js?split=.")
} else {
kit.For(arg, func(k string) { _command_list(m, k) })
}
}},
}) })
} }
var PodCmd = func(m *ice.Message, arg ...ice.Any) bool { return false } var PodCmd = func(m *ice.Message, arg ...ice.Any) bool { return false }
func Run(m *ice.Message, arg ...string) { func Run(m *ice.Message, arg ...string) {
kit.If(kit.IsIn(arg[0], "web.chat.grant") || !PodCmd(m, arg) && aaa.Right(m, arg), func() { m.Cmdy(arg) }) kit.If(!PodCmd(m, arg) && aaa.Right(m, arg), func() { m.Cmdy(arg) })
} }
func Command(m *ice.Message, arg ...string) { func Command(m *ice.Message, arg ...string) {
kit.If(kit.IsIn(arg[0], "web.chat.grant") || !PodCmd(m, COMMAND, arg), func() { m.Cmdy(COMMAND, arg) }) kit.If(!PodCmd(m, COMMAND, arg), func() { m.Cmdy(COMMAND, arg) })
} }
func FileURI(dir string) string {
if dir == "" {
return ""
} else if strings.Contains(dir, "/pkg/mod/") {
dir = strings.Split(dir, "/pkg/mod/")[1]
} else if ice.Info.Make.Path != "" && strings.HasPrefix(dir, ice.Info.Make.Path) {
dir = strings.TrimPrefix(dir, ice.Info.Make.Path)
} else if strings.HasPrefix(dir, kit.Path("")+nfs.PS) {
dir = strings.TrimPrefix(dir, kit.Path("")+nfs.PS)
} else if strings.HasPrefix(dir, ice.ISH_PLUGED) {
dir = strings.TrimPrefix(dir, ice.ISH_PLUGED)
} else if kit.HasPrefix(dir, nfs.PS, ice.HTTP) {
return dir
}
if strings.HasPrefix(dir, ice.USR_VOLCANOS) {
return strings.TrimPrefix(dir, ice.USR)
} else {
return path.Join(nfs.PS, ice.REQUIRE, dir)
}
}
func FileCmd(dir string) string { func FileCmd(dir string) string {
if strings.Index(dir, ":") == 1 { if strings.Index(dir, ":") == 1 {
return FileURI(kit.ExtChange(strings.Join(kit.Slice(strings.Split(dir, ":"), 0, 2), ":"), nfs.GO)) return ice.Pulse.FileURI(kit.ExtChange(strings.Join(kit.Slice(strings.Split(dir, ":"), 0, 2), ":"), nfs.GO))
} }
return FileURI(kit.ExtChange(strings.Split(dir, nfs.DF)[0], nfs.GO)) return ice.Pulse.FileURI(kit.ExtChange(strings.Split(dir, nfs.DF)[0], nfs.GO))
} }
func AddFileCmd(dir, key string) { func AddFileCmd(dir, key string) {
ice.Info.File[FileCmd(dir)] = key ice.Info.File[FileCmd(dir)] = key
@ -180,7 +140,7 @@ func GetFileCmd(dir string) string {
return "" return ""
} }
func GetCmdHelp(m *ice.Message, cmds string) (file string) { func GetCmdHelp(m *ice.Message, cmds string) (file string) {
file = strings.TrimPrefix(FileURI(kit.ExtChange(GetCmdFile(m, cmds), nfs.SHY)), nfs.REQUIRE) file = strings.TrimPrefix(m.FileURI(kit.ExtChange(GetCmdFile(m, cmds), nfs.SHY)), nfs.REQUIRE)
if !nfs.Exists(m, path.Join(nfs.USR_LEARNING_PORTAL, "commands", strings.TrimPrefix(file, nfs.USR_ICEBERGS)), func(p string) { file = p }) { if !nfs.Exists(m, path.Join(nfs.USR_LEARNING_PORTAL, "commands", strings.TrimPrefix(file, nfs.USR_ICEBERGS)), func(p string) { file = p }) {
kit.If(!nfs.Exists(m, file), func() { file = "" }) kit.If(!nfs.Exists(m, file), func() { file = "" })
} }
@ -188,7 +148,7 @@ func GetCmdHelp(m *ice.Message, cmds string) (file string) {
} }
func GetCmdFile(m *ice.Message, cmds string) (file string) { func GetCmdFile(m *ice.Message, cmds string) (file string) {
m.Search(kit.Select(m.PrefixKey(), cmds), func(key string, cmd *ice.Command) { m.Search(kit.Select(m.PrefixKey(), cmds), func(key string, cmd *ice.Command) {
if file = strings.TrimPrefix(FileURI(kit.Split(cmd.FileLine(), nfs.DF)[0]), nfs.REQUIRE); !nfs.Exists(m, file) { if file = strings.TrimPrefix(m.FileURI(kit.Split(cmd.FileLine(), nfs.DF)[0]), nfs.REQUIRE); !nfs.Exists(m, file) {
file = path.Join(nfs.REQUIRE, file) file = path.Join(nfs.REQUIRE, file)
} }
}) })
@ -211,7 +171,9 @@ func TravelCmd(m *ice.Message, cb func(key, file, line string)) *ice.Message {
}) })
return m return m
} }
func IsOrderCmd(key string) bool { return key[0] == '/' || key[0] == '_' } func IsOrderCmd(key string) bool {
return key[0] == '/' || key[0] == '_'
}
func ShortCmd(key string) string { func ShortCmd(key string) string {
_key := kit.Select("", kit.Split(key, nfs.PT), -1) _key := kit.Select("", kit.Split(key, nfs.PT), -1)
if _p, ok := ice.Info.Index[_key].(*ice.Context); ok && _p.Prefix(_key) == key { if _p, ok := ice.Info.Index[_key].(*ice.Context); ok && _p.Prefix(_key) == key {

113
base/ctx/config.go
View File

@ -13,24 +13,6 @@ import (
"shylinux.com/x/toolkits/miss" "shylinux.com/x/toolkits/miss"
) )
func _config_format_list(m *ice.Message, v ice.Any) string {
list := []string{"{", lex.NL}
kit.For(v, func(k string, v ice.Any) {
if k == mdb.HASH {
list = append(list, lex.TB, kit.Format("%q", k), nfs.DF, "{", lex.NL)
kit.For(v, func(k string, v ice.Any) {
list = append(list, lex.TB, lex.TB, kit.Format("%q", k), nfs.DF, kit.Format(v), mdb.FS, lex.NL)
})
list = list[:len(list)-2]
list = append(list, lex.TB, lex.NL, lex.TB, "}", mdb.FS, lex.NL)
} else {
list = append(list, lex.TB, kit.Format("%q", k), nfs.DF, kit.Format(v), mdb.FS, lex.NL)
}
})
list = list[:len(list)-2]
list = append(list, lex.NL, "}")
return strings.Join(list, "")
}
func _config_only(v ice.Any, arg ...string) bool { func _config_only(v ice.Any, arg ...string) bool {
switch v := v.(type) { switch v := v.(type) {
case nil: case nil:
@ -55,9 +37,9 @@ func _config_save(m *ice.Message, name string, arg ...string) {
for _, k := range arg { for _, k := range arg {
if v := mdb.Confv(msg, k); _config_only(v, mdb.META) && _config_only(kit.Value(v, mdb.META), if v := mdb.Confv(msg, k); _config_only(v, mdb.META) && _config_only(kit.Value(v, mdb.META),
mdb.IMPORTANT, mdb.EXPIRE, mdb.SHORT, mdb.FIELD, mdb.FIELDS, mdb.ACTION, mdb.SORT, mdb.TOOLS, mdb.IMPORTANT, mdb.EXPIRE, mdb.SHORT, mdb.FIELD, mdb.FIELDS, mdb.ACTION, mdb.SORT, mdb.TOOLS,
"regexp", "path", "link", nfs.SOURCE, nfs.SCRIPT,
lex.REGEXP, nfs.PATH, "link",
"linux", "darwin", "windows", "linux", "darwin", "windows",
"source", "script",
) { ) {
continue continue
} else { } else {
@ -91,40 +73,32 @@ func _config_load(m *ice.Message, name string, arg ...string) {
func _config_make(m *ice.Message, key string, arg ...string) { func _config_make(m *ice.Message, key string, arg ...string) {
msg := m.Spawn(m.Source()) msg := m.Spawn(m.Source())
if len(arg) > 1 { if len(arg) > 1 {
kit.If(!kit.IsIn(strings.Split(arg[0], nfs.PT)[0], mdb.META, mdb.HASH, mdb.LIST), func() { arg[0] = kit.Keys(mdb.META, arg[0]) })
kit.If(strings.HasPrefix(arg[1], mdb.AT), func() { arg[1] = msg.Cmdx(nfs.CAT, arg[1][1:]) }) kit.If(strings.HasPrefix(arg[1], mdb.AT), func() { arg[1] = msg.Cmdx(nfs.CAT, arg[1][1:]) })
if !kit.IsIn(strings.Split(arg[0], nfs.PT)[0], mdb.META, mdb.HASH, mdb.LIST) {
arg[0] = kit.Keys(mdb.META, arg[0])
}
mdb.Confv(msg, key, arg[0], kit.Parse(nil, "", arg[1:]...)) mdb.Confv(msg, key, arg[0], kit.Parse(nil, "", arg[1:]...))
} }
if len(arg) > 0 { if len(arg) > 0 {
m.Echo(FormatPretty(mdb.Confv(msg, key, arg[0]), 0, 1)) m.Echo(kit.Formats(mdb.Confv(msg, key, arg[0])))
} else { } else {
m.Echo(FormatPretty(mdb.Confv(msg, key), 0, 1)) m.Echo(kit.Formats(mdb.Confv(msg, key))).StatusTime(mdb.COUNT, kit.Length(mdb.Confv(msg, key, mdb.HASH)))
m.StatusTime(mdb.COUNT, kit.Length(mdb.Confv(msg, key, mdb.HASH)))
} }
} }
func _config_list(m *ice.Message) { func _config_list(m *ice.Message) {
for k, v := range m.Source().Configs { for k, v := range m.Source().Configs {
if IsOrderCmd(k) { if !IsOrderCmd(k) {
continue m.Push(mdb.KEY, k).Push(mdb.NAME, v.Name).Push(mdb.VALUE, kit.Format(v.Value))
} }
m.Push(mdb.KEY, k).Push(mdb.NAME, v.Name).Push(mdb.VALUE, kit.Format(v.Value))
} }
m.Sort(mdb.KEY) m.Sort(mdb.KEY)
} }
const (
SAVE = "save"
LOAD = "load"
)
const CONFIG = "config" const CONFIG = "config"
func init() { func init() {
Index.MergeCommands(ice.Commands{ Index.MergeCommands(ice.Commands{
CONFIG: {Name: "config key auto", Help: "配置", Actions: ice.Actions{ CONFIG: {Name: "config key auto", Help: "配置", Actions: ice.Actions{
SAVE: {Hand: func(m *ice.Message, arg ...string) { _config_save(m, arg[0], arg[1:]...) }}, nfs.SAVE: {Hand: func(m *ice.Message, arg ...string) { _config_save(m, arg[0], arg[1:]...) }},
LOAD: {Hand: func(m *ice.Message, arg ...string) { _config_load(m, arg[0], arg[1:]...) }}, nfs.LOAD: {Hand: func(m *ice.Message, arg ...string) { _config_load(m, arg[0], arg[1:]...) }},
mdb.EXPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(arg[0], mdb.EXPORT) }}, mdb.EXPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(arg[0], mdb.EXPORT) }},
mdb.IMPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(arg[0], mdb.IMPORT) }}, mdb.IMPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(arg[0], mdb.IMPORT) }},
nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) { nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) {
@ -132,11 +106,6 @@ func init() {
nfs.Trash(m, m.Cmdx(arg[0], mdb.EXPORT)) nfs.Trash(m, m.Cmdx(arg[0], mdb.EXPORT))
mdb.Config(m, arg[0], nil, nil) mdb.Config(m, arg[0], nil, nil)
}}, }},
mdb.LIST: {Hand: func(m *ice.Message, arg ...string) {
list := []ice.Any{}
kit.For(arg[2:], func(v string) { list = append(list, v) })
mdb.Confv(m, arg[0], arg[1], list)
}},
}, Hand: func(m *ice.Message, arg ...string) { }, Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 { if len(arg) == 0 {
_config_list(m) _config_list(m)
@ -152,14 +121,16 @@ func init() { ice.Info.Save = Save; ice.Info.Load = Load }
func Save(m *ice.Message, arg ...string) *ice.Message { func Save(m *ice.Message, arg ...string) *ice.Message {
kit.If(len(arg) == 0, func() { arg = kit.SortedKey(m.Target().Configs) }) kit.If(len(arg) == 0, func() { arg = kit.SortedKey(m.Target().Configs) })
kit.For(arg, func(i int, k string) { arg[i] = strings.Replace(m.Prefix(k), nfs.PS, "", 1) }) kit.For(arg, func(i int, k string) { arg[i] = strings.Replace(m.Prefix(k), nfs.PS, "", 1) })
return m.Cmd(CONFIG, SAVE, m.Prefix(nfs.JSON), arg) return m.Cmd(CONFIG, nfs.SAVE, m.Prefix(nfs.JSON), arg)
} }
func Load(m *ice.Message, arg ...string) *ice.Message { func Load(m *ice.Message, arg ...string) *ice.Message {
kit.If(len(arg) == 0, func() { arg = kit.SortedKey(m.Target().Configs) }) kit.If(len(arg) == 0, func() { arg = kit.SortedKey(m.Target().Configs) })
kit.For(arg, func(i int, k string) { arg[i] = strings.Replace(m.Prefix(k), nfs.PS, "", 1) }) kit.For(arg, func(i int, k string) { arg[i] = strings.Replace(m.Prefix(k), nfs.PS, "", 1) })
return m.Cmd(CONFIG, LOAD, m.Prefix(nfs.JSON), arg) return m.Cmd(CONFIG, nfs.LOAD, m.Prefix(nfs.JSON), arg)
}
func ConfAction(arg ...ice.Any) ice.Actions {
return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(arg...)}
} }
func ConfAction(arg ...ice.Any) ice.Actions { return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(arg...)} }
func ConfigSimple(m *ice.Message, key ...string) (res []string) { func ConfigSimple(m *ice.Message, key ...string) (res []string) {
kit.For(kit.Split(kit.Join(key)), func(k string) { res = append(res, k, mdb.Config(m, k)) }) kit.For(kit.Split(kit.Join(key)), func(k string) { res = append(res, k, mdb.Config(m, k)) })
return return
@ -176,59 +147,3 @@ func OptionFromConfig(m *ice.Message, arg ...string) string {
kit.For(arg, func(k string) { m.Option(k, mdb.Config(m, k)) }) kit.For(arg, func(k string) { m.Option(k, mdb.Config(m, k)) })
return m.Option(arg[0]) return m.Option(arg[0])
} }
func FormatPretty(v ice.Any, i, n int) string {
return kit.Formats(v)
switch v := v.(type) {
case map[string]ice.Any:
if n == 0 {
list := []string{"{"}
kit.For(v, func(k string, v ice.Any) {
list = append(list, kit.Format("%q", k), nfs.DF, FormatPretty(v, 0, 0), mdb.FS)
})
list = list[:len(list)-1]
list = append(list, "}")
return strings.Join(list, "")
}
list := []string{"{", lex.NL}
kit.For(v, func(k string, v ice.Any) {
list = append(list, strings.Repeat(lex.TB, i+1), kit.Format("%q", k), nfs.DF)
if i < n && !kit.IsIn(k, mdb.META) && !strings.HasPrefix(k, "_") {
list = append(list, FormatPretty(v, i+1, n))
} else {
list = append(list, FormatPretty(v, 0, 0))
}
list = append(list, mdb.FS, lex.NL)
})
list = append(list[:len(list)-2], lex.NL)
list = append(list, strings.Repeat(lex.TB, i), "}")
return strings.Join(list, "")
case []ice.Any:
if n == 0 {
list := []string{"["}
kit.For(v, func(k string, v ice.Any) {
list = append(list, FormatPretty(v, 0, 0), mdb.FS)
})
list = list[:len(list)-1]
list = append(list, "]")
return strings.Join(list, "")
}
list := []string{"[", lex.NL}
kit.For(v, func(v ice.Any) {
list = append(list, strings.Repeat(lex.TB, i+1))
if i < n {
list = append(list, FormatPretty(v, i+1, n))
} else {
list = append(list, FormatPretty(v, 0, 0))
}
list = append(list, mdb.FS, lex.NL)
})
list = append(list[:len(list)-2], lex.NL)
list = append(list, strings.Repeat(lex.TB, i), "]")
return strings.Join(list, "")
case string:
return kit.Format(v)
return kit.Format("%q", v)
default:
return kit.Format(v)
}
}

3
base/ctx/ctx.go
View File

@ -2,7 +2,6 @@ package ctx
import ( import (
ice "shylinux.com/x/icebergs" ice "shylinux.com/x/icebergs"
kit "shylinux.com/x/toolkits"
) )
const CTX = "ctx" const CTX = "ctx"
@ -10,5 +9,3 @@ const CTX = "ctx"
var Index = &ice.Context{Name: CTX, Help: "标准模块"} var Index = &ice.Context{Name: CTX, Help: "标准模块"}
func init() { ice.Index.Register(Index, nil, CONTEXT, COMMAND, CONFIG) } func init() { ice.Index.Register(Index, nil, CONTEXT, COMMAND, CONFIG) }
func Prefix(arg ...string) string { return kit.Keys(CTX, arg) }

36
base/ctx/display.go
View File

@ -10,22 +10,11 @@ import (
"shylinux.com/x/icebergs/base/nfs" "shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web/html" "shylinux.com/x/icebergs/base/web/html"
kit "shylinux.com/x/toolkits" kit "shylinux.com/x/toolkits"
"shylinux.com/x/toolkits/logs"
) )
type displayMessage interface {
Option(key string, arg ...ice.Any) string
Action(arg ...ice.Any) *ice.Message
}
func isLocalFile(p string) bool { func isLocalFile(p string) bool {
return !strings.HasPrefix(p, nfs.PS) && !strings.HasPrefix(p, ice.HTTP) return !strings.HasPrefix(p, nfs.PS) && !strings.HasPrefix(p, ice.HTTP)
} }
func Display(m *ice.Message, file string, arg ...ice.Any) *ice.Message {
kit.If(file == "", func() { file = kit.Keys(kit.FileName(5), nfs.JS) })
kit.If(isLocalFile(file), func() { file = path.Join(nfs.PS, path.Join(path.Dir(FileURI(logs.FileLines(2))), file)) })
return DisplayBase(m, file, arg...)
}
func DisplayTable(m *ice.Message, arg ...ice.Any) *ice.Message { func DisplayTable(m *ice.Message, arg ...ice.Any) *ice.Message {
return DisplayBase(m, ice.PLUGIN_TABLE_JS, arg...) return DisplayBase(m, ice.PLUGIN_TABLE_JS, arg...)
} }
@ -42,21 +31,17 @@ func DisplayStoryForm(m *ice.Message, arg ...ice.Any) *ice.Message {
for i := range arg { for i := range arg {
switch v := arg[i].(type) { switch v := arg[i].(type) {
case string: case string:
args = append(args, ice.SplitCmd("list "+v, nil)...) args = append(args, ice.SplitCmd("list "+v, nil)...)
default: default:
trans := kit.Value(m.Commands(m.CommandKey()).Meta, ice.CTX_TRANS) trans := kit.Value(m.Commands(m.CommandKey()).Meta, ice.CTX_TRANS)
if t := reflect.TypeOf(v); t.Kind() == reflect.Func { if t := reflect.TypeOf(v); t.Kind() == reflect.Func {
name := kit.FuncName(arg[i]) name := kit.FuncName(arg[i])
args = append(args, kit.Dict(mdb.TYPE, html.BUTTON, mdb.NAME, name, args = append(args, kit.Dict(mdb.TYPE, html.BUTTON, mdb.NAME, name, mdb.VALUE, kit.Select(name, kit.Value(trans, name), !m.IsEnglish())))
mdb.VALUE, kit.Select(name, kit.Value(trans, name), !m.IsEnglish()),
))
} }
} }
} }
for _, v := range args { kit.For(args, func(v string) { m.Push("", v, kit.Split("type,name,value,values,need,action")) })
m.Push("", v, kit.Split("type,name,value,values,need,action")) return DisplayStory(m, "form")
}
return DisplayStory(m, "form.js")
} }
func DisplayStoryJSON(m *ice.Message, arg ...ice.Any) *ice.Message { func DisplayStoryJSON(m *ice.Message, arg ...ice.Any) *ice.Message {
return DisplayStory(m, "json", arg...) return DisplayStory(m, "json", arg...)
@ -71,21 +56,20 @@ func DisplayStudio(m *ice.Message, cmd ...string) *ice.Message {
for i, k := range cmd { for i, k := range cmd {
kit.If(!strings.Contains(cmd[i], nfs.PT), func() { cmd[i] = m.Prefix(k) }) kit.If(!strings.Contains(cmd[i], nfs.PT), func() { cmd[i] = m.Prefix(k) })
} }
return DisplayStory(m.Cmdy(COMMAND, cmd), "studio.js") return DisplayStory(m.Cmdy(COMMAND, cmd), "studio")
} }
func DisplayLocal(m *ice.Message, file string, arg ...ice.Any) *ice.Message { func DisplayLocal(m *ice.Message, file string, arg ...ice.Any) *ice.Message {
kit.If(file == "", func() { file = path.Join(kit.PathName(5), kit.Keys(kit.FileName(5), nfs.JS)) }) kit.If(file == "", func() { file = strings.ReplaceAll(strings.TrimPrefix(m.PrefixKey(), "web."), nfs.PT, nfs.PS) })
kit.If(isLocalFile(file), func() { file = path.Join(ice.PLUGIN_LOCAL, file) }) kit.If(isLocalFile(file), func() { file = path.Join(ice.PLUGIN_LOCAL, file) })
return DisplayBase(m, file, arg...) return DisplayBase(m, file, arg...)
} }
func DisplayLocalInner(m *ice.Message, arg ...ice.Any) *ice.Message { func DisplayLocalInner(m *ice.Message, arg ...ice.Any) *ice.Message {
return DisplayLocal(m, "code/inner.js", arg...) return DisplayLocal(m, "code/inner", arg...)
} }
func DisplayBase(m *ice.Message, file string, arg ...ice.Any) *ice.Message { func DisplayBase(m *ice.Message, file string, arg ...ice.Any) *ice.Message {
m.Option(ice.MSG_DISPLAY, m.MergeLink(kit.Select(kit.ExtChange(file, nfs.JS), file, strings.Contains(file, mdb.QS)), arg...)) m.Option(ice.MSG_DISPLAY, m.MergeLink(kit.Select(kit.ExtChange(file, nfs.JS), file, strings.Contains(file, mdb.QS)), arg...))
Toolkit(m, "") return Toolkit(m, "")
return m
} }
func Toolkit(m *ice.Message, arg ...string) { func Toolkit(m *ice.Message, arg ...string) *ice.Message {
m.Option(ice.MSG_TOOLKIT, kit.Select(mdb.Config(m, mdb.TOOLS), kit.Fields(arg))) return m.Options(ice.MSG_TOOLKIT, kit.Select(mdb.Config(m, mdb.TOOLS), kit.Fields(arg)))
} }

12
base/gdb/gdb.go
View File

@ -5,6 +5,7 @@ import (
"os" "os"
"os/signal" "os/signal"
"syscall" "syscall"
"time"
ice "shylinux.com/x/icebergs" ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb" "shylinux.com/x/icebergs/base/mdb"
@ -14,7 +15,9 @@ import (
type Frame struct{ s chan os.Signal } type Frame struct{ s chan os.Signal }
func (f *Frame) Begin(m *ice.Message, arg ...string) { f.s = make(chan os.Signal, 10) } func (f *Frame) Begin(m *ice.Message, arg ...string) {
f.s = make(chan os.Signal, 10)
}
func (f *Frame) Start(m *ice.Message, arg ...string) { func (f *Frame) Start(m *ice.Message, arg ...string) {
kit.If(ice.Info.PidPath, func(p string) { kit.If(ice.Info.PidPath, func(p string) {
if f, p, e := logs.CreateFile(p); e == nil { if f, p, e := logs.CreateFile(p); e == nil {
@ -23,11 +26,12 @@ func (f *Frame) Start(m *ice.Message, arg ...string) {
fmt.Fprint(f, os.Getpid()) fmt.Fprint(f, os.Getpid())
} }
}) })
// t := kit.Duration(mdb.Conf(m, TIMER, kit.Keym(TICK))) t := time.NewTicker(kit.Duration(mdb.Conf(m, TIMER, kit.Keym(TICK))))
for { for {
select { select {
// case <-time.Tick(t): case <-t.C:
// m.Cmd(TIMER, HAPPEN, kit.Dict(ice.LOG_DISABLE, ice.TRUE)) m.Options(ice.LOG_DISABLE, ice.TRUE)
m.Cmd(TIMER, HAPPEN)
case s, ok := <-f.s: case s, ok := <-f.s:
if !ok { if !ok {
return return

8
base/gdb/signal.go
View File

@ -21,13 +21,7 @@ func _signal_action(m *ice.Message, arg ...string) {
mdb.HashSelect(m.Spawn(), arg...).Table(func(value ice.Maps) { m.Cmdy(kit.Split(value[ice.CMD])) }) mdb.HashSelect(m.Spawn(), arg...).Table(func(value ice.Maps) { m.Cmdy(kit.Split(value[ice.CMD])) })
} }
func _signal_process(m *ice.Message, p string, s os.Signal) { func _signal_process(m *ice.Message, p string, s os.Signal) {
if p == "" { kit.If(p == "", func() { b, _ := file.ReadFile(ice.Info.PidPath); p = string(b) })
b, _ := file.ReadFile(ice.Info.PidPath)
p = string(b)
if runtime.GOOS == ice.WINDOWS {
return
}
}
if p, e := os.FindProcess(kit.Int(kit.Select(kit.Format(os.Getpid()), p))); e == nil { if p, e := os.FindProcess(kit.Int(kit.Select(kit.Format(os.Getpid()), p))); e == nil {
p.Signal(s) p.Signal(s)
} }

15
base/gdb/timer.go
View File

@ -5,6 +5,7 @@ import (
ice "shylinux.com/x/icebergs" ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb" "shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/web/html"
kit "shylinux.com/x/toolkits" kit "shylinux.com/x/toolkits"
) )
@ -14,11 +15,10 @@ func _timer_action(m *ice.Message, now time.Time, arg ...string) {
if count == 0 || value[mdb.TIME] > now.Format(ice.MOD_TIME) { if count == 0 || value[mdb.TIME] > now.Format(ice.MOD_TIME) {
return return
} }
m.Option(ice.LOG_DISABLE, ice.FALSE) m.Options(ice.LOG_DISABLE, ice.FALSE)
// m.Cmd(ROUTINE, mdb.CREATE, mdb.NAME, value[mdb.NAME], kit.Keycb(ROUTINE), value[ice.CMD])
m.Cmd(kit.Split(value[ice.CMD])).Cost() m.Cmd(kit.Split(value[ice.CMD])).Cost()
kit.If(count < 0, func() { count++ }) kit.If(count < 0, func() { count++ })
mdb.HashModify(m, mdb.HASH, value[mdb.HASH], mdb.COUNT, count-1, mdb.TIME, m.Time(value[INTERVAL])) mdb.HashModify(m, mdb.NAME, value[mdb.NAME], mdb.COUNT, count-1, mdb.TIME, m.Time(value[INTERVAL]))
}) })
} }
@ -31,7 +31,9 @@ const TIMER = "timer"
func init() { func init() {
Index.MergeCommands(ice.Commands{ Index.MergeCommands(ice.Commands{
TIMER: {Help: "定时器", Actions: ice.MergeActions(ice.Actions{ TIMER: {Help: "定时器", Meta: kit.Dict(
ice.CTX_TRANS, kit.Dict(html.INPUT, kit.Dict(DELAY, "延时", INTERVAL, "间隔", TICK, "周期")),
), Actions: ice.MergeActions(ice.Actions{
mdb.INPUTS: {Hand: func(m *ice.Message, arg ...string) { mdb.INPUTS: {Hand: func(m *ice.Message, arg ...string) {
switch mdb.HashInputs(m, arg); arg[0] { switch mdb.HashInputs(m, arg); arg[0] {
case mdb.COUNT: case mdb.COUNT:
@ -43,7 +45,8 @@ func init() {
mdb.CREATE: {Name: "create name*=hi delay=10ms interval=10s count=3 cmd*=runtime"}, mdb.CREATE: {Name: "create name*=hi delay=10ms interval=10s count=3 cmd*=runtime"},
mdb.PRUNES: {Hand: func(m *ice.Message, arg ...string) { mdb.HashPrunesValue(m, mdb.COUNT, "0") }}, mdb.PRUNES: {Hand: func(m *ice.Message, arg ...string) { mdb.HashPrunesValue(m, mdb.COUNT, "0") }},
HAPPEN: {Hand: func(m *ice.Message, arg ...string) { _timer_action(m, time.Now(), arg...) }}, HAPPEN: {Hand: func(m *ice.Message, arg ...string) { _timer_action(m, time.Now(), arg...) }},
RESTART: {Name: "restart count=3", Hand: func(m *ice.Message, arg ...string) { mdb.HashModify(m, m.OptionSimple(mdb.HashShort(m)), arg) }}, }, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,name,delay,interval,count,cmd", TICK, "10s")), Hand: func(m *ice.Message, arg ...string) {
}, mdb.HashAction(mdb.SHORT, mdb.NAME, mdb.FIELD, "time,name,delay,interval,count,cmd", TICK, "1s"))}, mdb.HashSelect(m, arg...).StatusTimeCount(mdb.ConfigSimple(m, TICK))
}},
}) })
} }

6
base/web/dream.go
View File

@ -413,11 +413,11 @@ func init() {
if kit.HasPrefix(value, HTTP, nfs.PS) { if kit.HasPrefix(value, HTTP, nfs.PS) {
return value return value
} else if nfs.ExistsFile(m, path.Join(ice.USR_LOCAL_WORK, m.Appendv(mdb.NAME)[index], value)) { } else if nfs.ExistsFile(m, path.Join(ice.USR_LOCAL_WORK, m.Appendv(mdb.NAME)[index], value)) {
return kit.MergeURL(ctx.FileURI(value), ice.POD, m.Appendv(mdb.NAME)[index]) return m.Spawn(kit.Dict(ice.MSG_USERPOD, m.Appendv(mdb.NAME)[index])).FileURI(value)
} else if nfs.ExistsFile(m, value) { } else if nfs.ExistsFile(m, value) {
return kit.MergeURL(ctx.FileURI(value)) return m.FileURI(value)
} else { } else {
return kit.MergeURL(ctx.FileURI(nfs.USR_ICONS_ICEBERGS)) return m.FileURI(nfs.USR_ICONS_ICEBERGS)
} }
} }
return value return value

4
base/web/space.go
View File

@ -49,7 +49,7 @@ func _space_dial(m *ice.Message, dev, name string, arg ...string) {
} }
}).Cost(mdb.COUNT, i, mdb.NEXT, next, tcp.DIAL, dev, LINK, u.String()).Sleep(next) }).Cost(mdb.COUNT, i, mdb.NEXT, next, tcp.DIAL, dev, LINK, u.String()).Sleep(next)
} }
}, kit.Join(kit.Simple(SPACE, name), lex.SP)) }, kit.JoinWord(SPACE, dev))
} }
func _space_agent(m *ice.Message, args ...string) []string { func _space_agent(m *ice.Message, args ...string) []string {
kit.If(m.Option(cli.GOOS), func(p string) { args = append(args, cli.SYSTEM, p) }) kit.If(m.Option(cli.GOOS), func(p string) { args = append(args, cli.SYSTEM, p) })
@ -127,7 +127,7 @@ func _space_fork(m *ice.Message) {
}) })
} }
_space_handle(m, safe, name, c) _space_handle(m, safe, name, c)
}, kit.Join(kit.Simple(SPACE, name), lex.SP)) }, kit.JoinWord(SPACE, name))
} }
} }
func _space_handle(m *ice.Message, safe bool, name string, c *websocket.Conn) { func _space_handle(m *ice.Message, safe bool, name string, c *websocket.Conn) {

2
base/web/spide.go
View File

@ -285,7 +285,7 @@ func init() {
if p := path.Join(ice.SRC_TEMPLATE, m.PrefixKey(), path.Join(arg...)); nfs.Exists(m, p) { if p := path.Join(ice.SRC_TEMPLATE, m.PrefixKey(), path.Join(arg...)); nfs.Exists(m, p) {
return p + kit.Select("", nfs.PS, len(arg) == 0) return p + kit.Select("", nfs.PS, len(arg) == 0)
} else { } else {
return kit.MergeURL(ctx.FileURI(path.Join(path.Dir(ctx.GetCmdFile(m, m.PrefixKey())), path.Join(arg...))), ice.POD, m.Option(ice.MSG_USERPOD)) return m.FileURI(path.Join(path.Dir(ctx.GetCmdFile(m, m.PrefixKey())), path.Join(arg...)))
// return path.Join(path.Dir(ctx.GetCmdFile(m, m.PrefixKey())), path.Join(arg...)) + kit.Select("", nfs.PS, len(arg) == 0) // return path.Join(path.Dir(ctx.GetCmdFile(m, m.PrefixKey())), path.Join(arg...)) + kit.Select("", nfs.PS, len(arg) == 0)
} }
} }

2
base/web/web.go
View File

@ -52,7 +52,7 @@ func (f *Frame) Start(m *ice.Message, arg ...string) {
f.HandleFunc(key, func(w http.ResponseWriter, r *http.Request) { f.HandleFunc(key, func(w http.ResponseWriter, r *http.Request) {
m.Spawn(key, cmd, c, w, r).TryCatch(true, func(msg *ice.Message) { _serve_handle(key, cmd, msg, w, r) }) m.Spawn(key, cmd, c, w, r).TryCatch(true, func(msg *ice.Message) { _serve_handle(key, cmd, msg, w, r) })
}) })
ice.Info.Route[path.Join(list[c], key)+kit.Select("", nfs.PS, strings.HasSuffix(key, nfs.PS))] = ctx.FileURI(cmd.FileLine()) ice.Info.Route[path.Join(list[c], key)+kit.Select("", nfs.PS, strings.HasSuffix(key, nfs.PS))] = m.FileURI(cmd.FileLine())
}(key, cmd) }(key, cmd)
} }
}) })

3
base/yac/value.go
View File

@ -8,7 +8,6 @@ import (
"strings" "strings"
ice "shylinux.com/x/icebergs" ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/lex" "shylinux.com/x/icebergs/base/lex"
"shylinux.com/x/icebergs/base/mdb" "shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs" "shylinux.com/x/icebergs/base/nfs"
@ -458,7 +457,7 @@ func (m Message) Call(cmd string, arg ...Any) Any {
} else if !strings.HasPrefix(file, nfs.PS) && !strings.HasPrefix(file, ice.HTTP) { } else if !strings.HasPrefix(file, nfs.PS) && !strings.HasPrefix(file, ice.HTTP) {
file = path.Join(path.Dir(kit.Split(_parse_stack(m.Message).name, nfs.DF)[0]), file) file = path.Join(path.Dir(kit.Split(_parse_stack(m.Message).name, nfs.DF)[0]), file)
} }
m.Display(ctx.FileURI(file), arg[1:]...) m.Display(m.FileURI(file), arg[1:]...)
case "DebugStack": case "DebugStack":
list := []string{} list := []string{}
s := _parse_stack(m.Message) s := _parse_stack(m.Message)

4
core/chat/macos/macos.go
View File

@ -53,7 +53,7 @@ func PodCmdAction(arg ...string) ice.Actions {
file := kit.FileLine(2, 100) file := kit.FileLine(2, 100)
return ice.Actions{ return ice.Actions{
mdb.SELECT: {Name: "list hash auto create", Hand: func(m *ice.Message, arg ...string) { mdb.SELECT: {Name: "list hash auto create", Hand: func(m *ice.Message, arg ...string) {
defer m.Display(ctx.FileURI(file)) defer m.Display(m.FileURI(file))
msg := disableApp(mdb.HashSelect(m.Spawn(), arg...).Sort(mdb.NAME)) msg := disableApp(mdb.HashSelect(m.Spawn(), arg...).Sort(mdb.NAME))
web.PushPodCmd(msg, m.PrefixKey(), arg...) web.PushPodCmd(msg, m.PrefixKey(), arg...)
has := map[string]bool{} has := map[string]bool{}
@ -75,7 +75,7 @@ func CmdHashAction(arg ...string) ice.Actions {
} }
}}, }},
mdb.SELECT: {Hand: func(m *ice.Message, arg ...string) { mdb.SELECT: {Hand: func(m *ice.Message, arg ...string) {
disableApp(mdb.HashSelect(m, arg...).Sort(mdb.NAME).Display(ctx.FileURI(file))) disableApp(mdb.HashSelect(m, arg...).Sort(mdb.NAME).Display(m.FileURI(file)))
}}, }},
}, mdb.HashAction(mdb.SHORT, kit.Select("", arg, 0), mdb.FIELD, kit.Select("time,hash,icon,name,text,space,index,args", arg, 1), kit.Slice(arg, 2))) }, mdb.HashAction(mdb.SHORT, kit.Select("", arg, 0), mdb.FIELD, kit.Select("time,hash,icon,name,text,space,index,args", arg, 1), kit.Slice(arg, 2)))
} }

2
core/wiki/portal.go
View File

@ -52,7 +52,7 @@ func _portal_commands(m *ice.Message, arg ...string) {
if p := path.Join(nfs.USR_LEARNING_PORTAL, path.Join(arg...), mod, last, strings.Replace(cmd, nfs.PT, nfs.PS, -1)+".shy"); nfs.Exists(m, p) { if p := path.Join(nfs.USR_LEARNING_PORTAL, path.Join(arg...), mod, last, strings.Replace(cmd, nfs.PT, nfs.PS, -1)+".shy"); nfs.Exists(m, p) {
text = append(text, kit.Format(" %s %s.shy", cmd, cmd)) text = append(text, kit.Format(" %s %s.shy", cmd, cmd))
} else if p, ok := help[last+nfs.PT+cmd]; ok { } else if p, ok := help[last+nfs.PT+cmd]; ok {
text = append(text, kit.Format(" %s %s", cmd, strings.TrimPrefix(ctx.FileURI(p), "/require/"))) text = append(text, kit.Format(" %s %s", cmd, strings.TrimPrefix(m.FileURI(p), "/require/")))
} }
} }
} }

2
core/wiki/wiki.go
View File

@ -41,7 +41,7 @@ func _wiki_list(m *ice.Message, arg ...string) bool {
m.Copy(m.Cmd(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.CAT, nfs.DIR_REG, mdb.Config(m, lex.REGEXP))).SortStr(nfs.PATH)) m.Copy(m.Cmd(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.CAT, nfs.DIR_REG, mdb.Config(m, lex.REGEXP))).SortStr(nfs.PATH))
return true return true
} else { } else {
ctx.Display(m, ctx.FileURI(nfs.Relative(m, ctx.GetCmdFile(m, m.PrefixKey())))) m.Display(m.FileURI(nfs.Relative(m, ctx.GetCmdFile(m, m.PrefixKey()))))
// ctx.DisplayLocal(m, path.Join(kit.PathName(2), kit.Keys(kit.FileName(2), nfs.JS))) // ctx.DisplayLocal(m, path.Join(kit.PathName(2), kit.Keys(kit.FileName(2), nfs.JS)))
return false return false
} }

4
info.go
View File

@ -304,7 +304,7 @@ func Module(prefix string, arg ...Any) {
return m return m
} }
} }
func FileURI(dir string) string { func (m *Message) FileURI(dir string) string {
if dir == "" { if dir == "" {
return "" return ""
} else if strings.Contains(dir, "/pkg/mod/") { } else if strings.Contains(dir, "/pkg/mod/") {
@ -321,6 +321,6 @@ func FileURI(dir string) string {
if strings.HasPrefix(dir, USR_VOLCANOS) { if strings.HasPrefix(dir, USR_VOLCANOS) {
return strings.TrimPrefix(dir, USR) return strings.TrimPrefix(dir, USR)
} else { } else {
return path.Join(PS, REQUIRE, dir) return kit.MergeURL(path.Join(PS, REQUIRE, dir), POD, m.Option(MSG_USERPOD))
} }
} }

8
misc.go
View File

@ -159,6 +159,14 @@ func (m *Message) CmdMap(arg ...string) map[string]map[string]string {
func (m *Message) Toast(content string, arg ...string) { // title duration func (m *Message) Toast(content string, arg ...string) { // title duration
Info.PushNotice(m, "toast", content, arg) Info.PushNotice(m, "toast", content, arg)
} }
func (m *Message) PushStream() *Message { return Info.PushStream(m) }
func (m *Message) ToastSuccess(arg ...string) { m.Toast(SUCCESS, arg...) }
func (m *Message) ToastFailure(arg ...string) { m.Toast(FAILURE, arg...) }
func (m *Message) ToastProcess(arg ...string) func(...string) {
kit.If(len(arg) == 0, func() { arg = append(arg, "", "-1") })
m.Toast(PROCESS, arg...)
return func(arg ...string) { m.ToastSuccess(arg...) }
}
func (m *Message) Trans(en string, zh string) string { func (m *Message) Trans(en string, zh string) string {
switch strings.ToLower(kit.Select("", kit.Split(m.Option(MSG_LANGUAGE), "_-"), 0)) { switch strings.ToLower(kit.Select("", kit.Split(m.Option(MSG_LANGUAGE), "_-"), 0)) {
case "zh": case "zh":

2
misc/wx/ide.go
View File

@ -58,7 +58,7 @@ func _ide_autogen_pages(m *ice.Message) {
head_wxml, foot_wxml, wxml := nfs.TemplateText(m, "pages_head.wxml"), nfs.TemplateText(m, "pages_foot.wxml"), nfs.TemplateText(m, "pages.wxml") head_wxml, foot_wxml, wxml := nfs.TemplateText(m, "pages_head.wxml"), nfs.TemplateText(m, "pages_foot.wxml"), nfs.TemplateText(m, "pages.wxml")
m.Travel(func(_ *ice.Context, s *ice.Context, key string, cmd *ice.Command) { m.Travel(func(_ *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
if h, ok := cmd.Actions[PAGES]; ok { if h, ok := cmd.Actions[PAGES]; ok {
file := path.Join(path.Dir(strings.TrimPrefix(m.Resource(ctx.FileURI(cmd.FileLine())), nfs.REQUIRE)), kit.Select(key+".js", h.Name)) file := path.Join(path.Dir(strings.TrimPrefix(m.Resource(m.FileURI(cmd.FileLine())), nfs.REQUIRE)), kit.Select(key+".js", h.Name))
if !nfs.Exists(m, file) { if !nfs.Exists(m, file) {
return return
} }