types/logid: move logtail ID types here (#6336)

Many packages reference the logtail ID types,
but unfortunately pull in the transitive dependencies of logtail.
Fix this problem by putting the log ID types in its own package
with minimal dependencies.

Signed-off-by: Joe Tsai <joetsai@digital-static.net>

logtail/id.go

@@ -4,170 +4,25 @@
 
 package logtail
 
-import (
-	"crypto/rand"
-	"crypto/sha256"
-	"encoding/binary"
-	"encoding/hex"
-	"errors"
-	"fmt"
-)
+import "tailscale.com/types/logid"
 
-// PrivateID represents an instance that write logs.
-// Private IDs are only shared with the server when writing logs.
-type PrivateID [32]byte
+// Deprecated: Use "tailscale.com/types/logid".PrivateID instead.
+type PrivateID = logid.PrivateID
 
-// Safely generate a new PrivateId for use in Config objects.
-// You should persist this across runs of an instance of your app, so that
-// it can append to the same log file on each run.
-func NewPrivateID() (id PrivateID, err error) {
-	_, err = rand.Read(id[:])
-	if err != nil {
-		return PrivateID{}, err
-	}
-	// Clamping, for future use.
-	id[0] &= 248
-	id[31] = (id[31] & 127) | 64
-	return id, nil
+// Deprecated: Use "tailscale.com/types/logid".NewPrivateID instead.
+func NewPrivateID() (PrivateID, error) {
+	return logid.NewPrivateID()
 }
 
-func (id PrivateID) MarshalText() ([]byte, error) {
-	b := make([]byte, hex.EncodedLen(len(id)))
-	if i := hex.Encode(b, id[:]); i != len(b) {
-		return nil, fmt.Errorf("logtail.PrivateID.MarshalText: i=%d", i)
-	}
-	return b, nil
-}
-
-// ParsePrivateID returns a PrivateID from its hex (String) representation.
+// Deprecated: Use "tailscale.com/types/logid".ParsePrivateID instead.
 func ParsePrivateID(s string) (PrivateID, error) {
-	if len(s) != 64 {
-		return PrivateID{}, errors.New("invalid length")
-	}
-	var p PrivateID
-	for i := range p {
-		a, ok1 := fromHexChar(s[i*2+0])
-		b, ok2 := fromHexChar(s[i*2+1])
-		if !ok1 || !ok2 {
-			return PrivateID{}, errors.New("invalid hex character")
-		}
-		p[i] = (a << 4) | b
-	}
-	return p, nil
+	return logid.ParsePrivateID(s)
 }
 
-// IsZero reports whether id is the zero value.
-func (id PrivateID) IsZero() bool { return id == PrivateID{} }
+// Deprecated: Use "tailscale.com/types/logid".PublicID instead.
+type PublicID = logid.PublicID
 
-func (id *PrivateID) UnmarshalText(s []byte) error {
-	b, err := hex.DecodeString(string(s))
-	if err != nil {
-		return fmt.Errorf("logtail.PrivateID.UnmarshalText: %v", err)
-	}
-	if len(b) != len(id) {
-		return fmt.Errorf("logtail.PrivateID.UnmarshalText: invalid hex length: %d", len(b))
-	}
-	copy(id[:], b)
-	return nil
-}
-
-func (id PrivateID) String() string {
-	b, err := id.MarshalText()
-	if err != nil {
-		panic(err)
-	}
-	return string(b)
-}
-
-func (id PrivateID) Public() (pub PublicID) {
-	h := sha256.New()
-	h.Write(id[:])
-	if n := copy(pub[:], h.Sum(pub[:0])); n != len(pub) {
-		panic(fmt.Sprintf("public id short copy: %d", n))
-	}
-	return pub
-}
-
-// PublicID represents an instance in the logs service for reading and adoption.
-// The public ID value is a SHA-256 hash of a private ID.
-type PublicID [sha256.Size]byte
-
-// ParsePublicID returns a PublicID from its hex (String) representation.
+// Deprecated: Use "tailscale.com/types/logid".ParsePublicID instead.
 func ParsePublicID(s string) (PublicID, error) {
-	if len(s) != sha256.Size*2 {
-		return PublicID{}, errors.New("invalid length")
-	}
-	var p PublicID
-	for i := range p {
-		a, ok1 := fromHexChar(s[i*2+0])
-		b, ok2 := fromHexChar(s[i*2+1])
-		if !ok1 || !ok2 {
-			return PublicID{}, errors.New("invalid hex character")
-		}
-		p[i] = (a << 4) | b
-	}
-	return p, nil
-}
-
-func (id PublicID) MarshalText() ([]byte, error) {
-	b := make([]byte, hex.EncodedLen(len(id)))
-	if i := hex.Encode(b, id[:]); i != len(b) {
-		return nil, fmt.Errorf("logtail.PublicID.MarshalText: i=%d", i)
-	}
-	return b, nil
-}
-
-func (id *PublicID) UnmarshalText(s []byte) error {
-	if len(s) != len(id)*2 {
-		return fmt.Errorf("logtail.PublicID.UnmarshalText: invalid hex length: %d", len(s))
-	}
-	for i := range id {
-		a, ok1 := fromHexChar(s[i*2+0])
-		b, ok2 := fromHexChar(s[i*2+1])
-		if !ok1 || !ok2 {
-			return errors.New("invalid hex character")
-		}
-		id[i] = (a << 4) | b
-	}
-	return nil
-}
-
-func (id PublicID) String() string {
-	b, err := id.MarshalText()
-	if err != nil {
-		panic(err)
-	}
-	return string(b)
-}
-
-// fromHexChar converts a hex character into its value and a success flag.
-func fromHexChar(c byte) (byte, bool) {
-	switch {
-	case '0' <= c && c <= '9':
-		return c - '0', true
-	case 'a' <= c && c <= 'f':
-		return c - 'a' + 10, true
-	case 'A' <= c && c <= 'F':
-		return c - 'A' + 10, true
-	}
-
-	return 0, false
-}
-
-func (id1 PublicID) Less(id2 PublicID) bool {
-	for i, c1 := range id1[:] {
-		c2 := id2[i]
-		if c1 != c2 {
-			return c1 < c2
-		}
-	}
-	return false // equal
-}
-
-func (id PublicID) IsZero() bool {
-	return id == PublicID{}
-}
-
-func (id PublicID) Prefix64() uint64 {
-	return binary.BigEndian.Uint64(id[:8])
+	return logid.ParsePublicID(s)
 }

logtail/id_test.go

@@ -1,67 +0,0 @@
-// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package logtail
-
-import (
-	"testing"
-)
-
-func TestIDs(t *testing.T) {
-	id1, err := NewPrivateID()
-	if err != nil {
-		t.Fatal(err)
-	}
-	pub1 := id1.Public()
-
-	id2, err := NewPrivateID()
-	if err != nil {
-		t.Fatal(err)
-	}
-	pub2 := id2.Public()
-
-	if id1 == id2 {
-		t.Fatalf("subsequent private IDs match: %v", id1)
-	}
-	if pub1 == pub2 {
-		t.Fatalf("subsequent public IDs match: %v", id1)
-	}
-	if id1.String() == id2.String() {
-		t.Fatalf("id1.String()=%v equals id2.String()", id1.String())
-	}
-	if pub1.String() == pub2.String() {
-		t.Fatalf("pub1.String()=%v equals pub2.String()", pub1.String())
-	}
-
-	id1txt, err := id1.MarshalText()
-	if err != nil {
-		t.Fatal(err)
-	}
-	var id3 PrivateID
-	if err := id3.UnmarshalText(id1txt); err != nil {
-		t.Fatal(err)
-	}
-	if id1 != id3 {
-		t.Fatalf("id1 %v: marshal and unmarshal gives different key: %v", id1, id3)
-	}
-	if want, got := id1.Public(), id3.Public(); want != got {
-		t.Fatalf("id1.Public()=%v does not match id3.Public()=%v", want, got)
-	}
-	if id1.String() != id3.String() {
-		t.Fatalf("id1.String()=%v does not match id3.String()=%v", id1.String(), id3.String())
-	}
-	if id3, err := ParsePublicID(id1.Public().String()); err != nil {
-		t.Errorf("ParsePublicID: %v", err)
-	} else if id1.Public() != id3 {
-		t.Errorf("ParsePublicID mismatch")
-	}
-
-	id4, err := ParsePrivateID(id1.String())
-	if err != nil {
-		t.Fatalf("failed to ParsePrivateID(%q): %v", id1.String(), err)
-	}
-	if id1 != id4 {
-		t.Fatalf("ParsePrivateID returned different id")
-	}
-}