odisk 0.2.0

data/lib/odisk/crypter.rb

@@ -0,0 +1,40 @@
+
+module ODisk
+  class Crypter < ::Opee::Actor
+
+    def initialize(options={})
+      super(options)
+      @crypt_queue.ask(:ready, self)
+    end
+    
+    def set_options(options)
+      super(options)
+      @crypt_queue = options[:crypt_queue]
+      @copy_queue = options[:copy_queue]
+      @fixer = options[:fixer]
+    end
+
+    private
+
+    def encrypt(src, dest, remote)
+      ::Opee::Env.info("encrypt \"#{src}\" into \"#{dest}\"")
+      unless $dry_run
+        `gpg -c --batch --yes --force-mdc --passphrase-file "#{$remote.pass_file}" -o "#{dest}" "#{src}"`
+        @copy_queue.add_method(:upload, dest, remote, true)
+      end
+      @crypt_queue.ask(:ready, self)
+    end
+
+    def decrypt(src, dest)
+      ::Opee::Env.info("decrypt \"#{src}\" into \"#{dest}\"")
+      unless $dry_run
+        `gpg -d --batch --yes -q --passphrase-file "#{$remote.pass_file}" -o "#{dest}" "#{src}"`
+        ::File.delete(src)
+        ::Opee::Env.warn("Downloaded and decrypted \"#{dest}\"")
+      end
+      @fixer.ask(:collect, dest, :crypter) unless @fixer.nil?
+      @crypt_queue.ask(:ready, self)
+    end
+
+  end # Crypter
+end # ODisk

data/lib/odisk/diff.rb

@@ -0,0 +1,81 @@
+
+module ODisk
+  class Diff
+    # local Info Object
+    attr_accessor :local
+    # remote Info Object
+    attr_accessor :remote
+
+    attr_accessor :sub_diffs
+
+    def self.dir_diff(l, r, recursive=false)
+      ld = Digest.create(l, nil)
+      rd = Digest.create(r, nil)
+      diffs = digest_diff(ld, rd)
+      if recursive
+        lh = ld.entries_hash()
+        rh = rd.entries_hash()
+        keys = lh.keys | rh.keys
+        keys.each do |k|
+          next unless lh[k].is_a?(::ODisk::Dir) || rh[k].is_a?(::ODisk::Dir)
+          unless (sd = dir_diff(::File.join(l, k), ::File.join(r, k))).nil? || sd.empty?
+            if (d = diffs[k]).nil?
+              d = self.new(lh[k], rh[k], sd)
+            else
+              d.sub_diffs = sd
+            end
+            diffs[k] = d
+          end
+        end
+      end
+      diffs
+    end
+
+    def self.digest_diff(ld, rd)
+      diffs = {}
+      lh = ld.entries_hash()
+      rh = rd.entries_hash()
+      keys = lh.keys | rh.keys
+      keys.each do |k|
+        le = lh[k]
+        re = rh[k]
+        diffs[k] = self.new(le, re) unless le == re
+      end
+      diffs
+    end
+
+    def initialize(local, remote, sub_diffs={})
+      @local = local
+      @remote = remote
+      @sub_diffs = sub_diffs
+    end
+
+    def fill_hash(prefix, h, sym=false)
+      [:class, :name, :owner, :group, :mode, :mtime, :size, :target].each do |m|
+        next unless @local.respond_to?(m) and @remote.respond_to?(m)
+        lv = @local.send(m)
+        rv = @remote.send(m)
+        if sym
+          k = m
+        else
+          k = @local.name + '.' + m.to_s
+          k = prefix + '.' + k unless prefix.nil?
+        end
+        h[k] = [lv, rv] unless lv == rv unless (:mtime == m && !@remote.is_a?(::ODisk::File))
+      end
+      pre = prefix.nil? ? @local.name : (prefix + '.' + @local.name)
+      @sub_diffs.each do |name,d|
+        d.fill_hash(pre, h)
+      end
+    end
+
+    def to_s()
+      s = ''
+      h = {}
+      fill_hash(nil, h)
+      h.each { |k,v| s << "#{k}: #{v[0]} vs #{v[1]}\n" }
+      s
+    end
+
+  end # Diff
+end # ODisk

data/lib/odisk/digest.rb

@@ -0,0 +1,85 @@
+
+module ODisk
+  class Digest
+
+    attr_accessor :version
+
+    attr_accessor :entries
+
+    attr_reader :top_path
+
+    def self.create(top, rel_path)
+      path = (rel_path.nil? || rel_path.empty?) ? top : ::File.join(top, rel_path)
+      raise "#{path} is not a directory" unless ::File.directory?(path)
+      d = self.new(rel_path)
+      ::Dir.foreach(path) do |filename|
+        next if filename.start_with?('.')
+        child_path = ::File.join(path, filename)
+        c = self.create_info(child_path, filename, top)
+        d.entries << c
+      end
+      d
+    end
+
+    def self.create_info(path, filename=nil, top=nil)
+      top = $local_top if top.nil?
+      filename = ::File.basename(path) if filename.nil?
+      stat = ::File.lstat(path)
+      if stat.directory?
+        c = ::ODisk::Dir.new(filename)
+      elsif stat.symlink?
+        c = ::ODisk::Link.new(filename)
+        c.target = ::File.readlink(path)
+        c.target = c.target[top.size + 1..-1] if c.target.start_with?(top)
+      elsif stat.file?
+        c = ::ODisk::File.new(filename)
+        c.size = stat.size()
+      else
+        raise "file type of #{job.path} is not supported"
+      end
+      c.mtime = stat.mtime()
+      c.mode = stat.mode & 0777
+      begin
+        c.owner = Etc.getpwuid(stat.uid).name
+      rescue
+        c.owner = stat.uid
+      end
+      begin
+        c.group = Etc.getgrgid(stat.gid).name
+      rescue
+        c.group = stat.gid
+      end
+      c
+    end
+
+    def initialize(top_path)
+      @top_path = top_path
+      @version = 0
+      @entries = []
+    end
+
+    def [](name)
+      @entries.each { |e| return e if name == e.name }
+      nil
+    end
+
+    def empty?()
+      @entries.empty?
+    end
+
+    def delete(name)
+      @entries.delete_if { |e| name == e.name }
+    end
+
+    def sub_dirs()
+      @entries.select { |e| e.is_a?(::ODisk::Dir) }
+    end
+
+    def entries_hash()
+      h = {}
+      @entries.each { |e| h[e.name] = e }
+      h
+    end
+
+  end # Digest
+end # ODisk

data/lib/odisk/digester.rb

@@ -0,0 +1,33 @@
+
+require 'etc'
+
+module ODisk
+  class Digester < ::Opee::Actor
+
+    def initialize(options={})
+      super(options)
+    end
+    
+    def set_options(options)
+      super(options)
+      @collector = options[:collector]
+    end
+
+    private
+
+    def create(job)
+      path = ::File.join($local_top, job.path)
+      if ::File.directory?(path)
+        ::Opee::Env.info("create digest for #{path}")
+        d = ::ODisk::Digest.create($local_top, job.path)
+      else
+        ::Opee::Env.info("#{path} does not exist, no digest")
+        d = nil
+      end
+      job.current_digest = d
+      @collector.ask(:collect, job, :digester) unless @collector.nil?
+      ::Opee::Env.debug("#{Oj.dump(d, indent: 2)})")
+    end
+    
+  end # Digester
+end # ODisk

data/lib/odisk/dir.rb

@@ -0,0 +1,10 @@
+
+module ODisk
+  class Dir < Info
+
+    def initialize(name)
+      super(name)
+    end
+
+  end # Dir
+end # ODisk

data/lib/odisk/dirsyncjob.rb

@@ -0,0 +1,25 @@
+
+module ODisk
+  class DirSyncJob < ::Opee::Job
+
+    # relative path from top
+    attr_reader :path
+    # only set by the Digester
+    attr_accessor :current_digest
+    # only set by the SyncStarter
+    attr_accessor :previous_digest
+    # only set by the Fetcher
+    attr_accessor :remote_digest
+    # new digest to be set locally and remotely
+    attr_accessor :new_digest
+
+    def initialize(path)
+      @path = path
+      @current_digest = nil
+      @previous_digest = nil
+      @remote_digest = nil
+      @new_digest = nil
+    end
+    
+  end # DirSyncJob
+end # ODisk

data/lib/odisk/fetcher.rb

@@ -0,0 +1,54 @@
+
+begin
+  v = $VERBOSE
+  $VERBOSE = false
+  require 'net/ssh'
+  require 'net/sftp'
+  $VERBOSE = v
+end
+require 'oj'
+
+module ODisk
+  class Fetcher < ::Opee::Actor
+
+    def initialize(options={})
+      @ftp = nil
+      super(options)
+    end
+    
+    def set_options(options)
+      super(options)
+      @collector = options[:collector]
+    end
+
+    def close()
+      @ftp.close_channel() unless @ftp.nil?
+      @ftp = nil
+      super()
+    end
+
+    private
+
+    def fetch(job)
+      top = (job.path.nil? || job.path.empty?) ? $remote.dir : ::File.join($remote.dir, job.path)
+      path = ::File.join(top, '.odisk', 'digest.json')
+      ::Opee::Env.info("fetch digest \"#{path}\"")
+      @ftp = Net::SFTP.start($remote.host, $remote.user) if @ftp.nil?
+      begin
+        json = @ftp.download!(path)
+        files = @ftp.dir.entries(top).map {|e| e.name }
+        job.remote_digest = Oj.load(json, mode: :object)
+        missing = []
+        job.remote_digest.entries.each { |e| missing << e.name unless files.include?(e.name + '.gpg') || files.include?(e.name) }
+        unless ::ODisk::Planner::Step::REMOTE == $master
+          missing.each { |name| job.remote_digest.delete(name) }
+        end
+      rescue Exception
+        job.remote_digest = nil
+      end
+      @collector.ask(:collect, job, :fetcher) unless @collector.nil?
+      ::Opee::Env.debug("#{Oj.dump(job.remote_digest, indent: 2)})")
+    end
+    
+  end # Fetcher
+end # ODisk

data/lib/odisk/file.rb

@@ -0,0 +1,18 @@
+
+module ODisk
+  class File < Info
+
+    attr_accessor :size
+
+    def initialize(name)
+      super(name)
+      @size = 0
+    end
+
+    def eql?(o)
+      super(o) && @size == o.size && @mtime == o.mtime
+    end
+    alias == eql?
+
+  end # File
+end # ODisk

data/lib/odisk/info.rb

@@ -0,0 +1,40 @@
+
+module ODisk
+  class Info
+
+    NORMAL = 0 # or nil
+    ERROR  = 1
+    REMOTE = 2
+    LOCAL  = 3
+
+    attr_accessor :name
+    attr_accessor :owner
+    attr_accessor :group
+    attr_accessor :mode
+    attr_accessor :mtime
+    attr_accessor :master
+    attr_accessor :removed
+
+    def initialize(name)
+      @name = name
+      @owner = nil
+      @group = nil
+      @mode = 0
+      @mtime = nil
+      @master = nil
+      @removed = false
+    end
+
+    def eql?(o)
+      return false unless o.class == self.class
+      # don't check master flag
+      (@name == o.name &&
+       @owner == o.owner &&
+       @group == o.group &&
+       @mode == o.mode &&
+       @removed == o.removed)
+    end
+    alias == eql?
+
+  end # Info
+end # ODisk

data/lib/odisk/link.rb

@@ -0,0 +1,18 @@
+
+module ODisk
+  class Link < Info
+
+    attr_accessor :target
+
+    def initialize(name)
+      super(name)
+      @target = nil
+    end
+
+    def eql?(o)
+      super(o) && @target == o.target
+    end
+    alias == eql?
+
+  end # Link
+end # ODisk

data/lib/odisk/planner.rb

@@ -0,0 +1,309 @@
+
+require 'oj'
+
+module ODisk
+  class Planner < ::Opee::Collector
+
+    def initialize(options={})
+      super(options)
+    end
+    
+    def set_options(options)
+      super(options)
+      @dir_queue = options[:dir_queue]
+      @copy_queue = options[:copy_queue]
+      @crypt_queue = options[:crypt_queue]
+      @inputs = options[:inputs]
+      @fixer = options[:fixer]
+    end
+
+    # master can be Step::LOCAL or Step::REMOTE and forces direction
+    def self.sync_steps(pd, ld, rd, master=nil)
+      steps = {}
+      lh = {}
+      rh = {}
+      ph = {}
+      ld.entries.each { |e| lh[e.name] = e }
+      rd.entries.each { |e| rh[e.name] = e }
+      pd.entries.each { |e| ph[e.name] = e } unless pd.nil?
+      keys = lh.keys | rh.keys
+      keys.each do |name|
+        le = lh[name]
+        re = rh[name]
+        if re.nil?
+          if Step::REMOTE == master
+            steps[name] = Step.new(name, Step::LOCAL, Step::REMOVE)
+          elsif le.is_a?(::ODisk::File)
+            steps[name] = Step.new(name, Step::LOCAL, Step::COPY)
+          elsif le.is_a?(::ODisk::Dir)
+            steps[name] = Step.new(name, Step::LOCAL, Step::DIGEST)
+          end
+        elsif le.nil?
+          if Step::LOCAL == master
+            steps[name] = Step.new(name, Step::REMOTE, Step::REMOVE)
+          elsif re.is_a?(::ODisk::File)
+            steps[name] = Step.new(name, Step::REMOTE, Step::COPY)
+          elsif re.is_a?(::ODisk::Dir)
+            steps[name] = Step.new(name, Step::REMOTE, Step::DIGEST)
+          end
+        elsif le != re # both exist but are different
+          if le.class != re.class
+            ::Opee::Env.error("Conflict syncing #{ld.top_path}/#{name}. Local and remote types do not match.")
+            steps[name] = Step.new(name, Step::LOCAL, Step::ERROR)
+          elsif le.is_a?(::ODisk::File) || le.is_a?(::ODisk::Link)
+            op = le.is_a?(::ODisk::File) ? Step::COPY : Step::LINK
+            if Step::LOCAL == master
+              steps[name] = Step.new(name, Step::LOCAL, op) if le.is_a?(::ODisk::File)
+            elsif Step::REMOTE == master
+              steps[name] = Step.new(name, Step::REMOTE, op) if re.is_a?(::ODisk::File)
+            elsif le.removed
+              # TBD
+            elsif re.removed
+              # TBD
+            elsif le.mtime > re.mtime
+              pe = ph[name]
+              if pe.nil? || pe.mtime == re.mtime
+                # Don't know if the content or the stats changed so copy it.
+                steps[name] = Step.new(name, Step::LOCAL, op) if le.is_a?(::ODisk::File)
+              else
+                ::Opee::Env.error("Conflict syncing #{ld.top_path}/#{name}. Both local and remote have changed.")
+                steps[name] = Step.new(name, Step::LOCAL, Step::ERROR)
+              end
+            elsif le.mtime < re.mtime
+              # Don't know if the content or the stats changed so copy it.
+              steps[name] = Step.new(name, Step::REMOTE, op) if re.is_a?(::ODisk::File)
+            else # same times but different can't be good
+              ::Opee::Env.error("Conflict syncing #{ld.top_path}/#{name}. Both local and remote have changed.")
+              steps[name] = Step.new(name, Step::LOCAL, Step::ERROR)
+            end
+          end
+        end
+      end
+      steps.empty? ? nil : steps
+    end
+
+    private
+
+    def update_token(job, token, path_id)
+      token = [] if token.nil?
+      token << path_id
+      token
+    end
+
+    def complete?(job, token)
+      result = !token.nil? && token.size == @inputs.size && token.sort == @inputs.sort
+      ::Opee::Env.info("complete?(#{job.key()}, #{token}) => #{result}")
+      #::Opee::Env.debug("#{Oj.dump(job, indent: 2)}")
+      result
+    end
+
+    def keep_going(job)
+      path = ::File.join($local_top, job.path)
+      odisk_dir = ::File.join(path, '.odisk')
+      `mkdir -p "#{odisk_dir}"` unless ::File.directory?(odisk_dir) && !$dry_run
+      if @copy_queue.nil? && @crypt_queue.nil? && !job.current_digest.nil? # digests_only
+        if job.previous_digest.nil?
+          job.current_digest.version = 1
+        else
+          job.current_digest.version = job.previous_digest.version + 1
+          Oj.to_file(::File.join(odisk_dir, 'digest.old.json'), job.previous_digest, indent: 2)
+        end
+        Oj.to_file(::File.join(odisk_dir, 'digest.json'), job.current_digest, indent: 2)
+        job.current_digest.entries.each do |e|
+          @dir_queue.ask(:add, job.path.empty? ? e.name : ::File.join(job.path, e.name)) if e.is_a?(::ODisk::Dir)
+        end
+      elsif job.remote_digest.nil?
+        process_new(job, odisk_dir)
+      elsif ((job.current_digest.nil? || job.current_digest.empty?) &&
+             (job.previous_digest.nil? || job.previous_digest.empty?))
+        process_down(job, odisk_dir)
+      else
+        process_sync(job, odisk_dir)
+      end
+    end    
+
+    def process_new(job, odisk_dir)
+      job.current_digest.version = 1
+      job.new_digest = job.current_digest
+      # determine update new_digest
+      # write the digest files
+      # TBD if they are the same then don't bother
+      Oj.to_file(::File.join(odisk_dir, 'digest.old.json'), job.previous_digest, indent: 2) unless job.previous_digest.nil?
+      Oj.to_file(::File.join(odisk_dir, 'digest.json'), job.new_digest, indent: 2)
+
+      # get the transfers going for all files
+      job.new_digest.entries.each do |e|
+        path = job.path.empty? ? e.name : ::File.join(job.path, e.name)
+        case e
+        when ::ODisk::Dir
+          @dir_queue.ask(:add, path)
+        when ::ODisk::File
+          local = ::File.join($local_top, path)
+          remote = ::File.join($remote.dir, path)
+          if $remote.encrypt?
+            encrypt_path = (job.path.empty? ? 
+                            ::File.join($local_top, '.odisk', e.name + '.gpg') :
+                            ::File.join($local_top, job.path, '.odisk', e.name + '.gpg'))
+            @crypt_queue.add_method(:encrypt, local, encrypt_path, remote + '.gpg')
+          else
+            @copy_queue.add_method(:upload, local, remote)
+          end
+        when ::ODisk::Link
+          # nothing to do
+        end
+      end
+      path = job.path.empty? ? ::File.join('.odisk', 'digest.json') : ::File.join(job.path, '.odisk', 'digest.json')
+      local = ::File.join($local_top, path)
+      remote = ::File.join($remote.dir, path)
+      @copy_queue.add_method(:upload, local, remote)
+    end
+    
+    def process_down(job, odisk_dir)
+      job.new_digest = job.remote_digest
+      Oj.to_file(::File.join(odisk_dir, 'digest.json'), job.new_digest, indent: 2)
+      full_job_path = job.path.empty? ? $local_top : ::File.join($local_top, job.path)
+      stat_job = StatJob.new(full_job_path, job.new_digest)
+      job.new_digest.entries.each do |e|
+        path = job.path.empty? ? e.name : ::File.join(job.path, e.name)
+        local = ::File.join($local_top, path)
+        case e
+        when ::ODisk::Dir
+          ::Dir.mkdir(local) unless $dry_run || ::File.directory?(local)
+          @dir_queue.ask(:add, path)
+        when ::ODisk::File
+          remote = ::File.join($remote.dir, path)
+          stat_job.add_mod(e.name)
+          if $remote.encrypt?
+            encrypt_path = (job.path.empty? ? 
+                            ::File.join($local_top, '.odisk', e.name + '.gpg') :
+                            ::File.join($local_top, job.path, '.odisk', e.name + '.gpg'))
+            @copy_queue.add_method(:download, remote + '.gpg', encrypt_path, local)
+          else
+            @copy_queue.add_method(:download, remote, local, nil)
+          end
+        when ::ODisk::Link
+          target = e.target
+          target = ::File.join($local_top, e.target) unless '/' == target[0]
+          ::Opee::Env.info("symlink \"#{local}\" -> \"#{target}\"}")
+          ::File.symlink(target, local) unless $dry_run || ::File.exists?(local)
+        end
+      end
+      @fixer.ask(:collect, stat_job, :planner) unless @fixer.nil?
+    end
+
+    def process_sync(job, odisk_dir)
+      dirs = []
+      job.current_digest.entries.each { |e| dirs << e.name unless !e.is_a?(::ODisk::Dir) || dirs.include?(e.name) }
+      job.remote_digest.entries.each { |e| dirs << e.name unless !e.is_a?(::ODisk::Dir) || dirs.include?(e.name) }
+      dirs.each do |dir|
+        path = job.path.empty? ? dir : ::File.join(job.path, dir)
+        local = ::File.join($local_top, path)
+        ::Dir.mkdir(local) unless $dry_run || ::File.directory?(local)
+        @dir_queue.ask(:add, path)
+      end
+      steps = self.class.sync_steps(job.previous_digest, job.current_digest, job.remote_digest, $master)
+      #puts "*** steps for #{job.path}: #{steps}"
+      return if steps.nil?
+
+      Oj.to_file(::File.join(odisk_dir, 'digest.old.json'), job.previous_digest, indent: 2) unless job.previous_digest.nil?
+      nrh = {} # fill with new digest entries for remote
+      nlh = {} # fill with new digest entries for local
+      full_job_path = job.path.empty? ? $local_top : ::File.join($local_top, job.path)
+      stat_job = StatJob.new(full_job_path, nil)
+      job.remote_digest.entries.each { |e| nrh[e.name] = e }
+      job.current_digest.entries.each { |e| nlh[e.name] = e }
+=begin
+      if job.previous_digest.nil?
+        job.current_digest.entries.each { |e| nlh[e.name] = e }
+      else
+        job.previous_digest.entries.each { |e| nlh[e.name] = e }
+      end
+=end
+      steps.values.each do |s|
+        stat_job.add_mod(s.name) unless Step::REMOVE == s.op || Step::DIGEST == s.op
+        case s.op
+        when Step::COPY
+          path = job.path.empty? ? s.name : ::File.join(job.path, s.name)
+          local = ::File.join($local_top, path)
+          remote = ::File.join($remote.dir, path)
+          encrypt_path = (job.path.empty? ? 
+                          ::File.join($local_top, '.odisk', s.name + '.gpg') :
+                          ::File.join($local_top, job.path, '.odisk', s.name + '.gpg'))
+          if Step::REMOTE == s.master
+            if $remote.encrypt?
+              @copy_queue.add_method(:download, remote + '.gpg', encrypt_path, local)
+            else
+              @copy_queue.add_method(:download, remote, local, nil)
+            end
+            e = job.remote_digest[s.name]
+          else
+            if $remote.encrypt?
+              @crypt_queue.add_method(:encrypt, local, encrypt_path, remote + '.gpg')
+            else
+              @copy_queue.add_method(:upload, local, remote)
+            end
+            e = job.current_digest[s.name]
+          end
+          nrh[e.name] = e
+          nlh[e.name] = e
+        when Step::REMOVE
+          # TBD
+        when Step::DIGEST
+          e = (Step::REMOTE == s.master) ? job.remote_digest[s.name] : job.current_digest[s.name]
+          nrh[e.name] = e
+          nlh[e.name] = e
+        when Step::LINK
+          if Step::REMOTE == s.master
+            #TBD create link
+          end
+        when Step::ERROR
+          # TBD
+        end
+      end
+      nrd = Digest.new(job.remote_digest.top_path)
+      nld = Digest.new(job.current_digest.top_path)
+      # fill in digest entries from hashs
+      nrd.entries = nrh.values
+      nld.entries = nlh.values
+
+      job.new_digest = nrd
+      remote_digest_path = ::File.join(odisk_dir, 'digest.remote.json')
+      Oj.to_file(::File.join(odisk_dir, 'digest.json'), nld, indent: 2)
+      Oj.to_file(remote_digest_path, job.new_digest, indent: 2)
+      path = job.path.empty? ? ::File.join('.odisk', 'digest.json') : ::File.join(job.path, '.odisk', 'digest.json')
+      @copy_queue.add_method(:upload, remote_digest_path, ::File.join($remote.dir, path)) unless Step::REMOTE == $master
+
+      stat_job.digest = nld
+      @fixer.ask(:collect, stat_job, :planner) unless @fixer.nil?
+    end
+
+    class Step
+      # op values
+      STATS  = 0
+      REMOVE = 1
+      COPY   = 2
+      LINK   = 3
+      DIGEST = 4
+      ERROR  = 5
+      
+      # location of master
+      LOCAL  = true
+      REMOTE = false
+
+      attr_reader :name
+      attr_reader :master
+      attr_reader :op
+
+      def initialize(name, master, op)
+        @name = name
+        @master = master
+        @op = op
+      end
+
+      def to_s()
+        "<Step name=#{@name} master=#{@master ? 'LOCAL' : 'REMOTE'} op=#{['STATS', 'REMOVE', 'COPY', 'LINK', 'ERROR'][@op]}>"
+      end
+    end # Step
+
+  end # Planner
+end # ODisk