// shouldRunContinuousQuery returns true if the CQ should be schedule to run. It will use the
// lastRunTime of the CQ and the rules for when to run set through the query to determine
// if this CQ should be run
func (cq *ContinuousQuery) shouldRunContinuousQuery(now time.Time) (bool, time.Time, error) {
// if it's not aggregated we don't run it
if cq.q.IsRawQuery {
return false, cq.LastRun, errors.New("continuous queries must be aggregate queries")
}
// since it's aggregated we need to figure how often it should be run
interval, err := cq.q.GroupByInterval()
if err != nil {
return false, cq.LastRun, err
}
// allow the interval to be overwritten by the query's resample options
resampleEvery := interval
if cq.Resample.Every != 0 {
resampleEvery = cq.Resample.Every
}
// if we've passed the amount of time since the last run, or there was no last run, do it up
if cq.HasRun {
nextRun := cq.LastRun.Add(resampleEvery)
if nextRun.UnixNano() <= now.UnixNano() {
return true, nextRun, nil
}
} else {
return true, now, nil
}
return false, cq.LastRun, nil
}
func (a *Attempt) nextSleep(now time.Time) time.Duration {
sleep := a.strategy.Delay - now.Sub(a.last)
if sleep < 0 {
return 0
}
return sleep
}
// FormatTimestamp formats t into Postgres' text format for timestamps.
func FormatTimestamp(t time.Time) []byte {
// Need to send dates before 0001 A.D. with " BC" suffix, instead of the
// minus sign preferred by Go.
// Beware, "0000" in ISO is "1 BC", "-0001" is "2 BC" and so on
bc := false
if t.Year() <= 0 {
// flip year sign, and add 1, e.g: "0" will be "1", and "-10" will be "11"
t = t.AddDate((-t.Year())*2+1, 0, 0)
bc = true
}
b := []byte(t.Format(time.RFC3339Nano))
_, offset := t.Zone()
offset = offset % 60
if offset != 0 {
// RFC3339Nano already printed the minus sign
if offset < 0 {
offset = -offset
}
b = append(b, ':')
if offset < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(offset), 10)
}
if bc {
b = append(b, " BC"...)
}
return b
}
// Add adds new node and returns it, it replaces existing without notification.
func (s *nodeStore) Add(n *api.Node, expireFunc func()) *registeredNode {
s.mu.Lock()
defer s.mu.Unlock()
var attempts int
var registered time.Time
if existRn, ok := s.nodes[n.ID]; ok {
attempts = existRn.Attempts
registered = existRn.Registered
existRn.Heartbeat.Stop()
delete(s.nodes, n.ID)
}
if registered.IsZero() {
registered = time.Now()
}
rn := ®isteredNode{
SessionID: identity.NewID(), // session ID is local to the dispatcher.
Node: n,
Registered: registered,
Attempts: attempts,
Disconnect: make(chan struct{}),
}
s.nodes[n.ID] = rn
rn.Heartbeat = heartbeat.New(s.periodChooser.Choose()*s.gracePeriodMultiplierNormal, expireFunc)
return rn
}
func (self Weekday) NextAfter(t time.Time) (time.Time, error) {
diff := int(self) - int(t.Weekday())
if diff <= 0 {
diff += 7
}
return t.AddDate(0, 0, diff), nil
}
// buildCommonLogLine builds a log entry for req in Apache Common Log Format.
// ts is the timestamp with which the entry should be logged.
// status and size are used to provide the response HTTP status and size.
func buildCommonLogLine(req *http.Request, url url.URL, ts time.Time, status int, size int) []byte {
username := "******"
if url.User != nil {
if name := url.User.Username(); name != "" {
username = name
}
}
host, _, err := net.SplitHostPort(req.RemoteAddr)
if err != nil {
host = req.RemoteAddr
}
uri := url.RequestURI()
buf := make([]byte, 0, 3*(len(host)+len(username)+len(req.Method)+len(uri)+len(req.Proto)+50)/2)
buf = append(buf, host...)
buf = append(buf, " - "...)
buf = append(buf, username...)
buf = append(buf, " ["...)
buf = append(buf, ts.Format("02/Jan/2006:15:04:05 -0700")...)
buf = append(buf, `] "`...)
buf = append(buf, req.Method...)
buf = append(buf, " "...)
buf = appendQuoted(buf, uri)
buf = append(buf, " "...)
buf = append(buf, req.Proto...)
buf = append(buf, `" `...)
buf = append(buf, strconv.Itoa(status)...)
buf = append(buf, " "...)
buf = append(buf, strconv.Itoa(size)...)
return buf
}
// Enqueue is a convenience function to push a message to a channel while
// waiting for a timeout instead of just blocking.
// Passing a timeout of -1 will discard the message.
// Passing a timout of 0 will always block.
// Messages that time out will be passed to the dropped queue if a Dropped
// consumer exists.
// The source parameter is used when a message is dropped, i.e. it is passed
// to the Drop function.
func (msg Message) Enqueue(channel chan<- Message, timeout time.Duration) MessageState {
if timeout == 0 {
channel <- msg
return MessageStateOk // ### return, done ###
}
start := time.Time{}
spin := shared.Spinner{}
for {
select {
case channel <- msg:
return MessageStateOk // ### return, done ###
default:
switch {
// Start timeout based retries
case start.IsZero():
if timeout < 0 {
return MessageStateDiscard // ### return, discard and ignore ###
}
start = time.Now()
spin = shared.NewSpinner(shared.SpinPriorityHigh)
// Discard message after timeout
case time.Since(start) > timeout:
return MessageStateTimeout // ### return, drop and retry ###
// Yield and try again
default:
spin.Yield()
}
}
}
}
func (c *RuleCache) buildAll(refresh bool) (*RuleSet, time.Time, error) {
matcher := adblock.NewMatcher()
rules := []string{}
read := 0
oldest := time.Time{}
for _, url := range c.urls {
r, date, err := c.load(url, refresh)
if err != nil {
return nil, oldest, err
}
if oldest.After(date) {
oldest = date
}
log.Printf("building rules from %s", url)
built, n, err := buildOne(r, matcher)
r.Close()
if err != nil {
return nil, oldest, err
}
rules = append(rules, built...)
read += n
}
log.Printf("blacklists built: %d / %d added\n", len(rules), read)
return &RuleSet{
Rules: rules,
Matcher: matcher,
}, oldest, nil
}
func toUTCString(t time.Time) string {
utc := t.UTC().Round(time.Second)
// Ugly but straight forward formatting as time.Parse is such a prima donna
return fmt.Sprintf("%d-%02d-%02dT%02d:%02d:%02d.000Z",
utc.Year(), utc.Month(), utc.Day(),
utc.Hour(), utc.Minute(), utc.Second())
}
func humanizeTime(t time.Time) string {
if t.IsZero() {
return ""
} else {
return humanize.Time(t)
}
}
func (s *server) signSet(r []dns.RR, now time.Time, incep, expir uint32) (*dns.RRSIG, error) {
key := cache.Key(r)
if m, exp, hit := s.scache.Search(key); hit { // There can only be one sig in this cache.
// Is it still valid 24 hours from now?
if now.Add(+24*time.Hour).Sub(exp) < -24*time.Hour {
return m.Answer[0].(*dns.RRSIG), nil
}
s.scache.Remove(key)
}
logf("scache miss for %s type %d", r[0].Header().Name, r[0].Header().Rrtype)
StatsDnssecCacheMiss.Inc(1)
promCacheMiss.WithLabelValues("signature").Inc()
sig, err, shared := inflight.Do(key, func() (*dns.RRSIG, error) {
sig1 := s.NewRRSIG(incep, expir)
sig1.Header().Ttl = r[0].Header().Ttl
if r[0].Header().Rrtype == dns.TypeTXT {
sig1.OrigTtl = 0
}
e := sig1.Sign(s.config.PrivKey, r)
if e != nil {
logf("failed to sign: %s", e.Error())
}
return sig1, e
})
if err != nil {
return nil, err
}
if !shared {
s.scache.InsertSignature(key, sig)
}
return dns.Copy(sig).(*dns.RRSIG), nil
}
func (r *Rrd) Update(timestamp time.Time, values []string) error {
if timestamp.Before(r.LastUpdate) {
return errors.Errorf("illegal attempt to update using time %s when last update time is %s (minimum one second step)", timestamp.String(), r.LastUpdate.String())
}
elapsed := r.calculateElapsedSteps(timestamp)
newPdps, err := r.calculatePdpPreps(elapsed.Interval, values)
if err != nil {
return err
}
if elapsed.Steps == 0 {
r.simpleUpdate(newPdps, elapsed.Interval)
} else {
pdpTemp := r.processAllPdp(newPdps, elapsed)
rraStepCounts := r.updateAllCdpPreps(pdpTemp, elapsed)
r.updateAberrantCdps(pdpTemp, elapsed)
r.writeToRras(rraStepCounts)
for i, rra := range r.Rras {
if err := r.Store.StoreRraParams(i, rra); err != nil {
return err
}
}
}
return r.writeChanges(timestamp)
}
// buildLogLine creates a common log format
// in addittion to the common fields, we also append referrer, user agent and request ID
func buildLogLine(l *responseLogger, r *http.Request, start time.Time) string {
username := parseUsername(r)
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
host = r.RemoteAddr
}
uri := r.URL.RequestURI()
referer := r.Referer()
userAgent := r.UserAgent()
fields := []string{
host,
"-",
detect(username, "-"),
fmt.Sprintf("[%s]", start.Format("02/Jan/2006:15:04:05 -0700")),
r.Method,
uri,
r.Proto,
detect(strconv.Itoa(l.Status()), "-"),
strconv.Itoa(l.Size()),
detect(referer, "-"),
detect(userAgent, "-"),
r.Header.Get("Request-Id"),
}
return strings.Join(fields, " ")
}
func (k *Keys) sign(s *Service, t time.Time) []byte {
h := ghmac([]byte("AWS4"+k.SecretKey), []byte(t.Format(iSO8601BasicFormatShort)))
h = ghmac(h, []byte(s.Region))
h = ghmac(h, []byte(s.Name))
h = ghmac(h, []byte("aws4_request"))
return h
}
// Determine when the next housekeeping should occur.
func (self *containerData) nextHousekeeping(lastHousekeeping time.Time) time.Time {
if self.allowDynamicHousekeeping {
var empty time.Time
stats, err := self.memoryCache.RecentStats(self.info.Name, empty, empty, 2)
if err != nil {
if self.allowErrorLogging() {
glog.Warningf("Failed to get RecentStats(%q) while determining the next housekeeping: %v", self.info.Name, err)
}
} else if len(stats) == 2 {
// TODO(vishnuk): Use no processes as a signal.
// Raise the interval if usage hasn't changed in the last housekeeping.
if stats[0].StatsEq(stats[1]) && (self.housekeepingInterval < self.maxHousekeepingInterval) {
self.housekeepingInterval *= 2
if self.housekeepingInterval > self.maxHousekeepingInterval {
self.housekeepingInterval = self.maxHousekeepingInterval
}
} else if self.housekeepingInterval != *HousekeepingInterval {
// Lower interval back to the baseline.
self.housekeepingInterval = *HousekeepingInterval
}
}
}
return lastHousekeeping.Add(self.housekeepingInterval)
}
// GetBlobSASURI creates an URL to the specified blob which contains the Shared
// Access Signature with specified permissions and expiration time.
//
// See https://msdn.microsoft.com/en-us/library/azure/ee395415.aspx
func (b BlobStorageClient) GetBlobSASURI(container, name string, expiry time.Time, permissions string) (string, error) {
var (
signedPermissions = permissions
blobURL = b.GetBlobURL(container, name)
)
canonicalizedResource, err := b.client.buildCanonicalizedResource(blobURL)
if err != nil {
return "", err
}
signedExpiry := expiry.UTC().Format(time.RFC3339)
signedResource := "b"
stringToSign, err := blobSASStringToSign(b.client.apiVersion, canonicalizedResource, signedExpiry, signedPermissions)
if err != nil {
return "", err
}
sig := b.client.computeHmac256(stringToSign)
sasParams := url.Values{
"sv": {b.client.apiVersion},
"se": {signedExpiry},
"sr": {signedResource},
"sp": {signedPermissions},
"sig": {sig},
}
sasURL, err := url.Parse(blobURL)
if err != nil {
return "", err
}
sasURL.RawQuery = sasParams.Encode()
return sasURL.String(), nil
}
// compareTime checks if a and b are roughly equal
func compareTime(a time.Time, b time.Time) bool {
diff := a.Sub(b)
if diff < 0 {
diff = -diff
}
return diff < precision
}
func webTime(t time.Time) string {
ftime := t.Format(time.RFC1123)
if strings.HasSuffix(ftime, "UTC") {
ftime = ftime[0:len(ftime)-3] + "GMT"
}
return ftime
}
func marshalTime(t time.Time) string {
if t.IsZero() {
return ""
}
b, _ := t.MarshalText()
return string(b)
}
func Retry(maxWait time.Duration, failAfter time.Duration, f func() error) (err error) {
var lastStart time.Time
err = errors.New("Did not connect.")
loopWait := time.Millisecond * 500
retryStart := time.Now()
for retryStart.Add(failAfter).After(time.Now()) {
lastStart = time.Now()
if err = f(); err == nil {
return nil
}
if lastStart.Add(maxWait * 2).Before(time.Now()) {
retryStart = time.Now()
}
LogError(err)
logrus.Infof("Retrying in %f seconds...", loopWait.Seconds())
time.Sleep(loopWait)
loopWait = loopWait * time.Duration(int64(2))
if loopWait > maxWait {
loopWait = maxWait
}
}
return err
}
func Time(v, d time.Time) time.Time {
if v.IsZero() {
return d
}
return v
}
// minExpiry returns a minimal expiry. A minimal expiry is the larger on
// between now + minLeaseTerm and the given expectedExpiry.
func minExpiry(now time.Time, expectedExpiry time.Time) time.Time {
minExpiry := time.Now().Add(minLeaseTerm)
if expectedExpiry.Sub(minExpiry) < 0 {
expectedExpiry = minExpiry
}
return expectedExpiry
}
// create a time limit code
// code format: 12 length date time string + 6 minutes string + 40 sha1 encoded string
func CreateTimeLimitCode(data string, minutes int, startInf interface{}) string {
format := "200601021504"
var start, end time.Time
var startStr, endStr string
if startInf == nil {
// Use now time create code
start = time.Now()
startStr = start.Format(format)
} else {
// use start string create code
startStr = startInf.(string)
start, _ = time.ParseInLocation(format, startStr, time.Local)
startStr = start.Format(format)
}
end = start.Add(time.Minute * time.Duration(minutes))
endStr = end.Format(format)
// create sha1 encode string
sh := sha1.New()
sh.Write([]byte(data + setting.SecretKey + startStr + endStr + com.ToStr(minutes)))
encoded := hex.EncodeToString(sh.Sum(nil))
code := fmt.Sprintf("%s%06d%s", startStr, minutes, encoded)
return code
}
func (ts *timeStore) Delete(start, end time.Time) error {
ts.rwLock.Lock()
defer ts.rwLock.Unlock()
if ts.buffer.Len() == 0 {
return nil
}
if (end != time.Time{}) && !end.After(start) {
return fmt.Errorf("end time %v is not after start time %v", end, start)
}
// Assuming that deletes will happen more frequently for older data.
elem := ts.buffer.Back()
for elem != nil {
entry := elem.Value.(TimePoint)
if (end != time.Time{}) && entry.Timestamp.After(end) {
// If we have reached an entry which is more recent than 'end' stop iterating.
break
}
oldElem := elem
elem = elem.Prev()
// Skip entried which are before start.
if !entry.Timestamp.Before(start) {
ts.buffer.Remove(oldElem)
}
}
return nil
}
func (s *EtcdServer) parseProposeCtxErr(err error, start time.Time) error {
switch err {
case context.Canceled:
return ErrCanceled
case context.DeadlineExceeded:
curLeadElected := s.r.leadElectedTime()
prevLeadLost := curLeadElected.Add(-2 * time.Duration(s.Cfg.ElectionTicks) * time.Duration(s.Cfg.TickMs) * time.Millisecond)
if start.After(prevLeadLost) && start.Before(curLeadElected) {
return ErrTimeoutDueToLeaderFail
}
lead := types.ID(atomic.LoadUint64(&s.r.lead))
switch lead {
case types.ID(raft.None):
// TODO: return error to specify it happens because the cluster does not have leader now
case s.ID():
if !isConnectedToQuorumSince(s.r.transport, start, s.ID(), s.cluster.Members()) {
return ErrTimeoutDueToConnectionLost
}
default:
if !isConnectedSince(s.r.transport, start, lead) {
return ErrTimeoutDueToConnectionLost
}
}
return ErrTimeout
default:
return err
}
}
// KeyExpired returns whether sig is a self-signature of a key that has
// expired.
func (sig *Signature) KeyExpired(currentTime time.Time) bool {
if sig.KeyLifetimeSecs == nil {
return false
}
expiry := sig.CreationTime.Add(time.Duration(*sig.KeyLifetimeSecs) * time.Second)
return currentTime.After(expiry)
}
// flock acquires an advisory lock on a file descriptor.
func flock(f *os.File, exclusive bool, timeout time.Duration) error {
var t time.Time
for {
// If we're beyond our timeout then return an error.
// This can only occur after we've attempted a flock once.
if t.IsZero() {
t = time.Now()
} else if timeout > 0 && time.Since(t) > timeout {
return ErrTimeout
}
var lock syscall.Flock_t
lock.Start = 0
lock.Len = 0
lock.Pid = 0
lock.Whence = 0
lock.Pid = 0
if exclusive {
lock.Type = syscall.F_WRLCK
} else {
lock.Type = syscall.F_RDLCK
}
err := syscall.FcntlFlock(f.Fd(), syscall.F_SETLK, &lock)
if err == nil {
return nil
} else if err != syscall.EAGAIN {
return err
}
// Wait for a bit and try again.
time.Sleep(50 * time.Millisecond)
}
}
func timerLoop(count *uint64, ticker *time.Ticker) {
lastTime := time.Now().UTC()
lastCount := *count
zeroes := int8(0)
var (
msgsSent, newCount uint64
elapsedTime time.Duration
now time.Time
rate float64
)
for {
_ = <-ticker.C
newCount = *count
now = time.Now()
msgsSent = newCount - lastCount
lastCount = newCount
elapsedTime = now.Sub(lastTime)
lastTime = now
rate = float64(msgsSent) / elapsedTime.Seconds()
if msgsSent == 0 {
if newCount == 0 || zeroes == 3 {
continue
}
zeroes++
} else {
zeroes = 0
}
log.Printf("Sent %d messages. %0.2f msg/sec\n", newCount, rate)
}
}
func runDialTest(t *testing.T, test dialtest) {
var (
vtime time.Time
running int
)
pm := func(ps []*Peer) map[discover.NodeID]*Peer {
m := make(map[discover.NodeID]*Peer)
for _, p := range ps {
m[p.rw.id] = p
}
return m
}
for i, round := range test.rounds {
for _, task := range round.done {
running--
if running < 0 {
panic("running task counter underflow")
}
test.init.taskDone(task, vtime)
}
new := test.init.newTasks(running, pm(round.peers), vtime)
if !sametasks(new, round.new) {
t.Errorf("round %d: new tasks mismatch:\ngot %v\nwant %v\nstate: %v\nrunning: %v\n",
i, spew.Sdump(new), spew.Sdump(round.new), spew.Sdump(test.init), spew.Sdump(running))
}
// Time advances by 16 seconds on every round.
vtime = vtime.Add(16 * time.Second)
running += len(new)
}
}
func (d *deadline) setTime(t time.Time) {
if t.IsZero() {
d.set(0)
} else {
d.set(t.UnixNano())
}
}