basic pub and sub works!

weed/messaging/broker/topic_lock.go

@@ -1,9 +1,13 @@
 package broker
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
+	"github.com/chrislusf/seaweedfs/weed/filer2"
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/messaging_pb"
 	"github.com/chrislusf/seaweedfs/weed/util/log_buffer"
 )
 
@@ -14,6 +18,7 @@ type TopicPartition struct {
 }
 type TopicLock struct {
 	sync.Mutex
+	cond *sync.Cond
 	subscriberCount int
 	publisherCount  int
 	logBuffer       *log_buffer.LogBuffer
@@ -21,44 +26,56 @@ type TopicLock struct {
 
 type TopicLocks struct {
 	sync.Mutex
-	locks map[TopicPartition]*TopicLock
+	locks  map[TopicPartition]*TopicLock
+	broker *MessageBroker
 }
 
-func NewTopicLocks() *TopicLocks {
+func NewTopicLocks(messageBroker *MessageBroker) *TopicLocks {
 	return &TopicLocks{
-		locks: make(map[TopicPartition]*TopicLock),
+		locks:  make(map[TopicPartition]*TopicLock),
+		broker: messageBroker,
 	}
 }
 
-func (tl *TopicLocks) RequestSubscriberLock(partition TopicPartition) *TopicLock {
-	tl.Lock()
-	defer tl.Unlock()
+func (locks *TopicLocks) buildLogBuffer(tl *TopicLock, tp TopicPartition, topicConfig *messaging_pb.TopicConfiguration) *log_buffer.LogBuffer {
 
-	lock, found := tl.locks[partition]
-	if !found {
-		lock = &TopicLock{}
-		tl.locks[partition] = lock
+	flushFn := func(startTime, stopTime time.Time, buf []byte) {
+
+		targetFile := fmt.Sprintf(
+			"%s/%s/%s/%04d-%02d-%02d/%02d-%02d.part%02d",
+			filer2.TopicsDir, tp.Namespace, tp.Topic,
+			startTime.Year(), startTime.Month(), startTime.Day(), startTime.Hour(), startTime.Minute(),
+			tp.Partition,
+		)
+
+		if err := locks.broker.appendToFile(targetFile, topicConfig, buf); err != nil {
+			glog.V(0).Infof("log write failed %s: %v", targetFile, err)
+		}
 	}
-	lock.subscriberCount++
-
-	return lock
-}
-
-func (tl *TopicLocks) RequestPublisherLock(partition TopicPartition, flushFn func(startTime, stopTime time.Time, buf []byte)) *log_buffer.LogBuffer {
-	tl.Lock()
-	defer tl.Unlock()
-
-	lock, found := tl.locks[partition]
-	if !found {
-		lock = &TopicLock{}
-		tl.locks[partition] = lock
-	}
-	lock.publisherCount++
-	cond := sync.NewCond(&lock.Mutex)
-	lock.logBuffer = log_buffer.NewLogBuffer(time.Minute, flushFn, func() {
-		cond.Broadcast()
+	logBuffer := log_buffer.NewLogBuffer(time.Minute, flushFn, func() {
+		tl.cond.Broadcast()
 	})
-	return lock.logBuffer
+
+	return logBuffer
+}
+
+func (tl *TopicLocks) RequestLock(partition TopicPartition, topicConfig *messaging_pb.TopicConfiguration, isPublisher bool) *TopicLock {
+	tl.Lock()
+	defer tl.Unlock()
+
+	lock, found := tl.locks[partition]
+	if !found {
+		lock = &TopicLock{}
+		lock.cond = sync.NewCond(&lock.Mutex)
+		tl.locks[partition] = lock
+		lock.logBuffer = tl.buildLogBuffer(lock, partition, topicConfig)
+	}
+	if isPublisher {
+		lock.publisherCount++
+	} else {
+		lock.subscriberCount++
+	}
+	return lock
 }
 
 func (tl *TopicLocks) ReleaseLock(partition TopicPartition, isPublisher bool) {