WIP: beta branch collapse

.gitignore

@@ -5,3 +5,4 @@
 Gemfile.lock
 .yardoc
 doc
+.vagrant

.reek

@@ -31,6 +31,8 @@ NilCheck:
 # Boolean switches on state based methods (such as power and mute) are useful.
 BooleanParameter:
   enabled: false
+ControlParameter:
+  enabled: false
 
 # Allow for a larger number of constants for protocol definitions.
 TooManyConstants:
@@ -39,12 +41,16 @@ TooManyConstants:
 # Suppress warning about parameter length within reason.
 LongParameterList:
   max_params: 4
-  
+
 # Prevent from flagging multiple calls to utility methods
 # (e.g. is_affirmative?).
 RepeatedConditional:
   enabled: false
 
+# Allow for device model numbers to be used as module names.
+UncommunicativeModuleName:
+  enabled: false
+
 # Support private, pure functions
 UtilityFunction:
   public_methods_only: true

.rubocop.yml

@@ -27,6 +27,10 @@ Metrics/ClassLength:
 Metrics/ModuleLength:
   Max: 300
 
+Metrics/LineLength:
+  Exclude:
+    - "**/**/*_spec.rb"
+
 Metrics/ParameterLists:
   Max: 5
 
@@ -70,3 +74,6 @@ Style/Documentation:
 
 Style/NumericLiterals:
   Enabled: false
+
+Style/RegexpLiteral:
+  AllowInnerSlashes: true

Gemfile

@@ -3,3 +3,4 @@ source "https://rubygems.org"
 gemspec
 
 gem 'yard'
+gem 'yajl-ruby'

README.md

@@ -1,11 +1,9 @@
-# ACAEngine Modules
+# ACAEngine Drivers
 
-Physical device drivers, service integrations and modular logic for [ACAEngine](https://github.com/acaprojects/ruby-engine).
+Physical device drivers, service integrations and modular logic for [ACAEngine](https://docs.acaengine.com).
 
 ---
 
-If you are getting started head on over to https://developer.acaprojects.com/ to get setup.
-
-For those using these modules, you may find the [docs](https://acaprojects.github.io/aca-device-modules/) of use.
+For those using these drivers, you may find the [API docs](https://acaprojects.github.io/ruby-engine-drivers/) of use.
 
 Please read the [contributor guide](.github/CONTRIBUTING.md) for project guidelines, or check [support](.github/SUPPORT.md) if you're lost.

Vagrantfile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Local path to the drivers repo that you would like to use.
+DRIVERS_PATH = './'
+
+# Local path to the front-ends to have available.
+WWW_PATH = nil
+
+Vagrant.configure('2') do |config|
+    config.vm.define 'ACAEngine'
+
+    config.vm.box = 'acaengine/dev-env'
+
+    config.vm.synced_folder DRIVERS_PATH, '/etc/aca/ruby-engine-drivers' \
+        unless DRIVERS_PATH.nil?
+
+    config.vm.synced_folder WWW_PATH, '/etc/aca/www' \
+        unless WWW_PATH.nil?
+end

lib/aca/tracking/people_count.rb

@@ -0,0 +1,29 @@
+module Aca; end
+module Aca::Tracking; end
+class Aca::Tracking::PeopleCount < CouchbaseOrm::Base
+    design_document :pcount
+
+    # Connection details
+    attribute :room_email,   type: String
+    attribute :booking_id,   type: String
+    attribute :system_id,    type: String
+    attribute :capacity,     type: Integer
+    attribute :maximum,      type: Integer
+    attribute :average,      type: Integer
+    attribute :median,       type: Integer
+    attribute :organiser,    type: String
+    attribute :counts,       type: Array, default: lambda { [] }
+    attribute :start_time,   type: Integer
+
+    protected
+
+
+    before_create :set_id
+
+    view :all, emit_key: :room_email
+
+    def set_id
+        self.id = "count-#{self.booking_id}"
+    end
+
+end

lib/aca/tracking/switch_port.rb

@@ -186,7 +186,7 @@ def disconnected(temporary: 0)
 
             # Block the MAC address from being discovered for a period of time
             begin
-                self.class.set("temporarily_block_mac-#{self.mac_address}", ttl: temporary)
+                self.class.set("temporarily_block_mac-#{mac}", ttl: (temporary * 2))
                 ::Aca::Tracking::UserDevices.with_mac(mac).each do |user|
                     user.remove(mac)
                 end

lib/aca/tracking/user_devices.rb

@@ -21,6 +21,11 @@ def add(mac)
             .reject { |u| u.id == self.id }
             .each { |u| u.remove(mac) }
 
+        if self.class.bucket.get("temporarily_block_mac-#{mac}", quiet: true)
+          remove(mac)
+          return
+        end
+
         self.class.bucket.set("macuser-#{mac}", username)
         return if self.macs.include?(mac)
 

lib/cisco/broad_soft/broad_works.rb

@@ -0,0 +1,250 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+=begin
+
+Example Usage:
+bw = Cisco::BroadSoft::BroadWorks.new("xsi-events.domain.com", "user@domain.com", "Password!", proxy: ENV['HTTPS_PROXY'])
+
+# Processing events
+Thread.new do
+  bw.open_channel do |event|
+    puts "\n\Processing! #{event}\n\n"
+  end
+end
+
+# Registering for Automatic Call Distribution Events
+bw.get_user_events "0478242466@domain.au"
+
+=end
+
+require "active_support/all"
+require "securerandom"
+require "nokogiri"
+require "logger"
+require "httpi"
+require "json"
+
+module Cisco; end
+module Cisco::BroadSoft; end
+
+class Cisco::BroadSoft::BroadWorks
+  def initialize(domain, username, password, application: "ACAEngine", proxy: nil, logger: Logger.new(STDOUT))
+    @domain = domain
+    @username = username
+    @password = password
+    @logger = logger
+    @proxy = proxy
+    @application_id = application
+
+    @keepalive_active = false
+    @channel_open = false
+    @heartbeat = true
+
+    @channel_set_id = SecureRandom.uuid
+
+    @buffer = String.new
+  end
+
+  attr_reader :expires
+  attr_reader :channel_id
+  attr_reader :channel_set_id
+  attr_reader :channel_open
+
+  def open_channel
+    return if @channel_open
+    @channel_open = true
+
+    expires = 6.hours.to_i
+
+    channel_xml = %(<?xml version="1.0" encoding="utf-8"?>
+    <Channel xmlns="http://schema.broadsoft.com/xsi">
+      <channelSetId>#{@channel_set_id}</channelSetId>
+      <priority>1</priority>
+      <weight>50</weight>
+      <expires>#{expires}</expires>
+    </Channel>)
+
+    conn = new_request
+    conn.url = "https://#{@domain}/com.broadsoft.async/com.broadsoft.xsi-events/v2.0/channel"
+    conn.body = channel_xml
+
+    conn.on_body do |chunk|
+      @heartbeat = false
+      event = parse_event(chunk)
+      yield event if event
+    end
+
+    keepalive
+
+    @logger.info "Channel #{@channel_set_id} requested..."
+    HTTPI.post(conn)
+    @logger.info "Channel #{@channel_set_id} closed..."
+  ensure
+    @channel_open = false
+    # notify of the disconnect
+    yield nil
+  end
+
+  def heartbeat
+    conn = new_request
+    conn.url = "https://#{@domain}/com.broadsoft.xsi-events/v2.0/channel/#{@channel_id}/heartbeat"
+    response = HTTPI.put(conn)
+    if response.code != 200
+        if response.code == 404
+            # Seems multiple servers handle requests and not all are aware of channels!
+            # This just desperately tries to hit the right server to keep the channel alive
+            sleep 0.7
+            heartbeat if @heartbeat && @channel_open
+        else
+            @logger.warn "heartbeat failed\n#{response.inspect}"
+        end
+    end
+  end
+
+  def keepalive
+    return if @keepalive_active
+    @keepalive_active = true
+    @logger.debug "heartbeat starting..."
+    Thread.new do
+      begin
+        loop do
+          @heartbeat = true
+          sleep 6
+          break unless @channel_open
+          heartbeat if @heartbeat
+        end
+      rescue => e
+        @logger.error "error performing heartbeat: #{e.message}"
+      ensure
+        @keepalive_active = false
+        # Ensure this is always running if a channel is open
+        keepalive if @channel_open
+      end
+    end
+  end
+
+  def acknowledge(event_id)
+    channel_xml = %(<?xml version="1.0" encoding="utf-8"?>
+    <EventResponse xmlns="http://schema.broadsoft.com/xsi">
+      <eventID>#{event_id}</eventID>
+      <statusCode>200</statusCode>
+      <reason>OK</reason>
+    </EventResponse>)
+
+    conn = new_request
+    conn.url = "https://#{@domain}/com.broadsoft.xsi-events/v2.0/channel/eventresponse"
+    conn.body = channel_xml
+    response = HTTPI.post(conn)
+    if response.code == 200
+      @logger.debug "acknowledgment #{event_id}"
+    else
+      @logger.warn "acknowledgment failed\n#{response.inspect}"
+    end
+  end
+
+  def parse_event(data)
+    @buffer << data
+    data = @buffer
+
+    # Check if valid XML with our current buffer
+    xml = Nokogiri::XML(data)
+    return unless xml.errors.empty?
+    @buffer = String.new
+    xml.remove_namespaces!
+
+    begin
+      response_type = xml.children[0].name
+      case response_type
+      when 'Channel'
+        @channel_id = xml.xpath("//channelId").inner_text
+        @expires = (xml.xpath("//expires").inner_text.to_i - 5).seconds.from_now
+        @logger.info "channel established #{@channel_id}"
+        @logger.debug "channel details:\n#{data}"
+        {
+          channel_id: @channel_id,
+          event_name: 'new_channel'
+        }
+      when 'Event'
+        event_data = xml.xpath("//eventData")[0]
+        event = {
+          channel_id: xml.xpath("//channelId").inner_text,
+          user_id: xml.xpath("//userId").inner_text,
+          subscription_id: xml.xpath("//subscriptionId").inner_text,
+          event_id: xml.xpath("//eventID").inner_text,
+          event_name: event_data["type"].split(':')[1],
+          event_data: event_data
+        }
+        Thread.new { acknowledge(event[:event_id]) }
+        event
+      else
+        @logger.debug "recieved #{response_type} on channel"
+        nil
+      end
+    rescue => e
+      @logger.error "processing event\n#{e.message}\nevent: #{data}"
+      nil
+    end
+  end
+
+  # Admin Commands:
+  def renew(expires_in = 6.hours.to_i)
+    channel_xml = %(<?xml version="1.0" encoding="utf-8"?>
+    <Channel xmlns="http://schema.broadsoft.com/xsi">
+      <expires>#{expires_in}</expires>
+    </Channel>)
+
+    conn = new_request
+    conn.url = "https://#{@domain}/com.broadsoft.xsi-events/v2.0/channel/#{@channel_id}"
+    conn.body = channel_xml
+    response = HTTPI.put(conn)
+    if response.code != 200
+      @logger.warn "channel renewal failed\n#{response.inspect}"
+    end
+  end
+
+  def close_channel
+    conn = new_request
+    conn.url = "https://#{@domain}/com.broadsoft.xsi-events/v2.0/channel/#{@channel_id}"
+    response = HTTPI.delete(conn)
+    if response.code != 200
+      @logger.warn "channel close failed\n#{response.inspect}"
+    end
+  end
+
+  def get_user_events(group, events = "Call Center Queue")
+    channel_xml = %(<?xml version="1.0" encoding="UTF-8"?>
+      <Subscription xmlns="http://schema.broadsoft.com/xsi">
+        <event>#{events}</event>
+        <expires>#{6.hours.to_i}</expires>
+        <channelSetId>#{@channel_set_id}</channelSetId>
+        <applicationId>#{@application_id}</applicationId>
+      </Subscription>)
+
+    conn = new_request
+    conn.url = "https://#{@domain}/com.broadsoft.xsi-events/v2.0/user/#{group}"
+    conn.body = channel_xml
+    response = HTTPI.post(conn)
+    if response.code == 200
+      # extract the subscription ID
+      xml = Nokogiri::XML(response.body)
+      xml.remove_namespaces!
+      xml.xpath("//subscriptionId").inner_text
+    elsif response.code == 404
+      sleep 1
+      get_user_events(group, events) if @channel_open
+    else
+      @logger.warn "get user events failed\n#{response.inspect}"
+      raise "bad response when requesting events #{response.code}\n#{response.body}"
+    end
+  end
+
+  def new_request
+    conn = HTTPI::Request.new
+    conn.proxy = @proxy if @proxy
+    conn.headers['Content-Type'] = 'application/xml'
+    conn.headers['Accept'] = 'application/xml; charset=UTF-8'
+    conn.auth.basic(@username, @password)
+    conn
+  end
+end