cmds

Documentation

Index

• Variables
• type ExampleCommand
  • func NewExampleCommand() *ExampleCommand
  • func (e *ExampleCommand) Description() *cmds.CommandDescription
  • func (e *ExampleCommand) Run(ctx context.Context, parsedLayers map[string]*layers.ParsedParameterLayer, ...) error
  • func (e *ExampleCommand) RunFromParka(c *gin.Context, parsedLayers map[string]*layers.ParsedParameterLayer, ...) error

Variables

var LsServerCmd = &cobra.Command{
	Use:   "ls",
	Short: "List a server's commands",
	Run: func(cmd *cobra.Command, args []string) {
		ctx := cmd.Context()

		server, err := cmd.Flags().GetString("server")
		cobra.CheckErr(err)

		resp, err := http.Get(server + "/api/commands")
		cobra.CheckErr(err)
		defer func(Body io.ReadCloser) {
			err := Body.Close()
			if err != nil {
				log.Error().Err(err).Msg("Failed to close response body")
			}
		}(resp.Body)

		body, err := io.ReadAll(resp.Body)
		cobra.CheckErr(err)

		// Unmarshal the response JSON into a slice of CommandDescription structs
		var cmds []map[string]interface{}
		err = json.Unmarshal(body, &cmds)
		cobra.CheckErr(err)

		gp, _, err := cli.CreateGlazedProcessorFromCobra(cmd)
		cobra.CheckErr(err)

		for _, cmd := range cmds {
			err = gp.AddRow(ctx, types.NewRowFromMap(cmd))
			cobra.CheckErr(err)
		}

		err = gp.Close(ctx)
		cobra.CheckErr(err)
	},
}

var ServeCmd = &cobra.Command{
	Use:   "serve",
	Short: "Starts the server",
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		port, err := cmd.Flags().GetUint16("port")
		cobra.CheckErr(err)
		host, err := cmd.Flags().GetString("host")
		cobra.CheckErr(err)

		serverOptions := []server.ServerOption{
			server.WithPort(port),
			server.WithAddress(host),
		}
		defaultLookups := []render.TemplateLookup{}

		dev, _ := cmd.Flags().GetBool("dev")
		templateDir, err := cmd.Flags().GetString("template-dir")
		cobra.CheckErr(err)

		if dev {
			log.Info().
				Str("assetsDir", "pkg/web/dist").
				Str("templateDir", "pkg/web/src/templates").
				Msg("Using assets from disk")
			serverOptions = append(serverOptions,
				server.WithStaticPaths(fs.NewStaticPath(http.FS(os.DirFS("pkg/web/dist")), "/dist")),
			)
			defaultLookups = append(defaultLookups, render.NewLookupTemplateFromDirectory("pkg/web/src/templates"))
		} else {
			serverOptions = append(serverOptions, server.WithDefaultParkaStaticPaths())
		}

		if templateDir != "" {
			if dev {
				defaultLookups = append(defaultLookups, render.NewLookupTemplateFromDirectory(templateDir))
			} else {
				lookup := render.NewLookupTemplateFromFS(
					render.WithFS(os.DirFS(templateDir)),
					render.WithPatterns("**/*.tmpl"),
				)
				defaultLookups = append(defaultLookups, lookup)
			}
		}

		serverOptions = append(serverOptions,
			server.WithDefaultParkaRenderer(render.WithPrependTemplateLookups(defaultLookups...)),
		)
		s, _ := server.NewServer(serverOptions...)

		s.Router.GET("/api/example", json2.CreateJSONQueryHandler(NewExampleCommand()))
		s.Router.GET("/example", datatables.CreateDataTablesHandler(NewExampleCommand(), "", "example"))
		s.Router.GET("/download/example.csv", output_file.CreateGlazedFileHandler(NewExampleCommand(), "example.csv"))

		ctx, cancel := context.WithCancel(context.Background())
		defer cancel()

		go func() {
			err := helpers.CancelOnSignal(ctx, os.Interrupt, cancel)
			if err != nil && err != context.Canceled {
				fmt.Println(err)
			}
		}()
		err = s.Run(ctx)

		cobra.CheckErr(err)
	},
}

Types

type ExampleCommand

type ExampleCommand struct {
	// contains filtered or unexported fields
}

func NewExampleCommand

func NewExampleCommand() *ExampleCommand

func (*ExampleCommand) Description

func (e *ExampleCommand) Description() *cmds.CommandDescription

func (*ExampleCommand) Run

func (e *ExampleCommand) Run(
	ctx context.Context,
	parsedLayers map[string]*layers.ParsedParameterLayer,
	ps map[string]interface{},
	gp middlewares.Processor,
) error

func (*ExampleCommand) RunFromParka

func (e *ExampleCommand) RunFromParka(
	c *gin.Context,
	parsedLayers map[string]*layers.ParsedParameterLayer,
	ps map[string]interface{},
	gp middlewares.Processor,
) error