Second Import

app.go

@@ -6,105 +6,142 @@ package main
 
 import (
 	"errors"
-	"strings"
+	"sync"
+
+	log "github.com/golang/glog"
 )
 
-// Applications
+// An App
 type App struct {
+	sync.Mutex
+
 	Name                string
 	AppID               string
 	Key                 string
 	Secret              string
 	OnlySSL             bool
 	ApplicationDisabled bool
+	UserEvents          bool
+	WebHooks            bool
+	URLWebHook          string
 
 	PublicChannels   []*Channel `json:"-"`
 	PresenceChannels []*Channel `json:"-"`
 	PrivateChannels  []*Channel `json:"-"`
 
-	Connections []*Connection `json:"-"`
+	Subscribers map[string]*Subscriber `json:"-"`
 }
 
+// Returns a list of all channels in this app
 func (a *App) AllChannels() []*Channel {
 	var channels []*Channel
 
-	for _, c := range a.PrivateChannels {
-		channels = append(channels, c)
-	}
-
-	for _, c := range a.PublicChannels {
-		channels = append(channels, c)
-	}
-
-	for _, c := range a.PresenceChannels {
-		channels = append(channels, c)
-	}
+	channels = append(channels, a.PrivateChannels...)
+	channels = append(channels, a.PresenceChannels...)
+	channels = append(channels, a.PublicChannels...)
 
 	return channels
 }
 
-// Create a new Connection
-func (a *App) AddConnection(c *Connection) {
-	a.Connections = append(a.Connections, c)
-}
+func (a *App) Disconnect(socketID string) {
+	log.Infof("Disconnecting socket %+v", socketID)
 
-func (a *App) FindConnection(socketID string) (*Connection, error) {
-	for _, c := range a.Connections {
-		if c.SocketID == socketID {
-			return c, nil
+	s, err := a.FindSubscriber(socketID)
+
+	if err != nil {
+		log.Infof("Socket not found, %+v", err)
+		return
+	}
+
+	// Unsubscribe from channels
+	for _, c := range a.AllChannels() {
+		if c.IsSubscribed(s) {
+			c.Unsubscribe(a, s)
 		}
 	}
 
-	return nil, errors.New("Connection not found")
+	// Remove from app
+	a.Lock()
+	_, exists := a.Subscribers[s.SocketID]
+	if !exists {
+		return
+	}
+
+	delete(a.Subscribers, s.SocketID)
+
+	a.Unlock()
 }
 
+// Create a new Subscriber
+func (a *App) Connect(s *Subscriber) {
+	log.Infof("Adding a new Subscriber %s to app %s", s.SocketID, a.Name)
+	a.Lock()
+	a.Subscribers[s.SocketID] = s
+	a.Unlock()
+}
+
+// Find a Subscriber on this app
+func (a *App) FindSubscriber(socketID string) (*Subscriber, error) {
+
+	s, exists := a.Subscribers[socketID]
+
+	if exists {
+		return s, nil
+	}
+
+	return nil, errors.New("Subscriber not found")
+}
+
+// Add a new Channel to this APP
 func (a *App) AddChannel(c *Channel) {
-	if c.isPresence() {
+	log.Infof("Adding a new channel %s to app %s", c.ChannelID, a.Name)
+
+	a.Lock()
+
+	if c.IsPresence() {
 		a.PresenceChannels = append(a.PresenceChannels, c)
-	} else if c.isPrivate() {
+	} else if c.IsPrivate() {
 		a.PrivateChannels = append(a.PrivateChannels, c)
 	} else {
 		a.PublicChannels = append(a.PublicChannels, c)
 	}
+
+	a.Unlock()
 }
 
-func (a *App) FindOrCreateChannelByChannelID(n, data string) *Channel {
-	channel, err := a.FindChannelByChannelID(n)
+// Returns a Channel from this app
+// If not found then the channel is created and added to this app
+func (a *App) FindOrCreateChannelByChannelID(n string) *Channel {
+	c, err := a.FindChannelByChannelID(n)
 
 	if err != nil {
-		channel = NewChannel(n, data)
-
-		a.AddChannel(channel)
+		c = NewChannel(n)
+		a.AddChannel(c)
 	}
 
-	return channel
+	return c
 }
 
 // Find the channel by channel ID
 func (a *App) FindChannelByChannelID(n string) (*Channel, error) {
-	isPrivate := strings.HasPrefix(n, "private-")
-	isPresence := strings.HasPrefix(n, "presence-")
 
-	// Get the channel
-	if isPresence {
-		for _, channel := range a.PresenceChannels {
-			if channel.ChannelID == n {
-				return channel, nil
-			}
-		}
-	} else if isPrivate {
-		for _, channel := range a.PrivateChannels {
-			if channel.ChannelID == n {
-				return channel, nil
-			}
-		}
-	} else {
-		for _, channel := range a.PublicChannels {
-			if channel.ChannelID == n {
-				return channel, nil
-			}
+	for _, c := range a.AllChannels() {
+		if c.ChannelID == n {
+			return c, nil
 		}
 	}
 
 	return nil, errors.New("Channel does not exists")
 }
+
+func (a *App) Publish(c *Channel, event RawEvent, ignore string) error {
+	return c.Publish(a, event, ignore)
+}
+
+func (a *App) Unsubscribe(c *Channel, s *Subscriber) error {
+	return c.Unsubscribe(a, s)
+}
+
+func (a *App) Subscribe(c *Channel, s *Subscriber, data string) {
+	c.Subscribe(a, s, data)
+}