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

opt mdb

Browse Source
This commit is contained in:
shaoying 2022-11-24 13:24:09 +08:00
parent 33170bd6a9
commit 1301439db2
7 changed files with 83 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
base/mdb/engine.go
View File

@ -7,5 +7,5 @@ import (
const ENGINE = "engine"
func init() {
Index.MergeCommands(ice.Commands{ENGINE: {Name: "engine type name text auto", Help: "引擎", Actions: RenderAction()}})
Index.MergeCommands(ice.Commands{ENGINE: {Help: "引擎", Actions: RenderAction()}})
}

134
base/mdb/hash.go
View File

@ -24,7 +24,6 @@ func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
return
}
defer RLock(m, prefix, chain)()
list := map[string]int{}
Richs(m, prefix, chain, FOREACH, func(key string, val Map) {
val = kit.GetMeta(val)
@ -32,24 +31,18 @@ func _hash_inputs(m *ice.Message, prefix, chain string, field, value string) {
})
for k, i := range list {
if k != "" {
m.Push(field, k)
m.Push(COUNT, i)
m.Push(field, k).Push(COUNT, i)
}
}
m.SortIntR(COUNT)
}
func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) string {
m.Logs(INSERT, KEY, path.Join(prefix, chain), arg[0], arg[1])
defer Lock(m, prefix, chain)()
if value := m.Confm(prefix, kit.Keys(HASH, arg[1])); value != nil && arg[1] != "" {
value = kit.GetMeta(value)
for i := 2; i < len(arg)-1; i += 2 {
kit.Value(value, arg[i], arg[i+1])
}
if value := kit.GetMeta(m.Confm(prefix, kit.Keys(HASH, arg[1]))); value != nil && arg[1] != "" {
kit.Fetch(arg[2:], func(k, v string) { kit.Value(value, k, v)})
return arg[1]
}
m.Logs(INSERT, KEY, path.Join(prefix, chain), arg[0], arg[1])
if expire := m.Conf(prefix, kit.Keys(chain, kit.Keym(EXPIRE))); expire != "" {
arg = kit.Simple(TIME, m.Time(expire), arg)
}
@ -62,7 +55,6 @@ func _hash_insert(m *ice.Message, prefix, chain string, arg ...string) string {
}
func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
defer Lock(m, prefix, chain)()
Richs(m, prefix, chain, value, func(key string, val Map) {
if target, ok := kit.GetMeta(val)[TARGET].(io.Closer); ok {
target.Close()
@ -72,26 +64,18 @@ func _hash_delete(m *ice.Message, prefix, chain, field, value string) {
})
}
func _hash_modify(m *ice.Message, prefix, chain string, field, value string, arg ...string) {
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) {
m.Logs(MODIFY, KEY, path.Join(prefix, chain), field, value, arg)
_mdb_modify(m, val, field, arg...)
})
Richs(m, prefix, chain, value, func(key string, val Map) { _mdb_modify(m, val, field, arg...) })
}
func _hash_select(m *ice.Message, prefix, chain, field, value string) {
defer RLock(m, prefix, chain)()
if field == HASH && value == RANDOM {
value = RANDOMS
}
defer m.SortTimeR(TIME)
defer RLock(m, prefix, chain)()
fields := _hash_fields(m)
Richs(m, prefix, chain, value, func(key string, value Map) {
_mdb_select(m, m.OptionCB(""), key, value, fields, nil)
})
if !m.FieldsIsDetail() {
m.SortTimeR(TIME)
}
Richs(m, prefix, chain, value, func(key string, value Map) { _mdb_select(m, m.OptionCB(""), key, value, fields, nil) })
}
func _hash_select_field(m *ice.Message, prefix, chain string, key string, field string) (value string) {
defer RLock(m, prefix, chain)()
@ -106,70 +90,52 @@ func _hash_select_field(m *ice.Message, prefix, chain string, key string, field
}
func _hash_prunes(m *ice.Message, prefix, chain string, arg ...string) {
defer RLock(m, prefix, chain)()
fields := _hash_fields(m)
Richs(m, prefix, chain, FOREACH, func(key string, val Map) {
switch val = kit.GetMeta(val); cb := m.OptionCB(PRUNES).(type) {
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, val) {
return
if cb(key, value) {
m.Push(key, value, fields)
}
default:
for i := 0; i < len(arg)-1; i += 2 {
if val[arg[i]] != arg[i+1] && kit.Value(val, arg[i]) != arg[i+1] {
return
kit.Fetch(arg, func(k, v string) {
if value[k] == v || kit.Value(value, k) == v {
m.Push(key, value, fields)
}
}
})
}
m.Push(key, val, fields)
})
}
func _hash_export(m *ice.Message, prefix, chain, file string) {
defer Lock(m, prefix, chain)()
f, p, e := miss.CreateFile(kit.Keys(file, JSON))
m.Assert(e)
defer f.Close()
m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p)
defer m.Echo(p).StatusTime(LINK, "/share/local/"+p)
en := json.NewEncoder(f)
en.SetIndent("", " ")
m.Assert(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))))
m.Logs(EXPORT, KEY, path.Join(prefix, chain), FILE, p)
defer Lock(m, prefix, chain)()
m.Warn(en.Encode(m.Confv(prefix, kit.Keys(chain, HASH))), EXPORT, p)
m.Conf(prefix, kit.Keys(chain, HASH), "")
m.Echo(p).StatusTime(LINK, "/share/local/"+p)
}
func _hash_import(m *ice.Message, prefix, chain, file string) {
defer Lock(m, prefix, chain)()
f, e := miss.OpenFile(kit.Keys(file, JSON))
if m.Warn(e) {
return
}
defer f.Close()
list := Map{}
m.Assert(json.NewDecoder(f).Decode(&list))
count := 0
if m.Conf(prefix, kit.Keys(chain, META, SHORT)) == "" {
for k, data := range list {
m.Conf(prefix, kit.Keys(chain, HASH, k), data)
count++
}
} else {
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)
}
count++
m.Logs(IMPORT, KEY, path.Join(prefix, chain), COUNT, len(list))
defer m.Echo("%d", len(list))
defer Lock(m, prefix, chain)()
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)
}
}
m.Logs(IMPORT, KEY, path.Join(prefix, chain), COUNT, count)
m.Echo("%d", count)
}
const (
@ -180,31 +146,31 @@ const HASH = "hash"
func HashAction(arg ...Any) ice.Actions {
return ice.Actions{ice.CTX_INIT: AutoConfig(arg...), ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
INPUTS: {Hand: func(m *ice.Message, arg ...string) { HashInputs(m, arg) }},
CREATE: {Name: "create", Help: "创建", Hand: func(m *ice.Message, arg ...string) { HashCreate(m, arg) }},
REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) { HashRemove(m, arg) }},
CREATE: {Hand: func(m *ice.Message, arg ...string) { HashCreate(m, arg) }},
REMOVE: {Hand: func(m *ice.Message, arg ...string) { HashRemove(m, arg) }},
MODIFY: {Hand: func(m *ice.Message, arg ...string) { HashModify(m, arg) }},
SELECT: {Hand: func(m *ice.Message, arg ...string) { HashSelect(m, arg...) }},
PRUNES: {Name: "prunes before@date", Help: "清理", Hand: func(m *ice.Message, arg ...string) { HashPrunes(m, nil) }},
EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) { HashExport(m, arg) }},
IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) { HashImport(m, arg) }},
PRUNES: {Name: "prunes before@date", Hand: func(m *ice.Message, arg ...string) { HashPrunes(m, nil) }},
EXPORT: {Hand: func(m *ice.Message, arg ...string) { HashExport(m, arg) }},
IMPORT: {Hand: func(m *ice.Message, arg ...string) { HashImport(m, arg) }},
}
}
func HashStatusAction(arg ...Any) ice.Actions {
return ice.MergeActions(ice.Actions{
PRUNES: &ice.Action{Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(FIELD))
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "error")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "close")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "stop")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "end")
}},
}, HashAction(arg...))
}
func HashCloseAction(args ...Any) ice.Actions {
return ice.MergeActions(HashAction(args...), ice.Actions{
ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
})
}
func HashStatusAction(args ...Any) ice.Actions {
list := HashAction(args...)
list[PRUNES] = &ice.Action{Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(FIELD))
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "error")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "close")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "stop")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, STATUS, "end")
}}
return list
}
func HashStatusCloseAction(args ...Any) ice.Actions {
return ice.MergeActions(HashStatusAction(args...), ice.Actions{
ice.CTX_EXIT: {Hand: func(m *ice.Message, arg ...string) { HashSelectClose(m) }},
@ -264,9 +230,9 @@ func HashSelect(m *ice.Message, arg ...string) *ice.Message {
return m.StatusTime()
}
func HashPrunes(m *ice.Message, cb func(Maps) bool) *ice.Message {
expire := kit.Time(kit.Select(m.Time("-72h"), m.Option("before")))
expire := kit.Select(m.Time("-72h"), m.Option("before"))
m.Cmd("", func(value Maps) {
if kit.Time(value[TIME]) > expire {
if value[TIME] > expire {
return
}
if cb != nil && !cb(value) {
@ -318,14 +284,13 @@ func HashSelectField(m *ice.Message, key string, field string) (value string) {
})
return
}
func HashSelectDetail(m *ice.Message, key string, cb Any) bool {
func HashSelectDetail(m *ice.Message, key string, cb Any) (has bool) {
defer RLock(m, m.PrefixKey(), "")()
has := false
Richs(m, m.PrefixKey(), nil, key, func(key string, value Map) {
_mdb_select(m, cb, key, value, nil, nil)
has = true
})
return has
return
}
func HashSelectUpdate(m *ice.Message, key string, cb Any) *ice.Message {
defer Lock(m, m.PrefixKey(), "")()
@ -345,7 +310,6 @@ func HashSelectClose(m *ice.Message) *ice.Message {
HashSelectValue(m, func(value ice.Map) {
target := value[TARGET]
if c, ok := target.(io.Closer); ok {
m.Logs(DELETE, TARGET, m.PrefixKey())
c.Close()
}
delete(value, TARGET)

7
base/mdb/mdb.shy
View File

@ -1,7 +0,0 @@
chapter "mdb"
field "插件" mdb.plugin
field "渲染" mdb.render
field "引擎" mdb.engine
field "搜索" mdb.search

4
base/mdb/plugin.go
View File

@ -6,6 +6,4 @@ import (
const PLUGIN = "plugin"
func init() {
Index.MergeCommands(ice.Commands{PLUGIN: {Name: "plugin type name text auto", Help: "插件", Actions: RenderAction()}})
}
func init() { Index.MergeCommands(ice.Commands{PLUGIN: {Help: "插件", Actions: RenderAction()}}) }

29
base/mdb/render.go
View File

@ -7,9 +7,7 @@ import (
const RENDER = "render"
func init() {
Index.MergeCommands(ice.Commands{RENDER: {Name: "render type name text auto", Help: "渲染", Actions: RenderAction()}})
}
func init() { Index.MergeCommands(ice.Commands{RENDER: {Help: "渲染", Actions: RenderAction()}}) }
func RenderAction(args ...ice.Any) ice.Actions {
return ice.MergeActions(ice.Actions{
@ -20,27 +18,24 @@ func RenderAction(args ...ice.Any) ice.Actions {
if cs := m.Target().Configs; cs[m.CommandKey()] == nil {
cs[m.CommandKey()] = &ice.Config{Value: kit.Data(args...)}
} else {
ls := kit.Simple(args)
for i := 0; i < len(ls); i += 2 {
m.Config(ls[i], ls[i+1])
}
kit.Fetch(kit.Simple(args), func(key, value string) { m.Config(key, value) })
}
}},
CREATE: {Name: "create type name text", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
CREATE: {Name: "create type name text", Hand: func(m *ice.Message, arg ...string) {
m.Option(TYPE, kit.Ext(m.Option(TYPE)))
m.Option(NAME, kit.Select(m.Option(TYPE), m.Option(NAME)))
m.OptionDefault(NAME, m.Option(TYPE))
m.Cmdy(INSERT, m.PrefixKey(), "", HASH, m.OptionSimple(TYPE, NAME, TEXT))
}},
SELECT: {Name: "select type name text auto", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
if len(arg) > 1 {
for _, k := range kit.Split(arg[0]) {
HashSelect(m.Spawn(ice.OptionFields("")), 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))
})
}
SELECT: {Name: "select type name text auto create", Hand: func(m *ice.Message, arg ...string) {
if len(arg) < 2 || arg[0] == "" || arg[1] == "" {
HashSelect(m, arg...)
return
}
HashSelect(m, arg...)
for _, k := range kit.Split(arg[0]) {
HashSelect(m.Spawn(ice.OptionFields("")), 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))
})
}
}},
})
}

38
base/mdb/search.go
View File

@ -8,40 +8,28 @@ import (
const SEARCH = "search"
func init() {
Index.MergeCommands(ice.Commands{SEARCH: {Name: "search type name text auto", Help: "搜索", Actions: RenderAction()}})
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:
return func(m *ice.Message, arg ...string) { m.Cmd(SEARCH, CREATE, m.CommandKey(), m.PrefixKey()) }, nil
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: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) { HashSelectSearch(m, arg) }},
}
}
func HashSearchAction(arg ...Any) ice.Actions {
return ice.MergeActions(HashAction(arg...), SearchAction())
}
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 {
ls := kit.Split(m.Config(FIELD))
for _, k := range ls {
switch k {
case TIME, HASH:
default:
keys = append(keys, k)
}
keys = kit.Filters(kit.Split(m.Config(FIELD)), 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)
}
}
if args[0] == m.CommandKey() {
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
}

8
type.go
View File

@ -127,9 +127,15 @@ func (c *Context) Register(s *Context, x Server, n ...string) *Context {
return s
}
func (c *Context) MergeCommands(Commands Commands) *Context {
for _, cmd := range Commands {
for key, cmd := range Commands {
if cmd.Hand == nil && cmd.RawHand == nil {
cmd.RawHand = logs.FileLines(2)
if cmd.Actions != nil {
if action, ok := cmd.Actions[SELECT]; ok {
cmd.Name = kit.Select(strings.Replace(action.Name, SELECT, key, 1), cmd.Name)
cmd.Help = kit.Select(action.Help, cmd.Help)
}
}
}
}
configs := Configs{}