Updated main.go to have 2 divisions in an event, and fixed event.go to check child.Parent() instead of event.Parent()

event.go

@@ -132,9 +132,11 @@ func AddChild(event Event, child Event, info EventInfo) error {
   }
 
   event.LockParent()
-  if event.Parent() != nil {
+  child.LockParent()
+  if child.Parent() != nil {
+    child.UnlockParent()
     event.UnlockParent()
-    return errors.New("Parent already registered")
+    return errors.New(fmt.Sprintf("Parent already registered: %s->%s already %s", child.Name(), event.Name(), event.Parent().Name()))
   }
 
   event.LockChildren()
@@ -142,6 +144,7 @@ func AddChild(event Event, child Event, info EventInfo) error {
   for _, c := range(event.Children()) {
     if c.ID() == child.ID() {
       event.UnlockChildren()
+      child.UnlockParent()
       event.UnlockParent()
       return errors.New("Child already in event")
     }
@@ -152,6 +155,7 @@ func AddChild(event Event, child Event, info EventInfo) error {
   event.addChild(child, info)
 
   event.UnlockChildren()
+  child.UnlockParent()
   event.UnlockParent()
 
   update := NewSignal(event, "child_added")

main.go

@@ -1,9 +1,7 @@
 package main
 
 import (
-  "runtime/pprof"
   "time"
-  "os"
 )
 
 func fake_team(org string, id string, names []string) (*Team, []*Member) {
@@ -15,10 +13,10 @@ func fake_team(org string, id string, names []string) (*Team, []*Member) {
   return team, members
 }
 
-func fake_data() (* EventManager, *Arena, *Arena) {
+func fake_data() (* EventManager, []*Arena, []*Arena) {
   resources := []Resource{}
 
-  teams := []*Team{}
+  teams_div1 := []*Team{}
   t1,  m1  := fake_team("6659", "A", []string{"jimmy"})
   t2,  m2  := fake_team("6659", "B", []string{"timmy"})
   t3,  m3  := fake_team("6659", "C", []string{"grace"})
@@ -27,31 +25,32 @@ func fake_data() (* EventManager, *Arena, *Arena) {
   t6,  m6  := fake_team("210",  "X", []string{"toby"})
   t7,  m7  := fake_team("210",  "Y", []string{"jennifer"})
   t8,  m8  := fake_team("210",  "Z", []string{"emily"})
-  //t9,  m9  := fake_team("666",  "A", []string{"jimmy"})
+  teams_div2 := []*Team{}
-  //t10, m10 := fake_team("666",  "B", []string{"timmy"})
+  t9,  m9  := fake_team("666",  "A", []string{"jimmy"})
-  //t11, m11 := fake_team("666",  "C", []string{"grace"})
+  t10, m10 := fake_team("666",  "B", []string{"timmy"})
-  //t12, m12 := fake_team("666",  "D", []string{"jeremy"})
+  t11, m11 := fake_team("666",  "C", []string{"grace"})
-  //t13, m13 := fake_team("315",  "W", []string{"bobby"})
+  t12, m12 := fake_team("666",  "D", []string{"jeremy"})
-  //t14, m14 := fake_team("315",  "X", []string{"toby"})
+  t13, m13 := fake_team("315",  "W", []string{"bobby"})
-  //t15, m15 := fake_team("315",  "Y", []string{"jennifer"})
+  t14, m14 := fake_team("315",  "X", []string{"toby"})
-  //t16, m16 := fake_team("315",  "Z", []string{"emily"})
+  t15, m15 := fake_team("315",  "Y", []string{"jennifer"})
-
+  t16, m16 := fake_team("315",  "Z", []string{"emily"})
-  teams = append(teams, t1)
+
-  teams = append(teams, t2)
+  teams_div1 = append(teams_div1, t1)
-  teams = append(teams, t3)
+  teams_div1 = append(teams_div1, t2)
-  teams = append(teams, t4)
+  teams_div1 = append(teams_div1, t3)
-  teams = append(teams, t5)
+  teams_div1 = append(teams_div1, t4)
-  teams = append(teams, t6)
+  teams_div1 = append(teams_div1, t5)
-  teams = append(teams, t7)
+  teams_div1 = append(teams_div1, t6)
-  teams = append(teams, t8)
+  teams_div1 = append(teams_div1, t7)
-  //teams = append(teams, t9)
+  teams_div1 = append(teams_div1, t8)
-  //teams = append(teams, t10)
+  teams_div2 = append(teams_div2, t9)
-  //teams = append(teams, t11)
+  teams_div2 = append(teams_div2, t10)
-  //teams = append(teams, t12)
+  teams_div2 = append(teams_div2, t11)
-  //teams = append(teams, t13)
+  teams_div2 = append(teams_div2, t12)
-  //teams = append(teams, t14)
+  teams_div2 = append(teams_div2, t13)
-  //teams = append(teams, t15)
+  teams_div2 = append(teams_div2, t14)
-  //teams = append(teams, t16)
+  teams_div2 = append(teams_div2, t15)
+  teams_div2 = append(teams_div2, t16)
 
   resources = append(resources, m1[0])
   resources = append(resources, m2[0])
@@ -61,50 +60,98 @@ func fake_data() (* EventManager, *Arena, *Arena) {
   resources = append(resources, m6[0])
   resources = append(resources, m7[0])
   resources = append(resources, m8[0])
-  //resources = append(resources, m9[0])
+  resources = append(resources, m9[0])
-  //resources = append(resources, m10[0])
+  resources = append(resources, m10[0])
-  //resources = append(resources, m11[0])
+  resources = append(resources, m11[0])
-  //resources = append(resources, m12[0])
+  resources = append(resources, m12[0])
-  //resources = append(resources, m13[0])
+  resources = append(resources, m13[0])
-  //resources = append(resources, m14[0])
+  resources = append(resources, m14[0])
-  //resources = append(resources, m15[0])
+  resources = append(resources, m15[0])
-  //resources = append(resources, m16[0])
+  resources = append(resources, m16[0])
-
+
-  arenas := []*Arena{}
+  arenas_div1 := []*Arena{}
-  arenas = append(arenas, NewVirtualArena("Arena 1"))
+  arenas_div1 = append(arenas_div1, NewVirtualArena("Arena 1"))
-  arenas = append(arenas, NewVirtualArena("Arena 2"))
+  arenas_div1 = append(arenas_div1, NewVirtualArena("Arena 2"))
-
+  arenas_div2 := []*Arena{}
-  for _, arena := range arenas {
+  arenas_div2 = append(arenas_div2, NewVirtualArena("Arena 3"))
+  arenas_div2 = append(arenas_div2, NewVirtualArena("Arena 4"))
+
+  for _, arena := range arenas_div1 {
     resources = append(resources, arena)
   }
 
-  for _, team := range teams {
+  for _, arena := range arenas_div2 {
+    resources = append(resources, arena)
+  }
+
+  for _, team := range teams_div1 {
+    resources = append(resources, team)
+  }
+
+  for _, team := range teams_div2 {
     resources = append(resources, team)
   }
 
-  alliances := []*Alliance{}
+  alliances_div1 := []*Alliance{}
-  alliances = append(alliances, NewAlliance(t1, t2))
+  alliances_div1 = append(alliances_div1, NewAlliance(t1, t2))
-  alliances = append(alliances, NewAlliance(t3, t4))
+  alliances_div1 = append(alliances_div1, NewAlliance(t3, t4))
-  alliances = append(alliances, NewAlliance(t5, t6))
+  alliances_div1 = append(alliances_div1, NewAlliance(t5, t6))
-  alliances = append(alliances, NewAlliance(t7, t8))
+  alliances_div1 = append(alliances_div1, NewAlliance(t7, t8))
+  alliances_div2 := []*Alliance{}
+  alliances_div2 = append(alliances_div2, NewAlliance(t9,  t10))
+  alliances_div2 = append(alliances_div2, NewAlliance(t11, t12))
+  alliances_div2 = append(alliances_div2, NewAlliance(t13, t14))
+  alliances_div2 = append(alliances_div2, NewAlliance(t15, t16))
 
-  for _, alliance := range alliances {
+  for _, alliance := range alliances_div1 {
+    resources = append(resources, alliance)
+  }
+
+  for _, alliance := range alliances_div2 {
     resources = append(resources, alliance)
   }
 
 
   root_event := NewEventQueue("root_event", "", []Resource{})
   event_manager := NewEventManager(root_event, resources)
+  div_1 := NewEventQueue("Division 1", "", []Resource{})
+  div_2 := NewEventQueue("Division 2", "", []Resource{})
+  err := event_manager.AddEvent(root_event, div_1, NewEventQueueInfo(1))
+  if err != nil {
+    panic("Failed to add div_1")
+  }
+  err = event_manager.AddEvent(root_event, div_2, NewEventQueueInfo(1))
+  if err != nil {
+    panic("Failed to add div_2")
+  }
+
+  for i, alliance := range(alliances_div1) {
+    for j, alliance2 := range(alliances_div1) {
+      if j != i {
+        if alliance.Children()[0] == alliance2.Children()[0] || alliance.Children()[0] == alliance2.Children()[1] || alliance.Children()[1] == alliance2.Children()[0] || alliance.Children()[1] == alliance2.Children()[1] {
+        } else {
+          for arena_idx := 0; arena_idx < len(arenas_div1); arena_idx++ {
+            match := NewMatch(alliance, alliance2, arenas_div1[arena_idx])
+            log.Logf("test", "Adding %s", match.Name())
+            err := event_manager.AddEvent(div_1, match, NewEventQueueInfo(i))
+            if err != nil {
+              log.Logf("test", "Error adding %s: %s", match.Name(), err)
+            }
+          }
+        }
+      }
+    }
+  }
 
-  for i, alliance := range(alliances) {
+  for i, alliance := range(alliances_div2) {
-    for j, alliance2 := range(alliances) {
+    for j, alliance2 := range(alliances_div2) {
       if j != i {
         if alliance.Children()[0] == alliance2.Children()[0] || alliance.Children()[0] == alliance2.Children()[1] || alliance.Children()[1] == alliance2.Children()[0] || alliance.Children()[1] == alliance2.Children()[1] {
         } else {
-          for arena_idx := 0; arena_idx < len(arenas); arena_idx++ {
+          for arena_idx := 0; arena_idx < len(arenas_div2); arena_idx++ {
-            match := NewMatch(alliance, alliance2, arenas[arena_idx])
+            match := NewMatch(alliance, alliance2, arenas_div2[arena_idx])
             log.Logf("test", "Adding %s", match.Name())
-            err := event_manager.AddEvent(root_event, match, NewEventQueueInfo(i))
+            err := event_manager.AddEvent(div_2, match, NewEventQueueInfo(i))
             if err != nil {
               log.Logf("test", "Error adding %s: %s", match.Name(), err)
             }
@@ -114,7 +161,7 @@ func fake_data() (* EventManager, *Arena, *Arena) {
     }
   }
 
-  return event_manager, arenas[0], arenas[1]
+  return event_manager, arenas_div1, arenas_div2
 }
 
 type FakeClient struct {
@@ -122,6 +169,7 @@ type FakeClient struct {
   start time.Time
   arena * Arena
   update chan GraphSignal
+  games_done int
 }
 
 func NewFakeClient(arena *Arena) * FakeClient {
@@ -130,6 +178,7 @@ func NewFakeClient(arena *Arena) * FakeClient {
     start: time.Now(),
     arena: arena,
     update: arena.UpdateChannel(),
+    games_done: 0,
   }
 
   return client
@@ -181,28 +230,29 @@ func (client * FakeClient) process_update(update GraphSignal) {
     }
     client.state = "init"
     log.Logf("test", "FAKE_CLIENT_ACTION: Driver done on %s for %s", arena.Name(), update.Time())
+    client.games_done += 1
   }
 }
 
 func main() {
-  go func() {
+  event_manager, arenas_div1, arenas_div2 := fake_data()
-    time.Sleep(5 * time.Second)
-    if true {
-      pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
-    }
-  }()
-
-  event_manager, arena_1, arena_2 := fake_data()
   // Fake arena clients
+  arena_1_client := NewFakeClient(arenas_div1[0])
+  arena_2_client := NewFakeClient(arenas_div1[1])
+  arena_3_client := NewFakeClient(arenas_div2[0])
+  arena_4_client := NewFakeClient(arenas_div2[1])
+
   go func() {
-    arena_1_client := NewFakeClient(arena_1)
-    arena_2_client := NewFakeClient(arena_2)
     for true {
       select {
       case update := <- arena_1_client.update:
         arena_1_client.process_update(update)
       case update := <- arena_2_client.update:
         arena_2_client.process_update(update)
+      case update := <- arena_3_client.update:
+        arena_3_client.process_update(update)
+      case update := <- arena_4_client.update:
+        arena_4_client.process_update(update)
       }
     }
   }()
@@ -212,5 +262,9 @@ func main() {
     log.Logf("test", "Error running event_manager: %s", err)
   } else {
     log.Logf("test", "Finished event_manager")
+    log.Logf("test", "Client 1 games: %d", arena_1_client.games_done)
+    log.Logf("test", "Client 2 games: %d", arena_2_client.games_done)
+    log.Logf("test", "Client 3 games: %d", arena_3_client.games_done)
+    log.Logf("test", "Client 4 games: %d", arena_4_client.games_done)
   }
 }