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

opt mdb

Browse Source
This commit is contained in:
IT 老营长 @云轩领航-创始人 2023-03-23 00:13:29 +08:00
parent 82f59f190b
commit 860f79496a
69 changed files with 427 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
base/aaa/totp.go
View File

@ -68,7 +68,7 @@ func init() {
m.Push(mdb.EXPIRE, period-time.Now().Unix()%period)
m.Push(mdb.VALUE, _totp_get(value[SECRET], period, kit.Int(value[NUMBER])))
if len(arg) > 0 {
m.PushQRCode(mdb.SCAN, kit.Format(m.Config(mdb.LINK), value[mdb.NAME], value[SECRET]))
m.PushQRCode(mdb.SCAN, kit.Format(mdb.Config(m, mdb.LINK), value[mdb.NAME], value[SECRET]))
m.Echo(m.Append(mdb.VALUE))
} else {
m.PushAction(mdb.REMOVE)

2
base/aaa/user.go
View File

@ -63,7 +63,7 @@ func init() {
LOGIN: {Name: "login username* password", Hand: func(m *ice.Message, arg ...string) {
_user_login(m, m.Option(USERNAME), m.Option(PASSWORD))
}},
}, mdb.HashSearchAction(mdb.SHORT, USERNAME, mdb.FIELD, "time,username,usernick,userzone,userrole"), mdb.ImportantDataAction())},
}, mdb.HashAction(mdb.SHORT, USERNAME, mdb.FIELD, "time,username,usernick,userzone,userrole"), mdb.ImportantDataAction())},
})
}

5
base/cli/forever.go
View File

@ -67,10 +67,7 @@ func init() {
defer logs.Println(ice.EXIT)
break
}
if logs.Println(); m.Sleep("1s").Config("log.save") == ice.TRUE {
back := kit.Format("var/log.%s", logs.Now().Format("20060102_150405"))
m.Cmd(SYSTEM, "cp", "-r", "var/log", back, ice.Maps{CMD_OUTPUT: ""})
}
logs.Println()
}
}},
})

2
base/cli/mirrors.go
View File

@ -28,7 +28,7 @@ func init() {
MIRRORS: {Name: "mirrors cli auto", Help: "软件镜像", Actions: ice.MergeActions(ice.Actions{
mdb.INSERT: {Name: "insert cli* osid cmd*"},
CMD: {Name: "cmd cli osid", Hand: func(m *ice.Message, arg ...string) {
osid := kit.Select(m.Conf(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) {
if osid != "" && strings.Contains(osid, kit.Format(value[OSID])) {
m.Cmdy(kit.Split(kit.Format(value[CMD])))

46
base/cli/runtime.go
View File

@ -124,9 +124,7 @@ const (
MAKE_DOMAIN = "make.domain"
)
var ENV_LIST = []string{
TERM, SHELL, CTX_SHY, CTX_COM, CTX_DEV, CTX_OPS, CTX_ARG, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER, CTX_DAEMON,
}
var ENV_LIST = []string{TERM, SHELL, CTX_SHY, CTX_COM, CTX_DEV, CTX_OPS, CTX_ARG, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER, CTX_DAEMON}
const (
HOSTNAME = "hostname"
@ -147,16 +145,16 @@ const RUNTIME = "runtime"
func init() {
Index.MergeCommands(ice.Commands{
RUNTIME: {Name: "runtime info=bootinfo,ifconfig,hostinfo,hostname,userinfo,procinfo,diskinfo,api,cli,cmd,env,path,chain auto upgrade", Help: "运行环境", Actions: ice.MergeActions(ice.Actions{
RUNTIME: {Name: "runtime info=bootinfo,ifconfig,hostname,hostinfo,userinfo,procinfo,diskinfo,api,cli,cmd,env,path,chain auto", Help: "运行环境", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { _runtime_init(m) }},
IFCONFIG: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy("tcp.host") }},
HOSTINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_hostinfo(m) }},
HOSTNAME: {Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 {
ice.Info.Hostname = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), m.Conf(RUNTIME, kit.Keys(NODE, mdb.NAME), arg[0]))
ice.Info.Hostname = mdb.Conf(m, RUNTIME, kit.Keys(BOOT, HOSTNAME), mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.NAME), arg[0]))
}
m.Echo(ice.Info.Hostname)
}},
HOSTINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_hostinfo(m) }},
USERINFO: {Hand: func(m *ice.Message, arg ...string) { m.Split(m.Cmdx(SYSTEM, "who"), "user term time") }},
PROCINFO: {Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd("", HOSTINFO)
@ -165,12 +163,17 @@ func init() {
}},
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) {
if len(arg) > 0 {
runtime.GOMAXPROCS(kit.Int(m.Conf(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))
}},
DISKINFO: {Hand: func(m *ice.Message, arg ...string) { _runtime_diskinfo(m) }},
MAKE_DOMAIN: {Hand: func(m *ice.Message, arg ...string) {
if os.Getenv(CTX_DEV) == "" || os.Getenv(CTX_POD) == "" {
m.Echo(mdb.Conf(m, RUNTIME, MAKE_DOMAIN))
} else {
m.Echo(kit.MergePOD(os.Getenv(CTX_DEV), os.Getenv(CTX_POD)))
}
}},
API: {Hand: func(m *ice.Message, arg ...string) {
kit.For(ice.Info.Route, func(k, v string) { m.Push(nfs.PATH, k).Push(nfs.FILE, v) })
m.StatusTimeCount().Sort(nfs.PATH)
@ -190,38 +193,19 @@ func init() {
})
m.StatusTimeCount().Sort(mdb.NAME)
}},
MAKE_DOMAIN: {Hand: func(m *ice.Message, arg ...string) {
if os.Getenv(CTX_DEV) == "" || os.Getenv(CTX_POD) == "" {
m.Echo(m.Conf(RUNTIME, MAKE_DOMAIN))
} else {
m.Echo(kit.MergePOD(os.Getenv(CTX_DEV), os.Getenv(CTX_POD)))
}
}},
nfs.PATH: {Hand: func(m *ice.Message, arg ...string) {
for _, p := range _path_split(os.Getenv(PATH)) {
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()) }},
"upgrade": {Hand: func(m *ice.Message, arg ...string) {
file := kit.Keys("ice", runtime.GOOS, runtime.GOARCH)
_file := file
if runtime.GOOS == WINDOWS {
_file = file + "." + m.Time() + ".exe"
}
m.Cmd("web.spide", "dev", "save", _file, "GET", ice.Info.Make.Domain+"/publish/"+file)
}},
}, ctx.ConfAction("")), Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 0 && arg[0] == BOOTINFO {
arg = arg[1:]
}
kit.If(len(arg) > 0 && arg[0] == BOOTINFO, func() { arg = arg[1:] })
m.Cmdy(ctx.CONFIG, RUNTIME, arg)
ctx.DisplayStoryJSON(m)
}},
})
}
func NodeInfo(m *ice.Message, arg ...string) {
m.Conf(RUNTIME, kit.Keys(NODE, mdb.TIME), m.Time())
mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.TIME), m.Time())
ice.Info.NodeName = mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.NAME), kit.Select(ice.Info.NodeName, arg, 0))
ice.Info.NodeType = mdb.Conf(m, RUNTIME, kit.Keys(NODE, mdb.TYPE), kit.Select(ice.Info.NodeType, arg, 1))
}

49
base/ctx/config.go
View File

@ -70,12 +70,12 @@ func _config_make(m *ice.Message, key string, arg ...string) {
if strings.HasPrefix(arg[1], ice.AT) {
arg[1] = msg.Cmdx(nfs.CAT, arg[1][1:])
}
msg.Confv(key, arg[0], kit.Parse(nil, "", arg[1:]...))
mdb.Confv(msg, key, arg[0], kit.Parse(nil, "", arg[1:]...))
}
if len(arg) > 0 {
m.Echo(kit.Formats(msg.Confv(key, arg[0])))
m.Echo(kit.Formats(mdb.Confv(msg, key, arg[0])))
} else {
m.Echo(kit.Formats(msg.Confv(key)))
m.Echo(kit.Formats(mdb.Confv(msg, key)))
}
}
func _config_list(m *ice.Message) {
@ -96,28 +96,27 @@ const CONFIG = "config"
func init() {
Index.MergeCommands(ice.Commands{
CONFIG: {Name: "config key auto remove", Help: "配置", Actions: ice.Actions{
CONFIG: {Name: "config key auto export import trash", Help: "配置", Actions: ice.Actions{
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:]...) }},
mdb.EXPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(mdb.EXPORT, arg[0], "", mdb.HASH) }},
mdb.IMPORT: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(mdb.IMPORT, arg[0], "", mdb.HASH) }},
nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.EXPORT, arg[0], "", mdb.HASH, path.Join(ice.VAR_TRASH, kit.Keys(arg[0])))
nfs.Trash(m, path.Join(ice.VAR_DATA, arg[0]))
m.Go(func() { m.Cmd(ice.EXIT, 1) })
}},
mdb.LIST: {Hand: func(m *ice.Message, arg ...string) {
list := []ice.Any{}
for _, v := range arg[2:] {
list = append(list, v)
}
m.Confv(arg[0], arg[1], list)
}},
mdb.REMOVE: {Name: "remove key sub", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(mdb.EXPORT, m.Option(mdb.KEY), m.Option(mdb.SUB), mdb.HASH, path.Join(ice.VAR_TRASH, kit.Keys(m.Option(mdb.KEY), m.Option(mdb.SUB))))
nfs.Trash(m, path.Join(ice.VAR_DATA, m.Option(mdb.KEY)))
m.Go(func() { m.Cmd(ice.EXIT, 1) })
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) {
if len(arg) == 0 {
_config_list(m)
} else {
_config_make(m, arg[0], arg[1:]...)
DisplayStoryJSON(m)
m.Action(mdb.REMOVE)
// DisplayStoryJSON(m)
}
}},
})
@ -148,17 +147,21 @@ func Load(m *ice.Message, arg ...string) *ice.Message {
}
return m.Cmd(CONFIG, LOAD, m.Prefix(nfs.JSON), arg)
}
func ConfAction(args ...ice.Any) ice.Actions {
return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(args...)}
func ConfAction(arg ...ice.Any) ice.Actions {
return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(arg...)}
}
func ConfigAuto(m *ice.Message, arg ...string) {
if cs := m.Target().Configs; cs[m.CommandKey()] == nil {
cs[m.CommandKey()] = &ice.Config{Value: kit.Data()}
ice.Info.Load(m, m.CommandKey())
}
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)) })
return
}
func ConfigFromOption(m *ice.Message, arg ...string) {
for _, k := range arg {
m.Config(k, kit.Select(m.Config(k), m.Option(k)))
mdb.Config(m, k, kit.Select(mdb.Config(m, k), m.Option(k)))
}
}
func OptionFromConfig(m *ice.Message, arg ...string) string {
for _, key := range arg {
m.Option(key, mdb.Config(m, key))
}
return m.Option(arg[0])
}

19
base/ctx/display.go
View File

@ -11,11 +11,12 @@ import (
"shylinux.com/x/toolkits/logs"
)
type Message interface {
type displayMessage interface {
Option(key string, arg ...ice.Any) string
Action(arg ...ice.Any) *ice.Message
}
func Display(m Message, file string, arg ...ice.Any) Message {
func Display(m displayMessage, file string, arg ...ice.Any) displayMessage {
if file == "" {
file = kit.Keys(kit.FileName(2), nfs.JS)
}
@ -24,13 +25,13 @@ func Display(m Message, file string, arg ...ice.Any) Message {
}
return DisplayBase(m, file, arg...)
}
func DisplayTable(m Message, arg ...ice.Any) Message {
func DisplayTable(m displayMessage, arg ...ice.Any) displayMessage {
return DisplayBase(m, "/plugin/table.js", arg...)
}
func DisplayTableCard(m Message, arg ...ice.Any) Message {
func DisplayTableCard(m displayMessage, arg ...ice.Any) displayMessage {
return DisplayTable(m, "style", "card")
}
func DisplayStory(m Message, file string, arg ...ice.Any) Message {
func DisplayStory(m displayMessage, file string, arg ...ice.Any) displayMessage {
if file == "" {
file = kit.ExtChange(kit.FileName(2), nfs.JS)
}
@ -39,13 +40,13 @@ func DisplayStory(m Message, file string, arg ...ice.Any) Message {
}
return DisplayBase(m, file, arg...)
}
func DisplayStoryJSON(m Message, arg ...ice.Any) Message {
func DisplayStoryJSON(m displayMessage, arg ...ice.Any) displayMessage {
return DisplayStory(m, "json", arg...)
}
func DisplayStorySpide(m Message, arg ...ice.Any) Message {
func DisplayStorySpide(m displayMessage, arg ...ice.Any) displayMessage {
return DisplayStory(m, "spide", arg...)
}
func DisplayLocal(m Message, file string, arg ...ice.Any) Message {
func DisplayLocal(m displayMessage, file string, arg ...ice.Any) displayMessage {
if file == "" {
file = path.Join(kit.PathName(2), kit.Keys(kit.FileName(2), ice.JS))
}
@ -54,7 +55,7 @@ func DisplayLocal(m Message, file string, arg ...ice.Any) Message {
}
return DisplayBase(m, file, arg...)
}
func DisplayBase(m Message, file string, arg ...ice.Any) Message {
func DisplayBase(m displayMessage, file string, arg ...ice.Any) displayMessage {
m.Option(ice.MSG_DISPLAY, kit.MergeURL(kit.Select(kit.ExtChange(file, nfs.JS), file, strings.Contains(file, "?")), arg...))
return m
}

5
base/gdb/gdb.go
View File

@ -5,6 +5,7 @@ import (
"time"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
kit "shylinux.com/x/toolkits"
)
@ -19,11 +20,11 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
enable := mdb.Conf(m, TIMER, kit.Keym("enable")) == ice.TRUE
for {
select {
case <-time.Tick(t):
case <-time.Tick(t):
if enable {
m.Cmd(TIMER, HAPPEN)
}
case s, ok := &lt;-f.s:
case s, ok := <-f.s:
if !ok {
return true
}

10
base/log/log.go
View File

@ -37,7 +37,7 @@ func (f *Frame) Start(m *ice.Message, arg ...string) bool {
if file == "" {
continue
}
view := m.Confm(VIEW, m.Conf(SHOW, kit.Keys(l.l, VIEW)))
view := mdb.Confm(m, VIEW, m.Conf(SHOW, kit.Keys(l.l, VIEW)))
bio := m.Confv(FILE, kit.Keys(file, FILE)).(*bufio.Writer)
if bio == nil {
continue
@ -105,16 +105,16 @@ var Index = &ice.Context{Name: LOG, Help: "日志模块", Configs: ice.Configs{
SHOW: {Name: SHOW, Help: "日志分流", Value: kit.Dict()},
}, Commands: ice.Commands{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Confm(FILE, nil, func(key string, value ice.Map) {
kit.Fetch(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, FILE), key) })
mdb.Confm(m, FILE, nil, func(key string, value ice.Map) {
kit.For(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, FILE), key) })
if f, p, e := logs.CreateFile(kit.Format(value[nfs.PATH])); e == nil {
m.Cap(ice.CTX_STREAM, path.Base(p))
value[FILE] = bufio.NewWriter(f)
m.Logs(nfs.SAVE, nfs.FILE, p)
}
})
m.Confm(VIEW, nil, func(key string, value ice.Map) {
kit.Fetch(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, VIEW), key) })
mdb.Confm(m, VIEW, nil, func(key string, value ice.Map) {
kit.For(value[mdb.LIST], func(index int, k string) { m.Conf(SHOW, kit.Keys(k, VIEW), key) })
})
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) {}},

87
base/mdb/hash.go
View File

@ -19,9 +19,7 @@ func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
list := map[string]int{}
defer func() {
delete(list, "")
for k, i := range list {
m.Push(field, k).Push(COUNT, i)
}
kit.For(list, func(k string, i int) { m.Push(field, k).Push(COUNT, i) })
m.SortIntR(COUNT)
}()
defer RLock(m, prefix, chain)()
@ -37,12 +35,11 @@ func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) string {
arg = kit.Simple(TIME, m.Time(expire), arg)
}
if arg[0] == HASH {
m.Conf(prefix, kit.Keys(chain, HASH, arg[1]), kit.Data(arg[2:]))
m.Echo(arg[1])
m.Echo(arg[1]).Conf(prefix, kit.Keys(chain, HASH, arg[1]), kit.Data(arg[2:]))
} else {
m.Echo(Rich(m, prefix, chain, kit.Data(arg, TARGET, m.Optionv(TARGET))))
}
SaveImportant(m, prefix, chain, kit.Simple(INSERT, prefix, chain, HASH, TIME, m.Time(), HASH, m.Result(), arg)...)
saveImportant(m, prefix, chain, kit.Simple(INSERT, prefix, chain, HASH, HASH, m.Result(), TIME, m.Time(), arg)...)
return m.Result()
}
func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
@ -51,8 +48,8 @@ func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
if target, ok := kit.GetMeta(val)[TARGET].(io.Closer); ok {
target.Close()
}
saveImportant(m, prefix, chain, kit.Simple(DELETE, prefix, chain, HASH, HASH, key)...)
m.Logs(DELETE, KEY, path.Join(prefix, chain), field, value, VALUE, kit.Format(val))
SaveImportant(m, prefix, chain, kit.Simple(DELETE, prefix, chain, HASH, HASH, key)...)
m.Conf(prefix, kit.Keys(chain, HASH, key), "")
})
}
@ -60,14 +57,12 @@ func _hash_modify(m *ice.Message, prefix, chain string, field, value string, arg
m.Logs(MODIFY, KEY, path.Join(prefix, chain), field, value, arg)
defer Lock(m, prefix, chain)()
Richs(m, prefix, chain, value, func(key string, val Map) {
SaveImportant(m, prefix, chain, kit.Simple(MODIFY, prefix, chain, HASH, HASH, key, arg)...)
saveImportant(m, prefix, chain, kit.Simple(MODIFY, prefix, chain, HASH, HASH, key, arg)...)
_mdb_modify(m, val, field, arg...)
})
}
func _hash_select(m *ice.Message, prefix, chain, field, value string) {
if field == HASH && value == RANDOM {
value = RANDOMS
}
kit.If(field == HASH && value == RANDOM, func() { value = RANDOMS })
defer m.SortTimeR(TIME)
fields := _hash_fields(m)
defer RLock(m, prefix, chain)()
@ -90,14 +85,10 @@ func _hash_prunes(m *ice.Message, prefix, chain string, arg ...string) {
Richs(m, prefix, chain, FOREACH, func(key string, value Map) {
switch value = kit.GetMeta(value); cb := m.OptionCB(PRUNES).(type) {
case func(string, Map) bool:
if cb(key, value) {
m.Push(key, value, fields)
}
kit.If(cb(key, value), func() { m.Push(key, value, fields) })
default:
kit.Fetch(arg, func(k, v string) {
if value[k] == v || kit.Value(value, k) == v {
m.Push(key, value, fields)
}
kit.For(arg, func(k, v string) {
kit.If(value[k] == v || kit.Value(value, k) == v, func() { m.Push(key, value, fields) })
})
}
})
@ -108,7 +99,7 @@ func _hash_export(m *ice.Message, prefix, chain, file string) {
m.Assert(e)
defer f.Close()
defer m.Echo(p)
m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p, COUNT, len(m.Confm(prefix, kit.Keys(chain, HASH))))
m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p, COUNT, len(Confm(m, prefix, kit.Keys(chain, HASH))))
en := json.NewEncoder(f)
if en.SetIndent("", " "); !m.Warn(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))), EXPORT, prefix) {
m.Conf(prefix, kit.Keys(chain, HASH), "")
@ -121,22 +112,16 @@ func _hash_import(m *ice.Message, prefix, chain, file string) {
return
}
defer f.Close()
list := Map{}
m.Assert(json.NewDecoder(f).Decode(&list))
m.Logs(IMPORT, KEY, path.Join(prefix, chain), FILE, kit.Keys(file, JSON), COUNT, len(list))
defer m.Echo("%d", len(list))
for k, data := range list {
if m.Confv(prefix, kit.Keys(chain, HASH, k)) == nil {
m.Confv(prefix, kit.Keys(chain, HASH, k), data)
} else {
Rich(m, prefix, chain, data)
}
}
data := Map{}
m.Assert(json.NewDecoder(f).Decode(&data))
m.Logs(IMPORT, KEY, path.Join(prefix, chain), FILE, kit.Keys(file, JSON), COUNT, len(data))
defer m.Echo("%d", len(data))
kit.For(data, func(k string, v Any) { m.Confv(prefix, kit.Keys(chain, HASH, k), v) })
}
const (
MONTH = "720h"
WEEK = "24h"
DAYS = "72h"
HOUR = "1h"
)
const (
@ -145,8 +130,7 @@ const (
const HASH = "hash"
func HashAction(arg ...Any) ice.Actions {
return ice.Actions{
ice.CTX_INIT: AutoConfig(append(kit.List(FIELD, HASH_FIELD), arg...)...),
return ice.Actions{ice.CTX_INIT: AutoConfig(append(kit.List(FIELD, HASH_FIELD), arg...)...),
ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
INPUTS: {Hand: func(m *ice.Message, arg ...string) { HashInputs(m, arg) }},
@ -184,11 +168,11 @@ func HashInputs(m *ice.Message, arg ...Any) *ice.Message {
return m.Cmdy(INPUTS, m.PrefixKey(), "", HASH, arg)
}
func HashCreate(m *ice.Message, arg ...Any) string {
kit.If(len(arg) == 0 || len(kit.Simple(arg)) == 0, func() { arg = append(arg, m.OptionSimple(strings.Replace(HashField(m), "hash,", "", 1))) })
kit.If(len(arg) == 0 || len(kit.Simple(arg...)) == 0, func() { arg = append(arg, m.OptionSimple(strings.Replace(HashField(m), "hash,", "", 1))) })
return m.Echo(m.Cmdx(append(kit.List(INSERT, m.PrefixKey(), "", HASH, logs.FileLineMeta(-1)), arg...)...)).Result()
}
func HashRemove(m *ice.Message, arg ...Any) *ice.Message {
if args := kit.Simple(arg); len(args) == 0 {
if args := kit.Simple(arg...); len(args) == 0 {
arg = append(arg, m.OptionSimple(HashKey(m)))
} else if len(args) == 1 {
arg = kit.List(HashKey(m), args[0])
@ -214,7 +198,7 @@ func HashSelect(m *ice.Message, arg ...string) *ice.Message {
return m.StatusTime()
}
func HashPrunes(m *ice.Message, cb func(Map) bool) *ice.Message {
expire := kit.Select(m.Time("-"+kit.Select("72h", m.Config(EXPIRE))), m.Option("before"))
expire := kit.Select(m.Time("-"+kit.Select(DAYS, Config(m, EXPIRE))), m.Option("before"))
m.OptionCB(PRUNES, func(key string, value Map) bool {
if kit.Format(value[TIME]) > expire {
return false
@ -236,32 +220,32 @@ func HashSelects(m *ice.Message, arg ...string) *ice.Message {
}
func HashSelectValue(m *ice.Message, cb Any) *ice.Message {
m.OptionFields(Config(m, FIELD))
defer RLock(m, m.PrefixKey(), "")()
defer RLock(m, m.PrefixKey())()
Richs(m, m.PrefixKey(), nil, FOREACH, func(key string, value Map) { _mdb_select(m, cb, key, value, nil, nil) })
return m
}
func HashSelectUpdate(m *ice.Message, key string, cb Any) *ice.Message {
defer Lock(m, m.PrefixKey(), "")()
defer Lock(m, m.PrefixKey())()
Richs(m, m.PrefixKey(), nil, key, func(key string, value Map) { _mdb_select(m, cb, key, value, nil, nil) })
return m
}
func HashSelectDetail(m *ice.Message, key string, cb Any) (has bool) {
defer RLock(m, m.PrefixKey(), "")()
defer RLock(m, m.PrefixKey())()
Richs(m, m.PrefixKey(), nil, key, func(key string, value Map) {
_mdb_select(m, cb, key, value, nil, nil)
has = true
})
return
}
func HashSelectDetails(m *ice.Message, key string, cb func(ice.Map) bool) ice.Map {
func HashSelectDetails(m *ice.Message, key string, cb func(Map) bool) Map {
val := kit.Dict()
HashSelectDetail(m, key, func(value ice.Map) {
kit.If(cb(value), func() { kit.For(value, func(k string, v ice.Any) { val[k] = v }) })
HashSelectDetail(m, key, func(value Map) {
kit.If(cb(value), func() { kit.For(value, func(k string, v Any) { val[k] = v }) })
})
return val
}
func HashSelectField(m *ice.Message, key string, field string) (value string) {
HashSelectDetail(m, key, func(key string, val ice.Map) {
HashSelectDetail(m, key, func(key string, val Map) {
if field == HASH {
value = key
} else {
@ -271,12 +255,12 @@ func HashSelectField(m *ice.Message, key string, field string) (value string) {
return
}
func HashSelectTarget(m *ice.Message, key string, create Any) (target Any) {
HashSelectUpdate(m, key, func(value ice.Map) {
HashSelectUpdate(m, key, func(value Map) {
target = value[TARGET]
if _target, ok := target.([]string); ok && len(_target) == 0 {
target = nil
}
if _target, ok := target.(ice.List); ok && len(_target) == 0 {
if _target, ok := target.(List); ok && len(_target) == 0 {
target = nil
}
if _target, ok := target.(Map); ok && len(_target) == 0 {
@ -286,22 +270,21 @@ func HashSelectTarget(m *ice.Message, key string, create Any) (target Any) {
return
}
switch create := create.(type) {
case func(ice.Map) ice.Any:
case func(Map) Any:
target = create(value)
case func(ice.Maps) ice.Any:
case func(Maps) Any:
target = create(ToMaps(value))
case func() ice.Any:
case func() Any:
target = create()
default:
m.ErrorNotImplement(create)
return
}
value[TARGET] = target
})
return
}
func HashSelectClose(m *ice.Message) *ice.Message {
HashSelectValue(m, func(value ice.Map) {
HashSelectValue(m, func(value Map) {
if c, ok := value[TARGET].(io.Closer); ok {
c.Close()
}
@ -322,7 +305,7 @@ func HashModifyDeferRemove(m *ice.Message, arg ...Any) func() {
}
func Richs(m *ice.Message, prefix string, chain Any, raw Any, cb Any) (res Map) {
cache := m.Confm(prefix, chain)
cache := Confm(m, prefix, chain)
if cache == nil {
return nil
}
@ -330,7 +313,7 @@ func Richs(m *ice.Message, prefix string, chain Any, raw Any, cb Any) (res Map)
}
func Rich(m *ice.Message, prefix string, chain Any, data Any) string {
cache := m.Confm(prefix, chain)
cache := Confm(m, prefix, chain)
if cache == nil {
cache = kit.Data()
m.Confv(prefix, chain, cache)

16
base/mdb/list.go
View File

@ -17,9 +17,7 @@ func _list_inputs(m *ice.Message, prefix, chain string, field, value string) {
list := map[string]int{}
defer func() {
delete(list, "")
for k, i := range list {
m.Push(field, k).Push(COUNT, i)
}
kit.For(list, func(k string, i int) { m.Push(field, k).Push(COUNT, i) })
m.SortIntR(COUNT)
}()
defer RLock(m, prefix, chain)()
@ -57,9 +55,7 @@ func _list_export(m *ice.Message, prefix, chain, file string) {
count, head := 0, kit.Split(ListField(m))
Grows(m, prefix, chain, "", "", func(index int, value ice.Map) {
if value = kit.GetMeta(value); index == 0 {
if len(head) == 0 || head[0] == ice.FIELDS_DETAIL {
head = kit.SortedKey(value)
}
kit.If(len(head) == 0 || head[0] == ice.FIELDS_DETAIL, func() { head = kit.SortedKey(value) })
w.Write(head)
}
w.Write(kit.Simple(head, func(k string) string { return kit.Format(value[k]) }))
@ -118,18 +114,18 @@ func PageListAction(arg ...ice.Any) ice.Actions {
return ice.MergeActions(ice.Actions{
SELECT: {Name: "select id auto insert page", Hand: func(m *ice.Message, arg ...string) { PageListSelect(m, arg...) }},
NEXT: {Hand: func(m *ice.Message, arg ...string) {
NextPage(m, kit.Select(m.Config(COUNT), arg, 0), kit.Slice(arg, 1)...)
NextPage(m, kit.Select(Config(m, COUNT), arg, 0), kit.Slice(arg, 1)...)
}},
PREV: {Hand: func(m *ice.Message, arg ...string) {
PrevPageLimit(m, kit.Select(m.Config(COUNT), arg, 0), kit.Slice(arg, 1)...)
PrevPageLimit(m, kit.Select(Config(m, COUNT), arg, 0), kit.Slice(arg, 1)...)
}},
}, ListAction(arg...))
}
func ListField(m *ice.Message) string { return kit.Select(LIST_FIELD, m.Config(FIELD)) }
func ListField(m *ice.Message) string { return kit.Select(LIST_FIELD, Config(m, FIELD)) }
func ListSelect(m *ice.Message, arg ...string) *ice.Message {
m.Fields(len(kit.Slice(arg, 0, 1)), ListField(m))
if m.Cmdy(SELECT, m.PrefixKey(), "", LIST, ID, arg); !m.FieldsIsDetail() {
return m.StatusTimeCountTotal(m.Config(COUNT))
return m.StatusTimeCountTotal(Config(m, COUNT))
}
return m.StatusTime()
}

82
base/mdb/lock.go Normal file
View File

@ -0,0 +1,82 @@
package mdb
import (
"sync"
ice "shylinux.com/x/icebergs"
kit "shylinux.com/x/toolkits"
"shylinux.com/x/toolkits/task"
)
type configMessage interface {
Option(key string, arg ...Any) string
PrefixKey(...Any) string
Confv(...Any) Any
}
var _lock = task.Lock{}
var _locks = map[string]*task.Lock{}
func getLock(m configMessage, arg ...string) *task.Lock {
key := kit.Select(m.PrefixKey(), kit.Keys(arg))
m.Option("_lock", key)
defer _lock.Lock()()
l, ok := _locks[key]
if !ok {
l = &task.Lock{}
_locks[key] = l
}
return l
}
func Lock(m configMessage, arg ...string) func() { return getLock(m, arg...).Lock() }
func RLock(m configMessage, arg ...string) func() { return getLock(m, arg...).RLock() }
func Config(m configMessage, key string, arg ...Any) string {
return kit.Format(Configv(m, key, arg...))
}
func Configv(m configMessage, key string, arg ...Any) Any {
if len(arg) > 0 {
Confv(m, m.PrefixKey(), kit.Keym(key), arg[0])
}
return Confv(m, m.PrefixKey(), kit.Keym(key))
}
func Confv(m configMessage, arg ...Any) Any {
key := kit.Select(m.PrefixKey(), kit.Format(arg[0]))
if ctx, ok := ice.Info.Index[key].(*ice.Context); ok {
key = ctx.Prefix(key)
}
if len(arg) > 2 {
defer Lock(m, key)()
} else {
defer RLock(m, key)()
}
return m.Confv(arg...)
}
func Confm(m configMessage, key string, sub Any, cbs ...Any) Map {
val := m.Confv(key, sub)
if len(cbs) > 0 {
kit.For(val, cbs[0])
}
value, _ := val.(Map)
return value
}
func Conf(m configMessage, arg ...Any) string {
return kit.Format(Confv(m, arg...))
}
var cache = sync.Map{}
func Cache(m *ice.Message, key string, add func() Any) Any {
if add == nil {
cache.Delete(key)
return nil
}
if val, ok := cache.Load(key); ok {
return val
}
if val := add(); val != nil {
cache.Store(key, val)
return val
}
return nil
}

231
base/mdb/mdb.go
View File

@ -3,42 +3,19 @@ package mdb
import (
"path"
"strings"
"sync"
ice "shylinux.com/x/icebergs"
kit "shylinux.com/x/toolkits"
"shylinux.com/x/toolkits/task"
)
type Any = interface{}
type Map = map[string]Any
type Maps = map[string]string
type List = []interface{}
type Any = ice.Any
type List = ice.List
type Maps = ice.Maps
type Map = ice.Map
func _file_name(m *ice.Message, arg ...string) string {
if len(arg) > 3 && strings.Contains(arg[3], ice.PS) {
return arg[3]
}
return path.Join(ice.USR_LOCAL_EXPORT, path.Join(arg[:2]...), arg[2])
}
func _mdb_getmeta(m *ice.Message, prefix, chain, key string) string {
defer RLock(m, prefix, chain)()
return m.Conf(prefix, kit.Keys(chain, kit.Keym(key)))
}
func _mdb_modify(m *ice.Message, value ice.Map, field string, arg ...string) {
func _mdb_modify(m *ice.Message, value Map, field string, arg ...string) {
value = kit.GetMeta(value)
kit.Fetch(arg, func(k, v string) {
if k != field {
kit.Value(value, k, v)
}
})
}
func ToMaps(value ice.Map) ice.Maps {
res := Maps{}
for k, v := range value {
res[k] = kit.Format(v)
}
return res
kit.For(arg, func(k, v string) { kit.If(k != field, func() { kit.Value(value, k, v) }) })
}
func _mdb_select(m *ice.Message, cb Any, key string, value Map, fields []string, val Map) {
switch value, val = kit.GetMeta(value), kit.GetMeta(val); cb := cb.(type) {
@ -56,7 +33,7 @@ func _mdb_select(m *ice.Message, cb Any, key string, value Map, fields []string,
cb(value[TARGET])
case func(Maps):
cb(ToMaps(value))
case string, []string, []ice.Any, nil:
case string, []string, []Any, nil:
if m.FieldsIsDetail() {
m.Push(ice.FIELDS_DETAIL, value)
} else {
@ -66,6 +43,12 @@ func _mdb_select(m *ice.Message, cb Any, key string, value Map, fields []string,
m.ErrorNotImplement(cb)
}
}
func _mdb_export_file(m *ice.Message, arg ...string) string {
if len(arg) > 3 && strings.Contains(arg[3], ice.PS) {
return arg[3]
}
return path.Join(ice.USR_LOCAL_EXPORT, path.Join(arg[:2]...), arg[2])
}
const (
DICT = kit.MDB_DICT
@ -115,13 +98,6 @@ const (
CACHE_CLEAR_ON_EXIT = "cache.clear.on.exit"
)
const (
DETAIL = "detail"
RANDOM = "random"
ACTION = "action"
FIELDS = "fields"
PARAMS = "params"
RECENT = "recent"
INPUTS = "inputs"
CREATE = "create"
REMOVE = "remove"
@ -133,14 +109,21 @@ const (
EXPORT = "export"
IMPORT = "import"
UPLOAD = "upload"
REVERT = "revert"
REPEAT = "repeat"
DETAIL = "detail"
FIELDS = "fields"
PARAMS = "params"
ACTION = "action"
UPLOAD = "upload"
RECENT = "recent"
REPEAT = "repeat"
REVERT = "revert"
RANDOM = "random"
OFFEND = "offend"
PAGE = "page"
NEXT = "next"
PREV = "prev"
PAGE = "page"
OFFEND = "offend"
JSON = "json"
CSV = "csv"
@ -153,103 +136,83 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: ice.Commands
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) {}},
INPUTS: {Name: "inputs key sub type field value", Hand: func(m *ice.Message, arg ...string) {
const (
SPACE = "space"
CONTEXT = "context"
COMMAND = "command"
INDEX = "index"
)
switch arg[3] = strings.TrimPrefix(arg[3], EXTRA+ice.PT); arg[3] {
case ice.POD:
m.Cmdy(SPACE)
case ice.CTX:
m.Cmdy(CONTEXT)
case ice.CMD:
m.Cmdy(CONTEXT, kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(EXTRA, ice.CTX))), COMMAND)
case INDEX:
m.Cmdy(COMMAND, SEARCH, COMMAND, kit.Select("", arg, 1), ice.OptionFields(arg[3]))
default:
switch arg[2] {
case ZONE:
_zone_inputs(m, arg[0], arg[1], arg[3], kit.Select(NAME, arg, 4), kit.Select("", arg, 5))
case HASH:
_hash_inputs(m, arg[0], arg[1], kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
case ZONE:
_zone_inputs(m, arg[0], arg[1], arg[3], kit.Select(NAME, arg, 4), kit.Select("", arg, 5))
case LIST:
_list_inputs(m, arg[0], arg[1], kit.Select(NAME, arg, 3), kit.Select("", arg, 4))
}
}
}},
INSERT: {Name: "insert key sub type arg...", Hand: func(m *ice.Message, arg ...string) {
defer m.ProcessRefresh()
switch arg[2] {
case ZONE:
_zone_insert(m, arg[0], arg[1], arg[3], arg[4:]...)
case HASH:
_hash_insert(m, arg[0], arg[1], arg[3:]...)
case ZONE:
_zone_insert(m, arg[0], arg[1], arg[3], arg[4:]...)
case LIST:
_list_insert(m, arg[0], arg[1], arg[3:]...)
}
}},
DELETE: {Name: "delete key sub type field value", Hand: func(m *ice.Message, arg ...string) {
defer m.ProcessRefresh()
switch arg[2] {
case ZONE:
// _list_delete(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4], arg[5])
case HASH:
_hash_delete(m, arg[0], arg[1], arg[3], arg[4])
case ZONE:
// _list_delete(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4], arg[5])
case LIST:
// _list_delete(m, arg[0], arg[1], arg[3], arg[4])
}
}},
MODIFY: {Name: "modify key sub type field value arg...", Hand: func(m *ice.Message, arg ...string) {
switch arg[2] {
case ZONE:
_zone_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
case HASH:
_hash_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
case ZONE:
_zone_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
case LIST:
_list_modify(m, arg[0], arg[1], arg[3], arg[4], arg[5:]...)
}
}},
SELECT: {Name: "select key sub type field value", Hand: func(m *ice.Message, arg ...string) {
switch arg[2] {
case ZONE:
_zone_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select("", arg, 4))
case HASH:
_hash_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select(FOREACH, arg, 4))
case ZONE:
_zone_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select("", arg, 4))
case LIST:
_list_select(m, arg[0], arg[1], kit.Select("", arg, 3), kit.Select("", arg, 4))
}
}},
PRUNES: {Name: "prunes key sub type [field value]...", Hand: func(m *ice.Message, arg ...string) {
switch arg[2] {
case ZONE:
// _list_prunes(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
case HASH:
_hash_prunes(m, arg[0], arg[1], arg[3:]...)
m.Tables(func(value ice.Maps) { _hash_delete(m, arg[0], arg[1], HASH, value[HASH]) })
m.Tables(func(value Maps) { _hash_delete(m, arg[0], arg[1], HASH, value[HASH]) })
case ZONE:
// _list_prunes(m, arg[0], _domain_chain(m, kit.Keys(arg[1], kit.KeyHash(arg[3]))), arg[4:]...)
case LIST:
// _list_prunes(m, arg[0], arg[1], arg[3:]...)
}
}},
EXPORT: {Name: "export key sub type file", Hand: func(m *ice.Message, arg ...string) {
m.OptionDefault(CACHE_LIMIT, "-1")
switch file := _file_name(m, arg...); arg[2] {
case ZONE:
_zone_export(m, arg[0], arg[1], file)
switch file := _mdb_export_file(m, arg...); arg[2] {
case HASH:
_hash_export(m, arg[0], arg[1], file)
case ZONE:
_zone_export(m, arg[0], arg[1], file)
case LIST:
_list_export(m, arg[0], arg[1], file)
}
m.StatusTime(LINK, "/share/local/"+m.Result()).Process("_clear")
}},
IMPORT: {Name: "import key sub type file", Hand: func(m *ice.Message, arg ...string) {
switch file := _file_name(m, arg...); arg[2] {
case ZONE:
_zone_import(m, arg[0], arg[1], file)
switch file := _mdb_export_file(m, arg...); arg[2] {
case HASH:
_hash_import(m, arg[0], arg[1], file)
case ZONE:
_zone_import(m, arg[0], arg[1], file)
case LIST:
_list_import(m, arg[0], arg[1], file)
}
@ -257,110 +220,44 @@ var Index = &ice.Context{Name: MDB, Help: "数据模块", Commands: ice.Commands
}}
func init() {
ice.Index.Register(Index, nil, INSERT, DELETE, MODIFY, SELECT, INPUTS, PRUNES, EXPORT, IMPORT, PLUGIN, RENDER, ENGINE, SEARCH)
ice.Index.Register(Index, nil, INPUTS, INSERT, DELETE, MODIFY, SELECT, PRUNES, EXPORT, IMPORT, PLUGIN, RENDER, ENGINE, SEARCH)
}
func AutoConfig(args ...ice.Any) *ice.Action {
return &ice.Action{Hand: func(m *ice.Message, arg ...string) {
if cs := m.Target().Configs; len(args) > 0 {
func AutoConfig(arg ...Any) *ice.Action {
return &ice.Action{Hand: func(m *ice.Message, args ...string) {
if cs := m.Target().Configs; len(arg) > 0 {
if cs[m.CommandKey()] == nil {
cs[m.CommandKey()] = &ice.Config{Value: kit.Data(args...)}
// ice.Info.Load(m, m.CommandKey())
cs[m.CommandKey()] = &ice.Config{Value: kit.Data(arg...)}
} else {
for k, v := range kit.Dict(args...) {
m.Config(k, v)
}
kit.For(kit.Dict(arg...), func(k string, v Any) { Config(m, k, v) })
}
}
if cmd := m.Target().Commands[m.CommandKey()]; cmd == nil {
return
} else if cmd.Actions[INSERT] != nil {
if inputs := []ice.Any{}; cmd.Meta[INSERT] == nil {
kit.Fetch(kit.Filters(kit.Simple(m.Config(SHORT), kit.Split(ListField(m))), "", TIME, ID), func(k string) { inputs = append(inputs, k) })
if inputs := []Any{}; cmd.Meta[INSERT] == nil {
kit.For(kit.Filters(kit.Simple(Config(m, SHORT), kit.Split(ListField(m))), "", TIME, ID), func(k string) { inputs = append(inputs, k) })
m.Design(INSERT, "添加", inputs...)
}
if inputs := []ice.Any{}; cmd.Meta[CREATE] == nil {
kit.Fetch(kit.Filters(kit.Split(kit.Select(m.Config(SHORT), m.Config(FIELDS))), TIME, HASH, COUNT), func(k string) { inputs = append(inputs, k) })
if inputs := []Any{}; cmd.Meta[CREATE] == nil {
kit.For(kit.Filters(kit.Split(kit.Select(Config(m, SHORT), Config(m, FIELDS))), TIME, HASH, COUNT), func(k string) { inputs = append(inputs, k) })
m.Design(CREATE, "创建", inputs...)
}
} else if cmd.Actions[CREATE] != nil {
if inputs := []ice.Any{}; cmd.Meta[CREATE] == nil {
kit.Fetch(kit.Filters(kit.Split(HashField(m)), TIME, HASH), func(k string) { inputs = append(inputs, k) })
if inputs := []Any{}; cmd.Meta[CREATE] == nil {
kit.For(kit.Filters(kit.Split(HashField(m)), TIME, HASH), func(k string) { inputs = append(inputs, k) })
m.Design(CREATE, "创建", inputs...)
}
}
}}
}
var _lock = task.Lock{}
var _locks = map[string]*task.Lock{}
func getLock(m *ice.Message, key string) *task.Lock {
defer _lock.Lock()()
l, ok := _locks[key]
if !ok {
l = &task.Lock{}
_locks[key] = l
}
return l
}
func Lock(m *ice.Message, arg ...ice.Any) func() {
key := kit.Select(m.PrefixKey(), kit.Keys(arg...))
m.Option("_lock", key)
return getLock(m, key).Lock()
}
func RLock(m *ice.Message, arg ...ice.Any) func() {
key := kit.Select(m.PrefixKey(), kit.Keys(arg...))
m.Option("_lock", key)
return getLock(m, key).RLock()
}
func Config(m *ice.Message, key string, arg ...ice.Any) string {
return kit.Format(Configv(m, key, arg...))
}
func Configv(m *ice.Message, key string, arg ...ice.Any) ice.Any {
if len(arg) > 0 {
Confv(m, m.PrefixKey(), kit.Keym(key), arg[0])
}
return Confv(m, m.PrefixKey(), kit.Keym(key))
}
func Confv(m *ice.Message, arg ...ice.Any) ice.Any {
key := kit.Format(arg[0])
if ctx, ok := ice.Info.Index[key].(*ice.Context); ok {
key = ctx.PrefixKey(key)
}
if len(arg) > 1 {
defer Lock(m, key)()
} else {
defer RLock(m, key)()
}
return m.Confv(arg...)
}
func Conf(m *ice.Message, arg ...ice.Any) string {
return kit.Format(Confv(m, arg...))
}
var cache = sync.Map{}
func Cache(m *ice.Message, key string, add func() ice.Any) ice.Any {
if add == nil {
cache.Delete(key)
return nil
}
if val, ok := cache.Load(key); ok {
return val
}
if val := add(); val != nil {
cache.Store(key, val)
return val
}
return nil
}
func ImportantDataAction() ice.Actions {
return ice.Actions{ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Config("important", ice.TRUE) }}}
return ice.Actions{ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { Config(m, "important", ice.TRUE) }}}
}
func SaveImportant(m *ice.Message, key, sub string, arg ...string) {
if m.Conf(key, kit.Keys(sub, META, "important")) == ice.TRUE {
ice.SaveImportant(m, arg...)
}
func saveImportant(m *ice.Message, key, sub string, arg ...string) {
kit.If(m.Conf(key, kit.Keys(sub, META, "important")) == ice.TRUE, func() { ice.SaveImportant(m, arg...) })
}
func ToMaps(value Map) Maps {
res := Maps{}
kit.For(value, func(k, v string) { res[k] = v })
return res
}

26
base/mdb/render.go
View File

@ -9,33 +9,19 @@ const RENDER = "render"
func init() { Index.MergeCommands(ice.Commands{RENDER: {Help: "渲染", Actions: RenderAction()}}) }
func RenderAction(args ...ice.Any) ice.Actions {
return ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
if len(args) == 0 {
args = append(args, SHORT, TYPE, FIELD, "time,type,name,text")
}
if cs := m.Target().Configs; cs[m.CommandKey()] == nil {
cs[m.CommandKey()] = &ice.Config{Value: kit.Data(args...)}
} else {
kit.Fetch(kit.Simple(args), func(key, value string) { m.Config(key, value) })
}
}},
CREATE: {Name: "create type name text", Hand: func(m *ice.Message, arg ...string) {
m.Option(TYPE, kit.Ext(m.Option(TYPE)))
m.OptionDefault(NAME, m.Option(TYPE))
m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple(TYPE, NAME, TEXT))
}},
func RenderAction(arg ...ice.Any) ice.Actions {
return ice.MergeActions(ice.Actions{ice.CTX_INIT: AutoConfig(SHORT, TYPE, FIELD, "time,type,name,text", arg),
CREATE: {Name: "create type name text", Hand: func(m *ice.Message, arg ...string) { HashCreate(m) }},
SELECT: {Name: "select type name text auto create", Hand: func(m *ice.Message, arg ...string) {
if len(arg) < 2 || arg[0] == "" {
HashSelect(m, arg...)
return
}
for _, k := range kit.Split(arg[0]) {
HashSelect(m.Spawn(ice.OptionFields("")), k).Tables(func(value ice.Maps) {
kit.For(kit.Split(arg[0]), func(k string) {
HashSelects(m.Spawn(), k).Tables(func(value ice.Maps) {
m.Cmdy(kit.Keys(value[TEXT], value[NAME]), m.CommandKey(), k, arg[1], kit.Select("", arg, 2), kit.Slice(arg, 3))
})
}
})
}},
ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { Conf(m, m.PrefixKey(), HASH, "") }},
})

28
base/mdb/search.go
View File

@ -1,39 +1,15 @@
package mdb
import (
ice "shylinux.com/x/icebergs"
kit "shylinux.com/x/toolkits"
)
import ice "shylinux.com/x/icebergs"
const SEARCH = "search"
func init() {
Index.MergeCommands(ice.Commands{SEARCH: {Help: "搜索", Actions: RenderAction()}})
ice.AddMerges(func(c *ice.Context, key string, cmd *ice.Command, sub string, action *ice.Action) (ice.Handler, ice.Handler) {
switch sub {
case SEARCH:
if sub == SEARCH {
return func(m *ice.Message, arg ...string) { m.Cmd(sub, CREATE, m.CommandKey(), m.PrefixKey()) }, nil
}
return nil, nil
})
}
func SearchAction() ice.Actions {
return ice.Actions{SEARCH: {Hand: func(m *ice.Message, arg ...string) { HashSelectSearch(m, arg) }}}
}
func HashSearchAction(arg ...Any) ice.Actions {
return ice.MergeActions(HashAction(arg...), SearchAction())
}
func HashSelectSearch(m *ice.Message, args []string, keys ...string) *ice.Message {
if args[0] != m.CommandKey() {
return m
}
if len(keys) == 0 {
keys = kit.Filters(kit.Split(HashField(m)), TIME, HASH)
}
HashSelectValue(m, func(value ice.Map) {
if args[1] == "" || args[1] == value[keys[1]] {
m.PushSearch(kit.SimpleKV("", value[keys[0]], value[keys[1]], value[keys[2]]), value)
}
})
return m
}

25
base/mdb/zone.go
View File

@ -10,22 +10,26 @@ import (
"shylinux.com/x/toolkits/miss"
)
func _zone_meta(m *ice.Message, prefix, chain, key string) string {
defer RLock(m, prefix, chain)()
return m.Conf(prefix, kit.Keys(chain, kit.Keym(key)))
}
func _zone_fields(m *ice.Message) []string {
return kit.Split(kit.Select(ZONE_FIELD, m.OptionFields()))
}
func _zone_inputs(m *ice.Message, prefix, chain, zone string, field, value string) {
if field == _mdb_getmeta(m, prefix, chain, SHORT) {
if field == _zone_meta(m, prefix, chain, SHORT) {
_hash_inputs(m, prefix, chain, field, value)
return
}
defer RLock(m, prefix, chain)()
h := _hash_select_field(m, prefix, chain, zone, HASH)
defer RLock(m, prefix, chain)()
_list_inputs(m, prefix, kit.Keys(chain, HASH, h), field, value)
}
func _zone_insert(m *ice.Message, prefix, chain, zone string, arg ...string) {
h := _hash_select_field(m, prefix, chain, zone, HASH)
if h == "" {
h = _hash_insert(m, prefix, chain, kit.Select(ZONE, _mdb_getmeta(m, prefix, chain, SHORT)), zone)
h = _hash_insert(m, prefix, chain, kit.Select(ZONE, _zone_meta(m, prefix, chain, SHORT)), zone)
}
m.Assert(h != "")
defer Lock(m, prefix, chain)()
@ -147,8 +151,12 @@ func ZoneAction(arg ...ice.Any) ice.Actions {
func PageZoneAction(arg ...ice.Any) ice.Actions {
return ice.MergeActions(ice.Actions{
SELECT: {Name: "select zone id auto insert page", Hand: func(m *ice.Message, arg ...string) { PageZoneSelect(m, arg...) }},
NEXT: {Hand: func(m *ice.Message, arg ...string) { NextPage(m, arg[0], arg[1:]...) }},
PREV: {Hand: func(m *ice.Message, arg ...string) { PrevPageLimit(m, arg[0], arg[1:]...) }},
PREV: {Hand: func(m *ice.Message, arg ...string) {
PrevPageLimit(m, arg[0], arg[1:]...)
}},
NEXT: {Hand: func(m *ice.Message, arg ...string) {
NextPage(m, arg[0], arg[1:]...)
}},
}, ZoneAction(arg...))
}
func ZoneKey(m *ice.Message) string {
@ -197,15 +205,12 @@ func ZoneSelect(m *ice.Message, arg ...string) *ice.Message {
if m.Cmdy(SELECT, m.PrefixKey(), "", ZONE, arg, logs.FileLineMeta(-1)); len(arg) == 0 {
m.PushAction(Config(m, ACTION), REMOVE).StatusTimeCount().Sort(ZoneShort(m))
} else if len(arg) == 1 {
// m.StatusTimeCountTotal(_mdb_getmeta(m, m.PrefixKey(), kit.Keys(HASH, HashSelectField(m, arg[0], HASH)), COUNT))
m.StatusTimeCount()
m.StatusTimeCountTotal(_zone_meta(m, m.PrefixKey(), kit.Keys(HASH, HashSelectField(m, arg[0], HASH)), COUNT))
}
return m
}
func ZoneExport(m *ice.Message, arg ...Any) {
if m.OptionFields() == "" {
m.OptionFields(Config(m, SHORT), ZoneField(m))
}
kit.If(m.OptionFields() == "", func() { m.OptionFields(Config(m, SHORT), ZoneField(m)) })
m.Cmdy(EXPORT, m.PrefixKey(), "", ZONE, arg)
}
func ZoneImport(m *ice.Message, arg ...Any) {

17
base/nfs/cat.go
View File

@ -69,15 +69,14 @@ func _cat_list(m *ice.Message, file string) {
for {
if n, e := f.Read(buf[size:]); !m.Warn(e, ice.ErrNotValid, file) {
m.Logs(LOAD, FILE, file, SIZE, n)
if size += n; size < len(buf) {
if size += n; size >= len(buf) {
buf = append(buf, make([]byte, ice.MOD_BUFS)...)
continue
}
}
buf = buf[:size]
break
}
buf = append(buf, make([]byte, ice.MOD_BUFS)...)
} else {
break
}
}
m.Echo(string(buf)).StatusTime(FILE, file, SIZE, size)
default:
m.ErrorNotImplement(cb)
@ -136,11 +135,9 @@ const CAT = "cat"
func init() {
Index.MergeCommands(ice.Commands{
CAT: {Name: "cat path auto", Help: "文件", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { aaa.White(m, ice.SRC_MAIN_JS, ice.SRC_MAIN_GO, ice.SRC_MAIN_SHY) }},
}, ice.Actions{ice.CTX_INIT: mdb.AutoConfig(SOURCE, kit.DictList(
CAT: {Name: "cat path auto", Help: "文件", Actions: ice.MergeActions(ice.Actions{ice.CTX_INIT: mdb.AutoConfig(SOURCE, kit.DictList(
HTML, CSS, JS, GO, SH, SHY, CSV, JSON, PY, MD, TXT, XML, YML, ZML, IML,
"license", "makefile", "configure", "conf",
ice.LICENSE, ice.MAKEFILE, "configure", "conf",
))}), Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 || strings.HasSuffix(arg[0], ice.PS) {
m.Cmdy(DIR, arg)

4
base/ssh/script.go
View File

@ -127,7 +127,9 @@ func (f *Frame) scan(m *ice.Message, h, line string) *Frame {
if len(bio.Text()) == 0 && h == STDIO {
continue
}
f.count++
if f.count++; len(bio.Text()) == 0 {
continue
}
if strings.HasSuffix(bio.Text(), "\\") {
line += bio.Text()[:len(bio.Text())-1]
ps = f.ps2

15
base/tcp/port.go
View File

@ -7,15 +7,16 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
)
func _port_right(m *ice.Message, arg ...string) string {
current, end := kit.Int(kit.Select(m.Config(CURRENT), arg, 0)), kit.Int(m.Config(END))
current, end := kit.Int(kit.Select(mdb.Config(m, CURRENT), arg, 0)), kit.Int(mdb.Config(m, END))
if current >= end {
current = kit.Int(m.Config(BEGIN))
current = kit.Int(mdb.Config(m, BEGIN))
}
for i := current; i < end; i++ {
if p := path.Join(ice.USR_LOCAL_DAEMON, kit.Format(i)); nfs.ExistsFile(m, p) {
@ -26,7 +27,7 @@ func _port_right(m *ice.Message, arg ...string) string {
} else {
nfs.MkdirAll(m, p)
m.Logs(mdb.SELECT, PORT, i)
return m.Config(CURRENT, i)
return mdb.Config(m, CURRENT, i)
}
}
return ""
@ -43,7 +44,7 @@ const PORT = "port"
func init() {
Index.MergeCommands(ice.Commands{
PORT: {Name: "port port path auto", Help: "端口", Actions: ice.MergeActions(ice.Actions{
CURRENT: {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(CURRENT)) }},
CURRENT: {Hand: func(m *ice.Message, arg ...string) { m.Echo(mdb.Config(m, CURRENT)) }},
aaa.RIGHT: {Hand: func(m *ice.Message, arg ...string) { m.Echo(_port_right(m, arg...)) }},
nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) {
m.Assert(m.Option(PORT) != "")
@ -54,7 +55,7 @@ func init() {
m.Cmdy(nfs.DIR, arg[1:], kit.Dict(nfs.DIR_ROOT, path.Join(ice.USR_LOCAL_DAEMON, arg[0])))
return
}
current := kit.Int(m.Config(BEGIN))
current := kit.Int(mdb.Config(m, BEGIN))
m.Option(nfs.DIR_ROOT, ice.USR_LOCAL_DAEMON)
m.Cmd(nfs.DIR, nfs.PWD, func(value ice.Maps) {
bin := m.CmdAppend(nfs.DIR, path.Join(value[nfs.PATH], ice.BIN), nfs.PATH)
@ -68,8 +69,8 @@ func init() {
m.Push(ice.BIN, strings.TrimPrefix(bin, value[nfs.PATH]))
current = kit.Max(current, port)
})
m.Config(CURRENT, current)
m.PushAction(nfs.TRASH).StatusTimeCount(m.ConfigSimple(BEGIN, CURRENT, END)).SortInt(PORT)
mdb.Config(m, CURRENT, current)
m.PushAction(nfs.TRASH).StatusTimeCount(ctx.ConfigSimple(m, BEGIN, CURRENT, END)).SortInt(PORT)
}},
})
}

2
base/web/dream.go
View File

@ -55,7 +55,7 @@ func _dream_show(m *ice.Message, name string) {
defer m.Sleep3s()
m.Options(cli.CMD_DIR, kit.Path(p), cli.CMD_ENV, kit.Simple(
cli.CTX_OPS, "http://localhost:"+m.CmdAppend(SERVE, tcp.PORT), cli.CTX_LOG, ice.VAR_LOG_BOOT_LOG, cli.CTX_PID, ice.VAR_LOG_ICE_PID,
cli.PATH, cli.BinPath(p, ""), cli.USER, ice.Info.Username, kit.EnvSimple(cli.HOME, cli.TERM, cli.SHELL), m.Configv(cli.ENV),
cli.PATH, cli.BinPath(p, ""), cli.USER, ice.Info.Username, kit.EnvSimple(cli.HOME, cli.TERM, cli.SHELL), mdb.Configv(m, cli.ENV),
), cli.CMD_OUTPUT, path.Join(p, ice.VAR_LOG_BOOT_LOG))
defer m.Options(cli.CMD_DIR, "", cli.CMD_ENV, "", cli.CMD_OUTPUT, "")
gdb.Event(m, DREAM_CREATE, m.OptionSimple(mdb.NAME, mdb.TYPE))

11
base/web/serve.go
View File

@ -67,18 +67,18 @@ func _serve_main(m *ice.Message, w http.ResponseWriter, r *http.Request) bool {
return true
}
func _serve_handle(key string, cmd *ice.Command, m *ice.Message, w http.ResponseWriter, r *http.Request) {
_log := func(level string, arg ...ice.Any) *ice.Message { return m.Logs(level, arg...) }
_log := func(level string, arg ...ice.Any) *ice.Message { return m.Logs(strings.Title(level), arg...) }
if u, e := url.Parse(r.Header.Get(Referer)); e == nil {
add := func(k, v string) { _log("Path", k, m.Option(k, v)) }
add := func(k, v string) { _log(nfs.PATH, k, m.Option(k, v)) }
switch arg := strings.Split(strings.TrimPrefix(u.Path, ice.PS), ice.PS); arg[0] {
case CHAT:
kit.For(arg[1:], func(k, v string) { add(k, v) })
case SHARE:
add(arg[0], arg[1])
}
kit.For(u.Query(), func(k string, v []string) { _log("Refer", k, v).Optionv(k, v) })
kit.For(u.Query(), func(k string, v []string) { _log(ctx.ARGS, k, v).Optionv(k, v) })
}
m.Options(ice.MSG_USERUA, r.Header.Get(UserAgent), ice.MSG_HEIGHT, "480", ice.MSG_WIDTH, "320")
m.Options(ice.MSG_USERUA, r.Header.Get(UserAgent))
for k, v := range kit.ParseQuery(r.URL.RawQuery) {
kit.If(m.IsCliUA(), func() { v = kit.Simple(v, func(v string) (string, error) { return url.QueryUnescape(v) }) })
m.Optionv(k, v)
@ -96,6 +96,7 @@ func _serve_handle(key string, cmd *ice.Command, m *ice.Message, w http.Response
})
}
kit.For(r.Cookies(), func(k, v string) { m.Optionv(k, v) })
m.OptionDefault(ice.MSG_HEIGHT, "480", ice.MSG_WIDTH, "320")
m.Options(ice.MSG_USERWEB, _serve_domain(m), ice.MSG_USERPOD, m.Option(ice.POD))
m.Options(ice.MSG_SESSID, kit.Select(m.Option(ice.MSG_SESSID), m.Option(CookieName(m.Option(ice.MSG_USERWEB)))))
m.Options(ice.MSG_USERIP, r.Header.Get(ice.MSG_USERIP), ice.MSG_USERADDR, kit.Select(r.RemoteAddr, r.Header.Get(ice.MSG_USERADDR)))
@ -184,7 +185,7 @@ func init() {
Index.MergeCommands(ice.Commands{"/exit": {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(ice.EXIT) }},
SERVE: {Name: "serve name auto start", Help: "服务器", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
ice.Info.Localhost = m.Config(tcp.LOCALHOST) == ice.TRUE
ice.Info.Localhost = mdb.Config(m, tcp.LOCALHOST) == ice.TRUE
cli.NodeInfo(m, ice.Info.Pathname, WORKER)
}},
cli.START: {Name: "start dev proto host port=9020 nodename username usernick", Hand: func(m *ice.Message, arg ...string) {

2
base/web/space.go
View File

@ -25,7 +25,7 @@ func _space_dial(m *ice.Message, dev, name string, arg ...string) {
args := kit.SimpleKV("type,name,host,port", msg.Append(tcp.PROTOCOL), dev, msg.Append(tcp.HOST), msg.Append(tcp.PORT))
prints := false
m.Go(func() {
redial := kit.Dict(m.Configv(REDIAL))
redial := kit.Dict(mdb.Configv(m, REDIAL))
a, b, c := kit.Int(redial["a"]), kit.Int(redial["b"]), kit.Int(redial["c"])
for i := 1; i < c; i++ {
next := time.Duration(rand.Intn(a*(i+1))+b*i) * time.Millisecond

9
base/web/spide.go
View File

@ -13,7 +13,6 @@ import (
"time"
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/nfs"
@ -67,7 +66,7 @@ func _spide_show(m *ice.Message, name string, arg ...string) {
return
}
defer res.Body.Close()
if m.Config(LOGHEADERS) == ice.TRUE {
if mdb.Config(m, LOGHEADERS) == ice.TRUE {
for k, v := range res.Header {
m.Logs(mdb.IMPORT, k, v)
}
@ -274,7 +273,7 @@ func init() {
Index.MergeCommands(ice.Commands{
SPIDE: {Name: "spide client.name action=raw,msg,save,cache method=GET,PUT,POST,DELETE url format=form,part,json,data,file arg run create", Help: "蜘蛛侠", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
conf := m.Confm(cli.RUNTIME, cli.CONF)
conf := mdb.Confm(m, cli.RUNTIME, cli.CONF)
m.Cmd("", mdb.CREATE, ice.OPS, kit.Select("http://127.0.0.1:9020", conf[cli.CTX_OPS]))
m.Cmd("", mdb.CREATE, ice.DEV, kit.Select(kit.Select("https://contexts.com.cn", ice.Info.Make.Domain), conf[cli.CTX_DEV]))
m.Cmd("", mdb.CREATE, ice.COM, kit.Select("https://contexts.com.cn", conf[cli.CTX_COM]))
@ -304,10 +303,6 @@ func init() {
_spide_show(m, arg[0], arg[1:]...)
}
}},
"/spide-demo/": {Actions: aaa.WhiteAction(), Hand: func(m *ice.Message, arg ...string) {
m.Push("hi", "hello")
m.Echo("hello world")
}},
http.MethodGet: {Name: "GET url key value run", Help: "蜘蛛侠", Hand: func(m *ice.Message, arg ...string) {
m.Echo(kit.Formats(kit.UnMarshal(m.Cmdx(SPIDE, ice.DEV, SPIDE_RAW, http.MethodGet, arg[0], arg[1:]))))
}},

2
core/chat/action.go
View File

@ -79,7 +79,7 @@ func init() {
return
}
if len(arg) == 2 {
m.OptionFromConfig(MENUS)
ctx.OptionFromConfig(m, MENUS)
_action_list(m, arg[0], arg[1])
} else {
_action_exec(m, arg[0], arg[1], arg[2], arg[3:]...)

2
core/chat/header.go
View File

@ -48,7 +48,7 @@ func _header_check(m *ice.Message, arg ...string) bool {
if m.Option(ice.MSG_USERNAME) != "" {
return true
}
if m.OptionFromConfig(web.SSO) == "" && m.OptionFromConfig(web.LOGIN) == "" {
if ctx.OptionFromConfig(m, web.SSO) == "" && ctx.OptionFromConfig(m, web.LOGIN) == "" {
m.Option(web.SSO, GetSSO(m))
}
return false

4
core/chat/location.go
View File

@ -32,7 +32,7 @@ func init() {
}
get := func(m *ice.Message, api string, arg ...ice.Any) string {
return kit.Format(cache(m, kit.Join(kit.Simple(api, arg)), func() string {
return m.Cmdx(http.MethodGet, "https://apis.map.qq.com/ws/"+api, mdb.KEY, m.Config(aaa.TOKEN), arg)
return m.Cmdx(http.MethodGet, "https://apis.map.qq.com/ws/"+api, mdb.KEY, mdb.Config(m, aaa.TOKEN), arg)
}))
}
@ -73,7 +73,7 @@ func init() {
}},
}, mdb.HashAction(mdb.FIELD, "time,hash,type,name,text,latitude,longitude,extra"), ctx.CmdAction(), FavorAction()), Hand: func(m *ice.Message, arg ...string) {
mdb.HashSelect(m, kit.Slice(arg, 0, 1)...)
ctx.DisplayLocal(m, "", m.ConfigSimple(aaa.TOKEN))
ctx.DisplayLocal(m, "", ctx.ConfigSimple(m, aaa.TOKEN))
m.Option(LOCATION, get(m, "location/v1/ip", aaa.IP, m.Option(ice.MSG_USERIP)))
}},
})

2
core/chat/oauth/oauth.go
View File

@ -151,7 +151,7 @@ var Index = &ice.Context{Name: OAUTH, Help: "认证授权", Commands: ice.Comman
} else { // 授权
token := m.Cmdx(ACCESS, mdb.CREATE, aaa.USERNAME, m.Option(ice.MSG_USERNAME), msg.AppendSimple(SCOPE, REDIRECT_URI))
m.RenderJson(ACCESS_TOKEN, token, TOKEN_TYPE, web.Bearer, EXPIRES_IN, kit.Duration(m.Conf(ACCESS, kit.Keym(mdb.EXPIRE)))/time.Second)
m.RenderJson(ACCESS_TOKEN, token, TOKEN_TYPE, web.Bearer, EXPIRES_IN, kit.Duration(mdb.Conf(m, ACCESS, kit.Keym(mdb.EXPIRE)))/time.Second)
m.Cmdx(TOKEN, mdb.MODIFY, mdb.HASH, m.Option(CODE), USED, ice.TRUE)
}
}},

2
core/code/compile.go
View File

@ -62,7 +62,7 @@ func init() {
}, ctx.ConfAction(cli.ENV, kit.Dict("GOPRIVATE", "shylinux.com,github.com", "GOPROXY", "https://goproxy.cn,direct", "CGO_ENABLED", "0"))), Hand: func(m *ice.Message, arg ...string) {
defer web.ToastProcess(m)()
main, file, goos, arch := _compile_target(m, arg...)
env := kit.Simple(cli.PATH, cli.BinPath(), cli.HOME, kit.Select(kit.Path(""), kit.Env(cli.HOME)), m.Configv(cli.ENV), m.Optionv(cli.ENV), cli.GOOS, goos, cli.GOARCH, arch)
env := kit.Simple(cli.PATH, cli.BinPath(), cli.HOME, kit.Select(kit.Path(""), kit.Env(cli.HOME)), mdb.Configv(m, cli.ENV), m.Optionv(cli.ENV), cli.GOOS, goos, cli.GOARCH, arch)
kit.If(runtime.GOOS == cli.WINDOWS, func() { env = append(env, "GOPATH", kit.HomePath(GO), "GOCACHE", kit.HomePath("go/go-build")) })
m.Optionv(cli.CMD_ENV, env)
m.Cmd(AUTOGEN, VERSION)

4
core/code/inner.go
View File

@ -134,7 +134,7 @@ func PlugAction() ice.Actions {
kit.For([]string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE}, func(cmd string) { m.Cmd(cmd, mdb.CREATE, m.CommandKey(), m.PrefixKey()) })
LoadPlug(m, m.CommandKey())
}},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(PLUG)) }},
mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(mdb.Config(m, PLUG)) }},
mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) }},
mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) }},
mdb.SELECT: {Hand: func(m *ice.Message, arg ...string) {
@ -149,7 +149,7 @@ func PlugAction() ice.Actions {
func LoadPlug(m *ice.Message, lang ...string) {
for _, lang := range lang {
m.Conf(nfs.CAT, kit.Keym(nfs.SOURCE, kit.Ext(lang)), ice.TRUE)
m.Confm(lang, kit.Keym(PLUG, PREPARE), func(k string, v ice.Any) {
mdb.Confm(m, lang, kit.Keym(PLUG, PREPARE), func(k string, v ice.Any) {
kit.For(kit.Simple(v), func(v string) { m.Conf(lang, kit.Keym(PLUG, KEYWORD, v), k) })
})
}

6
core/code/install.go
View File

@ -199,10 +199,10 @@ func init() {
func InstallAction(args ...ice.Any) ice.Actions {
return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(args...),
web.DOWNLOAD: {Help: "下载", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, web.DOWNLOAD, m.Config(nfs.SOURCE)) }},
cli.BUILD: {Help: "构建", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, cli.BUILD, m.Config(nfs.SOURCE)) }},
web.DOWNLOAD: {Help: "下载", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, web.DOWNLOAD, mdb.Config(m, nfs.SOURCE)) }},
cli.BUILD: {Help: "构建", Hand: func(m *ice.Message, arg ...string) { m.Cmdy(INSTALL, cli.BUILD, mdb.Config(m, nfs.SOURCE)) }},
cli.ORDER: {Help: "加载", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(INSTALL, cli.ORDER, m.Config(nfs.SOURCE), path.Join(_INSTALL, ice.BIN))
m.Cmdy(INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), path.Join(_INSTALL, ice.BIN))
}},
nfs.TRASH: {Hand: func(m *ice.Message, arg ...string) { nfs.Trash(m, m.Option(nfs.PATH)) }},
}

4
core/code/oauth.go
View File

@ -42,7 +42,7 @@ func init() {
mdb.HashCreate(m, m.OptionSimple(CODE))
}},
ACCESS_TOKEN: {Name: "access_token", Help: "令牌", Hand: func(m *ice.Message, arg ...string) {
mdb.HashModify(m, m.OptionSimple(mdb.HASH), kit.Simple(web.SpidePost(_oauth_header(m), kit.MergeURL2(LOGIN_OAUTH, ACCESS_TOKEN), m.ConfigSimple(CLIENT_ID, CLIENT_SECRET), m.OptionSimple(CODE))))
mdb.HashModify(m, m.OptionSimple(mdb.HASH), kit.Simple(web.SpidePost(_oauth_header(m), kit.MergeURL2(LOGIN_OAUTH, ACCESS_TOKEN), ctx.ConfigSimple(m, CLIENT_ID, CLIENT_SECRET), m.OptionSimple(CODE))))
}},
"user": {Name: "user", Help: "用户", Hand: func(m *ice.Message, arg ...string) {
mdb.HashModify(m, m.OptionSimple(mdb.HASH), kit.Simple(web.SpideGet(_oauth_header(m), API_GITHUB+"user")))
@ -66,7 +66,7 @@ func init() {
}, mdb.HashAction(mdb.FIELD, "time,hash,code,access_token,scope,token_type")), Hand: func(m *ice.Message, arg ...string) {
if mdb.HashSelect(m, arg...).PushAction("public", "user", ACCESS_TOKEN, mdb.REMOVE); len(arg) == 0 {
if m.Action(mdb.CREATE); m.Length() == 0 {
m.Echo(kit.MergeURL2(LOGIN_OAUTH, "authorize", m.ConfigSimple(REDIRECT_URI, CLIENT_ID), SCOPE, "read:user read:public_key write:public_key repo"))
m.Echo(kit.MergeURL2(LOGIN_OAUTH, "authorize", ctx.ConfigSimple(m, REDIRECT_URI, CLIENT_ID), SCOPE, "read:user read:public_key write:public_key repo"))
}
}
}},

4
core/code/pprof.go
View File

@ -43,7 +43,7 @@ func init() {
return
}
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, http.MethodGet, m.Option(SERVICE), m.OptionSimple(SECONDS))
cmd := kit.Simple(m.Configv(PPROF), "-text", m.Option(BINNARY), msg.Append(nfs.FILE))
cmd := kit.Simple(mdb.Configv(m, PPROF), "-text", m.Option(BINNARY), msg.Append(nfs.FILE))
m.Option(mdb.TEXT, strings.Join(kit.Slice(strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL), 0, 20), ice.NL))
mdb.ZoneInsert(m, m.OptionSimple("zone,text"), msg.AppendSimple(nfs.FILE))
m.Echo(m.Option(mdb.TEXT)).ProcessInner()
@ -51,7 +51,7 @@ func init() {
web.SERVE: {Help: "展示", Hand: func(m *ice.Message, arg ...string) {
u := web.OptionUserWeb(m)
p := u.Hostname() + ice.DF + m.Cmdx(tcp.PORT, aaa.RIGHT)
m.Cmd(cli.DAEMON, m.Configv(PPROF), "-http="+p, m.Option(BINNARY), m.Option(nfs.FILE))
m.Cmd(cli.DAEMON, mdb.Configv(m, PPROF), "-http="+p, m.Option(BINNARY), m.Option(nfs.FILE))
m.Sleep("3s").ProcessOpen(kit.Format("http://%s/ui/top", p))
}},
}, mdb.ZoneAction(mdb.FIELDS, "time,zone,count,binnary,service,seconds", mdb.FIELD, "time,id,text,file", PPROF, kit.List(GO, "tool", PPROF))), Hand: func(m *ice.Message, arg ...string) {

2
core/code/sh.go
View File

@ -14,7 +14,7 @@ import (
)
func _sh_cmds(m *ice.Message, p string) (string, string) {
cmds, text := kit.Select(SH, m.Config(ssh.SHELL)), kit.Format(strings.TrimSpace(nfs.Template(m, "cmd.sh")), web.UserHost(m), m.Option(ice.MSG_USERPOD), p)
cmds, text := kit.Select(SH, mdb.Config(m, ssh.SHELL)), kit.Format(strings.TrimSpace(nfs.Template(m, "cmd.sh")), web.UserHost(m), m.Option(ice.MSG_USERPOD), p)
if head := kit.Select("", strings.Split(m.Cmdx(nfs.CAT, p), ice.NL), 0); strings.HasPrefix(head, "#!") {
cmds = strings.TrimSpace(strings.TrimPrefix(head, "#!"))
}

1
core/code/vimer.go
View File

@ -184,7 +184,6 @@ func init() {
switch sub {
case TEMPLATE, COMPLETE, NAVIGATE:
return func(m *ice.Message, arg ...string) {
m.Option(mdb.SHORT, mdb.TYPE)
m.Cmd(sub, mdb.CREATE, key, m.PrefixKey())
}, nil
}

2
core/wiki/data.go
View File

@ -26,7 +26,7 @@ func init() {
m.Cmd("", nfs.SAVE, m.Option(nfs.PATH), kit.Join(kit.Split(m.Option(mdb.FIELD)))+ice.NL+kit.Join(kit.Split(m.Option(mdb.VALUE)))+ice.NL)
}},
nfs.PUSH: {Name: "push path record", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(nfs.PUSH, path.Join(m.Config(nfs.PATH), arg[0]), kit.Join(arg[1:], ice.FS)+ice.NL)
m.Cmd(nfs.PUSH, path.Join(mdb.Config(m, nfs.PATH), arg[0]), kit.Join(arg[1:], ice.FS)+ice.NL)
}}, "draw": {Help: "绘图"},
}, WikiAction(ice.USR_LOCAL_EXPORT, nfs.CSV)), Hand: func(m *ice.Message, arg ...string) {
if !_wiki_list(m, arg...) {

3
core/wiki/spark.go
View File

@ -4,6 +4,7 @@ import (
"strings"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/ssh"
kit "shylinux.com/x/toolkits"
@ -19,7 +20,7 @@ func _spark_show(m *ice.Message, name, text string, arg ...string) *ice.Message
case "inner", FIELD:
return m.Echo(text)
}
prompt := kit.Select(name+"> ", m.Config(kit.Keys(ssh.PROMPT, name)))
prompt := kit.Select(name+"> ", mdb.Config(m, kit.Keys(ssh.PROMPT, name)))
for _, l := range kit.SplitLine(text) {
m.Echo(Format("div", Format("label", prompt), Format("span", l)))
}

2
core/wiki/title.go
View File

@ -22,7 +22,7 @@ func _title_menu(m *ice.Message, kind, text string, arg ...string) *ice.Message
if kind == NAVMENU {
m.Option(mdb.DATA, _title_parse(m, path.Dir(m.Option(ice.MSG_SCRIPT)), text))
}
return _option(m, kind, "", text, arg...).RenderTemplate(m.Config(kind), &Message{m})
return _option(m, kind, "", text, arg...).RenderTemplate(mdb.Config(m, kind), &Message{m})
}
func _title_show(m *ice.Message, kind, text string, arg ...string) *ice.Message {
switch title, _ := m.Optionv(TITLE).(map[string]int); kind {

8
core/wiki/wiki.go
View File

@ -46,7 +46,7 @@ func _wiki_list(m *ice.Message, arg ...string) bool {
if m.Option(nfs.DIR_DEEP) != ice.TRUE {
m.Cmdy(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.DIR))
}
m.Cmdy(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.CAT, nfs.DIR_REG, m.Config(lex.REGEXP)))
m.Cmdy(nfs.DIR, kit.Slice(arg, 0, 1), kit.Dict(nfs.DIR_TYPE, nfs.CAT, nfs.DIR_REG, mdb.Config(m, lex.REGEXP)))
m.StatusTimeCount()
m.SortTimeR(mdb.TIME)
return true
@ -64,7 +64,7 @@ func _wiki_upload(m *ice.Message, dir string) {
m.Cmdy(web.CACHE, web.WATCH, m.Option(ice.MSG_UPLOAD), _wiki_path(m, dir, m.Option(mdb.NAME)))
}
func _wiki_template(m *ice.Message, name, text string, arg ...string) *ice.Message {
return _option(m, m.CommandKey(), name, strings.TrimSpace(text), arg...).RenderTemplate(m.Config(nfs.TEMPLATE), &Message{m})
return _option(m, m.CommandKey(), name, strings.TrimSpace(text), arg...).RenderTemplate(mdb.Config(m, nfs.TEMPLATE), &Message{m})
}
const WIKI = "wiki"
@ -88,8 +88,8 @@ func WikiAction(dir string, ext ...string) ice.Actions {
mdb.INPUTS: {Hand: func(m *ice.Message, arg ...string) {
switch arg[0] {
case nfs.PATH:
m.Option(nfs.DIR_REG, m.Config(lex.REGEXP))
m.Cmdy(nfs.DIR, path.Join(m.Config(nfs.PATH), kit.Select("", arg, 1)))
m.Option(nfs.DIR_REG, mdb.Config(m, lex.REGEXP))
m.Cmdy(nfs.DIR, path.Join(mdb.Config(m, nfs.PATH), kit.Select("", arg, 1)))
case ctx.INDEX:
m.Cmdy(ctx.COMMAND, mdb.SEARCH, ctx.COMMAND, ice.OptionFields(ctx.INDEX))
}

2
core/wiki/word.go
View File

@ -62,5 +62,5 @@ func WordAction(template string, arg ...ice.Any) ice.Actions {
return ice.Actions{ice.CTX_INIT: mdb.AutoConfig(append([]ice.Any{nfs.TEMPLATE, template}, arg...)...)}
}
func WordAlias(m *ice.Message, cmd string, cmds ...string) {
m.Conf(WORD, kit.Keym(mdb.ALIAS, cmd), cmds)
mdb.Conf(m, WORD, kit.Keym(mdb.ALIAS, cmd), cmds)
}

22
data.go
View File

@ -22,28 +22,12 @@ func (m *Message) PrefixKey(arg ...Any) string {
return kit.Keys(m.Prefix(m.CommandKey()), kit.Keys(arg...))
}
func (m *Message) Prefix(arg ...string) string {
return m.Target().PrefixKey(arg...)
return m.Target().Prefix(arg...)
}
func (m *Message) PrefixPath(arg ...Any) string {
return strings.TrimPrefix(path.Join(strings.ReplaceAll(m.PrefixRawKey(arg...), PT, PS)), "web") + PS
}
func (m *Message) Config(key string, arg ...Any) string {
return kit.Format(m.Configv(key, arg...))
}
func (m *Message) Configv(key string, arg ...Any) Any {
if len(arg) > 0 {
m.Confv(m.PrefixKey(), kit.Keym(key), arg[0])
}
return m.Confv(m.PrefixKey(), kit.Keym(key))
}
func (m *Message) ConfigSimple(key ...string) (res []string) {
for _, k := range kit.Split(kit.Join(key)) {
res = append(res, k, m.Config(k))
}
return
}
func loadImportant(m *Message) {
if f, e := os.Open(VAR_DATA_IMPORTANT); e == nil {
defer f.Close()
@ -61,9 +45,7 @@ func SaveImportant(m *Message, arg ...string) {
return
}
for i, v := range arg {
if v == "" || strings.Contains(v, SP) {
arg[i] = "\"" + v + "\""
}
kit.If(v == "" || strings.Contains(v, SP), func() { arg[i] = "\"" + v + "\"" })
}
m.Cmd("nfs.push", VAR_DATA_IMPORTANT, kit.Join(arg, SP), NL)
}

3
init.go
View File

@ -27,8 +27,6 @@ func (s *Frame) Begin(m *Message, arg ...string) Server {
func (s *Frame) Start(m *Message, arg ...string) bool {
m.Cap(CTX_STREAM, strings.Split(m.Time(), SP)[1])
m.Cmd(kit.Keys(MDB, CTX_INIT))
m.Cmd(kit.Keys(AAA, CTX_INIT))
m.Cmd(kit.Keys(CLI, CTX_INIT))
m.Cmd(INIT, arg)
for _, k := range kit.Split(kit.Select("ctx,log,gdb,ssh", os.Getenv(CTX_DAEMON))) {
m.Start(k)
@ -70,7 +68,6 @@ var Index = &Context{Name: ICE, Help: "冰山模块", Configs: Configs{HELP: {Va
m.Cmd(CTX_INIT)
m.Cmd(SOURCE, ETC_INIT_SHY)
}},
HELP: {Hand: func(m *Message, arg ...string) { m.Echo(m.Config(INDEX)) }},
QUIT: {Hand: func(m *Message, arg ...string) { os.Exit(0) }},
EXIT: {Hand: func(m *Message, arg ...string) {
m.root.Option(EXIT, kit.Select("0", arg, 0))

18
logs.go
View File

@ -225,24 +225,20 @@ func (m *Message) FormatChain() string {
ms = append(ms, msg)
}
show := func(msg *Message, meta string) string {
if len(msg.meta[meta]) > 0 {
return kit.Format("%s:%d %v", meta, len(msg.meta[meta]), msg.meta[meta])
}
if len(msg.meta[meta]) == 0 || len(msg.meta[meta]) == 1 && msg.meta[meta][0] == "" {
return ""
}
return kit.Format("%s:%d %v", meta, len(msg.meta[meta]), msg.meta[meta])
}
meta := []string{}
for i := len(ms) - 1; i >= 0; i-- {
msg := ms[i]
meta = append(meta, kit.Join([]string{
msg.FormatPrefix(),
show(msg, MSG_DETAIL),
show(msg, MSG_OPTION),
show(msg, MSG_APPEND),
show(msg, MSG_RESULT),
msg._cmd.GetFileLine(),
}, " "))
meta = append(meta, kit.Join([]string{msg.FormatPrefix(), show(msg, MSG_DETAIL), show(msg, MSG_OPTION), show(msg, MSG_APPEND), show(msg, MSG_RESULT), msg._cmd.GetFileLine()}, SP))
for _, k := range msg.meta[MSG_OPTION] {
if v, ok := msg.meta[k]; ok {
if len(v) == 0 || len(v) == 1 && v[0] == "" {
continue
}
meta = append(meta, kit.Format("\t%s: %d %v", k, len(v), v))
}
}

2
misc.go
View File

@ -421,8 +421,8 @@ func SplitCmd(name string, actions Actions) (list []Any) {
case PAGE:
push(TEXT, "limit")
push(TEXT, "offend")
push(BUTTON, "next")
push(BUTTON, "prev")
push(BUTTON, "next")
case ARGS, TEXT, TEXTAREA, CONTENT:
push(TEXTAREA, ls[i])
case PASSWORD:

13
misc/alpha/alpha.go
View File

@ -6,6 +6,7 @@ import (
"shylinux.com/x/ice"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/core/wiki"
@ -30,13 +31,13 @@ type alpha struct {
func (s alpha) Load(m *ice.Message, arg ...string) {
lib := kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.ZONE))
m.Assert(nfs.RemoveAll(m, path.Join(m.Config(mdb.STORE), lib)))
m.Assert(nfs.RemoveAll(m, path.Join(mdb.Config(m, mdb.STORE), lib)))
s.Zone.Remove(m, mdb.ZONE, lib)
s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, m.ConfigSimple(mdb.FIELD, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, ctx.ConfigSimple(m.Message, mdb.FIELD, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
prefix := kit.Keys(mdb.HASH, m.Result())
m.Cmd(mdb.IMPORT, m.PrefixKey(), prefix, mdb.LIST, m.Option(nfs.FILE))
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
mdb.Conf(m, "", kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
mdb.Conf(m, "", kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
m.Echo("%s: %d", lib, mdb.Grow(m, m.PrefixKey(), prefix, kit.Dict(WORD, ice.SP)))
}
func (s alpha) List(m *ice.Message, arg ...string) {
@ -54,8 +55,8 @@ func (s alpha) List(m *ice.Message, arg ...string) {
m.OptionFields(ice.FIELDS_DETAIL)
arg[1] = "^" + arg[1] + ice.FS
}
wiki.CSV(m.Message.Spawn(), m.Cmdx(cli.SYSTEM, "grep", "-rih", arg[1], m.Config(mdb.STORE)), kit.Split(m.Config(mdb.FIELD))...).Tables(func(value ice.Maps) {
kit.If(m.FieldsIsDetail(), func() { m.PushDetail(value, m.Config(mdb.FIELD)) }, func() { m.PushRecord(value, m.Config(mdb.FIELD)) })
wiki.CSV(m.Message.Spawn(), m.Cmdx(cli.SYSTEM, "grep", "-rih", arg[1], mdb.Config(m, mdb.STORE)), kit.Split(mdb.Config(m, mdb.FIELD))...).Tables(func(value ice.Maps) {
kit.If(m.FieldsIsDetail(), func() { m.PushDetail(value, mdb.Config(m, mdb.FIELD)) }, func() { m.PushRecord(value, mdb.Config(m, mdb.FIELD)) })
}).StatusTimeCount()
}

6
misc/bash/bash.go
View File

@ -3,6 +3,8 @@ package bash
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/code"
@ -13,10 +15,10 @@ const BASH = "bash"
var Index = &ice.Context{Name: BASH, Help: "命令行", Commands: ice.Commands{
BASH: {Name: "bash path auto order build download", Help: "命令行", Actions: ice.MergeActions(ice.Actions{
cli.ORDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
m.Cmdy(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/bin")
}},
}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/bash/5.1_1/bash-5.1.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
}},
}}

6
misc/bash/zsh.go
View File

@ -3,6 +3,8 @@ package bash
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/core/code"
)
@ -13,10 +15,10 @@ func init() {
Index.MergeCommands(ice.Commands{
ZSH: {Name: "zsh path auto order build download", Help: "命令行", Actions: ice.MergeActions(ice.Actions{
cli.ORDER: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
m.Cmdy(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/bin")
}},
}, code.InstallAction(nfs.SOURCE, "https://nchc.dl.sourceforge.net/project/zsh/zsh/5.8/zsh-5.8.tar.xz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
}},
})
}

2
misc/chrome/cache.go
View File

@ -28,7 +28,7 @@ func (s cache) Create(m *ice.Message, arg ...string) *ice.Message {
s.Hash.Modify(m, kit.Simple(mdb.COUNT, count, mdb.TOTAL, total, mdb.VALUE, value)...)
})
name := kit.Keys(path.Base(m.Append(nfs.FILE)), path.Base(m.Append(mdb.TYPE)))
m.Cmdy(nfs.LINK, path.Join(m.Config(nfs.PATH), name), m.Append(nfs.FILE))
m.Cmdy(nfs.LINK, path.Join(mdb.Config(m, nfs.PATH), name), m.Append(nfs.FILE))
s.Hash.Modify(m, mdb.NAME, name)
web.ToastSuccess(m.Message)
return m

2
misc/coder/server.go
View File

@ -36,7 +36,7 @@ func (s server) Start(m *ice.Message, arg ...string) {
user-data-dir: %s
bind-addr: %s:%s
password: %s
`, "./data", kit.Select("0.0.0.0", m.Option(tcp.HOST)), path.Base(p), kit.Select(m.Config(aaa.PASSWORD), m.Option(aaa.PASSWORD))))
`, "./data", kit.Select("0.0.0.0", m.Option(tcp.HOST)), path.Base(p), kit.Select(mdb.Config(m, aaa.PASSWORD), m.Option(aaa.PASSWORD))))
return []string{"--config=config", kit.Path(nfs.PWD)}
})
}

2
misc/git/configs.go
View File

@ -40,7 +40,7 @@ func init() {
Index.MergeCommands(ice.Commands{
CONFIGS: {Name: "configs name value auto create init", Help: "配置键", Actions: ice.MergeActions(ice.Actions{
ice.INIT: {Help: "初始化", Hand: func(m *ice.Message, arg ...string) {
kit.Fetch(m.Configv(ice.INIT), func(p string, v ice.Any) {
kit.Fetch(mdb.Configv(m, ice.INIT), func(p string, v ice.Any) {
kit.Fetch(v, func(k string, v string) { _configs_set(m, kit.Keys(p, k), v) })
})
}},

8
misc/git/git.go
View File

@ -5,6 +5,8 @@ import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/code"
@ -23,11 +25,11 @@ const GIT = "git"
var Index = &ice.Context{Name: GIT, Help: "代码库", Commands: ice.Commands{
GIT: {Name: "git path auto order build download", Help: "代码库", Actions: ice.MergeActions(ice.Actions{
cli.ORDER: {Help: "加载", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/libexec/git-core")
m.Cmdy(code.INSTALL, cli.ORDER, m.Config(nfs.SOURCE), "_install/bin")
m.Cmd(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/libexec/git-core")
m.Cmdy(code.INSTALL, cli.ORDER, mdb.Config(m, nfs.SOURCE), "_install/bin")
}},
}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/git-cinnabar/git-2.31.1.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
}},
}}

2
misc/git/server.go
View File

@ -23,7 +23,7 @@ import (
)
func _server_login(m *ice.Message) error {
if tcp.IsLocalHost(m, m.Option(ice.MSG_USERIP)) && m.Conf("web.serve", kit.Keym(tcp.LOCALHOST)) == ice.TRUE {
if tcp.IsLocalHost(m, m.Option(ice.MSG_USERIP)) && ice.Info.Localhost {
return nil
}
ls := strings.SplitN(m.R.Header.Get(web.Authorization), ice.SP, 2)

2
misc/git/status.go
View File

@ -82,7 +82,7 @@ func _status_tags(m *ice.Message) {
}
func _status_each(m *ice.Message, title string, cmds ...string) {
web.GoToast(m, kit.Select(strings.Join(cmds, ice.SP), title), func(toast func(string, int, int)) {
list, count, total := []string{}, 0, len(m.Confm(REPOS, mdb.HASH))
list, count, total := []string{}, 0, m.Cmd(REPOS).Length()
ReposList(m).Tables(func(value ice.Maps) {
toast(value[REPOS], count, total)
if msg := m.Cmd(cmds, kit.Dict(cli.CMD_DIR, value[nfs.PATH])); !cli.IsSuccess(msg) {

2
misc/git/total.go
View File

@ -45,7 +45,7 @@ func init() {
}
from, days, adds, dels, rest, commit := "", 0, 0, 0, 0, 0
ReposList(m).TableGo(func(value ice.Maps, lock *task.Lock) {
if m.Config(kit.Keys("skip", value[REPOS])) == ice.TRUE {
if mdb.Config(m, kit.Keys("skip", value[REPOS])) == ice.TRUE {
return
}
msg := m.Cmd("_sum", value[nfs.PATH], mdb.TOTAL, "10000")

11
misc/input/input.go
View File

@ -10,6 +10,7 @@ import (
"shylinux.com/x/ice"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
kit "shylinux.com/x/toolkits"
@ -45,9 +46,9 @@ func (s input) Load(m *ice.Message, arg ...string) {
if f, e := nfs.OpenFile(m, m.Option(nfs.FILE)); !m.Warn(e) {
defer f.Close()
lib := kit.Select(path.Base(m.Option(nfs.FILE)), m.Option(mdb.ZONE))
m.Assert(nfs.RemoveAll(m, path.Join(m.Config(mdb.STORE), lib)))
m.Assert(nfs.RemoveAll(m, path.Join(mdb.Config(m, mdb.STORE), lib)))
s.Zone.Remove(m, mdb.ZONE, lib)
s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, m.ConfigSimple(mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
s.Zone.Create(m, kit.Simple(mdb.ZONE, lib, ctx.ConfigSimple(m.Message, mdb.LIMIT, mdb.LEAST, mdb.STORE, mdb.FSIZE))...)
prefix := kit.Keys(mdb.HASH, m.Result())
for bio := bufio.NewScanner(f); bio.Scan(); {
if strings.HasPrefix(bio.Text(), "# ") {
@ -59,8 +60,8 @@ func (s input) Load(m *ice.Message, arg ...string) {
}
mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(TEXT, line[0], CODE, line[1], WEIGHT, kit.Select("999999", line, 2)))
}
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
m.Conf(m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
mdb.Conf(m, m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LIMIT)), 0)
mdb.Conf(m, m.PrefixKey(), kit.Keys(prefix, kit.Keym(mdb.LEAST)), 0)
m.Echo("%s: %d", lib, mdb.Grow(m.Message, m.PrefixKey(), prefix, kit.Dict(TEXT, "成功", CODE, "z", WEIGHT, "0")))
}
}
@ -92,7 +93,7 @@ func (s input) List(m *ice.Message, arg ...string) {
case WORD:
arg[1] = "^" + arg[1] + ice.FS
}
res := m.Cmdx(cli.SYSTEM, "grep", "-rn", arg[1], m.Config(mdb.STORE))
res := m.Cmdx(cli.SYSTEM, "grep", "-rn", arg[1], mdb.Config(m, mdb.STORE))
bio := csv.NewReader(bytes.NewBufferString(strings.Replace(res, ice.DF, ice.FS, -1)))
for i := 0; i < kit.Int(10); i++ {
if line, e := bio.Read(); e != nil {

2
misc/lark/app.go
View File

@ -22,7 +22,7 @@ const APP = "app"
func init() {
Index.MergeCommands(ice.Commands{
APP: {Name: "app appid auto token login", Help: "应用", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, LARK, m.Config(tcp.SERVER)) }},
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, LARK, mdb.Config(m, tcp.SERVER)) }},
LOGIN: {Name: "login appid* appmm* duty", Help: "登录", Hand: func(m *ice.Message, arg ...string) {
mdb.HashCreate(m, m.OptionSimple(APPID, APPMM, DUTY))
}},

4
misc/lark/event.go
View File

@ -21,14 +21,14 @@ func init() {
EVENT: {Name: "event", Help: "事件", Actions: ice.Actions{
P2P_CHAT_CREATE: {Hand: func(m *ice.Message, arg ...string) {
if m.Option(OPEN_CHAT_ID) != "" {
m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), m.Conf(APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), mdb.Conf(m, APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
}
}},
MESSAGE_READ: {Hand: func(m *ice.Message, arg ...string) {}},
CHAT_DISBAND: {Hand: func(m *ice.Message, arg ...string) {}},
ADD_BOT: {Hand: func(m *ice.Message, arg ...string) {
if m.Option(OPEN_CHAT_ID) != "" {
m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), m.Conf(APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
m.Cmdy(SEND, m.Option(APP_ID), m.Option(OPEN_CHAT_ID), mdb.Conf(m, APP, kit.Keym(nfs.TEMPLATE, m.Option(mdb.TYPE))))
}
}},
}, Hand: func(m *ice.Message, arg ...string) { m.Cmdy(MSG, m.Option(MSG_TYPE)) }},

2
misc/lark/home.go
View File

@ -16,7 +16,7 @@ func init() {
name := kit.Select(m.Option(ice.MSG_USERNAME), m.Option(ice.MSG_USERNICK))
kit.If(len(name) > 10, func() { name = name[:10] })
name += "的" + kit.Select("应用列表", arg, 2)
text, link, list := kit.Select("", arg, 3), kit.MergeURL2(m.Conf(web.SHARE, kit.Keym(web.DOMAIN)), "/chat/lark/sso"), []string{}
text, link, list := kit.Select("", arg, 3), kit.MergeURL2(mdb.Conf(m, web.SHARE, kit.Keym(web.DOMAIN)), "/chat/lark/sso"), []string{}
if len(arg) == 0 {
m.Cmd("web.chat./river", func(val ice.Maps) {
m.Cmd("web.chat./river", val[mdb.HASH], chat.STORM, func(value ice.Maps) {

16
misc/mp/login.go
View File

@ -33,9 +33,9 @@ const LOGIN = "login"
func init() {
Index.MergeCommands(ice.Commands{
web.PP(LOGIN): {Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, MP, m.Config(tcp.SERVER)) }},
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { m.Cmd(web.SPIDE, mdb.CREATE, MP, mdb.Config(m, tcp.SERVER)) }},
aaa.SESS: {Name: "sess code", Help: "会话", Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/sns/jscode2session?grant_type=authorization_code", "js_code", m.Option(cli.CODE), APPID, m.Config(APPID), "secret", m.Config(APPMM))
msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/sns/jscode2session?grant_type=authorization_code", "js_code", m.Option(cli.CODE), APPID, mdb.Config(m, APPID), "secret", mdb.Config(m, APPMM))
m.Option(ice.MSG_USERZONE, MP)
m.Echo(aaa.SessCreate(msg, msg.Append(OPENID)))
}},
@ -54,20 +54,20 @@ func init() {
ctx.ConfigFromOption(m, APPID, APPMM)
}},
TOKENS: {Help: "令牌", Hand: func(m *ice.Message, arg ...string) {
if now := time.Now().Unix(); m.Config(TOKENS) == "" || now > kit.Int64(m.Config(EXPIRES)) {
msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, m.Config(APPID), "secret", m.Config(APPMM))
if now := time.Now().Unix(); mdb.Config(m, TOKENS) == "" || now > kit.Int64(mdb.Config(m, EXPIRES)) {
msg := m.Cmd(web.SPIDE, MP, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, mdb.Config(m, APPID), "secret", mdb.Config(m, APPMM))
if m.Warn(msg.Append(ERRCODE) != "", msg.Append(ERRCODE), msg.Append(ERRMSG)) {
return
}
m.Config(EXPIRES, now+kit.Int64(msg.Append("expires_in")))
m.Config(TOKENS, msg.Append("access_token"))
mdb.Config(m, EXPIRES, now+kit.Int64(msg.Append("expires_in")))
mdb.Config(m, TOKENS, msg.Append("access_token"))
}
m.Echo(m.Config(TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(m.Config(EXPIRES)), 0).Format(ice.MOD_TIME))
m.Echo(mdb.Config(m, TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(mdb.Config(m, EXPIRES)), 0).Format(ice.MOD_TIME))
}},
QRCODE: {Name: "qrcode path scene", Help: "扫码", Hand: func(m *ice.Message, arg ...string) {
msg := m.Cmd(web.SPIDE, MP, http.MethodPost, "/wxa/getwxacodeunlimit?access_token="+m.Cmdx(LOGIN, TOKENS), m.OptionSimple("path,scene"))
m.Echo(kit.Format(`<img src="data:image/png;base64,%s" title='%s'>`, base64.StdEncoding.EncodeToString([]byte(msg.Result())), "some")).ProcessInner()
}},
}, Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(APPID)) }},
}, Hand: func(m *ice.Message, arg ...string) { m.Echo(mdb.Config(m, APPID)) }},
})
}

2
misc/ssh/rsa.go
View File

@ -53,7 +53,7 @@ func init() {
})
}},
mdb.IMPORT: {Name: "import key=.ssh/id_rsa pub=.ssh/id_rsa.pub", Hand: func(m *ice.Message, arg ...string) {
m.Conf("", kit.Keys(mdb.HASH, path.Base(m.Option(KEY))), kit.Data(mdb.TIME, m.Time(),
mdb.Conf(m, "", kit.Keys(mdb.HASH, path.Base(m.Option(KEY))), kit.Data(mdb.TIME, m.Time(),
TITLE, kit.Format("%s@%s", ice.Info.Username, ice.Info.Hostname),
PRIVATE, m.Cmdx(nfs.CAT, kit.HomePath(m.Option(KEY))),
PUBLIC, m.Cmdx(nfs.CAT, kit.HomePath(m.Option(PUB))),

6
misc/ssh/service.go
View File

@ -124,11 +124,11 @@ func _ssh_handle(m *ice.Message, channel ssh.Channel, pty, tty *os.File, list []
h := m.Cmdx(mdb.INSERT, m.Prefix(CHANNEL), "", mdb.HASH, mdb.STATUS, tcp.OPEN, TTY, tty.Name(), m.OptionSimple(aaa.USERNAME, tcp.HOSTPORT), kit.Dict(mdb.TARGET, pty))
p := _ssh_watch(m, h, pty, channel)
m.Go(func() { io.Copy(channel, pty) })
channel.Write([]byte(m.Config(WELCOME)))
channel.Write([]byte(mdb.Config(m, WELCOME)))
m.Options(cli.CMD_INPUT, tty, cli.CMD_OUTPUT, tty)
m.Cmd(cli.DAEMON, kit.Select("sh", kit.Env(cli.SHELL)), func() {
defer m.Cmd(mdb.MODIFY, m.Prefix(CHANNEL), "", mdb.HASH, mdb.HASH, h, mdb.STATUS, tcp.CLOSE)
channel.Write([]byte(m.Config(GOODBYE)))
channel.Write([]byte(mdb.Config(m, GOODBYE)))
channel.Close()
p.Close()
})
@ -197,7 +197,7 @@ func init() {
mdb.SHORT, tcp.PORT, mdb.FIELD, "time,port,status,private,authkey,count", mdb.FIELDS, "time,id,type,name,text",
WELCOME, "welcome to contexts world\r\n", GOODBYE, "goodbye of contexts world\r\n",
)), Hand: func(m *ice.Message, arg ...string) {
m.Fields(len(arg), m.Config(mdb.FIELD), m.Config(mdb.FIELDS))
m.Fields(len(arg), mdb.Config(m, mdb.FIELD), mdb.Config(m, mdb.FIELDS))
if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
m.PushAction(aaa.INVITE, mdb.INSERT, ctx.LOAD, ctx.SAVE, mdb.REMOVE)
}

2
misc/ssh/session.go
View File

@ -60,7 +60,7 @@ func init() {
}
}},
}, mdb.PageZoneAction(mdb.SHORT, mdb.UNIQ, mdb.FIELD, "time,hash,count,status,connect", mdb.FIELDS, "time,id,type,text")), Hand: func(m *ice.Message, arg ...string) {
m.Fields(len(kit.Slice(arg, 0, 2)), m.Config(mdb.FIELD), m.Config(mdb.FIELDS))
m.Fields(len(kit.Slice(arg, 0, 2)), mdb.Config(m, mdb.FIELD), mdb.Config(m, mdb.FIELDS))
if mdb.PageZoneSelect(m, arg...); len(arg) == 0 {
m.Tables(func(value ice.Maps) {
m.PushButton(kit.Select("", ctx.COMMAND, value[mdb.STATUS] == tcp.OPEN), mdb.REMOVE)

6
misc/tmux/session.go
View File

@ -180,17 +180,17 @@ func init() {
} else if len(arg) > 0 {
m.Cmdy(WINDOW, arg[0])
} else {
m.Split(_tmux_cmd(m, LIST_SESSION, "-F", m.Config(FORMAT)).Result(), m.Config(FIELDS), ice.FS, ice.NL)
m.Split(_tmux_cmd(m, LIST_SESSION, "-F", mdb.Config(m, FORMAT)).Result(), mdb.Config(m, FIELDS), ice.FS, ice.NL)
}
m.Tables(func(value ice.Maps) {
kit.If(value["tag"] == "1", func() { m.PushButton("") }, func() { m.PushButton(code.XTERM, mdb.SELECT, mdb.REMOVE) })
}).StatusTimeCount()
}},
WINDOW: {Hand: func(m *ice.Message, arg ...string) {
m.Split(m.Cmdx(cli.SYSTEM, TMUX, LIST_WINDOWS, "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
m.Split(m.Cmdx(cli.SYSTEM, TMUX, LIST_WINDOWS, "-t", kit.Select("", arg, 0), "-F", mdb.Config(m, FORMAT)), mdb.Config(m, FIELDS), ice.FS, ice.NL)
}},
PANE: {Hand: func(m *ice.Message, arg ...string) {
m.Split(_tmux_cmds(m, LIST_PANES, "-t", kit.Select("", arg, 0), "-F", m.Config(FORMAT)), m.Config(FIELDS), ice.FS, ice.NL)
m.Split(_tmux_cmds(m, LIST_PANES, "-t", kit.Select("", arg, 0), "-F", mdb.Config(m, FORMAT)), mdb.Config(m, FIELDS), ice.FS, ice.NL)
}},
VIEW: {Hand: func(m *ice.Message, arg ...string) {
m.Echo(_tmux_cmds(m, CAPTURE_PANE, "-p", "-t", kit.Select("", arg, 0)))

6
misc/tmux/tmux.go
View File

@ -3,6 +3,8 @@ package tmux
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/code"
@ -17,10 +19,10 @@ var Index = &ice.Context{Name: TMUX, Help: "工作台", Commands: ice.Commands{
m.Optionv(code.PREPARE, func(p string) []string {
return []string{"-S", kit.Path(m.Option(cli.CMD_DIR, p), "tmux.socket"), NEW_SESSION, "-d", "-n", "miss"}
})
m.Cmdy(code.INSTALL, cli.START, m.Config(nfs.SOURCE), "bin/tmux")
m.Cmdy(code.INSTALL, cli.START, mdb.Config(m, nfs.SOURCE), "bin/tmux")
}},
}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/tmux/tmux-3.2.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
}},
}}

6
misc/vim/vim.go
View File

@ -3,6 +3,8 @@ package vim
import (
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/cli"
"shylinux.com/x/icebergs/base/ctx"
"shylinux.com/x/icebergs/base/mdb"
"shylinux.com/x/icebergs/base/nfs"
"shylinux.com/x/icebergs/base/web"
"shylinux.com/x/icebergs/core/code"
@ -13,10 +15,10 @@ const VIM = "vim"
var Index = &ice.Context{Name: VIM, Help: "编辑器", Commands: ice.Commands{
VIM: {Name: "vim path auto order build download", Help: "编辑器", Actions: ice.MergeActions(ice.Actions{
cli.BUILD: {Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, cli.BUILD, m.Config(nfs.SOURCE), "--enable-multibyte=yes", "--enable-cscope=yes", "--enable-luainterp=yes", "--enable-pythoninterp=yes")
m.Cmdy(code.INSTALL, cli.BUILD, mdb.Config(m, nfs.SOURCE), "--enable-multibyte=yes", "--enable-cscope=yes", "--enable-luainterp=yes", "--enable-pythoninterp=yes")
}},
}, code.InstallAction(nfs.SOURCE, "http://mirrors.tencent.com/macports/distfiles/vim/vim-8.2.2681.tar.gz")), Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(code.INSTALL, m.ConfigSimple(nfs.SOURCE), arg)
m.Cmdy(code.INSTALL, ctx.ConfigSimple(m, nfs.SOURCE), arg)
}},
}}

30
misc/wx/access.go
View File

@ -27,10 +27,10 @@ func _wx_sign(m *ice.Message, nonce, stamp string) string {
}
func _wx_config(m *ice.Message, nonce string) {
m.Option("signature", _wx_sign(m, m.Option("noncestr", nonce), m.Option("timestamp", kit.Format(time.Now().Unix()))))
m.OptionFromConfig(APPID, nfs.SCRIPT)
ctx.OptionFromConfig(m, APPID, nfs.SCRIPT)
}
func _wx_check(m *ice.Message) {
check := kit.Sort([]string{m.Config(TOKEN), m.Option("timestamp"), m.Option("nonce")})
check := kit.Sort([]string{mdb.Config(m, TOKEN), m.Option("timestamp"), m.Option("nonce")})
if sig := kit.Format(sha1.Sum([]byte(strings.Join(check, "")))); !m.Warn(sig != m.Option("signature"), ice.ErrNotRight, check) {
kit.If(m.Option("echostr") != "", func() { m.RenderResult(m.Option("echostr")) }, func() { m.Echo(ice.TRUE) })
}
@ -57,43 +57,43 @@ func init() {
Index.MergeCommands(ice.Commands{
ACCESS: {Name: "access appid auto ticket tokens login", Help: "认证", Actions: ice.MergeActions(ice.Actions{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Cmd(web.SPIDE, mdb.CREATE, WX, m.Config(tcp.SERVER))
m.Cmd(web.SPIDE, mdb.CREATE, WX, mdb.Config(m, tcp.SERVER))
gdb.Watch(m, chat.HEADER_AGENT, m.PrefixKey())
}},
chat.HEADER_AGENT: {Hand: func(m *ice.Message, arg ...string) {
if strings.Index(m.Option(ice.MSG_USERUA), "MicroMessenger") > -1 {
_wx_config(m, m.Config(APPID))
_wx_config(m, mdb.Config(m, APPID))
}
}},
LOGIN: {Name: "login appid appmm token", Help: "登录", Hand: func(m *ice.Message, arg ...string) {
ctx.ConfigFromOption(m, APPID, APPMM, TOKEN)
}},
TOKENS: {Help: "令牌", Hand: func(m *ice.Message, arg ...string) {
if now := time.Now().Unix(); m.Config(TOKENS) == "" || now > kit.Int64(m.Config(EXPIRES)) {
msg := m.Cmd(web.SPIDE, WX, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, m.Config(APPID), "secret", m.Config(APPMM))
if now := time.Now().Unix(); mdb.Config(m, TOKENS) == "" || now > kit.Int64(mdb.Config(m, EXPIRES)) {
msg := m.Cmd(web.SPIDE, WX, http.MethodGet, "/cgi-bin/token?grant_type=client_credential", APPID, mdb.Config(m, APPID), "secret", mdb.Config(m, APPMM))
if m.Warn(msg.Append(ERRCODE) != "", msg.Append(ERRCODE), msg.Append(ERRMSG)) {
return
}
m.Config(EXPIRES, now+kit.Int64(msg.Append("expires_in")))
m.Config(TOKENS, msg.Append("access_token"))
mdb.Config(m, EXPIRES, now+kit.Int64(msg.Append("expires_in")))
mdb.Config(m, TOKENS, msg.Append("access_token"))
}
m.Echo(m.Config(TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(m.Config(EXPIRES)), 0).Format(ice.MOD_TIME))
m.Echo(mdb.Config(m, TOKENS)).Status(EXPIRES, time.Unix(kit.Int64(mdb.Config(m, EXPIRES)), 0).Format(ice.MOD_TIME))
}},
TICKET: {Help: "票据", Hand: func(m *ice.Message, arg ...string) {
if now := time.Now().Unix(); m.Config(TICKET) == "" || now > kit.Int64(m.Config(EXPIRE)) {
if now := time.Now().Unix(); mdb.Config(m, TICKET) == "" || now > kit.Int64(mdb.Config(m, EXPIRE)) {
msg := m.Cmd(web.SPIDE, WX, http.MethodGet, "/cgi-bin/ticket/getticket?type=jsapi", "access_token", m.Cmdx("", TOKENS))
if m.Warn(msg.Append(ERRCODE) != "0", msg.Append(ERRCODE), msg.Append(ERRMSG)) {
return
}
m.Config(EXPIRE, now+kit.Int64(msg.Append("expires_in")))
m.Config(TICKET, msg.Append(TICKET))
mdb.Config(m, EXPIRE, now+kit.Int64(msg.Append("expires_in")))
mdb.Config(m, TICKET, msg.Append(TICKET))
}
m.Echo(m.Config(TICKET)).Status(EXPIRE, time.Unix(kit.Int64(m.Config(EXPIRE)), 0).Format(ice.MOD_TIME))
m.Echo(mdb.Config(m, TICKET)).Status(EXPIRE, time.Unix(kit.Int64(mdb.Config(m, EXPIRE)), 0).Format(ice.MOD_TIME))
}},
CONFIG: {Hand: func(m *ice.Message, arg ...string) { _wx_config(m, m.Config(APPID)) }},
CONFIG: {Hand: func(m *ice.Message, arg ...string) { _wx_config(m, mdb.Config(m, APPID)) }},
CHECK: {Hand: func(m *ice.Message, arg ...string) { _wx_check(m) }},
}, mdb.HashAction(tcp.SERVER, "https://api.weixin.qq.com", nfs.SCRIPT, "/plugin/local/chat/wx.js")), Hand: func(m *ice.Message, arg ...string) {
m.Echo(m.Config(APPID))
m.Echo(mdb.Config(m, APPID))
}},
})
}

2
misc/wx/favor.go
View File

@ -15,7 +15,7 @@ func init() {
mdb.SHORT, mdb.TEXT, mdb.FIELD, "time,type,name,text", mdb.LINK, "https://open.weixin.qq.com/qr/code",
), Hand: func(m *ice.Message, arg ...string) {
mdb.HashSelect(m, arg...).Tables(func(value ice.Maps) {
m.PushQRCode(mdb.SCAN, kit.MergeURL(m.Config(mdb.LINK), aaa.USERNAME, value[mdb.TEXT]))
m.PushQRCode(mdb.SCAN, kit.MergeURL(mdb.Config(m, mdb.LINK), aaa.USERNAME, value[mdb.TEXT]))
})
}},
})

2
misc/wx/text.go
View File

@ -10,7 +10,7 @@ import (
)
func _wx_reply(m *ice.Message, tmpl string) {
if res, err := kit.Render(m.Config(nfs.TEMPLATE), m); err == nil {
if res, err := kit.Render(mdb.Config(m, nfs.TEMPLATE), m); err == nil {
m.SetResult().RenderResult(string(res))
}
}

9
option.go
View File

@ -18,12 +18,7 @@ func (m *Message) OptionFields(arg ...string) string {
}
return kit.Join(kit.Simple(m.Optionv(MSG_FIELDS)))
}
func (m *Message) OptionFromConfig(arg ...string) string {
for _, key := range arg {
m.Option(key, m.Config(key))
}
return m.Option(arg[0])
}
func (m *Message) OptionDefault(arg ...string) string {
for i := 0; i < len(arg); i += 2 {
if m.Option(arg[i]) == "" && arg[i+1] != "" {
@ -34,7 +29,7 @@ func (m *Message) OptionDefault(arg ...string) string {
}
func (m *Message) OptionSimple(key ...string) (res []string) {
if len(key) == 0 {
for _, k := range kit.Split(kit.Select("type,name,text", m.Config(FIELD))) {
for _, k := range kit.Split(kit.Select("type,name,text", m.Conf(m.PrefixKey(), kit.Keym(FIELD)))) {
switch k {
case TIME, HASH:
continue

17
type.go
View File

@ -18,12 +18,12 @@ type List = []Any
type Map = map[string]Any
type Maps = map[string]string
type Handler func(m *Message, arg ...string)
type Messages = map[string]*Message
type Contexts = map[string]*Context
type Commands = map[string]*Command
type Actions = map[string]*Action
type Configs = map[string]*Config
type Caches = map[string]*Cache
type Contexts = map[string]*Context
type Messages = map[string]*Message
type Cache struct {
Name string
@ -87,7 +87,7 @@ func (c *Context) Cmd(m *Message, key string, arg ...string) *Message {
func (c *Context) Server() Server {
return c.server
}
func (c *Context) PrefixKey(arg ...string) string {
func (c *Context) Prefix(arg ...string) string {
return kit.Keys(c.Cap(CTX_FOLLOW), arg)
}
func (c *Command) GetFileLine() string {
@ -522,9 +522,6 @@ func (m *Message) Cmdx(arg ...Any) string {
func (m *Message) Cmdy(arg ...Any) *Message {
return m.Copy(m._command(arg...))
}
func (m *Message) Confi(key string, sub string) int {
return kit.Int(m.Conf(key, sub))
}
func (m *Message) Confv(arg ...Any) (val Any) {
if m.Spawn().Warn(Info.Important && m.Option("_lock") == "") {
m.Warn(true, "what unsafe lock", m.PrefixKey(), m.FormatStack(1, 100))
@ -556,14 +553,6 @@ func (m *Message) Confv(arg ...Any) (val Any) {
}
return
}
func (m *Message) Confm(key string, sub Any, cbs ...Any) Map {
val := m.Confv(key, sub)
if len(cbs) > 0 {
kit.Fetch(val, cbs[0])
}
value, _ := val.(Map)
return value
}
func (m *Message) Conf(arg ...Any) string {
return kit.Format(m.Confv(arg...))
}