add errors

Author: leopoldxx

errors/errors.go

@@ -0,0 +1,223 @@
+package errors
+
+import "fmt"
+
+// New returns an error that formats as the given text.
+func New(text string) error {
+	return &errorString{text}
+}
+
+// errorString is a trivial implementation of error.
+type errorString struct {
+	s string
+}
+
+func (e *errorString) Error() string {
+	return e.s
+}
+
+type errBadRequest struct {
+	message string
+}
+
+func (err *errBadRequest) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return err.message
+}
+
+// NewBadRequestError create a new not found error
+func NewBadRequestError(message string) error {
+	return &errBadRequest{message}
+}
+
+// IsBadRequestError judges error is errBadRequest
+func IsBadRequestError(err error) bool {
+	if _, ok := err.(*errBadRequest); ok {
+		return true
+	}
+	return false
+}
+
+type errNotFound struct {
+	resource string
+}
+
+func (err *errNotFound) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return fmt.Sprintf("resource '%s' is not found", err.resource)
+}
+
+// NewNotFoundError create a new not found error
+func NewNotFoundError(resource string) error {
+	return &errNotFound{resource}
+}
+
+// IsNotFoundError judges error is errNotFound
+func IsNotFoundError(err error) bool {
+	if _, ok := err.(*errNotFound); ok {
+		return true
+	}
+	return false
+}
+
+type errConflict struct {
+	resource string
+}
+
+func (err *errConflict) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return fmt.Sprintf("resource '%s' is conflict with the exists one", err.resource)
+}
+
+// NewConflictError create a new conflict error
+func NewConflictError(resource string) error {
+	return &errConflict{resource}
+}
+
+// IsConflictError judges error is errConflict
+func IsConflictError(err error) bool {
+	if _, ok := err.(*errConflict); ok {
+		return true
+	}
+	return false
+}
+
+// not ready will returen StatusNotAcceptable http status if user  post or put a request
+type errNotReady struct {
+	resource string
+}
+
+func (err *errNotReady) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return fmt.Sprintf("resource '%s' is not ready for process", err.resource)
+}
+
+// NewNotReadyError create a new not ready error
+func NewNotReadyError(resource string) error {
+	return &errNotReady{resource}
+}
+
+// IsNotReadyError judges error is errNotReady
+func IsNotReadyError(err error) bool {
+	if _, ok := err.(*errNotReady); ok {
+		return true
+	}
+	return false
+}
+
+type errTaskIsRunning struct {
+	message string
+}
+
+func (err *errTaskIsRunning) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return err.message
+}
+
+// NewTaskIsRunningError create a new task is running error
+func NewTaskIsRunningError(message string) error {
+	return &errTaskIsRunning{message}
+}
+
+// IsTaskIsRunningError judges error is errTaskIsRunning
+func IsTaskIsRunningError(err error) bool {
+	if _, ok := err.(*errTaskIsRunning); ok {
+		return true
+	}
+	return false
+}
+
+// NewClientError return a ClientError with the msg
+func NewClientError(msg string) *ClientError {
+	return &ClientError{message: msg}
+}
+
+// ClientError is an error caused by request client
+type ClientError struct {
+	message string
+}
+
+func (err *ClientError) Error() string {
+	return err.message
+}
+
+// IsClientError judeges error is IsClientError
+func IsClientError(err error) bool {
+	if _, ok := err.(*ClientError); ok {
+		return true
+	}
+	return false
+}
+
+// NewServerError return a ServerError with the msg
+func NewServerError(msg string) *ServerError {
+	return &ServerError{message: msg}
+}
+
+// ServerError is an error caused by request client
+type ServerError struct {
+	message string
+}
+
+func (err *ServerError) Error() string {
+	return err.message
+}
+
+// invalid region
+type errInvalidRegion struct {
+	region string
+}
+
+func (err *errInvalidRegion) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return fmt.Sprintf("invalid region '%s'", err.region)
+}
+
+// NewInvalidRegionError create a new not found error
+func NewInvalidRegionError(region string) error {
+	return &errInvalidRegion{region}
+}
+
+// IsInvalidRegionError judges error is errInvalidRegion
+func IsInvalidRegionError(err error) bool {
+	if _, ok := err.(*errInvalidRegion); ok {
+		return true
+	}
+	return false
+}
+
+type errForbidden struct {
+	message string
+}
+
+func (err *errForbidden) Error() string {
+	if err == nil {
+		return "nil"
+	}
+	return err.message
+}
+
+// NewForbiddenError create a new not found error
+func NewForbiddenError(message string) error {
+	return &errForbidden{message}
+}
+
+// IsForbiddenError judges error is errForbidden
+func IsForbiddenError(err error) bool {
+	if _, ok := err.(*errForbidden); ok {
+		return true
+	}
+	return false
+}

server/reply/reply.go

@@ -0,0 +1,98 @@
+package reply
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/leopoldxx/go-utils/errors"
+)
+
+type commResp struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+// CommReply can be used for replying some common data
+func CommReply(w http.ResponseWriter, r *http.Request, status int, message string) {
+	resp := commResp{
+		Code:    http.StatusText(status),
+		Message: message,
+	}
+	Reply(w, r, status, resp)
+}
+
+// Reply can be used for replying response
+// Rename this to "reply" in the future because should call ResponseReply instead
+func Reply(w http.ResponseWriter, r *http.Request, status int, v interface{}) {
+	data, _ := json.Marshal(v)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	w.Write(data)
+}
+
+// OK reply
+func OK(w http.ResponseWriter, r *http.Request, message string) {
+	CommReply(w, r, http.StatusOK, message)
+}
+
+// ResourceNotFound will return an error message indicating that the resource is not exist
+func ResourceNotFound(w http.ResponseWriter, r *http.Request, message string) {
+	CommReply(w, r, http.StatusNotFound, message)
+}
+
+// BadRequest will return an error message indicating that the request is invalid
+func BadRequest(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusBadRequest, err.Error())
+}
+
+// Forbidden will block user access the resource, not authorized
+func Forbidden(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusForbidden, err.Error())
+}
+
+// Unauthorized will block user access the api, not login
+func Unauthorized(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusUnauthorized, err.Error())
+}
+
+// InternalError will return an error message indicating that the something is error inside the controller
+func InternalError(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusInternalServerError, err.Error())
+}
+
+// ServiceUnavailable will return an error message indicating that the service is not available now
+func ServiceUnavailable(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusServiceUnavailable, err.Error())
+}
+
+// Conflict xxx
+func Conflict(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusConflict, err.Error())
+}
+
+// NotAcceptable xxx
+func NotAcceptable(w http.ResponseWriter, r *http.Request, err error) {
+	CommReply(w, r, http.StatusNotAcceptable, err.Error())
+}
+
+// SetRequestID will set the response header of the requestID
+func SetRequestID(w http.ResponseWriter, requestID string) {
+	w.Header().Set("x-request-id", requestID)
+}
+
+// ProcessError xxx
+func ProcessError(w http.ResponseWriter, r *http.Request, err error) {
+	if errors.IsNotFoundError(err) {
+		ResourceNotFound(w, r, err.Error())
+	} else if errors.IsConflictError(err) {
+		Conflict(w, r, err)
+	} else if errors.IsNotReadyError(err) || errors.IsTaskIsRunningError(err) {
+		NotAcceptable(w, r, err)
+	} else if errors.IsBadRequestError(err) || errors.IsClientError(err) || errors.IsInvalidRegionError(err) {
+		BadRequest(w, r, err)
+	} else if errors.IsForbiddenError(err) {
+		Forbidden(w, r, err)
+	} else {
+		InternalError(w, r, err)
+	}
+}