jgrouper 0.0.5 → 0.1.0

data/lib/jgrouper/audit_archiver.rb

@@ -0,0 +1,330 @@
+require 'csv'
+require 'date'
+
+module JGrouper # :nodoc:
+  #
+  # = JGrouper::AuditArchiver - Archive Grouper audit log entries
+  #
+  # == USAGE
+  #
+  #   require 'jgrouper'
+  #   require 'jgrouper/audit_archiver'
+  #
+  #   JGrouper::AuditArchiver.new { |archiver| archiver.archive }
+  #
+  class AuditArchiver
+
+    GROUPER_AUDIT_ENTRY = 'grouper_audit_entry' 
+    GROUPER_AUDIT_TYPE  = 'grouper_audit_type'
+
+    attr_writer :directory, :skip_columns, :verbose
+
+    def initialize
+      @config       = {}
+      @conn         = nil
+      @directory    = Dir.pwd
+      @fh           = nil
+      @mappings     = {}
+      @skip_columns = []
+      @start, @stop = Time.at(0), Time.at(0)
+      @date         = nil
+      @verbose      = false
+      yield self if block_given?
+      self
+    end
+
+    #
+    # Archive oldest date from 'grouper_audit_entry' table to file.
+    #
+    def archive
+      entries = []
+
+      log 'starting ...'
+
+      connect do
+        mappings do
+          start_at = time_to_microseconds @start
+          stop_at  = time_to_microseconds @stop
+
+          filehandle @directory, "grouper-audit-entries-#{ @date }.csv" do
+            log "archiving #{ @date } ..."
+
+            # TODO Extract!
+            # TODO Use prepared statement when I get JRuby, JDBC & Oracle to better cooperate on BigDecimal-ish data types
+            qry      = "SELECT * FROM #{GROUPER_AUDIT_ENTRY} WHERE created_on BETWEEN #{start_at} AND #{stop_at} ORDER BY created_on"
+            stmt     = @conn.create_statement
+            rs       = stmt.execute_query qry
+            md       = rs.meta_data
+            num_cols = md.column_count
+            while rs.next
+              entry = []
+              1.upto(num_cols) do |n|
+                k = md.column_name(n).downcase.to_sym
+                v = rs.get_object(n)
+
+                next if v.nil?
+                entry << k << v.to_s.gsub(/\n/, ', ')
+              end
+
+              entry = transform(entry)
+              entries << entry.each_slice(2).reject { |slice| skip? slice.first }.collect { |slice| "#{slice.first}=#{slice.last}" }
+
+              @fh.puts CSV.generate_line( entries.last, col_sep: "\t" )
+              yield entries.last if block_given?
+            end
+            rs.close
+            stmt.close
+            
+            log "archiving #{ @date } (#{entries.size} entries) - done"
+          end
+
+          prune(entries.size, start_at, stop_at) unless entries.empty?
+        end
+      end
+
+      log 'done'
+
+      entries
+    end
+
+
+    private
+
+      #
+      # Extract Grouper Hibernate configuration parameters
+      #
+      def configure
+        java_import edu.internet2.middleware.grouper.internal.dao.hibernate.HibernateDaoConfig
+        cfg = HibernateDaoConfig.new
+        %w( driver_class url username password autocommit ).each do |p|
+          k = "hibernate.connection.#{p}"
+          v = cfg.get_property k
+
+          if 'password' == p && File.exist?(v)
+            java_import edu.internet2.middleware.morphString.Morph
+            v = Morph.decryptIfFile(v)
+          end
+
+          @config[ p.to_sym ] = v
+        end
+        yield self
+      end
+
+      #
+      # Connect to Grouper database
+      #
+      def connect
+        configure do
+
+          java_import java.sql.DriverManager
+          java_import @config[:driver_class]
+
+          @conn  = DriverManager.get_connection @config[:url], @config[:username], @config[:password] 
+          @conn.auto_commit = false
+          @date  = oldest_entry unless @date  # Date of oldest entry
+          @start = @date.to_time              # Start-of-day on @date
+          @stop  = ( @date + 1 ).to_time - 1  # End-of-day on @date
+          yield self if block_given?
+          @conn.close
+
+        end
+      end
+
+      #
+      # Open filehandle for writing or raise exception if a) directory does not exist or b) file does exist.
+      # TODO DRY
+      #
+      def filehandle(directory, file)
+        raise "ERROR: directory does not exist - #{directory}" unless File.directory?(directory)
+        fn = File.join directory, file
+        raise "ERROR: file already exists - #{fn}" if File.exists?(fn)
+        File.open(fn, 'w') { |fh| @fh = fh ; yield self ; @fh = nil }
+      end
+
+      # TODO Use Logger...
+      # TODO DRY
+      def log(msg)
+        puts "#{ File.basename(__FILE__) } #{ Time.now.to_datetime.rfc3339 } - #{msg}" if verbose?
+      end
+
+      #
+      # Fetch audit type mappings.
+      #
+      def mappings
+        stmt     = @conn.create_statement
+        rs       = stmt.execute_query "SELECT * FROM #{GROUPER_AUDIT_TYPE}"
+        md       = rs.meta_data
+        num_cols = md.column_count
+
+        while rs.next
+          tmp = {}
+          1.upto(num_cols) do |n|
+            k = md.column_name(n).downcase.to_sym
+            case k
+            when :created_on, :last_updated
+              v = microseconds_to_rfc3399 rs.float(n)
+            else
+              v = rs.get_object(n)
+            end
+            next if v.nil?
+            tmp[k] = v.nil? ? v : v.to_s
+          end
+          @mappings[ tmp[:id] ] = tmp unless tmp.empty?
+        end
+
+        rs.close
+        stmt.close
+
+        yield self
+      end
+
+      #
+      # Convert microseconds to RFC3399 formatted timestamp.
+      #
+      def microseconds_to_rfc3399(microseconds)
+        Time.at( microseconds_to_seconds( microseconds.to_i ) ).to_datetime.rfc3339
+      end
+
+      #
+      # Convert microseconds to seconds.
+      #
+      def microseconds_to_seconds(microseconds)
+        microseconds / 1000
+      end
+
+      #
+      # Return number of entries for time interval.
+      #
+      def num_entries(start_at, stop_at)
+        num_entries = 0
+        
+        stmt = @conn.create_statement
+        rs   = stmt.execute_query "SELECT COUNT(*) FROM #{GROUPER_AUDIT_ENTRY} WHERE created_on BETWEEN #{start_at} AND #{stop_at}"
+        while rs.next
+          num_entries = rs.get_object(1).to_s.to_i # TODO Ugly
+          break
+        end
+        rs.close
+        stmt.close
+
+        return num_entries
+      end
+
+      #
+      # Calculate archive date based on MIN(created_on)
+      #
+      def oldest_entry
+        d = Date.new
+
+        stmt = @conn.create_statement
+        rs   = stmt.execute_query "SELECT MIN(created_on) FROM #{GROUPER_AUDIT_ENTRY}"
+        while rs.next
+          # Microseconds -> Seconds -> Time -> Date
+          d = Time.at( microseconds_to_seconds( rs.float(1) ) ).to_date
+          break
+        end
+        rs.close
+        stmt.close
+
+        d
+      end
+
+      #
+      # Prune entries from database.
+      #
+      def prune(expected, start_at, stop_at)
+        log "pruning #{ @date } (#{expected} entries) ..."
+
+        found = num_entries start_at, stop_at
+        if expected == found
+
+          @conn.auto_commit = false
+          qry  = "DELETE FROM #{GROUPER_AUDIT_ENTRY} WHERE created_on BETWEEN #{start_at} AND #{stop_at}" 
+          stmt = @conn.create_statement
+          rv   = stmt.execute_update qry
+          if expected == rv
+            @conn.commit
+            log "pruning #{ @date } (#{rv} entries) - done"
+          end
+          stmt.close
+          unless expected == rv
+            raise "ERROR: not committing delete as number of deleted entries does not match expected number - #{rv} != #{expected}"
+          end
+        else
+          raise "ERROR: not deleting as number of found entries does not match expected number - #{found} != #{expected}"
+        end
+      end
+
+      #
+      # Omit column from export?
+      #
+      def skip?(name)
+        @skip_columns.include? name
+      end
+
+      #
+      # Convert time to microseconds
+      #
+      def time_to_microseconds(time)
+        time.to_i * 1000
+      end
+
+      #
+      # Perhaps basic data transformations to make audit entry more readable.
+      #
+      def transform(entry)
+        # TODO Better validation & error handling
+        idx = entry.index(:audit_type_id)
+
+        if idx
+          type = @mappings[ entry[ idx + 1 ] ]
+          if type && type[:audit_category] && type[:action_name]
+            # TODO Or just replace :audit_type_id entirely?
+            entry.insert idx + 2, :audit_category
+            entry.insert idx + 3, type[:audit_category]
+            entry.insert idx + 4, :action_name
+            entry.insert idx + 5, type[:action_name]
+          end
+        end
+
+        entry.each_with_index do |v, idx|
+          if idx.even?
+            case v
+            when :created_on, :last_updated
+              entry[ idx + 1 ] = microseconds_to_rfc3399 entry[ idx + 1 ]
+            when :logged_in_member_id
+              entry[ idx + 1 ] = transform_member_uuid entry[ idx + 1 ]
+            else
+              label_key = "label_#{v}".to_sym
+              if type.include? label_key
+                entry[idx] = "#{v}:#{ type[label_key] }"
+                case type[label_key]
+                when 'memberId'
+                  entry[ idx + 1 ] = transform_member_uuid entry[ idx + 1 ]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      #
+      # Transform Grouper member UUID into something more useful.
+      #
+      def transform_member_uuid(uuid)
+        m = JGrouper::Member.find uuid
+        return uuid if m.nil?
+        return "#{uuid} (source=#{ m.subject_source_id } id=#{ m.subject_id } type=#{ m.subject_type })"
+      end
+
+      #
+      # Are we verbose?
+      #
+      def verbose?
+        @verbose
+      end
+
+  end
+end
+
+

data/lib/jgrouper/exporter.rb

@@ -0,0 +1,85 @@
+require 'csv'
+
+module JGrouper # :nodoc:
+  #
+  # = JGrouper::Exporter - Export (some of the) Groups registry to CSV
+  #
+  # == USAGE
+  #
+  #   require 'jgrouper'
+  #   require 'jgrouper/exporter'
+  #
+  #   JGrouper::Exporter do |exporter|
+  #     exporter.export 'stem:to:export'
+  #   end
+  #
+  class Exporter
+
+    attr_writer :verbose
+
+    def initialize
+      @directory    = Dir.pwd
+      @fh           = nil
+      @verbose      = false
+      yield self if block_given?
+      self
+    end
+
+    #
+    # Export (some of the) Groups registry to CSV.
+    #
+    def export( base = nil )
+      entries = []
+
+      filehandle @directory, "jgrouper-export.csv" do
+        stem = base.nil? ? Stem.root : Stem.find(base)
+        raise "ERROR: stem not found" if stem.nil?
+        log "exporting stem=#{stem.name} ..."
+
+        raise "NOT IMPLEMENTED - exporting child stems" if stem.stems.size > 0
+
+        groups = stem.groups do |child|
+          g  =  %w( display_extension extension name ).collect { |k| child.send(k) }
+          g  << CSV.generate_line( child.members.collect { |m| "#{ m.subject_source_id }|#{ m.subject_type_id }|#{ m.subject_id }" } ).chomp
+
+          entries << CSV.generate_line(g)
+          @fh.puts entries.last
+          yield entries.last if block_given?
+        end
+
+        log "exporting stem=#{stem.name} - done"
+      end
+
+      entries
+    end
+
+
+    private
+
+      #
+      # Open filehandle for writing or raise exception if a) directory does not exist or b) file does exist.
+      # TODO DRY
+      #
+      def filehandle(directory, file)
+        raise "ERROR: directory does not exist - #{directory}" unless File.directory?(directory)
+        fn = File.join directory, file
+        raise "ERROR: file already exists - #{fn}" if File.exists?(fn)
+        File.open(fn, 'w') { |fh| @fh = fh ; yield self ; @fh = nil }
+      end
+
+      # TODO Use Logger...
+      # TODO DRY
+      def log(msg)
+        puts "#{ File.basename(__FILE__) } #{ Time.now.to_datetime.rfc3339 } - #{msg}" if verbose?
+      end
+
+      #
+      # Are we verbose?
+      #
+      def verbose?
+        @verbose
+      end
+
+  end
+end
+

data/lib/jgrouper/group.rb

@@ -1,116 +1,40 @@
+require 'csv'
+
 module JGrouper # :nodoc:
+
+  #
+  # = JGrouper::Group - Grouper Group
+  #
+  # == Usage
+  #
+  #   require 'jgrouper'
   #
-  # = JGrouper::Group - A Grouper group
+  #   TODO
   #
   class Group
 
-    attr_reader :display_extension, :display_name, :extension, :name, :types, :uuid
-
-
-    def initialize
-      @grouper_group = nil
+    def initialize( obj = nil )
+      @obj = obj
       yield self if block_given?
       self
     end
 
     #
-    # Add group type.  Returns +true+ if type added or group already has type.
-    #
-    #   group.add_type 'group type'
-    #
-    def add_type(name)
-      return true  if types.include? name
-      t = Java::EduInternet2MiddlewareGrouper::GroupTypeFinder.find name, false
-      return false unless t
-      @grouper_group.add_type t
-      true
-    end
-
-    #
-    # Delete group type.  Returns +true+ if type deleted or group does not have type.
-    #
-    #   group.delete_type 'group type'
-    #
-    def delete_type(name)
-      t = Java::EduInternet2MiddlewareGrouper::GroupTypeFinder.find name, false
-      return false unless t
-      return true  unless types.include? name
-      @grouper_group.delete_type t
-      true
-    end
-
-    #
-    # Find group by name or returns +nil+.
+    # For passing methods on to Grouper Group object.
     #
-    #   group = JGrouper::Group.find(name)
-    #   
-    def self.find(name)
-      group = from_grouper GroupFinder.findByName( GrouperSession.startRootSession, name, false ) # How to handle sessions?
-      yield group if block_given?
-      group
-    end
-
-    #
-    # Generate JGrouper::Group instance from JSON by calling +JSON.parse(json_string)+
-    # 
-    def self.json_create(json)
-      new do |group|
-        group.instance_variable_set :@display_extension, json['display_extension']
-        group.instance_variable_set :@display_name,      json['display_name']
-        group.instance_variable_set :@extension,         json['extension']
-        group.instance_variable_set :@name,              json['name']
-        group.instance_variable_set :@types,             json['types']
-        group.instance_variable_set :@uuid,              json['uuid']
-      end
-    end
-
     def method_missing(meth, *args, &block)
+      super if @obj.nil?
       begin
-        warn "METHOD_MISSING: meth=#{ meth } args=#{ args }"
-        block.call @grouper_group.send(meth, *args) if block
-        @grouper_group.send(meth, *args)
+        block.call @obj.send(meth, *args) if block
+        @obj.send(meth, *args)
       rescue NoMethodError
         super
       end
     end
 
-    #
-    # Return JSON representation of JGrouper::Group instance.
-    #
-    def to_json
-      {
-        :json_class        => self.class.name,
-        :display_extension => self.display_extension,
-        :display_name      => self.display_name,
-        :extension         => self.extension,
-        :name              => self.name,
-        :types             => self.types,
-        :uuid              => self.uuid
-      }.to_json
-    end
-
-    #
-    # Return String representation of JGrouper::Group instance.
-    #
     def to_s
-      %w( name display_name uuid ).collect { |k| "#{k}=#{ self.send(k) }" }.join(' | ') + " | types=#{ types.join(',') }"
-    end
-
-
-    private
-
-    def self.from_grouper(grouper)
-      return nil if grouper.nil?
-      new do |group|
-        group.instance_variable_set :@grouper_group,     grouper
-        group.instance_variable_set :@display_extension, grouper.getDisplayExtension
-        group.instance_variable_set :@display_name,      grouper.getDisplayName
-        group.instance_variable_set :@extension,         grouper.getExtension
-        group.instance_variable_set :@name,              grouper.getName
-        # TODO Testing hack
-        group.instance_variable_set :@types,             grouper.getTypes.collect { |t| t.kind_of?(String) ? t : t.getName }
-        group.instance_variable_set :@uuid,              grouper.getUuid
-      end
+      return nil if @obj.nil?
+      CSV.generate_line %w( name display_name uuid ).collect { |k| "#{k}=#{ self.send(k) }" }
     end
 
   end

data/lib/jgrouper/member.rb

@@ -0,0 +1,47 @@
+module JGrouper # :nodoc:
+
+  #
+  # = JGrouper::Member - Grouper Member
+  #
+  # == Usage
+  #
+  #   require 'jgrouper'
+  #
+  #   m = JGrouper::Member.find uuid
+  #
+  class Member
+
+    # TODO
+    def initialize( obj = nil )
+      @obj = obj
+      yield self if block_given?
+      self
+    end
+
+    #
+    # Find Grouper member by UUID.  Returns +JGrouper::Member+ or +nil+.
+    #
+    def self.find(uuid)
+      m = MemberFinder.find_by_uuid GrouperSession.start_root_session, uuid, false
+      return nil if m.nil?
+      member = self.new m
+      yield member if block_given?
+      member
+    end
+
+    #
+    # For passing methods on to Grouper member object.
+    #
+    def method_missing(meth, *args, &block)
+      super if @obj.nil?
+      begin
+        block.call @obj.send(meth, *args) if block
+        @obj.send(meth, *args)
+      rescue NoMethodError
+        super
+      end
+    end
+
+  end
+end
+