mirror
/
goirc
mirror of https://github.com/fluffle/goirc
1
0
Fork 0
Code Issues Releases Wiki Activity

Remove state.StateTracker stutter, hide it in Conn.

This commit is contained in:
Alex Bramley 2013-02-16 11:29:56 +00:00
parent a88b866b63
commit 45d7b3317f
7 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
client/connection.go
View File

@ -24,8 +24,7 @@ type Conn struct {
commands *cSet commands *cSet
// State tracker for nicks and channels // State tracker for nicks and channels
ST state.StateTracker st state.Tracker
st bool
stRemovers []Remover stRemovers []Remover
// Use the State field to store external state that handlers might need. // Use the State field to store external state that handlers might need.
@ -100,32 +99,34 @@ func Client(nick string, args ...string) *Conn {
} }
func (conn *Conn) EnableStateTracking() { func (conn *Conn) EnableStateTracking() {
if !conn.st { if conn.st == nil {
n := conn.Me n := conn.Me
conn.ST = state.NewTracker(n.Nick) conn.st = state.NewTracker(n.Nick)
conn.Me = conn.ST.Me() conn.Me = conn.st.Me()
conn.Me.Ident = n.Ident conn.Me.Ident = n.Ident
conn.Me.Name = n.Name conn.Me.Name = n.Name
conn.addSTHandlers() conn.addSTHandlers()
conn.st = true
} }
} }
func (conn *Conn) DisableStateTracking() { func (conn *Conn) DisableStateTracking() {
if conn.st { if conn.st != nil {
conn.st = false
conn.delSTHandlers() conn.delSTHandlers()
conn.ST.Wipe() conn.st.Wipe()
conn.ST = nil conn.st = nil
} }
} }
func (conn *Conn) StateTracker() state.Tracker {
return conn.st
}
// Per-connection state initialisation. // Per-connection state initialisation.
func (conn *Conn) initialise() { func (conn *Conn) initialise() {
conn.io = nil conn.io = nil
conn.sock = nil conn.sock = nil
if conn.st { if conn.st != nil {
conn.ST.Wipe() conn.st.Wipe()
} }
} }
@ -328,8 +329,8 @@ func (conn *Conn) String() string {
str += "Not currently connected!\n\n" str += "Not currently connected!\n\n"
} }
str += conn.Me.String() + "\n" str += conn.Me.String() + "\n"
if conn.st { if conn.st != nil {
str += conn.ST.String() + "\n" str += conn.st.String() + "\n"
} }
return str return str
} }

15
client/connection_test.go
View File

@ -12,20 +12,19 @@ import (
type testState struct { type testState struct {
ctrl *gomock.Controller ctrl *gomock.Controller
st *state.MockStateTracker st *state.MockTracker
nc *mockNetConn nc *mockNetConn
c *Conn c *Conn
} }
func setUp(t *testing.T, start ...bool) (*Conn, *testState) { func setUp(t *testing.T, start ...bool) (*Conn, *testState) {
ctrl := gomock.NewController(t) ctrl := gomock.NewController(t)
st := state.NewMockStateTracker(ctrl) st := state.NewMockTracker(ctrl)
nc := MockNetConn(t) nc := MockNetConn(t)
c := Client("test", "test", "Testing IRC") c := Client("test", "test", "Testing IRC")
logging.SetLogLevel(logging.LogFatal) logging.SetLogLevel(logging.LogFatal)
c.ST = st c.st = st
c.st = true
c.sock = nc c.sock = nc
c.Flood = true // Tests can take a while otherwise c.Flood = true // Tests can take a while otherwise
c.Connected = true c.Connected = true
@ -82,7 +81,7 @@ func TestEOF(t *testing.T) {
func TestClientAndStateTracking(t *testing.T) { func TestClientAndStateTracking(t *testing.T) {
ctrl := gomock.NewController(t) ctrl := gomock.NewController(t)
st := state.NewMockStateTracker(ctrl) st := state.NewMockTracker(ctrl)
c := Client("test", "test", "Testing IRC") c := Client("test", "test", "Testing IRC")
// Assert some basic things about the initial state of the Conn struct // Assert some basic things about the initial state of the Conn struct
@ -114,16 +113,16 @@ func TestClientAndStateTracking(t *testing.T) {
c.Me.Name != "Testing IRC" || c.Me.Host != "" { c.Me.Name != "Testing IRC" || c.Me.Host != "" {
t.Errorf("Enabling state tracking did not replace Me correctly.") t.Errorf("Enabling state tracking did not replace Me correctly.")
} }
if !c.st || c.ST == nil || c.Me != c.ST.Me() { if c.st == nil || c.Me != c.st.Me() {
t.Errorf("State tracker not enabled correctly.") t.Errorf("State tracker not enabled correctly.")
} }
// Now, shim in the mock state tracker and test disabling state tracking // Now, shim in the mock state tracker and test disabling state tracking
me := c.Me me := c.Me
c.ST = st c.st = st
st.EXPECT().Wipe() st.EXPECT().Wipe()
c.DisableStateTracking() c.DisableStateTracking()
if c.st || c.ST != nil || c.Me != me { if c.st != nil || c.Me != me {
t.Errorf("State tracker not disabled correctly.") t.Errorf("State tracker not disabled correctly.")
} }

6
client/handlers.go
View File

@ -60,8 +60,8 @@ func (conn *Conn) h_433(line *Line) {
// we sent in the initial NICK command is in use) we will not receive // we sent in the initial NICK command is in use) we will not receive
// a NICK message to confirm our change of nick, so ReNick here... // a NICK message to confirm our change of nick, so ReNick here...
if line.Args[1] == conn.Me.Nick { if line.Args[1] == conn.Me.Nick {
if conn.st { if conn.st != nil {
conn.ST.ReNick(conn.Me.Nick, neu) conn.st.ReNick(conn.Me.Nick, neu)
} else { } else {
conn.Me.Nick = neu conn.Me.Nick = neu
} }
@ -79,7 +79,7 @@ func (conn *Conn) h_CTCP(line *Line) {
// Handle updating our own NICK if we're not using the state tracker // Handle updating our own NICK if we're not using the state tracker
func (conn *Conn) h_NICK(line *Line) { func (conn *Conn) h_NICK(line *Line) {
if !conn.st && line.Nick == conn.Me.Nick { if conn.st == nil && line.Nick == conn.Me.Nick {
conn.Me.Nick = line.Args[0] conn.Me.Nick = line.Args[0]
} }
} }

8
client/handlers_test.go
View File

@ -74,14 +74,14 @@ func Test433(t *testing.T) {
} }
// Test the code path that *doesn't* involve state tracking. // Test the code path that *doesn't* involve state tracking.
c.st = false c.st = nil
c.h_433(parseLine(":irc.server.org 433 test test :Nickname is already in use.")) c.h_433(parseLine(":irc.server.org 433 test test :Nickname is already in use."))
s.nc.Expect("NICK test_") s.nc.Expect("NICK test_")
if c.Me.Nick != "test_" { if c.Me.Nick != "test_" {
t.Errorf("My nick not updated from '%s'.", c.Me.Nick) t.Errorf("My nick not updated from '%s'.", c.Me.Nick)
} }
c.st = true c.st = s.st
} }
// Test the handler for NICK messages when state tracking is disabled // Test the handler for NICK messages when state tracking is disabled
@ -90,7 +90,7 @@ func TestNICK(t *testing.T) {
defer s.tearDown() defer s.tearDown()
// State tracking is enabled by default in setUp // State tracking is enabled by default in setUp
c.st = false c.st = nil
// Call handler with a NICK line changing "our" nick to test1. // Call handler with a NICK line changing "our" nick to test1.
c.h_NICK(parseLine(":test!test@somehost.com NICK :test1")) c.h_NICK(parseLine(":test!test@somehost.com NICK :test1"))
@ -109,7 +109,7 @@ func TestNICK(t *testing.T) {
} }
// Re-enable state tracking and send a line that *should* change nick. // Re-enable state tracking and send a line that *should* change nick.
c.st = true c.st = s.st
c.h_NICK(parseLine(":test1!test@somehost.com NICK :test2")) c.h_NICK(parseLine(":test1!test@somehost.com NICK :test2"))
// Verify that our Nick hasn't changed (should be handled by h_STNICK). // Verify that our Nick hasn't changed (should be handled by h_STNICK).

48
client/state_handlers.go
View File

@ -40,13 +40,13 @@ func (conn *Conn) delSTHandlers() {
// Handle NICK messages that need to update the state tracker // Handle NICK messages that need to update the state tracker
func (conn *Conn) h_STNICK(line *Line) { func (conn *Conn) h_STNICK(line *Line) {
// all nicks should be handled the same way, our own included // all nicks should be handled the same way, our own included
conn.ST.ReNick(line.Nick, line.Args[0]) conn.st.ReNick(line.Nick, line.Args[0])
} }
// Handle JOINs to channels to maintain state // Handle JOINs to channels to maintain state
func (conn *Conn) h_JOIN(line *Line) { func (conn *Conn) h_JOIN(line *Line) {
ch := conn.ST.GetChannel(line.Args[0]) ch := conn.st.GetChannel(line.Args[0])
nk := conn.ST.GetNick(line.Nick) nk := conn.st.GetNick(line.Nick)
if ch == nil { if ch == nil {
// first we've seen of this channel, so should be us joining it // first we've seen of this channel, so should be us joining it
// NOTE this will also take care of nk == nil && ch == nil // NOTE this will also take care of nk == nil && ch == nil
@ -55,7 +55,7 @@ func (conn *Conn) h_JOIN(line *Line) {
"from (non-me) nick %s", line.Args[0], line.Nick) "from (non-me) nick %s", line.Args[0], line.Nick)
return return
} }
ch = conn.ST.NewChannel(line.Args[0]) ch = conn.st.NewChannel(line.Args[0])
// since we don't know much about this channel, ask server for info // since we don't know much about this channel, ask server for info
// we get the channel users automatically in 353 and the channel // we get the channel users automatically in 353 and the channel
// topic in 332 on join, so we just need to get the modes // topic in 332 on join, so we just need to get the modes
@ -66,41 +66,41 @@ func (conn *Conn) h_JOIN(line *Line) {
} }
if nk == nil { if nk == nil {
// this is the first we've seen of this nick // this is the first we've seen of this nick
nk = conn.ST.NewNick(line.Nick) nk = conn.st.NewNick(line.Nick)
nk.Ident = line.Ident nk.Ident = line.Ident
nk.Host = line.Host nk.Host = line.Host
// since we don't know much about this nick, ask server for info // since we don't know much about this nick, ask server for info
conn.Who(nk.Nick) conn.Who(nk.Nick)
} }
// this takes care of both nick and channel linking \o/ // this takes care of both nick and channel linking \o/
conn.ST.Associate(ch, nk) conn.st.Associate(ch, nk)
} }
// Handle PARTs from channels to maintain state // Handle PARTs from channels to maintain state
func (conn *Conn) h_PART(line *Line) { func (conn *Conn) h_PART(line *Line) {
conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]), conn.st.Dissociate(conn.st.GetChannel(line.Args[0]),
conn.ST.GetNick(line.Nick)) conn.st.GetNick(line.Nick))
} }
// Handle KICKs from channels to maintain state // Handle KICKs from channels to maintain state
func (conn *Conn) h_KICK(line *Line) { func (conn *Conn) h_KICK(line *Line) {
// XXX: this won't handle autorejoining channels on KICK // XXX: this won't handle autorejoining channels on KICK
// it's trivial to do this in a seperate handler... // it's trivial to do this in a seperate handler...
conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]), conn.st.Dissociate(conn.st.GetChannel(line.Args[0]),
conn.ST.GetNick(line.Args[1])) conn.st.GetNick(line.Args[1]))
} }
// Handle other people's QUITs // Handle other people's QUITs
func (conn *Conn) h_QUIT(line *Line) { func (conn *Conn) h_QUIT(line *Line) {
conn.ST.DelNick(line.Nick) conn.st.DelNick(line.Nick)
} }
// Handle MODE changes for channels we know about (and our nick personally) // Handle MODE changes for channels we know about (and our nick personally)
func (conn *Conn) h_MODE(line *Line) { func (conn *Conn) h_MODE(line *Line) {
if ch := conn.ST.GetChannel(line.Args[0]); ch != nil { if ch := conn.st.GetChannel(line.Args[0]); ch != nil {
// channel modes first // channel modes first
ch.ParseModes(line.Args[1], line.Args[2:]...) ch.ParseModes(line.Args[1], line.Args[2:]...)
} else if nk := conn.ST.GetNick(line.Args[0]); nk != nil { } else if nk := conn.st.GetNick(line.Args[0]); nk != nil {
// nick mode change, should be us // nick mode change, should be us
if nk != conn.Me { if nk != conn.Me {
logging.Warn("irc.MODE(): recieved MODE %s for (non-me) nick %s", logging.Warn("irc.MODE(): recieved MODE %s for (non-me) nick %s",
@ -116,7 +116,7 @@ func (conn *Conn) h_MODE(line *Line) {
// Handle TOPIC changes for channels // Handle TOPIC changes for channels
func (conn *Conn) h_TOPIC(line *Line) { func (conn *Conn) h_TOPIC(line *Line) {
if ch := conn.ST.GetChannel(line.Args[0]); ch != nil { if ch := conn.st.GetChannel(line.Args[0]); ch != nil {
ch.Topic = line.Args[1] ch.Topic = line.Args[1]
} else { } else {
logging.Warn("irc.TOPIC(): topic change on unknown channel %s", logging.Warn("irc.TOPIC(): topic change on unknown channel %s",
@ -126,7 +126,7 @@ func (conn *Conn) h_TOPIC(line *Line) {
// Handle 311 whois reply // Handle 311 whois reply
func (conn *Conn) h_311(line *Line) { func (conn *Conn) h_311(line *Line) {
if nk := conn.ST.GetNick(line.Args[1]); nk != nil { if nk := conn.st.GetNick(line.Args[1]); nk != nil {
nk.Ident = line.Args[2] nk.Ident = line.Args[2]
nk.Host = line.Args[3] nk.Host = line.Args[3]
nk.Name = line.Args[5] nk.Name = line.Args[5]
@ -138,7 +138,7 @@ func (conn *Conn) h_311(line *Line) {
// Handle 324 mode reply // Handle 324 mode reply
func (conn *Conn) h_324(line *Line) { func (conn *Conn) h_324(line *Line) {
if ch := conn.ST.GetChannel(line.Args[1]); ch != nil { if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
ch.ParseModes(line.Args[2], line.Args[3:]...) ch.ParseModes(line.Args[2], line.Args[3:]...)
} else { } else {
logging.Warn("irc.324(): received MODE settings for unknown channel %s", logging.Warn("irc.324(): received MODE settings for unknown channel %s",
@ -148,7 +148,7 @@ func (conn *Conn) h_324(line *Line) {
// Handle 332 topic reply on join to channel // Handle 332 topic reply on join to channel
func (conn *Conn) h_332(line *Line) { func (conn *Conn) h_332(line *Line) {
if ch := conn.ST.GetChannel(line.Args[1]); ch != nil { if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
ch.Topic = line.Args[2] ch.Topic = line.Args[2]
} else { } else {
logging.Warn("irc.332(): received TOPIC value for unknown channel %s", logging.Warn("irc.332(): received TOPIC value for unknown channel %s",
@ -158,7 +158,7 @@ func (conn *Conn) h_332(line *Line) {
// Handle 352 who reply // Handle 352 who reply
func (conn *Conn) h_352(line *Line) { func (conn *Conn) h_352(line *Line) {
if nk := conn.ST.GetNick(line.Args[5]); nk != nil { if nk := conn.st.GetNick(line.Args[5]); nk != nil {
nk.Ident = line.Args[2] nk.Ident = line.Args[2]
nk.Host = line.Args[3] nk.Host = line.Args[3]
// XXX: do we care about the actual server the nick is on? // XXX: do we care about the actual server the nick is on?
@ -180,7 +180,7 @@ func (conn *Conn) h_352(line *Line) {
// Handle 353 names reply // Handle 353 names reply
func (conn *Conn) h_353(line *Line) { func (conn *Conn) h_353(line *Line) {
if ch := conn.ST.GetChannel(line.Args[2]); ch != nil { if ch := conn.st.GetChannel(line.Args[2]); ch != nil {
nicks := strings.Split(line.Args[len(line.Args)-1], " ") nicks := strings.Split(line.Args[len(line.Args)-1], " ")
for _, nick := range nicks { for _, nick := range nicks {
// UnrealIRCd's coders are lazy and leave a trailing space // UnrealIRCd's coders are lazy and leave a trailing space
@ -192,15 +192,15 @@ func (conn *Conn) h_353(line *Line) {
nick = nick[1:] nick = nick[1:]
fallthrough fallthrough
default: default:
nk := conn.ST.GetNick(nick) nk := conn.st.GetNick(nick)
if nk == nil { if nk == nil {
// we don't know this nick yet! // we don't know this nick yet!
nk = conn.ST.NewNick(nick) nk = conn.st.NewNick(nick)
} }
cp, ok := conn.ST.IsOn(ch.Name, nick) cp, ok := conn.st.IsOn(ch.Name, nick)
if !ok { if !ok {
// This nick isn't associated with this channel yet! // This nick isn't associated with this channel yet!
cp = conn.ST.Associate(ch, nk) cp = conn.st.Associate(ch, nk)
} }
switch c { switch c {
case '~': case '~':
@ -224,7 +224,7 @@ func (conn *Conn) h_353(line *Line) {
// Handle 671 whois reply (nick connected via SSL) // Handle 671 whois reply (nick connected via SSL)
func (conn *Conn) h_671(line *Line) { func (conn *Conn) h_671(line *Line) {
if nk := conn.ST.GetNick(line.Args[1]); nk != nil { if nk := conn.st.GetNick(line.Args[1]); nk != nil {
nk.Modes.SSL = true nk.Modes.SSL = true
} else { } else {
logging.Warn("irc.671(): received WHOIS SSL info for unknown nick %s", logging.Warn("irc.671(): received WHOIS SSL info for unknown nick %s",

72
state/mock_tracker.go
View File

@ -7,144 +7,144 @@ import (
gomock "code.google.com/p/gomock/gomock" gomock "code.google.com/p/gomock/gomock"
) )
// Mock of StateTracker interface // Mock of Tracker interface
type MockStateTracker struct { type MockTracker struct {
ctrl *gomock.Controller ctrl *gomock.Controller
recorder *_MockStateTrackerRecorder recorder *_MockTrackerRecorder
} }
// Recorder for MockStateTracker (not exported) // Recorder for MockTracker (not exported)
type _MockStateTrackerRecorder struct { type _MockTrackerRecorder struct {
mock *MockStateTracker mock *MockTracker
} }
func NewMockStateTracker(ctrl *gomock.Controller) *MockStateTracker { func NewMockTracker(ctrl *gomock.Controller) *MockTracker {
mock := &MockStateTracker{ctrl: ctrl} mock := &MockTracker{ctrl: ctrl}
mock.recorder = &_MockStateTrackerRecorder{mock} mock.recorder = &_MockTrackerRecorder{mock}
return mock return mock
} }
func (_m *MockStateTracker) EXPECT() *_MockStateTrackerRecorder { func (_m *MockTracker) EXPECT() *_MockTrackerRecorder {
return _m.recorder return _m.recorder
} }
func (_m *MockStateTracker) NewNick(nick string) *Nick { func (_m *MockTracker) NewNick(nick string) *Nick {
ret := _m.ctrl.Call(_m, "NewNick", nick) ret := _m.ctrl.Call(_m, "NewNick", nick)
ret0, _ := ret[0].(*Nick) ret0, _ := ret[0].(*Nick)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "NewNick", arg0) return _mr.mock.ctrl.RecordCall(_mr.mock, "NewNick", arg0)
} }
func (_m *MockStateTracker) GetNick(nick string) *Nick { func (_m *MockTracker) GetNick(nick string) *Nick {
ret := _m.ctrl.Call(_m, "GetNick", nick) ret := _m.ctrl.Call(_m, "GetNick", nick)
ret0, _ := ret[0].(*Nick) ret0, _ := ret[0].(*Nick)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNick", arg0) return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNick", arg0)
} }
func (_m *MockStateTracker) ReNick(old string, neu string) { func (_m *MockTracker) ReNick(old string, neu string) {
_m.ctrl.Call(_m, "ReNick", old, neu) _m.ctrl.Call(_m, "ReNick", old, neu)
} }
func (_mr *_MockStateTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "ReNick", arg0, arg1) return _mr.mock.ctrl.RecordCall(_mr.mock, "ReNick", arg0, arg1)
} }
func (_m *MockStateTracker) DelNick(nick string) { func (_m *MockTracker) DelNick(nick string) {
_m.ctrl.Call(_m, "DelNick", nick) _m.ctrl.Call(_m, "DelNick", nick)
} }
func (_mr *_MockStateTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNick", arg0) return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNick", arg0)
} }
func (_m *MockStateTracker) NewChannel(channel string) *Channel { func (_m *MockTracker) NewChannel(channel string) *Channel {
ret := _m.ctrl.Call(_m, "NewChannel", channel) ret := _m.ctrl.Call(_m, "NewChannel", channel)
ret0, _ := ret[0].(*Channel) ret0, _ := ret[0].(*Channel)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "NewChannel", arg0) return _mr.mock.ctrl.RecordCall(_mr.mock, "NewChannel", arg0)
} }
func (_m *MockStateTracker) GetChannel(channel string) *Channel { func (_m *MockTracker) GetChannel(channel string) *Channel {
ret := _m.ctrl.Call(_m, "GetChannel", channel) ret := _m.ctrl.Call(_m, "GetChannel", channel)
ret0, _ := ret[0].(*Channel) ret0, _ := ret[0].(*Channel)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "GetChannel", arg0) return _mr.mock.ctrl.RecordCall(_mr.mock, "GetChannel", arg0)
} }
func (_m *MockStateTracker) DelChannel(channel string) { func (_m *MockTracker) DelChannel(channel string) {
_m.ctrl.Call(_m, "DelChannel", channel) _m.ctrl.Call(_m, "DelChannel", channel)
} }
func (_mr *_MockStateTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "DelChannel", arg0) return _mr.mock.ctrl.RecordCall(_mr.mock, "DelChannel", arg0)
} }
func (_m *MockStateTracker) Me() *Nick { func (_m *MockTracker) Me() *Nick {
ret := _m.ctrl.Call(_m, "Me") ret := _m.ctrl.Call(_m, "Me")
ret0, _ := ret[0].(*Nick) ret0, _ := ret[0].(*Nick)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) Me() *gomock.Call { func (_mr *_MockTrackerRecorder) Me() *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Me") return _mr.mock.ctrl.RecordCall(_mr.mock, "Me")
} }
func (_m *MockStateTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) { func (_m *MockTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) {
ret := _m.ctrl.Call(_m, "IsOn", channel, nick) ret := _m.ctrl.Call(_m, "IsOn", channel, nick)
ret0, _ := ret[0].(*ChanPrivs) ret0, _ := ret[0].(*ChanPrivs)
ret1, _ := ret[1].(bool) ret1, _ := ret[1].(bool)
return ret0, ret1 return ret0, ret1
} }
func (_mr *_MockStateTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "IsOn", arg0, arg1) return _mr.mock.ctrl.RecordCall(_mr.mock, "IsOn", arg0, arg1)
} }
func (_m *MockStateTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs { func (_m *MockTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs {
ret := _m.ctrl.Call(_m, "Associate", channel, nick) ret := _m.ctrl.Call(_m, "Associate", channel, nick)
ret0, _ := ret[0].(*ChanPrivs) ret0, _ := ret[0].(*ChanPrivs)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Associate", arg0, arg1) return _mr.mock.ctrl.RecordCall(_mr.mock, "Associate", arg0, arg1)
} }
func (_m *MockStateTracker) Dissociate(channel *Channel, nick *Nick) { func (_m *MockTracker) Dissociate(channel *Channel, nick *Nick) {
_m.ctrl.Call(_m, "Dissociate", channel, nick) _m.ctrl.Call(_m, "Dissociate", channel, nick)
} }
func (_mr *_MockStateTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call { func (_mr *_MockTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Dissociate", arg0, arg1) return _mr.mock.ctrl.RecordCall(_mr.mock, "Dissociate", arg0, arg1)
} }
func (_m *MockStateTracker) Wipe() { func (_m *MockTracker) Wipe() {
_m.ctrl.Call(_m, "Wipe") _m.ctrl.Call(_m, "Wipe")
} }
func (_mr *_MockStateTrackerRecorder) Wipe() *gomock.Call { func (_mr *_MockTrackerRecorder) Wipe() *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Wipe") return _mr.mock.ctrl.RecordCall(_mr.mock, "Wipe")
} }
func (_m *MockStateTracker) String() string { func (_m *MockTracker) String() string {
ret := _m.ctrl.Call(_m, "String") ret := _m.ctrl.Call(_m, "String")
ret0, _ := ret[0].(string) ret0, _ := ret[0].(string)
return ret0 return ret0
} }
func (_mr *_MockStateTrackerRecorder) String() *gomock.Call { func (_mr *_MockTrackerRecorder) String() *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "String") return _mr.mock.ctrl.RecordCall(_mr.mock, "String")
} }

36
state/tracker.go
View File

@ -5,7 +5,7 @@ import (
) )
// The state manager interface // The state manager interface
type StateTracker interface { type Tracker interface {
// Nick methods // Nick methods
NewNick(nick string) *Nick NewNick(nick string) *Nick
GetNick(nick string) *Nick GetNick(nick string) *Nick
@ -63,7 +63,7 @@ func (st *stateTracker) Wipe() {
// can be properly tracked for state management purposes. // can be properly tracked for state management purposes.
func (st *stateTracker) NewNick(n string) *Nick { func (st *stateTracker) NewNick(n string) *Nick {
if _, ok := st.nicks[n]; ok { if _, ok := st.nicks[n]; ok {
logging.Warn("StateTracker.NewNick(): %s already tracked.", n) logging.Warn("Tracker.NewNick(): %s already tracked.", n)
return nil return nil
} }
st.nicks[n] = NewNick(n) st.nicks[n] = NewNick(n)
@ -93,10 +93,10 @@ func (st *stateTracker) ReNick(old, neu string) {
ch.lookup[neu] = nk ch.lookup[neu] = nk
} }
} else { } else {
logging.Warn("StateTracker.ReNick(): %s already exists.", neu) logging.Warn("Tracker.ReNick(): %s already exists.", neu)
} }
} else { } else {
logging.Warn("StateTracker.ReNick(): %s not tracked.", old) logging.Warn("Tracker.ReNick(): %s not tracked.", old)
} }
} }
@ -106,17 +106,17 @@ func (st *stateTracker) DelNick(n string) {
if nk != st.me { if nk != st.me {
st.delNick(nk) st.delNick(nk)
} else { } else {
logging.Warn("StateTracker.DelNick(): won't delete myself.") logging.Warn("Tracker.DelNick(): won't delete myself.")
} }
} else { } else {
logging.Warn("StateTracker.DelNick(): %s not tracked.", n) logging.Warn("Tracker.DelNick(): %s not tracked.", n)
} }
} }
func (st *stateTracker) delNick(nk *Nick) { func (st *stateTracker) delNick(nk *Nick) {
if nk == st.me { if nk == st.me {
// Shouldn't get here => internal state tracking code is fubar. // Shouldn't get here => internal state tracking code is fubar.
logging.Error("StateTracker.DelNick(): TRYING TO DELETE ME :-(") logging.Error("Tracker.DelNick(): TRYING TO DELETE ME :-(")
return return
} }
delete(st.nicks, nk.Nick) delete(st.nicks, nk.Nick)
@ -126,7 +126,7 @@ func (st *stateTracker) delNick(nk *Nick) {
if len(ch.nicks) == 0 { if len(ch.nicks) == 0 {
// Deleting a nick from tracking shouldn't empty any channels as // Deleting a nick from tracking shouldn't empty any channels as
// *we* should be on the channel with them to be tracking them. // *we* should be on the channel with them to be tracking them.
logging.Error("StateTracker.delNick(): deleting nick %s emptied "+ logging.Error("Tracker.delNick(): deleting nick %s emptied "+
"channel %s, this shouldn't happen!", nk.Nick, ch.Name) "channel %s, this shouldn't happen!", nk.Nick, ch.Name)
} }
} }
@ -136,7 +136,7 @@ func (st *stateTracker) delNick(nk *Nick) {
// can be properly tracked for state management purposes. // can be properly tracked for state management purposes.
func (st *stateTracker) NewChannel(c string) *Channel { func (st *stateTracker) NewChannel(c string) *Channel {
if _, ok := st.chans[c]; ok { if _, ok := st.chans[c]; ok {
logging.Warn("StateTracker.NewChannel(): %s already tracked.", c) logging.Warn("Tracker.NewChannel(): %s already tracked.", c)
return nil return nil
} }
st.chans[c] = NewChannel(c) st.chans[c] = NewChannel(c)
@ -156,7 +156,7 @@ func (st *stateTracker) DelChannel(c string) {
if ch, ok := st.chans[c]; ok { if ch, ok := st.chans[c]; ok {
st.delChannel(ch) st.delChannel(ch)
} else { } else {
logging.Warn("StateTracker.DelChannel(): %s not tracked.", c) logging.Warn("Tracker.DelChannel(): %s not tracked.", c)
} }
} }
@ -191,21 +191,21 @@ func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) {
// Associates an already known nick with an already known channel. // Associates an already known nick with an already known channel.
func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs { func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs {
if ch == nil || nk == nil { if ch == nil || nk == nil {
logging.Error("StateTracker.Associate(): passed nil values :-(") logging.Error("Tracker.Associate(): passed nil values :-(")
return nil return nil
} else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch {
// As we can implicitly delete both nicks and channels from being // As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that // tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel. // we're not being passed an old Nick or Channel.
logging.Error("StateTracker.Associate(): channel %s not found in "+ logging.Error("Tracker.Associate(): channel %s not found in "+
"(or differs from) internal state.", ch.Name) "(or differs from) internal state.", ch.Name)
return nil return nil
} else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk {
logging.Error("StateTracker.Associate(): nick %s not found in "+ logging.Error("Tracker.Associate(): nick %s not found in "+
"(or differs from) internal state.", nk.Nick) "(or differs from) internal state.", nk.Nick)
return nil return nil
} else if _, ok := nk.IsOn(ch); ok { } else if _, ok := nk.IsOn(ch); ok {
logging.Warn("StateTracker.Associate(): %s already on %s.", logging.Warn("Tracker.Associate(): %s already on %s.",
nk.Nick, ch.Name) nk.Nick, ch.Name)
return nil return nil
} }
@ -220,18 +220,18 @@ func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs {
// any common channels with, and channels we're no longer on. // any common channels with, and channels we're no longer on.
func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) { func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) {
if ch == nil || nk == nil { if ch == nil || nk == nil {
logging.Error("StateTracker.Dissociate(): passed nil values :-(") logging.Error("Tracker.Dissociate(): passed nil values :-(")
} else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch {
// As we can implicitly delete both nicks and channels from being // As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that // tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel. // we're not being passed an old Nick or Channel.
logging.Error("StateTracker.Dissociate(): channel %s not found in "+ logging.Error("Tracker.Dissociate(): channel %s not found in "+
"(or differs from) internal state.", ch.Name) "(or differs from) internal state.", ch.Name)
} else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk {
logging.Error("StateTracker.Dissociate(): nick %s not found in "+ logging.Error("Tracker.Dissociate(): nick %s not found in "+
"(or differs from) internal state.", nk.Nick) "(or differs from) internal state.", nk.Nick)
} else if _, ok := nk.IsOn(ch); !ok { } else if _, ok := nk.IsOn(ch); !ok {
logging.Warn("StateTracker.Dissociate(): %s not on %s.", logging.Warn("Tracker.Dissociate(): %s not on %s.",
nk.Nick, ch.Name) nk.Nick, ch.Name)
} else if nk == st.me { } else if nk == st.me {
// I'm leaving the channel for some reason, so it won't be tracked. // I'm leaving the channel for some reason, so it won't be tracked.