Upgrade Sonyflake to v2 (#66)

* Add v2

* Introduce staticcheck

* Introduce golangci-lint

* Add error checks

* Add error checks

* Lint v2 code

* Improve CI trigger

* Use io.ReadAll

* Use int64

* Remove NewSonyflake

* Fix errors

* v2: Change MachineID, sequence, and AmazonEC2MachineID to int; update all usage and tests for type consistency

* docs: update Settings struct in README to use int for MachineID and CheckMachineID (v2)

* docs(v2): clarify Settings, StartTime, MachineID, and CheckMachineID comments and update README links and explanations

* docs(v2/mock): improve comments and docstrings for mock implementations

* docs(types): unify and clarify package and type docstrings for types.go in v1 and v2

* test(v2): refactor and modernize tests, improve error assertions, and update mocks for v2

* test(v2): normalize whitespace in pseudoSleep calls for consistency

* feat(v2): add configurable TimeUnit and refactor time handling for So… (#67)

* feat(v2): add configurable TimeUnit and refactor time handling for Sonyflake v2

* test(v2): add ToTime tests, clarify TimeUnit behavior, and update docs for v2

* gofmt

Author: YoshiyukiMineo

.github/workflows/test-v1.yml

@@ -0,0 +1,45 @@
+name: CI for v1 Module
+
+on:
+  push:
+    paths-ignore:
+      - .github/workflows/test-v2.yml
+      - 'v2/**'
+  pull_request:
+    paths-ignore:
+      - .github/workflows/test-v2.yml
+      - 'v2/**'
+
+jobs:
+  test-v1:
+    strategy:
+      matrix:
+        go-version: [1.23.x, 1.24.x]
+        os: [ubuntu-latest]
+
+    runs-on: ${{matrix.os}}
+
+    defaults:
+      run:
+        working-directory: ./
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{matrix.go-version}}
+
+      - name: Lint Code
+        uses: golangci/golangci-lint-action@v6
+
+      - name: Check format
+        run: test -z "`gofmt -l .`"
+
+      - name: Run tests
+        run: go test -v ./...
+
+      - name: Build example
+        run: cd example && ./linux64_build.sh

.github/workflows/test-v2.yml

@@ -0,0 +1,50 @@
+name: CI for v2 Module
+
+on:
+  push:
+    paths:
+      - .github/workflows/test-v2.yml
+      - 'v2/**'
+  pull_request:
+    paths:
+      - .github/workflows/test-v2.yml
+      - 'v2/**'
+
+jobs:
+  test-v2:
+    strategy:
+      matrix:
+        go-version: [1.23.x, 1.24.x]
+        os: [ubuntu-latest]
+
+    runs-on: ${{matrix.os}}
+
+    defaults:
+      run:
+        working-directory: ./v2
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: ./v2/go.mod
+
+      - name: Tidy modules
+        run: go mod tidy
+
+      - name: Lint Code
+        uses: golangci/golangci-lint-action@v6
+        with:
+          working-directory: ./v2
+
+      - name: Check format
+        run: test -z "`gofmt -l .`"
+
+      - name: Run tests
+        run: go test ./... -v
+
+      - name: Build example
+        run: cd example && ./linux64_build.sh

.github/workflows/test.yml

@@ -1 +1,2 @@
 example/sonyflake_server
+v2/example/sonyflake_server

.gitignore

@@ -18,16 +18,16 @@ As a result, Sonyflake has the following advantages and disadvantages:
 
 - The lifetime (174 years) is longer than that of Snowflake (69 years)
 - It can work in more distributed machines (2^16) than Snowflake (2^10)
-- It can generate 2^8 IDs per 10 msec at most in a single machine/thread (slower than Snowflake)
+- It can generate 2^8 IDs per 10 msec at most in a single instance (fewer than Snowflake)
 
 However, if you want more generation rate in a single host,
-you can easily run multiple Sonyflake ID generators concurrently using goroutines.
+you can easily run multiple Sonyflake instances parallelly using goroutines.
 
 Installation
 ------------
 
 ```
-go get github.com/sony/sonyflake
+go get github.com/sony/sonyflake/v2
 ```
 
 Usage
@@ -43,42 +43,42 @@ You can configure Sonyflake by the struct Settings:
 
 ```go
 type Settings struct {
+	TimeUnit       time.Duration
 	StartTime      time.Time
-	MachineID      func() (uint16, error)
-	CheckMachineID func(uint16) bool
+	MachineID      func() (int, error)
+	CheckMachineID func(int) bool
 }
 ```
 
+- TimeUnit is the time unit of Sonyflake.
+  If TimeUnit is 0, the default time unit is used, which is 10 msec.
+  TimeUnit must be equal to or greater than 1 msec.
+
 - StartTime is the time since which the Sonyflake time is defined as the elapsed time.
-  If StartTime is 0, the start time of the Sonyflake is set to "2014-09-01 00:00:00 +0000 UTC".
-  If StartTime is ahead of the current time, Sonyflake is not created.
+  If StartTime is 0, the start time of the Sonyflake instance is set to "2025-01-01 00:00:00 +0000 UTC".
+  StartTime must be before the current time.
 
-- MachineID returns the unique ID of the Sonyflake instance.
-  If MachineID returns an error, Sonyflake is not created.
-  If MachineID is nil, default MachineID is used.
-  Default MachineID returns the lower 16 bits of the private IP address.
+- MachineID returns the unique ID of a Sonyflake instance.
+  If MachineID returns an error, the instance will not be created.
+  If MachineID is nil, the default MachineID is used, which returns the lower 16 bits of the private IP address.
 
-- CheckMachineID validates the uniqueness of the machine ID.
-  If CheckMachineID returns false, Sonyflake is not created.
+- CheckMachineID validates the uniqueness of a machine ID.
+  If CheckMachineID returns false, the instance will not be created.
   If CheckMachineID is nil, no validation is done.
 
 In order to get a new unique ID, you just have to call the method NextID.
 
 ```go
-func (sf *Sonyflake) NextID() (uint64, error)
+func (sf *Sonyflake) NextID() (int64, error)
 ```
 
-NextID can continue to generate IDs for about 174 years from StartTime.
+NextID can continue to generate IDs for about 174 years from StartTime by default.
 But after the Sonyflake time is over the limit, NextID returns an error.
 
-> **Note:**
-> Sonyflake currently does not use the most significant bit of IDs,
-> so you can convert Sonyflake IDs from `uint64` to `int64` safely.
-
 AWS VPC and Docker
 ------------------
 
-The [awsutil](https://github.com/sony/sonyflake/blob/master/awsutil) package provides
+The [awsutil](https://github.com/sony/sonyflake/blob/master/v2/awsutil) package provides
 the function AmazonEC2MachineID that returns the lower 16-bit private IP address of the Amazon EC2 instance.
 It also works correctly on Docker
 by retrieving [instance metadata](http://docs.aws.amazon.com/en_us/AWSEC2/latest/UserGuide/ec2-instance-metadata.html).
@@ -89,7 +89,7 @@ So if each EC2 instance has a unique private IP address in AWS VPC,
 the lower 16 bits of the address is also unique.
 In this common case, you can use AmazonEC2MachineID as Settings.MachineID.
 
-See [example](https://github.com/sony/sonyflake/blob/master/example) that runs Sonyflake on AWS Elastic Beanstalk.
+See [example](https://github.com/sony/sonyflake/blob/master/v2/example) that runs Sonyflake on AWS Elastic Beanstalk.
 
 License
 -------

README.md

@@ -33,10 +33,17 @@ func handler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.Header()["Content-Type"] = []string{"application/json; charset=utf-8"}
-	w.Write(body)
+	_, err = w.Write(body)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 }
 
 func main() {
 	http.HandleFunc("/", handler)
-	http.ListenAndServe(":8080", nil)
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		panic(err)
+	}
 }

example/sonyflake_server.go

@@ -1,6 +1,5 @@
-// Package mock offers implementations of interfaces defined in types.go
-// This allows complete control over input / output for any given method that consumes
-// a given type
+// Package mock offers mock implementations of interfaces defined in types.go.
+// This allows complete control over input / output for any given method that consumes a given type.
 package mock
 
 import (
@@ -10,7 +9,7 @@ import (
 	"github.com/sony/sonyflake/types"
 )
 
-// NewSuccessfulInterfaceAddrs returns a single private IP address
+// NewSuccessfulInterfaceAddrs returns a single private IP address.
 func NewSuccessfulInterfaceAddrs() types.InterfaceAddrs {
 	ifat := make([]net.Addr, 0, 1)
 	ifat = append(ifat, &net.IPNet{IP: []byte{192, 168, 0, 1}, Mask: []byte{255, 0, 0, 0}})
@@ -20,14 +19,14 @@ func NewSuccessfulInterfaceAddrs() types.InterfaceAddrs {
 	}
 }
 
-// NewFailingInterfaceAddrs returns an error
+// NewFailingInterfaceAddrs returns an error.
 func NewFailingInterfaceAddrs() types.InterfaceAddrs {
 	return func() ([]net.Addr, error) {
 		return nil, fmt.Errorf("test error")
 	}
 }
 
-// NewFailingInterfaceAddrs returns an empty slice of addresses
+// NewNilInterfaceAddrs returns an empty slice of addresses.
 func NewNilInterfaceAddrs() types.InterfaceAddrs {
 	return func() ([]net.Addr, error) {
 		return []net.Addr{}, nil

mock/sonyflake_mock.go

@@ -1,8 +1,8 @@
-// Package Types defines type signatures used throughout SonyFlake. This allows for
-// fine-tuned control over imports, and the ability to mock out imports as well
+// Package types defines type signatures used throughout sonyflake.
+// This provides the ability to mock out imports.
 package types
 
 import "net"
 
-// InterfaceAddrs defines the interface used for retrieving network addresses
+// InterfaceAddrs defines the interface used for retrieving network addresses.
 type InterfaceAddrs func() ([]net.Addr, error)

types/types.go

@@ -0,0 +1,64 @@
+// Package awsutil provides utility functions for using Sonyflake on AWS.
+package awsutil
+
+import (
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"time"
+)
+
+func amazonEC2PrivateIPv4() (net.IP, error) {
+	res, err := http.Get("http://169.254.169.254/latest/meta-data/local-ipv4")
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	ip := net.ParseIP(string(body))
+	if ip == nil {
+		return nil, errors.New("invalid ip address")
+	}
+	return ip.To4(), nil
+}
+
+// AmazonEC2MachineID retrieves the private IP address of the Amazon EC2 instance
+// and returns its lower 16 bits.
+// It works correctly on Docker as well.
+func AmazonEC2MachineID() (int, error) {
+	ip, err := amazonEC2PrivateIPv4()
+	if err != nil {
+		return 0, err
+	}
+
+	return int(ip[2])<<8 + int(ip[3]), nil
+}
+
+// TimeDifference returns the time difference between the localhost and the given NTP server.
+func TimeDifference(server string) (time.Duration, error) {
+	output, err := exec.Command("/usr/sbin/ntpdate", "-q", server).CombinedOutput()
+	if err != nil {
+		return time.Duration(0), err
+	}
+
+	re, _ := regexp.Compile("offset (.*) sec")
+	submatched := re.FindSubmatch(output)
+	if len(submatched) != 2 {
+		return time.Duration(0), errors.New("invalid ntpdate output")
+	}
+
+	f, err := strconv.ParseFloat(string(submatched[1]), 64)
+	if err != nil {
+		return time.Duration(0), err
+	}
+	return time.Duration(f*1000) * time.Millisecond, nil
+}

v2/awsutil/awsutil.go

@@ -0,0 +1,6 @@
+FROM ubuntu:24.04
+
+ADD ./sonyflake_server /
+ENTRYPOINT ["/sonyflake_server"]
+
+EXPOSE 8080