simple_pvr 0.0.1

data/lib/simple_pvr/pvr_initializer.rb

@@ -0,0 +1,47 @@
+module SimplePvr
+  class PvrInitializer
+    def self.setup
+      Model::DatabaseInitializer.setup
+      setup_with_hdhomerun(HDHomeRun.new)
+      @hdhomerun.scan_for_channels if Model::Channel.all.empty?
+    end
+    
+    def self.setup_for_integration_test
+      Model::DatabaseInitializer.prepare_for_test
+      setup_with_hdhomerun(HDHomeRunFake.new)
+    end
+    
+    def self.hdhomerun
+      @hdhomerun
+    end
+    
+    def self.recording_manager
+      @recording_manager
+    end
+    
+    def self.scheduler
+      @scheduler
+    end
+
+    def self.rackup_file_path
+      File.dirname(__FILE__) + '/server/config.ru'
+    end
+    
+    def self.rack_maps_file
+      File.read(File.dirname(__FILE__) + '/server/rack_maps.rb')
+    end
+    
+    def self.sleep_forever
+      forever = 6000.days
+      sleep forever
+    end
+    
+    private
+    def self.setup_with_hdhomerun(hdhomerun)
+      @hdhomerun = hdhomerun
+      @recording_manager = RecordingManager.new
+      @scheduler = Scheduler.new
+      @scheduler.start
+    end
+  end
+end

data/lib/simple_pvr/pvr_logger.rb

@@ -0,0 +1,14 @@
+require 'logger'
+
+module SimplePvr
+  class PvrLogger
+    @@logger = Logger.new(STDOUT)
+    @@logger.formatter = proc do |severity, datetime, progname, msg|
+      "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity} #{msg}\n"
+    end
+  
+    def self.info(message)
+      @@logger.info(message)
+    end
+  end
+end

data/lib/simple_pvr/recorder.rb

@@ -0,0 +1,25 @@
+require 'fileutils'
+require File.dirname(__FILE__) + '/hdhomerun'
+require File.dirname(__FILE__) + '/pvr_logger'
+
+module SimplePvr
+  class Recorder
+    def initialize(tuner, recording)
+      @tuner, @recording = tuner, recording
+    end
+  
+    def start!
+      @directory = PvrInitializer.recording_manager.create_directory_for_recording(@recording)
+      PvrInitializer.hdhomerun.start_recording(@tuner, @recording.channel.frequency, @recording.channel.channel_id, @directory)
+    
+      PvrLogger.info "Started recording #{@recording.show_name} in #{@directory}"
+    end
+  
+    def stop!
+      PvrInitializer.hdhomerun.stop_recording(@tuner)
+      Ffmpeg.create_thumbnail_for(@directory)
+    
+      PvrLogger.info "Stopped recording #{@recording.show_name}"
+    end
+  end
+end

data/lib/simple_pvr/recording_manager.rb

@@ -0,0 +1,101 @@
+module SimplePvr
+  RecordingMetadata = Struct.new(:has_thumbnail, :has_webm, :show_name, :episode, :channel, :subtitle, :description, :start_time, :duration)
+  
+  class RecordingManager
+    def initialize(recordings_directory=nil)
+      @recordings_directory = recordings_directory || Dir.pwd + '/recordings'
+    end
+    
+    def shows
+      Dir.new(@recordings_directory).entries - ['.', '..']
+    end
+    
+    def delete_show(show_name)
+      FileUtils.rm_rf(directory_for_show(show_name))
+    end
+    
+    def episodes_of(show_name)
+      episodes = Dir.new(directory_for_show(show_name)).entries - ['.', '..']
+      episodes.map do |episode|
+        metadata_for(show_name, episode)
+      end
+    end
+    
+    def metadata_for(show_name, episode)
+      metadata_file_name = directory_for_show_and_episode(show_name, episode) + '/metadata.yml'
+      metadata = File.exists?(metadata_file_name) ? YAML.load_file(metadata_file_name) : {}
+
+      thumbnail_file_name = directory_for_show_and_episode(show_name, episode) + '/thumbnail.png'
+      has_thumbnail = File.exists?(thumbnail_file_name)
+
+      webm_file_name = directory_for_show_and_episode(show_name, episode) + '/stream.webm'
+      has_webm = File.exists?(webm_file_name)
+
+      RecordingMetadata.new(
+        has_thumbnail,
+        has_webm,
+        show_name,
+        episode,
+        metadata[:channel],
+        metadata[:subtitle],
+        metadata[:description],
+        metadata[:start_time],
+        metadata[:duration])
+    end
+
+    def delete_show_episode(show_name, episode)
+      FileUtils.rm_rf(@recordings_directory + '/' + show_name + '/' + episode)
+    end
+
+    def create_directory_for_recording(recording)
+      show_directory = directory_for_show(recording.show_name)
+      ensure_directory_exists(show_directory)
+
+      new_sequence_number = next_sequence_number_for(show_directory)
+      recording_directory = "#{show_directory}/#{new_sequence_number}"
+      ensure_directory_exists(recording_directory)
+
+      create_metadata(recording_directory, recording)
+
+      recording_directory
+    end
+    
+    def directory_for_show_and_episode(show_name, episode)
+      directory_for_show(show_name) + '/' + episode
+    end
+
+    private
+    def directory_for_show(show_name)
+      sanitized_directory_name = show_name.gsub(/\"|\'|\*|\.|\/|\\|:/, '')
+      directory_name = sanitized_directory_name.present? ? sanitized_directory_name : 'Unnamed'
+      @recordings_directory + '/' + directory_name
+    end
+    
+    def ensure_directory_exists(directory)
+      FileUtils.makedirs(directory) unless File.exists?(directory)
+    end
+    
+    def next_sequence_number_for(base_directory)
+      largest_current_sequence_number = Dir.new(base_directory).map {|dir_name| dir_name.to_i }.max
+      1 + largest_current_sequence_number
+    end
+    
+    def create_metadata(directory, recording)
+      metadata = {
+        title: recording.show_name,
+        channel: recording.channel.name,
+        start_time: recording.start_time,
+        duration: recording.duration
+      }
+      
+      if recording.programme
+        metadata.merge!({
+          subtitle: recording.programme.subtitle,
+          description: recording.programme.description
+        })
+      end
+            
+      File.open(directory + '/metadata.yml', 'w') {|f| f.write(metadata.to_yaml) }
+    end
+  end
+end

data/lib/simple_pvr/recording_planner.rb

@@ -0,0 +1,72 @@
+module SimplePvr
+  class RecordingPlanner
+    def self.read
+      planner = self.new
+      planner.read
+    end
+    
+    def initialize
+      @recordings = []
+    end
+
+    def read
+      schedules = Model::Schedule.all
+      specifications = schedules.find_all {|s| s.type == :specification }
+      exceptions = schedules.find_all {|s| s.type == :exception }
+      
+      specifications.each do |specification|
+        title = specification.title
+        if specification.channel && specification.start_time
+          programmes = Model::Programme.on_channel_with_title_and_start_time(specification.channel, specification.title, specification.start_time)
+        elsif specification.channel
+          programmes = Model::Programme.on_channel_with_title(specification.channel, specification.title)
+        else
+          programmes = Model::Programme.with_title(specification.title)
+        end
+        
+        programmes_with_exceptions_removed = programmes.find_all {|programme| !matches_exception(programme, exceptions) }
+        programmes_filtered_by_weekdays = programmes_with_exceptions_removed.find_all {|programme| on_allowed_weekday(programme, specification) }
+        add_programmes(title, programmes_filtered_by_weekdays)
+      end
+
+      PvrInitializer.scheduler.recordings = @recordings
+    end
+    
+    private
+    def matches_exception(programme, exceptions)
+      exceptions.any? do |exception|
+        programme.title == exception.title &&
+        programme.channel == exception.channel &&
+        programme.start_time == exception.start_time
+      end
+    end
+    
+    def on_allowed_weekday(programme, specification)
+      return true unless specification.filter_by_weekday
+      
+      date = programme.start_time
+      case true
+      when date.monday? then specification.monday
+      when date.tuesday? then specification.tuesday
+      when date.wednesday? then specification.wednesday
+      when date.thursday? then specification.thursday
+      when date.friday? then specification.friday
+      when date.saturday? then specification.saturday
+      when date.sunday? then specification.sunday
+      else false
+      end
+    end
+    
+    def add_programmes(title, programmes)
+      programmes.each do |programme|
+        start_time = programme.start_time.advance(minutes: -2)
+        duration = programme.duration + 7.minutes
+        add_recording(title, programme.channel, start_time, duration, programme)
+      end
+    end
+    
+    def add_recording(title, channel, start_time, duration, programme=nil)
+      @recordings << SimplePvr::Model::Recording.new(channel, title, start_time, duration, programme)
+    end
+  end
+end

data/lib/simple_pvr/scheduler.rb

@@ -0,0 +1,124 @@
+module SimplePvr
+  class Scheduler
+    attr_reader :upcoming_recordings
+    
+    def initialize
+      @number_of_tuners = 2
+      @upcoming_recordings, @current_recordings, @recorders = [], [nil] * @number_of_tuners, {}
+      @mutex = Mutex.new
+    end
+
+    def start
+      @thread = Thread.new do
+        while true
+          @mutex.synchronize { process }
+          sleep 1
+        end
+      end
+    end
+    
+    def recordings=(recordings)
+      @mutex.synchronize do
+        @upcoming_recordings = recordings.sort_by {|r| r.start_time }.find_all {|r| !r.expired? }
+
+        @scheduled_programmes = programme_ids_from(@upcoming_recordings)
+        stop_current_recordings_not_relevant_anymore
+        @upcoming_recordings = remove_current_recordings(@upcoming_recordings)
+        mark_conflicting_recordings(@upcoming_recordings)
+        @conflicting_programmes = programme_ids_from(@upcoming_recordings.find_all {|r| r.conflicting? })
+      end
+    end
+    
+    def is_scheduled?(programme)
+      @scheduled_programmes[programme.id] != nil
+    end
+    
+    def is_conflicting?(programme)
+      @conflicting_programmes[programme.id] != nil
+    end
+    
+    def status_text
+      @mutex.synchronize do
+        return 'Idle' unless is_recording?
+
+        status_texts = active_recordings.map {|recording| "'#{recording.show_name}' on channel '#{recording.channel.name}'"}
+        'Recording ' + status_texts.join(', ')
+      end
+    end
+
+    def process
+      check_expiration_of_current_recordings
+      check_start_of_coming_recordings
+    end
+    
+    private
+    def mark_conflicting_recordings(recordings)
+      concurrent_recordings = active_recordings
+      recordings.each do |recording|
+        concurrent_recordings = concurrent_recordings.reject {|r| r.expired_at(recording.start_time) }
+        recording.conflicting = concurrent_recordings.size >= @number_of_tuners
+        concurrent_recordings << recording unless recording.conflicting?
+      end
+    end
+    
+    def is_recording?
+      !active_recordings.empty?
+    end
+    
+    def active_recordings
+      @current_recordings.find_all {|recording| recording != nil }
+    end
+    
+    def programme_ids_from(recordings)
+      result = {}
+      recordings.each do |recording|
+        result[recording.programme.id] = true if recording.programme
+      end
+      result
+    end
+    
+    def remove_current_recordings(recordings)
+      recordings.find_all {|recording| !@current_recordings.include?(recording) }
+    end
+    
+    def stop_current_recordings_not_relevant_anymore
+      @current_recordings.each do |recording|
+        stop_recording(recording) if recording && !@upcoming_recordings.include?(recording)
+      end
+    end
+    
+    def check_expiration_of_current_recordings
+      @current_recordings.each do |recording|
+        stop_recording(recording) if recording && recording.expired?
+      end
+    end
+    
+    def check_start_of_coming_recordings
+      while should_start_next_recording
+        start_next_recording
+      end
+    end
+    
+    def should_start_next_recording
+      next_recording = @upcoming_recordings[0]
+      next_recording && next_recording.start_time <= Time.now
+    end
+    
+    def stop_recording(recording)
+      @recorders[recording].stop!
+      @recorders[recording] = nil
+      @current_recordings[@current_recordings.find_index(recording)] = nil
+    end
+    
+    def start_next_recording
+      next_recording = @upcoming_recordings.delete_at(0)
+      available_slot = @current_recordings.find_index(nil)
+      if available_slot
+        recorder = Recorder.new(available_slot, next_recording)
+        @current_recordings[available_slot] = next_recording
+        @recorders[next_recording] = recorder
+        recorder.start!
+      end
+    end
+  end
+end

data/lib/simple_pvr/server/app_controller.rb

@@ -0,0 +1,13 @@
+module SimplePvr
+  module Server
+    class AppController < BaseController
+      get '/app/*' do |path|
+        send_file File.join(settings.public_folder, path)
+      end
+
+      get '/*' do
+        send_file File.join(settings.public_folder, 'index.html')
+      end
+    end
+  end
+end

data/lib/simple_pvr/server/base_controller.rb

@@ -0,0 +1,94 @@
+require 'sinatra/base'
+
+Time::DATE_FORMATS[:programme_date] = '%F'
+Time::DATE_FORMATS[:day] = '%a, %d %b'
+
+module SimplePvr
+  module Server
+    class BaseController < Sinatra::Base
+      include ERB::Util
+
+      http_username, http_password = ENV['username'], ENV['password']
+      if http_username && http_password
+        PvrLogger.info('Securing server with Basic HTTP Authentication')
+        use Rack::Auth::Basic, 'Restricted Area' do |username, password|
+          [username, password] == [http_username, http_password]
+        end
+      else
+        PvrLogger.info('Beware: Unsecured server. Do not expose to the rest of the world!')
+      end
+
+      configure do
+        set :public_folder, File.dirname(__FILE__) + '/../../../public/'
+        mime_type :webm, 'video/webm'
+      end
+
+      def reload_schedules
+        RecordingPlanner.read
+      end
+
+      def programme_hash(programme)
+        is_scheduled = PvrInitializer.scheduler.is_scheduled?(programme)
+        {
+          id: programme.id,
+          channel: { id: programme.channel.id, name: programme.channel.name },
+          title: programme.title,
+          subtitle: programme.subtitle,
+          description: programme.description,
+          start_time: programme.start_time,
+          is_scheduled: is_scheduled,
+          episode_num: programme.episode_num
+        }
+      end
+
+      def recording_hash(show_id, recording)
+        path = PvrInitializer.recording_manager.directory_for_show_and_episode(show_id, recording.episode)
+        {
+          id: recording.episode,
+          show_id: show_id,
+          episode: recording.episode,
+          subtitle: recording.subtitle,
+          description: recording.description,
+          start_time: recording.start_time,
+          channel_name: recording.channel,
+          has_thumbnail: recording.has_thumbnail,
+          has_webm: recording.has_webm,
+          local_file_url: 'file://' + File.join(path, 'stream.ts')
+        }
+      end
+
+      def channel_with_current_programmes_hash(channel_with_current_programmes)
+        channel = channel_with_current_programmes[:channel]
+        current_programme = channel_with_current_programmes[:current_programme]
+        upcoming_programmes = channel_with_current_programmes[:upcoming_programmes]
+
+        current_programme_map = current_programme ? programme_summary_hash(current_programme) : nil
+        upcoming_programmes_map = programme_summaries_hash(upcoming_programmes)
+
+        {
+          id: channel.id,
+          name: channel.name,
+          hidden: channel.hidden,
+          icon_url: channel.icon_url,
+          current_programme: channel,
+          current_programme: current_programme_map,
+          upcoming_programmes: upcoming_programmes_map
+        }
+      end
+    
+      def programme_summaries_hash(programmes)
+        programmes.map {|programme| programme_summary_hash(programme) }
+      end
+    
+      def programme_summary_hash(programme)
+        {
+          id: programme.id,
+          title: programme.title,
+          start_time: programme.start_time,
+          is_scheduled: PvrInitializer.scheduler.is_scheduled?(programme),
+          is_conflicting: PvrInitializer.scheduler.is_conflicting?(programme)
+        }
+      end
+    end
+  end
+end

data/lib/simple_pvr/server/channels_controller.rb

@@ -0,0 +1,68 @@
+module SimplePvr
+  module Server
+    class ChannelsController < BaseController
+      get '/' do
+        Model::Channel.all_with_current_programmes.map do |channel_with_current_programmes|
+          channel_with_current_programmes_hash(channel_with_current_programmes)
+        end.to_json
+      end
+
+      get '/:id' do |id|
+        channel_with_current_programmes_hash(Model::Channel.with_current_programmes(id)).to_json
+      end
+
+      post '/:id/hide' do |id|
+        channel = Model::Channel.get(id)
+        channel.hidden = true
+        channel.save
+        {
+          id: channel.id,
+          name: channel.name,
+          hidden: channel.hidden
+        }.to_json
+      end
+
+      post '/:id/show' do |id|
+        channel = Model::Channel.get(id)
+        channel.hidden = false
+        channel.save
+        {
+          id: channel.id,
+          name: channel.name,
+          hidden: channel.hidden
+        }.to_json
+      end
+
+      get '/:channel_id/programme_listings/:date/?' do |channel_id, date_string|
+        if date_string == 'today'
+          now = Time.now
+          this_date = Time.local(now.year, now.month, now.day)
+        else
+          this_date = Time.parse(date_string)
+        end
+        previous_date = this_date.advance(days: -7)
+        next_date = this_date.advance(days: 7)
+        channel = Model::Channel.get(channel_id)
+
+        days = (0..6).map do |date_advanced|
+          from_date = this_date.advance(days: date_advanced)
+          to_date = this_date.advance(days: date_advanced + 1)
+          programmes = Model::Programme.all(channel: channel, start_time: (from_date..to_date), order: :start_time)
+
+          {
+            date: from_date.to_s(:programme_date),
+            programmes: programme_summaries_hash(programmes)
+          }
+        end
+
+        {
+          channel: { id: channel.id, name: channel.name,  icon_url: channel.icon_url },
+          previous_date: previous_date.to_s(:programme_date),
+          this_date: this_date.to_s(:programme_date),
+          next_date: next_date.to_s(:programme_date),
+          days: days
+        }.to_json
+      end
+    end
+  end
+end

data/lib/simple_pvr/server/config.ru

@@ -0,0 +1,8 @@
+SimplePvr::PvrInitializer.setup
+SimplePvr::RecordingPlanner.read
+
+# Due to a lazy initialization bug in ActiveSupport:
+# http://stackoverflow.com/questions/5267700/undefined-method-encode-for-activesupportjsonmodule
+{:a => :b}.to_json
+
+eval SimplePvr::PvrInitializer.rack_maps_file

data/lib/simple_pvr/server/programmes_controller.rb

@@ -0,0 +1,46 @@
+module SimplePvr
+  module Server
+    class ProgrammesController < BaseController
+      get '/title_search' do
+        Model::Programme.titles_containing(params['query']).to_json
+      end
+
+      get '/search' do
+        Model::Programme.with_title_containing(params['query']).map {|programme| programme_hash(programme) }.to_json
+      end
+
+      get '/:id' do |id|
+        programme = Model::Programme.get(id)
+        programme_hash(programme).to_json
+      end
+
+      post '/:id/record_on_any_channel' do |id|
+        programme = Model::Programme.get(id.to_i)
+        Model::Schedule.add_specification(title: programme.title)
+        reload_schedules
+        programme_hash(programme).to_json
+      end
+
+      post '/:id/record_on_this_channel' do |id|
+        programme = Model::Programme.get(id.to_i)
+        Model::Schedule.add_specification(title: programme.title, channel: programme.channel)
+        reload_schedules
+        programme_hash(programme).to_json
+      end
+
+      post '/:id/record_just_this_programme' do |id|
+        programme = Model::Programme.get(id.to_i)
+        Model::Schedule.add_specification(title: programme.title, channel: programme.channel, start_time: programme.start_time)
+        reload_schedules
+        programme_hash(programme).to_json
+      end
+
+      post '/:id/exclude' do |id|
+        programme = Model::Programme.get(id.to_i)
+        Model::Schedule.create(type: :exception, title: programme.title, channel: programme.channel, start_time: programme.start_time)
+        reload_schedules
+        programme_hash(programme).to_json
+      end
+    end
+  end
+end

data/lib/simple_pvr/server/rack_maps.rb

@@ -0,0 +1,7 @@
+map('/')                        { run SimplePvr::Server::AppController                }
+map('/api/channels')            { run SimplePvr::Server::ChannelsController           }
+map('/api/programmes')          { run SimplePvr::Server::ProgrammesController         }
+map('/api/schedules')           { run SimplePvr::Server::SchedulesController          }
+map('/api/shows')               { run SimplePvr::Server::ShowsController              }
+map('/api/status')              { run SimplePvr::Server::StatusController             }
+map('/api/upcoming_recordings') { run SimplePvr::Server::UpcomingRecordingsController }