func main() {
defer common.LogPanic()
common.Init()
args := flag.Args()
if len(args) != 2 {
flag.Usage()
os.Exit(1)
}
bucket, prefix := args[0], args[1]
v, err := skiaversion.GetVersion()
if err != nil {
glog.Fatal(err)
}
glog.Infof("Version %s, built at %s", v.Commit, v.Date)
if *nsqdAddress == "" {
glog.Fatal("Missing address of nsqd server.")
}
globalEventBus, err := geventbus.NewNSQEventBus(*nsqdAddress)
if err != nil {
glog.Fatalf("Unable to connect to NSQ server: %s", err)
}
eventBus := eventbus.New(globalEventBus)
eventBus.SubscribeAsync(event.StorageEvent(bucket, prefix), func(evData interface{}) {
data := evData.(*event.GoogleStorageEventData)
glog.Infof("Google Storage notification from bucket\n %s: %s : %s", data.Updated, data.Bucket, data.Name)
})
select {}
}
func main() {
common.Init()
v, err := skiaversion.GetVersion()
if err != nil {
glog.Fatal(err)
}
glog.Infof("Version %s, built at %s", v.Commit, v.Date)
if *nsqdAddress == "" {
glog.Fatal("Missing address of nsqd server.")
}
globalEventBus, err := geventbus.NewNSQEventBus(*nsqdAddress)
if err != nil {
glog.Fatalf("Unable to connect to NSQ server: %s", err)
}
eventBus := eventbus.New(globalEventBus)
eventBus.SubscribeAsync(event.GLOBAL_GOOGLE_STORAGE, func(evData interface{}) {
data := evData.(*event.GoogleStorageEventData)
glog.Infof("Google Storage notification from bucket\n %s: %s : %s", data.Updated, data.Bucket, data.Name)
})
select {}
}
func main() {
common.Init()
v, err := skiaversion.GetVersion()
if err != nil {
glog.Fatal(err)
}
glog.Infof("Version %s, built at %s", v.Commit, v.Date)
if *nsqdAddress == "" {
glog.Fatal("Missing address of nsqd server.")
}
globalEventBus, err := geventbus.NewNSQEventBus(*nsqdAddress)
if err != nil {
glog.Fatalf("Unable to connect to NSQ server: %s", err)
}
eventBus := eventbus.New(globalEventBus)
// Send events every so often.
for _ = range time.Tick(2 * time.Second) {
evData := &event.GoogleStorageEventData{
Bucket: "test-bucket",
Name: "test-name",
Updated: time.Now().String(),
}
eventBus.Publish(event.GLOBAL_GOOGLE_STORAGE, evData)
glog.Infof("Sent Event: %#v ", evData)
}
}
func main() {
defer common.LogPanic()
common.InitWithMetrics("grandcentral", graphiteServer)
v, err := skiaversion.GetVersion()
if err != nil {
glog.Fatal(err)
}
glog.Infof("Version %s, built at %s", v.Commit, v.Date)
if *nsqdAddress == "" {
glog.Fatal("Missing address of nsqd server.")
}
globalEventBus, err := geventbus.NewNSQEventBus(*nsqdAddress)
if err != nil {
glog.Fatalf("Unable to connect to NSQ server: %s", err)
}
eventBus = eventbus.New(globalEventBus)
if *testing {
*useMetadata = false
}
serverURL := "https://" + *host
if *testing {
serverURL = "http://" + *host + *port
}
runServer(serverURL)
}
func main() {
defer common.LogPanic()
common.InitWithMetrics("grandcentral", graphiteServer)
v, err := skiaversion.GetVersion()
if err != nil {
glog.Fatal(err)
}
glog.Infof("Version %s, built at %s", v.Commit, v.Date)
if *nsqdAddress == "" {
glog.Fatal("Missing address of nsqd server.")
}
globalEventBus, err := geventbus.NewNSQEventBus(*nsqdAddress)
if err != nil {
glog.Fatalf("Unable to connect to NSQ server: %s", err)
}
eventBus = eventbus.New(globalEventBus)
// Add a subscription for the each event type. This prevents the messages
// to queue up if there are no other clients connected.
eventBus.SubscribeAsync(event.GLOBAL_GOOGLE_STORAGE, func(evData interface{}) {})
eventBus.SubscribeAsync(event.GLOBAL_BUILDBOT, func(evData interface{}) {})
if *testing {
*useMetadata = false
}
serverURL := "https://" + *host
if *testing {
serverURL = "http://" + *host + *port
}
runServer(serverURL)
}
func TestEventBusGlobally(t *testing.T) {
testutils.SkipIfShort(t)
globalEventBus, err := geventbus.NewNSQEventBus(NSQD_ADDR)
assert.Nil(t, err)
secondGlobalBus, err := geventbus.NewNSQEventBus(NSQD_ADDR)
assert.Nil(t, err)
eventBus := New(globalEventBus)
ch := make(chan interface{}, 100)
eventBus.SubscribeAsync(GLOBAL_TOPIC, func(e interface{}) { ch <- e })
secondCh := make(chan interface{}, 100)
errCh := make(chan error, 100)
assert.Nil(t, secondGlobalBus.SubscribeAsync(GLOBAL_TOPIC, geventbus.JSONCallback(&testType{}, func(data interface{}, err error) {
if err != nil {
errCh <- err
} else {
secondCh <- data
}
})))
eventBus.Publish(GLOBAL_TOPIC, &testType{0, "message-1"})
eventBus.Publish(GLOBAL_TOPIC, &testType{1, "message-2"})
eventBus.Publish(GLOBAL_TOPIC, &testType{2, "message-3"})
eventBus.Publish(GLOBAL_TOPIC, &testType{3, "message-4"})
time.Sleep(5 * time.Second)
assert.Equal(t, 4, len(ch))
assert.Equal(t, 4, len(secondCh))
close(ch)
close(secondCh)
found := map[int]bool{}
for m := range ch {
assert.IsType(t, &testType{}, m)
temp := m.(*testType)
assert.False(t, found[temp.ID])
found[temp.ID] = true
}
for m := range secondCh {
assert.IsType(t, &testType{}, m)
}
}
func TestEventBusGlobally(t *testing.T) {
testutils.SkipIfShort(t)
messages := []*testType{
&testType{0, "message-1"},
&testType{1, "message-2"},
&testType{2, "message-3"},
&testType{3, "message-4"},
}
globalEventBus, err := geventbus.NewNSQEventBus(NSQD_ADDR)
assert.Nil(t, err)
secondGlobalBus, err := geventbus.NewNSQEventBus(NSQD_ADDR)
assert.Nil(t, err)
// Use atomic ints to sync the callback functions.
firstMap := newAtomicMap()
firstEventBus := New(globalEventBus)
firstEventBus.SubscribeAsync(GLOBAL_TOPIC, func(e interface{}) {
data := e.(*testType)
if data.ID == SYNC_MSG {
firstMap.setReady()
return
}
firstMap.Add(data.ID, data)
})
secondMap := newAtomicMap()
errCh := make(chan error, 100)
assert.Nil(t, secondGlobalBus.SubscribeAsync(GLOBAL_TOPIC, geventbus.JSONCallback(&testType{}, func(data interface{}, err error) {
if err != nil {
errCh <- err
return
}
if data.(*testType).ID == SYNC_MSG {
secondMap.setReady()
return
}
d := data.(*testType)
secondMap.Add(d.ID, d)
})))
for !firstMap.isReady() && !secondMap.isReady() {
firstEventBus.Publish(GLOBAL_TOPIC, &testType{SYNC_MSG, "ignore"})
}
for _, m := range messages {
firstEventBus.Publish(GLOBAL_TOPIC, m)
}
lmsg := len(messages)
for ((firstMap.Len() < lmsg) || (secondMap.Len() < lmsg)) && (len(errCh) == 0) {
time.Sleep(time.Millisecond * 10)
}
if len(errCh) > 0 {
close(errCh)
for err = range errCh {
fmt.Printf("Error: %s\n", err)
}
assert.FailNow(t, "Received too many error messages.")
}
}
