Ejemplo n.º 1
0
func (h *Handler) removeUnstableClient(name ModuleName, err error) {
	// RPC call failed, module deemed unstable and is therefore removed

	// Signal a clean up to module
	rlog.Warn("Handler", "Removing "+string(name)+" [Module Client] due to RPC error: "+
		err.Error())

	err = h.SignalCleanup(name)
	if err != nil {
		rlog.Warn("Handler", string(name)+
			" [Module Client] did not successfully clean up, it will still be removed.")
	}

	h.RemoveModule(name)
	h.signalRemove(name)
}
Ejemplo n.º 2
0
// Limiter will rate limit inbound or outbound actions. If lim is Inlim, it will rate limit using
// the inbound rate limiter. If lim is Outlim, it will limit using the outbound limiter. A chan is
// is returned to the caller. It will be fulfilled when the rate limiter is able to act or when the
// bot has quit. Therefore a caller should check the value, as a false indicates that the bot's
// connection has been closed and no more inbound or outbound actions should be acted upon.
func (b *Bot) Limiter(lim string) chan bool {
	ch := make(chan bool, 1)

	go func(ch chan bool) {
		var r *rate.Reservation

		if lim == Inlim {
			r = b.Inlim.Reserve()
		} else if lim == Outlim {
			r = b.Outlim.Reserve()
		} else {
			ch <- false
		}

		if !r.OK() {
			rlog.Warn("Bot", lim+" not able to act")
		}

		// If in case the delay wins over the quit, the handler will have appropriated measures.
		select {
		case <-time.After(r.Delay()):
			ch <- true
		case <-b.quit:
			ch <- false
		case <-b.Client.Quit():
			ch <- false
		}
	}(ch)

	return ch
}
Ejemplo n.º 3
0
// RplTopic will set the topic for a created channel
func (l *Listeners) RplTopic(msg *irc.Message) {
	l.bot.Mu.Lock()

	name := msg.Params[1]
	topic := msg.Trailing

	channel, ok := l.bot.Channels[strings.ToLower(name)]

	if !ok {
		rlog.Warn("Bot", "Got RPL_TOPIC for a channel that hasn't been initialized yet")
	} else {
		channel.Topic = topic
	}

	l.bot.Mu.Unlock()
}
Ejemplo n.º 4
0
// Register registers a module with the bot. With the given port number in the Ticket, the bot
// creates a new rpc provider client connection to the module. The module is kept in the handler
// for event dispatching and module management.
func (b BotAPI) Register(t Ticket, result *string) error {
	rlog.Debug("Bot", "Starting registration for "+t.ModuleName+" [Module Client]")

	client, err := RpcCodecClientWithPort(t.Port)
	if err != nil {
		rlog.Error("Bot", "Could not establish an RPC client: "+err.Error())
		return err
	}

	module := rpc.NewClientWithCodec(client)
	if module == nil {
		rlog.Warn("Bot", "Could not register:"+t.ModuleName)
		return errors.New("Failed to regsiter module")
	}

	b.bot.Handler.AddModule(ModuleName(strings.ToLower(t.ModuleName)), module)
	b.bot.Modules[strings.ToLower(t.ModuleName)].Registered = true

	rlog.Debug("Bot", "Registered "+t.ModuleName+" on port "+t.Port)
	return nil
}
Ejemplo n.º 5
0
// RplNamreply will insert all users into the corresponding channel
func (l *Listeners) RplNamreply(msg *irc.Message) {
	l.bot.Mu.Lock()
	defer l.bot.Mu.Unlock()

	channel, ok := l.bot.Channels[strings.ToLower(msg.Params[2])]
	users := strings.Split(strings.Trim(msg.Trailing, " "), " ")

	if !ok {
		rlog.Warn("Bot", "Got RPL_NAMREPLY for a channel that hasn't been initialized yet")
		return
	}

	for _, user := range users {
		var name, rank string

		if strings.ContainsAny(string(user[0]), "+ & ~ & @ & &") {
			name, rank = user[1:], string(user[0])
		} else {
			name, rank = user, ""
		}

		channel.Users[name] = rank
	}
}