infopark_reactor_migrations 1.5.1

data/lib/reactor/tools/migrator.rb

@@ -0,0 +1,135 @@
+require 'reactor/tools/versioner'
+
+module Reactor
+  # Class responsible for running a single migration, a helper for Migrator
+  class MigrationProxy
+    def initialize(versioner, name, version, direction, filename)
+      @versioner = versioner
+      @name = name
+      @version = version
+      @filename = filename
+      @direction = direction
+    end
+
+    def load_migration
+      load @filename
+    end
+
+    def run
+      return down if @direction.to_sym == :down
+      return up
+    end
+
+    def up
+      if @versioner.applied?(@version) then
+        puts "Migrating up: #{@name} (#{@filename}) already applied, skipping"
+        return true
+      else
+        result = class_name.send(:up) and @versioner.add(@version)
+        class_name.contained.each do |version|
+          puts "#{class_name.to_s} contains migration #{version}"
+          #@versioner.add(version) # not neccesary!
+        end if result
+        result
+      end
+    end
+
+    def down
+      result = class_name.send(:down) and @versioner.remove(@version)
+      class_name.contained.each do |version|
+        puts "#{class_name.to_s} contains migration #{version}"
+        @versioner.remove(version)
+      end if result
+      result
+    end
+
+    def class_name
+      return Kernel.const_get(@name)
+    end
+
+    def name
+      @name
+    end
+
+    def version
+      @version
+    end
+
+    def filename
+      @filename
+    end
+  end
+
+  # Migrator is responsible for running migrations.
+  #
+  # <b>You should not use this class directly! Use rake cm:migrate instead.</b>
+  #
+  # Migrating to a specific version is possible by specifing VERSION environment
+  # variable: rake cm:migrate VERSION=0
+  # Depending on your current version migrations will be run up
+  # (target version > current version) or down (target version < current version)
+  #
+  # MIND THE FACT, that you land at the version <i>nearest</i> to target_version
+  # (possibly target version itself)
+  class Migrator
+    # Constructor takes two parameters migrations_path (relative path of migration files)
+    # and target_version (an integer or nil).
+    #
+    # Used by a rake task.
+    def initialize(migrations_path, target_version=nil)
+      @migrations_path = migrations_path
+      @target_version = target_version.to_i unless target_version.nil?
+      @target_version = 99999999999999 if target_version.nil?
+      @versioner = Versioner.instance
+    end
+
+    # Runs the migrations in proper direction (up or down)
+    # Ouputs current version when done
+    def migrate
+      return up if @target_version.to_i > current_version.to_i
+      return down
+    end
+
+    def up
+      rem_migrations = migrations.reject do |version, name, file|
+        version.to_i > @target_version.to_i or applied?(version)
+      end
+      run(rem_migrations, :up)
+    end
+
+    def down
+      rem_migrations = migrations.reject do |version, name, file|
+        version.to_i <= @target_version.to_i or not applied?(version)
+      end
+      run(rem_migrations.reverse, :down)
+    end
+
+    def migrations
+      files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort.collect do |file|
+        version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+        [version, name, file]
+      end
+    end
+
+    def applied?(version)
+      @versioner.applied?(version)
+    end
+
+    def current_version
+      @versioner.current_version
+    end
+
+    def run(rem_migrations, direction)
+      begin
+        rem_migrations.each do |version, name, file|
+          migration = MigrationProxy.new(@versioner, name.camelize, version, direction, file)
+          puts "Migrating #{direction.to_s}: #{migration.name} (#{migration.filename})"
+          migration.load_migration and migration.run or raise "Migrating #{direction.to_s}: #{migration.name} (#{migration.filename}) failed"
+        end
+      ensure
+        puts "At version: " + @versioner.current_version.to_s
+        puts "WARNING: Could not store applied migrations!" if not @versioner.store
+      end
+    end
+  end
+end

data/lib/reactor/tools/response_handler/base.rb

@@ -0,0 +1,22 @@
+module Reactor
+
+  module ResponseHandler
+    
+    # Common base class to handle a xml response. Provides helper methods to extract the content 
+    # from a xml response.
+    class Base
+
+      attr_accessor :response
+      attr_accessor :context
+
+      # Common strategy method for each sub class.
+      def get(response, context)
+        @response = response
+        @context = context
+      end
+      
+    end
+
+  end
+
+end

data/lib/reactor/tools/response_handler/string.rb

@@ -0,0 +1,19 @@
+require 'reactor/tools/response_handler/base'
+
+module Reactor
+
+  module ResponseHandler
+    
+    class String < Base
+      
+      def get(response, string)
+        super(response, string)
+
+        self.response.xpath(string)
+      end
+
+    end
+    
+  end
+
+end

data/lib/reactor/tools/response_handler/xml_attribute.rb

@@ -0,0 +1,52 @@
+require 'reactor/tools/response_handler/base'
+
+module Reactor
+
+  module ResponseHandler
+    
+    class XmlAttribute < Base
+      
+      def get(response, attribute)
+        super(response, attribute)
+
+        name = attribute.name
+        type = attribute.type
+
+        method_name = "extract_#{type}"
+
+        self.send(method_name, name)
+      end
+
+      private
+
+      # Extracts a string value with the given +name+ and returns a string.
+      def extract_string(name)
+        self.response.xpath("//#{name}/text()").to_s
+      end
+
+      # Extracts a list value with the given +name+ and returns an array of strings.
+      def extract_list(name)
+        result = self.response.xpath("//#{name}/listitem/text()")
+        result = result.kind_of?(Array) ? result : [result]
+
+        result.map(&:to_s)
+      end
+
+      # This shit will break with the slightest change of the CM.
+      def extract_signaturelist(name)
+        signatures = []
+        self.response.xpath("//#{name}/").each do |potential_signature|
+          if (potential_signature.name.to_s == "listitem")
+            attribute = potential_signature.children.first.text.to_s
+            group = potential_signature.children.last.text.to_s
+            signatures << {:attribute => attribute, :group => group}
+          end
+        end
+        signatures
+      end
+
+    end
+    
+  end
+
+end

data/lib/reactor/tools/smart_xml_logger.rb

@@ -0,0 +1,69 @@
+require 'nokogiri'
+require 'term/ansicolor'
+
+class SmartXmlLogger
+
+  include Term::ANSIColor
+
+  def initialize(forward_to, method = nil)
+    @logger = forward_to
+    @method = method
+  end
+
+  def configure(key, options)
+    @configuration ||= {}
+    @configuration[key] = options
+  end
+
+  def log(text)
+    return unless @logger
+    @logger.send(@method, text)
+  end
+
+  def log_xml(key, xml)
+    return unless @logger
+
+    options = @configuration[key]
+
+    dom = Nokogiri::XML::Document.parse(xml)
+
+    node_set = options[:xpath] ? dom.xpath(options[:xpath]) : dom
+
+    self.log(if node_set.respond_to?(:each)
+      node_set.map{|node| self.print_node(node, options[:start_indent] || 0)}.join
+    else
+      self.print_node(node_set, options[:start_indent] || 0)
+    end)
+  end
+
+  #private
+
+  def print_node(node, indent = 0)
+    return '' if node.text?
+
+    empty = node.children.empty?
+    has_text = node.children.detect{|child| child.text?}
+
+    out = ' ' * indent
+
+    attrs = node.attributes.values.map{|attr| %|#{attr.name}="#{red(attr.value)}"|}.join(' ')
+    attrs = " #{attrs}" if attrs.present?
+
+    out << "<#{green(node.name)}#{attrs}#{'/' if empty}>"
+
+    if has_text
+      out << "#{red(node.text)}"
+    else
+      out << "\n"
+    end
+
+    node.children.each do |child|
+      out << self.print_node(child, indent + 2)
+    end
+
+    out << ' ' * indent unless has_text || empty
+    out << "</#{green(node.name)}>\n" unless empty
+    out
+  end
+
+end

data/lib/reactor/tools/sower.rb

@@ -0,0 +1,89 @@
+module Reactor
+
+  class Sower
+    def initialize(filename)
+      @filename = filename
+    end
+    def sow
+      require @filename
+    end
+  end
+
+end
+
+class SeedObject < RailsConnector::Obj
+end
+
+module RailsConnector
+  class Obj
+
+    attr_accessor :keep_edited
+
+    def self.plant(path, &block)
+      obj = Obj.find_by_path(path)
+      raise ActiveRecord::RecordNotFound.new('plant: Ground not found:' +path) if obj.nil?
+      #obj.objClass = 'Container' # TODO: enable it!
+      #obj.save!
+      #obj.release!
+      obj.send(:reload_attributes)
+      obj.instance_eval(&block) if block_given?
+      # ActiveRecord is incompatible with changing the obj class, therefore you get RecordNotFound
+      begin
+        obj.save!
+      rescue ActiveRecord::RecordNotFound
+      end
+      obj.release unless obj.keep_edited || !Obj.last.edited?
+      obj
+    end
+
+    # creates of fetches an obj with given name (within context),
+    # executes a block on it (instance_eval)
+    # saves and releases (unless keep_edited = true was called)
+    # the object afterwards
+    def obj(name, objClass = 'Container', &block)
+      obj = Obj.find_by_path(File.join(self.path.to_s, name.to_s))
+      if obj.nil?
+        obj = Obj.create(:name => name, :parent => self.path, :obj_class => objClass)
+      else
+        obj = Obj.find_by_path(File.join(self.path.to_s, name.to_s))
+        if obj.obj_class != objClass
+          obj.obj_class = objClass
+          begin
+            obj.save!
+          rescue ActiveRecord::RecordNotFound
+          end
+          obj = Obj.find_by_path(File.join(self.path.to_s, name.to_s))
+        end
+      end
+      obj.send(:reload_attributes, objClass)
+      obj.instance_eval(&block) if block_given?
+      obj.save!
+      obj.release unless obj.keep_edited || !Obj.last.edited?
+      obj
+    end
+
+    def self.with(path, objClass = 'Container', &block)
+      splitted_path = path.split('/')
+      name = splitted_path.pop
+      # ensure path exists
+      (splitted_path.length).times do |i|
+        subpath = splitted_path[0,(i+1)].join('/').presence || '/'
+        subpath_parent = splitted_path[0,i].join('/').presence || '/'
+        subpath_name = splitted_path[i]
+        create(:name => subpath_name, :parent => subpath_parent, :obj_class => 'Container') unless Obj.find_by_path(subpath) unless subpath_name.blank?
+      end
+      parent_path = splitted_path.join('/').presence || '/'
+      parent = Obj.find_by_path(parent_path)
+      parent.obj(name, objClass, &block)
+    end
+
+    def do_not_release!
+      @keep_edited = true
+    end
+
+    def t(key, opts={})
+      I18n.t(key, opts)
+    end
+
+  end
+end

data/lib/reactor/tools/uploader.rb

@@ -0,0 +1,131 @@
+module Reactor
+  module Tools
+    class Uploader
+
+      attr_reader :cm_obj
+
+      def initialize(cm_obj)
+        self.cm_obj = cm_obj
+      end
+
+      # Uses streaming interface to upload data from
+      # given IO stream or memory location.
+      # Extension is used as basis for content detection.
+      # Larger file transfers should be executed through IO
+      # streams, which conserve memory.
+      #
+      # After the data has been successfuly transfered to
+      # streaming interface it stores contentType and resulting
+      # ticket into Reactor::Cm::Obj provided on initialization.
+      #
+      # NOTE: there is a known bug for Mac OS X: if you are
+      # uploading more files (IO objects) in sequence,
+      # the upload may fail randomly. For this platform
+      # and this case fallback to memory streaming is used.
+      def upload(data_or_io, extension)
+        if (data_or_io.kind_of?IO)
+          io = data_or_io
+          begin
+            ticket_id = stream_io(io, extension)
+          rescue Errno::EINVAL => e
+            if RUBY_PLATFORM.downcase.include?("darwin")
+              # mac os x is such a piece of shit
+              # writing to a socket can fail with EINVAL, randomly without
+              # visible reason when using body_stream
+              # in this case fallback to memory upload which always works (?!?!)
+              Reactor::Cm::LOGGER.log "MacOS X bug detected for #{io.inspect}"
+              io.rewind
+              return upload(io.read, extension)
+            else
+              raise e
+            end
+          end
+        else
+          ticket_id = stream_data(data_or_io, extension)
+        end
+
+        cm_obj.set(:contentType, extension)
+        cm_obj.set(:blob, {ticket_id=>{:encoding=>'stream'}})
+
+        ticket_id
+      end
+
+      protected
+
+      attr_writer :cm_obj
+
+      # Stream into CM from memory. Used in cases when the file
+      # has already been read into memory
+      def stream_data(data, extension)
+        response, ticket_id = (Net::HTTP.new(self.class.streaming_host, self.class.streaming_port).post('/stream', data,
+          {'Content-Type' => self.class.content_type_for_ext(extension)}))
+
+        handle_response(response, ticket_id)
+      end
+
+      # Stream directly an IO object into CM. Uses minimal memory,
+      # as the IO is read in 1024B-Blocks
+      def stream_io(io, extension)
+        request = Net::HTTP::Post.new('/stream')
+        request.body_stream = io
+        request.content_length = read_io_content_length(io)
+        request.content_type = self.class.content_type_for_ext(extension)
+
+        response, ticket_id = nil, nil
+        Net::HTTP.start(self.class.streaming_host, self.class.streaming_port) do |http|
+          http.read_timeout = 60
+          #http.set_debug_output $stderr
+          response, ticket_id = http.request(request)
+        end
+
+        handle_response(response, ticket_id)
+      end
+
+      # Returns ticket_id if response if one of success (success or redirect)
+      def handle_response(response, ticket_id)
+        if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+          ticket_id
+        else
+          nil
+        end
+      end
+
+      # Returns the size of the IO stream.
+      # The underlying stream must support either
+      # the :stat method or be able to seek to
+      # random position
+      def read_io_content_length(io)
+        if (io.respond_to?(:stat))
+          # For files it is easy to read the filesize
+          return io.stat.size
+        else
+          # For streams it is not. We seek to end of
+          # the stream, read the position, and rewind
+          # to the previous location
+          old_pos = io.pos
+          io.seek(0, IO::SEEK_END)
+          content_length = io.pos
+          io.seek(old_pos, IO::SEEK_SET)
+
+          content_length
+        end
+      end
+
+      def self.streaming_host
+        Reactor::Configuration.xml_access[:host]
+      end
+
+      def self.streaming_port
+        Reactor::Configuration.xml_access[:port]
+      end
+
+      # It should theoretically return correct/matching
+      # mime type for given extension. But since the CM
+      # accepts 'application/octet-stream', no extra logic
+      # or external dependency is required.
+      def self.content_type_for_ext(extension)
+        'application/octet-stream'
+      end
+    end
+  end
+end

data/lib/reactor/tools/versioner.rb

@@ -0,0 +1,120 @@
+require 'base64'
+require 'yaml'
+require 'singleton'
+
+module Reactor
+  # Class responsible for interfacing with version-storing mechanism
+  class Versioner
+    include Singleton
+
+    # Slave class used by Versioner class to load and store migrated files
+    # inside the CM. It uses separate object type named "version_store"
+    # and stores data as base64'ed YAML inside recordSetCallback
+    # (Versionszuweisungsfunktion).
+    # Theoretically you could use any class for this purpose, but you would
+    # lose the ability to set recordSetCallback for this class. Other than
+    # that, it does not affect the object class in any way!
+    #
+    # Maybe the future version won't disrupt even this fuction.
+    class Slave
+      def name
+        "version_store"
+      end
+
+      def base_name
+        "objClass"
+      end
+
+      def exists?
+        begin
+          request = Reactor::Cm::XmlRequest.prepare do |xml|
+            xml.where_key_tag!(base_name, 'name', name)
+            xml.get_key_tag!(base_name, 'name')
+          end
+          response = request.execute!
+          return response.ok?
+        rescue
+          return false
+        end
+      end
+
+      def load
+        create if not exists?
+        request = Reactor::Cm::XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', name)
+          xml.get_key_tag!(base_name, 'recordSetCallback')
+        end
+        response = request.execute!
+        base64 = response.xpath("//recordSetCallback").text.to_s
+        yaml = Base64::decode64(base64)
+        data = YAML::load(yaml)
+        return [] if data.nil? or data == false
+        return data.to_a
+      end
+
+      def store(data)
+        create if not exists?
+        yaml = data.to_yaml
+        base64 = Base64::encode64(yaml).gsub("\n", '').gsub("\r", '')
+        content = '#' + base64
+        request = Reactor::Cm::XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', name)
+          xml.set_key_tag!(base_name, 'recordSetCallback', content)
+        end
+        response = request.execute!
+        response.ok?
+      end
+
+      def create
+        request = Reactor::Cm::XmlRequest.prepare do |xml|
+          xml.create_tag!(base_name) do
+            xml.tag!('name') do
+              xml.text!(name)
+            end
+            xml.tag!('objType') do
+              xml.text!('document')
+            end
+          end
+        end
+        response = request.execute!
+        response.ok?
+      end
+    end
+
+    def initialize
+      @versions = []
+      @backend = Slave.new
+      load
+    end
+
+    def load
+      @versions = @backend.load
+    end
+
+    def store
+      @backend.store(@versions)
+    end
+
+    def applied?(version)
+      @versions.include? version.to_s
+    end
+
+    def add(version)
+      @versions << version.to_s
+    end
+
+    def remove(version)
+      not @versions.delete(version.to_s).nil?
+    end
+
+    def versions
+      @versions
+    end
+
+    def current_version
+      current = @versions.sort.reverse.first
+      return 0 if current.nil?
+      return current
+    end
+  end
+end

data/lib/reactor/tools/xml_attributes.rb

@@ -0,0 +1,70 @@
+require 'reactor/cm/xml_attribute'
+require 'reactor/tools/response_handler/xml_attribute'
+
+module Reactor
+
+  module XmlAttributes
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_attributes
+      self._attributes = {}
+
+      class_attribute :response_handler
+      self.response_handler = ResponseHandler::XmlAttribute.new
+    end
+
+    module ClassMethods
+
+      # This method can act as both getter and setter.
+      # I admit, that it is not the best design ever.
+      # But it makes a pretty good DSL
+      def primary_key(new_value = nil)
+        if new_value.nil?
+          @primary_key
+        else
+          @primary_key = new_value.to_s
+          @primary_key
+        end
+      end
+
+      def attribute(name, options = {})
+        xml_name = options.delete(:name).presence || name
+        type = options.delete(:type).presence
+
+        attribute = Reactor::Cm::XmlAttribute.new(xml_name, type, options)
+
+        self._attributes[name.to_sym] = attribute
+
+        attr_accessor name
+      end
+
+      def attributes(scopes = [])
+        scopes = Array(scopes)
+        attributes = self._attributes
+
+        if scopes.present?
+          attributes.reject { |_, xml_attribute| (xml_attribute.scopes & scopes).blank? }
+        else
+          attributes
+        end
+      end
+
+      def xml_attribute(name)
+        self._attributes[name.to_sym]
+      end
+
+      def xml_attribute_names
+        self._attributes.values.map(&:name)
+      end
+
+      def attribute_names
+        self._attributes.keys
+      end
+
+    end
+
+  end
+
+end