Class: AgentXmpp::MessageDelegate

Inherits:
Object
  • Object
show all
Defined in:
lib/agent_xmpp/client/message_delegate.rb

Overview

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.pubsub_service ⇒ Object (readonly)

.….….….….….….….….….….….….….….….….….….….….….….….….….….



11
12
13
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 11

def pubsub_service
  @pubsub_service
end

Class Method Details

.did_authenticate(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



112
113
114
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 112

def did_authenticate(pipe)
  AgentXmpp.logger.info "AUTHENTICATED"
end

.did_bind(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. authentication .….….….….….….….….….….….….….….….….….….….….….….….….….….



100
101
102
103
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 100

def did_bind(pipe)
  AgentXmpp.logger.info "DID BIND TO RESOURCE: #{AgentXmpp.jid.resource}"
  Xmpp::Iq.session(pipe) if pipe.stream_features.has_key?('session')
end

.did_connect(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. connection .….….….….….….….….….….….….….….….….….….….….….….….….….….



82
83
84
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 82

def did_connect(pipe)
  AgentXmpp.logger.info "CONNECTED"
end

.did_disconnect(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



87
88
89
90
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 87

def did_disconnect(pipe)
  AgentXmpp.logger.warn "DISCONNECTED"
  EventMachine::stop_event_loop
end

.did_discover_pupsub_collection(pipe, jid, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



461
462
463
464
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 461

def did_discover_pupsub_collection(pipe, jid, node)
  AgentXmpp.logger.info "DISCOVERED PUBSUB COLLECTION: #{jid}, #{node}"
  Xmpp::IqDiscoItems.get(pipe, jid, node) if pubsub_service.eql?(jid)
end

.did_discover_pupsub_leaf(pipe, jid, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



467
468
469
470
471
472
473
474
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 467

def did_discover_pupsub_leaf(pipe, jid, node)
  AgentXmpp.logger.info "DISCOVERED PUBSUB LEAF: #{jid}, #{node}"        
  if node.eql?(AgentXmpp.pubsub_root) or node.eql?(AgentXmpp.user_pubsub_root)          
    Xmpp::IqDiscoItems.get(pipe, jid, node)
  else
    Boot.call_if_implemented(:call_discovered_pubsub_node, jid, node)
  end
end

.did_discover_pupsub_service(pipe, jid) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



450
451
452
453
454
455
456
457
458
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 450

def did_discover_pupsub_service(pipe, jid)
  AgentXmpp.logger.info "DISCOVERED PUBSUB SERVICE: #{jid}"
  req = [Xmpp::IqPubSub.subscriptions(pipe, jid.to_s)]
  unless pubsub_service
    add_publish_methods(pipe, jid)
    @pubsub_service = jid
     req += [Xmpp::IqDiscoItems.get(pipe, jid.to_s)] + init_remote_services(pipe)
  end; req
end

.did_discover_user_pubsub_root(pipe, pubsub, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



477
478
479
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 477

def did_discover_user_pubsub_root(pipe, pubsub, node)
  AgentXmpp.logger.info "DISCOVERED USER PUBSUB ROOT: #{pubsub.to_s}, #{node}"
end

.did_not_authenticate(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….

Raises:



117
118
119
120
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 117

def did_not_authenticate(pipe)
  AgentXmpp.logger.info "AUTHENTICATION FAILED"
  raise AgentXmppError, "authentication failed"
end

.did_not_connect(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



93
94
95
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 93

def did_not_connect(pipe)
  AgentXmpp.logger.warn "CONNECTION FAILED"
end

.did_receive_all_roster_items(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



265
266
267
268
269
270
271
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 265

def did_receive_all_roster_items(pipe)
  AgentXmpp.logger.info "RECEIVED ALL ROSTER ITEMS"   
  AgentXmpp.roster.find_all_by_status(:inactive).map do |r|
    AgentXmpp.logger.info "ADDING CONTACT: #{r.jid}" 
    [Xmpp::IqRoster.update(pipe, r.jid, r.groups), Xmpp::Presence.subscribe(r.jid)]  
  end
end

.did_receive_command_set(pipe, stanza) ⇒ Object

event flow delegate methods .….….….….….….….….….….….….….….….….….….….….….….….….….…. process command .….….….….….….….….….….….….….….….….….….….….….….….….….….



18
19
20
21
22
23
24
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 18

def did_receive_command_set(pipe, stanza)
  command = stanza.command
  params = {:xmlns => 'jabber:x:data', :action => command.action, :to => stanza.from.to_s, 
    :from => stanza.from.to_s, :node => command.node, :id => stanza.id}
  AgentXmpp.logger.info "RECEIVED COMMAND NODE: #{command.node}, FROM: #{stanza.from.to_s}"
  Controller.new(pipe, params).invoke_execute
end

.did_receive_discoinfo_error(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



379
380
381
382
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 379

def did_receive_discoinfo_error(pipe, result)   
  from_jid = result.from
  AgentXmpp.logger.warn "RECEIVED DISCO INFO ERROR FROM: #{from_jid.to_s}, #{result.query.node}"
end

.did_receive_discoinfo_get(pipe, request) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 326

def did_receive_discoinfo_get(pipe, request)   
  from_jid = request.from
  if AgentXmpp.roster.has_jid?(from_jid)
    if request.query.node.nil?
      AgentXmpp.logger.info "RECEIVED DISCO INFO REQUEST FROM: #{from_jid.to_s}"
      Xmpp::IqDiscoInfo.result(pipe, request)
    else
      AgentXmpp.logger.info "RECEIVED DISCO INFO REQUEST FOR UNSUPPORTED NODE FROM: #{from_jid.to_s}"
      Xmpp::ErrorResponse.service_unavailable(request)
    end
  else
    AgentXmpp.logger.warn "RECEIVED DISCO INFO REQUEST FROM JID NOT IN ROSTER: #{from_jid.to_s}"
  end
end

.did_receive_discoinfo_result(pipe, discoinfo) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 342

def did_receive_discoinfo_result(pipe, discoinfo)   
  from_jid = discoinfo.from
  do_discoitems = true
  request = []
  if AgentXmpp.roster.has_jid?(from_jid) or AgentXmpp.services.has_jid?(from_jid)
    q = discoinfo.query
    AgentXmpp.logger.info "RECEIVED DISCO INFO RESULT FROM: #{from_jid.to_s}" + (q.node.nil? ? '' : ", NODE: #{q.node}")
    AgentXmpp.services.update_with_discoinfo(discoinfo)
    q.identities.each do |i|
      AgentXmpp.logger.info " IDENTITY: NAME:#{i.iname}, CATEGORY:#{i.category}, TYPE:#{i.type}"
      request << case i.category
                   when 'server'        then Xmpp::IqDiscoItems.get(pipe, from_jid.to_s, q.node) 
                   when 'pubsub'        then process_pubsub_discoinfo(i.type, pipe, from_jid, q.node)
                   when 'conference'
                   when 'proxy'
                   when 'directory'
                   when 'client'
                   when 'automation'
                   when 'auth'
                   when 'collaboration'
                   when 'componenet'
                   when 'gateway'
                   when 'hierarchy'
                   when 'headline'
                   when 'store'
                 end
               end
    q.features.each do |f|
      AgentXmpp.logger.info " FEATURE: #{f}"
    end
    request.smash
  else
    AgentXmpp.logger.warn "RECEIVED DISCO INFO RESULT FROM JID NOT A ROSTER ITEM OR SERVICE: #{from_jid.to_s}"
  end        
end

.did_receive_discoitems_error(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



432
433
434
435
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 432

def did_receive_discoitems_error(pipe, result)   
  from_jid = result.from
  AgentXmpp.logger.warn "RECEIVED DISCO ITEMS ERROR FROM: #{from_jid.to_s}, #{result.query.node}"
end

.did_receive_discoitems_get(pipe, request) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 385

def did_receive_discoitems_get(pipe, request)   
  from_jid = request.from
  if AgentXmpp.roster.has_jid?(from_jid)
    if request.query.node.eql?('http://jabber.org/protocol/commands')
      AgentXmpp.logger.info "RECEIVED COMMAND NODE DISCO ITEMS REQUEST FROM: #{from_jid.to_s}"
      Xmpp::IqDiscoItems.result_command_nodes(pipe, request)
    elsif request.query.node.nil?
      AgentXmpp.logger.info "RECEIVED DISCO ITEMS REQUEST FROM: #{from_jid.to_s}"
      Xmpp::IqDiscoItems.result(pipe, request)
    else
      AgentXmpp.logger.info "RECEIVED DISCO INFO REQUEST FOR UNSUPPORTED NODE FROM: #{from_jid.to_s}"
      Xmpp::ErrorResponse.item_not_found(request)
    end
  else
    AgentXmpp.logger.warn "RECEIVED DISCO ITEMS REQUEST FROM JID NOT IN ROSTER: #{from_jid.to_s}"
  end
end

.did_receive_discoitems_result(pipe, discoitems) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 404

def did_receive_discoitems_result(pipe, discoitems)
  from_jid = discoitems.from
  if AgentXmpp.roster.has_jid?(from_jid) or AgentXmpp.services.has_jid?(from_jid)
    q = discoitems.query
    AgentXmpp.logger.info "RECEIVED DISCO ITEMS RESULT FROM: #{from_jid.to_s}" + (q.node.nil? ? '' : ", NODE: #{q.node}")
    AgentXmpp.services.update_with_discoitems(discoitems)
    case q.node
      when 'http://jabber.org/protocol/commands' 
        Boot.call_if_implemented(:call_discovered_command_nodes, from_jid.to_s, q.items.map{|i| i.node}) unless q.items.empty?
    else
      msgs = if from_jid.to_s.eql?(pubsub_service.to_s) and q.node.eql?(AgentXmpp.pubsub_root)
               create_user_pubsub_root(pipe, from_jid, q.items)
             else ; []; end
      if from_jid.to_s.eql?(pubsub_service.to_s) and q.node.eql?(AgentXmpp.user_pubsub_root)
        msgs += update_publish_nodes(pipe, from_jid, q.items)
      end
      q.items.inject(msgs) do |r,i|
        AgentXmpp.logger.info " ITEM JID: #{i.jid}" + (i.node.nil? ? '' : ", NODE: #{i.node}")
        AgentXmpp.services.create(i.jid)
        r << Xmpp::IqDiscoInfo.get(pipe, i.jid, i.node)         
      end
    end
  else
    AgentXmpp.logger.warn "RECEIVED DISCO INFO RESULT FROM JID NOT A ROSTER ITEM OR SERVICE: #{from_jid.to_s}"
  end        
end

.did_receive_message_chat(pipe, stanza) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. process chat messages .….….….….….….….….….….….….….….….….….….….….….….….….….….



29
30
31
32
33
34
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 29

def did_receive_message_chat(pipe, stanza)
  params = {:xmlns => 'message:chat', :to => stanza.from.to_s, :from => stanza.from.to_s, :id => stanza.id, 
    :body => stanza.body}
  AgentXmpp.logger.info "RECEIVED CHAT MESSAGE FROM: #{stanza.from.to_s}"
  Controller.new(pipe, params).invoke_chat
end

.did_receive_message_normal(pipe, stanza) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. process normal messages .….….….….….….….….….….….….….….….….….….….….….….….….….….



39
40
41
42
43
44
45
46
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 39

def did_receive_message_normal(pipe, stanza)
  AgentXmpp.logger.info "RECEIVED NORMAL MESSAGE FROM: #{stanza.from.to_s}"
  if event = stanza.event
    did_receive_pubsub_event(pipe, event, stanza.to.to_s, stanza.from.to_s)
  else
    did_receive_unsupported_message(pipe, stanza)
  end
end

.did_receive_postauthenticate_features(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



123
124
125
126
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 123

def did_receive_postauthenticate_features(pipe)
  AgentXmpp.logger.info "SESSION STARTED"
  Xmpp::Iq.bind(pipe) if pipe.stream_features.has_key?('bind')
end

.did_receive_preauthenticate_features(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



106
107
108
109
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 106

def did_receive_preauthenticate_features(pipe)
  AgentXmpp.logger.info "SESSION INITIALIZED"
  Xmpp::SASL.authenticate(pipe.stream_mechanisms)
end

.did_receive_presence(pipe, presence) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. presence .….….….….….….….….….….….….….….….….….….….….….….….….….….



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 142

def did_receive_presence(pipe, presence)
  if AgentXmpp.roster.has_jid?(presence.from) 
    from_jid = presence.from    
    AgentXmpp.roster.update_resource(presence)
    AgentXmpp.logger.info "RECEIVED PRESENCE FROM: #{from_jid.to_s}"
    response = []
    unless from_jid.to_s.eql?(AgentXmpp.jid.to_s)
      Boot.call_if_implemented(:call_received_presence, from_jid.to_s, :available)             
      response << Xmpp::IqVersion.request(pipe, from_jid) unless AgentXmpp.roster.has_version?(from_jid)
      unless AgentXmpp.services.has_jid?(from_jid)
        response << Xmpp::IqDiscoInfo.get(pipe, from_jid)
        response << Xmpp::IqDiscoItems.get(pipe, from_jid, 'http://jabber.org/protocol/commands')
      end
    end; response
  else
    AgentXmpp.logger.warn "RECEIVED PRESENCE FROM JID NOT IN ROSTER: #{from_jid}" 
  end
end

.did_receive_presence_error(pipe, presence) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



202
203
204
205
206
207
208
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 202

def did_receive_presence_error(pipe, presence)
  AgentXmpp.logger.warn "RECEIVED PRESENCE ERROR FROM: #{presence.from.to_s}" 
  if AgentXmpp.roster.has_jid?(presence.from)
    AgentXmpp.logger.warn "REMOVING '#{presence.from.to_s}' FROM ROSTER" 
    Xmpp::IqRoster.remove(pipe, presence.from.to_s)
  end
end

.did_receive_presence_subscribe(pipe, presence) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



162
163
164
165
166
167
168
169
170
171
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 162

def did_receive_presence_subscribe(pipe, presence)
  from_jid = presence.from.to_s     
  if AgentXmpp.roster.has_jid?(presence.from) 
    AgentXmpp.logger.info "RECEIVED SUBSCRIBE REQUEST: #{from_jid}"
    Xmpp::Presence.accept(from_jid)  
  else
    AgentXmpp.logger.warn "RECEIVED SUBSCRIBE REQUEST FROM JID NOT IN ROSTER: #{from_jid}"        
    Xmpp::Presence.decline(from_jid)  
  end
end

.did_receive_presence_subscribed(pipe, presence) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



174
175
176
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 174

def did_receive_presence_subscribed(pipe, presence)
  AgentXmpp.logger.warn "SUBSCRIPTION ACCEPTED: #{presence.from.to_s}" 
end

.did_receive_presence_unavailable(pipe, presence) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



179
180
181
182
183
184
185
186
187
188
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 179

def did_receive_presence_unavailable(pipe, presence)
  from_jid = presence.from    
  if AgentXmpp.roster.has_jid?(from_jid) 
    AgentXmpp.roster.update_resource(presence)
    Boot.call_if_implemented(:call_received_presence, from_jid.to_s, :unavailable)             
    AgentXmpp.logger.info "RECEIVED UNAVAILABLE PRESENCE FROM: #{from_jid.to_s }"
  else
    AgentXmpp.logger.warn "RECEIVED UNAVAILABLE PRESENCE FROM JID NOT IN ROSTER: #{from_jid}"   
  end
end

.did_receive_presence_unsubscribed(pipe, presence) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



191
192
193
194
195
196
197
198
199
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 191

def did_receive_presence_unsubscribed(pipe, presence)
  from_jid = presence.from.to_s     
  if AgentXmpp.roster.destroy_by_jid(presence.from)           
    AgentXmpp.logger.info "RECEIVED UNSUBSCRIBED REQUEST: #{from_jid}"
    Xmpp::IqRoster.remove(pipe, presence.from)  
  else
    AgentXmpp.logger.warn "RECEIVED UNSUBSCRIBED REQUEST FROM JID NOT IN ROSTER: #{from_jid}"   
  end
end

.did_receive_publish_error(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



445
446
447
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 445

def did_receive_publish_error(pipe, result, node)
  AgentXmpp.logger.info "ERROR PUBLISING TO NODE: #{node}, #{result.from.to_s}"
end

.did_receive_publish_result(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. pubsub .….….….….….….….….….….….….….….….….….….….….….….….….….….



440
441
442
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 440

def did_receive_publish_result(pipe, result, node)
  AgentXmpp.logger.info "PUBLISH TO NODE ACKNOWLEDEGED: #{node}, #{result.from.to_s}"
end

.did_receive_pubsub_affiliations_error(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



517
518
519
520
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 517

def did_receive_pubsub_affiliations_error(pipe, result)
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED ERROR ON AFFILIATIONS REQUEST FROM: #{from_jid}"
end

.did_receive_pubsub_affiliations_result(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



511
512
513
514
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 511

def did_receive_pubsub_affiliations_result(pipe, result)
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED AFFILIATIONS FROM: #{from_jid}"
end

.did_receive_pubsub_create_node_error(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



532
533
534
535
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 532

def did_receive_pubsub_create_node_error(pipe, result, node)   
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED CREATE NODE ERROR FROM: #{from_jid.to_s}, #{node}"
end

.did_receive_pubsub_create_node_result(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



523
524
525
526
527
528
529
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 523

def did_receive_pubsub_create_node_result(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED CREATE NODE RESULT FROM: #{from_jid.to_s}, #{node}"
  if node.eql?(AgentXmpp.user_pubsub_root)
    [did_discover_user_pubsub_root(pipe, from_jid, node), Xmpp::IqDiscoInfo.get(pipe, from_jid.to_s, node)]   
  end
end

.did_receive_pubsub_delete_node_error(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



544
545
546
547
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 544

def did_receive_pubsub_delete_node_error(pipe, result, node)   
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED DELETE NODE ERROR FROM: #{from_jid.to_s}, #{node}"
end

.did_receive_pubsub_delete_node_result(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



538
539
540
541
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 538

def did_receive_pubsub_delete_node_result(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED DELETE NODE RESULT FROM: #{from_jid.to_s}, #{node}"
end

.did_receive_pubsub_event(pipe, event, to, from) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. process events .….….….….….….….….….….….….….….….….….….….….….….….….….….



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 51

def did_receive_pubsub_event(pipe, event, to, from)
  AgentXmpp.logger.info "RECEIVED EVENT FROM: #{from.to_s}"
  event.items.each do |is|
    is.item.each do |i|
      if data = i.x and data.type.eql?(:result)    
        src = is.node.split('/')  
        src_jid = "#{src[3]}@#{src[2]}"                
        params = {:xmlns => 'http://jabber.org/protocol/pubsub#event', :to => to, :pubsub => from, 
          :node => is.node, :data => data.to_native, :from => src_jid, :id => i.id,
          :resources => AgentXmpp.roster.available_resources(Xmpp::Jid.new(src_jid))}
        Controller.new(pipe, params).invoke_event
      else
        did_receive_unsupported_message(pipe, event)
      end
    end
  end          
end

.did_receive_pubsub_subscribe_error(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



556
557
558
559
560
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 556

def did_receive_pubsub_subscribe_error(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.warn "RECEIVED SUBSCRIBE ERROR FROM: #{from_jid.to_s}, #{node}"
  did_receive_pubsub_subscribe_error_item_not_found(pipe, result, node) if result.error.error.eql?('item-not-found')
end

.did_receive_pubsub_subscribe_error_item_not_found(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



563
564
565
566
567
568
569
570
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 563

def did_receive_pubsub_subscribe_error_item_not_found(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.warn "RECEIVED SUBSCRIBE ERROR ITEM-NOT-FOUND FROM: #{from_jid.to_s}, #{node}; " +
                        "RETRYING SUBSCRIPTION IN #{AgentXmpp::SUBSCRIBE_RETRY_PERIOD}s"
  EventMachine::Timer.new(AgentXmpp::SUBSCRIBE_RETRY_PERIOD) do
    pipe.send_resp(Xmpp::IqPubSub.subscribe(pipe, from_jid.to_s, node))
  end        
end

.did_receive_pubsub_subscribe_result(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



550
551
552
553
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 550

def did_receive_pubsub_subscribe_result(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED SUBSCRIBE RESULT FROM: #{from_jid.to_s}, #{node}"
end

.did_receive_pubsub_subscriptions_error(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



505
506
507
508
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 505

def did_receive_pubsub_subscriptions_error(pipe, result)
  from_jid = result.from
  AgentXmpp.logger.warn "RECEIVED ERROR ON SUBSCRIPTION REQUEST FROM: #{from_jid}"
end

.did_receive_pubsub_subscriptions_result(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 482

def did_receive_pubsub_subscriptions_result(pipe, result)
  from_jid = result.from.to_s
  AgentXmpp.logger.info "RECEIVED SUBSCRIPTIONS FROM: #{from_jid}"
  app_subs = BaseController.subscriptions(result.from.domain)
  srvr_subs = result.pubsub.subscriptions.map do |s| 
    AgentXmpp.logger.info "SUBSCRIBED TO NODE: #{from_jid}, #{s.node}"
    s.node
  end
  reqs = app_subs.inject([]) do |r,s|
           unless srvr_subs.include?(s)
             AgentXmpp.logger.info "SUBSCRIBING TO NODE: #{from_jid}, #{s}"
             r << Xmpp::IqPubSub.subscribe(pipe, from_jid, s)
           end; r
         end
  srvr_subs.inject(reqs) do |r,s|
    unless app_subs.include?(s) 
      AgentXmpp.logger.warn "UNSUBSCRIBING TO NODE: #{from_jid}, #{s}"
      r << Xmpp::IqPubSub.unsubscribe(pipe, from_jid, s)
    end; r
  end       
end

.did_receive_pubsub_unsubscribe_error(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



579
580
581
582
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 579

def did_receive_pubsub_unsubscribe_error(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED UNSUBSCRIBE ERROR FROM: #{from_jid.to_s}, #{node}"
end

.did_receive_pubsub_unsubscribe_result(pipe, result, node) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



573
574
575
576
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 573

def did_receive_pubsub_unsubscribe_result(pipe, result, node) 
  from_jid = result.from
  AgentXmpp.logger.info "RECEIVED UNSUBSCRIBE RESULT FROM: #{from_jid.to_s}, #{node}"
end

.did_receive_remove_roster_item_error(pipe, roster_item_jid) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



290
291
292
293
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 290

def did_receive_remove_roster_item_error(pipe, roster_item_jid)
  AgentXmpp.logger.info "REMOVE ROSTER ITEM RECEIVED ERROR REMOVING: #{roster_item_jid}"
  AgentXmpp.roster.destroy_by_jid(Xmpp::Jid.new(roster_item_jid))
end

.did_receive_remove_roster_item_result(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



285
286
287
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 285

def did_receive_remove_roster_item_result(pipe, result)
  AgentXmpp.logger.info "REMOVE ROSTER ITEM ACKNOWLEDEGED FROM: #{result.from.to_s}"   
end

.did_receive_roster_item(pipe, roster_item) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 223

def did_receive_roster_item(pipe, roster_item)
  roster_item_jid = roster_item.jid
  AgentXmpp.logger.info "RECEIVED ROSTER ITEM: #{roster_item_jid.to_s}"   
  if AgentXmpp.roster.has_jid?(roster_item_jid) 
    case roster_item.subscription   
    when :none
      if roster_item.ask.eql?(:subscribe)
        AgentXmpp.logger.info "CONTACT SUBSCRIPTION PENDING: #{roster_item_jid.to_s}"   
        AgentXmpp.roster.update_status(roster_item_jid, :ask) 
      else
        AgentXmpp.logger.info "CONTACT ADDED TO ROSTER: #{roster_item_jid.to_s}"   
        AgentXmpp.roster.update_status(roster_item_jid, :added)
      end
    when :to
      AgentXmpp.logger.info "SUBSCRIBED TO CONTACT PRESENCE: #{roster_item_jid.to_s}"   
      AgentXmpp.roster.update_status(roster_item_jid, :to) 
    when :from
      AgentXmpp.logger.info "CONTACT SUBSCRIBED TO PRESENCE: #{roster_item_jid.to_s}"   
      AgentXmpp.roster.update_status(roster_item_jid, :from) 
    when :both    
      AgentXmpp.logger.info "CONTACT SUBSCRIPTION BIDIRECTIONAL: #{roster_item_jid.to_s}"   
      AgentXmpp.roster.update_status(roster_item_jid, :both) 
    end
    AgentXmpp.roster.update_roster_item(roster_item)
    check_roster_item_group(pipe, roster_item)
  else
    AgentXmpp.logger.info "REMOVING ROSTER ITEM: #{roster_item_jid.to_s}"   
    Xmpp::IqRoster.remove(pipe, roster_item_jid)  
  end
end

.did_receive_roster_result(pipe, stanza) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. roster management .….….….….….….….….….….….….….….….….….….….….….….….….….….



213
214
215
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 213

def did_receive_roster_result(pipe, stanza)
  process_roster_items(pipe, stanza)
end

.did_receive_roster_set(pipe, stanza) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



218
219
220
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 218

def did_receive_roster_set(pipe, stanza)
  process_roster_items(pipe, stanza)
end

.did_receive_unsupported_message(pipe, stanza) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. errors .….….….….….….….….….….….….….….….….….….….….….….….….….….



72
73
74
75
76
77
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 72

def did_receive_unsupported_message(pipe, stanza)
  AgentXmpp.logger.info "RECEIVED UNSUPPORTED MESSAGE: #{stanza.to_s}"
  if stanza.class.eql?(AgentXmpp::Xmpp::Iq)
    Xmpp::ErrorResponse.feature_not_implemented(stanza)
  end
end

.did_receive_update_roster_item_error(pipe, roster_item_jid) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



279
280
281
282
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 279

def did_receive_update_roster_item_error(pipe, roster_item_jid)
  AgentXmpp.logger.info "UPDATE ROSTER ITEM RECEIVED ERROR REMOVING: #{roster_item_jid}"
  AgentXmpp.roster.destroy_by_jid(Xmpp::Jid.new(roster_item_jid))
end

.did_receive_update_roster_item_result(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



274
275
276
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 274

def did_receive_update_roster_item_result(pipe, result)
  AgentXmpp.logger.info "UPDATE ROSTER ITEM ACKNOWLEDEGED FROM: #{result.from.to_s}"                  
end

.did_receive_version_error(pipe, result) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



320
321
322
323
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 320

def did_receive_version_error(pipe, result)   
  from_jid = result.from
  AgentXmpp.logger.warn "RECEIVED VERSION ERROR FROM: #{from_jid.to_s}"
end

.did_receive_version_get(pipe, request) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



310
311
312
313
314
315
316
317
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 310

def did_receive_version_get(pipe, request)
  if AgentXmpp.roster.has_jid?(request.from)
    AgentXmpp.logger.info "RECEIVED VERSION REQUEST: #{request.from.to_s}"
    Xmpp::IqVersion.result(pipe, request)
  else
    AgentXmpp.logger.warn "RECEIVED VERSION REQUEST FROM JID NOT IN ROSTER: #{request.from.to_s}"
  end
end

.did_receive_version_result(pipe, version) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….…. service discovery management .….….….….….….….….….….….….….….….….….….….….….….….….….….



298
299
300
301
302
303
304
305
306
307
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 298

def did_receive_version_result(pipe, version)
  version_jid = version.from
  if AgentXmpp.roster.has_jid?(version_jid)
    query = version.query
    AgentXmpp.logger.info "RECEIVED VERSION RESULT: #{version_jid.to_s}, #{query.iname}, #{query.version}"
    AgentXmpp.roster.update_resource_version(version)
  else
    AgentXmpp.logger.warn "RECEIVED VERSION RESULT FROM JID NOT IN ROSTER: #{from.to_s}"
  end        
end

.did_remove_roster_item(pipe, roster_item) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



255
256
257
258
259
260
261
262
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 255

def did_remove_roster_item(pipe, roster_item)
  AgentXmpp.logger.info "REMOVE ROSTER ITEM"   
  roster_item_jid = roster_item.jid
  if AgentXmpp.roster.has_jid?(roster_item_jid) 
    AgentXmpp.logger.info "REMOVED ROSTER ITEM: #{roster_item_jid.to_s}"   
    AgentXmpp.roster.destroy_by_jid(roster_item_jid) 
  end
end

.did_start_session(pipe) ⇒ Object

.….….….….….….….….….….….….….….….….….….….….….….….….….….



129
130
131
132
133
134
135
136
137
 
# File 'lib/agent_xmpp/client/message_delegate.rb', line 129

def did_start_session(pipe)
  AgentXmpp.logger.info "SESSION STARTED"
  config_roster_item = AgentXmpp.roster.find_by_jid(AgentXmpp.jid)
  add_command_method(pipe)
  add_message_method(pipe)
  [Send(Xmpp::Presence.new(nil, nil, AgentXmpp.priority)), Xmpp::IqRoster.get(pipe),  
   Xmpp::IqDiscoInfo.get(pipe, AgentXmpp.jid.domain), 
   Xmpp::IqDiscoInfo.get(pipe, AgentXmpp.jid.bare)]
end