punchblock 1.1.0 → 1.2.0

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # [develop](https://github.com/adhearsion/punchblock)
 
+# [v1.2.0](https://github.com/adhearsion/punchblock/compare/v1.1.0...v1.2.0) - [2012-04-29](https://rubygems.org/gems/punchblock/versions/1.2.0)
+  * Feature: Basic support for record component on Asterisk, using MixMonitor. Currently unsupported options include: start_paused, initial_timeout, final_timeout. Hints are additionally not supported, and recordings are stored on the * machine's local filesystem.
+
 # [v1.1.0](https://github.com/adhearsion/punchblock/compare/v1.0.0...v1.1.0) - [2012-04-26](https://rubygems.org/gems/punchblock/versions/1.1.0)
   * Feature: Implement Reject on Asterisk
   * Bugfix: No longer generate warnings

data/lib/punchblock/component/record.rb

@@ -203,6 +203,10 @@ module Punchblock
           read_attr :uri
         end
 
+        def uri=(other)
+          write_attr :uri, other
+        end
+
         def duration
           read_attr :duration, :to_i
         end

data/lib/punchblock/translator/asterisk/call.rb

@@ -110,6 +110,9 @@ module Punchblock
           case ami_event.name
           when 'Hangup'
             pb_logger.trace "Received a Hangup AMI event. Sending End event."
+            @components.dup.each_pair do |id, component|
+              component.call_ended if component.alive?
+            end
             send_end_event HANGUP_CAUSE_TO_END_REASON[ami_event['Cause'].to_i]
           when 'AsyncAGI'
             pb_logger.trace "Received an AsyncAGI event. Looking for matching AGICommand component."
@@ -213,6 +216,8 @@ module Punchblock
             execute_component Component::Output, command
           when Punchblock::Component::Input
             execute_component Component::Input, command
+          when Punchblock::Component::Record
+            execute_component Component::Record, command
           else
             command.response = ProtocolError.new.setup 'command-not-acceptable', "Did not understand command for call #{id}", id
           end

data/lib/punchblock/translator/asterisk/component.rb

@@ -9,6 +9,7 @@ module Punchblock
         autoload :Asterisk
         autoload :Input
         autoload :Output
+        autoload :Record
         autoload :StopByRedirect
 
         class Component
@@ -22,6 +23,7 @@ module Punchblock
           def initialize(component_node, call = nil)
             @component_node, @call = component_node, call
             @id = UUIDTools::UUID.random_create.to_s
+            @complete = false
             setup
             pb_logger.debug "Starting up..."
           end
@@ -33,9 +35,12 @@ module Punchblock
             command.response = ProtocolError.new.setup 'command-not-acceptable', "Did not understand command for component #{id}", call_id, id
           end
 
-          def send_complete_event(reason)
+          def send_complete_event(reason, recording = nil)
+            return if @complete
+            @complete = true
             event = Punchblock::Event::Complete.new.tap do |c|
               c.reason = reason
+              c << recording if recording
             end
             send_event event
             current_actor.terminate!
@@ -48,7 +53,7 @@ module Punchblock
             if internal
               @component_node.add_event event
             else
-              translator.connection.handle_event event
+              translator.handle_pb_event! event
             end
           end
 
@@ -60,6 +65,10 @@ module Punchblock
             call.id if call
           end
 
+          def call_ended
+            send_complete_event Punchblock::Event::Complete::Hangup.new
+          end
+
           private
 
           def translator

data/lib/punchblock/translator/asterisk/component/record.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+module Punchblock
+  module Translator
+    class Asterisk
+      module Component
+        class Record < Component
+          RECORDING_BASE_PATH = '/var/punchblock/record'
+
+          def setup
+            @complete_reason = nil
+          end
+
+          def execute
+            max_duration = @component_node.max_duration || -1
+
+            raise OptionError, 'A start-paused value of true is unsupported.' if @component_node.start_paused
+            raise OptionError, 'An initial-timeout value is unsupported.' if @component_node.initial_timeout && @component_node.initial_timeout != -1
+            raise OptionError, 'A final-timeout value is unsupported.' if @component_node.final_timeout && @component_node.final_timeout != -1
+            raise OptionError, 'A max-duration value that is negative (and not -1) is invalid.' unless max_duration >= -1
+
+            @format = @component_node.format || 'wav'
+
+            @call.answer_if_not_answered
+
+            component = current_actor
+            call.register_handler :ami, :name => 'MonitorStop' do |event|
+              component.finished
+            end
+
+            send_ref
+
+            if @component_node.start_beep
+              pb_logger.debug "Playing a beep via STREAM FILE before recording"
+              @call.send_agi_action! 'STREAM FILE', 'beep', '""' do
+                component.signal! :beep_finished
+              end
+              wait :beep_finished
+            end
+
+            call.send_ami_action! 'Monitor', 'Channel' => call.channel, 'File' => filename, 'Format' => @format, 'Mix' => true
+            unless max_duration == -1
+              after max_duration/1000 do
+                pb_logger.trace "Max duration encountered, stopping recording"
+                call.send_ami_action! 'StopMonitor', 'Channel' => call.channel
+              end
+            end
+          rescue OptionError => e
+            with_error 'option error', e.message
+          end
+
+          def execute_command(command)
+            case command
+            when Punchblock::Component::Stop
+              command.response = true
+              a = current_actor
+              call.send_ami_action! 'StopMonitor', 'Channel' => call.channel do |complete_event|
+                @complete_reason = stop_reason
+              end
+            when Punchblock::Component::Record::Pause
+              a = current_actor
+              call.send_ami_action! 'PauseMonitor', 'Channel' => call.channel do |complete_event|
+                command.response = true
+              end
+            when Punchblock::Component::Record::Resume
+              a = current_actor
+              call.send_ami_action! 'ResumeMonitor', 'Channel' => call.channel do |complete_event|
+                command.response = true
+              end
+            else
+              super
+            end
+          end
+
+          def finished
+            send_complete_event(@complete_reason || success_reason)
+          end
+
+          private
+
+          def filename
+            File.join RECORDING_BASE_PATH, id
+          end
+
+          def recording
+            Punchblock::Component::Record::Recording.new :uri => "file://#{filename}.#{@format}"
+          end
+
+          def stop_reason
+            Punchblock::Event::Complete::Stop.new
+          end
+
+          def success_reason
+            Punchblock::Component::Record::Complete::Success.new
+          end
+
+          def send_complete_event(reason)
+            super reason, recording
+          end
+        end
+      end
+    end
+  end
+end

data/lib/punchblock/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Punchblock
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/spec/punchblock/translator/asterisk/call_spec.rb

@@ -235,6 +235,21 @@ module Punchblock
               subject.should_not be_alive
             end
 
+            it "should cause all components to send complete events before sending end event" do
+              subject.expects :answer_if_not_answered
+              comp_command = Punchblock::Component::Input.new :grammar => {:value => '<grammar/>'}, :mode => :dtmf
+              comp_command.request!
+              component = subject.execute_command comp_command
+              comp_command.response(0.1).should be_a Ref
+              expected_complete_event = Punchblock::Event::Complete.new :target_call_id => subject.id, :component_id => component.id
+              expected_complete_event.reason = Punchblock::Event::Complete::Hangup.new
+              expected_end_event = Punchblock::Event::End.new :reason => :hangup, :target_call_id  => subject.id
+              end_sequence = sequence 'end events'
+              translator.expects(:handle_pb_event!).with(expected_complete_event).once.in_sequence(end_sequence)
+              translator.expects(:handle_pb_event!).with(expected_end_event).once.in_sequence(end_sequence)
+              subject.process_ami_event ami_event
+            end
+
             context "with an undefined cause" do
               let(:cause)     { '0' }
               let(:cause_txt) { 'Undefined' }
@@ -736,7 +751,7 @@ module Punchblock
 
             let(:mock_action) { mock 'Component::Asterisk::Output', :id => 'foo' }
 
-            it 'should create an AGI command component actor and execute it asynchronously' do
+            it 'should create an Output component and execute it asynchronously' do
               Component::Output.expects(:new).once.with(command, subject).returns mock_action
               mock_action.expects(:internal=).never
               mock_action.expects(:execute!).once
@@ -751,7 +766,7 @@ module Punchblock
 
             let(:mock_action) { mock 'Component::Asterisk::Input', :id => 'foo' }
 
-            it 'should create an AGI command component actor and execute it asynchronously' do
+            it 'should create an Input component and execute it asynchronously' do
               Component::Input.expects(:new).once.with(command, subject).returns mock_action
               mock_action.expects(:internal=).never
               mock_action.expects(:execute!).once
@@ -759,6 +774,21 @@ module Punchblock
             end
           end
 
+          context 'with a Record component' do
+            let :command do
+              Punchblock::Component::Record.new
+            end
+
+            let(:mock_action) { mock 'Component::Asterisk::Record', :id => 'foo' }
+
+            it 'should create a Record component and execute it asynchronously' do
+              Component::Record.expects(:new).once.with(command, subject).returns mock_action
+              mock_action.expects(:internal=).never
+              mock_action.expects(:execute!).once
+              subject.execute_command command
+            end
+          end
+
           context 'with a component command' do
             let(:component_id) { 'foobar' }
 
@@ -789,7 +819,7 @@ module Punchblock
 
           context 'with a command we do not understand' do
             let :command do
-              Punchblock::Component::Record.new
+              Punchblock::Command::Mute.new
             end
 
             it 'sends an error in response to the command' do

data/spec/punchblock/translator/asterisk/component/asterisk/agi_command_spec.rb

@@ -116,10 +116,10 @@ module Punchblock
                 it 'should send a complete event' do
                   subject.handle_ami_event ami_event
 
-                  command.should be_complete
-
                   complete_event = command.complete_event 0.5
 
+                  command.should be_complete
+
                   complete_event.component_id.should be == component_id.to_s
                   complete_event.reason.should be == expected_complete_reason
                 end

data/spec/punchblock/translator/asterisk/component/record_spec.rb

@@ -0,0 +1,421 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Punchblock
+  module Translator
+    class Asterisk
+      module Component
+        describe Record do
+          let(:connection) do
+            mock_connection_with_event_handler do |event|
+              original_command.add_event event
+            end
+          end
+          let(:media_engine)  { nil }
+          let(:channel)       { 'SIP/foo' }
+          let(:translator)    { Punchblock::Translator::Asterisk.new mock('AMI'), connection, media_engine }
+          let(:mock_call)     { Punchblock::Translator::Asterisk::Call.new channel, translator }
+
+          let :original_command do
+            Punchblock::Component::Record.new command_options
+          end
+
+          let :command_options do
+            {}
+          end
+
+          subject { Record.new original_command, mock_call }
+
+          describe '#execute' do
+            let(:reason)    { original_command.complete_event(5).reason }
+            let(:recording) { original_command.complete_event(5).recording }
+
+            before { original_command.request! }
+
+            it "calls answer_if_not_answered on the call" do
+              mock_call.expects :send_ami_action!
+              mock_call.expects :answer_if_not_answered
+              subject.execute
+            end
+
+            before { mock_call.stubs :answer_if_not_answered }
+
+            it "sets command response to a reference to the component" do
+              mock_call.expects(:send_ami_action!)
+              subject.execute
+              original_command.response(0.1).should be_a Ref
+              original_command.component_id.should be == subject.id
+            end
+
+            it "starts a recording via AMI, using the component ID as the filename" do
+              filename = "#{Record::RECORDING_BASE_PATH}/#{subject.id}"
+              mock_call.expects(:send_ami_action!).once.with('Monitor', 'Channel' => channel, 'File' => filename, 'Format' => 'wav', 'Mix' => true)
+              subject.execute
+            end
+
+            it "sends a success complete event when the recording ends" do
+              full_filename = "file://#{Record::RECORDING_BASE_PATH}/#{subject.id}.wav"
+              mock_call.expects(:send_ami_action!)
+              subject.execute
+              monitor_stop_event = RubyAMI::Event.new('MonitorStop').tap do |e|
+                e['Channel'] = channel
+              end
+              mock_call.process_ami_event monitor_stop_event
+              reason.should be_a Punchblock::Component::Record::Complete::Success
+              recording.uri.should be == full_filename
+              original_command.should be_complete
+            end
+
+            describe 'start_paused' do
+              context "set to nil" do
+                let(:command_options) { { :start_paused => nil } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to false" do
+                let(:command_options) { { :start_paused => false } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to true" do
+                let(:command_options) { { :start_paused => true } }
+                it "should return an error and not execute any actions" do
+                  mock_call.expects(:send_agi_action!).never
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A start-paused value of true is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'initial_timeout' do
+              context "set to nil" do
+                let(:command_options) { { :initial_timeout => nil } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to -1" do
+                let(:command_options) { { :initial_timeout => -1 } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to a positive number" do
+                let(:command_options) { { :initial_timeout => 10 } }
+                it "should return an error and not execute any actions" do
+                  mock_call.expects(:send_agi_action!).never
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'An initial-timeout value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'final_timeout' do
+              context "set to nil" do
+                let(:command_options) { { :final_timeout => nil } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to -1" do
+                let(:command_options) { { :final_timeout => -1 } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to a positive number" do
+                let(:command_options) { { :final_timeout => 10 } }
+                it "should return an error and not execute any actions" do
+                  mock_call.expects(:send_agi_action!).never
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A final-timeout value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'format' do
+              context "set to nil" do
+                let(:command_options) { { :format => nil } }
+                it "should execute as 'wav'" do
+                  mock_call.expects(:send_ami_action!).once.with('Monitor', has_entry('Format' => 'wav'))
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+
+                it "provides the correct filename in the recording" do
+                  mock_call.expects(:send_ami_action!)
+                  subject.execute
+                  monitor_stop_event = RubyAMI::Event.new('MonitorStop').tap do |e|
+                    e['Channel'] = channel
+                  end
+                  mock_call.process_ami_event monitor_stop_event
+                  recording.uri.should match(/.*\.wav$/)
+                end
+              end
+
+              context "set to 'mp3'" do
+                let(:command_options) { { :format => 'mp3' } }
+                it "should execute as 'mp3'" do
+                  mock_call.expects(:send_ami_action!).once.with('Monitor', has_entry('Format' => 'mp3'))
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+
+                it "provides the correct filename in the recording" do
+                  mock_call.expects(:send_ami_action!)
+                  subject.execute
+                  monitor_stop_event = RubyAMI::Event.new('MonitorStop').tap do |e|
+                    e['Channel'] = channel
+                  end
+                  mock_call.process_ami_event monitor_stop_event
+                  recording.uri.should match(/.*\.mp3$/)
+                end
+              end
+            end
+
+            describe 'start_beep' do
+              context "set to nil" do
+                let(:command_options) { { :start_beep => nil } }
+                it "should execute normally" do
+                  mock_call.expects(:send_agi_action!).never.with('STREAM FILE', 'beep', '""')
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to false" do
+                let(:command_options) { { :start_beep => false } }
+                it "should execute normally" do
+                  mock_call.expects(:send_agi_action!).never.with('STREAM FILE', 'beep', '""')
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to true" do
+                let(:command_options) { { :start_beep => true } }
+
+                it "should play a beep before recording" do
+                  execute_seq = sequence 'beep then record'
+                  subject.wrapped_object.expects(:wait).once
+                  mock_call.expects(:send_agi_action!).once.with('STREAM FILE', 'beep', '""').in_sequence(execute_seq)
+                  mock_call.expects(:send_ami_action!).once.in_sequence(execute_seq)
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+
+                it "should wait for the beep to finish before starting recording" do
+                  def mock_call.send_agi_action!(*args)
+                    yield
+                  end
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+            end
+
+            describe 'max_duration' do
+              context "set to nil" do
+                let(:command_options) { { :max_duration => nil } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context "set to -1" do
+                let(:command_options) { { :max_duration => -1 } }
+                it "should execute normally" do
+                  mock_call.expects(:send_ami_action!).once
+                  subject.execute
+                  original_command.response(0.1).should be_a Ref
+                end
+              end
+
+              context 'a negative number other than -1' do
+                let(:command_options) { { :max_duration => -1000 } }
+
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A max-duration value that is negative (and not -1) is invalid.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+
+              context 'a positive number' do
+                let(:reason) { original_command.complete_event(5).reason }
+                let(:recording) { original_command.complete_event(5).recording }
+                let(:command_options) { { :max_duration => 1000 } }
+
+                it "executes a StopMonitor action" do
+                  mock_call.expects :send_ami_action!
+                  mock_call.expects(:send_ami_action!).once.with('StopMonitor', 'Channel' => channel)
+                  subject.execute
+                  sleep 1.2
+                end
+
+                it "sends the correct complete event" do
+                  def mock_call.send_ami_action!(*args, &block)
+                    block.call Punchblock::Component::Asterisk::AMI::Action::Complete::Success.new if block
+                  end
+                  full_filename = "file://#{Record::RECORDING_BASE_PATH}/#{subject.id}.wav"
+                  subject.execute
+                  sleep 1.2
+
+                  monitor_stop_event = RubyAMI::Event.new('MonitorStop').tap do |e|
+                    e['Channel'] = channel
+                  end
+                  mock_call.process_ami_event monitor_stop_event
+
+                  reason.should be_a Punchblock::Component::Record::Complete::Success
+                  recording.uri.should be == full_filename
+                  original_command.should be_complete
+                end
+              end
+            end
+          end
+
+          describe "#execute_command" do
+            let(:reason) { original_command.complete_event(5).reason }
+            let(:recording) { original_command.complete_event(5).recording }
+
+            context "with a command it does not understand" do
+              let(:command) { Punchblock::Component::Output::Pause.new }
+
+              before { command.request! }
+              it "returns a ProtocolError response" do
+                subject.execute_command command
+                command.response(0.1).should be_a ProtocolError
+              end
+            end
+
+            context "with a Stop command" do
+              let(:command) { Punchblock::Component::Stop.new }
+
+              before do
+                mock_call.expects :answer_if_not_answered
+                mock_call.expects :send_ami_action!
+                command.request!
+                original_command.request!
+                subject.execute
+              end
+
+              let :send_stop_event do
+                monitor_stop_event = RubyAMI::Event.new('MonitorStop').tap do |e|
+                  e['Channel'] = channel
+                end
+                mock_call.process_ami_event monitor_stop_event
+              end
+
+              it "sets the command response to true" do
+                mock_call.expects :send_ami_action!
+                subject.execute_command command
+                send_stop_event
+                command.response(0.1).should be == true
+              end
+
+              it "executes a StopMonitor action" do
+                mock_call.expects(:send_ami_action!).once.with('StopMonitor', 'Channel' => channel)
+                subject.execute_command command
+              end
+
+              it "sends the correct complete event" do
+                mock_call.instance_exec do
+                  class << self
+                    undef :send_ami_action! # This is here because mocha has already defined #send_ami_action! above. We need to undef it to prevent a warning on redefinition.
+                  end
+
+                  def send_ami_action!(*args, &block)
+                    block.call Punchblock::Component::Asterisk::AMI::Action::Complete::Success.new if block
+                  end
+                end
+
+                full_filename = "file://#{Record::RECORDING_BASE_PATH}/#{subject.id}.wav"
+                subject.execute_command command
+                send_stop_event
+                reason.should be_a Punchblock::Event::Complete::Stop
+                recording.uri.should be == full_filename
+                original_command.should be_complete
+              end
+            end
+
+            context "with a Pause command" do
+              let(:command) { Punchblock::Component::Record::Pause.new }
+
+              before do
+                command.request!
+                original_command.request!
+                original_command.execute!
+              end
+
+              it "sets the command response to true" do
+                def mock_call.send_ami_action!(*args, &block)
+                  block.call Punchblock::Component::Asterisk::AMI::Action::Complete::Success.new if block
+                end
+                subject.execute_command command
+                command.response(0.1).should be == true
+              end
+
+              it "pauses the recording via AMI" do
+                mock_call.expects(:send_ami_action!).once.with('PauseMonitor', 'Channel' => channel)
+                subject.execute_command command
+              end
+            end
+
+            context "with a Resume command" do
+              let(:command) { Punchblock::Component::Record::Resume.new }
+
+              before do
+                command.request!
+                original_command.request!
+                original_command.execute!
+              end
+
+              it "sets the command response to true" do
+                def mock_call.send_ami_action!(*args, &block)
+                  block.call Punchblock::Component::Asterisk::AMI::Action::Complete::Success.new if block
+                end
+                subject.execute_command command
+                command.response(0.1).should be == true
+              end
+
+              it "resumes the recording via AMI" do
+                mock_call.expects(:send_ami_action!).once.with('ResumeMonitor', 'Channel' => channel)
+                subject.execute_command command
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/punchblock/translator/asterisk/component_spec.rb

@@ -71,6 +71,13 @@ module Punchblock
             end
           end
 
+          describe "#call_ended" do
+            it "should send a complete event with the call hangup reason" do
+              subject.wrapped_object.expects(:send_complete_event).once.with Punchblock::Event::Complete::Hangup.new
+              subject.call_ended
+            end
+          end
+
           describe '#execute_command' do
             before do
               component_command.request!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: punchblock
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-26 00:00:00.000000000 Z
+date: 2012-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: niceogiri
@@ -401,6 +401,7 @@ files:
 - lib/punchblock/translator/asterisk/component/asterisk/ami_action.rb
 - lib/punchblock/translator/asterisk/component/input.rb
 - lib/punchblock/translator/asterisk/component/output.rb
+- lib/punchblock/translator/asterisk/component/record.rb
 - lib/punchblock/translator/asterisk/component/stop_by_redirect.rb
 - lib/punchblock/version.rb
 - punchblock.gemspec
@@ -445,6 +446,7 @@ files:
 - spec/punchblock/translator/asterisk/component/asterisk/ami_action_spec.rb
 - spec/punchblock/translator/asterisk/component/input_spec.rb
 - spec/punchblock/translator/asterisk/component/output_spec.rb
+- spec/punchblock/translator/asterisk/component/record_spec.rb
 - spec/punchblock/translator/asterisk/component/stop_by_redirect_spec.rb
 - spec/punchblock/translator/asterisk/component_spec.rb
 - spec/punchblock/translator/asterisk_spec.rb
@@ -465,7 +467,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2228525083493052617
+      hash: 621112647086219314
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -520,6 +522,7 @@ test_files:
 - spec/punchblock/translator/asterisk/component/asterisk/ami_action_spec.rb
 - spec/punchblock/translator/asterisk/component/input_spec.rb
 - spec/punchblock/translator/asterisk/component/output_spec.rb
+- spec/punchblock/translator/asterisk/component/record_spec.rb
 - spec/punchblock/translator/asterisk/component/stop_by_redirect_spec.rb
 - spec/punchblock/translator/asterisk/component_spec.rb
 - spec/punchblock/translator/asterisk_spec.rb