cmn

Documentation

Index

• func FailOnError(logger *utils.Logger, err error)
• type App
  • func NewApp(config *model.Config, logger *utils.Logger) *App
• type ChannelInterface
• type ChannelRabbitMq
  • func NewRabbitMq(app *App) *ChannelRabbitMq
  • func (r *ChannelRabbitMq) Receive()
  • func (r *ChannelRabbitMq) Start()
  • func (r *ChannelRabbitMq) Subscribe()
• type ChannelRedis
  • func NewRedis(app *App) *ChannelRedis
  • func (r *ChannelRedis) Receive()
  • func (r *ChannelRedis) Start()
  • func (r *ChannelRedis) Subscribe()
• type Job
  • func NewJob(app *App) *Job
  • func (j Job) Run(message *model.ReceivedMessage)
• type Scheduler
  • func NewScheduler(app *App) *Scheduler
  • func (s *Scheduler) Packages() ([]string, map[string]SchedulerInterface)
• type SchedulerGoCron
  • func (s *SchedulerGoCron) Add(args ...interface{})
  • func (s *SchedulerGoCron) Delete(args ...interface{})
  • func (s *SchedulerGoCron) Down()
  • func (s *SchedulerGoCron) List()
  • func (s *SchedulerGoCron) Run()
  • func (s *SchedulerGoCron) Start()
  • func (s *SchedulerGoCron) Stop()
  • func (s *SchedulerGoCron) Up()
  • func (s *SchedulerGoCron) Update(args ...interface{})
• type SchedulerInterface
• type SchedulerJob
• type SchedulerJobRunner
  • func (s *SchedulerJobRunner) Add(args ...interface{})
  • func (s *SchedulerJobRunner) Delete(args ...interface{})
  • func (s *SchedulerJobRunner) Down()
  • func (s *SchedulerJobRunner) List()
  • func (s *SchedulerJobRunner) Run()
  • func (s *SchedulerJobRunner) Start()
  • func (s *SchedulerJobRunner) Stop()
  • func (s *SchedulerJobRunner) Up()
  • func (s *SchedulerJobRunner) Update(args ...interface{})

Functions

func FailOnError

func FailOnError(logger *utils.Logger, err error)

FailOnError panic error with logger

Types

type App

type App struct {
	Database        *database.Database
	Channel         chan os.Signal
	Config          *model.Config
	Logger          *utils.Logger
	ChannelRabbitMq *ChannelRabbitMq
	ChannelRedis    *ChannelRedis
	Scheduler       *Scheduler
	Mode            model.MODE
	Job             *Job
	Node            *model2.Node
}

App structure

func NewApp

func NewApp(config *model.Config, logger *utils.Logger) *App

NewApp building new app

type ChannelInterface

type ChannelInterface interface {
	Start()
	Subscribe()
	Receive()
}

ChannelInterface queuing structure interface

type ChannelRabbitMq

type ChannelRabbitMq struct {
	ChannelInterface
	App     *App
	Conn    *amqp.Connection
	Channel *amqp.Channel
}

ChannelRabbitMq queuing structure

func NewRabbitMq

func NewRabbitMq(app *App) *ChannelRabbitMq

NewRabbitMq building rabbitMQ queuing

func (*ChannelRabbitMq) Receive

func (r *ChannelRabbitMq) Receive()

Receive consume rabbitMQ channel

func (*ChannelRabbitMq) Start

func (r *ChannelRabbitMq) Start()

Start RabbitMQ Conn

func (*ChannelRabbitMq) Subscribe

func (r *ChannelRabbitMq) Subscribe()

Subscribe rabbitMQ channel

type ChannelRedis

type ChannelRedis struct {
	ChannelInterface
	App    *App
	Client *redis.Client
	PubSub *redis.PubSub
}

ChannelRedis queuing structure

func NewRedis

func NewRedis(app *App) *ChannelRedis

NewRedis building redis queuing

func (*ChannelRedis) Receive

func (r *ChannelRedis) Receive()

Receive redis channel

func (*ChannelRedis) Start

func (r *ChannelRedis) Start()

Start Redis Conn

func (*ChannelRedis) Subscribe

func (r *ChannelRedis) Subscribe()

Subscribe redis channel

type Job

type Job struct {
	App    *App
	Name   string
	Detail interface{}
}

Job structure

func NewJob

func NewJob(app *App) *Job

NewJob building job

func (Job) Run

func (j Job) Run(message *model.ReceivedMessage)

Run job with received message

type Scheduler

type Scheduler struct {
	App     *App
	Package SchedulerInterface
}

Scheduler application job scheduler

func NewScheduler

func NewScheduler(app *App) *Scheduler

NewScheduler building job scheduler

func (*Scheduler) Packages

func (s *Scheduler) Packages() ([]string, map[string]SchedulerInterface)

Packages All defined scheduler packages

type SchedulerGoCron

type SchedulerGoCron struct {
	SchedulerInterface `json:"-"`
	*Scheduler
	GoCron *gocron.Scheduler
	Jobs   []Job
}

SchedulerGoCron gocron package adapter

func (*SchedulerGoCron) Add

func (s *SchedulerGoCron) Add(args ...interface{})

Add gcron job

func (*SchedulerGoCron) Delete

func (s *SchedulerGoCron) Delete(args ...interface{})

Delete gocron job

func (*SchedulerGoCron) Down

func (s *SchedulerGoCron) Down()

Down gocron kill

func (*SchedulerGoCron) List

func (s *SchedulerGoCron) List()

List gcron jobs

func (*SchedulerGoCron) Run

func (s *SchedulerGoCron) Run()

Run gocron job

func (*SchedulerGoCron) Start

func (s *SchedulerGoCron) Start()

Start gocron

func (*SchedulerGoCron) Stop

func (s *SchedulerGoCron) Stop()

Stop gocron job

func (*SchedulerGoCron) Up

func (s *SchedulerGoCron) Up()

Up gocron scheduler

func (*SchedulerGoCron) Update

func (s *SchedulerGoCron) Update(args ...interface{})

Update gocron job

type SchedulerInterface

type SchedulerInterface interface {
	Up()
	Down()
	Start()
	List()
	Add(args ...interface{})
	Update(args ...interface{})
	Delete(args ...interface{})
	Run()
	Stop()
}

SchedulerInterface application job scheduler interface

type SchedulerJob

type SchedulerJob struct {
	Data interface{} `json:"data"`
}

SchedulerJob General scheduler job struct

type SchedulerJobRunner

type SchedulerJobRunner struct {
	SchedulerInterface `json:"-"`
	*Scheduler
}

SchedulerJobRunner jobrunner package adapter

func (*SchedulerJobRunner) Add

func (s *SchedulerJobRunner) Add(args ...interface{})

Add jobrunner job

func (*SchedulerJobRunner) Delete

func (s *SchedulerJobRunner) Delete(args ...interface{})

Delete jobrunner job

func (*SchedulerJobRunner) Down

func (s *SchedulerJobRunner) Down()

Down jobrunner kill

func (*SchedulerJobRunner) List

func (s *SchedulerJobRunner) List()

List jobrunner jobs

func (*SchedulerJobRunner) Run

func (s *SchedulerJobRunner) Run()

Run jobrunner job

func (*SchedulerJobRunner) Start

func (s *SchedulerJobRunner) Start()

Start jobrunner job

func (*SchedulerJobRunner) Stop

func (s *SchedulerJobRunner) Stop()

Stop jobrunner job

func (*SchedulerJobRunner) Up

func (s *SchedulerJobRunner) Up()

Up jobruner start

func (*SchedulerJobRunner) Update

func (s *SchedulerJobRunner) Update(args ...interface{})

Update jobrunner job