goz 0.0.3 → 0.1.0

data/lib/goz/group/base.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'goz/group'
+require 'goz/logger'
+
+
+module  Goz   # :nodoc:
+  class Group # :nodoc:
+ 
+    # 
+    # = Goz::Group::Base - TODO
+    #   
+    # == Usage
+    #
+    # TODO
+    #  
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class Base
+
+      TAG = self.name
+
+      attr_accessor :display_name, :identifier, :klass, :name
+
+      @@cf = {}
+
+
+      #
+      # TODO 
+      #
+      def [](key)
+        send key.to_sym
+      end
+
+      #
+      # Set configuration.
+      #
+      def self.configuration(configuration)
+        @@cf = configuration
+      end
+
+      #
+      # Find Goz::Group by name or return +nil+
+      #
+      # MUST be implemented by API extensions.
+      #
+      def self.find_by_name(name)
+        raise RuntimeError, "not implemented"
+      end
+
+      #
+      # TODO
+      #
+      # MUST be implemented by API extensions.
+      #
+      def admins()
+        raise RuntimeError, "not implemented"
+      end
+
+      #
+      # TODO
+      #
+      # MUST be implemented by API extensions.
+      #
+      def members()
+        raise RuntimeError, "not implemented"
+      end
+
+      #
+      # Return groups where +user+ is an admin.
+      #
+      # MUST be implemented by API extensions.
+      #
+      def self.groups(user)
+        raise RuntimeError, "not implemented"
+      end
+
+      #
+      # Return groups where +user+ is a member.
+      #
+      # MUST be implemented by API extensions.
+      #
+      def self.memberships(user)
+        raise RuntimeError, "not implemented"
+      end
+
+      #
+      # Convert to Goz::Group-style hash
+      #
+      def to_hash
+        return { :display_name => self.display_name,
+                 :identifier   => self.identifier,
+                 :klass        => self.klass,
+                 :name         => self.name
+               }
+      end
+
+      #
+      # TODO
+      # 
+      def to_s
+        "display_name=#{display_name} | identifier=#{identifier} | klass=#{klass} | name=#{name}"
+      end
+
+    end
+
+  end
+end
+

data/lib/goz/group/etc_group.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require 'etc'
+require 'goz/group/base'
+
+
+module  Goz   # :nodoc:
+  class Group # :nodoc:
+ 
+    # 
+    # = Goz::Group::EtcGroup - +/etc/group+ derived users (mostly for testing)
+    #   
+    # == Usage
+    #
+    # TODO
+    #  
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class EtcGroup < Goz::Group::Base
+
+      TAG = self.name
+
+
+      def initialize(g)
+        @display_name = g[:name]
+        @identifier   = g[:gid]
+        @klass        = self.class.name
+        @name         = g[:name]
+      end
+
+
+      #
+      # Find Goz::Group by name or return +nil+
+      #
+      def self.find_by_name(name)
+        Goz::Logger.debug TAG, "find_by_name( name=#{name} )"
+        begin
+          return self.new( Etc.getgrnam(name) )
+        rescue ArgumentError => e
+          Goz::Logger.warn TAG, "find_by_name( name=#{name} ) - not found"
+        end
+        nil
+      end
+
+      #
+      # TODO
+      #
+      def admins()
+        Goz::Logger.debug TAG, "name=#{self.name} - #admins()"
+        users = []
+        g = Etc.getgrnam self.name
+        return users if g.nil?
+        # XXX ???
+        users
+      end
+
+      #
+      # TODO
+      #
+      def members()
+        Goz::Logger.debug TAG, "#{self.name} - #members()"
+        users = []
+        g = Etc.getgrnam self.name
+        return users if g.nil?
+        users = g[:mem].collect { |m| Goz::User.find_by_login m }
+        users.delete_if { |_| _.nil? }
+        users
+      end
+
+      #
+      # Return groups where +user+ is an admin.
+      #
+      def self.groups(user)
+        Goz::Logger.debug TAG, "groups( user.login=#{user.login} )"
+        groups = []
+        return groups if user.nil? || user.identifier.nil? || user.name.nil?
+        loop do
+          g = Etc.getgrent
+          break if g.nil?
+          groups << self.new(g) if ( '0' === user.identifier || ( g[:gid].to_s === user.identifier && g[:name] == user.login ) )
+        end
+        Etc.endgrent
+        return groups
+      end
+
+      #
+      # Return groups where +user+ is a member.
+      #
+      def self.memberships(user)
+        Goz::Logger.debug TAG, "groups( user.login=#{user.login} )"
+        groups = []
+        return groups if user.nil? || user.login.nil? || user.identifier.nil?
+        loop do
+          g = Etc.getgrent
+          break if g.nil?
+          groups << self.new(g) if ( g[:mem].include?(user.login) || ( g[:gid].to_s == user.identifier && g[:name] == user.login ) )
+        end
+        Etc.endgrent
+        return groups
+      end
+
+    end
+
+  end
+end
+
+

data/lib/goz/group/grouper.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+require 'goz/group/base'
+require 'grouper-rest-client'
+
+
+module  Goz   # :nodoc:
+  class Group # :nodoc:
+ 
+    # 
+    # = Goz::Group::Grouper - TODO
+    #   
+    # == Usage
+    #
+    # TODO
+    #  
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class Grouper < Goz::Group::Base
+
+      TAG = self.name
+
+
+      def initialize(g)
+        @display_name = _prettify_name g['name']
+        @identifier   = g['uuid']
+        @klass        = self.class.name
+        @name         = g['name']
+      end
+
+
+      #
+      # Find Goz::Group by name or return +nil+
+      #
+      def self.find_by_name(name)
+        Goz::Logger.debug TAG, "find_by_name( name=#{name} )"
+        connect do |grouper|
+          g = grouper.group(name.rstrip) # TODO Sigh...
+          if g.nil?
+            Goz::Logger.warn TAG, "find_by_name( name=#{name} ) - not found"
+            return nil
+          end
+          group = new g
+          yield group if block_given?
+          return group
+        end
+        nil
+      end
+
+      #
+      # TODO
+      #
+      def admins()
+        Goz::Logger.debug TAG, "name=#{self.name} - #admins() - not implemented"
+        [] # TODO
+      end
+
+      #
+      # TODO
+      #
+      def self.extension(name)
+        m = name.match( /^.+:(.+)$/ )
+        m ? m[1] : nil
+      end
+
+      #
+      # TODO
+      #
+      def members()
+        Goz::Logger.debug TAG, "#{self.name} - #members()"
+        users = []
+        Goz::Group::Grouper.connect do |grouper|
+          users = grouper.group(self.name).members.collect { |m| Goz::User.find_by_identifier m['id'] }
+          users.delete_if { |_| _.nil? }
+        end
+        users.each { |u| yield u } if block_given?
+        users
+      end
+
+      #
+      # Return groups where +user+ is an admin.
+      #
+      def self.groups(user)
+        Goz::Logger.debug TAG, "groups( user.login=#{user.login} ) - not implemented"
+        []
+      end
+
+      #
+      # Return groups where +user+ is a member.
+      #
+      def self.memberships(user)
+        if user.nil?
+          Goz::Logger.warn TAG, "memberships( user=nil )"
+          return []
+        end
+        Goz::Logger.debug TAG, "memberships( user.login=#{user.login} )"
+        groups = []
+        self.connect do |grouper|
+          subject = grouper.subject user.identifier
+          if subject.nil?
+            Goz::Logger.warn TAG, "memberships( user.login=#{user.login} ) - could not find user with identifier=#{ user.identifier }"
+            break
+          end
+          groups = subject.groups( @@cf['base'] ).collect { |g| new g }
+        end
+        groups.each { |g| yield g } if block_given?
+        groups
+      end
+
+      #
+      # TODO
+      #
+      def self.stem(name)
+        m = name.match( /^(.+):.+$/ )
+        m ? m[1] : nil
+      end
+
+      #
+      # TODO
+      #
+      def self.stemmed_group?(name)
+        suffixes  = @@cf['admin_suffix'] | @@cf['member_suffix']
+        Regexp.new( "^.*?:(#{ suffixes.join('|') })$" ).match(name) ? true : false
+      end
+
+
+      private
+
+      def self.connect
+        grouper = ::Grouper::Rest::Client::Resource.new @@cf['url'],
+                                                        :user     => @@cf['user'],
+                                                        :password => @@cf['password']
+        yield grouper if block_given?
+        grouper
+      end
+
+      def _prettify_name(name)
+        return name if name.nil?
+        name.sub /^#{ @@cf['base'] }/, ''
+      end
+
+    end
+
+  end
+end
+
+

data/lib/goz/group/grouper/stemmed_groups.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+
+require 'goz/group/grouper'
+require 'grouper-rest-client'
+
+
+module    Goz     # :nodoc:
+  class   Group   # :nodoc:
+    class Grouper # :nodoc:
+ 
+      # 
+      # = Goz::Group::Grouper::StemmedGroups - TODO
+      #   
+      # == Usage
+      #
+      # TODO
+      #  
+      # == Author
+      #
+      # blair christensen. <mailto:blair.christensen@gmail.com>
+      #
+      # == Homepage
+      #
+      # https://github.com/blairc/goz/
+      #
+      class StemmedGroups < Goz::Group::Grouper
+
+        TAG = self.name
+
+
+        #
+        # TODO
+        #
+        def initialize(g)
+          super(g)
+          @klass = self.class.name
+        end
+
+        #
+        # Find Goz::Group by name or return +nil+
+        #
+        def self.find_by_name(name)
+          name.rstrip!
+          Goz::Logger.debug TAG, "find_by_name( name=#{name} )"
+          g = super(name)
+          if g.nil?
+            connect do |grouper|
+              ns = grouper.stem(name)
+              if ns.nil?
+                Goz::Logger.debug TAG, "find_by_name( name=#{name} ) - not found"
+                return nil
+              end
+              return new ns
+            end
+          end
+          nil
+        end
+
+        #
+        # TODO
+        #
+        def admins()
+          Goz::Logger.debug TAG, "name=#{self.name} - #admins()"
+          return super(self) unless stem?(self.name)
+          return super(self) if     self.class.stemmed_group?(self.name)
+          _members @@cf['admin_suffix']
+        end
+
+        #
+        # Return groups where +user+ is an admin.
+        #
+        def self.groups(user)
+          Goz::Logger.debug TAG, "groups( user.login=#{user.login} )"
+          groups = []
+          memberships(user).each do |g|
+            groups << g if stemmed_group?(g.name) && @@cf['admin_suffix'].include?( extension(g.name) )
+          end
+          groups.each { |g| yield g } if block_given?
+          groups
+        end
+
+        #
+        # TODO
+        #
+        def members()
+          Goz::Logger.debug TAG, "#{self.name} - #members()"
+          return super(self) unless stem?(self.name)
+          _members @@cf['member_suffix']
+        end
+
+        #
+        # Return groups where +user+ is a member.
+        #
+        def self.memberships(user)
+          Goz::Logger.debug TAG, "memberships( user.login=#{user.login} )"
+          groups = []
+          super(user).each do |g|
+            g.klass = self.name
+            groups << g
+            groups << find_by_name( stem(g.name) ) if stemmed_group?(g.name)
+          end
+          groups.each { |g| yield g } if block_given?
+          groups
+        end
+
+        #
+        # TODO
+        #
+        def stem?(name)
+          self.class.connect do |grouper|
+            return grouper.stem(name) ? true : false
+          end
+        end
+
+
+        private
+
+        def _members(suffixes)
+          users = []
+          self.class.connect do |grouper|
+            suffixes.each do |suffix|
+              name  = "#{self.name}:#{suffix}"
+              _     = Goz::Group.find_by_name(name)
+              next if _.nil?
+              g      = Goz::Group.find_or_create _.to_hash
+              g.members.each do |m|
+                users << m unless users.include?(m)
+              end
+            end
+          end
+          users.each { |u| yield u } if block_given?
+          users
+        end
+
+      end
+
+    end
+  end
+end
+