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

opt misc

Browse Source
This commit is contained in:
IT 老营长 @云轩领航-创始人 2021-11-06 13:46:41 +08:00
parent 089c2b01d3
commit 9022f20d5d
28 changed files with 448 additions and 485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
base/mdb/hash.go
View File

@ -145,6 +145,16 @@ func HashAction(fields ...string) map[string]*ice.Action {
}
return kit.Select(kit.MDB_HASH, m.Config(kit.MDB_SHORT))
}
prunes := &ice.Action{Name: "prunes before@date", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
HashPrunes(m, nil)
}}
if len(fields) > 0 && fields[0] == "status" {
prunes = &ice.Action{Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, kit.MDB_STATUS, "error")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, kit.MDB_STATUS, "close")
}}
}
return ice.SelectAction(map[string]*ice.Action{
INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(INPUTS, m.PrefixKey(), "", HASH, arg)
@ -165,22 +175,40 @@ func HashAction(fields ...string) map[string]*ice.Action {
IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(IMPORT, m.PrefixKey(), "", HASH, arg)
}},
PRUNES: {Name: "prunes before@date", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
list, before := []string{}, kit.Time(kit.Select(m.Time("-72h"), m.Option(kit.MDB_BEFORE)))
m.Richs(m.PrefixKey(), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); kit.Time(kit.Format(value[kit.MDB_TIME])) < before {
list = append(list, key)
}
})
m.OptionFields(m.Config(kit.MDB_FIELD))
for _, v := range list {
m.Cmdy(DELETE, m.PrefixKey(), "", HASH, kit.MDB_HASH, v)
}
}},
PRUNES: prunes,
}, fields...)
}
func HashActionStatus(fields ...string) map[string]*ice.Action {
list := HashAction(fields...)
list[PRUNES] = &ice.Action{Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, kit.MDB_STATUS, "error")
m.Cmdy(PRUNES, m.PrefixKey(), "", HASH, kit.MDB_STATUS, "close")
}}
return list
}
func HashSelect(m *ice.Message, arg ...string) *ice.Message {
m.Fields(len(arg), m.Config(kit.MDB_FIELD))
m.Cmdy(SELECT, m.PrefixKey(), "", HASH, m.Config(kit.MDB_SHORT), arg)
return m
}
func HashPrunes(m *ice.Message, cb func(map[string]string) bool) *ice.Message {
_key := func(m *ice.Message) string {
if m.Config(kit.MDB_HASH) == "uniq" {
return kit.MDB_HASH
}
return kit.Select(kit.MDB_HASH, m.Config(kit.MDB_SHORT))
}
before := kit.Time(kit.Select(m.Time("-72h"), m.Option(kit.MDB_BEFORE)))
m.Cmd(m.PrefixKey()).Table(func(index int, value map[string]string, head []string) {
if kit.Time(value[kit.MDB_TIME]) > before {
return
}
if cb != nil && cb(value) {
return
}
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(DELETE, m.PrefixKey(), "", HASH, _key(m), value[_key(m)])
})
return m
}

4
base/mdb/list.go
View File

@ -73,7 +73,6 @@ func _list_export(m *ice.Message, prefix, chain, file string) {
count := 0
head := kit.Split(m.OptionFields())
m.Option(ice.CACHE_LIMIT, "-1")
m.Grows(prefix, chain, "", "", func(index int, val map[string]interface{}) {
if val = kit.GetMeta(val); index == 0 {
if len(head) == 0 || head[0] == "detail" { // 默认表头
@ -149,7 +148,8 @@ func ListAction(fields ...string) map[string]*ice.Action {
m.Cmdy(MODIFY, m.PrefixKey(), "", LIST, m.OptionSimple(kit.MDB_ID), arg)
}},
EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.META_FIELD))
m.Option(ice.CACHE_LIMIT, "-1")
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(EXPORT, m.PrefixKey(), "", LIST)
m.Conf(m.PrefixKey(), kit.MDB_LIST, "")
m.Config(kit.MDB_COUNT, 0)

4
base/mdb/zone.go
View File

@ -155,6 +155,9 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
m.Cmdy(DELETE, m.PrefixKey(), "", HASH, m.OptionSimple(_zone(m)), arg)
}},
INSERT: {Name: "insert zone type=go name=hi text=hello", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
if len(arg) == 0 {
arg = m.OptionSimple(_zone(m), m.Config(kit.MDB_FIELD))
}
m.Cmdy(INSERT, m.PrefixKey(), "", HASH, _zone(m), arg[1])
m.Cmdy(INSERT, m.PrefixKey(), "", ZONE, m.Option(_zone(m)), arg[2:])
}},
@ -183,6 +186,7 @@ func ZoneAction(fields ...string) map[string]*ice.Action {
}
func ZoneSelect(m *ice.Message, arg ...string) *ice.Message {
m.Fields(len(arg), kit.Fields(kit.MDB_TIME, m.Config(kit.MDB_SHORT), kit.MDB_COUNT), m.Config(kit.MDB_FIELD))
m.Debug(m.Config(kit.MDB_FIELD))
m.Cmdy(SELECT, m.PrefixKey(), "", ZONE, arg)
m.Sort(m.Config(kit.MDB_SHORT))
return m

2
core/chat/files.go
View File

@ -19,7 +19,7 @@ func init() {
web.UPLOAD: {Name: "upload", Help: "上传", Hand: func(m *ice.Message, arg ...string) {
up := kit.Simple(m.Optionv(ice.MSG_UPLOAD))
if len(up) < 2 {
msg := m.Cmd(web.CACHE, web.UPLOAD)
msg := m.Cmdy(web.CACHE, web.UPLOAD)
up = kit.Simple(msg.Append(kit.MDB_HASH), msg.Append(kit.MDB_NAME), msg.Append(kit.MDB_SIZE))
}
m.Cmdy(mdb.INSERT, m.Prefix(FILES), "", mdb.HASH, kit.MDB_TYPE, kit.Ext(up[1]), kit.MDB_NAME, up[1], kit.MDB_SIZE, up[2], kit.MDB_DATA, up[0])

7
core/code/install.go
View File

@ -45,7 +45,7 @@ func _install_download(m *ice.Message) {
})
// 下载
msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, link)
msg := m.Cmd("web.spide", ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, link)
m.Cmd(nfs.LINK, file, msg.Append(kit.MDB_FILE))
// 解压
@ -59,6 +59,7 @@ func _install_build(m *ice.Message, arg ...string) {
// 推流
web.PushStream(m)
defer m.ProcessHold()
// 配置
switch cb := m.Optionv(PREPARE).(type) {
@ -67,6 +68,7 @@ func _install_build(m *ice.Message, arg ...string) {
default:
if msg := m.Cmd(cli.SYSTEM, "./configure", "--prefix="+pp, arg[1:]); !cli.IsSuccess(msg) {
m.Echo(msg.Append(cli.CMD_ERR))
m.Toast(ice.FAILURE, cli.BUILD)
return
}
}
@ -74,17 +76,18 @@ func _install_build(m *ice.Message, arg ...string) {
// 编译
if msg := m.Cmd(cli.SYSTEM, "make", "-j8"); !cli.IsSuccess(msg) {
m.Echo(msg.Append(cli.CMD_ERR))
m.Toast(ice.FAILURE, cli.BUILD)
return
}
// 安装
if msg := m.Cmd(cli.SYSTEM, "make", "PREFIX="+pp, "install"); !cli.IsSuccess(msg) {
m.Echo(msg.Append(cli.CMD_ERR))
m.Toast(ice.FAILURE, cli.BUILD)
return
}
m.Toast(ice.SUCCESS, cli.BUILD)
m.ProcessHold()
}
func _install_order(m *ice.Message, arg ...string) {
p := kit.Path(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), m.Option(kit.MDB_PATH)+ice.NL)

7
exec.go
View File

@ -55,9 +55,10 @@ func (m *Message) Sleep(d string) *Message {
time.Sleep(kit.Duration(d))
return m
}
func (m *Message) Sleep30ms() *Message { return m.Sleep("30ms") }
func (m *Message) Sleep3s() *Message { return m.Sleep("3s") }
func (m *Message) Sleep30s() *Message { return m.Sleep("30s") }
func (m *Message) Sleep300ms() *Message { return m.Sleep("30ms") }
func (m *Message) Sleep30ms() *Message { return m.Sleep("30ms") }
func (m *Message) Sleep3s() *Message { return m.Sleep("3s") }
func (m *Message) Sleep30s() *Message { return m.Sleep("30s") }
func (m *Message) Hold(n int) *Message {
for ctx := m.target; ctx != nil; ctx = ctx.context {
if ctx.wg != nil {

10
misc.go
View File

@ -212,6 +212,10 @@ func (c *Context) cmd(m *Message, cmd *Command, key string, arg ...string) *Mess
return m
}
func (c *Context) _cmd(m *Message, cmd *Command, key string, k string, h *Action, arg ...string) *Message {
if h.Hand == nil {
m.Cmdy(kit.Split(h.Name), arg)
return m
}
if k == RUN && !m.Right(arg) {
return m
}
@ -241,11 +245,7 @@ func (c *Context) _cmd(m *Message, cmd *Command, key string, k string, h *Action
}
}
if h.Hand == nil {
m.Cmdy(kit.Split(h.Name), arg)
} else {
h.Hand(m, arg...)
}
h.Hand(m, arg...)
return m
}
func (c *Context) split(name string) (list []interface{}) {

11
misc/alpha/alpha.go
View File

@ -37,14 +37,7 @@ func _alpha_load(m *ice.Message, file, name string) {
m.Conf(ALPHA, name, "")
// 缓存配置
m.Conf(ALPHA, kit.Keys(name, kit.MDB_META), kit.Dict(
kit.MDB_FIELD, meta[kit.MDB_FIELD],
kit.MDB_STORE, meta[kit.MDB_STORE],
kit.MDB_FSIZE, meta[kit.MDB_FSIZE],
kit.MDB_LIMIT, meta[kit.MDB_LIMIT],
kit.MDB_LEAST, meta[kit.MDB_LEAST],
))
m.Conf(ALPHA, kit.Keys(name, kit.MDB_META), kit.Dict(meta))
m.Cmd(mdb.IMPORT, ALPHA, name, kit.MDB_LIST, file)
// 保存词库
@ -67,7 +60,7 @@ var Index = &ice.Context{Name: ALPHA, Help: "英汉词典", Configs: map[string]
kit.MDB_LIMIT, "50000", kit.MDB_LEAST, "1000",
)},
}, Commands: map[string]*ice.Command{
ALPHA: {Name: "alpha method=word,line word auto import", Help: "英汉", Action: map[string]*ice.Action{
ALPHA: {Name: "alpha method=word,line word auto", Help: "英汉", Action: map[string]*ice.Action{
mdb.IMPORT: {Name: "import file=usr/word-dict/ecdict name=ecdict", Help: "加载词库", Hand: func(m *ice.Message, arg ...string) {
_alpha_load(m, m.Option(kit.MDB_FILE), kit.Select(path.Base(m.Option(kit.MDB_FILE)), m.Option(kit.MDB_NAME)))
}},

5
misc/bash/bash.shy
View File

@ -6,8 +6,8 @@ refer `
`
chapter "源码"
field "bash" web.code.bash.bash
field "bash" web.code.inner args `usr/install/bash-5.1/ input.c 636`
field "命令行" web.code.bash.bash
field "源代码" web.code.inner args `usr/install/bash-5.1/ input.c 636`
section "构建"
spark shell `
@ -24,7 +24,6 @@ make -j8 && make install
section "启动"
spark shell `
cd ./_install
./bin/bash
`

2
misc/bash/favor.go
View File

@ -32,7 +32,7 @@ func init() {
cli.SYSTEM: {Name: "system", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, m.Option(cli.PWD))
m.ProcessCommand(cli.SYSTEM, kit.Split(m.Option(kit.MDB_TEXT)), arg...)
m.ProcessCommandOpt(cli.PWD)
m.ProcessCommandOpt(arg, cli.PWD)
}},
}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if mdb.ZoneSelect(m, arg...); len(arg) == 0 {

166
misc/bash/input.go
View File

@ -9,95 +9,93 @@ import (
)
func init() {
Index.Merge(&ice.Context{
Commands: map[string]*ice.Command{
"/input": {Name: "/input", Help: "补全", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
list := kit.Split(m.Option("line"), m.Option("break"))
word := list[kit.Int(m.Option("index"))]
switch arg[0] {
case "shy":
m.Cmd("web.code.input.find", word).Table(func(index int, value map[string]string, head []string) {
m.Echo(value["text"]).Echo(" ")
})
Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
"/input": {Name: "/input", Help: "补全", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
list := kit.Split(m.Option("line"), m.Option("break"))
word := list[kit.Int(m.Option("index"))]
switch arg[0] {
case "shy":
m.Cmd("web.code.input.find", word).Table(func(index int, value map[string]string, head []string) {
m.Echo(value["text"]).Echo(" ")
})
case "line":
if strings.HasPrefix(m.Option("line"), "ice ") {
list := kit.Split(m.Option("line"))
switch list[1] {
case "add":
m.Cmd("web.code.input.push", list[2:])
m.Option("line", list[4])
m.Option("point", 0)
default:
m.Cmdy(list[1:])
break
case "line":
if strings.HasPrefix(m.Option("line"), "ice ") {
list := kit.Split(m.Option("line"))
switch list[1] {
case "add":
m.Cmd("web.code.input.push", list[2:])
m.Option("line", list[4])
m.Option("point", 0)
default:
m.Cmdy(list[1:])
break
}
}
line := []rune(m.Option("line"))
if begin := kit.Int(m.Option("point")); begin < len(line) {
m.Richs("login", nil, m.Option("sid"), func(key string, value map[string]interface{}) {
m.Echo(string(line[:begin]))
for i := begin; i < len(line); i++ {
if i-begin < 3 && i < len(line)-1 {
continue
}
// 编码转换
for j := 0; j < 4; j++ {
code := string(line[begin : i+1-j])
list := append(m.Cmd("web.code.input.find", code).Appendv("text"), code)
if len(list) > 1 {
m.Echo(kit.Select(code, list[0]))
m.Info("input %s->%s", code, list[0])
i = i - j
break
}
}
// 输出编码
begin = i + 1
}
})
break
}
fallthrough
case "end":
m.Richs("login", nil, m.Option("sid"), func(key string, value map[string]interface{}) {
last_text := kit.Format(kit.Value(value, "last.text"))
last_list := kit.Simple(kit.Value(value, "last.list"))
last_index := kit.Int(kit.Value(value, "last.index"))
if last_text != "" && strings.HasSuffix(m.Option("line"), last_text) {
// 补全记录
index := last_index + 1
text := last_list[index%len(last_list)]
kit.Value(value, "last.index", index)
kit.Value(value, "last.text", text)
m.Echo(strings.TrimSuffix(m.Option("line"), last_text) + text)
m.Info("%d %v", index, last_list)
return
}
line := []rune(m.Option("line"))
if begin := kit.Int(m.Option("point")); begin < len(line) {
m.Richs("login", nil, m.Option("sid"), func(key string, value map[string]interface{}) {
m.Echo(string(line[:begin]))
for i := begin; i < len(line); i++ {
if i-begin < 3 && i < len(line)-1 {
continue
}
// 编码转换
for j := 0; j < 4; j++ {
code := string(line[begin : i+1-j])
list := append(m.Cmd("web.code.input.find", code).Appendv("text"), code)
if len(list) > 1 {
m.Echo(kit.Select(code, list[0]))
m.Info("input %s->%s", code, list[0])
i = i - j
break
}
}
// 输出编码
begin = i + 1
}
})
for i := len(line); i >= 0; i-- {
if i > 0 && len(line)-i < 4 && unicode.IsLower(line[i-1]) {
continue
}
// 编码转换
code := string(line[i:])
list := append(m.Cmd("web.code.input.find", code).Appendv("text"), code)
value["last"] = kit.Dict("code", code, "text", list[0], "list", list, "index", 0)
// 输出编码
m.Echo(string(line[:i]))
m.Echo(kit.Select(code, list[0]))
m.Info("input %s->%s", code, list[0])
break
}
fallthrough
case "end":
m.Richs("login", nil, m.Option("sid"), func(key string, value map[string]interface{}) {
last_text := kit.Format(kit.Value(value, "last.text"))
last_list := kit.Simple(kit.Value(value, "last.list"))
last_index := kit.Int(kit.Value(value, "last.index"))
if last_text != "" && strings.HasSuffix(m.Option("line"), last_text) {
// 补全记录
index := last_index + 1
text := last_list[index%len(last_list)]
kit.Value(value, "last.index", index)
kit.Value(value, "last.text", text)
m.Echo(strings.TrimSuffix(m.Option("line"), last_text) + text)
m.Info("%d %v", index, last_list)
return
}
line := []rune(m.Option("line"))
for i := len(line); i >= 0; i-- {
if i > 0 && len(line)-i < 4 && unicode.IsLower(line[i-1]) {
continue
}
// 编码转换
code := string(line[i:])
list := append(m.Cmd("web.code.input.find", code).Appendv("text"), code)
value["last"] = kit.Dict("code", code, "text", list[0], "list", list, "index", 0)
// 输出编码
m.Echo(string(line[:i]))
m.Echo(kit.Select(code, list[0]))
m.Info("input %s->%s", code, list[0])
break
}
})
}
m.Info("trans: %v", m.Result())
}},
},
})
})
}
m.Info("trans: %v", m.Result())
}},
}})
}

16
misc/bash/sync.go
View File

@ -11,10 +11,6 @@ import (
kit "shylinux.com/x/toolkits"
)
const (
SHELL = "shell"
HISTORY = "history"
)
const SYNC = "sync"
func init() {
@ -24,11 +20,11 @@ func init() {
)},
}, Commands: map[string]*ice.Command{
"/sync": {Name: "/sync", Help: "同步", Action: map[string]*ice.Action{
HISTORY: {Name: "history", Help: "历史", Hand: func(m *ice.Message, arg ...string) {
"history": {Name: "history", Help: "历史", Hand: func(m *ice.Message, arg ...string) {
ls := strings.SplitN(strings.TrimSpace(m.Option(ARG)), ice.SP, 4)
if text := strings.TrimSpace(strings.Join(ls[3:], ice.SP)); text != "" {
m.Cmd(SYNC, mdb.INSERT, kit.MDB_TIME, ls[1]+ice.SP+ls[2],
kit.MDB_TYPE, SHELL, kit.MDB_NAME, ls[0], kit.MDB_TEXT, text,
kit.MDB_TYPE, "shell", kit.MDB_NAME, ls[0], kit.MDB_TEXT, text,
m.OptionSimple(cli.PWD, aaa.USERNAME, tcp.HOSTNAME, tcp.HOSTNAME))
}
}},
@ -37,11 +33,13 @@ func init() {
cli.SYSTEM: {Name: "system", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Option(cli.CMD_DIR, m.Option(cli.PWD))
m.ProcessCommand(cli.SYSTEM, kit.Split(m.Option(kit.MDB_TEXT)), arg...)
m.ProcessCommandOpt(cli.PWD)
m.ProcessCommandOpt(arg, cli.PWD)
}},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(FAVOR, mdb.INPUTS, arg)
}},
mdb.INPUTS: {Name: "favor inputs", Help: "补全"},
FAVOR: {Name: "favor zone=some@key type name text pwd", Help: "收藏", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(FAVOR, mdb.INSERT, m.OptionSimple(kit.MDB_ZONE, m.Conf(FAVOR, kit.META_FIELD)))
m.Cmdy(FAVOR, mdb.INSERT)
}},
}, mdb.ListAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.OptionPage(kit.Slice(arg, 1)...)

16
misc/bash/trash.go
View File

@ -1,6 +1,8 @@
package bash
import (
"os"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/aaa"
"shylinux.com/x/icebergs/base/cli"
@ -39,16 +41,20 @@ func init() {
m.Cmdy(cli.SYSTEM, "mv", m.Option(TO), m.Option(FROM))
m.Cmdy(mdb.DELETE, m.PrefixKey(), "", mdb.HASH, m.OptionSimple(kit.MDB_HASH))
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
mdb.PRUNES: {Name: "prunes before@date", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
mdb.HashPrunes(m, func(value map[string]string) bool {
os.RemoveAll(value[TO])
return false
})
}},
nfs.DIR: {Name: "dir", Help: "目录", Hand: func(m *ice.Message, arg ...string) {
nfs.CAT: {Name: "cat", Help: "查看", Hand: func(m *ice.Message, arg ...string) {
m.Option(nfs.DIR_ROOT, m.Option(TO))
m.ProcessCommand(nfs.DIR, []string{}, arg...)
m.ProcessCommandOpt(TO)
m.ProcessCommand(nfs.CAT, []string{}, arg...)
m.ProcessCommandOpt(arg, TO)
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
mdb.HashSelect(m, arg...)
m.PushAction(nfs.DIR, mdb.REVERT, mdb.REMOVE)
m.PushAction(nfs.CAT, mdb.REVERT, mdb.REMOVE)
}},
}})
}

52
misc/input/input.go
View File

@ -17,6 +17,32 @@ import (
kit "shylinux.com/x/toolkits"
)
func _input_find(m *ice.Message, method, word, limit string) {
switch method {
case LINE:
case WORD:
word = "^" + word + ","
}
// 搜索词汇
res := m.Cmdx(cli.SYSTEM, "grep", "-rn", word, m.Config(kit.MDB_STORE))
bio := csv.NewReader(bytes.NewBufferString(strings.Replace(res, ":", ",", -1)))
for i := 0; i < kit.Int(limit); i++ {
if line, e := bio.Read(); e != nil {
break
} else if len(line) < 3 {
} else { // 输出词汇
m.Push(kit.MDB_ID, line[3])
m.Push(CODE, line[2])
m.Push(TEXT, line[4])
m.Push(WEIGHT, line[6])
}
}
m.SortIntR(WEIGHT)
}
func _input_load(m *ice.Message, file string, libs ...string) {
if f, e := os.Open(file); m.Assert(e) {
defer f.Close()
@ -91,32 +117,6 @@ func _input_save(m *ice.Message, file string, lib ...string) {
}
}
func _input_find(m *ice.Message, method, word, limit string) {
switch method {
case LINE:
case WORD:
word = "^" + word + ","
}
// 搜索词汇
res := m.Cmdx(cli.SYSTEM, "grep", "-rn", word, m.Config(kit.MDB_STORE))
bio := csv.NewReader(bytes.NewBufferString(strings.Replace(res, ":", ",", -1)))
for i := 0; i < kit.Int(limit); i++ {
if line, e := bio.Read(); e != nil {
break
} else if len(line) < 3 {
} else {
// 输出词汇
m.Push(kit.MDB_ID, line[3])
m.Push(CODE, line[2])
m.Push(TEXT, line[4])
m.Push(WEIGHT, line[6])
}
}
m.SortIntR(WEIGHT)
}
func _input_list(m *ice.Message, lib string) {
if lib == "" {
m.Richs(m.PrefixKey(), "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {

8
misc/input/wubi.go
View File

@ -18,16 +18,16 @@ func init() {
kit.MDB_LIMIT, "5000", kit.MDB_LEAST, "1000",
)},
}, Commands: map[string]*ice.Command{
WUBI: {Name: "wubi method=word,line code auto import export", Help: "五笔", Action: map[string]*ice.Action{
mdb.IMPORT: {Name: "import file=usr/wubi-dict/wubi86 zone=wubi86", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
_input_load(m, m.Option(FILE), m.Option(ZONE))
}},
WUBI: {Name: "wubi method=word,line code auto", Help: "五笔", Action: map[string]*ice.Action{
mdb.INSERT: {Name: "insert zone=person text code weight", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
_input_push(m, m.Option(ZONE), m.Option(TEXT), m.Option(CODE), m.Option(WEIGHT))
}},
mdb.EXPORT: {Name: "export file=usr/wubi-dict/person zone=person", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
_input_save(m, m.Option(FILE), m.Option(ZONE))
}},
mdb.IMPORT: {Name: "import file=usr/wubi-dict/wubi86 zone=wubi86", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
_input_load(m, m.Option(FILE), m.Option(ZONE))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
_input_find(m, arg[0], arg[1], m.Option(ice.CACHE_LIMIT))
m.StatusTime()

84
misc/ssh/channel.go
View File

@ -67,53 +67,49 @@ func _ssh_watch(m *ice.Message, meta map[string]string, h string, input io.Reade
const CHANNEL = "channel"
func init() {
psh.Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
CHANNEL: {Name: "channel", Help: "通道", Value: kit.Data()},
},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
psh.Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
CHANNEL: {Name: "channel", Help: "通道", Value: kit.Data(
kit.MDB_FIELD, "time,hash,status,username,hostport,tty,count",
)},
}, Commands: map[string]*ice.Command{
CHANNEL: {Name: "channel hash id auto", Help: "通道", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Richs(CHANNEL, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
kit.Value(value, kit.Keym(kit.MDB_STATUS), tcp.CLOSE)
})
}},
CHANNEL: {Name: "channel hash id auto command prunes", Help: "通道", Action: map[string]*ice.Action{
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, CHANNEL, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,hash,status,username,hostport,tty,count")
m.Cmdy(mdb.PRUNES, SERVICE, "", mdb.HASH, kit.MDB_STATUS, tcp.ERROR)
m.Cmdy(mdb.PRUNES, CHANNEL, "", mdb.HASH, kit.MDB_STATUS, tcp.CLOSE)
}},
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(CHANNEL, ctx.ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
}},
ctx.COMMAND: {Name: "command cmd=pwd", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, CHANNEL, kit.Keys(kit.MDB_HASH, m.Option(kit.MDB_HASH)), mdb.LIST, kit.MDB_TYPE, CMD, kit.MDB_TEXT, m.Option(CMD))
m.Richs(CHANNEL, "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
if w, ok := kit.Value(value, kit.Keym(INPUT)).(io.Writer); ok {
w.Write([]byte(m.Option(CMD) + "\n"))
}
})
m.ProcessRefresh("300ms")
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { // 通道列表
m.Fields(len(arg), "time,hash,status,username,hostport,tty,count")
if m.Cmdy(mdb.SELECT, CHANNEL, "", mdb.HASH); len(arg) == 0 {
m.Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", ctx.COMMAND, value[kit.MDB_STATUS] == tcp.OPEN), mdb.REMOVE)
})
}
return
}
// 通道命令
m.Fields(len(arg[1:]), "time,id,type,text")
m.Cmdy(mdb.SELECT, CHANNEL, kit.Keys(kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, arg[1:])
m.PushAction(mdb.REPEAT)
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.OptionFields(m.Config(kit.MDB_FIELD))
m.Cmdy(mdb.PRUNES, SERVICE, "", mdb.HASH, kit.MDB_STATUS, tcp.ERROR)
m.Cmdy(mdb.PRUNES, CHANNEL, "", mdb.HASH, kit.MDB_STATUS, tcp.CLOSE)
}},
},
})
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(CHANNEL, ctx.ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
}},
ctx.COMMAND: {Name: "command cmd=pwd", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.INSERT, CHANNEL, kit.Keys(kit.MDB_HASH, m.Option(kit.MDB_HASH)),
mdb.LIST, kit.MDB_TYPE, CMD, kit.MDB_TEXT, m.Option(CMD))
m.Richs(CHANNEL, "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
if w, ok := kit.Value(value, kit.Keym(INPUT)).(io.Writer); ok {
w.Write([]byte(m.Option(CMD) + ice.NL))
}
})
m.ProcessRefresh300ms()
}},
}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { // 通道列表
m.Action(mdb.PRUNES)
mdb.HashSelect(m, arg...).Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", ctx.COMMAND, value[kit.MDB_STATUS] == tcp.OPEN), mdb.REMOVE)
})
return
}
// 通道命令
m.Action(ctx.COMMAND)
m.Fields(len(arg[1:]), "time,id,type,text")
mdb.ZoneSelect(m, arg...)
m.PushAction(mdb.REPEAT)
}},
}})
}

115
misc/ssh/connect.go
View File

@ -35,8 +35,8 @@ func _ssh_open(m *ice.Message, arg ...string) {
// 初始命令
for _, item := range kit.Simple(m.Optionv(kit.MDB_LIST)) {
m.Sleep("500ms")
c.Write([]byte(item + "\n"))
m.Sleep300ms()
c.Write([]byte(item + ice.NL))
}
m.Go(func() { io.Copy(c, os.Stdin) })
@ -155,71 +155,62 @@ const SSH = "ssh"
const CONNECT = "connect"
func init() {
psh.Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
CONNECT: {Name: CONNECT, Help: "连接", Value: kit.Data()},
},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
psh.Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
CONNECT: {Name: CONNECT, Help: "连接", Value: kit.Data(
kit.MDB_FIELD, "time,hash,status,username,host,port",
)},
}, Commands: map[string]*ice.Command{
CONNECT: {Name: "connect hash auto", Help: "连接", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Richs(CONNECT, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); kit.Value(value, kit.MDB_STATUS) == tcp.OPEN {
m.Cmd(CONNECT, tcp.DIAL, aaa.USERNAME, value[aaa.USERNAME], kit.MDB_HASH, key, value)
}
})
}},
CONNECT: {Name: "connect hash auto dial prunes", Help: "连接", Action: map[string]*ice.Action{
tcp.OPEN: {Name: "open authfile username=shy password verfiy host=shylinux.com port=22 private=.ssh/id_rsa", Help: "终端", Hand: func(m *ice.Message, arg ...string) {
_ssh_open(m.OptionLoad(m.Option("authfile")), arg...)
m.Echo("exit %v@%v:%v\n", m.Option(aaa.USERNAME), m.Option(tcp.HOST), m.Option(tcp.PORT))
}},
tcp.DIAL: {Name: "dial username=shy host=shylinux.com port=22 private=.ssh/id_rsa", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Go(func() {
_ssh_conn(m, func(client *ssh.Client) {
h := m.Option(kit.MDB_HASH)
if h == "" {
h = m.Rich(CONNECT, "", kit.Dict(
aaa.USERNAME, m.Option(aaa.USERNAME),
tcp.HOST, m.Option(tcp.HOST), tcp.PORT, m.Option(tcp.PORT),
kit.MDB_STATUS, tcp.OPEN, CONNECT, client,
))
} else {
m.Conf(CONNECT, kit.Keys(kit.MDB_HASH, h, CONNECT), client)
}
m.Cmd(CONNECT, SESSION, kit.MDB_HASH, h)
}, arg...)
})
m.ProcessRefresh("300ms")
}},
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, CONNECT, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,hash,status,username,host,port")
m.Cmdy(mdb.PRUNES, CONNECT, "", mdb.HASH, kit.MDB_STATUS, tcp.ERROR)
m.Cmdy(mdb.PRUNES, CONNECT, "", mdb.HASH, kit.MDB_STATUS, tcp.CLOSE)
}},
SESSION: {Name: "session hash", Help: "会话", Hand: func(m *ice.Message, arg ...string) {
var client *ssh.Client
m.Richs(CONNECT, "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
client, _ = value[CONNECT].(*ssh.Client)
})
h := m.Rich(SESSION, "", kit.Data(kit.MDB_STATUS, tcp.OPEN, CONNECT, m.Option(kit.MDB_HASH)))
if session, e := _ssh_session(m, h, client); m.Assert(e) {
session.Shell()
session.Wait()
}
m.Echo(h)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Fields(len(arg), "time,hash,status,username,host,port")
if m.Cmdy(mdb.SELECT, CONNECT, "", mdb.HASH, kit.MDB_HASH, arg); len(arg) == 0 {
m.Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", SESSION, value[kit.MDB_STATUS] == tcp.OPEN), mdb.REMOVE)
})
}
tcp.OPEN: {Name: "open authfile username=shy password verfiy host=shylinux.com port=22 private=.ssh/id_rsa", Help: "终端", Hand: func(m *ice.Message, arg ...string) {
_ssh_open(m.OptionLoad(m.Option("authfile")), arg...)
m.Echo("exit %v@%v:%v\n", m.Option(aaa.USERNAME), m.Option(tcp.HOST), m.Option(tcp.PORT))
}},
},
})
tcp.DIAL: {Name: "dial username=shy host=shylinux.com port=22 private=.ssh/id_rsa", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Go(func() {
_ssh_conn(m, func(client *ssh.Client) {
h := m.Option(kit.MDB_HASH)
if h == "" {
h = m.Rich(CONNECT, "", kit.Dict(
aaa.USERNAME, m.Option(aaa.USERNAME),
tcp.HOST, m.Option(tcp.HOST), tcp.PORT, m.Option(tcp.PORT),
kit.MDB_STATUS, tcp.OPEN, CONNECT, client,
))
} else {
m.Conf(CONNECT, kit.Keys(kit.MDB_HASH, h, CONNECT), client)
}
m.Cmd(CONNECT, SESSION, kit.MDB_HASH, h)
}, arg...)
})
m.ProcessRefresh3s()
}},
SESSION: {Name: "session hash", Help: "会话", Hand: func(m *ice.Message, arg ...string) {
var client *ssh.Client
m.Richs(CONNECT, "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
client, _ = value[CONNECT].(*ssh.Client)
})
h := m.Rich(SESSION, "", kit.Data(kit.MDB_STATUS, tcp.OPEN, CONNECT, m.Option(kit.MDB_HASH)))
if session, e := _ssh_session(m, h, client); m.Assert(e) {
session.Shell()
session.Wait()
}
m.Echo(h)
}},
}, mdb.HashActionStatus()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
mdb.HashSelect(m, arg...).Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", SESSION, value[kit.MDB_STATUS] == tcp.OPEN), mdb.REMOVE)
})
if len(arg) == 0 {
m.Action(tcp.DIAL, mdb.PRUNES)
}
}},
}})
}

138
misc/ssh/service.go
View File

@ -100,87 +100,77 @@ const (
const SERVICE = "service"
func init() {
psh.Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
SERVICE: {Name: SERVICE, Help: "服务", Value: kit.Data(
WELCOME, "\r\nwelcome to context world\r\n",
GOODBYE, "\r\ngoodbye of context world\r\n",
kit.MDB_SHORT, tcp.PORT,
)},
},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
psh.Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SERVICE: {Name: SERVICE, Help: "服务", Value: kit.Data(
WELCOME, "\r\nwelcome to context world\r\n", GOODBYE, "\r\ngoodbye of context world\r\n",
kit.MDB_SHORT, tcp.PORT, kit.MDB_FIELD, "time,port,status,private,authkey,count",
)},
}, Commands: map[string]*ice.Command{
SERVICE: {Name: "service port id auto listen prunes", Help: "服务", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Richs(SERVICE, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
if value = kit.GetMeta(value); kit.Value(value, kit.MDB_STATUS) == tcp.OPEN {
m.Cmd(SERVICE, tcp.LISTEN, tcp.PORT, value[tcp.PORT], value)
}
})
}},
SERVICE: {Name: "service port id auto listen prunes", Help: "服务", Action: map[string]*ice.Action{
tcp.LISTEN: {Name: "listen port=9030 private=.ssh/id_rsa authkey=.ssh/authorized_keys", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
if m.Richs(SERVICE, "", m.Option(tcp.PORT), func(key string, value map[string]interface{}) {
kit.Value(value, kit.Keym(kit.MDB_STATUS), tcp.OPEN)
}) == nil {
m.Cmd(mdb.INSERT, SERVICE, "", mdb.HASH, tcp.PORT, m.Option(tcp.PORT),
PRIVATE, m.Option(PRIVATE), AUTHKEY, m.Option(AUTHKEY), kit.MDB_STATUS, tcp.OPEN, arg)
m.Cmd(SERVICE, mdb.IMPORT, AUTHKEY, m.Option(AUTHKEY))
}
m.Option(kit.Keycb(tcp.LISTEN), func(c net.Conn) { m.Go(func() { _ssh_accept(m, kit.Hashs(m.Option(tcp.PORT)), c) }) })
m.Go(func() {
m.Cmdy(tcp.SERVER, tcp.LISTEN, kit.MDB_TYPE, SSH, kit.MDB_NAME, tcp.PORT, tcp.PORT, m.Option(tcp.PORT))
})
}},
mdb.INSERT: {Name: "insert text:textarea", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
if ls := kit.Split(m.Option(kit.MDB_TEXT)); len(ls) > 2 {
m.Cmdy(mdb.INSERT, SERVICE, kit.Keys(kit.MDB_HASH, kit.Hashs(m.Option(tcp.PORT))), mdb.LIST,
kit.MDB_TYPE, ls[0], kit.MDB_NAME, ls[len(ls)-1], kit.MDB_TEXT, strings.Join(ls[1:len(ls)-1], "+"))
}
}},
mdb.EXPORT: {Name: "export authkey=.ssh/authorized_keys", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
list := []string{}
m.Cmd(mdb.SELECT, SERVICE, kit.Keys(kit.MDB_HASH, kit.Hashs(m.Option(tcp.PORT))), mdb.LIST).Table(func(index int, value map[string]string, head []string) {
list = append(list, fmt.Sprintf("%s %s %s", value[kit.MDB_TYPE], value[kit.MDB_TEXT], value[kit.MDB_NAME]))
})
if len(list) > 0 {
m.Cmdy(nfs.SAVE, path.Join(os.Getenv(cli.HOME), m.Option(AUTHKEY)), strings.Join(list, "\n")+"\n")
}
}},
mdb.IMPORT: {Name: "import authkey=.ssh/authorized_keys", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
p := path.Join(os.Getenv(cli.HOME), m.Option(AUTHKEY))
for _, pub := range strings.Split(strings.TrimSpace(m.Cmdx(nfs.CAT, p)), "\n") {
m.Cmd(SERVICE, mdb.INSERT, kit.MDB_TEXT, pub)
}
m.Echo(p)
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,port,status,private,authkey,count")
m.Cmdy(mdb.PRUNES, SERVICE, "", mdb.HASH, kit.MDB_STATUS, tcp.ERROR)
m.Cmdy(mdb.PRUNES, SERVICE, "", mdb.HASH, kit.MDB_STATUS, tcp.CLOSE)
}},
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
m.Option(cli.HOSTNAME, strings.Split(u.Host, ":")[0])
m.ProcessInner()
if buf, err := kit.Render(`ssh -p {{.Option "port"}} {{.Option "user.name"}}@{{.Option "hostname"}}`, m); err == nil {
m.EchoScript(string(buf))
}
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { // 服务列表
m.Fields(len(arg), "time,port,status,private,authkey,count")
m.Cmdy(mdb.SELECT, SERVICE, "", mdb.HASH)
m.PushAction(mdb.IMPORT, mdb.INSERT, mdb.EXPORT, aaa.INVITE)
return
tcp.LISTEN: {Name: "listen port=9030 private=.ssh/id_rsa authkey=.ssh/authorized_keys", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
if m.Richs(SERVICE, "", m.Option(tcp.PORT), func(key string, value map[string]interface{}) {
kit.Value(value, kit.Keym(kit.MDB_STATUS), tcp.OPEN)
}) == nil {
m.Cmd(mdb.INSERT, SERVICE, "", mdb.HASH, tcp.PORT, m.Option(tcp.PORT),
PRIVATE, m.Option(PRIVATE), AUTHKEY, m.Option(AUTHKEY), kit.MDB_STATUS, tcp.OPEN, arg)
m.Cmd(SERVICE, mdb.IMPORT, AUTHKEY, m.Option(AUTHKEY))
}
// 公钥列表
m.Fields(len(arg[1:]), "time,id,type,name,text")
m.Cmdy(mdb.SELECT, SERVICE, kit.Keys(kit.MDB_HASH, kit.Hashs(arg[0])), mdb.LIST, kit.MDB_ID, arg[1:])
m.Option(kit.Keycb(tcp.LISTEN), func(c net.Conn) { m.Go(func() { _ssh_accept(m, kit.Hashs(m.Option(tcp.PORT)), c) }) })
m.Go(func() {
m.Cmdy(tcp.SERVER, tcp.LISTEN, kit.MDB_TYPE, SSH, kit.MDB_NAME, tcp.PORT, tcp.PORT, m.Option(tcp.PORT))
})
}},
},
})
mdb.INSERT: {Name: "insert text:textarea", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
if ls := kit.Split(m.Option(kit.MDB_TEXT)); len(ls) > 2 {
m.Cmdy(mdb.INSERT, SERVICE, kit.Keys(kit.MDB_HASH, kit.Hashs(m.Option(tcp.PORT))), mdb.LIST,
kit.MDB_TYPE, ls[0], kit.MDB_NAME, ls[len(ls)-1], kit.MDB_TEXT, strings.Join(ls[1:len(ls)-1], "+"))
}
}},
mdb.EXPORT: {Name: "export authkey=.ssh/authorized_keys", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
list := []string{}
m.Cmd(mdb.SELECT, SERVICE, kit.Keys(kit.MDB_HASH, kit.Hashs(m.Option(tcp.PORT))), mdb.LIST).Table(func(index int, value map[string]string, head []string) {
list = append(list, fmt.Sprintf("%s %s %s", value[kit.MDB_TYPE], value[kit.MDB_TEXT], value[kit.MDB_NAME]))
})
if len(list) > 0 {
m.Cmdy(nfs.SAVE, path.Join(os.Getenv(cli.HOME), m.Option(AUTHKEY)), strings.Join(list, ice.NL)+ice.NL)
}
}},
mdb.IMPORT: {Name: "import authkey=.ssh/authorized_keys", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
p := path.Join(os.Getenv(cli.HOME), m.Option(AUTHKEY))
for _, pub := range strings.Split(strings.TrimSpace(m.Cmdx(nfs.CAT, p)), ice.NL) {
m.Cmd(SERVICE, mdb.INSERT, kit.MDB_TEXT, pub)
}
m.Echo(p)
}},
aaa.INVITE: {Name: "invite", Help: "邀请", Hand: func(m *ice.Message, arg ...string) {
u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
m.Option(cli.HOSTNAME, strings.Split(u.Host, ":")[0])
m.ProcessInner()
if buf, err := kit.Render(`ssh -p {{.Option "port"}} {{.Option "user.name"}}@{{.Option "hostname"}}`, m); err == nil {
m.EchoScript(string(buf))
}
}},
}, mdb.HashActionStatus()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 { // 服务列表
mdb.HashSelect(m, arg...)
m.PushAction(mdb.IMPORT, mdb.INSERT, mdb.EXPORT, aaa.INVITE)
return
}
// 公钥列表
m.Fields(len(arg[1:]), "time,id,type,name,text")
mdb.ZoneSelect(m, arg...)
}},
}})
}

27
misc/ssh/service_darwin.go
View File

@ -1,27 +0,0 @@
package ssh
import (
"encoding/binary"
"net"
"syscall"
"unsafe"
ice "shylinux.com/x/icebergs"
"golang.org/x/crypto/ssh"
)
type Winsize struct{ Height, Width, x, y uint16 }
func _ssh_size(fd uintptr, b []byte) {
w := binary.BigEndian.Uint32(b)
h := binary.BigEndian.Uint32(b[4:])
ws := &Winsize{Width: uint16(w), Height: uint16(h)}
syscall.Syscall(syscall.SYS_IOCTL, fd, uintptr(syscall.TIOCSWINSZ), uintptr(unsafe.Pointer(ws)))
}
func _ssh_sizes(fd uintptr, w, h int) {
ws := &Winsize{Width: uint16(w), Height: uint16(h)}
syscall.Syscall(syscall.SYS_IOCTL, fd, uintptr(syscall.TIOCSWINSZ), uintptr(unsafe.Pointer(ws)))
}
func _ssh_handle(m *ice.Message, meta map[string]string, c net.Conn, channel ssh.Channel, requests <-chan *ssh.Request) {
}

1
misc/ssh/service_darwin.go Symbolic link
View File

@ -0,0 +1 @@
service_linux.go

79
misc/ssh/session.go
View File

@ -58,54 +58,43 @@ const (
const SESSION = "session"
func init() {
psh.Index.Merge(&ice.Context{
Configs: map[string]*ice.Config{
SESSION: {Name: SESSION, Help: "会话", Value: kit.Data()},
},
Commands: map[string]*ice.Command{
ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
psh.Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
SESSION: {Name: SESSION, Help: "会话", Value: kit.Data(
kit.MDB_FIELD, "time,hash,status,count,connect",
)},
}, Commands: map[string]*ice.Command{
SESSION: {Name: "session hash id auto", Help: "会话", Action: ice.MergeAction(map[string]*ice.Action{
ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
m.Richs(SESSION, "", kit.MDB_FOREACH, func(key string, value map[string]interface{}) {
kit.Value(value, kit.Keym(kit.MDB_STATUS), tcp.CLOSE)
})
}},
SESSION: {Name: "session hash id auto command prunes", Help: "会话", Action: map[string]*ice.Action{
mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(mdb.DELETE, SESSION, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
}},
mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
m.Option(mdb.FIELDS, "time,hash,status,count,connect")
m.Cmdy(mdb.PRUNES, SESSION, "", mdb.HASH, kit.MDB_STATUS, tcp.ERROR)
m.Cmdy(mdb.PRUNES, SESSION, "", mdb.HASH, kit.MDB_STATUS, tcp.CLOSE)
}},
ctx.COMMAND: {Name: "command cmd=pwd", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Richs(SESSION, "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
if w, ok := kit.Value(value, kit.Keym(INPUT)).(io.Writer); ok {
m.Grow(SESSION, kit.Keys(kit.MDB_HASH, key), kit.Dict(kit.MDB_TYPE, CMD, kit.MDB_TEXT, m.Option(CMD)))
w.Write([]byte(m.Option(CMD) + ice.NL))
}
})
m.ProcessRefresh("300ms")
}},
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(SESSION, ctx.ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Fields(len(arg), "time,hash,status,count,connect")
if m.Cmdy(mdb.SELECT, SESSION, "", mdb.HASH, kit.MDB_HASH, arg); len(arg) == 0 {
m.Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", ctx.COMMAND, value[kit.MDB_STATUS] == tcp.OPEN), mdb.REMOVE)
})
}
return
}
m.Fields(len(arg[1:]), "time,id,type,text")
m.Cmdy(mdb.SELECT, SESSION, kit.Keys(kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, arg[1:])
m.Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", mdb.REPEAT, value[kit.MDB_TYPE] == CMD))
})
mdb.REPEAT: {Name: "repeat", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(SESSION, ctx.ACTION, ctx.COMMAND, CMD, m.Option(kit.MDB_TEXT))
}},
},
})
ctx.COMMAND: {Name: "command cmd=pwd", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
m.Richs(SESSION, "", m.Option(kit.MDB_HASH), func(key string, value map[string]interface{}) {
if w, ok := kit.Value(value, kit.Keym(INPUT)).(io.Writer); ok {
m.Grow(SESSION, kit.Keys(kit.MDB_HASH, key), kit.Dict(kit.MDB_TYPE, CMD, kit.MDB_TEXT, m.Option(CMD)))
w.Write([]byte(m.Option(CMD) + ice.NL))
}
})
m.ProcessRefresh300ms()
}},
}, mdb.HashActionStatus()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Action(mdb.PRUNES)
mdb.HashSelect(m, arg...).Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", ctx.COMMAND, value[kit.MDB_STATUS] == tcp.OPEN), mdb.REMOVE)
})
return
}
m.Action(ctx.COMMAND)
m.Fields(len(arg[1:]), "time,id,type,text")
mdb.ZoneSelect(m, arg...).Table(func(index int, value map[string]string, head []string) {
m.PushButton(kit.Select("", mdb.REPEAT, value[kit.MDB_TYPE] == CMD))
})
}},
}})
}

2
misc/vim/favor.go
View File

@ -25,7 +25,7 @@ func init() {
})
}},
mdb.INSERT: {Name: "insert", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
m.Cmd(FAVOR, mdb.INSERT, m.OptionSimple("zone,type,name,text,file,line,pwd"))
m.Cmd(FAVOR, mdb.INSERT)
}},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Cmd(FAVOR, m.Option(kit.MDB_ZONE)).Table(func(index int, value map[string]string, head []string) {

1
misc/vim/input.go
View File

@ -43,6 +43,7 @@ func init() {
}
// 词汇列表
m.Option(ice.CACHE_LIMIT, "10")
m.Cmd("web.code.input.wubi", "word", arg[0]).Table(func(index int, value map[string]string, head []string) {
m.Echo("%s\n", value[kit.MDB_TEXT])
})

4
misc/vim/sync.go
View File

@ -34,7 +34,9 @@ func init() {
p := path.Join(m.Option(cli.PWD), m.Option(BUF))
m.ProcessCommand(code.INNER, []string{path.Dir(p) + ice.PS, path.Base(p), m.Option(ROW)}, arg...)
}},
mdb.INPUTS: {Name: "favor inputs", Help: "补全"},
mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(FAVOR, mdb.INPUTS, arg)
}},
FAVOR: {Name: "favor zone=some@key type name text buf row pwd", Help: "收藏", Hand: func(m *ice.Message, arg ...string) {
m.Cmdy(FAVOR, mdb.INSERT, m.OptionSimple(kit.MDB_ZONE, "type,name,text,pwd"),
nfs.FILE, m.Option(BUF), nfs.LINE, m.Option(ROW))

45
misc/vim/tags.go
View File

@ -3,7 +3,6 @@ package vim
import (
"path"
"strings"
"unicode"
ice "shylinux.com/x/icebergs"
"shylinux.com/x/icebergs/base/mdb"
@ -20,37 +19,22 @@ func init() {
)},
}, Commands: map[string]*ice.Command{
"/tags": {Name: "/tags", Help: "跳转", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
pre := m.Option("pre")
n := kit.Int(m.Option(COL))
if n > len(pre) {
n = len(pre) - 1
}
for i := n; i > 0; i-- {
if i > 0 && i < len(pre) && (pre[i] == '_' || pre[i] == '.' || unicode.IsDigit(rune(pre[i])) || unicode.IsLetter(rune(pre[i]))) {
continue
}
pre = pre[i+1 : n]
break
}
switch file := kit.Slice(kit.Split(pre, ice.PT, ice.PT), -2)[0]; file {
case "kit", "ice", "ctx", "chat", "html", "lang":
m.Echo("4\n%s\n/%s: /\n", "usr/volcanos/proto.js", m.Option("pattern"))
case "msg":
m.Echo("4\nusr/volcanos/lib/%s.js\n/%s: \\(shy\\|func\\)/\n", "misc", m.Option("pattern"))
case "base", "core", "misc", "page", "user":
m.Echo("4\nusr/volcanos/lib/%s.js\n/%s: \\(shy\\|func\\)/\n", file, m.Option("pattern"))
case "onengine", "ondaemon", "onappend", "onlayout", "onmotion", "onkeypop":
m.Echo("4\n%s\n/%s: \\(shy\\|func\\)/\n", "usr/volcanos/frame.js", m.Option("pattern"))
switch m.Option("module") {
case "onimport", "onaction", "onexport":
m.Echo("4\n%s\n/%s: \\(shy\\|func\\)/\n", m.Option(BUF), m.Option("pattern"))
m.Echo("4\n%s\n/\\<%s: \\(shy\\|func\\)/\n", m.Option(BUF), m.Option("pattern"))
case "msg":
m.Echo("4\nusr/volcanos/lib/%s.js\n/\\<%s: \\(shy\\|func\\)/\n", "misc", m.Option("pattern"))
default:
switch m.Option("pattern") {
case "require", "request", "get", "set":
m.Echo("4\n%s\n/%s: \\(shy\\|func\\)/\n", "usr/volcanos/proto.js", m.Option("pattern"))
default:
m.Echo("4\n%s\n/%s: \\(shy\\|func\\)/\n", "usr/volcanos/frame.js", m.Option("pattern"))
if mdb.ZoneSelect(m, m.Option("module")); m.Length() > 0 {
switch m.Append(kit.MDB_TYPE) {
case "function":
m.Echo("4\nusr/volcanos%s\n/\\<%s: \\(shy\\|func\\)/\n", m.Append(kit.MDB_FILE), m.Option("pattern"))
default:
m.Echo("4\nusr/volcanos%s\n/\\<%s: /\n", m.Append(kit.MDB_FILE), m.Option("pattern"))
}
return
}
m.Echo("4\n%s\n/\\<%s: /\n", "usr/volcanos/proto.js", m.Option("pattern"))
}
}},
TAGS: {Name: "tags zone id auto", Help: "索引", Action: ice.MergeAction(map[string]*ice.Action{
@ -75,6 +59,9 @@ func init() {
m.PushAction(mdb.REMOVE)
} else {
if m.IsCliUA() {
if m.Length() == 0 {
return
}
m.Sort(kit.MDB_NAME)
m.Echo("func\n").Table(func(index int, value map[string]string, head []string) {
m.Echo(arg[0] + ice.PT + value[kit.MDB_NAME] + ice.NL)

1
misc/vim/vim.shy
View File

@ -24,7 +24,6 @@ make -j8 && make install
section "启动"
spark shell `
cd ./_install
./bin/vim
`

3
misc/vim/vimrc.go
View File

@ -19,8 +19,7 @@ func init() {
m.Cmd(mdb.RENDER, mdb.CREATE, VIM, m.Prefix(VIMRC))
code.LoadPlug(m, VIMRC)
}},
}, code.PlugAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
}},
}, code.PlugAction())},
}, Configs: map[string]*ice.Config{
VIMRC: {Name: VIMRC, Help: "收藏夹", Value: kit.Data(
code.PLUG, kit.Dict(

7
option.go
View File

@ -183,8 +183,11 @@ func (m *Message) ProcessCommand(cmd string, val []string, arg ...string) {
m.ProcessField(cmd, RUN)
m.Push(ARG, kit.Format(val))
}
func (m *Message) ProcessCommandOpt(arg ...string) {
m.Push(OPT, kit.Format(m.OptionSimple(arg...)))
func (m *Message) ProcessCommandOpt(arg []string, args ...string) {
if len(arg) > 0 && arg[0] == RUN {
return
}
m.Push(OPT, kit.Format(m.OptionSimple(args...)))
}
func (m *Message) ProcessField(arg ...interface{}) {
m.Process(PROCESS_FIELD)

64
type.go
View File

@ -367,29 +367,20 @@ func (m *Message) Search(key string, cb interface{}) *Message {
// 查找模块
p := m.target.root
key = strings.TrimPrefix(key, "ice.")
if ctx, ok := Info.names[key].(*Context); ok {
p = ctx
} else if key == "ice." {
p, key = m.target.root, ""
} else if key == PT {
if key = strings.TrimPrefix(key, "ice."); key == "." {
p, key = m.target, ""
} else if key == ".." {
if m.target.context == nil {
return m
}
p, key = m.target.context, ""
} else if key == "ice." {
p, key = m.target.root, ""
} else if strings.Contains(key, PT) {
list := strings.Split(key, PT)
ls := strings.Split(key, PT)
for _, p = range []*Context{m.target.root, m.target, m.source} {
if p == nil {
continue
}
for _, v := range list[:len(list)-1] {
if s, ok := p.contexts[v]; ok {
p = s
} else {
p = nil
for _, k := range ls[:len(ls)-1] {
if p = p.contexts[k]; p == nil {
break
}
}
@ -397,34 +388,38 @@ func (m *Message) Search(key string, cb interface{}) *Message {
break
}
}
if m.Warn(p == nil, ErrNotFound, key) {
return m
}
key = list[len(list)-1]
key = ls[len(ls)-1]
} else if ctx, ok := Info.names[key].(*Context); ok {
p = ctx
} else {
p = m.target
}
switch cb := cb.(type) {
case func(key string, cmd *Command): // 遍历命令
case func(key string, cmd *Command):
if key == "" {
for k, v := range p.Commands {
cb(k, v)
}
} else if cmd, ok := p.Commands[key]; ok {
cb(key, cmd)
}
case func(p *Context, s *Context, key string, cmd *Command):
if key == "" {
for key, cmd := range p.Commands {
cb(p.context, p, key, cmd)
cb(k, v) // 遍历命令
}
break
}
for _, p := range []*Context{m.target, p, m.source} {
if cmd, ok := p.Commands[key]; ok {
cb(key, cmd) // 查找命令
}
case func(p *Context, s *Context, key string, cmd *Command):
if key == "" {
for k, v := range p.Commands {
cb(p.context, p, k, v) // 遍历命令
}
break
}
for _, p := range []*Context{p, m.target, m.source} {
for s := p; s != nil; s = s.context {
if cmd, ok := s.Commands[key]; ok {
cb(s.context, s, key, cmd) // 查找命令
@ -433,6 +428,13 @@ func (m *Message) Search(key string, cb interface{}) *Message {
}
}
case func(p *Context, s *Context, key string, conf *Config):
if key == "" {
for k, v := range p.Configs {
cb(p.context, p, k, v) // 遍历命令
}
break
}
for _, p := range []*Context{m.target, p, m.source} {
for s := p; s != nil; s = s.context {
if cmd, ok := s.Configs[key]; ok {
@ -442,9 +444,9 @@ func (m *Message) Search(key string, cb interface{}) *Message {
}
}
case func(p *Context, s *Context, key string):
cb(p.context, p, key)
cb(p.context, p, key) // 查找模块
case func(p *Context, s *Context):
cb(p.context, p)
cb(p.context, p) // 查找模块
default:
m.Error(true, ErrNotImplement)
}