coopgo-platform
/
gorush
7
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Merge pull request #76 from appleboy/storage 

Fixed #75, #73 Rewrite boltdb, memory and redis engine.
This commit is contained in:
Bo-Yi Wu 2016-05-02 08:33:07 -05:00
parent 17c4ca4b2e 8bac86e2e8
commit 3af8d302fb
17 changed files with 368 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gorush/config.go → config/config/config.go
View File

@ -1,4 +1,4 @@
package gorush
package config
import (
"gopkg.in/yaml.v2"

2
gorush/config_test.go → config/config/config_test.go
View File

@ -1,4 +1,4 @@
package gorush
package config
import (
"github.com/stretchr/testify/assert"

5
gorush.go
View File

@ -3,6 +3,7 @@ package main
import (
"flag"
"github.com/appleboy/gorush/gorush"
"github.com/appleboy/gorush/gorush/config"
"log"
)
@ -39,11 +40,11 @@ func main() {
var err error
// set default parameters.
gorush.PushConf = gorush.BuildDefaultPushConf()
gorush.PushConf = config.BuildDefaultPushConf()
// load user define config.
if *confPath != "" {
gorush.PushConf, err = gorush.LoadConfYaml(*confPath)
gorush.PushConf, err = config.LoadConfYaml(*confPath)
if err != nil {
log.Printf("Load yaml config file error: '%v'", err)

7
gorush/global.go
View File

@ -3,13 +3,14 @@ package gorush
import (
"crypto/tls"
"github.com/Sirupsen/logrus"
"github.com/appleboy/gorush/gorush/config"
apns "github.com/sideshow/apns2"
"gopkg.in/redis.v3"
)
var (
// PushConf is gorush config
PushConf ConfYaml
PushConf config.ConfYaml
// QueueNotification is chan type
QueueNotification chan PushNotification
// CertificatePemIos is ios certificate file
@ -20,8 +21,8 @@ var (
LogAccess *logrus.Logger
// LogError is log server error log
LogError *logrus.Logger
// RushStatus is notification status
RushStatus StatusApp
// RedisClient is global variable for redis
RedisClient *redis.Client
// StatStorage implements the storage interface
StatStorage Storage
)

11
gorush/log_test.go
View File

@ -2,6 +2,7 @@ package gorush
import (
"github.com/Sirupsen/logrus"
"github.com/appleboy/gorush/gorush/config"
"github.com/stretchr/testify/assert"
"testing"
)
@ -34,7 +35,7 @@ func TestSetLogOut(t *testing.T) {
}
func TestInitDefaultLog(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
// no errors on default config
assert.Nil(t, InitLog())
@ -45,7 +46,7 @@ func TestInitDefaultLog(t *testing.T) {
}
func TestAccessLevel(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Log.AccessLevel = "invalid"
@ -53,7 +54,7 @@ func TestAccessLevel(t *testing.T) {
}
func TestErrorLevel(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Log.ErrorLevel = "invalid"
@ -61,7 +62,7 @@ func TestErrorLevel(t *testing.T) {
}
func TestAccessLogPath(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Log.AccessLog = "logs/access.log"
@ -69,7 +70,7 @@ func TestAccessLogPath(t *testing.T) {
}
func TestErrorLogPath(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Log.ErrorLog = "logs/error.log"

12
gorush/notification.go
View File

@ -199,7 +199,7 @@ func queueNotification(req RequestPush) int {
count += len(notification.Tokens)
}
addTotalCount(int64(count))
StatStorage.AddTotalCount(int64(count))
return count
}
@ -315,7 +315,7 @@ func PushToIOS(req PushNotification) bool {
// apns server error
LogPush(FailedPush, token, req, err)
isError = true
addIosError(1)
StatStorage.AddIosError(1)
continue
}
@ -323,13 +323,13 @@ func PushToIOS(req PushNotification) bool {
// error message:
// ref: https://github.com/sideshow/apns2/blob/master/response.go#L14-L65
LogPush(FailedPush, token, req, errors.New(res.Reason))
addIosError(1)
StatStorage.AddIosError(1)
continue
}
if res.Sent() {
LogPush(SucceededPush, token, req, nil)
addIosSuccess(1)
StatStorage.AddIosSuccess(1)
}
}
@ -410,8 +410,8 @@ func PushToAndroid(req PushNotification) bool {
}
LogAccess.Debug(fmt.Sprintf("Android Success count: %d, Failure count: %d", res.Success, res.Failure))
addAndroidSuccess(int64(res.Success))
addAndroidError(int64(res.Failure))
StatStorage.AddAndroidSuccess(int64(res.Success))
StatStorage.AddAndroidError(int64(res.Failure))
for k, result := range res.Results {
if result.Error != "" {

36
gorush/notification_test.go
View File

@ -2,6 +2,7 @@ package gorush
import (
"encoding/json"
"github.com/appleboy/gorush/gorush/config"
"github.com/buger/jsonparser"
"github.com/google/go-gcm"
"github.com/sideshow/apns2"
@ -13,7 +14,7 @@ import (
)
func TestDisabledAndroidIosConf(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
err := CheckPushConf()
@ -22,7 +23,7 @@ func TestDisabledAndroidIosConf(t *testing.T) {
}
func TestMissingIOSCertificate(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = true
PushConf.Ios.PemKeyPath = ""
@ -34,7 +35,7 @@ func TestMissingIOSCertificate(t *testing.T) {
}
func TestMissingAndroidAPIKey(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = ""
@ -46,7 +47,7 @@ func TestMissingAndroidAPIKey(t *testing.T) {
}
func TestCorrectConf(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = "xxxxx"
@ -217,11 +218,12 @@ func TestAndroidNotificationStructure(t *testing.T) {
}
func TestPushToIOS(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = true
PushConf.Ios.PemKeyPath = "../certificate/certificate-valid.pem"
InitAPNSClient()
InitAppStatus()
req := PushNotification{
Tokens: []string{"11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef7"},
@ -234,7 +236,7 @@ func TestPushToIOS(t *testing.T) {
}
func TestPushToAndroidWrongAPIKey(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY") + "a"
@ -250,7 +252,7 @@ func TestPushToAndroidWrongAPIKey(t *testing.T) {
}
func TestPushToAndroidWrongToken(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY")
@ -266,7 +268,7 @@ func TestPushToAndroidWrongToken(t *testing.T) {
}
func TestPushToAndroidRightTokenForJSONLog(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY")
@ -286,7 +288,7 @@ func TestPushToAndroidRightTokenForJSONLog(t *testing.T) {
}
func TestPushToAndroidRightTokenForStringLog(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY")
@ -304,7 +306,7 @@ func TestPushToAndroidRightTokenForStringLog(t *testing.T) {
}
func TestOverwriteAndroidAPIKey(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY")
@ -324,7 +326,7 @@ func TestOverwriteAndroidAPIKey(t *testing.T) {
}
func TestSenMultipleNotifications(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
InitWorkers(2, 2)
@ -359,7 +361,7 @@ func TestSenMultipleNotifications(t *testing.T) {
}
func TestDisabledAndroidNotifications(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = true
PushConf.Ios.PemKeyPath = "../certificate/certificate-valid.pem"
@ -392,7 +394,7 @@ func TestDisabledAndroidNotifications(t *testing.T) {
}
func TestDisabledIosNotifications(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = false
PushConf.Ios.PemKeyPath = "../certificate/certificate-valid.pem"
@ -425,7 +427,7 @@ func TestDisabledIosNotifications(t *testing.T) {
}
func TestMissingIosCertificate(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = true
PushConf.Ios.PemKeyPath = "test"
@ -435,7 +437,7 @@ func TestMissingIosCertificate(t *testing.T) {
}
func TestAPNSClientDevHost(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = true
PushConf.Ios.PemKeyPath = "../certificate/certificate-valid.pem"
@ -445,7 +447,7 @@ func TestAPNSClientDevHost(t *testing.T) {
}
func TestAPNSClientProdHost(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Ios.Enabled = true
PushConf.Ios.Production = true
@ -520,7 +522,7 @@ func TestGCMMessage(t *testing.T) {
}
func TestCheckAndroidMessage(t *testing.T) {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY")

3
gorush/server_test.go
View File

@ -2,6 +2,7 @@ package gorush
import (
"github.com/appleboy/gofight"
"github.com/appleboy/gorush/gorush/config"
"github.com/buger/jsonparser"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/assert"
@ -15,7 +16,7 @@ import (
var goVersion = runtime.Version()
func initTest() {
PushConf = BuildDefaultPushConf()
PushConf = config.BuildDefaultPushConf()
PushConf.Core.Mode = "test"
}

243
gorush/status.go
View File

@ -1,12 +1,11 @@
package gorush
import (
"github.com/asdine/storm"
"github.com/appleboy/gorush/gorush/storage/boltdb"
"github.com/appleboy/gorush/gorush/storage/memory"
"github.com/appleboy/gorush/gorush/storage/redis"
"github.com/gin-gonic/gin"
"gopkg.in/redis.v3"
"net/http"
"strconv"
"sync/atomic"
)
// StatusApp is app status structure
@ -30,234 +29,40 @@ type IosStatus struct {
PushError int64 `json:"push_error"`
}
func initApp() {
RushStatus.TotalCount = 0
RushStatus.Ios.PushSuccess = 0
RushStatus.Ios.PushError = 0
RushStatus.Android.PushSuccess = 0
RushStatus.Android.PushError = 0
}
// InitAppStatus for initialize app status
func InitAppStatus() error {
switch PushConf.Stat.Engine {
case "memory":
StatStorage = memory.New()
case "redis":
StatStorage = redis.New(PushConf)
err := StatStorage.Init()
func initRedis() error {
RedisClient = redis.NewClient(&redis.Options{
Addr: PushConf.Stat.Redis.Addr,
Password: PushConf.Stat.Redis.Password,
DB: PushConf.Stat.Redis.DB,
})
if err != nil {
LogError.Error("redis error: " + err.Error())
_, err := RedisClient.Ping().Result()
return err
}
if err != nil {
// redis server error
LogError.Error("Can't connect redis server: " + err.Error())
return err
case "boltdb":
StatStorage = boltdb.New(PushConf)
default:
StatStorage = memory.New()
}
RushStatus.TotalCount = getTotalCount()
RushStatus.Ios.PushSuccess = getIosSuccess()
RushStatus.Ios.PushError = getIosError()
RushStatus.Android.PushSuccess = getAndroidSuccess()
RushStatus.Android.PushError = getAndroidError()
return nil
}
func initBoltDB() {
RushStatus.TotalCount = getTotalCount()
RushStatus.Ios.PushSuccess = getIosSuccess()
RushStatus.Ios.PushError = getIosError()
RushStatus.Android.PushSuccess = getAndroidSuccess()
RushStatus.Android.PushError = getAndroidError()
}
// InitAppStatus for initialize app status
func InitAppStatus() {
switch PushConf.Stat.Engine {
case "memory":
initApp()
case "redis":
initRedis()
case "boltdb":
initBoltDB()
default:
initApp()
}
}
func getRedisInt64Result(key string, count *int64) {
val, _ := RedisClient.Get(key).Result()
*count, _ = strconv.ParseInt(val, 10, 64)
}
func boltdbSet(key string, count int64) {
db, _ := storm.Open(PushConf.Stat.BoltDB.Path)
db.Set(PushConf.Stat.BoltDB.Bucket, key, count)
defer db.Close()
}
func boltdbGet(key string, count *int64) {
db, _ := storm.Open(PushConf.Stat.BoltDB.Path)
db.Get(PushConf.Stat.BoltDB.Bucket, key, count)
defer db.Close()
}
func addTotalCount(count int64) {
switch PushConf.Stat.Engine {
case "memory":
atomic.AddInt64(&RushStatus.TotalCount, count)
case "redis":
RedisClient.Set(TotalCountKey, strconv.Itoa(int(count)), 0)
case "boltdb":
boltdbSet(TotalCountKey, count)
default:
atomic.AddInt64(&RushStatus.TotalCount, count)
}
}
func addIosSuccess(count int64) {
switch PushConf.Stat.Engine {
case "memory":
atomic.AddInt64(&RushStatus.Ios.PushSuccess, count)
case "redis":
RedisClient.Set(IosSuccessKey, strconv.Itoa(int(count)), 0)
case "boltdb":
boltdbSet(IosSuccessKey, count)
default:
atomic.AddInt64(&RushStatus.Ios.PushSuccess, count)
}
}
func addIosError(count int64) {
switch PushConf.Stat.Engine {
case "memory":
atomic.AddInt64(&RushStatus.Ios.PushError, count)
case "redis":
RedisClient.Set(IosErrorKey, strconv.Itoa(int(count)), 0)
case "boltdb":
boltdbSet(IosErrorKey, count)
default:
atomic.AddInt64(&RushStatus.Ios.PushError, count)
}
}
func addAndroidSuccess(count int64) {
switch PushConf.Stat.Engine {
case "memory":
atomic.AddInt64(&RushStatus.Android.PushSuccess, count)
case "redis":
RedisClient.Set(AndroidSuccessKey, strconv.Itoa(int(count)), 0)
case "boltdb":
boltdbSet(AndroidSuccessKey, count)
default:
atomic.AddInt64(&RushStatus.Android.PushSuccess, count)
}
}
func addAndroidError(count int64) {
switch PushConf.Stat.Engine {
case "memory":
atomic.AddInt64(&RushStatus.Android.PushError, count)
case "redis":
RedisClient.Set(AndroidErrorKey, strconv.Itoa(int(count)), 0)
case "boltdb":
boltdbSet(AndroidErrorKey, count)
default:
atomic.AddInt64(&RushStatus.Android.PushError, count)
}
}
func getTotalCount() int64 {
var count int64
switch PushConf.Stat.Engine {
case "memory":
count = atomic.LoadInt64(&RushStatus.TotalCount)
case "redis":
getRedisInt64Result(TotalCountKey, &count)
case "boltdb":
boltdbGet(TotalCountKey, &count)
default:
count = atomic.LoadInt64(&RushStatus.TotalCount)
}
return count
}
func getIosSuccess() int64 {
var count int64
switch PushConf.Stat.Engine {
case "memory":
count = atomic.LoadInt64(&RushStatus.Ios.PushSuccess)
case "redis":
getRedisInt64Result(IosSuccessKey, &count)
case "boltdb":
boltdbGet(IosSuccessKey, &count)
default:
count = atomic.LoadInt64(&RushStatus.Ios.PushSuccess)
}
return count
}
func getIosError() int64 {
var count int64
switch PushConf.Stat.Engine {
case "memory":
count = atomic.LoadInt64(&RushStatus.Ios.PushError)
case "redis":
getRedisInt64Result(IosErrorKey, &count)
case "boltdb":
boltdbGet(IosErrorKey, &count)
default:
count = atomic.LoadInt64(&RushStatus.Ios.PushError)
}
return count
}
func getAndroidSuccess() int64 {
var count int64
switch PushConf.Stat.Engine {
case "memory":
count = atomic.LoadInt64(&RushStatus.Android.PushSuccess)
case "redis":
getRedisInt64Result(AndroidSuccessKey, &count)
case "boltdb":
boltdbGet(AndroidSuccessKey, &count)
default:
count = atomic.LoadInt64(&RushStatus.Android.PushSuccess)
}
return count
}
func getAndroidError() int64 {
var count int64
switch PushConf.Stat.Engine {
case "memory":
count = atomic.LoadInt64(&RushStatus.Android.PushError)
case "redis":
getRedisInt64Result(AndroidErrorKey, &count)
case "boltdb":
boltdbGet(AndroidErrorKey, &count)
default:
count = atomic.LoadInt64(&RushStatus.Android.PushError)
}
return count
}
func appStatusHandler(c *gin.Context) {
result := StatusApp{}
result.QueueMax = cap(QueueNotification)
result.QueueUsage = len(QueueNotification)
result.TotalCount = getTotalCount()
result.Ios.PushSuccess = getIosSuccess()
result.Ios.PushError = getIosError()
result.Android.PushSuccess = getAndroidSuccess()
result.Android.PushError = getAndroidError()
result.TotalCount = StatStorage.GetTotalCount()
result.Ios.PushSuccess = StatStorage.GetIosSuccess()
result.Ios.PushError = StatStorage.GetIosError()
result.Android.PushSuccess = StatStorage.GetAndroidSuccess()
result.Android.PushError = StatStorage.GetAndroidError()
c.JSON(http.StatusOK, result)
}

196
gorush/status_test.go
View File

@ -2,67 +2,92 @@ package gorush
import (
"github.com/stretchr/testify/assert"
"sync/atomic"
// "sync/atomic"
"testing"
)
func TestAddTotalCount(t *testing.T) {
// func TestAddTotalCount(t *testing.T) {
// InitAppStatus()
// addTotalCount(1000)
// val := atomic.LoadInt64(&RushStatus.TotalCount)
// assert.Equal(t, int64(1000), val)
// }
// func TestAddIosSuccess(t *testing.T) {
// InitAppStatus()
// addIosSuccess(1000)
// val := atomic.LoadInt64(&RushStatus.Ios.PushSuccess)
// assert.Equal(t, int64(1000), val)
// }
// func TestAddIosError(t *testing.T) {
// InitAppStatus()
// addIosError(1000)
// val := atomic.LoadInt64(&RushStatus.Ios.PushError)
// assert.Equal(t, int64(1000), val)
// }
// func TestAndroidSuccess(t *testing.T) {
// InitAppStatus()
// addAndroidSuccess(1000)
// val := atomic.LoadInt64(&RushStatus.Android.PushSuccess)
// assert.Equal(t, int64(1000), val)
// }
// func TestAddAndroidError(t *testing.T) {
// InitAppStatus()
// addAndroidError(1000)
// val := atomic.LoadInt64(&RushStatus.Android.PushError)
// assert.Equal(t, int64(1000), val)
// }
func TestStatForMemoryEngine(t *testing.T) {
var val int64
PushConf.Stat.Engine = "memory"
InitAppStatus()
addTotalCount(1000)
val := atomic.LoadInt64(&RushStatus.TotalCount)
StatStorage.AddTotalCount(100)
StatStorage.AddIosSuccess(200)
StatStorage.AddIosError(300)
StatStorage.AddAndroidSuccess(400)
StatStorage.AddAndroidError(500)
assert.Equal(t, int64(1000), val)
}
func TestAddIosSuccess(t *testing.T) {
InitAppStatus()
addIosSuccess(1000)
val := atomic.LoadInt64(&RushStatus.Ios.PushSuccess)
assert.Equal(t, int64(1000), val)
}
func TestAddIosError(t *testing.T) {
InitAppStatus()
addIosError(1000)
val := atomic.LoadInt64(&RushStatus.Ios.PushError)
assert.Equal(t, int64(1000), val)
}
func TestAndroidSuccess(t *testing.T) {
InitAppStatus()
addAndroidSuccess(1000)
val := atomic.LoadInt64(&RushStatus.Android.PushSuccess)
assert.Equal(t, int64(1000), val)
}
func TestAddAndroidError(t *testing.T) {
InitAppStatus()
addAndroidError(1000)
val := atomic.LoadInt64(&RushStatus.Android.PushError)
assert.Equal(t, int64(1000), val)
val = StatStorage.GetTotalCount()
assert.Equal(t, int64(100), val)
val = StatStorage.GetIosSuccess()
assert.Equal(t, int64(200), val)
val = StatStorage.GetIosError()
assert.Equal(t, int64(300), val)
val = StatStorage.GetAndroidSuccess()
assert.Equal(t, int64(400), val)
val = StatStorage.GetAndroidError()
assert.Equal(t, int64(500), val)
}
func TestRedisServerSuccess(t *testing.T) {
PushConf.Stat.Engine = "redis"
PushConf.Stat.Redis.Addr = "localhost:6379"
err := initRedis()
err := InitAppStatus()
assert.NoError(t, err)
}
func TestRedisServerError(t *testing.T) {
PushConf.Stat.Engine = "redis"
PushConf.Stat.Redis.Addr = "localhost:6370"
err := initRedis()
err := InitAppStatus()
assert.Error(t, err)
}
@ -73,22 +98,25 @@ func TestStatForRedisEngine(t *testing.T) {
PushConf.Stat.Redis.Addr = "localhost:6379"
InitAppStatus()
addTotalCount(10)
addIosSuccess(20)
addIosError(30)
addAndroidSuccess(40)
addAndroidError(50)
StatStorage.Init()
StatStorage.Reset()
val = getTotalCount()
assert.Equal(t, int64(10), val)
val = getIosSuccess()
assert.Equal(t, int64(20), val)
val = getIosError()
assert.Equal(t, int64(30), val)
val = getAndroidSuccess()
assert.Equal(t, int64(40), val)
val = getAndroidError()
assert.Equal(t, int64(50), val)
StatStorage.AddTotalCount(100)
StatStorage.AddIosSuccess(200)
StatStorage.AddIosError(300)
StatStorage.AddAndroidSuccess(400)
StatStorage.AddAndroidError(500)
val = StatStorage.GetTotalCount()
assert.Equal(t, int64(100), val)
val = StatStorage.GetIosSuccess()
assert.Equal(t, int64(200), val)
val = StatStorage.GetIosError()
assert.Equal(t, int64(300), val)
val = StatStorage.GetAndroidSuccess()
assert.Equal(t, int64(400), val)
val = StatStorage.GetAndroidError()
assert.Equal(t, int64(500), val)
}
func TestDefaultEngine(t *testing.T) {
@ -96,22 +124,22 @@ func TestDefaultEngine(t *testing.T) {
PushConf.Stat.Engine = "test"
InitAppStatus()
addTotalCount(1)
addIosSuccess(2)
addIosError(3)
addAndroidSuccess(4)
addAndroidError(5)
StatStorage.AddTotalCount(100)
StatStorage.AddIosSuccess(200)
StatStorage.AddIosError(300)
StatStorage.AddAndroidSuccess(400)
StatStorage.AddAndroidError(500)
val = getTotalCount()
assert.Equal(t, int64(1), val)
val = getIosSuccess()
assert.Equal(t, int64(2), val)
val = getIosError()
assert.Equal(t, int64(3), val)
val = getAndroidSuccess()
assert.Equal(t, int64(4), val)
val = getAndroidError()
assert.Equal(t, int64(5), val)
val = StatStorage.GetTotalCount()
assert.Equal(t, int64(100), val)
val = StatStorage.GetIosSuccess()
assert.Equal(t, int64(200), val)
val = StatStorage.GetIosError()
assert.Equal(t, int64(300), val)
val = StatStorage.GetAndroidSuccess()
assert.Equal(t, int64(400), val)
val = StatStorage.GetAndroidError()
assert.Equal(t, int64(500), val)
}
func TestStatForBoltDBEngine(t *testing.T) {
@ -119,20 +147,22 @@ func TestStatForBoltDBEngine(t *testing.T) {
PushConf.Stat.Engine = "boltdb"
InitAppStatus()
addTotalCount(100)
addIosSuccess(200)
addIosError(300)
addAndroidSuccess(400)
addAndroidError(500)
StatStorage.Reset()
val = getTotalCount()
StatStorage.AddTotalCount(100)
StatStorage.AddIosSuccess(200)
StatStorage.AddIosError(300)
StatStorage.AddAndroidSuccess(400)
StatStorage.AddAndroidError(500)
val = StatStorage.GetTotalCount()
assert.Equal(t, int64(100), val)
val = getIosSuccess()
val = StatStorage.GetIosSuccess()
assert.Equal(t, int64(200), val)
val = getIosError()
val = StatStorage.GetIosError()
assert.Equal(t, int64(300), val)
val = getAndroidSuccess()
val = StatStorage.GetAndroidSuccess()
assert.Equal(t, int64(400), val)
val = getAndroidError()
val = StatStorage.GetAndroidError()
assert.Equal(t, int64(500), val)
}

22
gorush/storage.go
View File

@ -2,14 +2,16 @@ package gorush
// Storage interface
type Storage interface {
addTotalCount(int64)
addIosSuccess(int64)
addIosError(int64)
addAndroidSuccess(int64)
addAndroidError(int64)
getTotalCount() int64
getIosSuccess() int64
getIosError() int64
getAndroidSuccess() int64
getAndroidError() int64
Init() error
Reset()
AddTotalCount(int64)
AddIosSuccess(int64)
AddIosError(int64)
AddAndroidSuccess(int64)
AddAndroidError(int64)
GetTotalCount() int64
GetIosSuccess() int64
GetIosError() int64
GetAndroidSuccess() int64
GetAndroidError() int64
}

87
storage/boltdb/boltdb.go
View File

@ -1,37 +1,40 @@
package boltdb
import (
"github.com/appleboy/gorush/gorush"
"github.com/appleboy/gorush/gorush/config"
"github.com/asdine/storm"
)
// Stat variable for redis
const (
TotalCountKey = "gorush-total-count"
IosSuccessKey = "gorush-ios-success-count"
IosErrorKey = "gorush-ios-error-count"
AndroidSuccessKey = "gorush-android-success-count"
AndroidErrorKey = "gorush-android-error-count"
)
// Storage implements the storage interface for gorush (https://github.com/appleboy/gorush)
func New(config gorush.ConfYaml, stat gorush.StatusApp) *Storage {
func New(config config.ConfYaml) *Storage {
return &Storage{
stat: stat,
config: config,
}
}
type Storage struct {
config gorush.ConfYaml
stat gorush.StatusApp
config config.ConfYaml
}
func (s *Storage) initBoltDB() {
s.stat.TotalCount = s.getTotalCount()
s.stat.Ios.PushSuccess = s.getIosSuccess()
s.stat.Ios.PushError = s.getIosError()
s.stat.Android.PushSuccess = s.getAndroidSuccess()
s.stat.Android.PushError = s.getAndroidError()
func (s *Storage) Init() error {
return nil
}
func (s *Storage) resetBoltDB() {
s.setBoltDB(gorush.TotalCountKey, 0)
s.setBoltDB(gorush.IosSuccessKey, 0)
s.setBoltDB(gorush.IosErrorKey, 0)
s.setBoltDB(gorush.AndroidSuccessKey, 0)
s.setBoltDB(gorush.AndroidErrorKey, 0)
func (s *Storage) Reset() {
s.setBoltDB(TotalCountKey, 0)
s.setBoltDB(IosSuccessKey, 0)
s.setBoltDB(IosErrorKey, 0)
s.setBoltDB(AndroidSuccessKey, 0)
s.setBoltDB(AndroidErrorKey, 0)
}
func (s *Storage) setBoltDB(key string, count int64) {
@ -46,62 +49,62 @@ func (s *Storage) getBoltDB(key string, count *int64) {
defer db.Close()
}
func (s *Storage) addTotalCount(count int64) {
total := s.getTotalCount() + count
s.setBoltDB(gorush.TotalCountKey, total)
func (s *Storage) AddTotalCount(count int64) {
total := s.GetTotalCount() + count
s.setBoltDB(TotalCountKey, total)
}
func (s *Storage) addIosSuccess(count int64) {
total := s.getIosSuccess() + count
s.setBoltDB(gorush.IosSuccessKey, total)
func (s *Storage) AddIosSuccess(count int64) {
total := s.GetIosSuccess() + count
s.setBoltDB(IosSuccessKey, total)
}
func (s *Storage) addIosError(count int64) {
total := s.getIosError() + count
s.setBoltDB(gorush.IosErrorKey, total)
func (s *Storage) AddIosError(count int64) {
total := s.GetIosError() + count
s.setBoltDB(IosErrorKey, total)
}
func (s *Storage) addAndroidSuccess(count int64) {
total := s.getAndroidSuccess() + count
s.setBoltDB(gorush.AndroidSuccessKey, total)
func (s *Storage) AddAndroidSuccess(count int64) {
total := s.GetAndroidSuccess() + count
s.setBoltDB(AndroidSuccessKey, total)
}
func (s *Storage) addAndroidError(count int64) {
total := s.getAndroidError() + count
s.setBoltDB(gorush.AndroidErrorKey, total)
func (s *Storage) AddAndroidError(count int64) {
total := s.GetAndroidError() + count
s.setBoltDB(AndroidErrorKey, total)
}
func (s *Storage) getTotalCount() int64 {
func (s *Storage) GetTotalCount() int64 {
var count int64
s.getBoltDB(gorush.TotalCountKey, &count)
s.getBoltDB(TotalCountKey, &count)
return count
}
func (s *Storage) getIosSuccess() int64 {
func (s *Storage) GetIosSuccess() int64 {
var count int64
s.getBoltDB(gorush.IosSuccessKey, &count)
s.getBoltDB(IosSuccessKey, &count)
return count
}
func (s *Storage) getIosError() int64 {
func (s *Storage) GetIosError() int64 {
var count int64
s.getBoltDB(gorush.IosErrorKey, &count)
s.getBoltDB(IosErrorKey, &count)
return count
}
func (s *Storage) getAndroidSuccess() int64 {
func (s *Storage) GetAndroidSuccess() int64 {
var count int64
s.getBoltDB(gorush.AndroidSuccessKey, &count)
s.getBoltDB(AndroidSuccessKey, &count)
return count
}
func (s *Storage) getAndroidError() int64 {
func (s *Storage) GetAndroidError() int64 {
var count int64
s.getBoltDB(gorush.AndroidErrorKey, &count)
s.getBoltDB(AndroidErrorKey, &count)
return count
}

34
storage/boltdb/boltdb_test.go
View File

@ -1,7 +1,7 @@
package boltdb
import (
"github.com/appleboy/gorush/gorush"
c "github.com/appleboy/gorush/gorush/config"
"github.com/stretchr/testify/assert"
"testing"
)
@ -9,32 +9,32 @@ import (
func TestRedisEngine(t *testing.T) {
var val int64
config := gorush.BuildDefaultPushConf()
config := c.BuildDefaultPushConf()
boltDB := New(config, gorush.StatusApp{})
boltDB.initBoltDB()
boltDB.resetBoltDB()
boltDB := New(config)
boltDB.Init()
boltDB.Reset()
boltDB.addTotalCount(10)
val = boltDB.getTotalCount()
boltDB.AddTotalCount(10)
val = boltDB.GetTotalCount()
assert.Equal(t, int64(10), val)
boltDB.addTotalCount(10)
val = boltDB.getTotalCount()
boltDB.AddTotalCount(10)
val = boltDB.GetTotalCount()
assert.Equal(t, int64(20), val)
boltDB.addIosSuccess(20)
val = boltDB.getIosSuccess()
boltDB.AddIosSuccess(20)
val = boltDB.GetIosSuccess()
assert.Equal(t, int64(20), val)
boltDB.addIosError(30)
val = boltDB.getIosError()
boltDB.AddIosError(30)
val = boltDB.GetIosError()
assert.Equal(t, int64(30), val)
boltDB.addAndroidSuccess(40)
val = boltDB.getAndroidSuccess()
boltDB.AddAndroidSuccess(40)
val = boltDB.GetAndroidSuccess()
assert.Equal(t, int64(40), val)
boltDB.addAndroidError(50)
val = boltDB.getAndroidError()
boltDB.AddAndroidError(50)
val = boltDB.GetAndroidError()
assert.Equal(t, int64(50), val)
}

53
storage/memory/memory.go
View File

@ -1,66 +1,91 @@
package memory
import (
"github.com/appleboy/gorush/gorush"
"sync/atomic"
)
// StatusApp is app status structure
type statApp struct {
TotalCount int64 `json:"total_count"`
Ios IosStatus `json:"ios"`
Android AndroidStatus `json:"android"`
}
// AndroidStatus is android structure
type AndroidStatus struct {
PushSuccess int64 `json:"push_success"`
PushError int64 `json:"push_error"`
}
// IosStatus is iOS structure
type IosStatus struct {
PushSuccess int64 `json:"push_success"`
PushError int64 `json:"push_error"`
}
// Storage implements the storage interface for gorush (https://github.com/appleboy/gorush)
func New(stat gorush.StatusApp) *Storage {
func New() *Storage {
return &Storage{
stat: stat,
stat: &statApp{},
}
}
type Storage struct {
stat gorush.StatusApp
stat *statApp
}
func (s *Storage) addTotalCount(count int64) {
func (s *Storage) Init() error {
return nil
}
func (s *Storage) Reset() {
}
func (s *Storage) AddTotalCount(count int64) {
atomic.AddInt64(&s.stat.TotalCount, count)
}
func (s *Storage) addIosSuccess(count int64) {
func (s *Storage) AddIosSuccess(count int64) {
atomic.AddInt64(&s.stat.Ios.PushSuccess, count)
}
func (s *Storage) addIosError(count int64) {
func (s *Storage) AddIosError(count int64) {
atomic.AddInt64(&s.stat.Ios.PushError, count)
}
func (s *Storage) addAndroidSuccess(count int64) {
func (s *Storage) AddAndroidSuccess(count int64) {
atomic.AddInt64(&s.stat.Android.PushSuccess, count)
}
func (s *Storage) addAndroidError(count int64) {
func (s *Storage) AddAndroidError(count int64) {
atomic.AddInt64(&s.stat.Android.PushError, count)
}
func (s *Storage) getTotalCount() int64 {
func (s *Storage) GetTotalCount() int64 {
count := atomic.LoadInt64(&s.stat.TotalCount)
return count
}
func (s *Storage) getIosSuccess() int64 {
func (s *Storage) GetIosSuccess() int64 {
count := atomic.LoadInt64(&s.stat.Ios.PushSuccess)
return count
}
func (s *Storage) getIosError() int64 {
func (s *Storage) GetIosError() int64 {
count := atomic.LoadInt64(&s.stat.Ios.PushError)
return count
}
func (s *Storage) getAndroidSuccess() int64 {
func (s *Storage) GetAndroidSuccess() int64 {
count := atomic.LoadInt64(&s.stat.Android.PushSuccess)
return count
}
func (s *Storage) getAndroidError() int64 {
func (s *Storage) GetAndroidError() int64 {
count := atomic.LoadInt64(&s.stat.Android.PushError)
return count

23
storage/memory/memory_test.go
View File

@ -1,7 +1,6 @@
package memory
import (
"github.com/appleboy/gorush/gorush"
"github.com/stretchr/testify/assert"
"testing"
)
@ -9,25 +8,25 @@ import (
func TestMemoryEngine(t *testing.T) {
var val int64
memory := New(gorush.StatusApp{})
memory := New()
memory.addTotalCount(1)
val = memory.getTotalCount()
memory.AddTotalCount(1)
val = memory.GetTotalCount()
assert.Equal(t, int64(1), val)
memory.addIosSuccess(2)
val = memory.getIosSuccess()
memory.AddIosSuccess(2)
val = memory.GetIosSuccess()
assert.Equal(t, int64(2), val)
memory.addIosError(3)
val = memory.getIosError()
memory.AddIosError(3)
val = memory.GetIosError()
assert.Equal(t, int64(3), val)
memory.addAndroidSuccess(4)
val = memory.getAndroidSuccess()
memory.AddAndroidSuccess(4)
val = memory.GetAndroidSuccess()
assert.Equal(t, int64(4), val)
memory.addAndroidError(5)
val = memory.getAndroidError()
memory.AddAndroidError(5)
val = memory.GetAndroidError()
assert.Equal(t, int64(5), val)
}

89
storage/redis/redis.go
View File

@ -1,33 +1,40 @@
package redis
import (
"github.com/appleboy/gorush/gorush"
"github.com/appleboy/gorush/gorush/config"
"gopkg.in/redis.v3"
"log"
"strconv"
)
// Stat variable for redis
const (
TotalCountKey = "gorush-total-count"
IosSuccessKey = "gorush-ios-success-count"
IosErrorKey = "gorush-ios-error-count"
AndroidSuccessKey = "gorush-android-success-count"
AndroidErrorKey = "gorush-android-error-count"
)
var RedisClient *redis.Client
// Storage implements the storage interface for gorush (https://github.com/appleboy/gorush)
func New(config gorush.ConfYaml, stat gorush.StatusApp) *Storage {
func New(config config.ConfYaml) *Storage {
return &Storage{
stat: stat,
config: config,
}
}
func getRedisInt64Result(key string, count *int64) {
func getInt64(key string, count *int64) {
val, _ := RedisClient.Get(key).Result()
*count, _ = strconv.ParseInt(val, 10, 64)
}
type Storage struct {
config gorush.ConfYaml
stat gorush.StatusApp
config config.ConfYaml
}
func (s *Storage) initRedis() error {
func (s *Storage) Init() error {
RedisClient = redis.NewClient(&redis.Options{
Addr: s.config.Stat.Redis.Addr,
Password: s.config.Stat.Redis.Password,
@ -43,79 +50,73 @@ func (s *Storage) initRedis() error {
return err
}
s.stat.TotalCount = s.getTotalCount()
s.stat.Ios.PushSuccess = s.getIosSuccess()
s.stat.Ios.PushError = s.getIosError()
s.stat.Android.PushSuccess = s.getAndroidSuccess()
s.stat.Android.PushError = s.getAndroidError()
return nil
}
func (s *Storage) resetRedis() {
RedisClient.Set(gorush.TotalCountKey, strconv.Itoa(0), 0)
RedisClient.Set(gorush.IosSuccessKey, strconv.Itoa(0), 0)
RedisClient.Set(gorush.IosErrorKey, strconv.Itoa(0), 0)
RedisClient.Set(gorush.AndroidSuccessKey, strconv.Itoa(0), 0)
RedisClient.Set(gorush.AndroidErrorKey, strconv.Itoa(0), 0)
func (s *Storage) Reset() {
RedisClient.Set(TotalCountKey, strconv.Itoa(0), 0)
RedisClient.Set(IosSuccessKey, strconv.Itoa(0), 0)
RedisClient.Set(IosErrorKey, strconv.Itoa(0), 0)
RedisClient.Set(AndroidSuccessKey, strconv.Itoa(0), 0)
RedisClient.Set(AndroidErrorKey, strconv.Itoa(0), 0)
}
func (s *Storage) addTotalCount(count int64) {
total := s.getTotalCount() + count
RedisClient.Set(gorush.TotalCountKey, strconv.Itoa(int(total)), 0)
func (s *Storage) AddTotalCount(count int64) {
total := s.GetTotalCount() + count
RedisClient.Set(TotalCountKey, strconv.Itoa(int(total)), 0)
}
func (s *Storage) addIosSuccess(count int64) {
total := s.getIosSuccess() + count
RedisClient.Set(gorush.IosSuccessKey, strconv.Itoa(int(total)), 0)
func (s *Storage) AddIosSuccess(count int64) {
total := s.GetIosSuccess() + count
RedisClient.Set(IosSuccessKey, strconv.Itoa(int(total)), 0)
}
func (s *Storage) addIosError(count int64) {
total := s.getIosError() + count
RedisClient.Set(gorush.IosErrorKey, strconv.Itoa(int(total)), 0)
func (s *Storage) AddIosError(count int64) {
total := s.GetIosError() + count
RedisClient.Set(IosErrorKey, strconv.Itoa(int(total)), 0)
}
func (s *Storage) addAndroidSuccess(count int64) {
total := s.getAndroidSuccess() + count
RedisClient.Set(gorush.AndroidSuccessKey, strconv.Itoa(int(total)), 0)
func (s *Storage) AddAndroidSuccess(count int64) {
total := s.GetAndroidSuccess() + count
RedisClient.Set(AndroidSuccessKey, strconv.Itoa(int(total)), 0)
}
func (s *Storage) addAndroidError(count int64) {
total := s.getAndroidError() + count
RedisClient.Set(gorush.AndroidErrorKey, strconv.Itoa(int(total)), 0)
func (s *Storage) AddAndroidError(count int64) {
total := s.GetAndroidError() + count
RedisClient.Set(AndroidErrorKey, strconv.Itoa(int(total)), 0)
}
func (s *Storage) getTotalCount() int64 {
func (s *Storage) GetTotalCount() int64 {
var count int64
getRedisInt64Result(gorush.TotalCountKey, &count)
getInt64(TotalCountKey, &count)
return count
}
func (s *Storage) getIosSuccess() int64 {
func (s *Storage) GetIosSuccess() int64 {
var count int64
getRedisInt64Result(gorush.IosSuccessKey, &count)
getInt64(IosSuccessKey, &count)
return count
}
func (s *Storage) getIosError() int64 {
func (s *Storage) GetIosError() int64 {
var count int64
getRedisInt64Result(gorush.IosErrorKey, &count)
getInt64(IosErrorKey, &count)
return count
}
func (s *Storage) getAndroidSuccess() int64 {
func (s *Storage) GetAndroidSuccess() int64 {
var count int64
getRedisInt64Result(gorush.AndroidSuccessKey, &count)
getInt64(AndroidSuccessKey, &count)
return count
}
func (s *Storage) getAndroidError() int64 {
func (s *Storage) GetAndroidError() int64 {
var count int64
getRedisInt64Result(gorush.AndroidErrorKey, &count)
getInt64(AndroidErrorKey, &count)
return count
}

40
storage/redis/redis_test.go
View File

@ -1,17 +1,17 @@
package redis
import (
"github.com/appleboy/gorush/gorush"
c "github.com/appleboy/gorush/gorush/config"
"github.com/stretchr/testify/assert"
"testing"
)
func TestRedisServerError(t *testing.T) {
config := gorush.BuildDefaultPushConf()
config := c.BuildDefaultPushConf()
config.Stat.Redis.Addr = "localhost:6370"
redis := New(config, gorush.StatusApp{})
err := redis.initRedis()
redis := New(config)
err := redis.Init()
assert.Error(t, err)
}
@ -19,32 +19,32 @@ func TestRedisServerError(t *testing.T) {
func TestRedisEngine(t *testing.T) {
var val int64
config := gorush.BuildDefaultPushConf()
config := c.BuildDefaultPushConf()
redis := New(config, gorush.StatusApp{})
redis.initRedis()
redis.resetRedis()
redis := New(config)
redis.Init()
redis.Reset()
redis.addTotalCount(10)
val = redis.getTotalCount()
redis.AddTotalCount(10)
val = redis.GetTotalCount()
assert.Equal(t, int64(10), val)
redis.addTotalCount(10)
val = redis.getTotalCount()
redis.AddTotalCount(10)
val = redis.GetTotalCount()
assert.Equal(t, int64(20), val)
redis.addIosSuccess(20)
val = redis.getIosSuccess()
redis.AddIosSuccess(20)
val = redis.GetIosSuccess()
assert.Equal(t, int64(20), val)
redis.addIosError(30)
val = redis.getIosError()
redis.AddIosError(30)
val = redis.GetIosError()
assert.Equal(t, int64(30), val)
redis.addAndroidSuccess(40)
val = redis.getAndroidSuccess()
redis.AddAndroidSuccess(40)
val = redis.GetAndroidSuccess()
assert.Equal(t, int64(40), val)
redis.addAndroidError(50)
val = redis.getAndroidError()
redis.AddAndroidError(50)
val = redis.GetAndroidError()
assert.Equal(t, int64(50), val)
}