)
const (
- CRLF = "\x0d\x0a"
- BUF_SIZE = 1380
+ CRLF = "\x0d\x0a"
+ BufSize = 1380
)
type Client struct {
}
type ClientAlivenessState struct {
- ping_sent bool
+ pingSent bool
timestamp time.Time
}
// splits messages by CRLF and send them to Daemon gorouting for processing
// it futher. Also it can signalize that client is unavailable (disconnected).
func (client *Client) Processor(sink chan<- ClientEvent) {
- var buf_net []byte
+ var bufNet []byte
buf := make([]byte, 0)
log.Println(client, "New client")
- sink <- ClientEvent{client, EVENT_NEW, ""}
+ sink <- ClientEvent{client, EventNew, ""}
for {
- buf_net = make([]byte, BUF_SIZE)
- _, err := client.conn.Read(buf_net)
+ bufNet = make([]byte, BufSize)
+ _, err := client.conn.Read(bufNet)
if err != nil {
log.Println(client, "connection lost", err)
- sink <- ClientEvent{client, EVENT_DEL, ""}
+ sink <- ClientEvent{client, EventDel, ""}
break
}
- buf_net = bytes.TrimRight(buf_net, "\x00")
- buf = append(buf, buf_net...)
+ bufNet = bytes.TrimRight(bufNet, "\x00")
+ buf = append(buf, bufNet...)
if !bytes.HasSuffix(buf, []byte(CRLF)) {
continue
}
for _, msg := range bytes.Split(buf[:len(buf)-2], []byte(CRLF)) {
if len(msg) > 0 {
- sink <- ClientEvent{client, EVENT_MSG, string(msg)}
+ sink <- ClientEvent{client, EventMsg, string(msg)}
}
}
buf = []byte{}
go client.Processor(sink)
event := <-sink
- if event.event_type != EVENT_NEW {
+ if event.eventType != EventNew {
t.Fatal("no NEW event", event)
}
conn.inbound <- "foo"
event = <-sink
- if (event.event_type != EVENT_MSG) || (event.text != "foo") {
+ if (event.eventType != EventMsg) || (event.text != "foo") {
t.Fatal("no first MSG", event)
}
conn.inbound <- "bar"
event = <-sink
- if (event.event_type != EVENT_MSG) || (event.text != "bar") {
+ if (event.eventType != EventMsg) || (event.text != "bar") {
t.Fatal("no second MSG", event)
}
conn.inbound <- ""
event = <-sink
- if event.event_type != EVENT_DEL {
+ if event.eventType != EventDel {
t.Fatal("no client termination", event)
}
}
)
const (
- PING_TIMEOUT = time.Second * 180 // Max time deadline for client's unresponsiveness
- PING_THRESHOLD = time.Second * 90 // Max idle client's time before PING are sent
- ALIVENESS_CHECK = time.Second * 10 // Client's aliveness check period
+ PingTimeout = time.Second * 180 // Max time deadline for client's unresponsiveness
+ PingThreshold = time.Second * 90 // Max idle client's time before PING are sent
+ AlivenessCheck = time.Second * 10 // Client's aliveness check period
)
var (
- RE_NICKNAME = regexp.MustCompile("^[a-zA-Z0-9-]{1,9}$")
+ RENickname = regexp.MustCompile("^[a-zA-Z0-9-]{1,9}$")
)
type Daemon struct {
- Verbose bool
- hostname string
- motd string
- clients map[*Client]bool
- client_aliveness map[*Client]*ClientAlivenessState
- rooms map[string]*Room
- room_sinks map[*Room]chan ClientEvent
- last_aliveness_check time.Time
- log_sink chan<- LogEvent
- state_sink chan<- StateEvent
+ Verbose bool
+ hostname string
+ motd string
+ clients map[*Client]bool
+ clientAliveness map[*Client]*ClientAlivenessState
+ rooms map[string]*Room
+ roomSinks map[*Room]chan ClientEvent
+ lastAlivenessCheck time.Time
+ logSink chan<- LogEvent
+ stateSink chan<- StateEvent
}
-func NewDaemon(hostname, motd string, log_sink chan<- LogEvent, state_sink chan<- StateEvent) *Daemon {
+func NewDaemon(hostname, motd string, logSink chan<- LogEvent, stateSink chan<- StateEvent) *Daemon {
daemon := Daemon{hostname: hostname, motd: motd}
daemon.clients = make(map[*Client]bool)
- daemon.client_aliveness = make(map[*Client]*ClientAlivenessState)
+ daemon.clientAliveness = make(map[*Client]*ClientAlivenessState)
daemon.rooms = make(map[string]*Room)
- daemon.room_sinks = make(map[*Room]chan ClientEvent)
- daemon.log_sink = log_sink
- daemon.state_sink = state_sink
+ daemon.roomSinks = make(map[*Room]chan ClientEvent)
+ daemon.logSink = logSink
+ daemon.stateSink = stateSink
return &daemon
}
return
}
nickname := cols[1]
- for existing_client := range daemon.clients {
- if existing_client.nickname == nickname {
+ for existingClient := range daemon.clients {
+ if existingClient.nickname == nickname {
client.ReplyParts("433", "*", nickname, "Nickname is already in use")
return
}
}
- if !RE_NICKNAME.MatchString(nickname) {
+ if !RENickname.MatchString(nickname) {
client.ReplyParts("432", "*", cols[1], "Erroneous nickname")
return
}
// Register new room in Daemon. Create an object, events sink, save pointers
// to corresponding daemon's places and start room's processor goroutine.
func (daemon *Daemon) RoomRegister(name string) (*Room, chan<- ClientEvent) {
- room_new := NewRoom(daemon.hostname, name, daemon.log_sink, daemon.state_sink)
- room_new.Verbose = daemon.Verbose
- room_sink := make(chan ClientEvent)
- daemon.rooms[name] = room_new
- daemon.room_sinks[room_new] = room_sink
- go room_new.Processor(room_sink)
- return room_new, room_sink
+ roomNew := NewRoom(daemon.hostname, name, daemon.logSink, daemon.stateSink)
+ roomNew.Verbose = daemon.Verbose
+ roomSink := make(chan ClientEvent)
+ daemon.rooms[name] = roomNew
+ daemon.roomSinks[roomNew] = roomSink
+ go roomNew.Processor(roomSink)
+ return roomNew, roomSink
}
func (daemon *Daemon) HandlerJoin(client *Client, cmd string) {
}
denied := false
joined := false
- for room_existing, room_sink := range daemon.room_sinks {
- if room == room_existing.name {
- if (room_existing.key != "") && (room_existing.key != key) {
+ for roomExisting, roomSink := range daemon.roomSinks {
+ if room == roomExisting.name {
+ if (roomExisting.key != "") && (roomExisting.key != key) {
denied = true
} else {
- room_sink <- ClientEvent{client, EVENT_NEW, ""}
+ roomSink <- ClientEvent{client, EventNew, ""}
joined = true
}
break
if denied || joined {
continue
}
- room_new, room_sink := daemon.RoomRegister(room)
+ roomNew, roomSink := daemon.RoomRegister(room)
if key != "" {
- room_new.key = key
- room_new.StateSave()
+ roomNew.key = key
+ roomNew.StateSave()
}
- room_sink <- ClientEvent{client, EVENT_NEW, ""}
+ roomSink <- ClientEvent{client, EventNew, ""}
}
}
client := event.client
// Check for clients aliveness
- if daemon.last_aliveness_check.Add(ALIVENESS_CHECK).Before(now) {
+ if daemon.lastAlivenessCheck.Add(AlivenessCheck).Before(now) {
for c := range daemon.clients {
- aliveness, alive := daemon.client_aliveness[c]
+ aliveness, alive := daemon.clientAliveness[c]
if !alive {
continue
}
- if aliveness.timestamp.Add(PING_TIMEOUT).Before(now) {
+ if aliveness.timestamp.Add(PingTimeout).Before(now) {
log.Println(c, "ping timeout")
c.conn.Close()
continue
}
- if !aliveness.ping_sent && aliveness.timestamp.Add(PING_THRESHOLD).Before(now) {
+ if !aliveness.pingSent && aliveness.timestamp.Add(PingThreshold).Before(now) {
if c.registered {
c.Msg("PING :" + daemon.hostname)
- aliveness.ping_sent = true
+ aliveness.pingSent = true
} else {
log.Println(c, "ping timeout")
c.conn.Close()
}
}
}
- daemon.last_aliveness_check = now
+ daemon.lastAlivenessCheck = now
}
- switch event.event_type {
- case EVENT_NEW:
+ switch event.eventType {
+ case EventNew:
daemon.clients[client] = true
- daemon.client_aliveness[client] = &ClientAlivenessState{ping_sent: false, timestamp: now}
- case EVENT_DEL:
+ daemon.clientAliveness[client] = &ClientAlivenessState{pingSent: false, timestamp: now}
+ case EventDel:
delete(daemon.clients, client)
- delete(daemon.client_aliveness, client)
- for _, room_sink := range daemon.room_sinks {
- room_sink <- event
+ delete(daemon.clientAliveness, client)
+ for _, roomSink := range daemon.roomSinks {
+ roomSink <- event
}
- case EVENT_MSG:
+ case EventMsg:
cols := strings.SplitN(event.text, " ", 2)
command := strings.ToUpper(cols[0])
if daemon.Verbose {
}
if command == "QUIT" {
delete(daemon.clients, client)
- delete(daemon.client_aliveness, client)
+ delete(daemon.clientAliveness, client)
client.conn.Close()
continue
}
continue
}
if len(cols) == 1 {
- daemon.room_sinks[r] <- ClientEvent{client, EVENT_MODE, ""}
+ daemon.roomSinks[r] <- ClientEvent{client, EventMode, ""}
} else {
- daemon.room_sinks[r] <- ClientEvent{client, EVENT_MODE, cols[1]}
+ daemon.roomSinks[r] <- ClientEvent{client, EventMode, cols[1]}
}
case "MOTD":
go daemon.SendMotd(client)
client.ReplyNoChannel(room)
continue
}
- daemon.room_sinks[r] <- ClientEvent{client, EVENT_DEL, ""}
+ daemon.roomSinks[r] <- ClientEvent{client, EventDel, ""}
}
case "PING":
if len(cols) == 1 {
if !found {
client.ReplyNoNickChan(target)
}
- daemon.room_sinks[r] <- ClientEvent{client, EVENT_MSG, command + " " + strings.TrimLeft(cols[1], ":")}
+ daemon.roomSinks[r] <- ClientEvent{client, EventMsg, command + " " + strings.TrimLeft(cols[1], ":")}
case "TOPIC":
if len(cols) == 1 {
client.ReplyNotEnoughParameters("TOPIC")
} else {
change = ""
}
- daemon.room_sinks[r] <- ClientEvent{client, EVENT_TOPIC, change}
+ daemon.roomSinks[r] <- ClientEvent{client, EventTopic, change}
case "WHO":
if len(cols) == 1 || len(cols[1]) < 1 {
client.ReplyNotEnoughParameters("WHO")
client.ReplyNoChannel(room)
continue
}
- daemon.room_sinks[r] <- ClientEvent{client, EVENT_WHO, ""}
+ daemon.roomSinks[r] <- ClientEvent{client, EventWho, ""}
case "WHOIS":
if len(cols) == 1 || len(cols[1]) < 1 {
client.ReplyNotEnoughParameters("WHOIS")
client.ReplyNicknamed("421", command, "Unknown command")
}
}
- if aliveness, alive := daemon.client_aliveness[client]; alive {
+ if aliveness, alive := daemon.clientAliveness[client]; alive {
aliveness.timestamp = now
- aliveness.ping_sent = false
+ aliveness.pingSent = false
}
}
}
)
const (
- EVENT_NEW = iota
- EVENT_DEL = iota
- EVENT_MSG = iota
- EVENT_TOPIC = iota
- EVENT_WHO = iota
- EVENT_MODE = iota
- FORMAT_MSG = "[%s] <%s> %s\n"
- FORMAT_META = "[%s] * %s %s\n"
+ EventNew = iota
+ EventDel = iota
+ EventMsg = iota
+ EventTopic = iota
+ EventWho = iota
+ EventMode = iota
+ FormatMsg = "[%s] <%s> %s\n"
+ FormatMeta = "[%s] * %s %s\n"
)
// Client events going from each of client
// They can be either NEW, DEL or unparsed MSG
type ClientEvent struct {
- client *Client
- event_type int
- text string
+ client *Client
+ eventType int
+ text string
}
func (m ClientEvent) String() string {
- return string(m.event_type) + ": " + m.client.String() + ": " + m.text
+ return string(m.eventType) + ": " + m.client.String() + ": " + m.text
}
// Logging in-room events
continue
}
if event.meta {
- format = FORMAT_META
+ format = FormatMeta
} else {
- format = FORMAT_MSG
+ format = FormatMsg
}
_, err = fd.WriteString(fmt.Sprintf(format, time.Now(), event.who, event.what))
fd.Close()
events := make(chan ClientEvent)
log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile)
- log_sink := make(chan LogEvent)
+ logSink := make(chan LogEvent)
if *logdir == "" {
// Dummy logger
go func() {
- for _ = range log_sink {
+ for _ = range logSink {
}
}()
} else {
log.Fatalln("Need absolute path for logdir")
return
}
- go Logger(*logdir, log_sink)
+ go Logger(*logdir, logSink)
log.Println(*logdir, "logger initialized")
}
- state_sink := make(chan StateEvent)
- daemon := NewDaemon(*hostname, *motd, log_sink, state_sink)
+ stateSink := make(chan StateEvent)
+ daemon := NewDaemon(*hostname, *motd, logSink, stateSink)
daemon.Verbose = *verbose
if *statedir == "" {
// Dummy statekeeper
go func() {
- for _ = range state_sink {
+ for _ = range stateSink {
}
}()
} else {
log.Println("Loaded state for room", room.name)
}
}
- go StateKeeper(*statedir, state_sink)
+ go StateKeeper(*statedir, stateSink)
log.Println(*statedir, "statekeeper initialized")
}
)
var (
- RE_ROOM = regexp.MustCompile("^#[^\x00\x07\x0a\x0d ,:/]{1,200}$")
+ RERoom = regexp.MustCompile("^#[^\x00\x07\x0a\x0d ,:/]{1,200}$")
)
// Sanitize room's name. It can consist of 1 to 50 ASCII symbols
// with some exclusions. All room names will have "#" prefix.
func RoomNameValid(name string) bool {
- return RE_ROOM.MatchString(name)
+ return RERoom.MatchString(name)
}
type Room struct {
- Verbose bool
- name string
- topic string
- key string
- members map[*Client]bool
- hostname string
- log_sink chan<- LogEvent
- state_sink chan<- StateEvent
+ Verbose bool
+ name string
+ topic string
+ key string
+ members map[*Client]bool
+ hostname string
+ logSink chan<- LogEvent
+ stateSink chan<- StateEvent
}
-func NewRoom(hostname, name string, log_sink chan<- LogEvent, state_sink chan<- StateEvent) *Room {
+func NewRoom(hostname, name string, logSink chan<- LogEvent, stateSink chan<- StateEvent) *Room {
room := Room{name: name}
room.members = make(map[*Client]bool)
room.topic = ""
room.key = ""
room.hostname = hostname
- room.log_sink = log_sink
- room.state_sink = state_sink
+ room.logSink = logSink
+ room.stateSink = stateSink
return &room
}
}
// Send message to all room's subscribers, possibly excluding someone
-func (room *Room) Broadcast(msg string, client_to_ignore ...*Client) {
+func (room *Room) Broadcast(msg string, clientToIgnore ...*Client) {
for member := range room.members {
- if (len(client_to_ignore) > 0) && member == client_to_ignore[0] {
+ if (len(clientToIgnore) > 0) && member == clientToIgnore[0] {
continue
}
member.Msg(msg)
}
func (room *Room) StateSave() {
- room.state_sink <- StateEvent{room.name, room.topic, room.key}
+ room.stateSink <- StateEvent{room.name, room.topic, room.key}
}
func (room *Room) Processor(events <-chan ClientEvent) {
var client *Client
for event := range events {
client = event.client
- switch event.event_type {
- case EVENT_NEW:
+ switch event.eventType {
+ case EventNew:
room.members[client] = true
if room.Verbose {
log.Println(client, "joined", room.name)
}
room.SendTopic(client)
room.Broadcast(fmt.Sprintf(":%s JOIN %s", client, room.name))
- room.log_sink <- LogEvent{room.name, client.nickname, "joined", true}
+ room.logSink <- LogEvent{room.name, client.nickname, "joined", true}
nicknames := []string{}
for member := range room.members {
nicknames = append(nicknames, member.nickname)
sort.Strings(nicknames)
client.ReplyNicknamed("353", "=", room.name, strings.Join(nicknames, " "))
client.ReplyNicknamed("366", room.name, "End of NAMES list")
- case EVENT_DEL:
+ case EventDel:
if _, subscribed := room.members[client]; !subscribed {
client.ReplyNicknamed("442", room.name, "You are not on that channel")
continue
delete(room.members, client)
msg := fmt.Sprintf(":%s PART %s :%s", client, room.name, client.nickname)
room.Broadcast(msg)
- room.log_sink <- LogEvent{room.name, client.nickname, "left", true}
- case EVENT_TOPIC:
+ room.logSink <- LogEvent{room.name, client.nickname, "left", true}
+ case EventTopic:
if _, subscribed := room.members[client]; !subscribed {
client.ReplyParts("442", room.name, "You are not on that channel")
continue
room.topic = strings.TrimLeft(event.text, ":")
msg := fmt.Sprintf(":%s TOPIC %s :%s", client, room.name, room.topic)
go room.Broadcast(msg)
- room.log_sink <- LogEvent{room.name, client.nickname, "set topic to " + room.topic, true}
+ room.logSink <- LogEvent{room.name, client.nickname, "set topic to " + room.topic, true}
room.StateSave()
- case EVENT_WHO:
+ case EventWho:
for m := range room.members {
client.ReplyNicknamed("352", room.name, m.username, m.conn.RemoteAddr().String(), room.hostname, m.nickname, "H", "0 "+m.realname)
}
client.ReplyNicknamed("315", room.name, "End of /WHO list")
- case EVENT_MODE:
+ case EventMode:
if event.text == "" {
mode := "+"
if room.key != "" {
continue
}
var msg string
- var msg_log string
+ var msgLog string
if strings.HasPrefix(event.text, "+k") {
cols := strings.Split(event.text, " ")
if len(cols) == 1 {
}
room.key = cols[1]
msg = fmt.Sprintf(":%s MODE %s +k %s", client, room.name, room.key)
- msg_log = "set channel key to " + room.key
+ msgLog = "set channel key to " + room.key
} else if strings.HasPrefix(event.text, "-k") {
room.key = ""
msg = fmt.Sprintf(":%s MODE %s -k", client, room.name)
- msg_log = "removed channel key"
+ msgLog = "removed channel key"
}
go room.Broadcast(msg)
- room.log_sink <- LogEvent{room.name, client.nickname, msg_log, true}
+ room.logSink <- LogEvent{room.name, client.nickname, msgLog, true}
room.StateSave()
- case EVENT_MSG:
+ case EventMsg:
sep := strings.Index(event.text, " ")
room.Broadcast(fmt.Sprintf(":%s %s %s :%s", client, event.text[:sep], room.name, event.text[sep+1:]), client)
- room.log_sink <- LogEvent{room.name, client.nickname, event.text[sep+1:], false}
+ room.logSink <- LogEvent{room.name, client.nickname, event.text[sep+1:], false}
}
}
}
"testing"
)
-func no_nickchan(t *testing.T, c *TestingConn) {
+func noNickchan(t *testing.T, c *TestingConn) {
if r := <-c.outbound; !strings.HasPrefix(r, ":foohost 401") {
t.Fatal("no nick/channel", r)
}
}
-func no_chan(t *testing.T, c *TestingConn) {
+func noChan(t *testing.T, c *TestingConn) {
if r := <-c.outbound; !strings.HasPrefix(r, ":foohost 403") {
t.Fatal("no channel", r)
}
}
-func not_enough_params(t *testing.T, c *TestingConn) {
+func notEnoughParams(t *testing.T, c *TestingConn) {
if r := <-c.outbound; !strings.HasPrefix(r, ":foohost 461") {
t.Fatal("not enough params", r)
}
}
func TestTwoUsers(t *testing.T) {
- log_sink := make(chan LogEvent, 8)
- state_sink := make(chan StateEvent, 8)
- daemon := NewDaemon("foohost", "", log_sink, state_sink)
+ logSink := make(chan LogEvent, 8)
+ stateSink := make(chan StateEvent, 8)
+ daemon := NewDaemon("foohost", "", logSink, stateSink)
events := make(chan ClientEvent)
go daemon.Processor(events)
}
conn1.inbound <- "WHOIS"
- not_enough_params(t, conn1)
+ notEnoughParams(t, conn1)
conn1.inbound <- "WHOIS nick3"
- no_nickchan(t, conn1)
+ noNickchan(t, conn1)
conn1.inbound <- "WHOIS nick2"
if r := <-conn1.outbound; r != ":foohost 311 nick1 nick2 foo2 Unknown * :Long name2\r\n" {
t.Fatal("first WHOIS 311", r)
}
conn1.inbound <- "WHO"
- not_enough_params(t, conn1)
+ notEnoughParams(t, conn1)
conn1.inbound <- "WHO #fooroom"
- no_chan(t, conn1)
+ noChan(t, conn1)
conn1.inbound <- "JOIN #foo"
conn2.inbound <- "JOIN #foo"
}
func TestJoin(t *testing.T) {
- log_sink := make(chan LogEvent, 8)
- state_sink := make(chan StateEvent, 8)
- daemon := NewDaemon("foohost", "", log_sink, state_sink)
+ logSink := make(chan LogEvent, 8)
+ stateSink := make(chan StateEvent, 8)
+ daemon := NewDaemon("foohost", "", logSink, stateSink)
events := make(chan ClientEvent)
go daemon.Processor(events)
conn := NewTestingConn()
}
conn.inbound <- "JOIN"
- not_enough_params(t, conn)
+ notEnoughParams(t, conn)
conn.inbound <- "JOIN bla/bla/bla"
- no_chan(t, conn)
+ noChan(t, conn)
conn.inbound <- "JOIN bla:bla:bla"
- no_chan(t, conn)
+ noChan(t, conn)
conn.inbound <- "JOIN #foo"
if r := <-conn.outbound; r != ":foohost 331 nick2 #foo :No topic is set\r\n" {
if r := <-conn.outbound; r != ":foohost 366 nick2 #foo :End of NAMES list\r\n" {
t.Fatal("no end of NAMES list", r)
}
- if r := <-log_sink; (r.what != "joined") || (r.where != "#foo") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "joined") || (r.where != "#foo") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("invalid join log event", r)
}
if _, ok := daemon.rooms["#baz"]; !ok {
t.Fatal("#baz does not exist")
}
- if r := <-log_sink; (r.what != "joined") || (r.where != "#bar") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "joined") || (r.where != "#bar") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("invalid join log event #bar", r)
}
- if r := <-log_sink; (r.what != "joined") || (r.where != "#baz") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "joined") || (r.where != "#baz") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("invalid join log event #baz", r)
}
if daemon.rooms["#bazenc"].key != "key2" {
t.Fatal("no room with key2")
}
- if r := <-log_sink; (r.what != "joined") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "joined") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("invalid join log event #barenc", r)
}
- if r := <-log_sink; (r.what != "joined") || (r.where != "#bazenc") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "joined") || (r.where != "#bazenc") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("invalid join log event #bazenc", r)
}
- if r := <-state_sink; (r.topic != "") || (r.where != "#barenc") || (r.key != "key1") {
+ if r := <-stateSink; (r.topic != "") || (r.where != "#barenc") || (r.key != "key1") {
t.Fatal("set channel key1 state", r)
}
- if r := <-state_sink; (r.topic != "") || (r.where != "#bazenc") || (r.key != "key2") {
+ if r := <-stateSink; (r.topic != "") || (r.where != "#bazenc") || (r.key != "key2") {
t.Fatal("set channel key2 state", r)
}
if daemon.rooms["#barenc"].key != "" {
t.Fatal("removing key from #barenc")
}
- if r := <-log_sink; (r.what != "removed channel key") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "removed channel key") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("removed channel key log", r)
}
- if r := <-state_sink; (r.topic != "") || (r.where != "#barenc") || (r.key != "") {
+ if r := <-stateSink; (r.topic != "") || (r.where != "#barenc") || (r.key != "") {
t.Fatal("removed channel key state", r)
}
if r := <-conn.outbound; r != ":foohost 442 #bazenc :You are not on that channel\r\n" {
t.Fatal("not on that channel", r)
}
- if r := <-log_sink; (r.what != "left") || (r.where != "#bazenc") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "left") || (r.where != "#bazenc") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("left #bazenc log", r)
}
if r := <-conn.outbound; r != ":nick2!foo2@someclient MODE #barenc +k newkey\r\n" {
t.Fatal("+k MODE setting", r)
}
- if r := <-log_sink; (r.what != "set channel key to newkey") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "set channel key to newkey") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("set channel key", r)
}
- if r := <-state_sink; (r.topic != "") || (r.where != "#barenc") || (r.key != "newkey") {
+ if r := <-stateSink; (r.topic != "") || (r.where != "#barenc") || (r.key != "newkey") {
t.Fatal("set channel newkey state", r)
}
if r := <-conn.outbound; r != ":nick2!foo2@someclient TOPIC #barenc :New topic\r\n" {
t.Fatal("set TOPIC", r)
}
- if r := <-log_sink; (r.what != "set topic to New topic") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
+ if r := <-logSink; (r.what != "set topic to New topic") || (r.where != "#barenc") || (r.who != "nick2") || (r.meta != true) {
t.Fatal("set TOPIC log", r)
}
- if r := <-state_sink; (r.topic != "New topic") || (r.where != "#barenc") || (r.key != "newkey") {
+ if r := <-stateSink; (r.topic != "New topic") || (r.where != "#barenc") || (r.key != "newkey") {
t.Fatal("set channel TOPIC state", r)
}