func lintDesc(cmdName, optName, desc, origDesc string) {
if len(optName) == 0 {
logger.Panicf("option on %q has no name", cmdName)
}
if len(origDesc) != 0 {
logger.Panicf("description of %s's %q of %q set from tag (=> no i18n)", cmdName, optName, origDesc)
}
if len(desc) > 0 {
if !unicode.IsUpper(([]rune)(desc)[0]) {
logger.Panicf("description of %s's %q not uppercase: %q", cmdName, optName, desc)
}
}
}
func genSocketFile(appInfo *snap.AppInfo) string {
serviceTemplate := `[Unit]
# Auto-generated, DO NO EDIT
Description=Socket for snap application {{.App.Snap.Name}}.{{.App.Name}}
PartOf={{.ServiceFileName}}
X-Snappy=yes
[Socket]
ListenStream={{.App.ListenStream}}
{{if .App.SocketMode}}SocketMode={{.App.SocketMode}}{{end}}
[Install]
WantedBy={{.SocketTargetUnit}}
`
var templateOut bytes.Buffer
t := template.Must(template.New("wrapper").Parse(serviceTemplate))
wrapperData := struct {
App *snap.AppInfo
ServiceFileName string
SocketTargetUnit string
}{
App: appInfo,
ServiceFileName: filepath.Base(appInfo.ServiceFile()),
SocketTargetUnit: systemd.SocketsTarget,
}
if err := t.Execute(&templateOut, wrapperData); err != nil {
// this can never happen, except we forget a variable
logger.Panicf("Unable to execute template: %v", err)
}
return templateOut.String()
}
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
}
// Unlock releases the state lock and checkpoints the state.
// It does not return until the state is correctly checkpointed.
// After too many unsuccessful checkpoint attempts, it panics.
func (s *State) Unlock() {
defer s.unlock()
if !s.modified || s.backend == nil {
return
}
data := s.checkpointData()
var err error
start := time.Now()
for time.Since(start) <= unlockCheckpointRetryMaxTime {
if err = s.backend.Checkpoint(data); err == nil {
s.modified = false
return
}
time.Sleep(unlockCheckpointRetryInterval)
}
logger.Panicf("cannot checkpoint even after %v of retries every %v: %v", unlockCheckpointRetryMaxTime, unlockCheckpointRetryInterval, err)
}
// Run runs the requested command.
func Run(context *hookstate.Context, args []string) (stdout, stderr []byte, err error) {
parser := flags.NewParser(nil, flags.PassDoubleDash|flags.HelpFlag)
// Create stdout/stderr buffers, and make sure commands use them.
var stdoutBuffer bytes.Buffer
var stderrBuffer bytes.Buffer
for name, cmdInfo := range commands {
cmd := cmdInfo.generator()
cmd.setStdout(&stdoutBuffer)
cmd.setStderr(&stderrBuffer)
cmd.setContext(context)
_, err = parser.AddCommand(name, cmdInfo.shortHelp, cmdInfo.longHelp, cmd)
if err != nil {
logger.Panicf("cannot add command %q: %s", name, err)
}
}
_, err = parser.ParseArgs(args)
return stdoutBuffer.Bytes(), stderrBuffer.Bytes(), err
}
func genServiceFile(appInfo *snap.AppInfo) string {
serviceTemplate := `[Unit]
# Auto-generated, DO NO EDIT
Description=Service for snap application {{.App.Snap.Name}}.{{.App.Name}}
After=snapd.frameworks.target{{ if .App.Socket }} {{.SocketFileName}}{{end}}
Requires=snapd.frameworks.target{{ if .App.Socket }} {{.SocketFileName}}{{end}}
X-Snappy=yes
[Service]
ExecStart={{.App.LauncherCommand}}
Restart={{.Restart}}
WorkingDirectory={{.App.Snap.DataDir}}
{{if .App.StopCommand}}ExecStop={{.App.LauncherStopCommand}}{{end}}
{{if .App.PostStopCommand}}ExecStopPost={{.App.LauncherPostStopCommand}}{{end}}
{{if .StopTimeout}}TimeoutStopSec={{.StopTimeout.Seconds}}{{end}}
Type={{.App.Daemon}}
{{if .App.BusName}}BusName={{.App.BusName}}{{end}}
[Install]
WantedBy={{.ServiceTargetUnit}}
`
var templateOut bytes.Buffer
t := template.Must(template.New("wrapper").Parse(serviceTemplate))
var restartCond string
if appInfo.RestartCond == systemd.RestartNever {
restartCond = "no"
} else {
restartCond = appInfo.RestartCond.String()
}
if restartCond == "" {
restartCond = systemd.RestartOnFailure.String()
}
socketFileName := ""
if appInfo.Socket {
socketFileName = filepath.Base(appInfo.ServiceSocketFile())
}
wrapperData := struct {
App *snap.AppInfo
SocketFileName string
Restart string
StopTimeout time.Duration
ServiceTargetUnit string
Home string
EnvVars string
}{
App: appInfo,
SocketFileName: socketFileName,
Restart: restartCond,
StopTimeout: serviceStopTimeout(appInfo),
ServiceTargetUnit: systemd.ServicesTarget,
// systemd runs as PID 1 so %h will not work.
Home: "/root",
}
if err := t.Execute(&templateOut, wrapperData); err != nil {
// this can never happen, except we forget a variable
logger.Panicf("Unable to execute template: %v", err)
}
return templateOut.String()
}
// 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 {
optionsData.Version = func() {
printVersions()
panic(&exitStatus{0})
}
parser := flags.NewParser(&optionsData, flags.HelpFlag|flags.PassDoubleDash|flags.PassAfterNonOption)
parser.ShortDescription = i18n.G("Tool to interact with snaps")
parser.LongDescription = i18n.G(`
Install, configure, refresh and remove snap packages. Snaps are
'universal' packages that work across many different Linux systems,
enabling secure distribution of the latest apps and utilities for
cloud, servers, desktops and the internet of things.
This is the CLI for snapd, a background service that takes care of
snaps on the system. Start with 'snap list' to see installed snaps.
`)
parser.FindOptionByLongName("version").Description = i18n.G("Print the version and exit")
// Add all regular commands
for _, c := range commands {
obj := c.builder()
if x, ok := obj.(parserSetter); ok {
x.setParser(parser)
}
cmd, err := parser.AddCommand(c.name, c.shortHelp, strings.TrimSpace(c.longHelp), obj)
if err != nil {
logger.Panicf("cannot add command %q: %v", c.name, err)
}
cmd.Hidden = c.hidden
opts := cmd.Options()
if c.optDescs != nil && len(opts) != len(c.optDescs) {
logger.Panicf("wrong number of option descriptions for %s: expected %d, got %d", c.name, len(opts), len(c.optDescs))
}
for _, opt := range opts {
name := opt.LongName
if name == "" {
name = string(opt.ShortName)
}
desc, ok := c.optDescs[name]
if !(c.optDescs == nil || ok) {
logger.Panicf("%s missing description for %s", c.name, name)
}
lintDesc(c.name, name, desc, opt.Description)
if desc != "" {
opt.Description = desc
}
}
args := cmd.Args()
if c.argDescs != nil && len(args) != len(c.argDescs) {
logger.Panicf("wrong number of argument descriptions for %s: expected %d, got %d", c.name, len(args), len(c.argDescs))
}
for i, arg := range args {
name, desc := arg.Name, ""
if c.argDescs != nil {
name = c.argDescs[i].name
desc = c.argDescs[i].desc
}
lintArg(c.name, name, desc, arg.Description)
arg.Name = name
arg.Description = desc
}
}
return parser
}
func lintArg(cmdName, optName, desc, origDesc string) {
lintDesc(cmdName, optName, desc, origDesc)
if optName[0] != '<' || optName[len(optName)-1] != '>' {
logger.Panicf("argument %q's %q should have <>s", cmdName, optName)
}
}
// 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 {
optionsData.Version = func() {
printVersions()
panic(&exitStatus{0})
}
parser := flags.NewParser(&optionsData, flags.HelpFlag|flags.PassDoubleDash|flags.PassAfterNonOption)
parser.ShortDescription = i18n.G("Tool to interact with snaps")
parser.LongDescription = i18n.G(`
The snap tool interacts with the snapd daemon to control the snappy software platform.
`)
parser.FindOptionByLongName("version").Description = i18n.G("Print the version and exit")
// Add all regular commands
for _, c := range commands {
obj := c.builder()
if x, ok := obj.(parserSetter); ok {
x.setParser(parser)
}
cmd, err := parser.AddCommand(c.name, c.shortHelp, strings.TrimSpace(c.longHelp), obj)
if err != nil {
logger.Panicf("cannot add command %q: %v", c.name, err)
}
cmd.Hidden = c.hidden
opts := cmd.Options()
if c.optDescs != nil && len(opts) != len(c.optDescs) {
logger.Panicf("wrong number of option descriptions for %s: expected %d, got %d", c.name, len(opts), len(c.optDescs))
}
for _, opt := range opts {
name := opt.LongName
if name == "" {
name = string(opt.ShortName)
}
desc, ok := c.optDescs[name]
if !(c.optDescs == nil || ok) {
logger.Panicf("%s missing description for %s", c.name, name)
}
lintDesc(c.name, name, desc, opt.Description)
if desc != "" {
opt.Description = desc
}
}
args := cmd.Args()
if c.argDescs != nil && len(args) != len(c.argDescs) {
logger.Panicf("wrong number of argument descriptions for %s: expected %d, got %d", c.name, len(args), len(c.argDescs))
}
for i, arg := range args {
name, desc := arg.Name, ""
if c.argDescs != nil {
name = c.argDescs[i].name
desc = c.argDescs[i].desc
}
lintArg(c.name, name, desc, arg.Description)
arg.Name = name
arg.Description = desc
}
}
// 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 (inst *snapInstruction) dispatch() snapActionFunc {
if len(inst.Snaps) != 1 {
logger.Panicf("dispatch only handles single-snap ops; got %d", len(inst.Snaps))
}
return snapInstructionDispTable[inst.Action]
}