144 lines
2.2 KiB
Go
144 lines
2.2 KiB
Go
// counter
|
|
package main
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Counter structure
|
|
type Counter struct {
|
|
mu sync.Mutex
|
|
user int
|
|
log int
|
|
rem int
|
|
err int
|
|
dup int
|
|
time time.Duration
|
|
wg []int
|
|
}
|
|
|
|
// NewCounter iniitialized Counter structure
|
|
func NewCounter() *Counter {
|
|
return &Counter{
|
|
user: 0,
|
|
log: 0,
|
|
err: 0,
|
|
rem: 0,
|
|
dup: 0,
|
|
time: 0,
|
|
wg: make([]int, opts.Concurrent),
|
|
}
|
|
}
|
|
|
|
// AddUser increment number of users managed
|
|
func (c *Counter) AddUser() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.user++
|
|
}
|
|
|
|
// AddDuplicate increment number of duplicates log
|
|
func (c *Counter) AddDuplicate() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.dup++
|
|
}
|
|
|
|
// AddLog increment number of log's rows managed
|
|
func (c *Counter) AddLog(add int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.log += add
|
|
}
|
|
|
|
//AddRem increment removed logs row
|
|
func (c *Counter) AddRem(add int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.rem += add
|
|
}
|
|
|
|
// AddWG ...
|
|
func (c *Counter) AddWG(id int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.wg[id]++
|
|
}
|
|
|
|
// AddErr ...
|
|
func (c *Counter) AddErr() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.err++
|
|
}
|
|
|
|
// DelWG ...
|
|
func (c *Counter) DelWG(id int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.wg[id]--
|
|
}
|
|
|
|
// GetUser return total users
|
|
func (c *Counter) GetUser() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.user
|
|
return
|
|
}
|
|
|
|
// GetDup return total duplicated logins
|
|
func (c *Counter) GetDup() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.dup
|
|
return
|
|
}
|
|
|
|
// GetLog return total log's rows
|
|
func (c *Counter) GetLog() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.log
|
|
return
|
|
}
|
|
|
|
// GetErr return total errors
|
|
func (c *Counter) GetErr() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.err
|
|
return
|
|
}
|
|
|
|
// GetRem return total removed log's rows
|
|
func (c *Counter) GetRem() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.rem
|
|
return
|
|
}
|
|
|
|
// GetWG ...
|
|
func (c *Counter) GetWG(id int) (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.wg[id]
|
|
return
|
|
}
|
|
|
|
// GetTime ...
|
|
func (c *Counter) GetTime() (ret float64) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.time.Seconds()
|
|
return
|
|
}
|
|
|
|
// SetTime ...
|
|
func (c *Counter) SetTime(t time.Duration) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.time = t
|
|
}
|