App struct

App represents a Vanilla OS application

Fields:

  • Sign (types.Sign)
  • RDNN (string)
  • Name (string)
  • Version (string)
  • Log (logsTypes.Logger)
  • LC (spreak.Localizer)
  • LocalesFS (embed.FS)
  • CLI (*cli.Command)

Methods:

WithCLI

WithCLI adds a command line interface to the application

Parameters:
  • options *cliTypes.CLIOptions

Example:

app.WithCLI(&cli.CLIOptions{
	Use:   "batsignal",
	Short: "A simple CLI to call Batman",
	Long:  "A simple CLI to call Batman using the BatSignal",
})
Show/Hide Method Body 
{
	app.CLI = cli.NewCLI(options)
}

NewApp function

NewApp creates a new Vanilla OS application, which can be used to

interact with the system. The application is created with the

default configuration if no options are provided.

Example:

app, err := app.NewApp({
RDNN: "com.vanilla-os.batsignal",
Name: "BatSignal",
Version: "1.0.0",
LocalesFS: localesFS,
DefaultLocale: "en",
CLIOptions: &cli.CLIOptions{
Use: "batsignal",
Short: "A simple CLI to call Batman",
Long: "A simple CLI to call Batman using the BatSignal",
},
})
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
fmt.Printf("App Sign: %s\n", app.Sign)

Notes:

If the project does not provide a FS for the locales, the

localizer will not be created. If the localizer fails to be created

in any way, the application will continue to work without it but

translation keys will be returned as they are (in English).

The logger, instead, is mandatory for each application. So if the

logger fails to be created, the application will return an error and

will not work.

Parameters:

  • options types.AppOptions

Returns:

  • *App
  • error
Show/Hide Function Body 
{
	app := App{
		RDNN:      options.RDNN,
		Name:      options.Name,
		Version:   options.Version,
		LocalesFS: options.LocalesFS,
	}
	app.Sign = generateAppSign(&app)

	// here we prepare a logger for the application
	logger, err := logs.NewLogger(string(app.Sign))
	if err != nil {
		return &app, err // logger is mandatory for each application
	}
	app.Log = logger

	// here we prepare a localizer for the application
	localizer, err := i18n.NewLocalizer(options.LocalesFS, app.RDNN, options.DefaultLocale)
	if err == nil {
		app.LC = *localizer
	} // something went wrong, perhaps the FS is not provided

	return &app, nil
}

generateAppSign function

generateAppSign generates a unique signature for the application

based on the RDNN, name and version. The signature is used to

identify the application.

Parameters:

  • app *App

Returns:

  • types.Sign
Show/Hide Function Body 
{
	sign := fmt.Sprintf("%s-%s-%s", app.RDNN, app.Name, app.Version)

	h := sha1.New()
	h.Write([]byte(sign))
	return types.Sign(base64.URLEncoding.EncodeToString(h.Sum(nil)))
}

crypto/sha1 import

Import example:

import "crypto/sha1"

embed import

Import example:

import "embed"

encoding/base64 import

Import example:

import "encoding/base64"

fmt import

Import example:

import "fmt"

github.com/vanilla-os/sdk/pkg/v1/app/types import

Import example:

import "github.com/vanilla-os/sdk/pkg/v1/app/types"

github.com/vanilla-os/sdk/pkg/v1/cli import

Import example:

import "github.com/vanilla-os/sdk/pkg/v1/cli"

github.com/vanilla-os/sdk/pkg/v1/cli/types import

Import example:

import "github.com/vanilla-os/sdk/pkg/v1/cli/types"

Imported as:

cliTypes

github.com/vanilla-os/sdk/pkg/v1/i18n import

Import example:

import "github.com/vanilla-os/sdk/pkg/v1/i18n"

github.com/vanilla-os/sdk/pkg/v1/logs import

Import example:

import "github.com/vanilla-os/sdk/pkg/v1/logs"

github.com/vanilla-os/sdk/pkg/v1/logs/types import

Import example:

import "github.com/vanilla-os/sdk/pkg/v1/logs/types"

Imported as:

logsTypes

github.com/vorlif/spreak import

Import example:

import "github.com/vorlif/spreak"