nickludlam-ruby-mythtv 0.1.0 → 0.1.2

data/History.txt

@@ -1,3 +1,10 @@
+== 0.1.1 (2008-07-27)
+
+* Updated documentation
+* Added initial multiple protocol version support via protocol.rb
+* Implemented MythTV::Backend#get_program_guide() to wrap "/Myth/GetProgramGuide" from the Mythbackend Status port
+* Created a Utils class to hold miscellaneous methods. The utils.rb file also holds the exception classes
+
 == 0.1.0 (2008-06-08)
 
 * Initial release onto GitHub/Rubyforge

data/README.txt

@@ -28,13 +28,21 @@ and can be cloned from
   require 'ruby-mythtv'
   
   # Connect to the server
-  backend = MythTV::Backend.new(:host => 'mythtv.localdomain')
+  mythbackend, mythdb = MythTV.connect(:host => 'mythtv.localdomain')
   
   # Get an array of recordings
-  recordings = backend.query_recordings
+  recordings = mythbackend.query_recordings
+  
+  # Download a recording
+  mythbackend.download(recordings[0])
+  
+  # Stream a recording into a block
+  mythbackend.stream(recordings[0], :transfer_blocksize => 65535) do |chunk|
+    ..do something with the 64k chunk..
+  end
   
   # Generate a thumbnail of the most recent recording, at 60 seconds in from the start
-  preview_thumbnail = @backend.preview_image(recordings[0], :secs_in => 60)
+  preview_thumbnail = mythbackend.preview_image(recordings[0], :secs_in => 60)
   File.open('preview_thumbnail.png', 'w') { |f| f.write(preview_thumbnail) }
 
 == Author

data/Rakefile

@@ -5,23 +5,23 @@ require 'rake/testtask'
 
 spec = Gem::Specification.new do |s|
   s.name = %q{ruby-mythtv}
-  s.version = "0.1.0"
+  s.version = "0.1.2"
  
   s.specification_version = 2 if s.respond_to? :specification_version=
  
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nick Ludlam"]
-  s.date = %q{2008-06-08}
+  s.date = %q{2008-07-27}
   s.description = %q{Ruby implementation of the MythTV communication protocol}
   s.email = %q{nick@recoil.org}
   s.extra_rdoc_files = ["History.txt", "License.txt", "README.txt"]
-  s.files = ["History.txt", "License.txt", "README.txt", "Rakefile", "lib/ruby-mythtv.rb", "lib/mythtv/backend.rb", "lib/mythtv/recording.rb", "test/test_backend.rb", "test/test_helper.rb"]
+  s.files = ["History.txt", "License.txt", "README.txt", "Rakefile", "lib/ruby-mythtv.rb", "lib/mythtv/backend.rb", "lib/mythtv/channel.rb", "lib/mythtv/database.rb", "lib/mythtv/program.rb", "lib/mythtv/protocol.rb", "lib/mythtv/recording.rb", "lib/mythtv/recording_schedule.rb", "lib/mythtv/utils.rb", "test/test_backend.rb", "test/test_db.rb", "test/test_helper.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/nickludlam/ruby-mythtv/}
   s.rdoc_options = ["--main", "README.txt"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{ruby-mythtv}
-  s.rubygems_version = %q{0.1.0}
+  s.rubygems_version = %q{0.1.2}
   s.summary = %q{Ruby implementation of the MythTV backend protocol}
   s.test_files = ["test/test_backend.rb", "test/test_helper.rb"]
 end
@@ -36,10 +36,17 @@ end
 
 desc "Run basic unit tests"
 Rake::TestTask.new("test_units") do |t|
-  t.pattern = 'test/test_*.rb'
+  t.pattern = ENV["TESTFILES"] || ['test/test_backend.rb', 'test/test_db.rb']
   t.verbose = true
   t.warning = true
 end
 
+task :test => :test_units
+
+Rake::TestTask.new('test_db') do |t|
+  t.pattern = ['test/test_db.rb']
+  t.verbose = true
+end
+  
 desc "Run unit tests as default"
-task :default => :test_units
+task :default => :test_units

data/Todo.txt

@@ -0,0 +1,5 @@
+- Implement the Recorder class, and associated functions (see existing MythTV Python module)
+- Look at how we obtain the channel icon by streaming a backend file (see existing MythTV Perl module)
+- Support Ruby 1.9
+- Support seeking with the MythTV::Backend#stream() method
+- Work out method to remove and add database columns for Channel/Program/RecordingSchedule, as we do for the PROTOCOL mapping system. It seems the database can change without the Protocol version being bumped, so they are independent.

data/lib/ruby-mythtv.rb

@@ -20,12 +20,33 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-module MythTV;
-  VERSION = '0.1.0'
+module MythTV
+  VERSION = '0.1.2'
+  
+  def self.connect(options)
+    backend = connect_backend(options)
+    database = connect_database(options)
+    
+    [backend, database]
+  end
+  
+  def self.connect_backend(options)
+    Backend.new(options)
+  end
+  
+  def self.connect_database(options)
+    Database.new(options)
+  end
+  
 end
 
 $:.unshift(File.dirname(__FILE__))
 
-require 'mythtv/backend.rb'
+require 'mythtv/channel.rb'
+require 'mythtv/program.rb'
+require 'mythtv/protocol.rb'
 require 'mythtv/recording.rb'
-
+require 'mythtv/recording_schedule.rb'
+require 'mythtv/utils.rb'
+require 'mythtv/database.rb'
+require 'mythtv/backend.rb'

data/test/test_backend.rb

@@ -2,9 +2,8 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 
 class TestBackend < Test::Unit::TestCase
   def setup
-    abort("\nERROR: You must set the environment variable MYTHTV_BACKEND to the name of your MythTV backend server\n\n") unless ENV['MYTHTV_BACKEND']
-    host = ENV['MYTHTV_BACKEND']
-    @backend = MythTV::Backend.new(:host => host)
+    abort("\n\tERROR: You must set the environment variable MYTHTV_BACKEND to the name of your MythTV backend server\n\n") unless ENV['MYTHTV_BACKEND']
+    @backend = MythTV.connect_backend(:host => ENV['MYTHTV_BACKEND'])
   end
   
   def teardown
@@ -46,6 +45,12 @@ class TestBackend < Test::Unit::TestCase
     assert_equal test_image_sig, png_sig
   end
   
+  # def test_process_guide_xml
+  #   guide_data = @backend.get_program_guide
+  #   
+  #   channels = MythTV::Backend.process_guide_xml(guide_data)
+  # end
+  
   # Don't run this by default as it takes a while. Possibly limit to 100kB?
   #def test_download
   #  recordings = @backend.query_recordings

data/test/test_db.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestDatabase < Test::Unit::TestCase
+  def setup
+    abort("\n\tmyERROR: You must set the environment variable MYTHTV_DB to the name of your MythTV database server\n\n") unless ENV['MYTHTV_DB']
+    @db = MythTV.connect_database(:host => ENV['MYTHTV_DB'],
+                                  :database_user => 'mythtv',
+                                  :database_password => '4c6UUCJp',
+                                  :log_level => Logger::WARN)
+  end
+  
+  def teardown
+    @db.close
+  end
+  
+  # Check the DBSchemaVer key in the settings table as our first check
+  # It should always be present
+  def test_get_setting
+    schema_version = @db.get_setting('DBSchemaVer')
+    assert schema_version.to_i > 0
+  end
+
+  # Check the DBSchemaVer, once queried, is in the setting cache
+  def test_get_setting_cache
+    schema_version = @db.get_setting('DBSchemaVer')
+    assert @db.setting_cache['DBSchemaVer_'].to_i > 0
+  end
+
+  def test_list_channels
+    channels = @db.list_channels
+    
+    assert_kind_of Array, channels 
+    assert channels.length > 0
+    assert_kind_of MythTV::Channel, channels[0] 
+    assert channels[0].chanid > 0
+  end
+  
+  # Test we can pull back a single channel when
+  # specifying a :chanid
+  def test_list_single_chanid
+    first_channel_list = @db.list_channels
+    wanted_chanid = first_channel_list[0].chanid
+
+    second_channel_list = @db.list_channels(:chanid => wanted_chanid)
+    assert_equal 1, second_channel_list.length
+
+    channel = second_channel_list[0]
+    assert_kind_of MythTV::Channel, channel
+    assert_equal channel.chanid, wanted_chanid
+  end
+  
+  def test_list_multiple_chanids
+    first_channel_list = @db.list_channels
+    first_five = first_channel_list.slice(0..4)
+    wanted_chanids = first_five.map { |x| x.chanid }
+
+    second_channel_list = @db.list_channels(:chanid => wanted_chanids)
+    assert_equal 5, second_channel_list.length
+    second_channel_list
+  end
+  
+  def test_list_programs
+    programs = @db.list_programs(:limit => 10)
+    
+    assert_equal 10, programs.length
+  end
+  
+  def test_list_programs_with_search
+    programs = @db.list_programs(:conditions => ['title LIKE ?', "%"],
+                                 :limit => 5)
+    assert programs.length > 0
+  end
+  
+  def test_list_programs_with_starttime_range
+    # Programs in the next two hours
+    programs = @db.list_programs(:conditions => ['starttime BETWEEN ? AND ?', Time.now, Time.now + 7200],
+                                 :limit => 1)
+    
+    assert_equal 1, programs.length
+  end
+  
+  def test_program_links_to_channel
+    programs = @db.list_programs(:conditions => ['title LIKE ?', "%"], :limit => 1)
+    program_channel = programs[0].channel
+    assert_kind_of MythTV::Channel, program_channel
+  end
+
+  def test_new_schedule
+    # Get list of schedules for later reference
+    num_schedules = @db.list_recording_schedules
+    programs = @db.list_programs(:conditions => ['starttime BETWEEN ? AND ?', Time.now + 3600, Time.now + 7200],
+                                 :limit => 1)
+    
+    # Convert our first program selected into a recording schedule
+    new_schedule = MythTV::RecordingSchedule.new(programs[0], @db)
+    new_schedule.save
+    
+    # Get new list
+    new_num_schedules = @db.list_recording_schedules
+    # Assert that we now have one more schedule
+    assert_equal num_schedules.length + 1, new_num_schedules.length
+    
+    assert new_schedule.recordid > 0
+    
+    assert new_schedule.destroy()
+  end
+  
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nickludlam-ruby-mythtv
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Nick Ludlam
@@ -9,10 +9,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-08 00:00:00 -07:00
+date: 2008-09-24 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: Ruby implementation of the MythTV communication protocol
 email: nick@recoil.org
 executables: []
@@ -29,10 +37,19 @@ files:
 - README.txt
 - Rakefile
 - lib/ruby-mythtv.rb
-- lib/mythtv/backend.rb
-- lib/mythtv/recording.rb
+- mythtv/backend.rb
+- mythtv/channel.rb
+- mythtv/database.rb
+- mythtv/program.rb
+- mythtv/protocol.rb
+- mythtv/recording.rb
+- mythtv/recording_schedule.rb
+- mythtv/utils.rb
 - test/test_backend.rb
+- test/test_db.rb
 - test/test_helper.rb
+- test_stream.rb
+- Todo.txt
 has_rdoc: true
 homepage: http://github.com/nickludlam/ruby-mythtv/
 post_install_message: 
@@ -56,10 +73,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ruby-mythtv
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Ruby implementation of the MythTV backend protocol
 test_files: 
-- test/test_backend.rb
 - test/test_helper.rb
+- test/test_backend.rb
+- test/test_db.rb

data/lib/mythtv/backend.rb

@@ -1,416 +0,0 @@
-require 'socket'
-require 'uri'
-require 'net/http'
-
-module MythTV
-
-  # Raised when we get a response that isn't what we expect
-  class CommunicationError < RuntimeError
-  end
-  
-  # Raised when we have a protocol version mismatch
-  class ProcolError < RuntimeError
-  end
-  
-  # Raised when a method is passed incomplete initialisation information
-  class ArgumentError < RuntimeError
-  end
-  
-  class Backend
-    include Socket::Constants
-  
-    # Our current protocol implementation. TODO: Consider how we support
-    # multiple protocol versions within a single gem. In theory this is
-    # just a case of limiting the number of attr_accessors that are
-    # class_eval'd onto MythTV::Recording, and bumping the number below
-    MYTHTV_PROTO_VERSION = 40
-    
-    # The currently defined field separator in responses
-    FIELD_SEPARATOR = "[]:[]"
-    
-    # The payload size we request from the backend when performing a filetransfer
-    TRANSFER_BLOCKSIZE = 65535
-
-    attr_reader :host,
-                :port,
-                :status_port,
-                :connection_type,
-                :filetransfer_port,
-                :filetransfer_size,
-                :socket
-
-    # Open the socket, make a protocol check, and announce we'd like an interactive
-    # session with the backend server
-    def initialize(options = {})
-      default_options = { :port => 6543, :status_port => 6544, :connection_type => :playback }
-      options = default_options.merge(options)
-      
-      raise ArgumentError, "You must specify a :host key and value to initialize()" unless options.has_key?(:host)
-      
-      @host = options[:host]
-      @port = options[:port]
-      @status_port = options[:status_port]
-
-      @socket = TCPSocket.new(@host, @port)
-      
-      check_proto
-      
-      if options[:connection_type] == :playback
-        announce_playback()
-      elsif options[:connection_type] == :filetransfer
-        announce_filetransfer(options[:filename])
-      else
-        raise ArgumentError, "Unknown connection type '#{options[:connection_type]}'"
-      end
-    end
-
-    ############################################################################
-    # COMMAND WRAPPERS #########################################################
-
-    # Tell the backend we speak a specific version of the protocol. Raise
-    # an error if the backend does not accept that version.
-    def check_proto
-      send("MYTH_PROTO_VERSION #{MYTHTV_PROTO_VERSION}")
-      response = recv
-      unless response[0] == "ACCEPT" && response[1] == MYTHTV_PROTO_VERSION.to_s
-        close
-        raise ProcolError, response.join(": ")
-      end
-    end
-
-    # Announce ourselves as a Playback connection.
-    # http://www.mythtv.org/wiki/index.php/Myth_Protocol_Command_ANN for details
-    def announce_playback
-      client_hostname = Socket.gethostname
-      
-      # We don't want to receive broadcast events for this connection
-      want_events = "0"
-      
-      send("ANN Playback #{client_hostname} #{want_events}")
-      response = recv
-
-      unless response[0] == "OK"
-        close
-        raise CommunicationError, response.join(": ")
-      else
-        @connection_type = :playback  # Not currently used, but may be in later versions
-      end
-    end
-
-    # Announce ourselves as a FileTransfer connection.
-    # http://www.mythtv.org/wiki/index.php/Myth_Protocol_Command_ANN for details
-    def announce_filetransfer(filename = nil)
-      raise ArgumentError, "you must specify a filename" if filename.nil?
-      
-      client_hostname = Socket.gethostname
-  
-      filename = "/" + filename if filename[0] != "/"  # Ensure leading slash
-  
-      send("ANN FileTransfer #{client_hostname}#{FIELD_SEPARATOR}#{filename}")
-      response = recv
-  
-      # Should get back something like:
-      #   OK[]:[]<socket number>[]:[]<file size high 32 bits>[]:[]<file size low 32 bits>
-      unless response[0] == "OK"
-        close
-        raise CommunicationError, response.join(": ")
-      else
-        @filetransfer_port = response[1]
-        @filetransfer_size = [response[3].to_i, response[2].to_i].pack("ll").unpack("Q")[0]
-        @connection_type = :filetransfer   # Not currently used, but may be in later versions
-      end
-    end
-
-    # Simple method to query the load of the backend server. Returns a hash with keys for
-    # :one_minute, :five_minute and :fifteen_minute
-    def query_load
-      send("QUERY_LOAD")
-      response = recv
-      { :one_minute => response[0].to_f, :five_minute => response[1].to_f, :fifteen_minute => response[2].to_f }
-    end
-
-    # List all recordings stored on the backend. You can filter via the storagegroup property,
-    # and this defaults to /Default/, to list the recordings, rather than any which are from
-    # LiveTV sessions.
-    # 
-    # Returns an array of MythTV::Recording objects
-    def query_recordings(options = {})
-      default_options = { :filter => { :storagegroup => /Default/ } }
-      options = default_options.merge(options)
-      
-      send("QUERY_RECORDINGS Play")
-      response = recv
-
-      recording_count = response.shift.to_i
-      recordings = []
-
-      while recording_count > 0
-        recording_array = response.slice!(0, Recording::RECORDINGS_ELEMENTS.length)
-
-        recording = Recording.new(recording_array)
-
-        options[:filter].each_pair do |k, v|
-          recordings.push(recording) if recording.send(k) =~ v
-        end
-        
-        recording_count -= 1
-      end
-
-      recordings = recordings.sort_by { |r| r.startts }
-      recordings.reverse!
-    end
-    
-    # This method will return the next free recorder that the backend has available to it
-    # TODO: Fix up the checking of response. Does it return an IP or address in element 1?
-    def get_next_free_recorder
-      send("GET_NEXT_FREE_RECORDER#{FIELD_SEPARATOR}-1")
-      response = recv
-
-      # If we have a recorder free, return the recorder id, otherwise false
-      response[0] == "-1" ? false : response[0].to_i
-    end
-    
-    # This will trigger the backend to start recording Live TV from a certain channel.
-    # TODO: This is currently buggy, so avoid until it's fixed in a later release
-    def spawn_live_tv(recorder_id, start_channel = 1)
-      client_hostname = Socket.gethostname
-      spawn_time = Time.now.strftime("%y-%m-%dT%H:%M:%S")
-      chain_id = "livetv-#{client_hostname}-#{spawn_time}"
-      
-      query_recorder(recorder_id, "SPAWN_LIVETV", [chain_id, 0, "#{start_channel}"])
-      response = recv
-      
-      # If we have an "OK" back, then return the chain_id, otherwise return false
-      response[0] == "OK" ? chain_id : false
-    end
-    
-    # This method returns an array of recording objects which describe which programmes
-    # are to be recorded as far as the current EPG data extends
-    def query_scheduled
-      send("QUERY_GETALLSCHEDULED")
-      response = recv
-      
-      recording_count = response.shift.to_i
-      recordings = []
-
-      while recording_count > 0
-        recording_array = response.slice!(0, Recording::RECORDINGS_ELEMENTS.length)
-        recordings << Recording.new(recording_array)
-        recording_count -= 1
-      end
-
-      recordings = recordings.sort_by { |r| r.startts }
-      recordings.reverse!
-    end
-
-    # Wrap the QUERY_MEMSTATS backend command. Returns a hash with keys for
-    # :used_memory, :free_memory, :total_swap and :free_swap
-    def query_memstats
-      send("QUERY_MEMSTATS")
-      response = recv
-      
-      # We expect to get back 4 elements only for this method
-      raise CommunicationError, "Unexpected response from QUERY_MEMSTATS: #{response.join(":")}" if response.length != 4
-
-      { :used_memory => response[0].to_i, :free_memory => response[1].to_i, :total_swap => response[2].to_i, :free_swap => response[3].to_i }
-    end
-
-    # Wrap the QUERY_UPTIME backend command. Return a single integer
-    def query_uptime
-      send("QUERY_UPTIME")
-      response = recv
-
-      # We expect to get back 1 element only for this method
-      raise CommunicationError, "Unexpected response from QUERY_UPTIME: #{response.join(":")}" if response.length != 1
-
-      response[0].to_i
-    end
-
-    # This is used when transfering files from the backend. It requests that the next block of data
-    # be sent to the socket, ready for us to recieve
-    def query_filetransfer_transfer_block(sock_num, size)
-      query = "QUERY_FILETRANSFER #{sock_num}#{FIELD_SEPARATOR}REQUEST_BLOCK#{FIELD_SEPARATOR}#{size}"
-      send(query)
-    end
-    
-    # Tell the backend we've finished talking to it for the current session
-    def close
-      send("DONE")
-      @socket.close unless @socket.nil?
-    end
-    
-    ############################################################################
-    # STATUS PORT METHODS
-    
-    # Returns a string which contains a PNG image of the this recording. The time offset
-    # into the file defaults to two minutes, and the default image width is 120 pixels.
-    # This uses the separate status port, rather than talking over the backend control port
-    def preview_image(recording, options = {})
-      default_options = { :height => 120, :secs_in => 120 }
-      options = default_options.merge(options)
-    
-      # Generate our query string for the MythTV request
-      query_string = "ChanId=#{recording.chanid}&StartTime=#{recording.myth_delimited_recstart}"
-
-      # Add in the optional parameters if they were specified
-      query_string += "&SecsIn=#{options[:secs_in]}" if options[:secs_in]
-      query_string += "&Height=#{options[:height]}" if options[:height]
-      query_string += "&Width=#{options[:width]}" if options[:width]
-    
-      url = URI::HTTP.build( { :host  => @host,
-                               :port  => @status_port,
-                               :path  => "/Myth/GetPreviewImage",
-                               :query => query_string } )
-      
-      # Make a GET request, and store the image data returned
-      image_data = Net::HTTP.get(url)
-
-      image_data
-    end
-    
-    ############################################################################
-    # FILETRANSFER RELATED METHODS
-
-    # Yield into the given block with the data buffer of size TRANSFER_BLOCKSIZE
-    def stream(recording, options = {}, &block)
-    
-      # Initialise a new connection of connection_type => :filetransfer
-      data_conn = Backend.new(:host => @host,
-                              :port => @port,
-                              :status_port => @status_port,
-                              :connection_type => :filetransfer,
-                              :filename => recording.path)
-
-      ft_port = data_conn.filetransfer_port
-      ft_size = data_conn.filetransfer_size
-    
-      blocksize = options.has_key?(:transfer_blocksize) ? options[:transfer_blocksize] : TRANSFER_BLOCKSIZE
-
-      total_transfered = 0
-
-      begin
-        # While we still have data to fetch
-        while total_transfered < ft_size
-          # Make a request for the backend to send data
-          query_filetransfer_transfer_block(ft_port, blocksize)
-
-          # Collect the socket data in a string
-          buffer = ""
-       
-          while buffer.length < blocksize
-            buffer += data_conn.socket.recv(blocksize)
-            # Special case for when the remainer to fetch is less than TRANSFER_BLOCKSIZE
-            break if total_transfered + buffer.length == ft_size
-          end
-
-          # Yield into the given block to allow the user to process as a stream
-          yield buffer
-       
-          total_transfered += buffer.length
-       
-          # If the user has only asked for a certain amount of data, stop when we hit this
-          break if options[:max_length] && total_transfered > options[:max_length]
-        end
-      ensure
-        # We need to close the data connection regardless of what is going on when we yield
-        data_conn.close
-      end
-      
-    end
-    
-    # Download the file to a given location, either with a default filename, or
-    # one specified by the caller
-    def download(recording, filename = nil)
-      
-      # If no filename is given, we default to <title>_<recstartts>.<extension>
-      if filename.nil?
-        filename = recording.title + "_" +
-                   recording.myth_nondelimited_recstart + File.extname(recording.filename) 
-      end
-
-      File.open(filename, "wb") do |f|
-        stream(recording) { |data| f.write(data) }
-      end
-    end
-    
-    # TODO: The LiveTV methods are still work-in-progress.
-    def start_livetv(channel = 1)
-      # If we have a free recorder...
-      if recorder_id = get_next_free_recorder
-        puts "Got a recorder ID of #{recorder_id}"
-        # If we can spawn live tv...
-        if chain_id = spawn_live_tv(recorder_id, channel)
-          puts "Got a chain ID of #{chain_id}"
-          # Send the two backend event messages
-          backend_message(["RECORDING_LIST_CHANGE", "empty"])
-          puts "Sent RECORDING_LIST_CHANGE"
-          backend_message(["LIVETV_CHAIN UPDATE #{chain_id}", "empty"])
-          puts "Sent LIVETV_CHAIN UPDATE"
-          
-          # Find the filename from here...
-          query_recorder(recorder_id, "GET_CURRENT_RECORDING")
-          cur_rec = recv
-          puts "Current recording is:"
-          puts cur_rec.inspect
-          recording = Recording.new(cur_rec)
-        else
-          puts "spawn_live_tv returned with false or nil"
-          return false
-        end
-      else
-        puts "get_next_free_recorder returned with false or nil"
-        return false
-      end
-    end
-
-    # TODO: Finish this off. Check response?
-    def stop_livetv(recorder_id)
-      query_recorder(recorder_id, "STOP_LIVETV")
-      response = recv
-    end
-    
-    private
-    
-    # Private method for the generic QUERY_RECORDER command, which itself
-    # wraps a number of sub-commands. 
-    def query_recorder(recorder_id, sub_command, options = [])
-      # place the recorder_id and sub_command strings on the front of options
-      # and join with the FIELD_SEPARATOR. This forms the QUERY_RECORDER command
-      cmd_string = options.unshift(recorder_id, sub_command)
-      send("QUERY_RECORDER #{options.join(FIELD_SEPARATOR)}")
-    end
-
-    # Wraps the BACKEND_MESSAGE command, which just sends events to the
-    # backend, with no responses provided. Only events expected are
-    # RECORDING_LIST_CHANGE, and LIVETV CHAIN_UPDATE
-    def backend_message(event_message = [])
-      event_message.unshift("BACKEND_MESSAGE")
-      send(message.join(FIELD_SEPARATOR))
-    end
-    
-    # Send a message to the MythTV Backend
-    def send(message)
-      length = sprintf("%-8d", message.length)
-      @socket.write("#{length}#{message}")
-    end
-    
-    # Fetch a reply from the MythTV Backend. Automatically splits around the
-    # FIELD_SEPARATOR
-    def recv
-      count = @socket.recv(8).to_i
-
-      # Where we accumulate the response
-      response = ""
-
-      # Keep fetching data until we have received the entire response
-      while (count > 0) do
-        buf = @socket.recv(TRANSFER_BLOCKSIZE)
-        response += buf
-        count -= buf.length
-      end
-
-      response.split(FIELD_SEPARATOR)
-    end
-    
-  end # end Backend
-end # end MythTV

data/lib/mythtv/recording.rb

@@ -1,67 +0,0 @@
-module MythTV
-
-  class Recording
-    # Represents a recording that is held on the MythTV Backend server we are communicating with.
-    #
-    # The keys included here, and the order in which they are specified seem to change between protocol version bumps
-    # on the MythTV backend, so this array affects both the initialize() and to_s() methods.
-    #
-    # Found inside mythtv/libs/libmythtv/programinfo.cpp in the MythTV subversion repository
-    RECORDINGS_ELEMENTS = [ :title, :subtitle, :description, :category, :chanid, :chanstr, :chansign, :channame,
-                            :pathname, :filesize_hi, :filesize_lo, :startts, :endts, :duplicate, :shareable, :findid,
-                            :hostname, :sourceid, :cardid, :inputid, :recpriority, :recstatus, :recordid, :rectype,
-                            :dupin, :dupmethod, :recstartts, :recendts, :repeat, :programflags, :recgroup, :chancommfree,
-                            :chanOutputFilters, :seriesid, :programid, :lastmodified, :stars, :originalAirDate,
-                            :hasAirDate, :playgroup, :recpriority2, :parentid, :storagegroup, :audioproperties,
-                            :videoproperties, :subtitleType ]
-    
-    # Warning, metaprogramming ahead: Create attr_accessors for each symbol defined in MythTVRecording::RECORDINGS_ELEMENTS
-    def initialize(recording_array)
-      class << self;self;end.class_eval { RECORDINGS_ELEMENTS.each { |field| attr_accessor field } }
-      
-      RECORDINGS_ELEMENTS.each_with_index do |field, i|
-        send(field.to_s + '=', recording_array[i])
-      end
-    end
-  
-    # A string representation of a Recording is used when we converse with the MythTV Backend about that recording
-    def to_s
-      RECORDINGS_ELEMENTS.collect { |field| self.send(field.to_s) }.join(MythTV::Backend::FIELD_SEPARATOR) + MythTV::Backend::FIELD_SEPARATOR
-    end
-    
-    # Convenience methods to access the start and end times as Time objects, and duration as an Float
-    def start;  Time.at(recstartts.to_i); end
-    def end;  Time.at(recendts.to_i); end
-    def duration; self.end - self.start; end
-  
-    # Cribbed from the Mythweb PHP code. Required for some method calls to the backend
-    def myth_delimited_recstart;  myth_format_time(recstartts, :delimited); end
-  
-    # Formats the start time for use in the copy process, as the latter half of the filename is a non-delimited time string
-    def myth_nondelimited_recstart; myth_format_time(recstartts, :nondelimited);  end
-    
-    # Convert the lo/hi long representation of the filesize into a string
-    def filesize
-      [filesize_lo.to_i, filesize_hi.to_i].pack("ll").unpack("Q").to_s
-    end
-    
-    # Fetch the path section of the pathname
-    def path;  URI.parse(pathname).path; end
-    
-    # Strip the filename out from the path returned by the server
-    def filename;  File.basename(URI.parse(pathname).path); end
-  
-    private
-  
-    def myth_format_time(timestamp, format = :nondelimited)
-      timestamp = timestamp.to_i if timestamp.class != Bignum
-      case format
-      when :nondelimited
-        Time.at(timestamp).strftime("%Y%m%d%H%M%S")
-      when :delimited
-        Time.at(timestamp).strftime("%Y-%m-%dT%H:%M:%S")
-      end
-    end
-      
-  end # end Recording
-end # end MythTV