Class: ModSpox::Bot

Inherits:
Object
  • Object
show all
Defined in:
lib/mod_spox/Bot.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Bot

Create a Bot



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/mod_spox/Bot.rb', line 29

def initialize
    Logger.severity($VERBOSITY)
    Logger.fd
    clean_models
    @start_time = Time.now
    @pipeline = Pipeline.new
    @timer = Timer.new(@pipeline)
    @config = BaseConfig.new(BotConfig[:userconfigpath])
    @factory = MessageFactory.new(@pipeline)
    @socket = nil
    @plugin_manager = PluginManager.new(@pipeline)
    @shutdown = false
    @socket = nil
    @nick = nil
    @thread = Thread.current
    @waiter = Monitors::Boolean.new
    hook_pipeline
end

Instance Attribute Details

#factory ⇒ Object (readonly)

message factory



26
27
28
 
# File 'lib/mod_spox/Bot.rb', line 26

def factory
  @factory
end

#pipeline ⇒ Object (readonly)

message pipeline



20
21
22
 
# File 'lib/mod_spox/Bot.rb', line 20

def pipeline
  @pipeline
end

#plugin_manager ⇒ Object (readonly)

plugin manager



23
24
25
 
# File 'lib/mod_spox/Bot.rb', line 23

def plugin_manager
  @plugin_manager
end

#timer ⇒ Object (readonly)

bot timer



17
18
19
 
# File 'lib/mod_spox/Bot.rb', line 17

def timer
  @timer
end

Instance Method Details

#admin(message) ⇒ Object

message

Messages::Outgoing::Admin message

Sends ADMIN message to server



360
361
362
 
# File 'lib/mod_spox/Bot.rb', line 360

def admin(message)
    @socket << "ADMIN #{message.target}"
end

#away(message) ⇒ Object

message

Messages::Outgoing::Away message

Sends AWAY message to server



424
425
426
 
# File 'lib/mod_spox/Bot.rb', line 424

def away(message)
    @socket << "AWAY :#{message.message}"
end

#bot_connect(message) ⇒ Object

message

Messages::Internal::EstablishConnection message

Initialize connection to IRC server



88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/mod_spox/Bot.rb', line 88

def bot_connect(message)
    Logger.log("Received a connection command", 10)
    begin
        @socket = Socket.new(self, message.server, message.port)
        @socket.connect
        @pipeline << Messages::Internal::Connected.new(message.server, message.port)
    rescue Object => boom
        Logger.log("Failed connection to server: #{boom}")
        @pipeline << Messages::Internal::ConnectionFailed.new(message.server, message.port)
    end
end

#channel_mode(message) ⇒ Object

message

Messages::Outgoing::ChannelMode message

Sends MODE message to server



237
238
239
240
241
242
243
 
# File 'lib/mod_spox/Bot.rb', line 237

def channel_mode(message)
    target = message.target
    channel = message.channel
    target = target.nick if target.is_a?(Models::Nick)
    channel = channel.name if channel.is_a?(Models::Channel)
    @socket << "MODE #{channel} #{message.mode} #{target}"
end

#clear_timer(message) ⇒ Object

message

Messages::Internal::TimerClear

Clear all actions from timer



147
148
149
 
# File 'lib/mod_spox/Bot.rb', line 147

def clear_timer(message)
    @timer.clear
end

#connect(message) ⇒ Object

message

Messages::Outgoing::Connect message

Sends CONNECT message to server



348
349
350
 
# File 'lib/mod_spox/Bot.rb', line 348

def connect(message)
    @socket << "CONNECT #{message.target_server} #{message.port} #{message.remote_server}"
end

#die(message) ⇒ Object

message

Messages::Outgoing::Die message

Sends DIE message to server



442
443
444
 
# File 'lib/mod_spox/Bot.rb', line 442

def die(message)
    @socket << "DIE"
end

#disconnected(message) ⇒ Object

message

Messages::Internal::Disconnected

Disconnect the bot from the IRC server



153
154
155
156
 
# File 'lib/mod_spox/Bot.rb', line 153

def disconnected(message)
    @socket.shutdown
    @socket = nil
end

#get_nick(message) ⇒ Object

message

Messages::Internal::NickRequest

Sends the bot’s nick to plugins



172
173
174
 
# File 'lib/mod_spox/Bot.rb', line 172

def get_nick(message)
    @pipeline << Messages::Internal::NickResponse(message.requester, @nick)
end

#halt(message) ⇒ Object

Stop the bot



159
160
161
162
 
# File 'lib/mod_spox/Bot.rb', line 159

def halt(message)
    @shutdown = true
    @thread.run
end

#hook_pipeline ⇒ Object

Adds hooks to pipeline for processing messages



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/mod_spox/Bot.rb', line 115

def hook_pipeline
    {:Outgoing_Admin => :admin, :Outgoing_Away => :away,
     :Outgoing_ChannelMode => :channel_mode, :Outgoing_Connect => :connect,
     :Outgoing_Die => :die, :Outgoing_Info => :info,
     :Outgoing_Invite => :invite, :Outgoing_Ison => :ison,
     :Outgoing_Join => :join, :Outgoing_Kick => :kick,
     :Outgoing_Kill => :kill, :Outgoing_Links => :links,
     :Outgoing_List => :list, :Outgoing_Lusers => :lusers,
     :Outgoing_Motd => :motd, :Outgoing_Names => :names,
     :Outgoing_Nick => :nick, :Outgoing_Notice => :notice,
     :Outgoing_Oper => :oper, :Outgoing_Part => :part,
     :Outgoing_Pass => :pass, :Outgoing_Ping => :ping,
     :Outgoing_Pong => :pong, :Outgoing_Privmsg => :privmsg,
     :Outgoing_Quit => :quit, :Outgoing_Rehash => :rehash,
     :Outgoing_ServList => :servlist, :Outgoing_Squery => :squery,
     :Outgoing_Squit => :squit, :Outgoing_Stats => :stats,
     :Outgoing_Summon => :summon, :Outgoing_Time => :time,
     :Outgoing_Topic => :topic, :Outgoing_Trace => :trace,
     :Outgoing_Unaway => :unaway, :Outgoing_User => :user,
     :Outgoing_UserHost => :userhost, :Outgoing_UserMode => :user_mode,
     :Outgoing_Users => :users, :Outgoing_Version => :version,
     :Outgoing_Who => :who, :Outgoing_WhoWas => :whowas,
     :Outgoing_Whois => :whois, :Internal_EstablishConnection => :bot_connect,
     :Internal_StatusRequest => :status, :Internal_ChangeNick => :set_nick,
     :Internal_NickRequest => :get_nick, :Internal_HaltBot => :halt,
     :Internal_Disconnected => :disconnected, :Internal_TimerClear => :clear_timer,
     :Outgoing_Raw => :raw
     }.each_pair{ |type,method| @pipeline.hook(self, method, type) }
end

#info(message) ⇒ Object

message

Messages::Outgoing::Info message

Sends INFO message to server



366
367
368
 
# File 'lib/mod_spox/Bot.rb', line 366

def info(message)
    @socket << "INFO #{message.target}"
end

#invite(message) ⇒ Object

message

Messages::Outgoing::Invite message

Sends INVITE message to server



268
269
270
271
272
 
# File 'lib/mod_spox/Bot.rb', line 268

def invite(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "INVITE #{nick} #{channel}"
end

#ison(message) ⇒ Object

message

Messages::Outgoing::Ison message

Sends ISON message to server



478
479
480
481
 
# File 'lib/mod_spox/Bot.rb', line 478

def ison(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "ISON #{nick}"
end

#join(message) ⇒ Object

message

Messages::Outgoing::Join message

Sends JOIN message to server



223
224
225
226
 
# File 'lib/mod_spox/Bot.rb', line 223

def join(message)
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "JOIN #{channel} #{message.key}"
end

#kick(message) ⇒ Object

message

Messages::Outgoing::Kick message

Sends KICK message to server



276
277
278
279
280
 
# File 'lib/mod_spox/Bot.rb', line 276

def kick(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "KICK #{channel} #{nick} :#{message.reason}"
end

#kill(message) ⇒ Object

message

Messages::Outgoing::Kill message

Sends KILL message to server



405
406
407
408
 
# File 'lib/mod_spox/Bot.rb', line 405

def kill(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "KILL #{nick} :#{message.comment}"
end

#links(message) ⇒ Object

message

Messages::Outgoing::Links message

Sends LINKS message to server



336
337
338
 
# File 'lib/mod_spox/Bot.rb', line 336

def links(message)
    @socket << "LIST #{message.server} #{message.mask}"
end

#list(message) ⇒ Object

message

Messages::Outgoing::List message

Sends LIST message to server



261
262
263
264
 
# File 'lib/mod_spox/Bot.rb', line 261

def list(message)
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "LIST #{channel}"
end

#lusers(message) ⇒ Object

message

Messages::Outgoing::Lusers message

Sends LUSERS message to server



317
318
319
 
# File 'lib/mod_spox/Bot.rb', line 317

def lusers(message)
    @socket << "LUSERS #{message.mask} #{message.target}"
end

#motd(message) ⇒ Object

message

Messages::Outgoing::Motd message

Sends MOTD message to server



311
312
313
 
# File 'lib/mod_spox/Bot.rb', line 311

def motd(message)
    @socket << "MOTD #{message.target}"
end

#names(message) ⇒ Object

message

Messages::Outgoing::Names message

Sends NAMES message to server



254
255
256
257
 
# File 'lib/mod_spox/Bot.rb', line 254

def names(message)
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "NAMES #{channel} #{message.target}"
end

#nick(message) ⇒ Object

message

Messages::Outgoing::Nick message

Sends NICK message to server



184
185
186
187
 
# File 'lib/mod_spox/Bot.rb', line 184

def nick(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "NICK #{nick}"
end

#notice(message) ⇒ Object

message

Messages::Outgoing::Notice message

Sends NOTICE message to server



303
304
305
306
307
 
# File 'lib/mod_spox/Bot.rb', line 303

def notice(message)
    target = message.target.name if message.target.is_a?(Models::Channel)
    target = message.target.nick if message.target.is_a?(Models::Nick)
    @socket << "NOTICE #{target} :#{message}"
end

#oper(message) ⇒ Object

message

Messages::Outgoing::Oper message

Sends Oper message to server



197
198
199
 
# File 'lib/mod_spox/Bot.rb', line 197

def oper(message)
    @socket << "OPER #{message.name} #{message.password}"
end

#part(message) ⇒ Object

message

Messages::Outgoing::Part message

Sends PART message to server



230
231
232
233
 
# File 'lib/mod_spox/Bot.rb', line 230

def part(message)
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "PART #{channel} :#{message.reason}"
end

#pass(message) ⇒ Object

message

Messages::Outgoing::Pass message

Sends PASS message to server



178
179
180
 
# File 'lib/mod_spox/Bot.rb', line 178

def pass(message)
    @socket << "PASS #{message.password}"
end

#ping(message) ⇒ Object

message

Messages::Outgoing::Ping message

Sends PING message to server



412
413
414
 
# File 'lib/mod_spox/Bot.rb', line 412

def ping(message)
    @socket << "PING #{message.message}"
end

#pong(message) ⇒ Object

message

Messages::Outgoing::Pong message

Sends PONG message to server



418
419
420
 
# File 'lib/mod_spox/Bot.rb', line 418

def pong(message)
    @socket << "PONG #{message.server} #{message.string.nil? ? '' : ":#{message.string}"}"
end

#privmsg(message) ⇒ Object

message

Messages::Outgoing::Privmsg message

Sends PRIVMSG message to server



284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
 
# File 'lib/mod_spox/Bot.rb', line 284

def privmsg(message)
    target = message.target.name if message.target.is_a?(Models::Channel)
    target = message.target.nick if message.target.is_a?(Models::Nick)
    target = message.target unless target
    messages = message.message.is_a?(Array) ? message.message : [message.message]
    messages.each do |part|
        part.split("\n").each do |content|
            while(content.size > 450)
                output = content[0..450]
                content.slice!(0, 450) #(450, content.size)
                @socket << "PRIVMSG #{target} :#{message.is_action? ? "\cAACTION #{output}\cA" : output}"
            end
            @socket << "PRIVMSG #{target} :#{message.is_action? ? "\cAACTION #{content}\cA" : content}"
        end
    end
end

#quit(message) ⇒ Object

message

Messages::Outgoing::Quit message

Sends QUIT message to server



211
212
213
 
# File 'lib/mod_spox/Bot.rb', line 211

def quit(message)
    @socket << "QUIT :#{message.message}"
end

#raw(message) ⇒ Object

message

Messages::Outoing::Raw message

Send raw message to server



485
486
487
 
# File 'lib/mod_spox/Bot.rb', line 485

def raw(message)
    @socket << message.message
end

#rehash(message) ⇒ Object

message

Messages::Outgoing::Rehash message

Sends REHASH message to server



436
437
438
 
# File 'lib/mod_spox/Bot.rb', line 436

def rehash(message)
    @socket << "REHASH"
end

#reload ⇒ Object

Reload the bot (basically a restart)



82
83
84
 
# File 'lib/mod_spox/Bot.rb', line 82

def reload
    @thread.run
end

#restart(message) ⇒ Object

message

Messages::Outgoing::Restart message

Sends RESTART message to server



448
449
450
 
# File 'lib/mod_spox/Bot.rb', line 448

def restart(message)
    @socket << "RESTART"
end

#run ⇒ Object

Run the bot



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/mod_spox/Bot.rb', line 49

def run
    trap('SIGTERM'){ Logger.log("Caught SIGTERM"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
    trap('SIGKILL'){ Logger.log("Caught SIGKILL"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
    trap('SIGINT'){ Logger.log("Caught SIGINT"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
    trap('SIGQUIT'){ Logger.log("Caught SIGQUIT"); @shutdown = true; @waiter.wakeup; sleep(0.1); Thread.current.exit; Logger.kill; }
    until @shutdown do
        @timer.start
        @pipeline << Messages::Internal::BotInitialized.new
        begin
            @waiter.wait
        rescue Object => boom
            Logger.log("Caught exception: #{boom}")
        end
        shutdown
    end
end

#servlist(message) ⇒ Object

message

Messages::Outgoing::ServList message

Sends SERVLIST message to server



372
373
374
 
# File 'lib/mod_spox/Bot.rb', line 372

def servlist(message)
    @socket << "SERVLIST #{message.mask} #{message.type}"
end

#set_nick(message) ⇒ Object

message

Messages::Internal::ChangeNick message

Changes the bot’s nick to the given nick



166
167
168
 
# File 'lib/mod_spox/Bot.rb', line 166

def set_nick(message)
    @nick = message.new_nick
end

#shutdown ⇒ Object

Shut the bot down



67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/mod_spox/Bot.rb', line 67

def shutdown
    @shutdown = true
    @plugin_manager.destroy_plugins
    @thread.run
    @timer.stop
    @timer.destroy
    @factory.destroy
    @pipeline << Messages::Internal::Shutdown.new
    sleep(0.1)
    @pipeline.destroy
    @socket.shutdown unless @socket.nil?
    clean_models
end

#squery(message) ⇒ Object

message

Messages::Outgoing::Squery message

Sends SQUERY message to server



378
379
380
 
# File 'lib/mod_spox/Bot.rb', line 378

def squery(message)
    @socket << "SQUERY #{message.service_name} #{message.message}"
end

#squit(message) ⇒ Object

message

Messages::Outgoing::Squit message

Sends SQUIT message to server



217
218
219
 
# File 'lib/mod_spox/Bot.rb', line 217

def squit(message)
    @socket << "SQUIT #{message.server} :#{message.comment}"
end

#stats(message) ⇒ Object

message

Messages::Outgoing::Stats message

Sends STATS message to server

Raises:



107
108
109
110
111
112
 
# File 'lib/mod_spox/Bot.rb', line 107

def stats
    return ["Uptime: #{Helpers::format_seconds(@start_time - Time.now)}",
            "Plugins: #{@plugins.plugins.size} loaded",
            "Lines sent: #{@socket.sent}",
            "Lines received: #{@socket.received}"].join(' ')
end

#status(message) ⇒ Object

message

Messages::Internal::StatusRequest message

Returns the current status of the bot



102
103
104
 
# File 'lib/mod_spox/Bot.rb', line 102

def status(message)
    @pipeline << Messages::Internal::StatusResponse(message.requester, stats)
end

#summon(message) ⇒ Object

message

Messages::Outgoing::Summon message

Sends SUMMON message to server



454
455
456
457
458
 
# File 'lib/mod_spox/Bot.rb', line 454

def summon(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "SUMMON #{nick} #{message.target} #{channel}"
end

#time(message) ⇒ Object

message

Messages::Outgoing::Time message

Sends TIME message to server



342
343
344
 
# File 'lib/mod_spox/Bot.rb', line 342

def time(message)
    @socket << "TIME #{message.target}"
end

#topic(message) ⇒ Object

message

Messages::Outgoing::Topic message

Sends TOPIC message to server



247
248
249
250
 
# File 'lib/mod_spox/Bot.rb', line 247

def topic(message)
    channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
    @socket << "TOPIC #{channel} :#{message.topic}"
end

#trace(message) ⇒ Object

message

Messages::Outgoing::Trace message

Sends TRACE message to server



354
355
356
 
# File 'lib/mod_spox/Bot.rb', line 354

def trace(message)
    @socket << "TRACE #{message.target}"
end

#unaway(message) ⇒ Object

message

Messages::Outgoing::Unaway message

Sends AWAY message to server



430
431
432
 
# File 'lib/mod_spox/Bot.rb', line 430

def unaway(message)
    @socket << "AWAY"
end

#user(message) ⇒ Object

message

Messages::Outgoing::User message

Sends USER message to server



191
192
193
 
# File 'lib/mod_spox/Bot.rb', line 191

def user(message)
    @socket << "USER #{message.username} #{message.mode} * :#{message.real_name}"
end

#user_mode(message) ⇒ Object

message

Messages::Outgoing::UserMode message

Sends MODE message to server

Raises:



203
204
205
206
207
 
# File 'lib/mod_spox/Bot.rb', line 203

def user_mode(message)
    raise Exceptions::InvalidValue.new('Mode must be in the form of: [+-][a-z]+') unless message.mode =~ /^[+\-][a-z]+$/
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "MODE #{nick} #{message.mode}"
end

#userhost(message) ⇒ Object

message

Messages::Outgoing::UserHost message

Sends USERHOST message to server



471
472
473
474
 
# File 'lib/mod_spox/Bot.rb', line 471

def userhost(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "USERHOST #{nick}"
end

#users(message) ⇒ Object

message

Messages::Outgoing::Users message

Sends USERS message to server



462
463
464
 
# File 'lib/mod_spox/Bot.rb', line 462

def users(message)
    @socket << "USERS #{message.target}"
end

#version(message) ⇒ Object

message

Messages::Outgoing::Version message

Sends VERSION message to server



323
324
325
 
# File 'lib/mod_spox/Bot.rb', line 323

def version(message)
    @socket << "VERSION #{message.target}"
end

#wallops ⇒ Object 



466
467
 
# File 'lib/mod_spox/Bot.rb', line 466

def wallops
end

#who(message) ⇒ Object

message

Messages::Outgoing::Who message

Sends WHO message to server



384
385
386
387
 
# File 'lib/mod_spox/Bot.rb', line 384

def who(message)
    o = message.only_ops? ? 'o' : ''
    @socket << "WHO #{message.mask} #{o}"
end

#whois(message) ⇒ Object

message

Messages::Outgoing::Whois message

Sends WHOIS message to server



391
392
393
394
 
# File 'lib/mod_spox/Bot.rb', line 391

def whois(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "WHOIS #{message.target_server} #{nick}"
end

#whowas(message) ⇒ Object

message

Messages::Outgoing::WhoWas message

Sends WHOWAS message to server



398
399
400
401
 
# File 'lib/mod_spox/Bot.rb', line 398

def whowas(message)
    nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
    @socket << "WHOWAS #{message.nick} #{message.count} #{message.target}"
end