vncrec 1.0.1

data/spec/executable_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper.rb'
+
+describe 'vncrec' do
+  describe 'command line options' do
+  end
+
+  describe 'sending signals', vnc: true, port: true do
+    let(:ps) { `ps -A`.lines.grep(@pid.to_s) }
+
+    before do
+      @pid = fork do
+        exec 'vncrec'
+      end
+      sleep 1
+    end
+
+    context 'when connected' do
+      before { launch_vnc_server 5900 }
+
+      it 'INT stops' do
+        expect_no_timeout(3) do
+          Process.kill('INT', @pid)
+          Process.waitpid(@pid)
+        end
+        expect($?.exited?).to be_truthy
+      end
+    end
+
+    context 'when disconnected' do
+
+      it 'INT stops' do
+        expect_no_timeout(3) do
+          Process.kill('INT', @pid)
+          Process.waitpid(@pid)
+        end
+        expect($?.exited?).to be_truthy
+      end
+    end
+  end
+end

data/spec/recorder_spec.rb

@@ -0,0 +1,338 @@
+require 'spec_helper.rb'
+Rec = VNCRec::Recorder
+
+describe Rec do
+  describe '#intialize' do
+    let(:width) { r.instance_variable_get(:@w) }
+    let(:height) { r.instance_variable_get(:@h) }
+
+    describe 'option geometry:' do
+      context 'passed with wrong format' do
+        it 'leads to fail' do
+          expect { Rec.new(geometry: '1920') }.to raise_error ArgumentError
+          expect { Rec.new(geometry: 1920) }.to raise_error ArgumentError
+        end
+      end
+
+      context 'passed and correct' do
+        let(:r) { Rec.new(geometry: '800x600') }
+
+        it 'raises no error' do
+          expect { r }.not_to raise_error
+        end
+
+        it 'IVs are set' do
+          r
+          r.send(:parse_geometry)
+          expect(width).to eq(800)
+          expect(height).to eq(600)
+        end
+      end
+    end
+
+    context 'encoding' do
+      let(:iv) { rec.instance_variable_get(:@enc) }
+
+      context 'given raw' do
+        let(:rec) { Rec.new(encoding: VNCRec::ENC_RAW) }
+
+        it ' sets iv to constant ENC_RAW' do
+          rec
+          expect(iv).to eq VNCRec::ENC_RAW
+        end
+      end
+
+      context 'given zrle' do
+        let(:rec) { Rec.new(encoding: VNCRec::ENC_ZRLE) }
+
+        it ' sets iv to constant ENC_ZRLE' do
+          rec
+          expect(iv).to eq VNCRec::ENC_ZRLE
+        end
+      end
+
+      context 'given hextile' do
+        let(:rec) { Rec.new(encoding: VNCRec::ENC_HEXTILE) }
+
+        it ' sets iv to constant ENC_HEXTILE' do
+          rec
+          expect(iv).to eq VNCRec::ENC_HEXTILE
+        end
+      end
+    end
+
+    describe 'option host:', port: true do
+      context 'when given' do
+        before do
+          @sock = nil
+          Thread.new do
+            @sock = TCPServer.new(5900).accept
+          end.run
+        end
+
+        let(:rec) { Rec.new host: 'localhost', port: 5900 }
+
+        it 'rec tries to connect' do
+          expect do
+            rec.run
+            sleep 1
+          end.to change { @sock.nil? }
+          .from(true).to(false)
+        end
+      end
+      context 'when not given' do
+        let(:rec) { Rec.new }
+
+        it 'rec listens on specified port' do
+          rec.run
+          sleep 1
+          expect(pid_using_port 5900).to eq Process.pid
+        end
+      end
+    end
+
+    describe 'option pixel format:' do
+      subject { rec.instance_variable_get(:@pix_fmt) }
+      context 'passing bgra' do
+        let(:rec) { Rec.new(filename: 'file.mp4', pix_fmt: 'bgra') }
+
+        it 'does not raise error' do
+          expect { rec }.not_to raise_error
+        end
+        it { is_expected.to eq VNCRec::PIX_FMT_BGRA }
+      end
+
+      context 'passing bgr8' do
+        let(:rec) { Rec.new(filename: 'file.mp4', pix_fmt: 'bgr8') }
+
+        it 'does not raise error' do
+          expect { rec }.not_to raise_error
+        end
+        it { is_expected.to eq VNCRec::PIX_FMT_BGR8 }
+      end
+
+      context 'passing other' do
+        let(:rec) { Rec.new(filename: 'file.mp4', pix_fmt: 'gbr32') }
+
+        it 'raises error' do
+          expect { rec }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    describe 'option port:', port: true do
+      let(:rec) { Rec.new(port: port) }
+      context 'valid integer given' do
+        let(:port) { 5900 }
+
+        it 'does not raise error' do
+          expect { rec }.not_to raise_error
+        end
+      end
+      context 'integer too big' do
+        let(:port) { 10_000_000 }
+        it 'raises ArgumentError' do
+          expect { rec }.to raise_error ArgumentError
+        end
+      end
+      context 'integer too small' do
+        let(:port) { 0 }
+        it 'raises ArgumentError' do
+          expect { rec }.to raise_error ArgumentError
+        end
+      end
+      context 'non-integer' do
+        let(:port) { 'aa' }
+        it 'raises ArgumentError' do
+          expect { rec }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    describe 'option filename:' do
+      let(:f1) { Rec.new }
+      let(:f2) { Rec.new(filename: 'file') }
+      let(:f3) { Rec.new(filename: '/root/file') }
+
+      context 'when no filename given' do
+        it 'file with default name exists' do
+          expect { f1 }.to change { File.exist?('5900.raw') }.from(false).to(true)
+        end
+      end
+      context 'when given' do
+        it 'file with specified name exists' do
+          expect { f2 }.to change { File.exist?('file') }.from(false).to(true)
+        end
+      end
+      context 'when can create file' do
+        it 'file exists' do
+          expect { f2 }.to change { File.exist?('file') }.from(false).to(true)
+        end
+      end
+      context 'when can not create file' do
+        it 'raises error' do
+          expect { f3 }.to raise_error(/Cannot create file .*/)
+        end
+      end
+    end
+  end
+  describe '#running?', port: true, vnc: true do
+    let(:rec) { Rec.new(filename: '/dev/null') }
+    context 'when not yet connected' do
+      it 'returns false' do
+        expect(rec.running?).to be_falsy
+      end
+    end
+
+    context 'when connected' do
+      before { rec.run }
+      it 'returns true' do
+        launch_vnc_server 5900
+        expect(rec.running?).to be_truthy
+      end
+    end
+  end
+  describe 'network issues', port: true, vnc: true do
+    subject(:rec)  { Rec.new(filename: 'file.raw', port: get_free_port) }
+    subject(:port) { rec.instance_variable_get(:@port) }
+    context 'when server is not responding' do
+      it 'exits eventually, correct close' do
+      end
+    end
+    context 'when connection is lost' do
+      after(:each) do
+        `killall x11vnc &>/dev/null`
+      end
+      it 'closes correctly', port: true do
+        rec.run
+        launch_vnc_server port
+        sleep 4
+        `killall x11vnc &>/dev/null`
+        sleep 1
+        expect(rec.stopped?).to be_truthy
+      end
+    end
+  end
+  describe 'basic functionality' do
+    describe 'Pix format', port: true, vnc: true do
+      before(:each) { `rm -f rec.jpg &>/dev/null` }
+      let(:port) { get_free_port }
+      let(:geo) { '800x600' }
+      let(:common_options) do
+        {
+          geometry: geo,
+          filename: 'file.raw',
+          encoding: VNCRec::ENC_RAW,
+          port:     port
+        }
+      end
+      let(:rec) do
+        Rec.new(common_options.merge(pix_fmt: f))
+      end
+      let(:run) do
+        rec.run
+        sleep 5
+        rec.stop
+      end
+
+      context 'given bgr8' do
+        let(:f) { 'bgr8' }
+
+        it 'produces output' do
+          rec
+          launch_vnc_server port
+          run
+          sleep 1
+          `ffmpeg -y -f rawvideo  -s #{geo} -r 3 -pix_fmt #{f} -i file.raw \
+          -frames 1 rec.jpg &>/dev/null`
+          sleep 4
+          expect(File.exist?('rec.jpg')).to be_truthy
+        end
+
+        context 'given bgra' do
+          let(:f) { 'bgra' }
+
+          it 'produces output' do
+            rec
+            launch_vnc_server port
+            run
+            sleep 1
+            `ffmpeg -y -f rawvideo  -s #{geo} -r 3 -pix_fmt #{f} -i file.raw \
+          -frames 1 rec.jpg &>/dev/null`
+            sleep 4
+            expect(File.exist?('rec.jpg')).to be_truthy
+          end
+        end
+      end
+    end
+
+    describe 'Transmission mode', port: true, vnc: true do
+      context '(with resolution 800x600)' do
+        let(:geo)  { '800x600' }
+        describe 'raw' do
+          let(:mode) { VNCRec::ENC_RAW }
+          let(:port) { get_free_port }
+          let(:rec) do
+            Rec.new(
+              geometry: geo,
+              filename: 'file.raw',
+              encoding: mode,
+              port:     port
+            )
+          end
+
+          it 'works' do
+            rec.run
+            launch_vnc_server port
+            sleep 3
+            rec.stop
+            sleep 1
+            expect(File.exist?('file.raw')).to be_truthy
+            expect(File.size('file.raw')).to be > 0
+          end
+        end
+
+        describe 'hextile', skip: 1 do
+          let(:mode) { VNCRec::ENC_HEXTILE }
+          let(:port) { get_free_port }
+          let(:rec) do
+            Rec.new(
+              geometry: geo,
+              filename: 'file.raw',
+              encoding: mode,
+              port:     port
+            )
+          end
+
+          it 'works' do
+            rec.run
+            launch_vnc_server port
+            sleep 3
+            rec.stop
+            sleep 1
+            expect(File.exist?('file.raw')).to be_truthy
+            expect(File.size('file.raw')).to be > 0
+          end
+        end
+      end
+    end
+    describe '#kill', port: true, vnc: true do
+      subject(:rec) { Rec.new(filename: 'file.mp4', port: get_free_port) }
+      subject(:port) { rec.instance_variable_get(:@port) }
+      before(:each) do
+        rec.run
+        launch_vnc_server port
+        sleep 6
+      end
+      it 'recorder is dead' do
+        ffmpeg = rec.instance_variable_get(:@file)
+        expect(rec.stopped?).to be_falsy
+        expect(ffmpeg.closed?).to be_falsy
+        rec.stop
+        sleep 0.5
+        expect(rec.stopped?).to be_truthy
+        expect(ffmpeg.closed?).to be_truthy
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,171 @@
+require 'timeout'
+require 'socket'
+require 'vncrec'
+require 'active_support/core_ext/numeric/time'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.exclusion_filter = :interactive, :skip
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.before(:all) do
+    `rake gem`
+  end
+
+  config.before(:each, port: true) do
+    free_port 5900
+  end
+
+  config.after(:each, port: true) do
+    free_port 5900
+  end
+
+  config.after(:each) do
+    kill_children
+    `rake clean &>/dev/null`
+    `rm -rf file* &>/dev/null`
+  end
+
+  config.after(:each, vnc: true) do
+    stop_vnc_server
+  end
+
+  config.after(:all) do
+    `rake clean`
+    `kill -ABRT \`pgrep x11vnc\` &>/dev/null`
+    begin
+      `kill -INT \`pgrep ruby\` \`pgrep vncrec\` &>/dev/null`
+      kill_children
+    rescue SignalException
+    end
+    `xset r &>/dev/null`
+  end
+end
+
+def get_free_port
+  gen = proc do
+    (rand * 1000).to_i + 5001
+  end
+  port = gen.call
+  port = gen.call while port_in_use? port
+  port
+end
+
+def port_avail?(port)
+  lines = File.readlines('/proc/net/tcp')
+  rx = /\d+: \d+:(?<port>\w+)/
+  !lines.map do |line|
+    m = line.match(rx)
+    m[:port].to_i(16) if m
+  end.include?(port)
+end
+
+def port_in_use?(port)
+  !port_avail?(port)
+end
+
+def pid_using_port(port)
+  lines = `lsof -i:#{port}`.lines
+  return nil if lines.empty?
+  col = lines[0].split(' ').index('PID')
+  lines.drop(1)[0].split(' ')[col].to_i
+end
+
+def free_port(port)
+  p = pid_using_port(port)
+  if Process.pid == p
+    close_socket_descriptors
+    return
+  end
+  `kill -INT #{p} &>/dev/null; sleep 1`
+  return unless port_in_use?(port)
+  `kill -QUIT #{p} &>/dev/null; sleep 1`
+  return unless port_in_use?(port)
+  `kill -KILL #{p} &>/dev/null; sleep 1`
+end
+
+def kill_children(sig = 'INT')
+  chids =  `ps --ppid #{Process.pid} 2>/dev/null`
+    .lines.drop(1).map { |l| l.split(/\W+/)[0] }
+  chids.each do |v|
+    `kill -#{sig} #{v} 2>/dev/null`
+  end
+end
+
+def close_socket_descriptors
+  ObjectSpace.each_object(TCPSocket) do |o|
+    begin
+      o.close unless o.closed?
+    rescue
+    end
+  end
+end
+
+def read_process_timeout(cmd = '', tout = 0.2)
+  `rm -f log`
+
+  pid = fork do
+    exec "#{cmd} &>log"
+  end
+
+  sleep 2
+  `kill -INT #{pid}`
+  sleep 0.3
+
+  begin
+    Timeout.timeout(0.5) do
+      Process.waitpid(pid)
+    end
+  rescue Timeout::Error
+    `kill -TERM #{pid}`
+  end
+
+  f = File.open('log', 'r')
+  res =  f.read_nonblock(1024)
+  f.close
+  `rm -f log`
+  res
+end
+
+def expect_timeout(time, &block)
+  expect do
+    Timeout.timeout(time) do
+      block.call
+    end
+  end.to raise_error Timeout::Error
+end
+
+def expect_no_timeout(time, &block)
+  expect do
+    Timeout.timeout(time) do
+      block.call
+    end
+  end.not_to raise_error
+end
+
+def launch_vnc_server(port, host = '0.0.0.0', debug = false)
+  fork do
+    `x11vnc --connect #{host}:#{port} #{debug ? nil : '&>/dev/null'}`
+  end
+end
+
+def stop_vnc_server
+  `killall x11vnc &>/dev/null`
+  'killall -ABRT x11vnc &>/dev/null'
+end