mirror of
https://github.com/hanzoai/tasks.git
synced 2026-10-30 14:56:19 +00:00
Alex ShtinandGitHub
8e8f1b0f7c
## What changed?
<!-- Describe what has changed in this PR -->
Remove license header from every file. Because it is really hard to
follow in this PR here is the summary:
1. License header is removed from all `.go` and `.proto` files
:fireworks::fireworks:🎆.
2. `LICENSE` file in the root directory has only Temporal and Uber
copyrights.
3. 5 other `LICENSE` files added to the packages which have copyrights
different from Temporal and Uber: Datadog, Xargin, "Mat Ryer, Tyler
Bunnell and contributors".
4. `license_file` flag is removed from all code generation tools.
5. `copyright_file` flag is removed from `go:generate mockgen`
directive.
6. All copyright related targets are removed from `Makefile`.
7. Updated Temporal copyright year to 2025 everywhere.
## Why?
<!-- Tell your future self why have you made these changes -->
I double checked with legal department that it is not needed to have
license header in every file. One file per repo is enough. I put all
copyrights to the root `LICENSE` file and removed header from all other
files. Also updated tools and `Makefile`.
105 lines
2.5 KiB
Go
105 lines
2.5 KiB
Go
package hybrid_logical_clock
|
|
|
|
import (
|
|
"time"
|
|
|
|
clockspb "go.temporal.io/server/api/clock/v1"
|
|
commonclock "go.temporal.io/server/common/clock"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
)
|
|
|
|
type Clock = clockspb.HybridLogicalClock
|
|
|
|
// Next generates the next clock timestamp given the current clock.
|
|
// HybridLogicalClock requires the previous clock to ensure that time doesn't move backwards and the next clock is
|
|
// monotonically increasing.
|
|
func Next(prior *Clock, source commonclock.TimeSource) *Clock {
|
|
wallclock := source.Now().UnixMilli()
|
|
// Ensure time does not move backwards
|
|
if wallclock < prior.GetWallClock() {
|
|
wallclock = prior.GetWallClock()
|
|
}
|
|
// Ensure timestamp is monotonically increasing
|
|
var version int32
|
|
if wallclock == prior.GetWallClock() {
|
|
version = prior.GetVersion() + 1
|
|
}
|
|
|
|
return &Clock{WallClock: wallclock, Version: version, ClusterId: prior.ClusterId}
|
|
}
|
|
|
|
// Zero generates a zeroed logical clock for the cluster ID.
|
|
func Zero(clusterID int64) *Clock {
|
|
return &Clock{WallClock: 0, Version: 0, ClusterId: clusterID}
|
|
}
|
|
|
|
func sign[T int64 | int32](x T) int {
|
|
if x > 0 {
|
|
return 1
|
|
}
|
|
if x < 0 {
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Compare 2 Clocks, returns 0 if a == b, -1 if a > b, 1 if a < b
|
|
func Compare(a *Clock, b *Clock) int {
|
|
if a.WallClock == b.WallClock {
|
|
if a.Version == b.Version {
|
|
return sign(b.ClusterId - a.ClusterId)
|
|
}
|
|
return sign(b.Version - a.Version)
|
|
}
|
|
return sign(b.WallClock - a.WallClock)
|
|
}
|
|
|
|
// Greater returns true if a is greater than b
|
|
func Greater(a *Clock, b *Clock) bool {
|
|
return Compare(b, a) > 0
|
|
}
|
|
|
|
// Greater returns true if a is greater than b
|
|
func Less(a *Clock, b *Clock) bool {
|
|
return Compare(a, b) > 0
|
|
}
|
|
|
|
// Max returns the maximum of two Clocks
|
|
func Max(a *Clock, b *Clock) *Clock {
|
|
if Compare(a, b) > 0 {
|
|
return b
|
|
}
|
|
return a
|
|
}
|
|
|
|
// Min returns the minimum of two Clocks
|
|
func Min(a *Clock, b *Clock) *Clock {
|
|
if Compare(a, b) > 0 {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Equal returns whether two Clocks are equal
|
|
func Equal(a *Clock, b *Clock) bool {
|
|
return Compare(a, b) == 0
|
|
}
|
|
|
|
// UTC returns a Time from a Clock in millisecond resolution. The Time's Location is set to UTC.
|
|
func UTC(c *Clock) time.Time {
|
|
if c == nil {
|
|
return time.Unix(0, 0).UTC()
|
|
}
|
|
return time.Unix(c.WallClock/1000, c.WallClock%1000*1000000).UTC()
|
|
}
|
|
|
|
// Since returns time.Since(UTC(c))
|
|
func Since(c *Clock) time.Duration {
|
|
return time.Since(UTC(c))
|
|
}
|
|
|
|
// ProtoTimestamp returns timestamppb.New(UTC(c))
|
|
func ProtoTimestamp(c *Clock) *timestamppb.Timestamp {
|
|
return timestamppb.New(UTC(c))
|
|
}
|