// Parser creates and populates a fresh parser. // Since commands have local state a fresh parser is required to isolate tests // from each other. func Parser() *flags.Parser { parser := flags.NewParser(&optionsData, flags.HelpFlag|flags.PassDoubleDash) // Add all regular commands for _, c := range commands { cmd, err := parser.AddCommand(c.name, c.shortHelp, strings.TrimSpace(c.longHelp), c.builder()) if err != nil { logger.Panicf("cannot add command %q: %v", c.name, err) } cmd.Hidden = c.hidden } // Add the experimental command experimentalCommand, err := parser.AddCommand("experimental", shortExperimentalHelp, longExperimentalHelp, &cmdExperimental{}) experimentalCommand.Hidden = true if err != nil { logger.Panicf("cannot add command %q: %v", "experimental", err) } // Add all the sub-commands of the experimental command for _, c := range experimentalCommands { cmd, err := experimentalCommand.AddCommand(c.name, c.shortHelp, strings.TrimSpace(c.longHelp), c.builder()) if err != nil { logger.Panicf("cannot add experimental command %q: %v", c.name, err) } cmd.Hidden = c.hidden } return parser }
func init() { _, err := parser.AddCommand("enable-classic", i18n.G("Enable classic dimension."), i18n.G("Enable the ubuntu classic dimension."), &cmdEnableClassic{}) if err != nil { logger.Panicf("Unable to enable-classic: %v", err) } _, err = parser.AddCommand("destroy-classic", i18n.G("Destroy the classic dimension."), i18n.G("Destroy the ubuntu classic dimension."), &cmdDestroyClassic{}) if err != nil { logger.Panicf("Unable to destroy-classic: %v", err) } }
func init() { _, err := parser.AddCommand("activate", i18n.G(`Activate a package`), i18n.G(`Activate a package that has previously been deactivated. If the package is already activated, do nothing.`), &cmdActivate{activate: true}) if err != nil { logger.Panicf("Unable to activate: %v", err) } _, err = parser.AddCommand("deactivate", i18n.G(`Deactivate a package`), i18n.G(`Deactivate a package. If the package is already deactivated, do nothing.`), &cmdActivate{activate: false}) if err != nil { logger.Panicf("Unable to deactivate: %v", err) } }
func (data customData) set(key string, value interface{}) { serialized, err := json.Marshal(value) if err != nil { logger.Panicf("internal error: could not marshal value for state entry %q: %v", key, err) } entryJSON := json.RawMessage(serialized) data[key] = &entryJSON }
func (s *State) checkpointData() []byte { data, err := json.Marshal(s) if err != nil { // this shouldn't happen, because the actual delicate serializing happens at various Set()s logger.Panicf("internal error: could not marshal state for checkpointing: %v", err) } return data }
func init() { _, err := parser.AddCommand("grub-migrate", "internal", "internal", &cmdGrubMigrate{}) if err != nil { logger.Panicf("Unable to grub-migrate: %v", err) } }
func init() { _, err := parser.AddCommand("versions", shortVersionsHelp, longVersionsHelp, &cmdVersions{}) if err != nil { logger.Panicf("Unable to versions: %v", err) } }
func init() { _, err := parser.AddCommand("console", "Run snappy console interface", "Run snappy console interface", &cmdConsole{}) if err != nil { logger.Panicf("Unable to console: %v", err) } }
func init() { _, err := parser.AddCommand("firstboot", "internal", "internal", &cmdInternalFirstBootOemConfig{}) if err != nil { logger.Panicf("Unable to first_boot: %v", err) } }
func init() { _, err := parser.AddCommand("booted", "internal", "internal", &cmdBooted{}) if err != nil { logger.Panicf("Unable to booted: %v", err) } }
func init() { _, err := parser.AddCommand("internal-run-hooks", "internal", "internal", &cmdInternalRunHooks{}) if err != nil { logger.Panicf("Unable to internal_run_hooks: %v", err) } }
func init() { _, err := parser.AddCommand("set", i18n.G("Set properties of system or package"), setHelp, &cmdSet{}) if err != nil { logger.Panicf("Unable to set: %v", err) } }
func init() { _, err := parser.AddCommand("internal-unpack", "internal", "internal", &cmdInternalUnpack{}) if err != nil { logger.Panicf("Unable to internal_unpack: %v", err) } }
func init() { arg, err := parser.AddCommand("hw-info", shortHWInfoHelp, longHWInfoHelp, &cmdHWInfo{}) if err != nil { logger.Panicf("Unable to hwinfo: %v", err) } addOptionDescription(arg, "package name", i18n.G("List assigned hardware for a specific installed package")) }
func init() { arg, err := parser.AddCommand("shell", i18n.G("Run snappy shell interface"), i18n.G("Run snappy shell interface"), &cmdShell{}) if err != nil { logger.Panicf("Unable to add shell command: %q", err) } addOptionDescription(arg, "shell-type", i18n.G("The type of shell you want")) }
func init() { arg, err := parser.AddCommand("login", shortLoginHelp, longLoginHelp, &cmdLogin{}) if err != nil { logger.Panicf("Unable to login: %v", err) } addOptionDescription(arg, "userid", i18n.G("Username for the login")) }
func init() { arg, err := parser.AddCommand("purge", shortPurgeHelp, longPurgeHelp, &cmdPurge{}) if err != nil { logger.Panicf("Unable to purge: %v", err) } addOptionDescription(arg, "installed", i18n.G("Purge an installed package.")) }
func init() { arg, err := parser.AddCommand("remove", i18n.G("Remove a snapp part"), i18n.G("Remove a snapp part"), &cmdRemove{}) if err != nil { logger.Panicf("Unable to remove: %v", err) } addOptionDescription(arg, "no-gc", i18n.G("Do not clean up old versions of the package.")) }
func init() { arg, err := parser.AddCommand("config", shortConfigHelp, longConfigHelp, &cmdConfig{}) if err != nil { logger.Panicf("Unable to config: %v", err) } addOptionDescription(arg, "package name", i18n.G("Set configuration for a specific installed package")) addOptionDescription(arg, "config file", i18n.G("The configuration for the given file")) }
func init() { _, err := parser.AddCommand("service", i18n.G("Query and modify snappy services"), i18n.G("Query and modify snappy services of locally-installed packages"), &cmdService{}) if err != nil { logger.Panicf("Unable to service: %v", err) } }
func init() { arg, err := parser.AddCommand("rollback", shortRollbackHelp, longRollbackHelp, &cmdRollback{}) if err != nil { logger.Panicf("Unable to rollback: %v", err) } addOptionDescription(arg, "package name", i18n.G("The package to rollback ")) addOptionDescription(arg, "version", i18n.G("The version to rollback to")) }
func init() { arg, err := parser.AddCommand("update", i18n.G("Update all installed parts"), i18n.G("Ensures system is running with latest parts"), &cmdUpdate{}) if err != nil { logger.Panicf("Unable to update: %v", err) } addOptionDescription(arg, "no-gc", i18n.G("Do not clean up old versions of the package.")) addOptionDescription(arg, "automatic-reboot", i18n.G("Reboot if necessary to be on the latest running system.")) }
func init() { arg, err := parser.AddCommand("policygen", i18n.G("Generate the apparmor policy"), i18n.G("Generate the apparmor policy"), &cmdPolicygen{}) if err != nil { logger.Panicf("Unable to install: %v", err) } addOptionDescription(arg, "force", i18n.G("Force policy generation.")) addOptionDescription(arg, "package.yaml path", i18n.G("The path to the package.yaml used to generate the apparmor policy.")) }
func init() { arg, err := parser.AddCommand("hw-unassign", shortHWUnassignHelp, longHWUnassignHelp, &cmdHWUnassign{}) if err != nil { logger.Panicf("Unable to hwunassign: %v", err) } addOptionDescription(arg, "package name", i18n.G("Remove hardware from a specific installed package")) addOptionDescription(arg, "device path", i18n.G("The hardware device path (e.g. /dev/ttyUSB0)")) }
func init() { arg, err := parser.AddCommand("info", shortInfoHelp, longInfoHelp, &cmdInfo{}) if err != nil { logger.Panicf("Unable to info: %v", err) } addOptionDescription(arg, "verbose", i18n.G("Provides more detailed information")) addOptionDescription(arg, "include-remote", i18n.G("Include information about packages from the snappy store")) addOptionDescription(arg, "package name", i18n.G("Provide information about a specific installed package")) }
func init() { cmd, err := parser.AddCommand("search", i18n.G("Search for packages to install"), i18n.G("Query the store for available packages"), &cmdSearch{}) if err != nil { logger.Panicf("Unable to search: %v", err) } cmd.Aliases = append(cmd.Aliases, "se") addOptionDescription(cmd, "show-all", i18n.G("Show all available forks of a package")) }
func init() { cmd, err := parser.AddCommand("build", i18n.G("Builds a snap package"), longBuildHelp, &cmdBuild{}) if err != nil { logger.Panicf("Unable to build: %v", err) } cmd.Aliases = append(cmd.Aliases, "bu") addOptionDescription(cmd, "output", i18n.G("Specify an alternate output directory for the resulting package")) }
func fillSnapEnvVars(desc interface{}, vars []string) []string { for i, v := range vars { var templateOut bytes.Buffer t := template.Must(template.New("wrapper").Parse(v)) if err := t.Execute(&templateOut, desc); err != nil { // this can never happen, except we forget a variable logger.Panicf("Unable to execute template: %v", err) } vars[i] = templateOut.String() } return vars }
func init() { arg, err := parser.AddCommand("install", i18n.G("Install a snap package"), i18n.G("Install a snap package"), &cmdInstall{}) if err != nil { logger.Panicf("Unable to install: %v", err) } addOptionDescription(arg, "allow-unauthenticated", i18n.G("Install snaps even if the signature can not be verified.")) addOptionDescription(arg, "no-gc", i18n.G("Do not clean up old versions of the package.")) addOptionDescription(arg, "package name", i18n.G("The Package to install (name or path)")) addOptionDescription(arg, "config file", i18n.G("The configuration for the given install")) }
func init() { cmd, err := parser.AddCommand("list", shortListHelp, longListHelp, &cmdList{}) if err != nil { logger.Panicf("Unable to list: %v", err) } cmd.Aliases = append(cmd.Aliases, "li") addOptionDescription(cmd, "updates", i18n.G("Show available updates (requires network)")) addOptionDescription(cmd, "verbose", i18n.G("Show channel information and expand all fields")) }