qooxview 1.9.9

data/lib/qooxview/storages/csv.rb

@@ -0,0 +1,170 @@
+class CSV < StorageType
+
+  def configure(config)
+    dputs(3) { "Configuring CSV with #{@name}" }
+    @csv_dir = 'data/'
+    @add_only = false
+    @backup_count = 5
+    super config
+    @csv_backup = "#{@csv_dir}/backup/"
+    @csv_name = "#{@entity.class.name}.csv"
+    @csv_file = @csv_dir + @csv_name
+    @csv_backup_file = @csv_backup + @csv_name
+    dputs(5) { "data_file is #{@csv_file}" }
+
+    @mutex = Mutex.new
+  end
+
+  def write_line(f, d)
+    # Only write non-nil data
+    d = d.select { |k, v| v }
+    # And convert the Array back into a Hash
+    d = Hash[*d.flatten(1)]
+    # If there is only nil-data (except the field-id), don't write it!
+    if d.length > 1
+      dputs(5) { "Writing line #{d.inspect}" }
+      f << d.to_json << "\n"
+    end
+  end
+
+  # Saves the data stored, optionally takes an index to say
+  # which data needs to be saved
+  def save(data)
+    @add_only ?
+        dputs(5) { "Not saving data for #{@name}" } :
+        @mutex.synchronize {
+          begin
+            dputs(3) { "Saving data for #{@name} to #{@csv_dir} - #{@csv_file}" }
+            [@csv_dir, @csv_backup].each { |d|
+              FileUtils.mkdir_p d unless File.exists? d
+            }
+            #dputs(5) { "Data is #{data.inspect}" }
+
+            if File.exists? @csv_file
+              time = File.mtime(@csv_file).strftime('%Y%m%d_%H%M%S')
+              backup = "#{@csv_backup_file}.#{time}"
+              counter = 1
+              while File.exists? backup
+                backup = "#{@csv_backup_file}.#{time}-#{counter}"
+                counter += 1
+              end
+              FileUtils.cp @csv_file, backup
+            end
+
+            tmpfile = "#{@csv_file}_tmp"
+            File.open(tmpfile, 'w') { |f|
+              data_each(data) { |d|
+                write_line(f, d)
+                if di = @entity.data_instances[d[@data_field_id]]
+                  di.changed = false
+                end
+              }
+            }
+            FileUtils.mv tmpfile, @csv_file
+            #%x[ sync ]
+            dputs(3) { 'Delete oldest file(s)' }
+            if (backups = Dir.glob("#{@csv_backup_file}.*").sort).size > @backup_count
+              oldfiles = backups.first(backups.size - @backup_count)
+              dputs(3){"Deleting #{oldfiles.inspect}"}
+              FileUtils.rm oldfiles
+            end
+          rescue Exception => e
+            dputs(0) { "Error: couldn't save CSV #{@name}" }
+            dputs(0) { "#{e.inspect}" }
+            dputs(0) { "#{e.to_s}" }
+            puts e.backtrace
+          end
+        }
+  end
+
+  # Each new entry is directly stored if @add_only is true
+  def data_create(data)
+    @add_only or return
+    @mutex.synchronize {
+      begin
+        FileUtils.mkdir_p @csv_dir unless File.exists? @csv_dir
+        tmpfile = "#{@csv_file}_tmp"
+        File.exists? @csv_file and FileUtils.cp @csv_file, tmpfile
+        File.open(tmpfile, 'a') { |f|
+          write_line(f, data)
+        }
+        #%x[ sync ]
+        dputs(5) { 'Moving file' }
+        FileUtils.mv tmpfile, @csv_file
+      rescue Exception => e
+        dputs(0) { "Error: couldn't save newly created data #{self.class.name}" }
+        dputs(0) { "#{e.inspect}" }
+        dputs(0) { "#{e.to_s}" }
+        puts e.backtrace
+      end
+    }
+  end
+
+  # Restores somewhat sane directory with all saved files in 'backup'
+  def cleanup
+    FileUtils.mkdir @csv_backup unless File.exists? @csv_backup
+    log_msg :CSV, "Cleaning up #{@csv_file}"
+    Dir.glob("#{@csv_file}*").each { |f|
+      time = File.mtime(f).strftime('%Y%m%d_%H%M%S')
+      FileUtils.mv f, "#{@csv_backup_file}.#{time}"
+    }
+    FileUtils.mv Dir.glob("#{@csv_backup_file}*").sort.reverse.first, @csv_file
+  end
+
+  # loads the data
+  def load
+    # Go and fetch eventual existing data from the file
+    dputs(3) { "Starting to load #{@csv_file}" }
+    @mutex.synchronize {
+      cleanup if Dir.glob("#{@csv_file}*").size > 1
+      ["#{@csv_file}"].concat(Dir.glob("#{@csv_backup_file}*").sort.reverse).each { |file|
+        next if (!File.exists?(file) || File.size(file) == 0)
+        begin
+          dputs(3) { "Loading file #{file}" }
+          data = {}
+          File.open(file, 'r').readlines().each { |l|
+            dputs(5) { "Reading line #{l}" }
+            # Convert the keys in the lines back to Symbols
+            data_parse = JSON.parse(l)
+            data_csv = {}
+            data_parse.each { |k, v|
+              data_csv.merge!({k.to_sym => v})
+            }
+            # dputs( 5 ){ "Putting #{data_csv.inspect}" }
+            did = data_csv[@data_field_id] = data_csv[@data_field_id].to_i
+            data[did] = data_csv
+          }
+          dputs(5) { "data is now #{data.inspect}" }
+          return data
+        rescue JSON::ParserError
+          log_msg :CSV, "Oups - couldn't load CSV for #{file}"
+          FileUtils.rm file
+        end
+      }
+    }
+
+    return {}
+  end
+
+  def check_login(uid, pass)
+    dputs(3) { "Searching in the CSV data" }
+    index = @entity.find_index_by(:full_name, uid)
+    if index
+      dputs(3) { "Found index #{index} with pass #{@entity.data[index][:password]}" }
+      return @entity.data[index][:password] == pass
+    end
+    dputs(3) { "Didn't find user with uid of #{uid}" }
+    return false
+  end
+
+  def delete_all(local_only = false)
+    # Making it in two steps is more secure... Luckily MacOSX doesn't mind
+    # rm -rf /*
+    # as a user ;)
+    if not local_only
+      dputs(2) { "Deleting #{@csv_dir}" }
+      FileUtils.rm Dir.glob("#{@csv_file}")
+      FileUtils.rm Dir.glob("#{@csv_backup_file}*")
+    end
+  end
+end

data/lib/qooxview/storages/ldap.rb

@@ -0,0 +1,238 @@
+require 'net/ldap'
+require 'parseconfig'
+
+class LDAP < StorageType
+  attr_accessor :data_ldap_base, :data_ldap_users
+
+  def self.get_config_file(first, second, config)
+    file = get_config(first, :LDAPConfig, config)
+    if !File.exists?(file)
+      file = second
+    end
+    if !File.exists?(file)
+      dputs(0) { "Error: Can't find #{file}" }
+      exit
+    end
+    dputs(3) { "Returning #{file} for #{first}-#{second}-#{config}" }
+    file
+  end
+
+  # Load the configuration file and set up different variables
+  # for LDAP. This has to be loaded just once
+  def configure(config)
+    dputs(2) { "Configuring LDAP: #{config.inspect}" }
+    if conf = get_config(nil, :LDAPConfig, :array)
+      @data_ldap_host, @data_ldap_base, @data_ldap_root, @data_ldap_users,
+          @data_ldap_pass = conf
+    else
+      file_conf = LDAP.get_config_file('ldapscripts.conf',
+                                       '/etc/ldapscripts/ldapscripts.conf', :ldapscripts)
+      ldap_config = ParseConfig.new(file_conf)
+      dputs(2) { "Configuration options are #{ldap_config.get_params.inspect}" }
+      @data_ldap_host, @data_ldap_base, @data_ldap_root, @data_ldap_users =
+          ldap_config.params['SERVER'], ldap_config.params['SUFFIX'], ldap_config.params['BINDDN'],
+              ldap_config.params['USUFFIX']
+
+      file_pass = LDAP.get_config_file('ldap.secret', '/etc/ldap.secret',
+                                       :ldapsecret)
+      @data_ldap_pass = `cat #{ file_pass }`
+    end
+    @data_ldap_users += ",#{@data_ldap_base}"
+    %w( host base root pass users ).each { |v| eval("dputs( 3 ){ @data_ldap_#{v}.to_s}") }
+
+    @data_ldap = Net::LDAP.new :host => @data_ldap_host,
+                               :auth => {
+                                   :method => :simple,
+                                   :username => @data_ldap_root,
+                                   :password => @data_ldap_pass
+                               }
+
+    # Don't cache data, always ask
+    @data_cache = false
+
+    super config
+
+    @dns = {}
+  end
+
+  def save(data, notmp: false)
+    dputs(3) { 'Everything should already be saved...' }
+  end
+
+  def load
+    data = {}
+    # Read in the entries from the LDAP-directory
+    dputs(3) { 'Reading LDAP-entries' }
+    filter = Net::LDAP::Filter.eq('cn', '*')
+    @field_id_ldap = @fields[@data_field_id][:ldap_name].to_sym
+
+    dputs(3) { "Going to read #{@data_ldap_base}" }
+    @data_ldap.search(:base => @data_ldap_base, :filter => filter) do |entry|
+      dputs(4) { "DN: #{entry.dn}" }
+      data_ldap = {}
+      if entry.respond_to? @field_id_ldap
+        field_id_value = entry[@field_id_ldap].to_s
+        data_ldap = {@data_field_id => field_id_value}
+        @fields.each { |k, v|
+          ln = v[:ldap_name]
+          if entry.respond_to? ln.to_sym
+            value = entry[ln.to_sym][0].to_s
+            dputs(4) { "Value is #{value.inspect} with encoding #{value.encoding}" }
+            value.force_encoding(Encoding::UTF_8)
+            #if entry.dn =~ /kaina/
+            #  dputs( 0 ){ entry.inspect }
+            #  dputs( 0 ){ data_ldap.inspect }
+            #end
+            if ln.to_sym == :givenname or ln.to_sym == :l or ln.to_sym == :sn
+              dputs(4) { "Responding to #{[k, v, value, value.class].inspect} - " +
+                  "encoding is #{value.encoding}" }
+            end
+            if value[0..0] == '['
+              # dputs( 4 ){ "Parsing value #{value}" }
+              value = JSON.parse(value)
+              if ln.to_sym == :givenname or ln.to_sym == :l or ln.to_sym == :sn
+                dputs(4) { "Parsing to #{[k, v, value, value.class].inspect}" }
+              end
+              #if value.class == String
+              #  value.force_encoding( Encoding::UTF_8 )
+              #end
+            end
+            data_ldap.merge!({k => value})
+          end
+        }
+        # We hold a hash of all id_values to dn-entries for later use
+        if entry.respond_to? :dn
+          fiv = field_id_value.gsub(/[\[\]]/, '').to_i
+          @dns[fiv] = entry[:dn][0]
+          dputs(4) { "Adding dn-entry #{entry[:dn][0]} with id #{fiv.inspect}" }
+        end
+      else
+        dputs(4) { "Field-id #{@field_id_ldap} not found. List of ids: #{entry.attribute_names.inspect}" }
+      end
+      # Often needed to check one entry...
+      #if entry.dn =~ /mahamouth/
+      #  dputs( 0 ){ entry.inspect }
+      #  dputs( 0 ){ data_ldap.inspect }
+      #end
+      if data_ldap
+        data_ldap[@data_field_id] = data_ldap[@data_field_id].to_i
+        data[data_ldap[@data_field_id]] = data_ldap
+      end
+    end
+    dputs(5) { data.inspect }
+    return data
+  end
+
+  def check_login(uid, pass)
+    ldap = Net::LDAP.new
+    ldap.host = @data_ldap_host
+    ldap.auth "uid=#{uid},#{@data_ldap_users}", pass
+    dputs(2) { ldap.inspect }
+    begin
+      return ldap.bind
+    rescue Net::LDAP::LdapError
+      return nil
+    end
+  end
+
+  # Searches for the field in the LDAP-entry, changes it and returns the new
+  # value (which might not be what you expected).
+  def set_entry(id, field, value)
+    dputs(3) { "Fields is #{@fields.inspect}" }
+    attribute = @fields[field.to_sym][:ldap_name]
+    if not attribute
+      return value
+    end
+    dn = @dns[id.to_i]
+
+    value_stored = value.class == Array ? value.to_json : value
+    dputs(3) { 'Replacing attribute in ' +
+        "#{[@data_ldap_pass, dn, attribute, field, value, value_stored].inspect}" }
+
+    if not dn
+      dputs(0) { "Error: DN is empty... #{@dns.to_a.last(10).inspect}" }
+      dputs(0) { "Error: DN is empty: id, field, value = #{id}, #{field}, #{value}" }
+      #return
+    end
+
+    ret = @data_ldap.replace_attribute(dn, attribute, value_stored.to_s)
+    dputs(3) { "Replaced #{attribute} in #{dn} with #{value}" }
+    dputs(3) { "State of LDAP is: #{@data_ldap.get_operation_result.message} - #{ret.inspect}" }
+    @data_ldap.search(:base => @data_ldap_base,
+                      :filter => Net::LDAP::Filter.eq(@field_id_ldap.to_s, id.to_s)) do |entry|
+      dputs(3) { "Found entry: #{entry.inspect}" }
+      value_entry = entry[attribute][0].to_s
+      value_entry.force_encoding(Encoding::UTF_8)
+      if value_stored.to_s == value_entry
+        dputs(4) { "returning value #{value.inspect}" }
+        return value
+      else
+        dputs(0) { "Error: Didn't get right return value: #{value_entry.inspect} instead of #{value_stored.inspect}" }
+      end
+    end
+    return nil
+  end
+
+  def get_entry(id, field)
+    ret = nil
+    attribute = @fields[field.to_sym][:ldap_name]
+    filter = Net::LDAP::Filter.eq(@field_id_ldap.to_s, id.to_s)
+
+    @data_ldap.search(:base => @data_ldap_base,
+                      :filter => filter) { |entry|
+      dputs(5) { "DN: #{entry.dn} - #{attribute}" }
+      if entry.respond_to? attribute
+        ret = entry[attribute][0]
+        if ret.class == Net::BER::BerIdentifiedString and ret[0..0] == '['
+          dputs(4) { "Parsing value #{ret}" }
+          ret = JSON.parse(ret)
+        else
+          ret = ret.to_s
+          # Keep integers as integers
+          if ret.to_i.to_s == ret
+            ret = ret.to_i
+          end
+        end
+      end
+    }
+
+    dputs(5) { ret.inspect }
+    return ret
+  end
+
+  # If our @entity has a "data_create"-method, it is called, and then the
+  # object is extracted from the LDAP-tree.
+  def data_create(data)
+    if @entity.respond_to? :data_create
+      dputs(2) { "Going to call data_create of #{@name}" }
+      @entity.data_create(data)
+      uid = @fields.select { |k, v|
+        dputs(3) { "Field is #{k.inspect} - #{v.inspect}" }
+        v and (v[:ldap_name].to_sym == :uid)
+      }
+      dputs(3) { "Found uid #{uid.inspect}" }
+      uid = uid.to_a[0][0]
+      dputs(2) { "Found uid to be field #{uid.inspect}: #{data[uid]}" }
+      filter = Net::LDAP::Filter.eq('uid', data[uid])
+      @field_id_ldap = @fields[@data_field_id][:ldap_name].to_sym
+
+      dputs(3) { "Going to read #{@data_ldap_base}" }
+      @data_ldap.search(:base => @data_ldap_base, :filter => filter) do |entry|
+        dputs(4) { "DN: #{entry.dn}" }
+        if entry.respond_to? @field_id_ldap
+          ldap_id = entry[@field_id_ldap].to_s.gsub(/[^0-9]/, '')
+          dputs(2) { "Found #{@field_id_ldap}, getting real value of " +
+              "#{ldap_id}" }
+          id = ldap_id.to_i
+          data[@data_field_id] = id
+          @dns[id] = entry.dn.to_s
+          dputs(2) { "Found id=#{id} and dn=#{entry.dn.to_s}" }
+        end
+      end
+    else
+      dputs(0) { "Error: LDAP can't create data on it's own! Needs #{@name}.data_create!" }
+      exit 0
+    end
+    dputs(2) { "Data is now #{data.inspect}" }
+  end
+end

data/lib/qooxview/storages/sqlite.rb

@@ -0,0 +1,198 @@
+=begin
+SQLite-handler for Storagetypes. All data is stored in a common database,
+and different subclasses get different tables.
+
+Creation of table-columns is handled here
+=end
+
+require 'active_record'
+require 'active_record/base'
+require 'logger'
+
+
+class SQLite < StorageType
+  attr :db_class
+
+  def configure(config, name_base = 'stsql', name_file = 'sql.db')
+    dputs(2) { "Configuring SQLite with #{@name}" }
+    @db_table = "#{name_base}_#{@name.downcase}s"
+    @db_class_name = "#{name_base.capitalize}_#{@name.downcase}"
+    @db_class = nil
+    %x[ mkdir -p data ]
+    @name_file = name_file
+    #    ActiveRecord::Base.logger = Logger.new('debug.log')
+    ActiveRecord::Migration.verbose = false
+    #ActiveRecord::Base.logger = Logger.new(STDERR)
+
+    @mutex_es = Mutex.new
+
+    dputs(4) { 'Opening database' }
+    open_db
+
+    super config
+  end
+
+  # Allows for debugging when wanting to load another db
+  def close_db
+    dputs(4){"Closing db #{@name_file}"}
+    ActiveRecord::Base.remove_connection
+  end
+
+  def open_db
+    @mutex_es.synchronize {
+      dputs(4) { "Opening connection to #{@name_file}" }
+      ActiveRecord::Base.establish_connection(
+          :adapter => 'sqlite3', :database => "data/#{@name_file}")
+
+      dputs(4) { 'Initializing tables' }
+      init_table
+
+      dputs(4) { 'Getting Base' }
+      eval("class #{@db_class_name} < ActiveRecord::Base; end")
+      @db_class = eval(@db_class_name)
+      dputs(4) { "db_class is #{db_class.inspect}" }
+
+      @entries = {}
+      @entries_save = {}
+    }
+  end
+
+  # Saves the data stored, optionally takes an index to say
+  # which data needs to be saved
+  def save(data, notmp: false)
+    @mutex_es.synchronize {
+      dputs(3) { "Saving #{@entries_save.count} entries in #{@db_class}" }
+      @entries_save.each_value { |v|
+        v.save
+      }
+      @entries_save = {}
+    }
+  end
+
+  def set_entry(data, field, value)
+    @mutex_es.synchronize {
+      dputs(5) { "Searching id #{data.inspect}" }
+      if @entries[data]
+        @entries[data].save
+      end
+      @entries[data] ||= @db_class.first(:conditions => {@data_field_id => data})
+      if entry = @entries[data]
+        entry.send("#{field}=", value)
+        @entries_save[data] = entry
+        return value
+      else
+        dputs(2) { "Didn't find id #{data.inspect}" }
+        return nil
+      end
+    }
+  end
+
+  # Each new entry is directly stored, helping somewhat if the program or the
+  # computer crashes
+  def data_create(data)
+    dputs(5) { "Creating early data #{data.inspect} with #{data.class}" }
+    dputs(5) { "hello for #{data.inspect}" }
+    dputs(5) { "db_class is #{@db_class.inspect}" }
+    e = @db_class.create(data)
+    dputs(5) { 'hello - 2' }
+    new_id = e.attributes[@data_field_id.to_s]
+    dputs(5) { "New id is #{new_id}" }
+    data[@data_field_id] = new_id
+    dputs(5) { "Creating data: #{e.inspect}" }
+  end
+
+  def init_table
+    db_table, fields = @db_table, @fields
+    dputs(3) { "Initializing #{@db_class_name} with db_table=#{db_table.inspect}" }
+    ActiveRecord::Schema.define do
+      new_table = false
+      if !table_exists? db_table
+        dputs(2) { "Creating table #{db_table}" }
+        create_table db_table
+        new_table = true
+      end
+      dputs(3) { "Fields is #{fields.inspect}" }
+      fields.each_key { |f|
+        dputs(3) { "Checking for field #{f} in table #{db_table}" }
+        if not columns(db_table).index { |c|
+          c.name.to_s == f.to_s }
+          dputs(new_table ? 4 : 1) { "Adding column #{f} of type " +
+              "#{fields[f][:dtype]} to table #{db_table}" }
+          case fields[f][:dtype]
+            when /int/, /entity/
+              add_column(db_table, f, :integer)
+            when /bool/
+              add_column(db_table, f, :boolean)
+            when /float/
+              add_column(db_table, f, :float)
+            else
+              add_column(db_table, f, :string)
+          end
+        end
+      }
+    end
+    #    ActiveRecord::Base.logger = nil
+  end
+
+  # loads the data
+  def load
+    dputs(2) { "Loading data for #{@db_class_name}" }
+    res = Hash[*@db_class.all.collect { |s|
+                 @entries[s[@data_field_id]] = s
+                 [s[@data_field_id].to_i, s.attributes.symbolize_keys]
+               }.flatten(1)
+    ]
+    dputs(5) { "Result is: #{res.inspect}" }
+    return res
+  end
+
+  def delete_all(local_only = false)
+    if !local_only
+      db_table = @db_table
+      dputs(2) { "Deleting table #{db_table}" }
+      ActiveRecord::Schema.define do
+        if table_exists? db_table
+          drop_table db_table.to_sym
+        end
+      end
+      init_table
+    end
+  end
+
+  def self.with_all_sqlites
+    RPCQooxdooService.entities { |e|
+      e.storage.each { |storage_name, storage_class|
+        dputs(3) { "Found storage_name of #{storage_name.inspect}" }
+        if storage_name.to_s =~ /^SQLite/
+          dputs(3) { "Found #{e.name}::#{storage_name} as SQLite-something" }
+          yield storage_class
+        end
+      }
+    }
+  end
+
+  def self.dbs_close_all
+    dputs(2) { 'Closing all dbs' }
+    SQLite.with_all_sqlites { |sql|
+      sql.close_db
+    }
+  end
+
+  def self.dbs_open_load
+    dputs(2) { 'Opening all dbs' }
+    SQLite.with_all_sqlites { |sql|
+      sql.open_db
+    }
+    dputs(2) { 'Loading all dbs' }
+    RPCQooxdooService.entities { |e|
+      e.is_loaded = false
+      e.load
+    }
+  end
+
+  def self.dbs_open_load_migrate
+    SQLite.dbs_open_load
+    dputs(2) { 'Migrating all dbs' }
+    RPCQooxdooService.migrate_all
+  end
+end