tivohmo 0.1.0

data/lib/tivohmo/server.rb

@@ -0,0 +1,306 @@
+require 'builder'
+require 'sinatra/base'
+require 'active_support/core_ext/string'
+require 'zlib'
+require 'time'
+
+module TivoHMO
+
+  # The http server for serving the Application/Container/Item tree,
+  # including an endpoint for transcoding video from the Item to the
+  # tivo format
+  class Server < Sinatra::Base
+    include GemLogger::LoggerSupport
+
+    disable :logging
+    set :root, File.expand_path("../server", __FILE__)
+    set :reload_templates, true
+    set :builder, :content_type => 'text/xml'
+
+    before do
+      logger.info "Request from #{request.ip} \"#{request.request_method} #{request.url}\""
+      logger.debug "Headers: #{headers.inspect}"
+    end
+
+    after do
+      logger.info "Response to #{request.ip} for \"#{request.request_method} #{request.url}\" [#{response.status}]"
+      logger.debug "Headers: #{response.header}"
+      if ! response.body.is_a?(Sinatra::Helpers::Stream)
+        logger.debug "Body:\n"
+        logger.debug response.body.join("\n")
+      end
+    end
+
+
+    def self.start(server, port, &block)
+      Rack::Handler.default.run new(server), Port: port, &block
+    end
+
+    def initialize(server)
+      @server = server
+      super
+    end
+
+    module Helpers
+      include Rack::Utils
+
+      def logger
+        Server.logger
+      end
+
+      def server
+        @server
+      end
+
+      def unsupported
+        status 404
+        erb :unsupported, layout: true
+      end
+
+      def tsn
+        headers['TiVo_TCD_ID']
+      end
+
+      def sort(items, sort_order)
+        sort_order = sort_order.split(/\s*,\s*/)
+
+        sort_order.each do |order|
+
+          reverse = false
+          if order[0] == '!'
+            reverse = true
+            order = order[1..-1]
+          end
+
+          case order
+            when 'Title'
+              items = items.sort_by(&:title)
+            when 'CaptureDate'
+              items = items.sort_by(&:created_at)
+          end
+
+          items = items.reverse if reverse
+        end
+        items
+      end
+
+      def container_url(container)
+        url = "/TiVoConnect"
+        params = {
+            Command: 'QueryContainer',
+            Container: container.title_path
+        }
+        url << "?" << build_query(params)
+      end
+
+      def item_url(item)
+        item.title_path
+      end
+
+      def item_detail_url(item)
+        url = "/TiVoConnect"
+        container = item.app.title
+        file = item.title_path.sub("/#{container}/", '')
+        params = {
+            Command: 'TVBusQuery',
+            Container: container,
+            File: file
+        }
+        url << "?" << build_query(params)
+      end
+
+      # to format uuids as needed by tivo in builders
+      def format_uuid(s)
+        Zlib.crc32(s)
+      end
+
+      # to format date/time as needed by tivo in builders
+      def format_date(time)
+        "0x#{time.to_i.to_s(16)}"
+      end
+
+      def format_iso_date(time)
+        return "" unless time
+        time.utc.strftime("%FT%T.%6N")
+      end
+
+      def format_iso_duration(duration)
+        return "" unless duration
+        seconds = duration % 60
+        minutes = (duration / 60) % 60
+        hours = (duration / (60 * 60)) % 24
+        days = (duration / (60 * 60 * 24)).to_i
+        'P%sDT%sH%sM%sS' % [days, hours, minutes, seconds]
+      end
+
+      def pad(length, align)
+        extra = length % align
+        extra = align - extra if extra > 0
+        extra
+      end
+
+      def tivo_header(item, mime)
+        if mime == 'video/x-tivo-mpeg-ts'
+          flag = 45
+        else
+          flag = 13
+        end
+
+        item_details_xml = builder :item_details, layout: true, locals: {item: item}
+        ld = item_details_xml.bytesize
+        chunk = item_details_xml + '\0' * (pad(ld, 4) + 4)
+        lc = chunk.bytesize
+        blocklen = lc * 2 + 40
+        padding = pad(blocklen, 1024)
+
+        data = 'TiVo'
+        data << [4, flag, 0, padding + blocklen, 2].pack('nnnNn')
+        data << [lc + 12, ld, 1, 0].pack('NNnn')
+        data << chunk
+        data << [lc + 12, ld, 2, 0].pack('NNnn')
+        data << chunk
+        data << "\0" * padding
+
+        data
+      end
+
+    end
+
+    helpers do
+      include Helpers
+    end
+
+    # Get the xml doc describing the active HME applications
+    get '/TiVoConnect' do
+      command = params['Command']
+
+      # pagination
+      item_start = (params['ItemStart'] || 0).to_i
+      item_count = (params['ItemCount'] || 8).to_i
+
+      # Yes or No, default no
+      recurse = (params['Recurse'] == 'Yes')
+
+      # csv of Type, Title, CreationDate, LastChangeDate, Random
+      # reverse with preceding !
+      sort_order = params['SortOrder']
+
+      # csv of mime types from Details.ContentType, wildcards allowed,
+      # negation is preceding !, default/missing is */*
+      filter = params['Filter']
+      serial = params['SerialNum']
+
+      container_path = params['Container'] || '/'
+
+      anchor_item = params['AnchorItem']
+      if anchor_item && anchor_item =~ /QueryContainer/
+        query = parse_query(URI(anchor_item).query)
+        anchor_item = query['Container']
+      end
+
+      anchor_offset = params['AnchorOffset'].to_i
+
+      locals = {
+          show_genres: params['DoGenres'],
+          item_start: item_start,
+          item_count: item_count
+      }
+
+      case command
+
+        when 'QueryContainer' then
+
+          container = server.find(container_path)
+          halt 404, "No container found for #{container_path}" unless container
+
+          children = container.children
+          children = sort(children, sort_order) if sort_order
+
+          if anchor_item
+            anchor = server.find(anchor_item)
+            if anchor
+              idx = children.index(anchor)
+              if idx
+                # -1 means show starting at the anchor item
+                # ItemStart should be the index of the anchor
+                anchor_offset = anchor_offset + 1 if anchor_offset < 0
+                item_start = idx + anchor_offset
+                item_start = 0 if item_start < 0
+                locals[:item_start] = item_start
+              else
+                logger.warn "Anchor not in container: #{container}, #{anchor_item}"
+              end
+            else
+              logger.warn "Anchor not found: #{anchor_item}"
+            end
+          end
+
+          if container.root?
+            builder :server, layout: true,
+                    locals: locals.merge(container: container, children: children)
+          else
+            builder :container, layout: true,
+                    locals: locals.merge(container: container, children: children)
+          end
+
+
+        when 'TVBusQuery' then
+          container_path = params['Container']
+          item_title = params['File']
+          halt 404, "Need Container and File params" unless container_path && item_title
+
+          path = "#{container_path}/#{item_title}"
+          item = server.find(path)
+          halt 404, "No item found for #{path}" unless item
+
+          builder :item_details, layout: true, locals: locals.merge(item: item)
+
+        when 'QueryFormats' then
+          sf = params['SourceFormat']
+          if sf.to_s.start_with?('video')
+            formats = ["video/x-tivo-mpeg"]
+            formats << "video/x-tivo-mpeg-ts" # if is_ts_capable(tsn)
+            builder :video_formats, layout: true, locals: locals.merge(formats: formats)
+          else
+            unsupported
+          end
+
+        when 'QueryServer' then
+          builder :server_info, layout: true
+
+        when 'QueryItem' then
+          status 200
+          body ""
+
+        when 'FlushServer' then
+          status 200
+          body ""
+
+        when 'ResetServer' then
+          status 200
+          body ""
+
+        else
+          unsupported
+      end
+
+    end
+
+    get '/*' do
+      title_path = params[:splat].first
+      format = params['Format']
+      item = server.find(title_path)
+      halt 404, "No item found for #{title_path}" unless item && item.is_a?(TivoHMO::API::Item)
+
+      status 206
+      response["Content-Type"] = format
+
+      stream do |out|
+        out << tivo_header(item, format)
+        item.transcoder.transcode(out, format)
+      end
+
+    end
+
+  end
+end

data/lib/tivohmo/version.rb

@@ -0,0 +1,3 @@
+module TivoHMO
+  VERSION = "0.1.0"
+end

data/lib/tivohmo.rb

@@ -0,0 +1,5 @@
+require 'gem_logger'
+require "tivohmo/version"
+require "tivohmo/api"
+require "tivohmo/server"
+require "tivohmo/beacon"

data/spec/adapters/filesystem/application_spec.rb

@@ -0,0 +1,19 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/filesystem'
+
+describe TivoHMO::Adapters::Filesystem::Application do
+
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      app = described_class.new(File.dirname(__FILE__))
+      expect(app).to be_a described_class
+      expect(app).to be_a TivoHMO::Adapters::Filesystem::FolderContainer
+      expect(app.metadata_class).to eq TivoHMO::Adapters::StreamIO::Metadata
+      expect(app.transcoder_class).to eq TivoHMO::Adapters::StreamIO::Transcoder
+    end
+
+  end
+
+end

data/spec/adapters/filesystem/file_item_spec.rb

@@ -0,0 +1,33 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/filesystem'
+
+describe TivoHMO::Adapters::Filesystem::FileItem do
+
+
+  describe "#initialize" do
+
+    describe "#initialize" do
+
+      it "should fail with non-existant file" do
+        expect{described_class.new("not-here")}.to raise_error(ArgumentError, /existing file/)
+      end
+
+      it "should fail with dir" do
+        expect{described_class.new(File.dirname(__FILE__))}.to raise_error(ArgumentError, /existing file/)
+      end
+
+      it "should instantiate" do
+        file = __FILE__
+        subject = described_class.new(file)
+        expect(subject).to be_a described_class
+        expect(subject.full_path).to eq File.expand_path(file)
+        expect(subject.title).to eq File.basename(file)
+        expect(subject.modified_at).to_not be_nil
+        expect(subject.created_at).to_not be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/adapters/filesystem/folder_container_spec.rb

@@ -0,0 +1,115 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/filesystem'
+
+describe TivoHMO::Adapters::Filesystem::FolderContainer do
+
+  describe "#initialize" do
+
+    it "should fail with non-existant dir" do
+      expect{described_class.new("not-here")}.to raise_error(ArgumentError, /existing directory/)
+    end
+
+    it "should fail with file" do
+      expect{described_class.new(__FILE__)}.to raise_error(ArgumentError, /existing directory/)
+    end
+
+    it "should instantiate" do
+      with_file_tree(foo: [1]) do |dir|
+        subject = described_class.new("#{dir}/foo")
+        expect(subject).to be_a described_class
+        expect(subject.full_path).to eq "#{dir}/foo"
+        expect(subject.title).to eq 'Foo'
+        expect(subject.modified_at).to_not be_nil
+        expect(subject.created_at).to_not be_nil
+        expect(subject.allowed_item_types).to eq %i[file dir]
+        expect(subject.allowed_item_extensions).to eq described_class::VIDEO_EXTENSIONS
+      end
+    end
+
+  end
+
+  describe "#allowed_container?" do
+
+    it "is false when not allowed" do
+      with_file_tree(1, foo: []) do |dir|
+        subject = described_class.new(dir)
+        subject.allowed_item_types = %i[dir]
+        expect(subject.send(:allowed_container?, "#{dir}/foo")).to eq(true)
+        expect(subject.send(:allowed_container?, "#{dir}/1")).to eq(false)
+        expect(subject.send(:allowed_container?, "#{dir}/nothere")).to eq(false)
+        subject.allowed_item_types = %i[]
+        expect(subject.send(:allowed_container?, "#{dir}/foo")).to eq(false)
+      end
+    end
+
+  end
+
+  describe "#allowed_item?" do
+
+    it "is false when not allowed" do
+      with_file_tree('1.avi', '1.bad', foo: []) do |dir|
+        subject = described_class.new(dir)
+        subject.allowed_item_types = %i[file]
+        subject.allowed_item_extensions = %w[avi]
+        expect(subject.send(:allowed_item?, "#{dir}/1.avi")).to eq(true)
+        expect(subject.send(:allowed_item?, "#{dir}/1.bad")).to eq(false)
+        expect(subject.send(:allowed_item?, "#{dir}/foo")).to eq(false)
+        expect(subject.send(:allowed_item?, "#{dir}/nothere")).to eq(false)
+        subject.allowed_item_types = %i[]
+        expect(subject.send(:allowed_item?, "#{dir}/1.avi")).to eq(false)
+      end
+    end
+
+  end
+
+  describe "#children" do
+
+    it "contains filesystem children" do
+      with_file_tree('1.avi', foo: ['2.avi']) do |dir|
+        subject = described_class.new(dir)
+        expect(subject.children.collect(&:title)).to match_array ['1.avi', 'Foo']
+        expect(subject.find('1.avi')).to be_a(TivoHMO::API::Item)
+        expect(subject.find('1.avi')).to be_a(TivoHMO::Adapters::Filesystem::FileItem)
+        expect(subject.find('Foo')).to be_a(TivoHMO::API::Container)
+        expect(subject.find('Foo')).to be_a(TivoHMO::Adapters::Filesystem::FolderContainer)
+      end
+    end
+
+    it "memoizes" do
+      subject = described_class.new(File.dirname(__FILE__))
+      expect(subject.children.object_id).to eq subject.children.object_id
+    end
+
+    it "watches for filesystem addition" do
+      with_file_tree('1.avi', foo: ['2.avi']) do |dir|
+        subject = described_class.new(dir)
+        expect(subject.children.collect(&:title)).to match_array ['1.avi', 'Foo']
+        FileUtils.touch "#{dir}/3.avi"
+        sleep 0.5
+        expect(subject.children.collect(&:title)).to match_array ['3.avi','1.avi', 'Foo']
+      end
+    end
+
+    it "watches for filesystem removal" do
+      with_file_tree('1.avi', foo: ['2.avi']) do |dir|
+        subject = described_class.new(dir)
+        expect(subject.children.collect(&:title)).to match_array ['1.avi', 'Foo']
+        FileUtils.rm "#{dir}/1.avi"
+        sleep 0.5
+        expect(subject.children.collect(&:title)).to match_array ['Foo']
+      end
+    end
+
+    it "doesn't watch children" do
+      with_file_tree('1.avi', foo: ['2.avi']) do |dir|
+        subject = described_class.new(dir)
+        oldid = subject.children.object_id
+        FileUtils.touch "#{dir}/foo/3.avi"
+        sleep 0.5
+        expect(subject.children.object_id).to eq oldid
+      end
+    end
+
+  end
+
+end

data/spec/adapters/plex/application_spec.rb

@@ -0,0 +1,20 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Application do
+
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      app = described_class.new('localhost')
+      expect(app).to be_a described_class
+      expect(app).to be_a TivoHMO::API::Application
+      expect(app).to be_a TivoHMO::API::Container
+      expect(app.metadata_class).to eq TivoHMO::Adapters::Plex::Metadata
+      expect(app.transcoder_class).to eq TivoHMO::Adapters::Plex::Transcoder
+    end
+
+  end
+
+end

data/spec/adapters/plex/category_spec.rb

@@ -0,0 +1,66 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Category do
+
+  let(:plex_delegate) { plex_stub(::Plex::Section) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      category = described_class.new(plex_delegate, :newest)
+      expect(category).to be_a described_class
+      expect(category).to be_a TivoHMO::API::Container
+      expect(category.category_type).to eq(:newest)
+      expect(category.category_value).to be_nil
+      expect(category.title).to eq('Newest')
+      expect(category.identifier).to eq(plex_delegate.key)
+      expect(category.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(category.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+    it "should use_category_value for title if present" do
+      cval = {title: 'MyTitle', key: '/plex/key'}
+      category = described_class.new(plex_delegate, :by_year, cval)
+      expect(category.category_type).to eq(:by_year)
+      expect(category.category_value).to eq(cval)
+      expect(category.title).to eq('MyTitle')
+    end
+
+  end
+
+  describe "#children" do
+
+    it "should memoize" do
+      listing = [plex_stub(::Plex::Movie)]
+      allow(plex_delegate).to receive(:newest).and_return(listing)
+      section = described_class.new(plex_delegate, :newest)
+      expect(section.children.object_id).to eq(section.children.object_id)
+    end
+
+    it "should have children" do
+      listing = [
+          plex_stub(::Plex::Movie),
+          plex_stub(::Plex::Episode),
+          plex_stub(::Plex::Show)
+      ]
+      allow(plex_delegate).to receive(:newest).and_return(listing)
+      section = described_class.new(plex_delegate, :newest)
+      expect(section.children.size).to eq(3)
+    end
+
+    it "should use category_value for children" do
+      listing = [
+          plex_stub(::Plex::Movie),
+          plex_stub(::Plex::Episode),
+          plex_stub(::Plex::Show)
+      ]
+      cval = {title: 'Title', key: 'key'}
+      allow(plex_delegate).to receive(:by_year).with('key').and_return(listing)
+      section = described_class.new(plex_delegate, :by_year, cval)
+      expect(section.children.size).to eq(3)
+    end
+
+  end
+
+end

data/spec/adapters/plex/episode_spec.rb

@@ -0,0 +1,22 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Episode do
+
+  let(:plex_delegate) { plex_stub(::Plex::Episode) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      episode = described_class.new(plex_delegate)
+      expect(episode).to be_a described_class
+      expect(episode).to be_a TivoHMO::API::Item
+      expect(episode.title).to eq(plex_delegate.title)
+      expect(episode.identifier).to eq(plex_delegate.key)
+      expect(episode.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(episode.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+  end
+
+end

data/spec/adapters/plex/metadata_spec.rb

@@ -0,0 +1,24 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Metadata do
+
+  let(:plex_delegate) { plex_stub(::Plex::Movie,
+                                  summary: 'Summary',
+                                  duration: 10000) }
+
+  let(:item) { double('item', delegate: plex_delegate)}
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      md = described_class.new(item)
+      expect(md).to be_a described_class
+      expect(md).to be_a TivoHMO::API::Metadata
+      expect(md.duration).to eq(plex_delegate.duration / 1000)
+      expect(md.description).to eq plex_delegate.summary
+    end
+
+  end
+
+end

data/spec/adapters/plex/movie_spec.rb

@@ -0,0 +1,22 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Movie do
+
+  let(:plex_delegate) { plex_stub(::Plex::Movie) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      movie = described_class.new(plex_delegate)
+      expect(movie).to be_a described_class
+      expect(movie).to be_a TivoHMO::API::Item
+      expect(movie.title).to eq(plex_delegate.title)
+      expect(movie.identifier).to eq(plex_delegate.key)
+      expect(movie.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(movie.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+  end
+
+end

data/spec/adapters/plex/qualified_category_spec.rb

@@ -0,0 +1,51 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::QualifiedCategory do
+
+  let(:plex_delegate) { plex_stub(::Plex::Section) }
+
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      qcat = described_class.new(plex_delegate, :by_year, '2000')
+      expect(qcat).to be_a described_class
+      expect(qcat).to be_a TivoHMO::API::Container
+      expect(qcat.title).to eq("By Year")
+      expect(qcat.category_qualifier).to eq('2000')
+      expect(qcat.title).to eq("By Year")
+      expect(qcat.identifier).to eq(plex_delegate.key)
+      expect(qcat.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(qcat.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+  end
+
+  describe "#children" do
+
+    it "should memoize" do
+      listing = [
+          {title: 'Title1', key: 'key1'}
+      ]
+      allow(plex_delegate).to receive(:years).and_return(listing)
+      section = described_class.new(plex_delegate, :by_year, :years)
+      expect(section.children.object_id).to eq(section.children.object_id)
+    end
+
+    it "should have children" do
+      listing = [
+          {title: 'Title1', key: 'key1'},
+          {title: 'Title2', key: 'key2'}
+      ]
+      allow(plex_delegate).to receive(:years).and_return(listing)
+      section = described_class.new(plex_delegate, :by_year, :years)
+      expect(section.children.size).to eq(2)
+      expect(section.children[0]).to be_instance_of(TivoHMO::Adapters::Plex::Category)
+      expect(section.children[0].category_type).to be(:by_year)
+      expect(section.children[0].category_value).to eq(listing[0])
+    end
+
+  end
+
+end