Example #1
0
func main() {
	if _, err := os.Stat("mate.conf"); err != nil {
		if os.IsNotExist(err) {
			fmt.Println("Please copy mate.conf.example to mate.conf, and configure this file.")
			return
		}
		fmt.Println(err)
		return
	}

	logrus_mate.Logger().Infoln("=== Using internal defualt logurs mate ===")
	logrus_mate.Logger().Debugln("Hello Default Logrus Mate")

	loggerConf := logrus_mate.LoggerConfig{
		Level: "info",
		Formatter: logrus_mate.FormatterConfig{
			Name: "json",
		},
	}

	if _, err := logrus_mate.NewLogger("jack", loggerConf); err != nil {
		logrus_mate.Logger().Error(err)
		return
	}

	logrus_mate.Logger().Warnln("*** Add Logger named jack, and it will use json format")

	logrus_mate.Logger("jack").Debugln("not print")
	logrus_mate.Logger("jack").Infoln("Hello, I am A Logger from jack")

	fmt.Println("")
	os.Setenv("RUN_MODE", "production")
	logrus_mate.Logger().Infoln("=== Load logrus mate config from mate.conf ===")

	if mateConf, err := logrus_mate.LoadLogrusMateConfig("mate.conf"); err != nil {
		logrus_mate.Logger().Error(err)
		return
	} else {

		logrus_mate.Logger().Debugf("Run mode is %s", mateConf.RunEnv())

		if newMate, err := logrus_mate.NewLogrusMate(mateConf); err != nil {
			logrus_mate.Logger().Error(err)
			return
		} else {
			newMate.Logger("mike").Errorln("I am mike in new logrus mate")

			ErrTest := errors.TN("GOGAP", 1000, "hello {{.param}}")
			ErrTest2 := errors.TN("GOGAP", 1002, "hello")
			e := ErrTest.New(errors.Params{"param": "world"}).Append("append error").Append(ErrTest2).WithContext("key", "Value")
			newMate.Logger("mike").WithError(e).Error(e)

			// This sleep is for output of redisio to write data to redis
			time.Sleep(time.Second)
		}
	}

}
Example #2
0
package main

import (
	"fmt"

	"github.com/gogap/errors"
)

var (
	ERR_PARSE_TEST     = errors.T(10001, "test error")
	ERR_PARSE_TEST2    = errors.T(10002, "test {{.param1}} error")
	ERR_STACK_TEST     = errors.T(10003, "call stack test")
	ERR_NAMESPACE_TEST = errors.TN("GOOD", 10001, "haha error")
)

func main() {
	if e := errors.LoadMessageTemplate("./test.txt"); e != nil {
		fmt.Println(e)
		return
	}

	err1 := ERR_PARSE_TEST.New()
	equal1 := ERR_PARSE_TEST.IsEqual(err1)
	fmt.Println(err1)
	fmt.Println(err1, "Equal", ERR_PARSE_TEST, "?:", equal1)

	fmt.Println("==FullError=======================")
	fmt.Println(err1.FullError())

	err2 := ERR_PARSE_TEST2.New(errors.Params{"param1": "example"})
Example #3
0
package http_json_api

import (
	"encoding/json"
	"github.com/gogap/errors"
	"github.com/gogap/spirit"
	"github.com/rs/xid"
	"strings"
)

var (
	ErrHttpResponseGenericError = errors.TN(HttpJsonApiErrNamespace, 100, "")
)

type JsonPayload struct {
	Id      string          `json:"id"`
	Data    interface{}     `json:"data"`
	Errors  []*spirit.Error `json:"errors"`
	Context spirit.Map      `json:"context"`
}

type HttpJsonApiPayload struct {
	id      string
	data    interface{}
	errs    []*spirit.Error
	context spirit.Map
}

func NewHttpJsonApiPayload() (payload *HttpJsonApiPayload) {
	payload = &HttpJsonApiPayload{
		id:      xid.New().String(),
Example #4
0
package ali_mns

import (
	"github.com/gogap/errors"
)

const (
	ALI_MNS_ERR_NS = "MNS"

	ali_MNS_ERR_TEMPSTR = "ali_mns response status error,code: {{.resp.Code}}, message: {{.resp.Message}}, resource: {{.resource}} request id: {{.resp.RequestId}}, host id: {{.resp.HostId}}"
)

var (
	ERR_SIGN_MESSAGE_FAILED        = errors.TN(ALI_MNS_ERR_NS, 1, "sign message failed, {{.err}}")
	ERR_MARSHAL_MESSAGE_FAILED     = errors.TN(ALI_MNS_ERR_NS, 2, "marshal message filed, {{.err}}")
	ERR_GENERAL_AUTH_HEADER_FAILED = errors.TN(ALI_MNS_ERR_NS, 3, "general auth header failed, {{.err}}")

	ERR_CREATE_NEW_REQUEST_FAILED = errors.TN(ALI_MNS_ERR_NS, 4, "create new request failed, {{.err}}")
	ERR_SEND_REQUEST_FAILED       = errors.TN(ALI_MNS_ERR_NS, 5, "send request failed, {{.err}}")
	ERR_READ_RESPONSE_BODY_FAILED = errors.TN(ALI_MNS_ERR_NS, 6, "read response body failed, {{.err}}")

	ERR_UNMARSHAL_ERROR_RESPONSE_FAILED = errors.TN(ALI_MNS_ERR_NS, 7, "unmarshal error response failed, {{.err}}")
	ERR_UNMARSHAL_RESPONSE_FAILED       = errors.TN(ALI_MNS_ERR_NS, 8, "unmarshal response failed, {{.err}}")
	ERR_DECODE_BODY_FAILED              = errors.TN(ALI_MNS_ERR_NS, 9, "decode body failed, {{.err}}, body: \"{{.body}}\"")
	ERR_GET_BODY_DECODE_ELEMENT_ERROR   = errors.TN(ALI_MNS_ERR_NS, 10, "get body decode element error, local: {{.local}}, error: {{.err}}")

	ERR_MNS_ACCESS_DENIED                = errors.TN(ALI_MNS_ERR_NS, 100, ali_MNS_ERR_TEMPSTR)
	ERR_MNS_INVALID_ACCESS_KEY_ID        = errors.TN(ALI_MNS_ERR_NS, 101, ali_MNS_ERR_TEMPSTR)
	ERR_MNS_INTERNAL_ERROR               = errors.TN(ALI_MNS_ERR_NS, 102, ali_MNS_ERR_TEMPSTR)
	ERR_MNS_INVALID_AUTHORIZATION_HEADER = errors.TN(ALI_MNS_ERR_NS, 103, ali_MNS_ERR_TEMPSTR)
	ERR_MNS_INVALID_DATE_HEADER          = errors.TN(ALI_MNS_ERR_NS, 104, ali_MNS_ERR_TEMPSTR)
Example #5
0
File: errors.go Project: gogap/aop
package aop

import (
	"github.com/gogap/errors"
)

const (
	AOPErrorNamespace = "AOP"
)

var (
	ErrBeanInstanceIsNil         = errors.TN(AOPErrorNamespace, 1, "aop error namespace is nil, id: {{.id}}")
	ErrBeanIsNotAnPtr            = errors.TN(AOPErrorNamespace, 2, "bean should be an ptr, id: {{.id}}")
	ErrBeanAlreadyRegistered     = errors.TN(AOPErrorNamespace, 3, "bean already regitered, id: {{.id}}")
	ErrBeanIDShouldNotBeEmpty    = errors.TN(AOPErrorNamespace, 4, "bean id should not be empty")
	ErrBeanNotExist              = errors.TN(AOPErrorNamespace, 5, "bean not exist, id: {{.id}}")
	ErrAspectIDShouldNotBeEmpty  = errors.TN(AOPErrorNamespace, 6, "aspect id should not be empty")
	ErrBeanMethodNotExit         = errors.TN(AOPErrorNamespace, 7, "bean method not exist, id: {{.id}}, class: {{.class}}, method: {{.method}}")
	ErrWrongAdviceFuncArgsNum    = errors.TN(AOPErrorNamespace, 8, "wrong advice func args number, id: {{.id}}, class: {{.class}}, method: {{.method}}")
	ErrEndInvokeParamsIsNotFunc  = errors.TN(AOPErrorNamespace, 9, "en invoke params is not func, bean id: {{.id}}, method: {{.method}}")
	ErrWrongEndInvokeFuncArgsNum = errors.TN(AOPErrorNamespace, 10, "wrong end invoke func args number, bean id: {{.id}}, method: {{.method}}")
	ErrInvokeParamsIsNotFunc     = errors.TN(AOPErrorNamespace, 11, "invoke params is not func, bean id: {{.id}}, method: {{.method}}")
	ErrWrongInvokeFuncArgsNum    = errors.TN(AOPErrorNamespace, 12, "wrong invoke func args number, bean id: {{.id}}, method: {{.method}}")
	ErrInvokeFuncNotExist        = errors.TN(AOPErrorNamespace, 13, "invoke func not exist, bean id: {{.id}}, method: {{.method}}")
	ErrInvokeFuncTypeError       = errors.TN(AOPErrorNamespace, 14, "invoke func is not func type, bean id: {{.id}}, method: {{.method}}")
	ErrEndInvokeTwice            = errors.TN(AOPErrorNamespace, 15, "end invoke twice, bean id: {{.id}}, method: {{.method}}")
	ErrBadInvokeMethodType       = errors.TN(AOPErrorNamespace, 16, "invoke method params should be func name or func type")
	ErrPointcutNotExist          = errors.TN(AOPErrorNamespace, 17, "pointcut no exist, pointcut id: {{.id}}")
	ErrMethodIsNil               = errors.TN(AOPErrorNamespace, 18, "method is nil")
	ErrBadMethodType             = errors.TN(AOPErrorNamespace, 19, "method type error")
	ErrBadPointcutExpr           = errors.TN(AOPErrorNamespace, 20, "bad pointcut expression, expression: {{.expr}}")
Example #6
0
package spirit

import (
	"github.com/gogap/errors"
)

const SPIRIT_ERR_NS = "SPIRIT"

var (
	ERR_MESSAGE_GRAPH_ADDRESS_NOT_FOUND = errors.TN(SPIRIT_ERR_NS, 1, "could not found next address in graph, current component name: {{.compName}}, port name: {{.portName}}")
	ERR_MESSAGE_GRAPH_IS_NIL            = errors.TN(SPIRIT_ERR_NS, 2, "component graph is nil")
	ERR_MESSAGE_ADDRESS_IS_EMPTY        = errors.TN(SPIRIT_ERR_NS, 3, "component message address is empty")
	ERR_MESSAGE_SERIALIZE_FAILED        = errors.TN(SPIRIT_ERR_NS, 4, "component message serialize failed, err: {{.err}}")

	ERR_COMPONENT_HANDLER_RETURN_ERROR = errors.TN(SPIRIT_ERR_NS, 5, "component handler return error, component name: {{.name}}, port: {{.port}}, error: {{.err}}")
	ERR_COMPONENT_HANDLER_NOT_EXIST    = errors.TN(SPIRIT_ERR_NS, 6, "component handler not exist, component name: {{.name}},  handler name: {{.handlerName}}")

	ERR_SENDER_CREDENTIAL_IS_NIL = errors.TN(SPIRIT_ERR_NS, 8, "credential is nil, type: {{.type}}, url: {{.url}}")
	ERR_SENDER_MNS_CLIENT_IS_NIL = errors.TN(SPIRIT_ERR_NS, 9, "sender mns client is nil, type: {{.type}}, url: {{.url}}")
	ERR_SENDER_SEND_FAILED       = errors.TN(SPIRIT_ERR_NS, 10, "component message send failed, type: {{.type}}, url: {{.url}}, err:{{.err}}")

	ERR_SENDER_CREATE_FAILED    = errors.TN(SPIRIT_ERR_NS, 11, "create sender failed, driver type: {{.type}}")
	ERR_SENDER_DRIVER_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 12, "message sender driver not exist, type: {{.type}}")
	ERR_SENDER_BAD_DRIVER       = errors.TN(SPIRIT_ERR_NS, 13, "bad message sender driver of {{.type}}")

	ERR_RECEIVER_CREDENTIAL_IS_NIL     = errors.TN(SPIRIT_ERR_NS, 14, "credential is nil, type: {{.type}}")
	ERR_RECEIVER_MNS_CLIENT_IS_NIL     = errors.TN(SPIRIT_ERR_NS, 15, "receiver mns client is nil, type: {{.type}}, url: {{.url}}")
	ERR_RECEIVER_DELETE_MSG_ERROR      = errors.TN(SPIRIT_ERR_NS, 16, "delete message error, type: {{.type}}, url: {{.url}}, err: {{.err}}")
	ERR_RECEIVER_UNMARSHAL_MSG_FAILED  = errors.TN(SPIRIT_ERR_NS, 17, "receiver unmarshal message failed, type: {{.type}}, err: {{.err}}")
	ERR_RECEIVER_RECV_ERROR            = errors.TN(SPIRIT_ERR_NS, 18, "receiver recv error, type: {{.type}}, url: {{.url}}, err: {{.err}}")
	ERR_RECEIVER_BAD_DRIVER            = errors.TN(SPIRIT_ERR_NS, 19, "bad message receiver driver of {{.type}}")
Example #7
0
	"encoding/base64"
	"github.com/gogap/errors"
	"github.com/gogap/spirit"
	"strings"

	"github.com/gogap/spirit_tutorial/todo/controllers"
)

var _ spirit.Component = new(AuthComponent)

const (
	taskAuthComponentURN = "urn:spirit_tutorial:component:todo:auth"
)

var (
	ErrAuthorizationHeaderNotExist = errors.TN(TodoErrorNamespace, 30001, "header of Authorization not exist!")
	ErrAuthorizationHeaderFmtError = errors.TN(TodoErrorNamespace, 30002, "header of Authorization format error.")
)

type AuthComponent struct {
	name string
	*controllers.Auth
}

func init() {
	spirit.RegisterComponent(taskAuthComponentURN, NewAuthComponent)
}

func NewAuthComponent(name string, options spirit.Map) (component spirit.Component, err error) {
	component = &AuthComponent{
		name: name,
Example #8
0
package event_center

import (
	"github.com/gogap/errors"
)

const EVENT_CENTER_ERR_NS = "EVENT_CENTER"

var (
	ERR_SUBSCRIBER_NOT_EXIST               = errors.TN(EVENT_CENTER_ERR_NS, 1, "subscriber {{.id}} not exist")
	ERR_COULD_NOT_GET_ANONYMOUS_SUBSCRIBER = errors.TN(EVENT_CENTER_ERR_NS, 2, "could not get subscriber anonymous by name")
	ERR_INVALIDATE_INDEX_RANGE             = errors.TN(EVENT_CENTER_ERR_NS, 3, "invalidate index range")
	ERR_SUBSCRIBER_ID_IS_EMPTY             = errors.TN(EVENT_CENTER_ERR_NS, 4, "subscriber id is empty")
	ERR_SUBSCRIBER_HANDLER_IS_NIL          = errors.TN(EVENT_CENTER_ERR_NS, 5, "subscriber handler is nil, index: {{.index}}, name: {{.id}}")
	ERR_SUBSCRIBER_ID_GENERATE_FAILED      = errors.TN(EVENT_CENTER_ERR_NS, 6, "generate subscriber id failed, err: {{.err}}")
	ERR_SUBSCRIBER_IS_NIL                  = errors.TN(EVENT_CENTER_ERR_NS, 7, "subscriber is nil")

	ERR_EVENT_ALREADY_REGISTERED = errors.TN(EVENT_CENTER_ERR_NS, 8, "event already registered, name: {{.name}}")
	ERR_EVENT_NAME_IS_EMPTY      = errors.TN(EVENT_CENTER_ERR_NS, 9, "event name is empty")
	ERR_EVENT_NOT_EXIST          = errors.TN(EVENT_CENTER_ERR_NS, 10, "event not exist, name: {{.name}}")

	ERR_EVENT_CENTER_NAME_IS_EMPTY = errors.TN(EVENT_CENTER_ERR_NS, 11, "event center name is empty")
)
Example #9
0
package api_client

import (
	"github.com/gogap/errors"
)

const (
	HttpJsonApiErrNamespace = "JSON_APIClient"
)

var JsonApiClientErrorNamespace = "APIClient"

var (
	ErrAPINameIsEmpty                   = errors.TN(JsonApiClientErrorNamespace, 1, "api name is empty")
	ErrAPIClientSendFailed              = errors.TN(JsonApiClientErrorNamespace, 2, "api client send failed, api: {{.api}}, url: {{.url}}")
	ErrAPIClientResponseUnmarshalFailed = errors.TN(JsonApiClientErrorNamespace, 3, "api response unmarshal failed, api: {{.api}}, url: {{.url}}")

	ErrAPIClientReadResponseBodyFailed = errors.TN(JsonApiClientErrorNamespace, 4, "read api response body failed, api is: {{.api}}")
	ErrAPIClientBadStatusCode          = errors.TN(JsonApiClientErrorNamespace, 5, "bad response status code, api is: {{.api}}, code is: {{.code}}")
	ErrAPIClientCreateNewRequestFailed = errors.TN(JsonApiClientErrorNamespace, 6, "create new request failed")

	ErrUnknownPayloadError = errors.TN(JsonApiClientErrorNamespace, 7, "")
)
Example #10
0
package http_json_api

import (
	"github.com/gogap/errors"
)

const (
	HttpJsonApiErrNamespace = "JSON_API"
)

var (
	ErrApiNameIsEmpty = errors.New("api name is empty")
)

var (
	ErrTmplVarAlreadyExist   = errors.TN(HttpJsonApiErrNamespace, 400, "template var already exist, key: {{.key}}, value: {{.value}}, original value: {{.originalValue}}")
	ErrApiAlreadyRelatedTmpl = errors.TN(HttpJsonApiErrNamespace, 401, "api already related template, api: {{.apiName}}, template: {{.tmplName}}")
	ErrTmplNotExit           = errors.TN(HttpJsonApiErrNamespace, 402, "template of {{.tmplName}} not exist")
	ErrRequestTimeout        = errors.TN(HttpJsonApiErrNamespace, 408, "request timeout")

	ErrApiGenericError            = errors.TN(HttpJsonApiErrNamespace, 500, "")
	ErrNotSupportMultiCallForward = errors.TN(HttpJsonApiErrNamespace, 501, "not support multi call forward")
	ErrRenderApiDataFailed        = errors.TN(HttpJsonApiErrNamespace, 502, "render api data failed")
)
Example #11
0
package access_limiter

import (
	"github.com/gogap/errors"
)

var ACCESS_LIMITER_NS = "ACCESS_LIMITER"

var (
	ERR_QPS_REACHED_UPPER_LIMIT   = errors.TN(ACCESS_LIMITER_NS, 1, "qps reached upper limit, counter: {{.counter}}, {{.dimensions}}")
	ERR_QUOTA_REACHED_UPPER_LIMIT = errors.TN(ACCESS_LIMITER_NS, 2, "quota reached upper limit, counter: {{.counter}}, {{.dimensions}}")
	ERR_INCREASE_COUNT_FAILED     = errors.TN(ACCESS_LIMITER_NS, 3, "increase counter failed, counter: {{.counter}}, err: {{.err}}")
	ERR_INCREASE_QPS_COUNT_FAILED = errors.TN(ACCESS_LIMITER_NS, 4, "increase qps count failed, counter: {{.counter}}, err: {{.err}}")
	ERR_RESET_QPS_COUNT_FAILED    = errors.TN(ACCESS_LIMITER_NS, 5, "reset next qps count failed, counter: {{.counter}}, err: {{.err}}")
	ERR_RESET_COUNT_FAILED        = errors.TN(ACCESS_LIMITER_NS, 6, "reset counter failed, counter: {{.counter}}, err: {{.err}}")
	ERR_GET_OPTIONS_FAILED        = errors.TN(ACCESS_LIMITER_NS, 7, "get options failed, counter: {{.counter}}")
	ERR_UPDATE_OPTIONS_FAILED     = errors.TN(ACCESS_LIMITER_NS, 8, "update options failed, counter: {{.counter}}, err: {{.err}}")
)
Example #12
0
package controllers

import (
	"github.com/gogap/errors"
)

var (
	ErrUserNotExist  = errors.TN(TodoErrorNamespace, 40000, "user not exist: {{.username}}")
	ErrWrongPassword = errors.TN(TodoErrorNamespace, 40001, "wrong password !")
)

type Auth struct {
	users map[string]string
}

func NewAuth() *Auth {
	users := make(map[string]string)
	users["zeal"] = "123456"
	users["gogap"] = "123456"

	return &Auth{
		users: users,
	}
}

func (p *Auth) CheckAuth(username, password string) (err error) {
	if pwd, exist := p.users[username]; !exist {
		err = ErrUserNotExist.New(errors.Params{"username": username})
		return
	} else if pwd != password {
		err = ErrWrongPassword.New()
Example #13
0
import (
	"time"

	"github.com/gogap/errors"
	"github.com/rs/xid"

	"github.com/gogap/spirit_tutorial/todo/models"
)

type TaskManager struct {
	tasks map[string]*models.Task
}

var (
	ErrTaskNotExist = errors.TN(TodoErrorNamespace, 50404, "task not exist, id: {{.id}}")
)

func NewTaskManager() *TaskManager {
	return &TaskManager{
		tasks: make(map[string]*models.Task),
	}
}

func (p *TaskManager) NewTask(task models.Task) (id string, err error) {

	task.Id = xid.New().String()
	task.CreateTime = time.Now()
	task.UpdateTime = time.Now()

	p.tasks[task.Id] = &task