lib/mythtv/setting.rb @@ -1,3 +1,8 @@ +== 0.3.0 (2009-02-18) + +* Replaced old database code with one based on ActiveRecord, which is now a dependency +* Changed test code + == 0.2.0 (2008-09-29) * Bumped to version 0.2 as we now support proper editing of recording schedules, and speaking multiple versions of the database schema History.txt @@ -3,29 +3,35 @@ require 'rake/gempackagetask' require 'rake/testtask' spec = Gem::Specification.new do |s| - s.name = %q{ruby-mythtv} - s.version = "0.2.0" + s.name = 'ruby-mythtv' + s.version = '0.3.0' 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-07-27} - s.description = %q{Ruby implementation of the MythTV communication protocol} + s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version= + s.date = %q{2009-02-18} + s.description = %q{Ruby implementation of the MythTV communication protocol, and interface to the MythTV database} + s.authors = [ 'Nick Ludlam' ] 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/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.extra_rdoc_files = [ 'History.txt', 'License.txt', 'README.txt', 'Todo.txt' ] + s.files = [ 'History.txt', 'License.txt', 'README.txt', 'Rakefile', 'Todo.txt' ] + Dir["lib/*.rb"] + Dir["lib/mythtv/*.rb"] + Dir["test/*.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.rdoc_options = ['--main', 'README.txt'] + s.require_paths = ['lib'] s.rubyforge_project = %q{ruby-mythtv} - s.rubygems_version = %q{0.2.0} + s.rubygems_version = %q{0.3.0} + + s.add_dependency('mysql') + s.add_dependency('activerecord') + s.add_dependency('composite_primary_keys') + s.summary = %q{Ruby implementation of the MythTV backend protocol} - s.test_files = ["test/test_backend.rb", "test/test_helper.rb"] + s.test_files = Dir["test/*.rb"] end Rake::GemPackageTask.new(spec) do |pkg| + pkg.need_zip = true pkg.need_tar = true end @@ -34,18 +40,22 @@ task :build => "pkg/#{spec.name}-#{spec.version}.gem" do end desc "Run basic unit tests" -Rake::TestTask.new("test_units") do |t| +Rake::TestTask.new("test") do |t| 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| +Rake::TestTask.new('test:db') do |t| t.pattern = ['test/test_db.rb'] t.verbose = true end + +Rake::TestTask.new('test:backend') do |t| + t.pattern = ['test/test_backend.rb'] + t.verbose = true +end + desc "Run unit tests as default" -task :default => :test_units +task :default => :test Rakefile @@ -1,7 +1,7 @@ -- 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 -- Look at how we need to pass the DB instance to each constructor for Channel, Program and RecordingSchedule. Automate the link back to db instance? -- Make use of the ENUMS placed in RecordingSchedule to help with validation of various columns -- Introspect column types in the database, and coerce the values into the correct class. Currently recordid is a string, for instance +== Todo + +* 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 +* Make use of the ENUMS placed in RecordingSchedule to help with validation of various columns Todo.txt @@ -22,6 +22,14 @@ module MythTV :filetransfer_size, :socket + # Create a new instance of the backend connection, yield it into the block, then + # close once the block execution has finished + def self.perform_commands(initialize_options = {}, &block) + connection = self.new(initialize_options) + yield connection + connection.close + end + # Open the socket, make a protocol check, and announce we'd like an interactive # session with the backend server. # @@ -275,7 +283,7 @@ module MythTV # Tell the backend we've finished talking to it for the current session def close send("DONE") - @socket.close unless @socket.nil? + @socket.close end ############################################################################ lib/mythtv/backend.rb @@ -1,27 +1,11 @@ module MythTV - class Channel - # Construct a new instamce by passing in an array of elements, whos length, - # and order are the same as those set out in the columns mapping for Channel - # - def initialize(channel_array, db_instance) - # Find out the attributes this class has from the schema calculations earlier - columns = db_instance.table_columns[self.class] - - self.class.class_eval { attr_accessor(*columns) } - - @columns = columns - - @columns.each_with_index do |col, i| - self.send("#{col}=", channel_array[i]) - end - - @db = db_instance - end - - # Create a to_s method to help with debugging - def to_s; @columns.collect { |v| "#{v}: '#{send(v) || 'nil'}'" }.join(", "); end - + class Channel < ActiveRecord::Base + set_table_name 'channel' + set_primary_key :chanid + + #has_many :recording_schedules, :foreign_key => 'chanid' + has_many :programs, :foreign_key => 'chanid', :class_name => "MythTV::Program" end end \ No newline at end of file lib/mythtv/channel.rb @@ -1,256 +1,63 @@ require 'rubygems' +require 'active_record' +require 'composite_primary_keys' require 'mysql' module MythTV class Database - - attr_accessor :connection # The MySQL connection object - attr_accessor :setting_cache # The Hash which stores previously retrieved settings - attr_accessor :table_columns # The Hash which contains the column info for the tables - - TABLE_TO_CLASS_MAP = { 'channel' => Channel, - 'program' => Program, - 'record' => RecordingSchedule } # Initialise and connect to the MySQL server # # Required keys in options[] are: # - # :database_user => The username to connect to the mysql database as - # :database_password => The password to connect to the mysql database with + # :database_host (or :host) => The target server address or name + # :database_user => The username used to connect to the MythTV MySQL database + # :database_password => The password used to connect to the MythTV MySQL database # # Optional keys: # - # :database_host => Defaults to the same value as the backend host, unless specified # :database_name => Defaults to 'mythconverg' unless specified # :log_output => A Ruby Logger output. Defaults to STDERR # :log_level => A Ruby Logger log level. Defaults to Logger::WARN def initialize(options) - # Initialise the caches for later use - @setting_cache = {} - - default_options = { :database_user => 'mythtv', :database_name => 'mythconverg', :database_host => :host } - - raise ArgumentError, ":database_password must be a key within the options argument Hash" unless options.has_key?(:database_password) + default_options = { :database_user => 'mythtv', + :database_name => 'mythconverg', + :database_host => :host, + :database_port => 3306 } options = default_options.merge(options) @database_host = options[:database_host] == :host ? options[:host] : options[:database_host] @database_name = options[:database_name] @database_user = options[:database_user] + @database_port = options[:database_port] @database_password = options[:database_password] - @connection = Mysql.real_connect(@database_host, @database_user, @database_password, @database_name) - - # Set up a local logging object - @log = MythTV::Utils.setup_logging(options) - - # Query the schema version, and calculate the columns in Channel, Program, and RecordingSchedule - @table_columns = { - Channel => process_dbschemaver(:channel), - Program => process_dbschemaver(:program), - RecordingSchedule => process_dbschemaver(:recording_schedule) + @connection_details = { + :adapter => 'mysql', + :host => @database_host, + :port => @database_port, + :database => @database_name, + :username => @database_user, + :password => @database_password } - end - - # Close the database connection properly - def close() - @connection.close() if @connection - end - - # Fetch the stored setting from the settings database table, for the specified value field - def get_setting(value, hostname = '') - # Construct a unique key. Fetch from cache if present - key = value + "_" + hostname - return @setting_cache[key] if @setting_cache.has_key?(key) - - query = "SELECT data FROM settings WHERE value = ?" - # If we're explicitly given a value for hostname, then make this part of - # the WHERE condition - query += " AND hostname = ?" unless hostname == '' - - st = @connection.prepare(query) - - begin - hostname == '' ? st.execute(value) : st.execute(value, hostname) - # We shouldn't get multiple matches, so check and raise an exception if necessary - raise ArgumentError, ("Too many matches! %d matching rows found for '%s'" % [st.num_rows, value]) if st.num_rows > 1 - - # If we haven't found anything, return now - data = st.num_rows == 0 ? nil : st.fetch[0] - ensure - # Make sure we close the statement object nicely - st.close - end - - # Set in the cache before we return the value - @setting_cache[key] = data - - data - end - - # Return an array of Channel objects, selected by the criteria set out in - # the options hash. - # - def list_channels(options = {}) - default_options = { :order => "chanid ASC" } - - # Merge in our defaults with what we've been given - options = default_options.merge(options) - - st_query = "SELECT " + @table_columns[Channel].collect { |c| c.to_s }.join(",") + " FROM channel" - - (converted_query, st_args) = simple_options_to_sql(options, 'channel') - st_query += converted_query - - @log.debug("CHANNEL QUERY: #{st_query}") - - # Execute the statement, and create the Channel objects from the results - st = @connection.prepare(st_query) - results = st.execute(*st_args) - channels = [] - st.num_rows.times { channels << Channel.new(st.fetch, self) } - - channels - end - - def list_programs(options = {}) - default_options = { :order => "starttime ASC" } - - # Merge in our defaults with what we've been given - options = default_options.merge(options) - - st_query = "SELECT " + @table_columns[Program].collect { |c| c.to_s }.join(",") + " FROM program" - - (converted_query, st_args) = simple_options_to_sql(options, 'program') - st_query += converted_query - @log.debug("PROGRAM QUERY: #{st_query}") + # Establish our connections specifically for the ruby-mythtv module + # TODO: I'm not particularly happy about this, as I'd rather it was done + # on demand, but at the moment it's not clear how you share nicely + # with other ActiveRecord instances talking to other databases + MythTV::Channel.establish_connection(@connection_details) + MythTV::Program.establish_connection(@connection_details) + MythTV::RecordingSchedule.establish_connection(@connection_details) + MythTV::Setting.establish_connection(@connection_details) - # Execute the statement, and create the Channel objects from the results - st = @connection.prepare(st_query) - results = st.execute(*st_args) - programs = [] - st.num_rows.times { programs << Program.new(st.fetch, self) } - - programs - end - - def list_recording_schedules(options = {}) - default_options = { :order => "recordid ASC" } - - # Merge in our defaults with what we've been given - options = default_options.merge(options) - - st_query = "SELECT " + @table_columns[RecordingSchedule].collect { |c| c.to_s }.join(",") + " FROM record" - - (converted_query, st_args) = simple_options_to_sql(options, 'record') - st_query += converted_query - - @log.debug("RECORD QUERY: #{st_query}") - - # Execute the statement, and create the Channel objects from the results - st = @connection.prepare(st_query) - results = st.execute(*st_args) - recording_schedules = [] - st.num_rows.times { recording_schedules << RecordingSchedule.new(st.fetch, self) } - - recording_schedules - end - - private - # We need to work out what schema version the database is, and derive the columns - # present for each of the database tables represented in Channel, Program and RecordingSchedule - def process_dbschemaver(class_name_sym) - # First get the DBSchemaVer of the database we're talking to - schema_version = get_setting('DBSchemaVer').to_i - - #@log.debug("Got schema_version #{schema_version}") - - base_columns_const_name = class_name_sym.to_s.upcase + "_BASE_COLUMNS" - # Duplicate this for schema change processing - table_columns = MythTV.const_get(base_columns_const_name).dup - - #@log.debug("base table_columns are: #{table_columns.inspect}") - - # Find any schema changes for this version of the DBSchemaVer - schema_changes_const_name = class_name_sym.to_s.upcase + "_SCHEMA_CHANGES" - schema_changes = MythTV.const_get(schema_changes_const_name) - - # Process the :push and :remove keys appropriately - if schema_changes.has_key?(schema_version) - @log.debug("Schema mapping found. Applying changes to the column layout") - schema_changes[schema_version].each_pair do |action, columns| - columns.map do |column| - table_columns.send(action, column) - end - end - end - - #@log.debug("Returning column array #{table_columns.inspect}") - table_columns - end - - - # A simple method which allows the presence of a key in the options array which matches - # a column in the table to be turned into a simple equality statement, or IN statement. - # - # If the value class is an array, the resulting statement is of the form "<col> IN (?, ?...)" - # - # In all other cases, the resulting statement is of the form "<co> = ?" - # - # Also allows specification of :conditions, :order and :limit, which emulate their - # ActiveRecord counterparts - def simple_options_to_sql(options, table_name) - where_query = [] # Accumulate statements here, and join with " AND " after - where_args = [] # Accumulate substitution variables here - assembled_query = "" # Final output SQL goes in here - - # Turn the name of the table into a class reference, and find the column defs - table_columns = @table_columns[TABLE_TO_CLASS_MAP[table_name]] - - options.each_pair do |key, value| - if table_columns.include?(key) - # If we have been given a key which corresponds to a column - if value.class == Array - # If it's an array, we substitute in a '?' in the statement for every element - where_query << "#{key} IN (" + (1..value.length).map {'?'}.join(',') + ")" - where_args += value - else - where_query << "#{key} = ?" - where_args << value - end - end - end - - # Custom where clauses are specified with an array, with the first - # element being the statement to pass to prepare(), and the second being - # the arguments for that statement fragment. - # - # ie/ :where => ["starttime BETWEEN ? AND ?", Time.now, Time.now + 3600] - if options.has_key?(:conditions) && options[:conditions].class == Array - where_query << options[:conditions].shift - where_args += options[:conditions] if options[:conditions].length > 0 - end - - # Assemble the fragments around WHERE and AND, if we need to - if where_query.length > 0 - assembled_query += " WHERE #{where_query.join(" AND ")}" - end - - # Allow specification of an ORDER column and direction - if options.has_key?(:order) - assembled_query += " ORDER BY #{options[:order]}" - end + # Set up a local logging object + @log = MythTV::Utils.setup_logging(options) - # Allow limiting of returned results - if options.has_key?(:limit) - assembled_query += " LIMIT #{options[:limit]}" - end - - [assembled_query, where_args] + # Although we don't need to give back an instance, as we now work through + # class methods, we pass back self for the constructor + self end - end end \ No newline at end of file lib/mythtv/database.rb @@ -1,31 +1,13 @@ module MythTV - class Program + class Program < ActiveRecord::Base + set_table_name 'program' + set_primary_keys 'chanid', 'starttime', 'manualid' - def initialize(program_array, db_instance) - # Find out the attributes this class has from the schema calculations earlier - columns = db_instance.table_columns[self.class] - - self.class.class_eval { attr_accessor(*columns) } - - @columns = columns - - @columns.each_with_index do |col, i| - self.send("#{col}=", program_array[i]) - end - - @db = db_instance - end + belongs_to :channel, :foreign_key => 'chanid' - def to_s; @columns.collect { |v| "#{v}: '#{send(v) || 'nil'}'" }.join(", "); end - - def channel - channels = @db.list_channels(:conditions => ['chanid = ?', self.chanid]) - if channels.length == 1 - channels[0] - else - nil - end + def inspect + "#{title} : #{subtitle} [#{category}] on at #{starttime} on channel id #{chanid}" end end lib/mythtv/program.rb @@ -1,7 +1,12 @@ module MythTV - class RecordingSchedule + class RecordingSchedule < ActiveRecord::Base + set_table_name 'record' + set_primary_key 'recordid' + set_inheritance_column nil + belongs_to :channel, :foreign_key => 'chanid', :class_name => "MythTV::Channel" + # Map the 'type' column to a string RS_TYPE_MAP = { 0 => :kNotRecording, 1 => :kSingleRecord, @@ -30,139 +35,84 @@ module MythTV :kDupCheckSubDesc => 0x06, :kDupCheckSubThenDesc => 0x08 } - + # COLUMN_TO_ENUM_MAP = { :type => RS_TYPE_MAP, :dupmethod => RS_DUPIN_MASK, :dupmethod => RS_DUPMETHOD_MASK } - - # Columns which need ENUMS: dupmethod, dupin, type? search? - # Foreign keys: transcoder, storagegroup - def initialize(data_source, db_instance) - @db = db_instance - - # Find out the attributes this class has from the schema calculations earlier - columns = db_instance.table_columns[self.class] + # + def initialize(options = nil) + super() - self.class.class_eval { attr_accessor(*columns) } + default_options = { :type => 6, # Find one of... + :profile => 'Default', + :recpriority => 0, + :autoexpire => MythTV::Setting.data_for_value('AutoExpireDefault'), + :maxepisodes => 0, + :maxnewest => 0, + :startoffset => MythTV::Setting.data_for_value('DefaultStartOffset'), + :endoffset => MythTV::Setting.data_for_value('DefaultEndOffset'), + :recgroup => 'Default', + :dupmethod => 6, # + :dupin => 15, + :search => 0, + :autotranscode => MythTV::Setting.data_for_value('AutoTranscode'), + :autocommflag => MythTV::Setting.data_for_value('AutoCommercialFlag'), + :autouserjob1 => MythTV::Setting.data_for_value('AutoRunUserJob1'), + :autouserjob2 => MythTV::Setting.data_for_value('AutoRunUserJob2'), + :autouserjob3 => MythTV::Setting.data_for_value('AutoRunUserJob3'), + :autouserjob4 => MythTV::Setting.data_for_value('AutoRunUserJob4'), + :findday => 0, + :findtime => 0, + :findid => 0, + :inactive => 0, + :parentid => 0, + :transcoder => MythTV::Setting.data_for_value('DefaultTranscoder'), + :tsdefault => 1, + :playgroup => 'Default', + :prefinput => 0, + :next_record => Time.at(0), + :last_record => Time.at(0), + :last_delete => Time.at(0), + :storagegroup => 'Default', + :avg_delay => 0 } - @columns = columns + # TODO: The logic here isn't very clean. More DRY needed! - if data_source.class == Array - # If we're given an array, it's from the database, so construct via DATABASE_COLUMNS - @db.table_columns[RecordingSchedule].each_with_index do |col, i| - send("#{col}=", data_source[i]) - end - elsif data_source.class == Program - # If we're initialising from a Program, invoke our new_from_program() method - new_from_program(data_source) + # We can be passed a Hash, or an instance of Program. In the Hash case, we + # merge the specified options in with the defaults before assignment happens + if options.is_a?(MythTV::Program) || options.nil? + program = options + merged_options = default_options + elsif options.class == Hash + program = nil + merged_options = default_options.merge(options) end - end - - # This method - def new_from_program(program) - defaults = { :recordid => nil, - :type => 1, # Single recording - :profile => "Default", - :recpriority => 0, - :autoexpire => @db.get_setting('AutoExpireDefault'), - :maxepisodes => 0, - :maxnewest => 0, - :startoffset => @db.get_setting('DefaultStartOffset'), - :endoffset => @db.get_setting('DefaultEndOffset'), - :recgroup => "Default", - :dupmethod => 6, # - :dupin => 15, - :search => 0, - :autotranscode => @db.get_setting('AutoTranscode'), - :autocommflag => @db.get_setting('AutoTranscode'), - :autouserjob1 => @db.get_setting('AutoRunUserJob1'), - :autouserjob2 => @db.get_setting('AutoRunUserJob2'), - :autouserjob3 => @db.get_setting('AutoRunUserJob3'), - :autouserjob4 => @db.get_setting('AutoRunUserJob4'), - :findday => 0, - :findtime => 0, - :findid => 0, - :inactive => 0, - :parentid => 0, - :transcoder => @db.get_setting('DefaultTranscoder'), - :tsdefault => 1, - :playgroup => 'Default', - :prefinput => 0, - :next_record => 0, - :last_record => 0, - :last_delete => 0, - :storagegroup => 'Default', - :avg_delay => 0 } - - self.chanid = program.chanid - self.starttime = program.starttime - self.startdate = program.starttime - self.endtime = program.endtime - self.enddate = program.endtime - self.title = program.title - self.subtitle = program.subtitle - self.description = program.description - self.category = program.category - self.seriesid = program.seriesid - self.programid = program.programid - - defaults.each_pair do |k,v| - self.send("#{k}=", v) + # Assign the options to self + merged_options.each_pair do |k, v| + self.send("#{k.to_s}=", v) end - # Station assignment from the channel object. Needs caching - channels = @db.list_channels(:chanid => self.chanid) - self.station = channels[0].name if channels.length == 1 - end - - def save - query = "REPLACE INTO record (" + @columns.collect { |c| c.to_s }.join(",") + ")" - query += " VALUES (" + (1..@columns.length).map {'?'}.join(',') + ")" + # If we've been passed a Program, we do some work to set up things up accordingly + if program + self.chanid = program.chanid + self.starttime = program.starttime + self.startdate = program.starttime + self.endtime = program.endtime + self.enddate = program.endtime + self.title = program.title + self.subtitle = program.subtitle + self.description = program.description + self.category = program.category + self.seriesid = program.seriesid + self.programid = program.programid - puts query - - st = @db.connection.prepare(query) - st_args = @columns.collect { |c| send(c) } - result = st.execute(*st_args) - - if result.affected_rows() == 1 - # Set the recordid from the replace - @recordid = result.insert_id().to_s - return true - else - return false - end - end - - # Re-select all the data from the database via the primary key, recordid - def reload - st_query = "SELECT " + @db.table_columns[self.class].collect { |c| c.to_s }.join(",") + " FROM record" - st_query += " WHERE recordid = ?" - - st = @db.connection.prepare(st_query) - results = st.execute(@recordid) - - @db.table_columns[self.class].each_with_index do |col, i| - send("#{col}=", result[i]) + # Station assignment from the channel object. Needs caching? + channel = MythTV::Channel.find(self.chanid).name end - end - - # Remove the row from the database - def destroy - # We should have a valid recordid before we continue - return false if recordid.to_i < 1 - - st_query = "DELETE FROM record WHERE recordid = ?" - st = @db.connection.prepare(st_query) - result = st.execute(@recordid) - result.affected_rows() == 1 end - - # Enable more pleasant debugging through a to_s method - def to_s; @columns.collect { |v| "#{v}: '#{send(v) || 'nil'}'" }.join(", "); end - + end end lib/mythtv/recording_schedule.rb @@ -45,4 +45,13 @@ module MythTV end end # end Utils -end # end MythTV \ No newline at end of file +end # end MythTV + +# Workaround for a dependency within ActiveRecord on ActiveSupport multibyte strings +# TODO: Will this be necessary going forward? +module ActiveSupport + module Multibyte + class Chars + end + end +end \ No newline at end of file lib/mythtv/utils.rb @@ -21,7 +21,7 @@ # THE SOFTWARE. module MythTV - VERSION = '0.2.0' + VERSION = '0.3.0' def self.connect(options) backend = connect_backend(options) @@ -42,11 +42,12 @@ end $:.unshift(File.dirname(__FILE__)) +require 'mythtv/backend.rb' +require 'mythtv/database.rb' require 'mythtv/channel.rb' require 'mythtv/program.rb' require 'mythtv/protocol.rb' require 'mythtv/recording.rb' require 'mythtv/recording_schedule.rb' +require 'mythtv/setting.rb' require 'mythtv/utils.rb' -require 'mythtv/database.rb' -require 'mythtv/backend.rb' lib/ruby-mythtv.rb @@ -1,28 +1,27 @@ -Gem::Specification.new do |s| +spec = Gem::Specification.new do |s| s.name = 'ruby-mythtv' - s.version = '0.2.0' + s.version = '0.3.0' 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.date = %q{2008-09-29} - s.description = %q{Ruby implementation of the MythTV communication protocol} + s.date = %q{2009-02-18} + s.description = %q{Ruby implementation of the MythTV communication protocol, and interface to the MythTV database} s.authors = [ 'Nick Ludlam' ] 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', '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' ] + s.extra_rdoc_files = [ 'History.txt', 'License.txt', 'README.txt', 'Todo.txt' ] + s.files = [ 'History.txt', 'License.txt', 'README.txt', 'Rakefile', 'Todo.txt' ] + Dir["lib/*.rb"] + Dir["lib/mythtv/*.rb"] + Dir["test/*.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.2.0} + s.rubygems_version = %q{0.3.0} + s.add_dependency('mysql') + s.add_dependency('activerecord') + s.add_dependency('composite_primary_keys') + s.summary = %q{Ruby implementation of the MythTV backend protocol} - s.test_files = [ 'test/test_helper.rb', 'test/test_backend.rb', 'test/test_db.rb' ] -end + s.test_files = Dir["test/*.rb"] +end \ No newline at end of file ruby-mythtv.gemspec @@ -2,8 +2,8 @@ require File.dirname(__FILE__) + '/test_helper.rb' class TestBackend < Test::Unit::TestCase def setup - 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']) + abort("\n\tERROR: You must set the environment variable MYTHTV_HOST to the name of your MythTV backend server\n\n") unless ENV['MYTHTV_HOST'] + @backend = MythTV.connect_backend(:host => ENV['MYTHTV_HOST']) end def teardown @@ -45,6 +45,20 @@ class TestBackend < Test::Unit::TestCase assert_equal test_image_sig, png_sig end + # In this test, we ignore the @backend instance connection which was created by setup() + # and perform our own block of commands on a new connection + def test_perform_commands + MythTV::Backend.perform_commands(:host => ENV['MYTHTV_HOST']) do |connection| + # Check the query_uptime method and query_memstats methods + uptime = connection.query_uptime + assert uptime > 0 + + memstats = connection.query_memstats + assert_equal Hash, memstats.class + assert_equal 4, memstats.keys.length + end + end + # def test_process_guide_xml # guide_data = @backend.get_program_guide # test/test_backend.rb @@ -2,103 +2,90 @@ 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'] - abort("\n\tmyERROR: You must set the environment variable MYTHTV_PW to the name of your MythTV database server\n\n") unless ENV['MYTHTV_PW'] - @db = MythTV.connect_database(:host => ENV['MYTHTV_DB'], - :database_password => ENV['MYTHTV_PW'], - :log_level => Logger::DEBUG) + abort("\n\tERROR: You must set the environment variable MYTHTV_HOST to the name of your MythTV database server\n\n") unless ENV['MYTHTV_HOST'] + abort("\n\tERROR: You must set the environment variable MYTHTV_PW to your MySQL MythTV password\n\n") unless ENV['MYTHTV_PW'] + + conn_opts = Hash.new(:log_level => Logger::DEBUG) + conn_opts[:host] = ENV['MYTHTV_HOST'] if ENV.has_key?('MYTHTV_HOST') + conn_opts[:database_user] = ENV['MYTHTV_USER'] if ENV.has_key?('MYTHTV_USER') + conn_opts[:database_password] = ENV['MYTHTV_PW'] if ENV.has_key?('MYTHTV_PW') + + @db = MythTV::Database.new(conn_opts) end def teardown - @db.close + #@db.disconnect 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') + schema_version = MythTV::Setting.data_for_value('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 + channels = MythTV::Channel.find(:all) - assert_kind_of Array, channels + assert_kind_of Array, channels assert channels.length > 0 - assert_kind_of MythTV::Channel, channels[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 + channel_list = MythTV::Channel.find(:all) + wanted_chanid = channel_list[0].chanid - second_channel_list = @db.list_channels(:chanid => wanted_chanid) - assert_equal 1, second_channel_list.length + channel = MythTV::Channel.find_by_chanid(wanted_chanid) - 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) + programs = MythTV::Program.find(:all, :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 + programs = MythTV::Program.find(:all, :conditions => ['title like ?', '%'], :limit => 5) + assert_equal 5, programs.length 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) + # Programs in the next two hours. Assume database is up to date + programs = MythTV::Program.find(:all, :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 + programs = MythTV::Program.find(:all, :limit => 1) + assert_kind_of MythTV::Channel, programs[0].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) + num_schedules = MythTV::RecordingSchedule.count + program = MythTV::Program.find(:first, :conditions => ['starttime BETWEEN ? AND ?', Time.now, Time.now + 7200], + :limit => 1) + + # Check we have one at all + assert program # Convert our first program selected into a recording schedule - new_schedule = MythTV::RecordingSchedule.new(programs[0], @db) + new_schedule = MythTV::RecordingSchedule.new(program) new_schedule.save # Get new list - new_num_schedules = @db.list_recording_schedules + new_num_schedules = MythTV::RecordingSchedule.count # Assert that we now have one more schedule - assert_equal num_schedules.length + 1, new_num_schedules.length + assert_equal num_schedules + 1, new_num_schedules assert new_schedule.recordid.to_i > 0 @@ -108,18 +95,22 @@ class TestDatabase < Test::Unit::TestCase def test_new_and_modify_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) + num_schedules = MythTV::RecordingSchedule.count + program = MythTV::Program.find(:first, :conditions => ['starttime BETWEEN ? AND ?', Time.now, Time.now + 7200], + :limit => 1) - # Convert our first program selected into a recording schedule - new_schedule = MythTV::RecordingSchedule.new(programs[0], @db) + # Check we have one at all + assert program + + # Convert our first program selected into a recording schedule, and save it + new_schedule = MythTV::RecordingSchedule.new(program) new_schedule.save new_schedule.type = 4 new_schedule.save - test_query = @db.list_recording_schedules(:conditions => ['recordid = ?', new_schedule.recordid]) + # We should find this now with new query + test_query = MythTV::RecordingSchedule.find(:all, :conditions => ['recordid = ?', new_schedule.recordid]) assert_equal 1, test_query.length test_retrieval = test_query[0] test/test_db.rb @@ -12,23 +12,13 @@ class StreamFileHandler < Mongrel::HttpHandler def process(request, response) pp "request.params => #{request.params['REQUEST_PATH']}" - response.write("HTTP/1.1 200 OK\r\n") - #response.write("Cache-Control: no-cache\r\n") - #response.write("Pragma: no-cache\r\n") - #response.write("ETag: \"7531dc-102f000-44dda50e16281\"\r\n") response.write("Accept-Ranges: bytes\r\n") response.write("Content-Length: 999999999\r\n") response.write("Keep-Alive: timeout=5, max=100\r\n") response.write("Connection: Keep-Alive\r\n") response.write("Content-type: video/mpeg\r\n\r\n") - # response.status = 200 - # response.send_status(nil) - # response.header['Content-Type'] = "video/mpeg" - # response.header['Connection'] = "Close" - # response.send_header - buffer="" total_bytes_read = 0 test/test_stream.rb 13783515b1e302e1bdedb1b08a08655c27885911 Nick Ludlam nick@Dusk.config http://github.com/nickludlam/ruby-mythtv/commit/d42bde0bc2e75bf8466462b88989692a8d3e5cbc d42bde0bc2e75bf8466462b88989692a8d3e5cbc 2009-02-18T09:49:33-08:00 2009-02-18T09:43:33-08:00 Deleted gemspec file ae43f8c88a8c6750ea6540f3e64920841fc4352e Nick Ludlam nick@Dusk.config