cliserv

var Create = &cli.Command{
	Name:    "service",
	Aliases: aliases,
	Action: func(ctx *cli.Context) error {
		client := cmdutil.GetClient(ctx)
		ns := cmdutil.GetNamespace(ctx)
		deplList, err := client.GetDeploymentList(ns)
		if err != nil {
			logrus.WithError(err).Errorf("error while gettin deployment list")
			return err
		}
		if len(deplList) == 0 {
			fmt.Printf("You have no deployments to create service :(")
			return nil
		}
		deployments := make([]string, 0, len(deplList))
		for _, depl := range deplList {
			deployments = append(deployments, depl.Name)
		}
		list, err := servactive.RunInteractveConstructor(servactive.ConstructorConfig{
			Force:       ctx.Bool("force"),
			Deployments: deployments,
		})
		switch err {
		case servactive.ErrUserStoppedSession, nil:

		default:
			logrus.WithError(err).Debugf("error while constructing service")
			return err
		}
		if len(list) == 0 {
			fmt.Printf("You didn't create any services\n")
			return nil
		}
		fmt.Println(list.RenderTable())
		if yes, _ := activeToolkit.Yes("Do you want to push services to server?"); yes {
			for _, serv := range list {
				if err := client.CreateService(ns, serv); err != nil {
					logrus.WithError(err).Errorf("unable to create service %q", serv.Name)
					return err
				}
			}
		}
		return nil
	},
	Flags: []cli.Flag{
		&cli.BoolFlag{
			Name:    "force",
			Aliases: []string{"f"},
			Value:   false,
		},
	},
}

var Delete = &cli.Command{
	Name:        "service",
	Usage:       "call to delete service in specific namespace",
	UsageText:   "chkit delete service service_label [-n namespace]",
	Description: "deletes service in namespace. Aliases: " + strings.Join(aliases, ", "),
	Aliases:     aliases,
	Flags:       cmdutil.DeleteFlags,
	Action: func(ctx *cli.Context) error {
		logrus.Debugf("running command delete service")
		client := cmdutil.GetClient(ctx)
		namespace := cmdutil.GetNamespace(ctx)
		if ctx.NArg() == 0 {
			logrus.Debugf("show help")
			return cli.ShowSubcommandHelp(ctx)
		}
		service := ctx.Args().First()
		logrus.Debugf("deleting service %q from %q", service, namespace)
		err := client.DeleteService(namespace, service)
		logrus.WithError(err).Debugf("error while deleting service")
		return err
	},
}

var GetService = &cli.Command{
	Name:        "service",
	Usage:       "shows service info",
	UsageText:   "chkit get service service_label [-o yaml/json] [-f output_file]",
	Description: "shows service info. Aliases: " + strings.Join(aliases, ", "),
	Aliases:     aliases,
	Action: func(ctx *cli.Context) error {
		client := cmdutil.GetClient(ctx)
		defer cmdutil.StoreClient(ctx, client)
		var show model.Renderer
		var err error

		anime := &animation.Animation{
			Framerate:      0.5,
			ClearLastFrame: true,
			Source:         trasher.NewSilly(),
		}
		go func() {
			time.Sleep(time.Second)
			anime.Run()
		}()

		switch ctx.NArg() {
		case 0:
			namespace := cmdutil.GetNamespace(ctx)
			list, err := client.GetServiceList(namespace)
			if err != nil {
				anime.Stop()
				return err
			}
			show = list
		case 1:
			namespace := cmdutil.GetNamespace(ctx)
			show, err = client.GetService(namespace, ctx.Args().First())
			if err != nil {
				anime.Stop()
				return err
			}
		default:
			namespace := cmdutil.GetNamespace(ctx)
			servicesNames := cmdutil.NewSet(ctx.Args().Slice())
			gainedList, err := client.GetServiceList(namespace)
			if err != nil {
				anime.Stop()
				return err
			}
			var list service.ServiceList
			for _, serv := range gainedList {
				if servicesNames.Have(serv.Name) {
					list = append(list, serv)
				}
			}
			show = list
		}
		anime.Stop()
		return cmdutil.ExportDataCommand(ctx, show)
	},
	Flags: cmdutil.GetFlags,
}