feat: Support --args functionality in CLI

Arguments to a service can now be passed by
using the following syntax:

    pebble run [opts..] --args <svc> arguments.. ; [opts..]

Tests are failing right now, will be fixed soon.

Author: rebornplusplus

client/services.go

@@ -25,50 +25,63 @@ import (
 
 type ServiceOptions struct {
 	Names []string
+	Args  map[string][]string
 }
 
 // AutoStart starts the services makes as "startup: enabled". opts.Names must
 // be empty for this call.
 func (client *Client) AutoStart(opts *ServiceOptions) (changeID string, err error) {
-	_, changeID, err = client.doMultiServiceAction("autostart", opts.Names)
+	_, changeID, err = client.doMultiServiceAction("autostart", &multiActionOptions{services: opts.Names})
 	return changeID, err
 }
 
 // Start starts the services named in opts.Names in dependency order.
 func (client *Client) Start(opts *ServiceOptions) (changeID string, err error) {
-	_, changeID, err = client.doMultiServiceAction("start", opts.Names)
+	_, changeID, err = client.doMultiServiceAction("start", &multiActionOptions{services: opts.Names})
 	return changeID, err
 }
 
 // Stop stops the services named in opts.Names in dependency order.
 func (client *Client) Stop(opts *ServiceOptions) (changeID string, err error) {
-	_, changeID, err = client.doMultiServiceAction("stop", opts.Names)
+	_, changeID, err = client.doMultiServiceAction("stop", &multiActionOptions{services: opts.Names})
 	return changeID, err
 }
 
 // Restart stops and then starts the services named in opts.Names in
 // dependency order.
 func (client *Client) Restart(opts *ServiceOptions) (changeID string, err error) {
-	_, changeID, err = client.doMultiServiceAction("restart", opts.Names)
+	_, changeID, err = client.doMultiServiceAction("restart", &multiActionOptions{services: opts.Names})
 	return changeID, err
 }
 
 // Replan stops and (re)starts the services whose configuration has changed
 // since they were started. opts.Names must be empty for this call.
 func (client *Client) Replan(opts *ServiceOptions) (changeID string, err error) {
-	_, changeID, err = client.doMultiServiceAction("replan", opts.Names)
+	_, changeID, err = client.doMultiServiceAction("replan", &multiActionOptions{services: opts.Names})
 	return changeID, err
 }
 
+func (client *Client) PassServiceArgs(opts *ServiceOptions) (changeID string, err error) {
+	_, changeID, err = client.doMultiServiceAction("pass-args", &multiActionOptions{serviceArgs: opts.Args})
+	return changeID, err
+}
+
+type multiActionOptions struct {
+	services    []string
+	serviceArgs map[string][]string
+}
+
 type multiActionData struct {
-	Action   string   `json:"action"`
-	Services []string `json:"services"`
+	Action      string              `json:"action"`
+	Services    []string            `json:"services"`
+	ServiceArgs map[string][]string `json:"service-args"`
 }
 
-func (client *Client) doMultiServiceAction(actionName string, services []string) (result json.RawMessage, changeID string, err error) {
+func (client *Client) doMultiServiceAction(actionName string, opts *multiActionOptions) (result json.RawMessage, changeID string, err error) {
 	action := multiActionData{
-		Action:   actionName,
-		Services: services,
+		Action:      actionName,
+		Services:    opts.services,
+		ServiceArgs: opts.serviceArgs,
 	}
 	data, err := json.Marshal(&action)
 	if err != nil {

cmd/pebble/cmd_run.go

@@ -39,10 +39,11 @@ The run command starts pebble and runs the configured environment.
 type cmdRun struct {
 	clientMixin
 
-	CreateDirs bool   `long:"create-dirs"`
-	Hold       bool   `long:"hold"`
-	HTTP       string `long:"http"`
-	Verbose    bool   `short:"v" long:"verbose"`
+	CreateDirs bool       `long:"create-dirs"`
+	Hold       bool       `long:"hold"`
+	HTTP       string     `long:"http"`
+	Verbose    bool       `short:"v" long:"verbose"`
+	Args       [][]string `long:"args" terminator:";"`
 }
 
 func init() {
@@ -52,6 +53,7 @@ func init() {
 			"hold":        "Do not start default services automatically",
 			"http":        `Start HTTP API listening on this address (e.g., ":4000")`,
 			"verbose":     "Log all output from services to stdout",
+			"args":        "Pass terminated arguments",
 		}, nil)
 }
 
@@ -166,6 +168,20 @@ func runDaemon(rcmd *cmdRun, ch chan os.Signal) error {
 
 	logger.Debugf("activation done in %v", time.Now().Truncate(time.Millisecond).Sub(t0))
 
+	if rcmd.Args != nil {
+		mappedArgs, err := convertArgs(rcmd.Args)
+		if err != nil {
+			logger.Noticef("cannot parse service arguments: %v", err)
+		}
+		servopts := client.ServiceOptions{Args: mappedArgs}
+		changeID, err := rcmd.client.PassServiceArgs(&servopts)
+		if err != nil {
+			return fmt.Errorf("cannot pass arguments to services: %v", err)
+		} else {
+			logger.Noticef("Passed arguments to services with change %s.", changeID)
+		}
+	}
+
 	if !rcmd.Hold {
 		servopts := client.ServiceOptions{}
 		changeID, err := rcmd.client.AutoStart(&servopts)
@@ -199,3 +215,21 @@ out:
 
 	return d.Stop(ch)
 }
+
+func convertArgs(args [][]string) (map[string][]string, error) {
+	mappedArgs := make(map[string][]string)
+
+	for _, arg := range args {
+		if len(arg) < 2 {
+			continue
+		}
+
+		name := arg[0]
+		if _, ok := mappedArgs[name]; ok {
+			return nil, fmt.Errorf("Passing args twice to a service is not supported, in --args %s", name)
+		}
+		mappedArgs[name] = append([]string(nil), arg[1:]...)
+	}
+
+	return mappedArgs, nil
+}

internal/daemon/api_services.go

@@ -61,8 +61,9 @@ func v1GetServices(c *Command, r *http.Request, _ *userState) Response {
 
 func v1PostServices(c *Command, r *http.Request, _ *userState) Response {
 	var payload struct {
-		Action   string   `json:"action"`
-		Services []string `json:"services"`
+		Action      string              `json:"action"`
+		Services    []string            `json:"services"`
+		ServiceArgs map[string][]string `json:"service-args"`
 	}
 
 	decoder := json.NewDecoder(r.Body)
@@ -93,6 +94,10 @@ func v1PostServices(c *Command, r *http.Request, _ *userState) Response {
 			})
 		}
 		payload.Services = services
+	case "pass-args":
+		if len(payload.Services) != 0 {
+			return statusBadRequest("%s accepts no service names", payload.Action)
+		}
 	default:
 		if len(payload.Services) == 0 {
 			return statusBadRequest("no services to %s provided", payload.Action)
@@ -176,6 +181,11 @@ func v1PostServices(c *Command, r *http.Request, _ *userState) Response {
 		}
 		sort.Strings(services)
 		payload.Services = services
+	case "pass-args":
+		err = servmgr.SetServiceArgs(payload.ServiceArgs)
+		if err != nil {
+			break
+		}
 	default:
 		return statusBadRequest("action %q is unsupported", payload.Action)
 	}
@@ -187,7 +197,7 @@ func v1PostServices(c *Command, r *http.Request, _ *userState) Response {
 	// resolved one. But do use the resolved set for the count.
 	var summary string
 	switch {
-	case len(taskSet.Tasks()) == 0:
+	case taskSet == nil || len(taskSet.Tasks()) == 0:
 		// Can happen with a replan that has no services to stop/start. A
 		// change with no tasks needs to be marked Done manually (normally a
 		// change is marked Done when its last task is finished).

internal/overlord/servstate/manager.go

@@ -356,6 +356,16 @@ func (m *ServiceManager) StopOrder(services []string) ([]string, error) {
 	return m.plan.StopOrder(services)
 }
 
+func (m *ServiceManager) SetServiceArgs(serviceArgs map[string][]string) error {
+	releasePlan, err := m.acquirePlan()
+	if err != nil {
+		return err
+	}
+	defer releasePlan()
+
+	return m.plan.SetServiceArgs(serviceArgs)
+}
+
 // ServiceLogs returns iterators to the provided services. If last is negative,
 // return tail iterators; if last is zero or positive, return head iterators
 // going back last elements. Each iterator must be closed via the Close method.

internal/plan/plan.go

@@ -211,6 +211,11 @@ func (s *Service) GetCommand() ([]string, error) {
 	return fargs, nil
 }
 
+func (s *Service) setArgs(args []string) error {
+	s.cmdArgs = append([]string(nil), args...)
+	return nil
+}
+
 func (s *Service) checkCommand() error {
 	args, err := shlex.Split(s.Command)
 	if err != nil {
@@ -672,6 +677,28 @@ func (p *Plan) StopOrder(names []string) ([]string, error) {
 	return order(p.Services, names, true)
 }
 
+func (p *Plan) SetServiceArgs(serviceArgs map[string][]string) error {
+	for svcName, svcArgs := range serviceArgs {
+		service, ok := p.Services[svcName]
+		if !ok {
+			return fmt.Errorf("Service %s does not exist in the plan (arguments passed via --args)", svcName)
+		}
+		if err := service.setArgs(svcArgs); err != nil {
+			return err
+		}
+		for i := len(p.Layers) - 1; i >= 0; i-- {
+			layerService, ok := p.Layers[i].Services[svcName]
+			if ok {
+				if err := layerService.setArgs(svcArgs); err != nil {
+					return err
+				}
+				break
+			}
+		}
+	}
+	return nil
+}
+
 func order(services map[string]*Service, names []string, stop bool) ([]string, error) {
 	// For stop, create a list of reversed dependencies.
 	predecessors := map[string][]string(nil)