func deleteParam() cli.Command {
return cli.Command{
Name: "remove",
Usage: "remove parameter",
Flags: []cli.Flag{
cli.StringFlag{
Name: "name",
Usage: "name of a parameter",
},
},
Action: func(ctx *cli.Context) {
logger.Trace.Println("command params remove")
defer logger.Trace.Println("command params remove done")
name := ctx.String("name")
if !ctx.IsSet("name") || name == "" {
panic(fmt.Errorf("option name must be set"))
}
logger.Debug.Printf("remove parameter %s", name)
d := parameters.GetInstance()
defer checkErr(d.Close)
param, err := d.FindByName(name)
if err != nil {
panic(err)
}
if param.IsPreDefined() {
panic(ErrParamRemovePreDefined)
}
if err := d.Delete(param); err != nil {
panic(err)
}
logger.Info.Printf("Parameter removed: %s\n", param)
},
}
}
func setParam() cli.Command {
return cli.Command{
Name: "set",
Usage: "set parameter",
Flags: []cli.Flag{
cli.StringFlag{
Name: "name",
Usage: "name of a parameter",
},
cli.StringFlag{
Name: "value",
Usage: "name of a parameter",
},
cli.StringFlag{
Name: "desc",
Usage: "description of a parameter",
},
},
Action: func(ctx *cli.Context) {
logger.Trace.Println("command params set")
defer logger.Trace.Println("command params set done")
if !ctx.IsSet("name") || ctx.String("name") == "" {
panic(fmt.Errorf("option name must be set"))
}
name := ctx.String("name")
value := ctx.String("value")
description := ctx.String("desc")
logger.Debug.Printf("set parameter:%q value:%q description=%q\n", name, value, description)
d := parameters.GetInstance()
defer checkErr(d.Close)
param, err := d.FindByName(name)
if err == parameters.ErrNotFound {
param = parameters.MustParameter(name, value, description)
if err := d.Add(param); err != nil {
panic(err)
}
} else if err != nil {
panic(err)
}
if ctx.IsSet("value") {
param.Value = value
}
if ctx.IsSet("desc") && !param.IsPreDefined() {
param.Description = description
}
if err := d.Update(param); err != nil {
panic(err)
}
logger.Info.Printf("Parameter set: %s\n", param)
},
}
}
func getParam() cli.Command {
return cli.Command{
Name: "get",
Usage: "get parameter by name",
Flags: []cli.Flag{
cli.StringFlag{
Name: "name",
Usage: "name of a parameter",
},
cli.BoolFlag{
Name: "full,f",
Usage: "use full output with name,value,description",
},
},
Action: func(ctx *cli.Context) {
logger.Trace.Println("command params get")
defer logger.Trace.Println("command params get done")
if !ctx.IsSet("name") || ctx.String("name") == "" {
panic(fmt.Errorf("option name must be set"))
}
name := ctx.String("name")
logger.Debug.Printf("get parameter:%q\n", name)
d := parameters.GetInstance()
defer checkErr(d.Close)
param, err := d.FindByName(name)
if err != nil {
panic(err)
}
logger.Debug.Printf("parameter value:%q\n", param.ValueStr())
if ctx.Bool("full") || ctx.Bool("f") {
fmt.Printf("parameter:%s\nvalue:%s\ndescription:%s\n", param.Name, param.ValueStr(), param.Description)
} else {
fmt.Println(param.ValueStr())
}
},
}
}
func parseSQLFromArgs(ctx *cli.Context) *sqlcommand.SQLCommand {
var sqlText string
if !ctx.IsSet("sql") {
//Trying from stdin
fi, err := os.Stdin.Stat()
if err != nil {
panic(err)
}
if fi.Mode()&os.ModeNamedPipe == 0 {
return nil
}
bio := bufio.NewReader(os.Stdin)
sqlText, err = bio.ReadString(0)
if err != nil && err != io.EOF {
panic(err)
}
} else {
sqlText = ctx.String("sql")
}
//Prepare parameters
colParams, e := parameters.GetInstance().All()
if e != nil {
panic(e)
}
params := colParams.Get()
paramsArgs := ctx.StringSlice("param")
for i := 0; i < len(paramsArgs); i++ {
newparam, e := paramsreplace.Replace(paramsArgs[i], params)
if e != nil {
logger.Error.Println(e)
} else {
paramsArgs[i] = newparam
}
}
return sqlcommand.New(sqlText, paramsArgs)
}
//Run concrete action for all databases
func Run(dbs []db.Database, sql *sqlcommand.SQLCommand, act action.Actioner, ctx *action.Context, pget parametergetter.ParameterGetter) (*action.Context, error) {
logger.Trace.Println("rdb run")
defer logger.Trace.Println("rdb run done")
ctx.Set("params", pget)
ctx.Set("silent", pget.GetDef(parametergetter.Silent, false).(bool))
ctx.Snap.Start()
colParams, err := parameters.GetInstance().All()
if err != nil {
return nil, err
}
ctx.Set("Params", colParams.Get())
for _, d := range dbs {
err := runItem(d, sql, act, ctx, pget)
if err != nil {
logger.Error.Println(err)
//todo: в общий список ошибок
}
}
wg.Wait()
ctx.Snap.Done(nil)
return ctx, nil
}
func listParams() cli.Command {
return cli.Command{
Name: "list",
Usage: "list of parametrs",
Flags: []cli.Flag{
cli.BoolFlag{
Name: "fit",
Usage: "use for fit table by width window of terminal",
},
cli.StringFlag{
Name: "border",
Usage: "set type of border table: Thin,Double,Simple or None. Default:Thin",
},
},
Action: func(ctx *cli.Context) {
logger.Trace.Println("command params list")
defer logger.Trace.Println("command params list done")
d := parameters.GetInstance()
defer checkErr(d.Close)
params, err := d.All()
if err != nil {
panic(err)
}
tab := fmttab.New("List of databases", fmttab.BorderThin, nil)
tab.AddColumn("Id", 4, fmttab.AlignRight)
tab.AddColumn("Name", fmttab.WidthAuto, fmttab.AlignLeft)
tab.AddColumn("Value", fmttab.WidthAuto, fmttab.AlignLeft)
tab.AddColumn("Description", fmttab.WidthAuto, fmttab.AlignLeft)
for _, curd := range params.Get() {
rec := make(map[string]interface{})
rec["Id"] = curd.ID
rec["Name"] = curd.Name
rec["Value"] = curd.ValueStr()
rec["Description"] = curd.Description
tab.AppendData(rec)
}
pget := parametergetter.New(ctx, parameters.GetInstance())
if pget.GetDef(parametergetter.Fit, false).(bool) {
if e := termbox.Init(); e != nil {
panic(e)
}
tw, _ := termbox.Size()
tab.AutoSize(true, tw)
termbox.Close()
}
switch pget.GetDef(parametergetter.BorderTable, "").(string) {
case "Thin":
tab.SetBorder(fmttab.BorderThin)
case "Double":
tab.SetBorder(fmttab.BorderDouble)
case "None":
tab.SetBorder(fmttab.BorderNone)
case "Simple":
tab.SetBorder(fmttab.BorderSimple)
}
if _, err := tab.WriteTo(os.Stdout); err != nil {
panic(err)
}
},
}
}
func createParametersGetter(ctx *cli.Context) parametergetter.ParameterGetter {
return parametergetter.New(ctx, parameters.GetInstance())
}
func listDatabase() cli.Command {
dbFilterFlags := newCliFlags(cliOption{
Databases: modeFlagMulti,
ExcludeDatabases: modeFlagMulti,
Engines: modeFlagMulti,
Tags: modeFlagMulti,
ExcludeTags: modeFlagMulti,
})
return cli.Command{
Name: "list",
Usage: "list of databases",
Flags: append(dbFilterFlags.Flags(),
cli.BoolFlag{
Name: "fit",
Usage: "use for fit table by width window of terminal",
},
cli.StringFlag{
Name: "border",
Usage: "set type of border table: Thin,Double,Simple or None. Default:Thin",
}),
Action: func(ctx *cli.Context) error {
logger.Trace.Println("command list database")
dbFilterFlags.SetContext(ctx)
d := db.GetInstance()
dbs, err := d.All()
if err != nil {
return err
}
for _, e := range dbFilterFlags.Engines() {
rdb.CheckCodeEngine(e)
}
dbFilterFlags.ApplyTo(dbs)
tab := fmttab.New("List of databases", fmttab.BorderThin, nil)
tab.AddColumn("Id", 4, fmttab.AlignRight)
tab.AddColumn("On", 2, fmttab.AlignLeft)
tab.AddColumn("Code", 10, fmttab.AlignLeft)
tab.AddColumn("Engine", 11, fmttab.AlignLeft)
tab.AddColumn("URI", 40, fmttab.AlignLeft)
tab.AddColumn("Tags", 25, fmttab.AlignLeft)
for _, curd := range dbs.Get() {
rec := make(map[string]interface{})
rec["Id"] = curd.ID
if curd.Enabled {
rec["On"] = "+"
}
rec["Code"] = curd.Code
rec["URI"] = curd.ConnectionString
rec["Engine"] = curd.Engine
rec["Tags"] = curd.TagsComma(";")
tab.AppendData(rec)
}
pget := parametergetter.New(ctx, parameters.GetInstance())
if pget.GetDef(parametergetter.Fit, false).(bool) {
if e := termbox.Init(); e != nil {
panic(e)
}
tw, _ := termbox.Size()
tab.AutoSize(true, tw)
termbox.Close()
}
switch pget.GetDef(parametergetter.BorderTable, "").(string) {
case "Thin":
tab.SetBorder(fmttab.BorderThin)
case "Double":
tab.SetBorder(fmttab.BorderDouble)
case "None":
tab.SetBorder(fmttab.BorderNone)
case "Simple":
tab.SetBorder(fmttab.BorderSimple)
}
_, err = tab.WriteTo(os.Stdout)
return err
},
}
}
func tagDatabase() cli.Command {
dbFilterFlags := newCliFlags(cliOption{
Databases: modeFlagMulti,
ExcludeDatabases: modeFlagMulti,
Engines: modeFlagMulti,
Tags: modeFlagUnUsed,
ExcludeTags: modeFlagUnUsed,
})
flags := dbFilterFlags.Flags()
flags = append(flags, cli.StringSliceFlag{
Name: "add",
Usage: "new tag(s)",
})
flags = append(flags, cli.StringSliceFlag{
Name: "remove",
Usage: "remove tag(s)",
})
return cli.Command{
Name: "tag",
Usage: "add or remove tag for database",
Flags: flags,
Action: func(ctx *cli.Context) {
logger.Trace.Println("command db tag")
defer logger.Trace.Println("command db tag done")
var add, remove = ctx.StringSlice("add"), ctx.StringSlice("remove")
if len(add) == 0 && len(remove) == 0 {
panic(fmt.Errorf("must be set: new tag or del tag"))
}
dbFilterFlags.SetContext(ctx)
logger.Debug.Printf("updating new:%s remove:%s\n", add, remove)
d := db.GetInstance()
col, err := d.All()
if err != nil {
panic(err)
}
for _, e := range dbFilterFlags.Engines() {
rdb.CheckCodeEngine(e)
}
dbFilterFlags.ApplyTo(col)
dbs := col.Get()
if len(dbs) == 0 {
panic("databases not found")
}
pget := parametergetter.New(ctx, parameters.GetInstance())
showstat := pget.GetDef(parametergetter.Statistic, false).(bool)
var cntadd, cntremove int
for _, curdb := range dbs {
logger.Trace.Printf("process tag: %q\n", curdb.Code)
if cnt, err := d.AddTags(&curdb, add...); err != nil {
panic(err)
} else {
cntadd += cnt
logger.Info.Printf("Added tags %d for %s\n", cnt, curdb.Code)
}
if cnt, err := d.RemoveTags(&curdb, remove...); err != nil {
panic(err)
} else {
cntremove += cnt
logger.Info.Printf("Removed tags %d for %s\n", cnt, curdb.Code)
}
}
if showstat {
fmt.Printf("Added tags: %d\nRemoved tags: %d\n", cntadd, cntremove)
}
},
}
}
