generated from mrz1836/go-template
-
-
Notifications
You must be signed in to change notification settings - Fork 2
/
client.go
149 lines (125 loc) · 4.14 KB
/
client.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package cachestore
import (
"context"
"github.com/coocood/freecache"
"github.com/mrz1836/go-cache"
zLogger "github.com/mrz1836/go-logger"
"github.com/newrelic/go-agent/v3/newrelic"
)
type (
// Client is the client (configuration)
Client struct {
options *clientOptions
}
// clientOptions holds all the configuration for the client
clientOptions struct {
debug bool // For extra logs and additional debug information
engine Engine // Cachestore engine (redis or mcache)
freeCache *freecache.Cache // Driver (client) for local in-memory storage
logger zLogger.GormLoggerInterface // Internal logging
newRelicEnabled bool // If NewRelic is enabled (parent application)
redis *cache.Client // Current redis client (read & write)
redisConfig *RedisConfig // Configuration for a new redis client
}
)
// NewClient creates a new client for all CacheStore functionality
//
// If no options are given, it will use the defaultClientOptions()
// ctx may contain a NewRelic txn (or one will be created)
func NewClient(ctx context.Context, opts ...ClientOps) (ClientInterface, error) {
// Create a new client with defaults
client := &Client{options: defaultClientOptions()}
// Overwrite defaults with any set by user
for _, opt := range opts {
opt(client.options)
}
// Set logger if not set
if client.options.logger == nil {
client.options.logger = zLogger.NewGormLogger(client.IsDebug(), 4)
}
// EMPTY! Engine was NOT set, show warning and use in-memory cache
if client.Engine().IsEmpty() {
client.options.logger.Warn(ctx, "cachestore engine was not set, using in-memory FreeCache")
client.options.engine = FreeCache
}
// Use NewRelic if it's enabled (use existing txn if found on ctx)
ctx = client.options.getTxnCtx(ctx)
// Load cache based on engine
if client.Engine() == Redis {
// Only if we don't already have an existing client
if client.options.redis == nil {
var err error
if client.options.redis, err = loadRedisClient(
ctx, client.options.redisConfig, client.options.newRelicEnabled,
); err != nil {
return nil, err
}
}
} else if client.Engine() == FreeCache {
// Only if we don't already have an existing client
if client.options.freeCache == nil {
client.options.freeCache = loadFreeCache(DefaultCacheSize, DefaultGCPercent)
}
}
// Return the client
return client, nil
}
// Close will close the client and any open connections
func (c *Client) Close(ctx context.Context) {
if txn := newrelic.FromContext(ctx); txn != nil {
defer txn.StartSegment("close_cachestore").End()
}
if c != nil && c.options != nil {
if c.Engine() == Redis {
if c.options.redis != nil {
c.options.redis.Close()
}
c.options.redis = nil
} else if c.Engine() == FreeCache {
if c.options.freeCache != nil {
c.options.freeCache.Clear()
}
c.options.freeCache = nil
}
c.options.engine = Empty
}
}
// Debug will set the debug flag
func (c *Client) Debug(on bool) {
c.options.debug = on
}
// IsDebug will return if debugging is enabled
func (c *Client) IsDebug() bool {
return c.options.debug
}
// IsNewRelicEnabled will return if new relic is enabled
func (c *Client) IsNewRelicEnabled() bool {
return c.options.newRelicEnabled
}
// Engine will return the engine that is set
func (c *Client) Engine() Engine {
return c.options.engine
}
// Redis will return the Redis client if found
func (c *Client) Redis() *cache.Client {
return c.options.redis
}
// RedisConfig will return the Redis config client if found
func (c *Client) RedisConfig() *RedisConfig {
return c.options.redisConfig
}
// FreeCache will return the FreeCache client if found
func (c *Client) FreeCache() *freecache.Cache {
return c.options.freeCache
}
// EmptyCache will empty the cache entirely
//
// CAUTION: this will dump all the stored cache
func (c *Client) EmptyCache(ctx context.Context) error {
if c.Engine() == Redis && c.options.redis != nil {
return cache.DestroyCache(ctx, c.options.redis)
} else if c.options.freeCache != nil {
c.options.freeCache.Clear()
}
return nil
}