func main() {
// get rpc address from env
rpcAddr := os.Getenv("RPC_ADDR")
if rpcAddr == "" {
rpcAddr = "127.0.0.1:6430"
}
// get wallet dir from env
wltDir := os.Getenv("WALLET_DIR")
if wltDir == "" {
home := util.UserHome()
wltDir = home + "/.skycoin/wallets"
}
// get wallet name from env
wltName := os.Getenv("WALLET_NAME")
if wltName == "" {
wltName = "skycoin_cli.wlt"
} else {
if !strings.HasSuffix(wltName, ".wlt") {
fmt.Println("value of 'WALLET_NAME' env is not correct, must has .wlt extenstion")
return
}
}
// init the skycli
skycli.Init(skycli.RPCAddr(rpcAddr),
skycli.WalletDir(wltDir),
skycli.DefaultWltName(wltName))
cli.SubcommandHelpTemplate = commandHelpTemplate
cli.CommandHelpTemplate = commandHelpTemplate
cli.HelpFlag = cli.BoolFlag{
Name: "help,h",
Usage: "show help, can also be used to show subcommand help",
}
app := cli.NewApp()
app.Usage = "the skycoin command line interface"
app.Version = "0.1"
app.Commands = skycli.Commands()
app.EnableBashCompletion = true
app.OnUsageError = func(context *cli.Context, err error, isSubcommand bool) error {
fmt.Fprintf(context.App.Writer, "Error: %v\n\n", err)
cli.ShowAppHelp(context)
return nil
}
app.CommandNotFound = func(ctx *cli.Context, command string) {
tmp := fmt.Sprintf("{{.HelpName}}: '%s' is not a {{.HelpName}} command. See '{{.HelpName}} --help'.\n", command)
cli.HelpPrinter(app.Writer, tmp, app)
}
if err := app.Run(os.Args); err != nil {
fmt.Println(err)
}
}
// NewAppFor creates a new instance of the command line parser (cli.App) for the given executableType.
func NewAppFor(executableType ExecutableType) *cli.App {
app := newAppFor(executableType)
registerCommandsFor(executableType, app)
app.CommandNotFound = func(c *cli.Context, command string) {
fmt.Fprintf(os.Stderr, "Command does not exist: %v\n\n", command)
cli.HelpPrinter(os.Stderr, cli.AppHelpTemplate, app)
}
return app
}
func (c *Create) Run(cliContext *cli.Context) (err error) {
if c.advancedOptions {
cli.HelpPrinter(cliContext.App.Writer, EntireOptionHelpTemplate, cliContext.Command)
return nil
}
if c.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if err = c.processParams(); err != nil {
return err
}
var images map[string]string
if images, err = c.checkImagesFiles(cliContext); err != nil {
return err
}
if len(cliContext.Args()) > 0 {
log.Errorf("Unknown argument: %s", cliContext.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Installing VCH ####")
var keypair *certificate.Keypair
if keypair, err = c.loadCertificate(); err != nil {
log.Error("Create cannot continue: unable to load certificate")
return err
}
if keypair != nil {
c.KeyPEM = keypair.KeyPEM
c.CertPEM = keypair.CertPEM
}
ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("Create timed out: use --timeout to add more time")
}
}()
validator, err := validate.NewValidator(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: failed to create validator")
return err
}
vchConfig, err := validator.Validate(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: configuration validation failed")
return err
}
if keypair != nil {
vchConfig.UserKeyPEM = string(keypair.KeyPEM)
vchConfig.UserCertPEM = string(keypair.CertPEM)
}
vConfig := validator.AddDeprecatedFields(ctx, vchConfig, c.Data)
vConfig.ImageFiles = images
vConfig.ApplianceISO = path.Base(c.ApplianceISO)
vConfig.BootstrapISO = path.Base(c.BootstrapISO)
{ // create certificates for VCH extension
var certbuffer, keybuffer bytes.Buffer
if certbuffer, keybuffer, err = certificate.CreateRawKeyPair(); err != nil {
return errors.Errorf("Failed to create certificate for VIC vSphere extension: %s", err)
}
vchConfig.ExtensionCert = certbuffer.String()
vchConfig.ExtensionKey = keybuffer.String()
}
executor := management.NewDispatcher(ctx, validator.Session, vchConfig, c.Force)
if err = executor.CreateVCH(vchConfig, vConfig); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Initialization of appliance successful")
executor.ShowVCH(vchConfig, c.key, c.cert)
log.Infof("Installer completed successfully")
return nil
}
func newFunctionsFor(renderer *Renderer) template.FuncMap {
return template.FuncMap{
"transformIdType": renderer.transformIDType,
"getDisplayIdOf": renderer.getDisplayIDOf,
"renderValueType": renderer.renderValueType,
"renderMarkdown": renderer.renderMarkdown,
"toSimple": func(definition Definition) *SimpleDefinition {
if result, ok := definition.(*SimpleDefinition); ok {
return result
}
return nil
},
"toObject": func(definition Definition) *ObjectDefinition {
if result, ok := definition.(*ObjectDefinition); ok {
return result
}
return nil
},
"toEnum": func(definition Definition) *EnumDefinition {
if result, ok := definition.(*EnumDefinition); ok {
return result
}
return nil
},
"toProperty": func(definition Definition) *PropertyDefinition {
if result, ok := definition.(*PropertyDefinition); ok {
return result
}
return nil
},
"toElement": func(definition Definition) *ElementDefinition {
if result, ok := definition.(*ElementDefinition); ok {
return result
}
return nil
},
"include": func(name string, data interface{}) (template.HTML, error) {
tmpl, err := parseTemplate(renderer.Project, "includes/"+name, renderer.Functions)
if err != nil {
return "", err
}
return tmpl.Execute(data)
},
"includeJavaScript": func(name string) (template.JS, error) {
content, err := ioutil.ReadFile(renderer.Project.SrcRootPath + "/manual/templates/scripts/" + name + ".js")
if err != nil {
return "", err
}
return template.JS(content), err
},
"includeCss": func(name string) (template.CSS, error) {
content, err := ioutil.ReadFile(renderer.Project.SrcRootPath + "/manual/templates/styles/" + name + ".css")
if err != nil {
return "", err
}
return template.CSS(content), err
},
"includeMarkdown": func(name string, headerTypeStart int, headerIdPrefix string, data interface{}) (template.HTML, error) {
source := renderer.Project.SrcRootPath + "/manual/includes/" + name + ".md"
content, err := ioutil.ReadFile(source)
if err != nil {
return "", err
}
html, err := renderer.renderMarkdownWithContext(string(content), nil, headerTypeStart, headerIdPrefix)
if err != nil {
return "", err
}
tmpl, err := template.New(source).Funcs(renderer.Functions).Parse(string(html))
if err != nil {
return "", err
}
buf := new(bytes.Buffer)
err = tmpl.ExecuteTemplate(buf, source, data)
if err != nil {
return "", err
}
return template.HTML(buf.String()), nil
},
"includeLicense": func() (string, error) {
content, err := ioutil.ReadFile(renderer.Project.SrcRootPath + "/LICENSE")
if err != nil {
return "", err
}
return string(content), err
},
"includeAppUsageOf": func(executableType app.ExecutableType, app *cli.App) template.HTML {
app.HelpName = executableType.String()
buf := new(bytes.Buffer)
cli.HelpPrinter(buf, cli.AppHelpTemplate, app)
content := buf.String()
content = renderer.replaceUsageEnvVarDisplaysIfNeeded(content)
return template.HTML(content)
},
"collectExamples": renderer.collectExamples,
"transformElementHtmlId": renderer.transformElementHTMLID,
"renderDefinitionStructure": renderer.renderDefinitionStructure,
}
}
func (c *Create) Run(cliContext *cli.Context) (err error) {
if c.advancedOptions {
cli.HelpPrinter(cliContext.App.Writer, EntireOptionHelpTemplate, cliContext.Command)
return nil
}
if c.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if err = c.processParams(); err != nil {
return err
}
var images map[string]string
if images, err = c.CheckImagesFiles(c.Force); err != nil {
return err
}
if len(cliContext.Args()) > 0 {
log.Errorf("Unknown argument: %s", cliContext.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Installing VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("Create timed out: use --timeout to add more time")
}
}()
validator, err := validate.NewValidator(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: failed to create validator")
return err
}
vchConfig, err := validator.Validate(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: configuration validation failed")
return err
}
vConfig := validator.AddDeprecatedFields(ctx, vchConfig, c.Data)
vConfig.ImageFiles = images
vConfig.ApplianceISO = path.Base(c.ApplianceISO)
vConfig.BootstrapISO = path.Base(c.BootstrapISO)
vConfig.HTTPProxy = c.HTTPProxy
vConfig.HTTPSProxy = c.HTTPSProxy
vchConfig.InsecureRegistries = c.Data.InsecureRegistries
if validator.Session.IsVC() { // create certificates for VCH extension
var certbuffer, keybuffer bytes.Buffer
if certbuffer, keybuffer, err = certificate.CreateSelfSigned("", []string{"VMware Inc."}, 2048); err != nil {
return errors.Errorf("Failed to create certificate for VIC vSphere extension: %s", err)
}
vchConfig.ExtensionCert = certbuffer.String()
vchConfig.ExtensionKey = keybuffer.String()
}
// separate initial validation from dispatch of creation task
log.Info("")
executor := management.NewDispatcher(ctx, validator.Session, vchConfig, c.Force)
if err = executor.CreateVCH(vchConfig, vConfig); err != nil {
executor.CollectDiagnosticLogs()
return err
}
// check the docker endpoint is responsive
if err = executor.CheckDockerAPI(vchConfig, c.clientCert); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Initialization of appliance successful")
executor.ShowVCH(vchConfig, c.key, c.cert, c.cacert, c.envFile)
log.Infof("Installer completed successfully")
return nil
}