jeeves-pvr 0.2.0

data/lib/jeeves/scheduler/base.rb

@@ -0,0 +1,209 @@
+#
+#
+# = Scheduler
+#
+# == Base class
+#
+# Author:: Robert Sharp
+# Copyright:: Copyright (c) 2011 Robert Sharp
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file copyright.txt. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+#
+# A base class for the Jeeves Tuner and Scheduler
+#
+# This class needs to be inherited to create specific subclasses for different tuners
+#
+
+require 'jerbil/jerbil_service/base'
+require 'jerbil/jerbil_service/support'
+require 'jerbil/support'
+
+require 'jeeves/config'
+require 'jeeves/errors'
+
+require 'open3'
+
+#
+# == Jeeves Service
+#
+# Synopsis of the whole service
+#
+module Jscheduler
+
+  # add generic class methods
+  extend JerbilService::Support
+  
+  # inherit the Jeeves config file
+  class Config < Jeeves::Config; end  
+
+  # === Jeeves Service class
+  #
+  # Description of how the service class works
+  #
+  class Base < JerbilService::Base
+
+    # Document the constructor as required.
+    #
+    # pkey:: string - private key that must be used for
+    #        supervision calls (e.g. stop_callback)
+    # options:: hash of options, preferably as created by Jeckyl. See documentation
+    #           on JerbilService::Base for assumed options re logging etc
+    #
+    # Note that this method should be super'd before any local initialization
+    #
+    def initialize(pkey, options)
+      
+      @tuner = options[:tuner]
+      @device = '/dev/video0' # set this to the device from which the tuner streams
+
+      # do things that cannot be done when $SAFE > 0
+
+      # the symbol should be the app name and must correspond to a service in /etc/services
+      super(:jschedule, pkey, options)
+
+      # DRb is now working, this process may have daemonized and $SAFE = 1
+      
+      # the current priority, an integer where the higher the number the higher the priority
+      @priority = 0
+      
+      # save the pid for the tuner process if there is one
+      @tuner_pid = nil
+      
+      @logger.verbose("Started scheduler for tuner #{@tuner}")
+
+    end
+
+    #
+    # define additional class methods to make things happen
+    #
+    
+    # tune_receiver is needed for each receiver to prepare that receiver for
+    # a given channel.
+    # 
+    # calls init_receiver to prepare the receiver itself
+    # and then sets a timer to protect the tuner
+    def tune_receiver(priority, params={})
+      
+      # do not tune anything if there is a higher priority tune in progress
+      raise Jeeves::TunerBusy if @priority > 0 && priority <= @priority
+      
+      # do the specific stuff for the given tuner and get back its pid (or not if there
+      # is not process involved)
+      self.stop_tuner(@tuner_pid) unless @tuner_pid.nil?
+      
+      @tuner_pid = self.init_tuner(params)
+      
+      if params[:duration] then
+        # need to do this for a given time
+        @priority = priority
+        @thread = Thread.new do
+          # use Jeckyl to ensure this is sensible!
+          sleep(params[:duration])
+          # now clear up
+          @priority = 0
+          self.stop_tuner(@tuner_pid)
+        end
+      else
+        # no duration, so tune indefinitely
+        # BUT what if there is a priority? Ignore it!
+        @priority = 0
+      end
+      #raise NotImplementedError
+      # needs to do what ever the tuner requires to tune to the given channel
+      # For Drb tuners this may involve a process running continuously, which
+      # can be ended either after a certain time or when another call is made
+      # to tune the receiver.
+      
+      # params include:
+      #
+      # * an identity for the channel as required by the tuner
+      # * a priority - to allow recordings to overide casual viewing, for example
+      # * a duration that enforces the priority and may also hold the tuner on.
+    end
+    
+    # this will record the current receiver settings to a given file. It needs
+    # to know the device from which to record and will then use FFMPEG to do
+    # the recording
+    def record(filename)
+      
+    end
+    
+    # play the current tuned channel on the primary X display
+    def play
+      
+    end
+    
+    # stream the current tuned channel over the net using netcat
+    def stream
+      
+    end
+    
+    # this will create an at job to record a programme at some time in the future
+    def schedule(params={})
+      [:filename, :channel, :start, :duration].each do |param|
+        raise Jeeves::MissingParam, "Schedule method must specify #{param}" unless params.has_key?(param)
+      end
+      mode = params[:mode] || :avi
+      raise InvalidMode, "Tuner #{@tuner} does not have mode: #{mode}" unless Schedulers[@tuner].has_key?(mode)
+      scheduler = Schedulers[@tuner][mode]
+      
+      startParam = params[:start].strftime("%H:%M %b %d")
+		
+			command = "#{scheduler} #{params[:channel]} #{params[:duration]} #{params[:filename]}"
+      
+      @logger.debug "About to schedule: #{command}"
+			
+      # need open3 to get the full communication with at
+			inpipe, outpipe, errpipe = Open3.popen3("/usr/bin/at #{startParam}")
+			inpipe.puts command
+			inpipe.close
+			response = errpipe.readlines
+      outpipe.close
+      errpipe.close
+
+      # get the job id and return it to the caller
+      jobnum = nil
+      job_re = /job (\d+) at/
+      response.each do |resp|
+        @logger.debug "Response includes: " + resp
+        if results = job_re.match(resp) then
+          @logger.debug "Recognised Job: " + results[1]
+          jobnum = results[1].clone
+        end
+      end
+      
+      @logger.info "Scheduled recording on #{params[:channel]} at #{startParam} for #{params[:duration]} with job no: #{jobnum}"
+      # set a wol timer here
+      
+			return jobnum
+		rescue Jeeves::JeevesError
+      raise
+    rescue
+      @logger.exception($!)
+      return '0'
+		end
+
+    
+    # deletes the at job with the given job number
+    # assume that the given jobnum is valid
+    def delete_schedule(jobnum)
+      begin
+        @logger.info "Removing job: #{jobnum}"
+        system("/usr/bin/atrm #{jobnum.to_s}")
+      rescue
+        @logger.exception($!)
+      end
+    end
+
+    # do not redefine the superclass methods unless you are absolutely sure you know
+    # what you are doing.
+    
+    protected
+    
+
+  end
+end

data/lib/jeeves/scheduler/old_base.rb

@@ -0,0 +1,148 @@
+#
+#
+# = Jeeves Scheduler
+#
+# == Schedule Jeeves related tasks from recordings to shutdowns and wakeups
+#
+# Author:: Robert Sharp
+# Copyright:: Copyright (c) 2011 Robert Sharp
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file copyright.txt. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+#
+# This scheduler will schedule at jobs and use wolly to schedule wakeups. It is a Jerbil
+# service.
+#
+
+require 'jerbil/jerbil_service/base'
+require 'jerbil/jerbil_service/support'
+require 'jerbil/support'
+
+require 'jeeves/config'
+require 'jeeves/errors'
+
+require 'open3'
+
+#
+# == Jeeves Service
+#
+# Synopsis of the whole service
+#
+module Jscheduler
+
+  # add generic class methods
+  extend JerbilService::Support
+  
+  # inherit the Jeeves config file
+  class Config < Jeeves::Config; end  
+
+  # === Jeeves Service class
+  #
+  # Description of how the service class works
+  #
+  class Service < JerbilService::Base
+
+    # Document the constructor as required.
+    #
+    # pkey:: string - private key that must be used for
+    #        supervision calls (e.g. stop_callback)
+    # options:: hash of options, preferably as created by Jeckyl. See documentation
+    #           on JerbilService::Base for assumed options re logging etc
+    #
+    def initialize(pkey, options)
+      
+      @tuner = options[:tuner]
+      raise InvalidTuner("Tuner is not recognized: #{@tuner}") unless Schedulers.has_key?(@tuner)
+
+      # do things that cannot be done when $SAFE > 0
+
+      # the symbol should be the app name and must correspond to a service in /etc/services
+      super(:jschedule, pkey, options)
+
+      # DRb is now working, this process may have daemonized and $SAFE = 1
+      
+      @logger.verbose("Started scheduler for tuner #{@tuner}")
+
+    end
+
+    #
+    # define additional class methods to make things happen
+    #
+    
+    def schedule(params={})
+      [:filename, :channel, :start, :duration].each do |param|
+        raise Jeeves::MissingParam, "Schedule method must specify #{param}" unless params.has_key?(param)
+      end
+      mode = params[:mode] || :avi
+      raise InvalidMode, "Tuner #{@tuner} does not have mode: #{mode}" unless Schedulers[@tuner].has_key?(mode)
+      scheduler = Schedulers[@tuner][mode]
+      
+      startParam = params[:start].strftime("%H:%M %b %d")
+		
+			command = "#{scheduler} #{params[:channel]} #{params[:duration]} #{params[:filename]}"
+      
+      @logger.debug "About to schedule: #{command}"
+			
+      # need open3 to get the full communication with at
+			inpipe, outpipe, errpipe = Open3.popen3("/usr/bin/at #{startParam}")
+			inpipe.puts command
+			inpipe.close
+			response = errpipe.readlines
+      outpipe.close
+      errpipe.close
+
+      # get the job id and return it to the caller
+      jobnum = nil
+      job_re = /job (\d+) at/
+      response.each do |resp|
+        @logger.debug "Response includes: " + resp
+        if results = job_re.match(resp) then
+          @logger.debug "Recognised Job: " + results[1]
+          jobnum = results[1].clone
+        end
+      end
+      
+      @logger.info "Scheduled recording on #{params[:channel]} at #{startParam} for #{params[:duration]} with job no: #{jobnum}"
+      # set a wol timer here
+      
+			return jobnum
+		rescue Jeeves::JeevesError
+      raise
+    rescue
+      @logger.exception($!)
+      return '0'
+		end
+
+    
+    # deletes the at job with the given job number
+    # assume that the given jobnum is valid
+    def delete_schedule(jobnum)
+      begin
+        @logger.info "Removing job: #{jobnum}"
+        system("/usr/bin/atrm #{jobnum.to_s}")
+      rescue
+        @logger.exception($!)
+      end
+    end
+
+    # do not redefine the superclass methods unless you are absolutely sure you know
+    # what you are doing.
+    
+    protected
+    
+    Schedulers = {
+      :dvb=>{
+        :avi=>'/usr/local/bin/virea-dvb-record.sh', 
+        :ts=>'/usr/local/bin/virea-dvb-record-ts.sh'
+      },
+      :pvr=>{
+        :avi=>'/usr/local/bin/virea-pvr-record.sh',
+        :ts=>'/usr/local/bin/virea-pvr-record-ts.sh'
+      }
+    }
+
+  end
+end

data/lib/jeeves/store.rb

@@ -0,0 +1,544 @@
+#
+# Author:: R.J.Sharp
+# Email:: robert(a)osburn-sharp.ath.cx
+# Copyright:: Copyright (c) 2013 
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file LICENCE. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+#
+# 
+
+require 'jerbil/jerbil_service/support'
+
+
+require 'jellog'
+
+require 'yaml'
+require 'open-uri'
+require 'digest'
+
+require 'jeeves/partition'
+require 'jeeves/errors'
+require 'jeeves/version'
+require 'jeeves/utils'
+
+
+module Jeeves
+
+  # Check if this is really needed...
+  #extend JerbilService::Support
+
+  # === Jeeves Store class
+  #
+  # Store manages the allocation of video files for use by Jeeves. Multiple
+  # locations can be added to a store and Jestore distributes the video files
+  # across these in proportion to their size. Files are pre-allocated when a
+  # recording is scheduled and then released when the recording completes.
+  # Store also notifies Jeeves when a video is released.
+  #
+  # NOTE: Store assumes it has all of the space on a given partition. For example,
+  # if you define two stores that are actually on the same partition then Store
+  # will report twice the space that is actually available! Probably needs fixing to
+  # detect duplicate partitions at some point.
+  #
+  # Store is not an active daemon but just an interface. It uses file locking to
+  # avoid any conflicts with multiple versions running across the network.
+  #
+  class Store
+    
+    # create an interface to Store.
+    #
+    # creates lookup tables but does not fill them at this stage
+    #
+    # @param [Jeckyl::Config] options hash as defined in {Jeeves:Config}
+    def initialize(logger, options)
+
+      # do things that cannot be done when $SAFE > 0
+      
+      @store_params = options[:add_partition]
+      @store_errors = options[:store_errors]
+      @partitions = Array.new
+      @logger = logger
+      @file_list_path = nil
+      # lookup of device to free space
+      @space_lup = Hash.new
+      # lookup of path to device
+      @dev_lup = Hash.new
+      
+      check_partitions
+      
+      @base_rate = options[:base_data_rate]
+      @jeeves_url = options[:jeeves_url]
+      
+      # hash of allocated files to space allocated
+      @file_list = Hash.new
+      
+      # file basenames and date to check if files have already been
+      # allocated
+      @file_lup = Hash.new
+      
+      if @file_list_path.nil? then
+      end
+      
+      
+      
+
+      # ??
+      @alloc_lup = Hash.new
+      @total_space = 0
+      @total_alloc = 0
+      
+      options[:unsafe] = true
+      
+      
+      # set up my own logger
+      
+      
+      @logger.debug "Added stores: #{@partitions.inspect}"      
+
+    end
+    
+    # return the free space (as a human readable string) in the system, or
+    # on the partition for the given path.
+    #
+    # @param [String] path to the
+    def free_space(path='')
+      
+      get_and_lock_file_list do
+        update_space
+        fspace = 0
+        if path.empty? then
+          fspace = @total_space - @total_alloc
+        else
+          dev, space = free_space(path)
+          fspace = space - @alloc_lup[dev]
+        end
+        return Jeeves.human_size(fspace)
+      end
+      
+    end
+    
+    
+    # allocate space for a video file with the given name, start time and duration
+    #
+    # use scale to adjust the default data rate if a tuner produces more or less.
+    # If the file is already allocated then do not allocate it again.
+    # Note that where a file already exists with the same name (for some reason?)
+    # a random key will be added, but the original name is remembered in case
+    # it is later used again.
+    #
+    # @param [String] name of the file, which should be a basename only
+    # @param [Integer] duration of the proposed recording in seconds
+    # @param [Time] for_when to allocate the space
+    def allocate(name, duration, for_when, scale=1.0)
+      space = 0
+      path = ''
+      dev = ''
+      
+      get_and_lock_file_list do
+        
+        # check if there is already a file for this programme
+        if @file_lup.has_key?(name) && @file_lup[name][:date] == for_when then
+          # we already have it so don't allocate again
+          @logger.info "File is already allocated: #{name} for #{for_when.strftime('%d-%b-%y %H:%M')}"
+          path = @file_lup[name][:path]
+          break
+        end
+          
+        update_space # work out what space there is
+        
+        # how much do we need
+        space = (duration * @base_rate * scale).to_i
+        
+        # get the best drive for it
+        path = get_path(name, space)
+        
+        #path = File.join(@partitions.first.path, name)
+        
+        # does it already exist?
+        if file_exists_or_is_allocated?(path) then
+          # yes - so rename it
+          path = Jeeves.rename(path) {|f| file_exists_or_is_allocated?(f)}
+        
+        end
+        # save it to the list
+        @file_list[path] = {:space=>space, :date=>for_when + duration}
+        @file_lup[name] = {:date=>for_when, :path=>path}
+        @total_alloc += space
+        
+        @logger.info "Allocating #{space} kbytes for #{path} on #{dev}"
+          
+      end
+      
+      return path
+    end
+    
+    
+    # release allocated space, either because the file has been created
+    # or is no longer required
+    #
+    # @param [String] path to the file to be released
+    def release(path)
+      @logger.verbose "Attempting to release #{path}"
+      deleted = false
+      # open the list file to lock it for the duration
+      get_and_lock_file_list do
+        
+        if @file_list.has_key?(path) then
+          # remove the space from the record of allocated space
+          @total_alloc -= @file_list[path][:space]
+          @file_list.delete(path)
+          @file_lup.delete(File.basename(path))
+          @logger.info "Deleted: #{path} from file_list"
+          deleted = true
+        else
+          @logger.verbose "Did not find #{path} to release"
+        end
+
+      end # auto closes the file
+      return deleted
+    end
+    
+    def release_and_notify(path)
+      
+      unless self.release(path)
+        # the file was never allocated? what
+        # to do now?
+        @logger.verbose "Trying to notify for a file that was not allocated: #{path}"
+      end
+      
+      data = ''
+      @logger.info "Notifying Jeeves for #{path}"
+      open("#{@jeeves_url}/videos/new_from_file.txt?path=#{path}") do |resp|
+        resp.each_line do |line|
+          data << line
+        end
+      end
+      @logger.verbose "Jeeves returned #{data}"
+      
+      return data == '0'
+        
+    end
+    
+    # return block for each allocated file with the path and a hash
+    # containing :space (in Kbytes) and :date when recording expected
+    def each_file(&block)
+      get_and_lock_file_list do
+        @file_list.each_pair do |key, value|
+          block.call(key, value)
+        end
+      end
+    end
+    
+    # return true if there are no entries allocated
+    def empty?
+      empty = true
+      get_and_lock_file_list do
+        empty = @file_list.empty?
+      end
+      return empty
+    end
+    
+    # return the number of entries in the file list
+    def files
+      len = 0
+      get_and_lock_file_list do
+        len = @file_list.length
+      end
+      return len
+    end
+    
+    # return the number of stale files
+    #
+    # stale files are old and have no real file on the system
+    #
+    def stale_files
+      len = 0
+      get_and_lock_file_list do
+        @file_list.each_pair do |path, params|
+          len += 1 if params[:date] < Time.now
+        end
+      end
+      return len
+    end
+    
+    # clear all allocated files etc. Should only do this if you are certain there
+    # are no outstanding recordings etc
+    def clean(all=false)
+      get_and_lock_file_list do
+        if all then
+          @file_list = Hash.new
+        else
+          @file_list.each_pair do |path, params|
+            if params[:date] < Time.now then
+              # already passed so lets clear it
+              @file_list.delete(path)
+              @file_list.delete(File.basename(path))
+            end
+          end
+        end # if all
+      end # lock flie list
+    end
+
+    
+    
+    # check that the specified partitions exist etc and add them to the store
+    #
+    # internal method called during initialization to set up the store. 
+    # Checks that the partitions specified are properly mounted and ready
+    # (that the keys given match the partition), and then removes
+    # any duplicates that are on the same disk partition.
+    #
+    # It also looks for the file_list on each partition and if it finds it
+    # then it uses it and sets the partition as the master (has priority when
+    # removing duplicates). If there are two or more file_lists found then
+    # the most recent one is used. If there are none then one is created
+    # on the largest partition.
+    #
+    def check_partitions
+
+      @store_params.each_pair do |path, options|
+        begin
+          part = Jeeves::Partition.new(path, options)
+          if part.mounted? then
+            # path is OK, check it has been initialised with the given key
+            if part.ready? then
+              # it has, does it have a file_
+
+              @logger.info "Added #{path} to Jeeves Store"
+              @partitions << part
+              
+            else
+              raise Jeeves::InvalidPartitionKey, "#{part.path} does not have a valid key"
+            end
+          else
+            raise Jeeves::InvalidPartition, "#{part.path} does not exist or is not mounted"
+          end
+        rescue Jeeves::InvalidPartition, Jeeves::InvalidPartitionKey => err
+          msg = "Jeeves Error with partition: #{err}"
+          case @store_errors
+          when :ignore
+            @logger.system msg
+          when :warn
+            @logger.warn msg
+          when :fatal
+            @logger.fatal msg + ", Aborting"
+            raise
+          end 
+        end # begin block
+      end # do loop
+      
+      if @partitions.length == 0 then
+        raise Jeeves::StoreError, "There are no partitions available"
+      else
+        @logger.verbose "There are #{@partitions.length} partitions specified"
+      end
+      
+      # find the best file list!
+      master = nil
+      @partitions.each do |part|
+        if part.file_list? then
+          if master.nil? then
+            # no master yet so set this one to be it
+            master = part
+          else
+            # master exists but ignore it if its not the newest
+            master = part unless master.file_list_date > part.file_list_date
+          end
+        end
+      end
+      
+      if master.nil?
+        @logger.verbose "No master partition found"
+      else
+        @logger.verbose "Master Partition set to #{master.path}"
+      end
+      
+      # remove duplicates, giving precedence to the one with the most recent
+      # file list (master)
+      devices = Hash.new
+      @partitions.each do |part|
+        if devices.has_key?(part.device) then
+          # got one already
+          if part == master then
+            # but this one is better
+            old_part = devices[part.device]
+            devices[part.device] = part
+            @logger.verbose "Duplicate partition replaced: #{old_part.path}"
+          else
+            # duplicate, so ignore it
+            @logger.verbose "Duplicate partition: #{part.path}"
+          end
+        else
+          # not already there so save it...
+          devices[part.device] = part
+          @logger.verbose "Keeping unique partition #{part.path} on #{part.device}"
+        end
+      end # do
+      
+      @partitions = devices.values
+      
+      update_space
+      
+      if master.nil? then
+        # did not find a partition with a file list so create one
+        # the first partition should be the largest
+        # not found a filelist, so create one
+        @logger.debug "No file list found"
+        @file_list_path = @partitions.first.file_list
+        save_file_list
+        @logger.debug "Created file list at #{@file_list_path}"
+      else
+        @file_list_path = master.file_list
+      end
+      
+      @logger.info "Using file list: #{@file_list_path}"
+      
+    end
+    
+    def each_partition
+      @partitions.each do |part|
+        yield part
+      end
+    end
+    
+    private
+    # wrapper around the file locking business
+    def get_and_lock_file_list(&block)
+      File.open(@file_list_path, 'r+') do |flist|
+        flist.flock(File::LOCK_EX)
+        begin
+          saved_data = YAML.load(flist)
+          unless saved_data[:version_major] == Jeeves::Version.split('.').first
+            raise VersionError, "Saved data is incompatible with current version"
+          end
+          load_saved_data(saved_data)
+          
+          # do whatever
+          yield
+      
+          # empty the file before re-writing it
+          flist.truncate(0)
+          flist.rewind 
+          YAML::dump(save_data, flist)
+        ensure
+          flist.flock(File::LOCK_UN)
+        end 
+      end # auto closes the file
+      
+    end
+    
+    # update the free space records
+    def update_space
+      @total_space = 0
+      # get actual free space from df
+      @partitions.each do |part|
+        part.update_space # in case it has been a while?
+        #dev, space = free_space(store)
+        @logger.debug "Updating space for store #{part.path}: #{part.free_space}"
+        @dev_lup[part.path] = part.device
+        @space_lup[part.device] = part.free_space
+        @total_space += part.free_space
+      end
+      # now deduct stuff that has been allocated
+      if @file_list then
+        @file_list.each_pair do |key, value|
+          @logger.debug "Deducting allocated file: #{key}, #{value}"
+          # dev = @dev_lup[File.dirname(key)]
+          # @space_lup[dev] -= value
+        end
+      end
+      # now sort the partitions by free space
+      @partitions.sort! {|x,y| x.free_space <=> y.free_space}
+      
+    end
+    
+    # return the free space in 1K blocks on the given path
+    # def free_space(path)
+    #   # use df to get the free space for path
+    #   df_lines = `/bin/df -Pk #{path}`.split("\n")
+    #   @logger.debug "df yeilds: " + df_lines.inspect
+    #   df_fields = df_lines[1].split
+    #   return [df_fields[0], df_fields[3].to_i]
+    # end
+    # 
+    
+    # @file_list contains a list of file data for requests made but 
+    # where files have not yet been created. Need to save
+    # this information to disk to retain over restarts
+    #
+    # load a saved file list if there was one
+    def load_file_list
+      if FileTest.exists?(@file_list_path) then
+        @file_list = File.open(@file_list_path) {|yf| YAML.load(yf)}
+      end
+      
+      # update allocated space
+      @total_alloc = 0
+      @file_list.each do |file, space|
+        #dev, dev_space = free_space(File.dirname(file))
+        @total_alloc += space
+      end
+      
+    end
+    
+    # load the saved data into instance variables
+    def load_saved_data(saved_data)
+      @file_list = saved_data[:file_list] || Hash.new
+      @file_lup = saved_data[:file_lup] || Hash.new
+    end
+    
+    def save_data
+      saved_data = Hash.new
+      saved_data[:version_major] = Jeeves::Version.split('.').first
+      saved_data[:file_list] = @file_list || Hash.new
+      saved_data[:file_lup] = @file_lup || Hash.new
+      @logger.debug "Saving #{saved_data.inspect}"
+      return saved_data
+    end
+    
+    # save the file list
+    def save_file_list
+      File.open(@file_list_path, 'w') do |yf|
+        yf.flock(File::LOCK_EX)
+        begin
+          YAML::dump(save_data, yf)
+        ensure
+          yf.flock(File::LOCK_UN)
+        end 
+      end
+    end
+    
+    # find the best place to put the file
+    def get_path(name, space)
+      best_dev = @space_lup.sort {|a,b| b[1] <=> a[1]}.first[0]
+      @logger.debug "#{best_dev} has the most space left"
+      path = @dev_lup.key(best_dev)
+      return File.join(path, name)
+    end
+    
+    def file_exists_or_is_allocated?(path)
+      File.exists?(path) || @file_list.has_key?(path)
+    end
+    
+    def rename(path)
+      dir_name = File.dirname(path)
+      extname = File.extname(path)
+      basename = File.basename(path, extname)
+      
+      while file_exists?(path)
+        # oh dear, got one already. need to add something to the name
+        randname = (rand * 10000).to_i.to_s
+        basename = basename + '_' + randname + extname
+        path = File.join(dir_name, basename)
+      end
+      
+      return path
+      
+    end
+
+  end
+end