electric_eye 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a47ea7aadb4898d0e3021215284e48906b11d0af
+  data.tar.gz: 585767b4e074d6443a586ef063123fbef896f19b
+SHA512:
+  metadata.gz: 669d9b4aed0148677a03aa7b3a99c346a73ba05571008936e49a9585c88f95281ab55e9f5122880253001948184cc5f000fb0267b031459bec7cbed356f5a3a6
+  data.tar.gz: 6e5e82f135be9c9199baa758be1fce94d56367208abeb54a1dd9117b618328d7d875824155837ff15b8a5d2f84205e0068ffa423069d5be71265c598e68a6e14

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+results.html
+pkg
+html

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in electric_eye.gemspec
+gemspec
+
+gem 'construct'                 # Config manager in YAML format
+gem 'table_print'               # Print a nice table in stdout
+gem 'timecop'                   # Freeze time for tests
+gem 'fakefs', require: "fakefs/safe"
+gem 'open4'                     # Handle shell commands

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    electric_eye (0.0.1)
+      methadone (~> 1.9.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aruba (0.6.2)
+      childprocess (>= 0.3.6)
+      cucumber (>= 1.1.1)
+      rspec-expectations (>= 2.7.0)
+    builder (3.2.2)
+    childprocess (0.5.6)
+      ffi (~> 1.0, >= 1.0.11)
+    construct (0.1.7)
+    cucumber (2.0.0)
+      builder (>= 2.1.2)
+      cucumber-core (~> 1.1.3)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 2.12)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.1.2)
+    cucumber-core (1.1.3)
+      gherkin (~> 2.12.0)
+    diff-lcs (1.2.5)
+    fakefs (0.6.7)
+    ffi (1.9.8)
+    gherkin (2.12.2)
+      multi_json (~> 1.3)
+    json (1.8.2)
+    methadone (1.9.0)
+      bundler
+    multi_json (1.11.0)
+    multi_test (0.1.2)
+    open4 (1.3.4)
+    rake (10.4.2)
+    rdoc (4.2.0)
+      json (~> 1.4)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.3)
+    table_print (1.5.3)
+    timecop (0.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aruba
+  bundler (~> 1.7)
+  construct
+  electric_eye!
+  fakefs
+  open4
+  rake (~> 10.0)
+  rdoc
+  rspec (~> 2.99)
+  table_print
+  timecop

data/LICENSE.txt

@@ -0,0 +1,8 @@
+Name: electric_eye
+Copyright (c) 2015 Michael Pope
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# ElectricEye
+
+A network video recorder for multiple IP cameras using VLC.
+
+## History
+
+I've been using Zoneminder & motion and these programs are either too large for my requirements (zoneminder) or don't work with the cameras I own (motion). What I did notice is all my cameras work through VLC with high resolution and VLC can record. 
+
+The problem was though VLC doesn't automate the recordings or handle the file structure nicely. This is where I started to think about creating an application which records from VLC and nicely sorts those recordings in directories by date & time.
+
+## Requirements
+
+- VLC
+- ruby
+- Linux (Tested on Debian 7)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'electric_eye'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install electric_eye
+
+## Configuration
+
+Enter your cameras into the JSON config file like so
+
+```yaml
+---
+duration: 60
+path: "/media/data/recordings/temp"
+cameras:
+- :name: Reception
+  :url: rtsp://<user>:<passwd>@<camera's ip>/live2.sdp
+- :name: Kitchen
+  :url: rtsp://<user>:<passwd>@<camera's ip>/live2.sdp
+- :name: Workstations
+  :url: rtsp://<user>:<passwd>@<camera's ip>/live2.sdp
+```
+
+You should be able to view the URL through vlc before using this program.
+
+The recordings directory will end up with these directories
+
+    /media/data/recordings/reception/20150527
+    /media/data/recordings/kitchen/20150527
+
+Notice the date at the end of these paths, there will be one for each day. The contents within will be recordings which are done by default every 10minutes, example;
+
+    20150527-1020-reception.mjpeg
+    20150527-1030-reception.mjpeg
+    20150527-1040-reception.mjpeg
+
+The default is going to be 10 minute blocks, this can be overridden with the duration variable above in minutes.
+
+## Usage
+
+First make sure you add your cameras
+
+    electric_eye add Reception <url>
+
+Now start the daemon to start the recording process
+
+    electric_eye start
+
+Stop all recordings
+
+    electric_eye stop
+
+Usage in development mode
+
+    bundle exec bin/electric_eye -h
+
+
+## Cleanup
+
+Cleaning up recordings. Put the following into your /etc/crontab per recording directory.
+
+    00 19	* * *	root	/usr/bin/find <directory to recordings> -type f -mtime +<days> -exec rm {} \;
+
+Example for cleaning up reception after 60days at 7pm everynight.
+
+    00 19	* * *	root	/usr/bin/find /media/recordings/reception -type f -mtime +60 -exec rm {} \;
+
+## Contributing
+
+1. Fork it ( https://github.com/map7/electric_eye/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## TODO
+
+- Adjust directory layout
+- Turn into a gem
+- Add testing
+- Add motion detection (using [rmotion](https://github.com/rikiji/rmotion))
+- Do inline motion detection (using activevlc)
+- Allow different recording programs like raspicam
+

data/README.rdoc

@@ -0,0 +1,23 @@
+= electric_eye - DESCRIBE YOUR GEM
+
+Author::  YOUR NAME (YOUR EMAIL)
+Copyright:: Copyright (c) 2015 YOUR NAME
+
+
+License:: mit, see LICENSE.txt
+
+
+
+DESCRIBE YOUR GEM HERE
+
+== Links
+
+* {Source on Github}[LINK TO GITHUB]
+* RDoc[LINK TO RDOC.INFO]
+
+== Install
+
+== Examples
+
+== Contributing
+

data/Rakefile

@@ -0,0 +1,66 @@
+def dump_load_path
+  puts $LOAD_PATH.join("\n")
+  found = nil
+  $LOAD_PATH.each do |path|
+    if File.exists?(File.join(path,"rspec"))
+      puts "Found rspec in #{path}"
+      if File.exists?(File.join(path,"rspec","core"))
+        puts "Found core"
+        if File.exists?(File.join(path,"rspec","core","rake_task"))
+          puts "Found rake_task"
+          found = path
+        else
+          puts "!! no rake_task"
+        end
+      else
+        puts "!!! no core"
+      end
+    end
+  end
+  if found.nil?
+    puts "Didn't find rspec/core/rake_task anywhere"
+  else
+    puts "Found in #{path}"
+  end
+end
+require 'bundler'
+require 'rake/clean'
+
+begin
+require 'rspec/core/rake_task'
+rescue LoadError
+dump_load_path
+raise
+end
+
+require 'cucumber'
+require 'cucumber/rake/task'
+gem 'rdoc' # we need the installed RDoc gem, not the system one
+require 'rdoc/task'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+
+RSpec::Core::RakeTask.new do |t|
+  # Put spec opts in a file named .rspec in root
+end
+
+
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty --no-source -x"
+  t.fork = false
+end
+
+Rake::RDocTask.new do |rd|
+  
+  rd.main = "README.rdoc"
+  
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+end
+
+task :default => [:spec,:features]
+

data/bin/electric_eye

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'methadone'
+require 'construct'
+require 'electric_eye.rb'
+include ElectricEye
+
+class App
+  include Methadone::Main
+  include Methadone::CLILogging
+
+  main do |camera, url| # Add args you want: |like,so|
+    @configEye = ConfigEye.new     # Initialize config
+    @record = Record.new(@configEye) # Initialize record and pass in our config
+    
+    if options[:a]              # Add camera
+      @configEye.add_camera(camera,url) 
+    elsif options[:r]           # Remove camera
+      @configEye.remove_camera(camera)
+    elsif options[:l]           # List cameras
+      @configEye.list_cameras
+    elsif options[:d]           # Set duration
+      @configEye.set_duration(options[:duration]) 
+    elsif options[:p]           # Set path
+      @configEye.set_path(options[:path]) 
+    elsif options[:s]           # Start recording
+      @record.start
+    elsif options[:k]           # Stop recordings
+      @record.stop
+    end
+    
+    exit 0
+  end
+
+
+  
+  description "Network Video Recorder"
+
+  # Accept flags via:
+  on("-a", "--add", "Add a camera") 
+  on("-r", "--remove", "Remove a camera")
+  on("-l", "--list", "List cameras")
+  on("-d", "--duration SECONDS", "Set recording duration in seconds")
+  on("-p", "--path DIR", "Set recordings path")
+  on("-s", "--start", "Start recordings")
+  on("-k", "--stop", "Stop recordings")
+
+  # Arguments
+  arg :camera, :optional
+  arg :url, :optional
+
+  version ElectricEye::VERSION
+  use_log_level_option :toggle_debug_on_signal => 'USR1'
+
+  go!
+end

data/electric_eye.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'electric_eye/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "electric_eye"
+  spec.version       = ElectricEye::VERSION
+  spec.authors       = ["Michael Pope"]
+  spec.email         = ["michael@dtcorp.com.au"]
+  spec.summary       = %q{Network Video Recorder}
+  spec.description   = %q{A network video recorder for multiple IP cameras which uses VLC to record and organises the files according to date and camera name.}
+  spec.homepage      = "https://github.com/map7/electric_eye"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency('rdoc')
+  spec.add_development_dependency('aruba')
+  spec.add_dependency('methadone', '~> 1.9.0')
+  spec.add_development_dependency('rspec', '~> 2.99')
+end

data/features/config.feature

@@ -0,0 +1,40 @@
+Feature: Config Electric Eye
+  In order to record cameras
+  I want to easily setup cameras and other variables
+  So we can just start and stop the recordings
+
+  Scenario: Add camera
+    When I successfully run `electric_eye -a Reception rtsp://user:passwd@192.168.0.100/live.sdp`
+    Then the exit status should be 0
+    And we should have a directory called "~/.electric_eye"
+    And we should have a file called "~/.electric_eye/config.yml"
+    And within the file "~/.electric_eye/config.yml" we should have the camera "Reception"
+    And the stdout should contain "Camera added"
+
+  Scenario: Remove camera
+    Given I have a camera called "Reception"
+    When I successfully run `electric_eye -r Reception`
+    Then the exit status should be 0
+    And within the file "~/.electric_eye/config.yml" we should no cameras
+    And the stdout should contain "Camera removed"
+
+  Scenario: List cameras
+    Given I have a camera called "Reception"
+    When I successfully run `electric_eye -l`
+    Then the exit status should be 0
+    And within the file "~/.electric_eye/config.yml" we should have the camera "Reception"
+    And the stdout should contain "Cameras"
+    And the stdout should contain "Reception"
+
+  Scenario: Set duration
+    When I successfully run `electric_eye -d 10`
+    Then the exit status should be 0
+    And within the file "~/.electric_eye/config.yml" we should have the duration "10"
+    And the stdout should contain "Duration set to 10 seconds"
+
+  Scenario: Set path
+    When I successfully run `electric_eye -p '/data/recordings'`
+    Then the exit status should be 0
+    And within the file "~/.electric_eye/config.yml" we should have the path "/data/recordings"
+    And the stdout should contain "Path set to /data/recordings"
+

data/features/electric_eye.feature

@@ -0,0 +1,23 @@
+Feature: Electric Eye
+  In order to record cameras
+  I want to have an easy to use interface
+
+  Scenario: Basic UI
+    When I get help for "electric_eye"
+    Then the exit status should be 0
+    And the banner should be present
+    And there should be a one line summary of what the app does
+    And the banner should include the version
+    And the banner should document that this app takes options
+    And the banner should document that this app's arguments are:
+    | camera | which is optional |
+    | url    | which is optional |
+    And the following options should be documented:
+    | --add      |
+    | --remove   |
+    | --duration |
+    | --path     |
+    | --list     |
+    | --start    |
+    | --stop     |
+

data/features/record.feature

@@ -0,0 +1,18 @@
+Feature: Record
+  In order to record cameras
+  I need a way to start recordings per camera
+
+  Scenario: Record cameras
+    Given I have a camera called "Reception"
+    When I successfully run `electric_eye --start`
+    Then the exit status should be 0
+    And it should create a pid file in "/tmp/electric_eye.pid"
+    And the stdout should contain "Cameras recording"
+
+  Scenario: Stop recordings
+    Given I have a camera called "Reception"
+    And I successfully run `electric_eye --start`
+    When I successfully run `electric_eye --stop`
+    Then the exit status should be 0
+    And it should remove the pid file in "/tmp/electric_eye.pid"
+    And the stdout should contain "Stop recordings"

data/features/step_definitions/config_steps.rb

@@ -0,0 +1,47 @@
+require 'construct'
+require 'fileutils'
+
+Given(/^I have a camera called "([^"]*)"$/) do |arg1|
+  @config = Construct.new
+  @config.cameras = [{name: "Reception", url: "http://thecamera.org"}]
+  dir="#{ENV['HOME']}/.electric_eye"
+  FileUtils.rm_r(dir) if Dir.exist?(dir)
+  Dir.mkdir(dir)
+  File.open("#{dir}/config.yml","w"){ |f| f.write @config.to_yaml }
+end
+
+Then(/^we should have a directory called "([^"]*)"$/) do |dir|
+  config_dir = File.expand_path(dir) # Expand ~ to ENV["HOME"]
+  expect(Dir.exist?(config_dir)).to equal(true)
+end
+
+Then(/^we should have a file called "([^"]*)"$/) do |dir|
+  config_file = File.expand_path(dir) # Expand ~ to ENV["HOME"]
+  expect(File.exist?(config_file)).to equal(true)
+end
+
+Then(/^within the file "([^"]*)" we should have the camera "([^"]*)"$/) do |file, camera|
+  config_file = File.expand_path(file) # Expand ~ to ENV["HOME"]
+  @config = Construct.load File.read(config_file)
+  expect(@config.cameras.length).to equal(1)
+  expect(@config.cameras.first[:name] == camera).to equal(true)
+end
+
+Then(/^within the file "([^"]*)" we should have the duration "([^"]*)"$/) do |file, duration|
+  config_file = File.expand_path(file) # Expand ~ to ENV["HOME"]
+  @config = Construct.load File.read(config_file)
+  expect(@config.duration == duration.to_i).to equal(true)
+end
+
+Then(/^within the file "([^"]*)" we should have the path "([^"]*)"$/) do |file, path|
+  config_file = File.expand_path(file) # Expand ~ to ENV["HOME"]
+  @config = Construct.load File.read(config_file)
+  expect(@config.path == path).to equal(true)
+end
+
+Then(/^within the file "([^"]*)" we should no cameras$/) do |file|
+  config_file = File.expand_path(file) # Expand ~ to ENV["HOME"]
+  @config = Construct.load File.read(config_file)
+  expect(@config.cameras.length).to equal(0)
+end
+

data/features/step_definitions/electric_eye_steps.rb

@@ -0,0 +1,10 @@
+require 'construct'
+require 'fileutils'
+
+Then(/^it should create a pid file in "([^"]*)"$/) do |file|
+  expect(File.exist?(file)).to equal(true)
+end
+
+Then(/^it should remove the pid file in "([^"]*)"$/) do |file|
+  expect(File.exist?(file)).to equal(false)
+end

data/features/support/env.rb

@@ -0,0 +1,22 @@
+require 'aruba/cucumber'
+require 'methadone/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+  @original_rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+
+  @original_home = ENV['HOME']
+  ENV['HOME'] = "/tmp/fakehome"
+  FileUtils.rm_rf "/tmp/fakehome"
+  FileUtils.mkdir "/tmp/fakehome"
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
+  ENV['HOME'] = @original_home
+end

data/lib/electric_eye/config_eye.rb

@@ -0,0 +1,75 @@
+require 'methadone'
+require 'fileutils'
+require 'table_print'
+
+module ElectricEye
+  class ConfigEye
+
+    include Methadone::CLILogging
+    
+    # Check the directory and if it doesn't exist create it.
+    def self.check_dir
+      FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+    end
+
+    # Check that the config file exists.
+    def self.load
+      # Check if we have a config CONFIG_FILE
+      ConfigEye.check_dir
+      if File.exist?(CONFIG_FILE)
+        Construct.load File.read(CONFIG_FILE)
+      else
+        Construct.new({duration: 600, path: '~/recordings', cameras: []})
+      end
+    end
+
+    # Save the config file
+    def save()
+      File.open(CONFIG_FILE, 'w'){ |f| f.write config.to_yaml } # Store
+    end
+
+    # Add camera
+    def add_camera(camera, url)
+      @config.cameras.push({name: camera, url: url})
+      save
+      info "Camera added"
+    end
+
+    # Remove camera
+    def remove_camera(camera)
+      record = @config.cameras.bsearch{ |c| c[:name] == camera }
+      if record
+        @config.cameras.delete(record)
+        save
+      end
+      info "Camera removed"
+    end
+
+    # List cameras in setup
+    def list_cameras
+      info "Cameras"
+      tp @config.cameras, :name, :url => {width: 120}
+    end
+
+    # Set duration
+    def set_duration(seconds)
+      @config.duration = seconds.to_i
+      save
+      info "Duration set to #{seconds} seconds"
+    end
+
+    # Set path
+    def set_path(dir)
+      @config.path = dir
+      save
+      info "Path set to #{dir}"
+    end
+
+    # Initialise the method.
+    attr_reader :config
+    def initialize
+      @config = ConfigEye.load
+      save
+    end
+  end
+end

data/lib/electric_eye/record.rb

@@ -0,0 +1,72 @@
+require 'methadone'
+require 'open4'
+require 'fileutils'
+
+module ElectricEye
+  class Record
+
+    include Methadone::CLILogging
+    
+    def store_pids(pids = [])
+      File.open(PID_FILE, "w") { |file| file.write pids.join(" ") }
+    end
+
+    def start
+      pids = []
+      # Step through each camera
+      @configEye.config.cameras.each do |camera|
+        # Let's first record two 1minute videos of each camera.
+        # This will turn into a never ending loop until we stop the process.
+        pids << fork do
+          stop_recording = false
+          Signal.trap('INT') { stop_recording = true }
+          until stop_recording
+            debug "Recording #{camera[:name]} to #{path(camera)}..."
+
+            # Set a recording going using vlc, hold onto the process till it's finished.
+            cmd="cvlc --qt-minimal-view --no-audio -R #{camera[:url]} --sout file/ts:#{path(camera)}"
+            pid,stdin,stdout,stderr=Open4::popen4(cmd)
+
+            # Wait for a defined duration from the config file.
+            seconds = @configEye.config.duration
+            while(seconds > 0)
+              sleep 1
+              seconds -= 1
+              break if stop_recording
+            end
+            
+            Process.kill 9, pid # Stop current recording.
+            Process.wait pid    # Wait around so we don't get Zombies
+          end
+        end
+      end
+
+      store_pids(pids)
+      info "Cameras recording"
+    end
+
+    def stop
+      stop_recordings(get_pids) if File.exist?(PID_FILE)
+    end
+
+    def stop_recordings(pids)
+      info "Stop recordings with PID: #{pids}..."
+      Open4::popen4("kill -INT #{pids}") # Kill all recordings
+      File.delete(PID_FILE)   # Remove the pid file.
+    end
+
+    def get_pids
+      File.open(PID_FILE, "r").gets # Get pids
+    end
+    
+    def path(camera)
+      dir = "#{@configEye.config.path}/#{camera[:name]}"
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      "#{dir}/#{Time.now.strftime('%Y%m%d-%H%M')}-#{camera[:name]}.mjpeg"
+    end
+
+    def initialize(configEye)
+      @configEye = configEye
+    end
+  end
+end

data/lib/electric_eye/settings.rb

@@ -0,0 +1,5 @@
+module ElectricEye
+  CONFIG_DIR = "#{ENV['HOME']}/.electric_eye"
+  CONFIG_FILE = "#{CONFIG_DIR}/config.yml"
+  PID_FILE = "/tmp/electric_eye.pid"
+end

data/lib/electric_eye/version.rb

@@ -0,0 +1,3 @@
+module ElectricEye
+  VERSION = "0.0.1"
+end

data/lib/electric_eye.rb

@@ -0,0 +1,9 @@
+require "electric_eye/version"
+require "electric_eye/settings"
+require "electric_eye/config_eye"
+require "electric_eye/record"
+
+module ElectricEye
+
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,190 @@
+require ('spec_helper.rb')
+include ElectricEye
+
+describe "initialize" do
+  include FakeFS::SpecHelpers
+
+  it "sets config" do
+    configEye = ConfigEye.new
+
+    # Check defaults
+    expect(configEye.config.duration).to equal(600)
+    expect(configEye.config.path).to include("~/recordings")
+    expect(configEye.config.cameras.length).to equal(0)
+  end
+end
+
+describe "check_dir" do
+  include FakeFS::SpecHelpers
+  
+  context "when config directory does not exists" do
+    it "makes a directory" do
+      ConfigEye.check_dir
+      expect(File.directory?(CONFIG_DIR)).to equal(true)
+    end
+  end
+  
+  context "when config directory exists" do
+    it "doesn't make a directory" do
+      FileUtils.mkdir_p(CONFIG_DIR) # Create the directory
+      ConfigEye.check_dir
+      expect(File.directory?(CONFIG_DIR)).to equal(true)
+    end
+  end
+end
+
+describe "save" do
+  include FakeFS::SpecHelpers
+
+  context "config is set" do
+    it "writes the config file" do
+      @configEye = ConfigEye.new
+      @configEye.save
+      expect(File.file?(CONFIG_FILE)).to equal(true)
+    end
+  end
+end
+
+describe "check config" do
+  include FakeFS::SpecHelpers
+
+  it "checks the directory" do
+    ConfigEye.load
+    expect(File.directory?(CONFIG_DIR)).to equal(true)
+  end
+  
+  context "when exists" do
+    before do
+      # Create the file beforehand
+      @configEye = ConfigEye.new
+      @configEye.save
+    end
+    
+    it "returns a construct object" do
+      expect(File.directory?(CONFIG_DIR)).to equal(true)
+      @config = ConfigEye.load      
+      expect(@config.class).to equal(Construct)      
+    end
+  end
+  
+  context "doesn't exist" do
+    before do
+      @configEye = ConfigEye.load      
+      expect(File.file?(CONFIG_FILE)).to equal(false)
+    end
+
+    it "returns a construct object" do
+      expect(@configEye.class).to equal(Construct)      
+    end
+
+    it "includes a cameras array" do
+      expect(@configEye.cameras.class).to equal(Array)      
+    end
+  end
+end
+
+describe "add camera" do
+  include FakeFS::SpecHelpers
+
+  before do
+    @configEye = ConfigEye.new
+  end
+  
+  it "adds camera to array" do
+    @configEye.add_camera("Reception", "http://user:pass@my.camera.org/live2.sdp")
+    expect(@configEye.config.cameras.length).to equal(1)
+  end
+
+  it "calls save" do
+    expect(@configEye).to receive(:save).once
+    @configEye.add_camera("Reception", "http://user:pass@my.camera.org/live2.sdp")
+  end
+end
+
+describe "remove camera" do
+  include FakeFS::SpecHelpers
+
+  before do
+    @configEye = ConfigEye.new
+    @configEye.add_camera("Reception", "http://user:pass@my.camera.org/live2.sdp")
+  end
+
+  context "when camera exists" do
+    it "removes camera from array" do
+      expect(@configEye.config.cameras.length).to equal(1)
+      @configEye.remove_camera("Reception")
+      expect(@configEye.config.cameras.length).to equal(0)
+    end
+
+    it "calls save" do
+      expect(@configEye).to receive(:save).once
+      @configEye.remove_camera("Reception")
+    end
+  end
+
+  context "when specified camera doesn't exist" do
+    it "keeps the camera array the same size" do
+      expect(@configEye.config.cameras.length).to equal(1)
+      @configEye.remove_camera("Kitchen")
+      expect(@configEye.config.cameras.length).to equal(1)
+    end
+
+    it "calls save" do
+      expect(ConfigEye).to receive(:save).never
+      @configEye.remove_camera("Kitchen")
+    end
+  end
+end
+
+describe "set_duration" do
+  include FakeFS::SpecHelpers
+
+  before do
+    @configEye = ConfigEye.new
+  end
+
+  context "when no duration has been set" do
+    it "returns the default of 600 seconds" do
+      expect(@configEye.config.duration).to equal(600)
+    end
+  end
+
+  context "when calling with -d 10" do
+    it "returns 10" do
+      @configEye.set_duration(10)
+      expect(@configEye.config.duration).to equal(10)
+    end
+
+    it "calls save" do
+      expect(@configEye).to receive(:save).once
+      @configEye.set_duration(10)
+    end
+  end
+end
+
+describe "set_path" do
+  include FakeFS::SpecHelpers
+
+  before do
+    @configEye = ConfigEye.new
+  end
+
+  context "when no path has been set" do
+    it "returns the default of ~/recordings" do
+      expect(@configEye.config.path == "~/recordings").to equal(true)
+    end
+  end
+
+  context "when calling with -p '/data/recordings'" do
+    it "returns '/data/recordings'" do
+      @configEye.set_path('/data/recordings')
+      expect(@configEye.config.path == '/data/recordings').to equal(true)
+    end
+
+    it "calls save" do
+      expect(@configEye).to receive(:save).once
+      @configEye.set_path('/data/recordings')
+    end
+  end
+end
+

data/spec/electric_eye_spec.rb

@@ -0,0 +1,77 @@
+require ('spec_helper.rb')
+
+describe "record" do
+  include FakeFS::SpecHelpers
+
+  before do
+    @configEye = ConfigEye.new
+    @configEye.add_camera("Reception", "http://user:pass@my.camera.org/live2.sdp")
+    @record = Record.new(@configEye)
+  end
+
+  describe "store_pids" do
+    before do
+      @file = "/tmp/electric_eye.pid"
+      ConfigEye.stub(:load).and_return(Construct.new({path: "~/recordings", cameras: [{name: "Reception"}]}))
+    end
+
+    it "creates a file #{@file}" do
+      @record.store_pids
+      expect(File.exist?(@file)).to equal(true)
+    end
+
+    it "should store the pids in the file" do
+      pids = [100, 101, 102]
+      @record.store_pids(pids)
+      expect(File.read(@file) == "100 101 102").to equal(true)
+    end
+  end
+
+  describe "record_path" do
+    before do
+      Timecop.freeze(Time.local(2015,06,30,10,05,0))
+    end
+
+    after do
+      Timecop.return
+    end
+    
+    it "returns a full path with todays date" do
+      path = @record.path(@configEye.config.cameras.first)
+      expect(path).to include("~/recordings/Reception/20150630-1005-Reception.mjpeg")
+    end
+  end
+
+  describe "get_pids" do
+    it "returns pids" do
+      File.open("/tmp/electric_eye.pid", "w") do |file|
+        file.write("1 2 3")
+      end
+
+      expect(@record.get_pids == "1 2 3").to equal(true)
+    end
+  end
+
+  describe "stop_recordings" do
+    before do
+      File.open("/tmp/electric_eye.pid", "w") do |file|
+        file.write("10000 10001 10002")
+      end
+    end
+    
+    it "calls kill" do
+      open4 = mock(Open4)
+      open4.stub!(:exitstatus).and_return(0)
+      
+      Open4.should_receive(:popen4).with('kill -INT 10000 10001 10002').and_return(open4)
+
+      @record.stop_recordings("10000 10001 10002")
+    end
+
+    it "removes the old file" do
+      expect(File.exists?("/tmp/electric_eye.pid")).to equal(true)
+      @record.stop_recordings("10000 10001 10002")
+      expect(File.exists?("/tmp/electric_eye.pid")).to equal(false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'construct'
+require 'timecop'
+require 'fakefs/spec_helpers'
+require ('electric_eye.rb')
+
+RSpec.configure do |config|
+  config.before(:each) do
+    # Set the directory
+    stub_const("ElectricEye::CONFIG_DIR", "/tmp/fakehome/.electric_eye")
+    stub_const("ElectricEye::CONFIG_FILE", "/tmp/fakehome/.electric_eye/config.yml")
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: electric_eye
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Pope
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: methadone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+description: A network video recorder for multiple IP cameras which uses VLC to record
+  and organises the files according to date and camera name.
+email:
+- michael@dtcorp.com.au
+executables:
+- electric_eye
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- README.rdoc
+- Rakefile
+- bin/electric_eye
+- electric_eye.gemspec
+- features/config.feature
+- features/electric_eye.feature
+- features/record.feature
+- features/step_definitions/config_steps.rb
+- features/step_definitions/electric_eye_steps.rb
+- features/support/env.rb
+- lib/electric_eye.rb
+- lib/electric_eye/config_eye.rb
+- lib/electric_eye/record.rb
+- lib/electric_eye/settings.rb
+- lib/electric_eye/version.rb
+- spec/config_spec.rb
+- spec/electric_eye_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/map7/electric_eye
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Network Video Recorder
+test_files:
+- features/config.feature
+- features/electric_eye.feature
+- features/record.feature
+- features/step_definitions/config_steps.rb
+- features/step_definitions/electric_eye_steps.rb
+- features/support/env.rb
+- spec/config_spec.rb
+- spec/electric_eye_spec.rb
+- spec/spec_helper.rb