Replace all occurences of "interface{}" with "any"

Author: NicoBiernat

TODO.md

@@ -13,6 +13,7 @@
 - DONE: save current state of resources before terminating (or even periodically)
 - DONE: load last state of resources at startup
 - DONE: LINK operation to link a resource to another resource
+- DONE: replace all occurences of "interface{}" with "any"
 
 - IMPORTANT/DIFFICULT: websocket timeout after some time of no or only invalid, or unauthorized request
 - IMPORTANT/EASY-MEDIUM: change STREAM behavior: allow multiple streams of same resource but with different REID
@@ -21,7 +22,6 @@
 
 - UNIMPORTANT/MEDIUM-DIFFICULT: overhaul interface to heimdall (redis seems unergonomic and clunky), maybe use http endpoint in heimdall to check authentication and cache the result
 - UNIMPORTANT/MEDIUM: overhaul snapshotting (make it more robust, maybe change "gob" AND "msgpack" to just "msgpack" -> cannot differentiate between directory and resource content)
-- UNIMPORTANT/EASY: replace all occurences of "interface{}" with "any"
 - UNIMPORTANT/MEDIUM: export prometheus metrics
 - UNIMPORTANT/DIFFICULT: fine grained access control
 

auth/jwt/authentication.go

@@ -16,8 +16,8 @@ var (
 // --- JWT Authentication ---
 
 // ValidateJWT parses and validates an HMAC signed JWT and returns its claims or an error if invalid
-func ValidateJWT(tokenStr string) (map[string]interface{}, error) {
-	token, err := jwt.Parse(tokenStr, func(token *jwt.Token) (interface{}, error) {
+func ValidateJWT(tokenStr string) (map[string]any, error) {
+	token, err := jwt.Parse(tokenStr, func(token *jwt.Token) (any, error) {
 		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
 		}

directory/directory.go

@@ -33,7 +33,7 @@ type Directory interface {
 	ForEach(f func(resource.Resource) (bool, error)) error
 
 	// Returns the directory structure as a nested map
-	List(path []string) (map[string]interface{}, error)
+	List(path []string) (map[string]any, error)
 
 	// Takes a snapshot of a directory
 	Snapshot(path []string, writer io.Writer) error

directory/tree/tree.go

@@ -253,7 +253,7 @@ func forEach(t tree, f func(resource.Resource) (bool, error)) (err error) {
 
 // List lists the contents of a directory by returning a recursively nested map of subdirectories.
 // A resource is indicated by a nil value.
-func (d *directory) List(path []string) (map[string]interface{}, error) {
+func (d *directory) List(path []string) (map[string]any, error) {
 	d.lock.RLock()
 	defer d.lock.RUnlock()
 
@@ -268,8 +268,8 @@ func (d *directory) List(path []string) (map[string]interface{}, error) {
 	return m, nil
 }
 
-func list(n *node, includeContent bool) (map[string]interface{}, error) {
-	result := make(map[string]interface{})
+func list(n *node, includeContent bool) (map[string]any, error) {
+	result := make(map[string]any)
 	for k, v := range n.entries {
 		switch x := v.(type) {
 		case *leaf:
@@ -296,7 +296,7 @@ func list(n *node, includeContent bool) (map[string]interface{}, error) {
 // We therefore use MsgPack to marshal the resource contents (in order to keep full MsgPack compatibility)
 // and then gob (Go's binary encoding) to marshal the directory tree.
 // Restoring from a snapshot does the same thing in reverse: First decode with gob and then decode the resources with msgpack.
-// Note: shamaton/msgpack library decodes map[string]interface{} as map[interface{}]interface{} -> switched to vmihailenco/msgpack
+// Note: shamaton/msgpack library decodes map[string]any as map[any]any -> switched to vmihailenco/msgpack
 
 // Snapshot takes a snapshot of a directory (including the resource contents), serializes and writes it to the io.Writer.
 func (d *directory) Snapshot(path []string, writer io.Writer) error {
@@ -306,7 +306,7 @@ func (d *directory) Snapshot(path []string, writer io.Writer) error {
 	if err != nil {
 		return err
 	}
-	gob.Register(map[string]interface{}{})
+	gob.Register(map[string]any{})
 	enc := gob.NewEncoder(writer)
 	m, err := list(n, true)
 	if err != nil {
@@ -322,8 +322,8 @@ func (d *directory) Restore(path []string, reader io.Reader) error {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
-	var m map[string]interface{}
-	gob.Register(map[string]interface{}{})
+	var m map[string]any
+	gob.Register(map[string]any{})
 	dec := gob.NewDecoder(reader)
 	err := dec.Decode(&m)
 	if err != nil {
@@ -332,10 +332,10 @@ func (d *directory) Restore(path []string, reader io.Reader) error {
 	return restore(d, path, m)
 }
 
-func restore(d *directory, path []string, m map[string]interface{}) error {
+func restore(d *directory, path []string, m map[string]any) error {
 	for k, v := range m {
 		switch x := v.(type) {
-		case map[string]interface{}:
+		case map[string]any:
 			p := append(path, k)
 			_, err := d.getDirectory(p, true)
 			if err != nil {

handler/handler.go

@@ -42,7 +42,7 @@ func (handler *Handler) Close() {
 }
 
 func (handler *Handler) Disconnect(client *types.Client) {
-	client.ForEachStream(func(path []string, ch chan interface{}) {
+	client.ForEachStream(func(path []string, ch chan any) {
 		resource, err := handler.directory.GetResource(path)
 		if err != nil {
 			return

resource/broker/broker.go

@@ -32,33 +32,33 @@ var (
 type broker struct {
 	path []string // resource path
 
-	input   chan inputMsg                // input channel (only for PUT)
-	control chan controlMsg              // control channel (for everything else than PUT)
-	streams map[chan interface{}]bool    // keeps track of active subscriber streams (value indicates whether the channel is infinite->blocking-send or finite->non-blocking-send)
-	links   map[*broker]chan interface{} // keeps track of active links from other resources
+	input   chan inputMsg        // input channel (only for PUT)
+	control chan controlMsg      // control channel (for everything else than PUT)
+	streams map[chan any]bool    // keeps track of active subscriber streams (value indicates whether the channel is infinite->blocking-send or finite->non-blocking-send)
+	links   map[*broker]chan any // keeps track of active links from other resources
 
-	value     interface{} // latest input value
+	value     any // latest input value
 	valueLock sync.RWMutex
 }
 
 var _ resource.Resource = (*broker)(nil) // ensure resource implements Resource
 
 // Message sent through input channel
 type inputMsg struct { // PUT
-	Content      interface{}
+	Content      any
 	ResponseChan chan resource.Response
 }
 
 // Message sent through control channel
 type controlMsg struct {
 	Type         controlMsgType // enum - see const
-	Content      interface{}
+	Content      any
 	ResponseChan chan resource.Response
 }
 
 // Content for STREAM controlMsg
 type streamContent struct {
-	channel  chan interface{}
+	channel  chan any
 	infinite bool
 }
 
@@ -72,8 +72,8 @@ func Create(path []string) resource.Resource {
 		input:   make(chan inputMsg, inputChanSize),
 		control: make(chan controlMsg, controlChanSize),
 
-		streams: make(map[chan interface{}]bool),
-		links:   make(map[*broker]chan interface{}),
+		streams: make(map[chan any]bool),
+		links:   make(map[*broker]chan any),
 
 		value:     msgp.Raw{},
 		valueLock: sync.RWMutex{},
@@ -99,7 +99,7 @@ func (r *broker) monitor() {
 	}
 }
 
-func nonBlockingSend(c chan interface{}, v interface{}) bool {
+func nonBlockingSend(c chan any, v any) bool {
 	select {
 	case c <- v:
 		return true
@@ -157,7 +157,7 @@ func (r *broker) broker() {
 				controlMsg.ResponseChan <- resource.Response{Code: 200, Err: nil}
 
 			case STOP:
-				stream := controlMsg.Content.(chan interface{})
+				stream := controlMsg.Content.(chan any)
 				_, ok := r.streams[stream]
 				if !ok {
 					controlMsg.ResponseChan <- resource.Response{Code: 404, Err: errors.New("the stream does not exist and therefore cannot be closed")}
@@ -211,16 +211,16 @@ func (r *broker) Close() resource.Response {
 
 // Stream subscribes to this resource.
 // This returns a new channel where all updates to this resource will be sent to.
-func (r *broker) Stream() (chan interface{}, resource.Response) {
-	stream := make(chan interface{}, streamChanSize)
+func (r *broker) Stream() (chan any, resource.Response) {
+	stream := make(chan any, streamChanSize)
 	respChan := make(chan resource.Response)
 	defer close(respChan)
 	r.control <- controlMsg{Type: STREAM, Content: streamContent{stream, false}, ResponseChan: respChan}
 	return stream, <-respChan
 }
 
 // TODO: change interface sucht that this method can be used
-func (r *broker) StreamWithGuaranteedDelivery() (chan interface{}, resource.Response) {
+func (r *broker) StreamWithGuaranteedDelivery() (chan any, resource.Response) {
 	streamIn, streamOut := makeInfinite()
 	respChan := make(chan resource.Response)
 	defer close(respChan)
@@ -230,23 +230,23 @@ func (r *broker) StreamWithGuaranteedDelivery() (chan interface{}, resource.Resp
 
 // StopStream unsubscribes from this resource.
 // The channel created by Stream() needs to be passed
-func (r *broker) StopStream(stream chan interface{}) resource.Response {
+func (r *broker) StopStream(stream chan any) resource.Response {
 	respChan := make(chan resource.Response)
 	defer close(respChan)
 	r.control <- controlMsg{Type: STOP, Content: stream, ResponseChan: respChan}
 	return <-respChan
 }
 
 // Put updates the value of this resource.
-func (r *broker) Put(payload interface{}) resource.Response {
+func (r *broker) Put(payload any) resource.Response {
 	respChan := make(chan resource.Response)
 	defer close(respChan)
 	r.input <- inputMsg{Content: payload, ResponseChan: respChan}
 	return <-respChan
 }
 
 // Get returns the current (latest written) value of this resource
-func (r *broker) Get() (interface{}, resource.Response) {
+func (r *broker) Get() (any, resource.Response) {
 	r.valueLock.RLock()
 	defer r.valueLock.RUnlock()
 	return r.value, resource.Response{Code: 200, Err: nil}
@@ -289,18 +289,18 @@ func (r *broker) isLinkedBy(other *broker) bool {
 }
 
 // Makes an infinite channel by using a slice and a goroutine
-func makeInfinite() (in chan interface{}, out chan interface{}) {
-	in = make(chan interface{}, streamChanSize)
-	out = make(chan interface{}, streamChanSize)
+func makeInfinite() (in chan any, out chan any) {
+	in = make(chan any, streamChanSize)
+	out = make(chan any, streamChanSize)
 	go func() {
-		var inQ []interface{}
-		outC := func() chan interface{} {
+		var inQ []any
+		outC := func() chan any {
 			if len(inQ) == 0 {
 				return nil
 			}
 			return out
 		}
-		curVal := func() interface{} {
+		curVal := func() any {
 			if len(inQ) == 0 {
 				return nil
 			}

resource/brokerless/brokerless.go

@@ -63,14 +63,14 @@ func (r *brokerless) Close() resource.Response {
 }
 
 // Get implements resource.Resource.
-func (r *brokerless) Get() (interface{}, resource.Response) {
+func (r *brokerless) Get() (any, resource.Response) {
 	r.valueLock.RLock()
 	defer r.valueLock.RUnlock()
 	return r.value, resource.Response{Code: 200, Err: nil}
 }
 
 // Put implements resource.Resource.
-func (r *brokerless) Put(value interface{}) resource.Response {
+func (r *brokerless) Put(value any) resource.Response {
 	r.valueLock.Lock()
 	r.value = value
 	r.valueLock.Unlock()
@@ -92,7 +92,7 @@ func (r *brokerless) Put(value interface{}) resource.Response {
 }
 
 // Stream implements resource.Resource.
-func (r *brokerless) Stream() (chan interface{}, resource.Response) {
+func (r *brokerless) Stream() (chan any, resource.Response) {
 	r.streamsLock.Lock()
 	defer r.streamsLock.Unlock()
 
@@ -102,7 +102,7 @@ func (r *brokerless) Stream() (chan interface{}, resource.Response) {
 }
 
 // StopStream implements resource.Resource.
-func (r *brokerless) StopStream(stream chan interface{}) resource.Response {
+func (r *brokerless) StopStream(stream chan any) resource.Response {
 	r.streamsLock.Lock()
 	defer r.streamsLock.Unlock()
 

resource/resource.go

@@ -1,20 +1,20 @@
 package resource
 
 type Resource interface {
-	Stream() (chan interface{}, Response)
-	StopStream(chan interface{}) Response
-	Put(interface{}) Response
-	Get() (interface{}, Response)
+	Stream() (chan any, Response)
+	StopStream(chan any) Response
+	Put(any) Response
+	Get() (any, Response)
 	Link(Resource) Response
 	UnLink(Resource) Response
 	Close() Response
 }
 
-// type Channel chan interface{}
+// type Channel chan any
 
 // type Channel interface {
-// 	Write(interface{})
-// 	Read() (interface{}, bool)
+// 	Write(any)
+// 	Read() (any, bool)
 // 	Close()
 // }
 

resource/resource_test.go

@@ -313,7 +313,7 @@ func TestLinkUnLinkStreamPut(t *testing.T) {
 
 func TestStopStreamInvalid(t *testing.T) {
 	testResource := resource.Create([]string{})
-	stream := make(chan interface{})
+	stream := make(chan any)
 	resp := testResource.StopStream(stream)
 	if resp.Err == nil {
 		t.Fatalf("Expected error, got nil")

types/client.go

@@ -9,7 +9,7 @@ type Client struct {
 
 type stream struct {
 	path    []string
-	channel chan interface{}
+	channel chan any
 }
 
 func NewClient(send func(*Response) error) *Client {
@@ -19,14 +19,14 @@ func NewClient(send func(*Response) error) *Client {
 	}
 }
 
-func (c *Client) AddStream(path []string, ch chan interface{}) {
+func (c *Client) AddStream(path []string, ch chan any) {
 	c.streams = append(c.streams, stream{
 		path:    path,
 		channel: ch,
 	})
 }
 
-func (c *Client) GetStream(path []string) chan interface{} {
+func (c *Client) GetStream(path []string) chan any {
 	for _, s := range c.streams {
 		if equals(s.path, path) {
 			return s.channel
@@ -52,7 +52,7 @@ func (c *Client) RemoveStream(path []string) {
 	c.streams = c.streams[:len(c.streams)-1]
 }
 
-func (c *Client) ForEachStream(f func(path []string, ch chan interface{})) {
+func (c *Client) ForEachStream(f func(path []string, ch chan any)) {
 	for _, s := range c.streams {
 		f(s.path, s.channel)
 	}