Slice (Work in progress)

Problem

During the process of writing software in the team, you develop a certain style and define standards that meet the requirements for this software. These standards grow into libraries and frameworks. This is our approach based on interface-based programming and modular programming.

Overview

package main

import (
	"github.com/goava/slice"
	"github.com/goava/di"
	// imports omitted
)

func main() {
	slice.Run(
		slice.WithName("grpc-service"),
		slice.WithBundles(
			logging.Bundle,
			monitoring.Bundle,
			grpc.Bundle,
		),
		slice.WithComponents(
			slice.Provide(NewDispatcher, di.As(new(slice.Dispatcher))),
			slice.Provide(grpcsrv.NewService, di.As(new(grpc.Service))),
		),
	)
}

Minimal start

The minimum that you need to run the application on slice.

Set application name

Use slice.WithName("your name") to specify the application name.

slice.Run(
    slice.WithName("sliced"),
    // ...
)

Check application environment

Use environment variable ENV to specify the application environment. The value can be any string. Environments that have a prefix dev will be recognized as a development environment. Others will be recognized as production.

Provide application dispatcher

Provide your own slice.Dispatcher implementation:

slice.Run(
    slice.WithName("sliced"),
    slice.WithComponents(
        slice.Provide(NewDispatcher, di.As(new(slice.Dispatcher))),
    ),
)

How it works

Application lifecycle

Initialization

• Initializes slice.StdLogger
• Checks application name
• Initializes slice.Context
• Parses environment variables:
  • ENV
  • DEBUG
• Provide slice.Env
• Initializes slice.Info
• Checks bundle acyclic and sort dependencies
• Validates component signatures

Configuring

• Resolves slice.ParameterParser
• Collects parameters
• Checks --parameters flag
• Provides parameters
• Resolves slice.Logger

Starting

• Check dispatchers exists
• Sets StartTimeout and ShutdownTimeout
• Runs interrupt signal catcher
• Invokes BeforeStart bundle hooks
• Resolves dispatchers

Running

• Run dispatchers

Shutdown

• Invokes BeforeShutdown bundle hooks in reverse order

Lifecycle details

Parameter parsing

Applications created with slice support parameter parsing. By default, it's processed by envconfig.

You can use your own parameter parser. To do this, implement the ParameterParser interface and use it using the WithParameterParser() or by setting the ParameterParser field of the Application.

You can print all parameters by using <binary-name> --parameters. Example output with default parameter parser and following structure:

// Parameters contains application configuration.
type Parameters struct {
	Addr         string        `envconfig:"addr" required:"true" desc:"Server address"`
	ReadTimeout  time.Duration `envconfig:"read_timeout" required:"true" desc:"Server read timeout"`
	WriteTimeout time.Duration `envconfig:"write_timeout" required:"true" desc:"Server write timeout"`
}

Output:

KEY              TYPE        DEFAULT    REQUIRED    DESCRIPTION
ADDR             String                 true        Server address
READ_TIMEOUT     Duration               true        Server read timeout
WRITE_TIMEOUT    Duration               true        Server write timeout

Components

Default components

slice.Context

A Context carries a deadline, a cancellation signal, and other values across API boundaries.

slice.Info

Info contains information about application: name, env, debug.

User components

TBD

Bundle components

TBD

References

• interface-based programming
• modular programming
• uber-go/fx