rename all remaining packages to internal/ (#12418)

This is to ensure that there are no projects
that try to import `minio/minio/pkg` into
their own repo. Any such common packages should
go to `https://github.com/minio/pkg`

internal/pubsub/pubsub.go

@@ -0,0 +1,87 @@
+// Copyright (c) 2015-2021 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package pubsub
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// Sub - subscriber entity.
+type Sub struct {
+	ch     chan interface{}
+	filter func(entry interface{}) bool
+}
+
+// PubSub holds publishers and subscribers
+type PubSub struct {
+	subs           []*Sub
+	numSubscribers int32
+	sync.RWMutex
+}
+
+// Publish message to the subscribers.
+// Note that publish is always nob-blocking send so that we don't block on slow receivers.
+// Hence receivers should use buffered channel so as not to miss the published events.
+func (ps *PubSub) Publish(item interface{}) {
+	ps.RLock()
+	defer ps.RUnlock()
+
+	for _, sub := range ps.subs {
+		if sub.filter == nil || sub.filter(item) {
+			select {
+			case sub.ch <- item:
+			default:
+			}
+		}
+	}
+}
+
+// Subscribe - Adds a subscriber to pubsub system
+func (ps *PubSub) Subscribe(subCh chan interface{}, doneCh <-chan struct{}, filter func(entry interface{}) bool) {
+	ps.Lock()
+	defer ps.Unlock()
+
+	sub := &Sub{subCh, filter}
+	ps.subs = append(ps.subs, sub)
+	atomic.AddInt32(&ps.numSubscribers, 1)
+
+	go func() {
+		<-doneCh
+
+		ps.Lock()
+		defer ps.Unlock()
+
+		for i, s := range ps.subs {
+			if s == sub {
+				ps.subs = append(ps.subs[:i], ps.subs[i+1:]...)
+			}
+		}
+		atomic.AddInt32(&ps.numSubscribers, -1)
+	}()
+}
+
+// NumSubscribers returns the number of current subscribers
+func (ps *PubSub) NumSubscribers() int32 {
+	return atomic.LoadInt32(&ps.numSubscribers)
+}
+
+// New inits a PubSub system
+func New() *PubSub {
+	return &PubSub{}
+}

internal/pubsub/pubsub_test.go

@@ -0,0 +1,91 @@
+// Copyright (c) 2015-2021 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package pubsub
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestSubscribe(t *testing.T) {
+	ps := New()
+	ch1 := make(chan interface{}, 1)
+	ch2 := make(chan interface{}, 1)
+	doneCh := make(chan struct{})
+	defer close(doneCh)
+	ps.Subscribe(ch1, doneCh, nil)
+	ps.Subscribe(ch2, doneCh, nil)
+	ps.Lock()
+	defer ps.Unlock()
+	if len(ps.subs) != 2 {
+		t.Errorf("expected 2 subscribers")
+	}
+}
+
+func TestUnsubscribe(t *testing.T) {
+	ps := New()
+	ch1 := make(chan interface{}, 1)
+	ch2 := make(chan interface{}, 1)
+	doneCh1 := make(chan struct{})
+	doneCh2 := make(chan struct{})
+	ps.Subscribe(ch1, doneCh1, nil)
+	ps.Subscribe(ch2, doneCh2, nil)
+
+	close(doneCh1)
+	// Allow for the above statement to take effect.
+	time.Sleep(100 * time.Millisecond)
+	ps.Lock()
+	if len(ps.subs) != 1 {
+		t.Errorf("expected 1 subscriber")
+	}
+	ps.Unlock()
+	close(doneCh2)
+}
+
+func TestPubSub(t *testing.T) {
+	ps := New()
+	ch1 := make(chan interface{}, 1)
+	doneCh1 := make(chan struct{})
+	defer close(doneCh1)
+	ps.Subscribe(ch1, doneCh1, func(entry interface{}) bool { return true })
+	val := "hello"
+	ps.Publish(val)
+	msg := <-ch1
+	if msg != "hello" {
+		t.Errorf(fmt.Sprintf("expected %s , found %s", val, msg))
+	}
+}
+
+func TestMultiPubSub(t *testing.T) {
+	ps := New()
+	ch1 := make(chan interface{}, 1)
+	ch2 := make(chan interface{}, 1)
+	doneCh := make(chan struct{})
+	defer close(doneCh)
+	ps.Subscribe(ch1, doneCh, func(entry interface{}) bool { return true })
+	ps.Subscribe(ch2, doneCh, func(entry interface{}) bool { return true })
+	val := "hello"
+	ps.Publish(val)
+
+	msg1 := <-ch1
+	msg2 := <-ch2
+	if msg1 != "hello" && msg2 != "hello" {
+		t.Errorf(fmt.Sprintf("expected both subscribers to have%s , found %s and  %s", val, msg1, msg2))
+	}
+}