app

README

Application as service

Base config file

config.yaml

env: dev
level: 3 
log: /var/log/simple.log
pig: /var/run/simple.pid

level:

• 0 - error only
• 1 - + warning
• 2 - + info
• 3 - + debug

Example

package main

import (
	"fmt"

	"github.com/osspkg/go-sdk/app"
	"github.com/osspkg/go-sdk/log"
)

type (
	//Simple model
	Simple struct{}
	//Config model
	Config struct {
		Env string `yaml:"env"`
	}
)

//NewSimple init Simple
func NewSimple(_ Config) *Simple {
	fmt.Println("--> call NewSimple")
	return &Simple{}
}

//Up  method for start Simple in DI container
func (s *Simple) Up(_ app.Context) error {
	fmt.Println("--> call *Simple.Up")
	return nil
}

//Down  method for stop Simple in DI container
func (s *Simple) Down(_ app.Context) error {
	fmt.Println("--> call *Simple.Down")
	return nil
}

func main() {
	app.New().
		Logger(log.Default()).
		ConfigFile(
			"./config.yaml",
			Config{},
		).
		Modules(
			NewSimple,
		).
		Run()
}

HowTo

Run the app

app.New()
    .ConfigFile(<path to config file: string>, <config objects separate by comma: ...interface{}>)
    .Modules(<config objects separate by comma: ...interface{}>)
    .Run()

Supported types for initialization

• Function that returns an object or interface

All incoming dependencies will be injected automatically

type Simple1 struct{}
func NewSimple1(_ *log.Logger) *Simple1 { return &Simple1{} }

Returns the interface

type Simple2 struct{}
type Simple2Interface interface{
    Get() string
}
func NewSimple2() Simple2Interface { return &Simple2{} }
func (s2 *Simple2) Get() string { 
    return "Hello world"
}

If the object has the Up(app.Context) error and Down() error methods, they will be called Up(app.Context) error when the app starts, and Down() error when it finishes. This allows you to automatically start and stop routine processes inside the module

var _ service.IServiceCtx = (*Simple3)(nil)
type Simple3 struct{}
func NewSimple3(_ *Simple4) *Simple3 { return &Simple3{} }
func (s3 *Simple3) Up(_ app.Context) error { return nil }
func (s3 *Simple3) Down(_ app.Context) error { return nil }

• Named type

type HelloWorld string

• Object structure

type Simple4 struct{
    S1 *Simple1
    S2 Simple2Interface
    HW HelloWorld
}

• Object reference or type

s1 := &Simple1{}
hw := HelloWorld("Hello!!")

Documentation

Index

• type App
  • func New() App
• type Config
• type Context
  • func NewContext() Context
• type ENV
• type Modules
  • func (m Modules) Add(v ...interface{}) Modules
• type ServiceContextInterface
• type ServiceInterface
• type Sources
  • func (v Sources) Decode(configs ...interface{}) error

Types

type App

type App interface {
	Logger(log log.Logger) App
	Modules(modules ...interface{}) App
	ConfigFile(filename string, configs ...interface{}) App
	PidFile(filename string) App
	Run()
	Invoke(call interface{})
	ExitFunc(call func(code int)) App
}

func New

func New() App

New create application

type Config

type Config struct {
	Env     string `yaml:"env"`
	Level   uint32 `yaml:"level"`
	LogFile string `yaml:"log"`
}

Config config model

type Context

type Context interface {
	Close()
	Context() context.Context
	Done() <-chan struct{}
}

Context model for force close application

func NewContext

func NewContext() Context

type ENV

type ENV string

ENV type for environments (prod, dev, stage, etc)

type Modules

type Modules []interface{}

Modules DI container

func (Modules) Add

func (m Modules) Add(v ...interface{}) Modules

Add object to container

type ServiceContextInterface

type ServiceContextInterface interface {
	Up(ctx Context) error
	Down() error
}

ServiceContextInterface interface for services with context

type ServiceInterface

type ServiceInterface interface {
	Up() error
	Down() error
}

ServiceInterface interface for services

type Sources

type Sources string

Sources model

func (Sources) Decode

func (v Sources) Decode(configs ...interface{}) error

Decode unmarshal file to model