Example #1
0
// RemoveModule will first remove all commands and listeners of a module from the handler. It will
// then remove its RPC client.
func (h *Handler) RemoveModule(name ModuleName) {
	h.mu.Lock()
	defer h.mu.Unlock()

	// Let's make sure we haven't already removed the module, as removal can be initiated by
	// multiple sources.
	if !h.ModuleExists(string(name)) {
		// Our job here is/was done
		return
	}

	// Remove all commands
	for cmd, modname := range h.Commands {
		if modname == name {
			delete(h.Commands, cmd)
		}
	}

	// Remove all triggers
	for event, modnames := range h.Triggers {
		for i, modname := range modnames {
			if modname == name {
				rlog.Debug("here", "here")
				h.Triggers[event] = append(h.Triggers[event][:i], h.Triggers[event][i+1:]...)
			}
		}
	}

	// And finally remove from handler
	delete(h.Modules, name)
}
Example #2
0
// EnableModules goes through every module list found in the config and sets them up appropriately.
func (b *Bot) EnableModules() {
	rlog.Info("Bot", "Enabling Modules...")

	b.Handler.AddRemoveCallback(func(name ModuleName) {
		b.Modules[strings.ToLower(string(name))].Registered = false
	})

	for modtype, modules := range b.Config.Module.Modules {
		for name, value := range modules {
			route, optionsArray := b.Parser.ParseModuleValue(value)

			optionsMap := make(map[string]bool)
			for _, opt := range optionsArray {
				optionsMap[opt] = true
			}

			if route == "." {
				route = DefaultModulesRoute + modtype
			}

			b.Modules[strings.ToLower(name)] = NewModule(name, route, optionsMap, modtype)
			rlog.Debug("Bot", "Module "+name+" Created")
		}
	}
	b.loadModules()
}
Example #3
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
}
Example #4
0
// RegisterCommand registers a command from a module with the handler. The command request
// holds the command's name and the module it belongs to (used to signal the module to fire the
// command).
func (b BotAPI) RegisterCommand(cr CommandRequest, result *string) error {
	b.bot.Handler.AddCommand(CommandName(cr.CommandName), ModuleName(cr.ModuleName))
	rlog.Debug("Bot", "Added: "+cr.CommandName+" for module: "+cr.ModuleName)
	return nil
}