Class: Adhearsion::PunchblockPlugin::Initializer

108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 108

def connect_to_server
  begin
    logger.info "Starting connection to server"
    client.run
  rescue ::Punchblock::DisconnectedError => e
    # We only care about disconnects if the process is up or booting
    return unless [:booting, :running].include? Adhearsion::Process.state_name

    Adhearsion::Process.reset unless Adhearsion::Process.state_name == :booting

    self.attempts += 1

    if self.attempts >= self.config.reconnect_attempts
      logger.fatal "Connection lost. Connection retry attempts exceeded."
      Adhearsion::Process.stop!
      return
    end

    logger.error "Connection lost. Attempting reconnect #{self.attempts} of #{self.config.reconnect_attempts}"
    sleep self.config.reconnect_timer
    retry
  rescue ::Punchblock::ProtocolError => e
    logger.fatal "The connection failed due to a protocol error: #{e.name}."
    raise e
  end
end

152
153
154
155
156
157
158

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 152

def dispatch_call_event(event)
  if call = Adhearsion.active_calls[event.target_call_id]
    call.deliver_message! event
  else
    logger.error "Event received for inactive call #{event.target_call_id}: #{event.inspect}"
  end
end

135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 135

def dispatch_offer(offer)
  catching_standard_errors do
    call = Adhearsion.active_calls.from_offer offer
    case Adhearsion::Process.state_name
    when :booting, :rejecting
      logger.info "Declining call because the process is not yet running."
      call.reject :decline
    when :running
      call.accept
      dispatcher = Adhearsion.router.handle call
      dispatcher.call call
    else
      call.reject :error
    end
  end
end

160
161
162
163
164
165
166

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 160

def handle_event(event)
  Events.trigger :punchblock, event
  case event
  when Punchblock::Event::Asterisk::AMI::Event
    Events.trigger :ami, event
  end
end

13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 13

def init
  self.config = Adhearsion.config[:punchblock]

  username = self.config.username
  connection_class = case (self.config.platform || :xmpp)
  when :xmpp
    username = Blather::JID.new username
    username = Blather::JID.new username.node, username.domain, resource unless username.resource
    username = username.to_s
    ::Punchblock::Connection::XMPP
  when :asterisk
    ::Punchblock::Connection::Asterisk
  end

  connection_options = {
    :username           => username,
    :password           => self.config.password,
    :connection_timeout => self.config.connection_timeout,
    :host               => self.config.host,
    :port               => self.config.port,
    :root_domain        => self.config.root_domain,
    :calls_domain       => self.config.calls_domain,
    :mixers_domain      => self.config.mixers_domain,
    :media_engine       => self.config.media_engine
  }

  self.connection = connection_class.new connection_options
  self.client = ::Punchblock::Client.new :connection => connection

  # Tell the Punchblock connection that we are ready to process calls.
  Events.register_callback :after_initialization do
    connection.ready!
  end

  # When a stop is requested, change our status to "Do Not Disturb"
  # This should prevent the telephony engine from sending us any new calls.
  Events.register_callback :stop_requested do
    connection.not_ready! if connection.connected?
  end

  # Make sure we stop everything when we shutdown
  Events.register_callback :shutdown do
    client.stop
  end

  # Handle events from Punchblock via events system
  self.client.register_event_handler do |event|
    handle_event event
  end

  Events.punchblock ::Punchblock::Connection::Connected do |event|
    logger.info "Connected to Punchblock server"
    self.attempts = 0
  end

  Events.punchblock ::Punchblock::Event::Offer do |offer|
    dispatch_offer offer
  end

  Events.punchblock proc { |e| e.respond_to?(:source) }, :source do |event|
    event.source.trigger_event_handler event
  end

  Events.punchblock proc { |e| e.respond_to?(:target_call_id) }, :target_call_id do |event|
    dispatch_call_event event
  end
end

168
169
170

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 168

def resource
  [Adhearsion::Process.fqdn, ::Process.pid].join '-'
end

81
82
83

# File 'lib/adhearsion/punchblock_plugin/initializer.rb', line 81

def run
  connect
end