func getInitDbCommand() cli.Command {
return cli.Command{
Name: "init-db",
ShortName: "idb",
Usage: "Initialize DB backend with given schema file",
Description: `
Initialize empty database with given schema.
Setting meta-schema option will additionaly populate meta-schema table with schema resources.
Useful for development purposes.`,
Flags: []cli.Flag{
cli.StringFlag{Name: "database-type, t", Value: "sqlite3", Usage: "Backend datebase type"},
cli.StringFlag{Name: "database, d", Value: "gohan.db", Usage: "DB connection string"},
cli.StringFlag{Name: "schema, s", Value: "etc/schema/gohan.json", Usage: "Schema definition"},
cli.BoolFlag{Name: "drop-on-create", Usage: "If true, old database will be dropped"},
cli.BoolFlag{Name: "cascade", Usage: "If true, FOREIGN KEYS in database will be created with ON DELETE CASCADE"},
cli.StringFlag{Name: "meta-schema, m", Value: "", Usage: "Meta-schema file (optional)"},
},
Action: func(c *cli.Context) {
dbType := c.String("database-type")
dbConnection := c.String("database")
schemaFile := c.String("schema")
metaSchemaFile := c.String("meta-schema")
dropOnCreate := c.Bool("drop-on-create")
cascade := c.Bool("cascade")
manager := schema.GetManager()
manager.LoadSchemasFromFiles(schemaFile, metaSchemaFile)
err := db.InitDBWithSchemas(dbType, dbConnection, dropOnCreate, cascade)
if err != nil {
util.ExitFatal(err)
}
fmt.Println("DB is initialized")
},
}
}
func getValidateCommand() cli.Command {
return cli.Command{
Name: "validate",
ShortName: "v",
Usage: "Validate document",
Description: `
Validate document against schema.
It's especially useful to validate schema files against gohan meta-schema.`,
Flags: []cli.Flag{
cli.StringFlag{Name: "schema, s", Value: "etc/schema/gohan.json", Usage: "Schema path"},
cli.StringFlag{Name: "document, d", Value: "etc/apps/example.json", Usage: "Document path"},
},
Action: func(c *cli.Context) {
schemaPath := c.String("schema")
documentPath := c.String("document")
manager := schema.GetManager()
err := manager.LoadSchemaFromFile(schemaPath)
if err != nil {
util.ExitFatal("Failed to parse schema:", err)
}
err = manager.LoadSchemaFromFile(documentPath)
if err == nil {
fmt.Println("Schema is valid")
} else {
util.ExitFatalf("Schema is not valid, see errors below:\n%s\n", err)
}
},
}
}
func getValidateCommand() cli.Command {
return cli.Command{
Name: "validate",
ShortName: "v",
Usage: "Validate document",
Description: `
Validate document against schema.
It's especially useful to validate schema files against gohan meta-schema.`,
Flags: []cli.Flag{
cli.StringFlag{Name: "schema, s", Value: "etc/schema/gohan.json", Usage: "Schema path"},
cli.StringSliceFlag{Name: "document, d", Usage: "Document path"},
},
Action: func(c *cli.Context) {
schemaPath := c.String("schema")
documentPaths := c.StringSlice("document")
if len(documentPaths) == 0 {
util.ExitFatalf("At least one document should be specified for validation\n")
}
manager := schema.GetManager()
err := manager.LoadSchemaFromFile(schemaPath)
if err != nil {
util.ExitFatal("Failed to parse schema:", err)
}
for _, documentPath := range documentPaths {
err = manager.LoadSchemaFromFile(documentPath)
if err != nil {
util.ExitFatalf("Schema is not valid, see errors below:\n%s\n", err)
}
}
fmt.Println("Schema is valid")
},
}
}
func getConvertCommand() cli.Command {
return cli.Command{
Name: "convert",
ShortName: "conv",
Usage: "Convert DB",
Description: `
Gohan convert can be used to migrate Gohan resources between different types of databases.
Setting meta-schema option will additionaly convert meta-schema table with schema resources.
Useful for development purposes.`,
Flags: []cli.Flag{
cli.StringFlag{Name: "in-type, it", Value: "", Usage: "Input db type (yaml, json, sqlite3, mysql)"},
cli.StringFlag{Name: "in, i", Value: "", Usage: "Input db connection spec (or filename)"},
cli.StringFlag{Name: "out-type, ot", Value: "", Usage: "Output db type (yaml, json, sqlite3, mysql)"},
cli.StringFlag{Name: "out, o", Value: "", Usage: "Output db connection spec (or filename)"},
cli.StringFlag{Name: "schema, s", Value: "", Usage: "Schema file"},
cli.StringFlag{Name: "meta-schema, m", Value: "", Usage: "Meta-schema file (optional)"},
},
Action: func(c *cli.Context) {
inType, in := c.String("in-type"), c.String("in")
if inType == "" || in == "" {
util.ExitFatal("Need to provide input database specification")
}
outType, out := c.String("out-type"), c.String("out")
if outType == "" || out == "" {
util.ExitFatal("Need to provide output database specification")
}
schemaFile := c.String("schema")
if schemaFile == "" {
util.ExitFatal("Need to provide schema file")
}
metaSchemaFile := c.String("meta-schema")
schemaManager := schema.GetManager()
err := schemaManager.LoadSchemasFromFiles(schemaFile, metaSchemaFile)
if err != nil {
util.ExitFatal("Error loading schema:", err)
}
inDB, err := db.ConnectDB(inType, in)
if err != nil {
util.ExitFatal(err)
}
outDB, err := db.ConnectDB(outType, out)
if err != nil {
util.ExitFatal(err)
}
err = db.CopyDBResources(inDB, outDB)
if err != nil {
util.ExitFatal(err)
}
fmt.Println("Conversion complete")
},
}
}
func doTemplate(c *cli.Context) {
template := c.String("template")
manager := schema.GetManager()
configFile := c.String("config-file")
config := util.GetConfig()
err := config.ReadConfig(configFile)
if err != nil {
util.ExitFatal(err)
return
}
templateCode, err := util.GetContent(template)
if err != nil {
util.ExitFatal(err)
return
}
pwd, _ := os.Getwd()
os.Chdir(path.Dir(configFile))
schemaFiles := config.GetStringList("schemas", nil)
if schemaFiles == nil {
util.ExitFatal("No schema specified in configuraion")
} else {
err = manager.LoadSchemasFromFiles(schemaFiles...)
if err != nil {
util.ExitFatal(err)
return
}
}
schemas := manager.OrderedSchemas()
if err != nil {
util.ExitFatal(err)
return
}
tpl, err := pongo2.FromString(string(templateCode))
if err != nil {
util.ExitFatal(err)
return
}
output, err := tpl.Execute(pongo2.Context{"schemas": schemas})
if err != nil {
util.ExitFatal(err)
return
}
os.Chdir(pwd)
fmt.Println(output)
}
func getGohanClientCommand() cli.Command {
return cli.Command{
Name: "client",
Usage: "Manage Gohan resources",
SkipFlagParsing: true,
HideHelp: true,
Description: `gohan client schema_id command [arguments...]
COMMANDS:
list List all resources
show Show resource details
create Create resource
set Update resource
delete Delete resource
ARGUMENTS:
There are two types of arguments:
- named:
they are in '--name value' format and should be specified directly after
command name.
If you want to pass JSON null value, it should be written as: '--name "<null>"'.
Special named arguments:
--output-format [json/table] - specifies in which format results should be shown
--verbosity [0-3] - specifies how much debug info Gohan Client should show (default 0)
- unnamed:
they are in 'value' format and should be specified at the end of the line,
after all named arguments. At the moment only 'id' argument in 'show',
'set' and 'delete' commands are available in this format.
Identifying resources:
It is possible to identify resources with its ID and Name.
Examples:
gohan client network show network-id
gohan client network show "Network Name"
gohan client subnet create --network "Network Name"
gohan client subnet create --network network-id
gohan client subnet create --network_id network-id
CONFIGURATION:
Configuration is available by environment variables:
* Keystone username - OS_USERNAME
* Keystone password - OS_PASSWORD
* Keystone tenant name or tenant id - OS_TENANT_NAME or OS_TENANT_ID
* Keystone url - OS_AUTH_URL
* Gohan service name in keystone - GOHAN_SERVICE_NAME
* Gohan region in keystone - GOHAN_REGION
* Gohan schema URL - GOHAN_SCHEMA_URL
* Should Client cache schemas (default - true) - GOHAN_CACHE_SCHEMAS
* Cache expiration time (in format 1h20m10s - default 5m) - GOHAN_CACHE_TIMEOUT
* Cache path (default - /tmp/.cached-gohan-schemas) - GOHAN_CACHE_PATH
* In which format results should be shown, see --output-format - GOHAN_OUTPUT_FORMAT
* How much debug info Gohan Client should show, see --verbosity - GOHAN_VERBOSITY
Additional options for Keystone v3 only:
* Keystone domain name or domain id - OS_DOMAIN_NAME or OS_DOMAIN_ID
`,
Action: func(c *cli.Context) {
opts, err := client.NewOptsFromEnv()
if err != nil {
util.ExitFatal(err)
}
gohanCLI, err := client.NewGohanClientCLI(opts)
if err != nil {
util.ExitFatalf("Error initializing Gohan Client CLI: %v\n", err)
}
command := fmt.Sprintf("%s %s", c.Args().Get(0), c.Args().Get(1))
arguments := c.Args().Tail()
if len(arguments) > 0 {
arguments = arguments[1:]
}
result, err := gohanCLI.ExecuteCommand(command, arguments)
if err != nil {
util.ExitFatal(err)
}
if result == "null" {
result = ""
}
fmt.Println(result)
},
}
}