goz 0.0.3 → 0.1.0

data/.gitignore

@@ -2,6 +2,7 @@
 *.gem
 .bundle
 coverage/
+fake_service.yaml
 Gemfile.lock
 goz.log
 html/

data/HISTORY.rdoc

@@ -1,5 +1,11 @@
 = Goz History
 
+== YYYY-MM-DD v0.0.4
+
+* Added +Goz::Group::EtcGroup+
+* Added +Goz::User::EtcPasswd+
+* TBD
+
 == 2012-04-30 v0.0.3
 
 * Added +Goz::Database+

data/README.rdoc

@@ -2,22 +2,7 @@
   
 == Usage
 
-
-  # Cache
-  require 'goz/cache'
-  Goz::Cache.instance do |cache|
-    ... do stuff ...
-  end
-
-  # Logger
-  require 'goz/logger'
-  Goz::Logger.instance('MyApp') do |logger|
-    ... do stuff ...
-  end
-
-== See Also
-
-Goz::Cache, Goz::Group, Goz::Logger, Goz::User
+See https://github.com/blairc/goz-sinatra for an example implementation
 
 == Author
 
@@ -29,5 +14,5 @@ https://github.com/blairc/goz/
 
 == See Also
 
-https://github.com/blairc/goz-rails/
+https://github.com/blairc/goz-sinatra/, https://github.com/blairc/goz-rails/
 

data/TODO.md

@@ -0,0 +1,16 @@
+Goz To Do
+=========
+
+Goz v0.1.0
+----------
+* Release v0.1.0
+
+
+Future
+------
+* Documentation!
+* Add a real service
+* Revisit-or-remove `Goz::Cache`
+* Add support for asynchronous jobs (eg. interacting with external services)
+* Rework API definition to support multiple implementations
+

data/goz.gemspec

@@ -18,12 +18,16 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.add_runtime_dependency  'activesupport'
+  s.add_runtime_dependency  'grouper-rest-client'
+  s.add_runtime_dependency  'json'
   s.add_runtime_dependency  'sequel'
+  s.add_runtime_dependency  'sqlite3'
 
+  s.add_development_dependency  'mocha'
   s.add_development_dependency  'rake'
   s.add_development_dependency  'rdoc'
   s.add_development_dependency  'rdoc-readme',  '~> 0.1.2'
   s.add_development_dependency  'simplecov'
-  s.add_development_dependency  'sqlite3'
 end
 

data/lib/goz.rb

@@ -1,35 +1,19 @@
 # encoding: utf-8
 
-require 'goz/cache'
-require 'goz/event'
-require 'goz/event_type'
-require 'goz/group'
-require 'goz/logger'
-require 'goz/service'
-require 'goz/user'
-require 'goz/version'
+require_relative 'goz/event'
+require_relative 'goz/event_type'
+require_relative 'goz/group'
+require_relative 'goz/logger'
+require_relative 'goz/service'
+require_relative 'goz/user'
+require_relative 'goz/version'
 
 # 
 # = Goz - Generic self-service provisioning system
 #   
 # == Usage
 #
-#
-#   # Cache
-#   require 'goz/cache'
-#   Goz::Cache.instance do |cache|
-#     ... do stuff ...
-#   end
-#
-#   # Logger
-#   require 'goz/logger'
-#   Goz::Logger.instance('MyApp') do |logger|
-#     ... do stuff ...
-#   end
-#
-# == See Also
-#
-# Goz::Cache, Goz::Group, Goz::Logger, Goz::User
+# See https://github.com/blairc/goz-sinatra for an example implementation
 #
 # == Author
 #
@@ -41,7 +25,7 @@ require 'goz/version'
 #
 # == See Also
 #
-# https://github.com/blairc/goz-rails/
+# https://github.com/blairc/goz-sinatra/, https://github.com/blairc/goz-rails/
 #
 module Goz
   # Your code goes here...

data/lib/goz/database.rb

@@ -32,6 +32,8 @@ module Goz # :nodoc:
   #
   class Database
 
+    # XXX Better method for setting db url
+
     #
     # Sequel database instance
     #
@@ -39,6 +41,14 @@ module Goz # :nodoc:
     Goz::Database::Migrations.migrate!
 
 
+    # XXX http://sequel.rubyforge.org/rdoc/classes/Sequel/Model/ClassMethods.html#method-i-db-3D
+    def self.connect!(url)
+      self.send( :remove_const, :'DB' ) if self.const_defined?( :'DB' )
+      self.const_set :'DB', Sequel.connect(url)
+      Goz::Database::Migrations.migrate!
+      self.instance
+    end
+
     #
     # Get database instance
     #

data/lib/goz/database/migrations.rb

@@ -31,10 +31,11 @@ module Goz        # :nodoc:
           change do
             DB.create_table(:groups) do
               primary_key :id
-              String      :display_name,    :null => false
-              String      :identifier,      :null => false
-              String      :name,            :null => false
-              timestamp   :created_at,      :null => false
+              String      :display_name,   :null => false
+              String      :identifier,     :null => false
+              String      :klass,          :null => false
+              String      :name,           :null => false
+              timestamp   :created_at,     :null => false
               timestamp   :modified_at
               timestamp   :synchronized_at
 
@@ -49,9 +50,9 @@ module Goz        # :nodoc:
           change do
             DB.create_table(:services) do
               primary_key :id
-              String      :name,            :null => false
-              String      :klass,           :null => false
-              timestamp   :created_at,      :null => false
+              String      :name,           :null => false
+              String      :klass,          :null => false
+              timestamp   :created_at,     :null => false
               timestamp   :modified_at
               timestamp   :synchronized_at
 
@@ -68,6 +69,7 @@ module Goz        # :nodoc:
               String      :identifier,      :null => false
               String      :login,           :null => false
               String      :name,            :null => false
+              String      :klass,           :null => false
               timestamp   :created_at,      :null => false
               timestamp   :modified_at
               timestamp   :synchronized_at
@@ -126,6 +128,7 @@ module Goz        # :nodoc:
           end
         end
 
+        # TODO Consider removing?
         Sequel.migration do
           change do
             event_types = DB[:event_types]
@@ -146,15 +149,18 @@ module Goz        # :nodoc:
           change do
             DB.create_table(:events) do
               primary_key :id
-              Integer :event_type_id,   :null => false
+              String  :event_type,      :null => false
+              String  :group,           :null => true
               Integer :group_id,        :null => true
+              String  :service,         :null => true
               Integer :service_id,      :null => true
+              String  :user,            :null => true
               Integer :user_id,         :null => true
               # TODO Some sort of boolean or enum completion status?
               timestamp   :created_at,  :null => false
               # TODO Some sort of completed_at timestamp?
 
-              index :event_type_id
+              index :event_type
               index :group_id
               index :service_id
               index :user_id

data/lib/goz/event.rb

@@ -2,6 +2,9 @@
 
 require 'goz/database'
 require 'goz/event_type'
+require 'goz/group'
+require 'goz/service'
+require 'json'
 
 module Goz # :nodoc:
  
@@ -18,6 +21,9 @@ module Goz # :nodoc:
   #
   class Event < Sequel::Model
 
+    plugin :serialization, :json, :group
+    plugin :serialization, :json, :service
+    plugin :serialization, :json, :user
     plugin :validation_helpers
 
 
@@ -31,68 +37,124 @@ module Goz # :nodoc:
     end
 
     def self.admin_add(group, user)
-      self.create( :event_type_id => Goz::EventType::ADMIN_ADD, :group_id => group.id, :user_id => user.id )
+      self.create :event_type    => Goz::EventType::ADMIN_ADD,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :user          => user,
+                  :user_id       => user.id
     end
 
     def self.admin_remove(group, user)
-      self.create( :event_type_id => Goz::EventType::ADMIN_REMOVE, :group_id => group.id, :user_id => user.id )
+      self.create :event_type    => Goz::EventType::ADMIN_REMOVE,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :user          => user,
+                  :user_id       => user.id
     end
 
     def self.group_add(group)
-      self.create :event_type_id => Goz::EventType::GROUP_ADD, :group_id => group.id
+      self.create :event_type    => Goz::EventType::GROUP_ADD,
+                  :group         => group,
+                  :group_id      => group.id
     end
 
     def self.group_remove(group)
-      self.create :event_type_id => Goz::EventType::GROUP_REMOVE, :group_id => group.id
+      self.create :event_type    => Goz::EventType::GROUP_REMOVE,
+                  :group         => group,
+                  :group_id      => group.id
     end
 
     def self.group_sync(group)
-      self.create :event_type_id => Goz::EventType::GROUP_SYNC, :group_id => group.id
+      self.create :event_type    => Goz::EventType::GROUP_SYNC,
+                  :group         => group,
+                  :group_id      => group.id
     end
 
     def self.group_service_add(group, service)
-      self.create( :event_type_id => Goz::EventType::GROUP_SERVICE_ADD, :group_id => group.id, :service_id => service.id )
+      self.create :event_type    => Goz::EventType::GROUP_SERVICE_ADD,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :service       => service,
+                  :service_id    => service.id
     end
 
     def self.group_service_remove(group, service)
-      self.create( :event_type_id => Goz::EventType::GROUP_SERVICE_REMOVE, :group_id => group.id, :service_id => service.id )
+      self.create :event_type    => Goz::EventType::GROUP_SERVICE_REMOVE,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :service       => service,
+                  :service_id    => service.id
     end
 
     def self.group_service_sync(group, service)
-      self.create( :event_type_id => Goz::EventType::GROUP_SERVICE_SYNC, :group_id => group.id, :service_id => service.id )
+      self.create :event_type    => Goz::EventType::GROUP_SERVICE_SYNC,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :service       => service,
+                  :service_id    => service.id
     end
 
     def self.member_add(group, user)
-      self.create( :event_type_id => Goz::EventType::MEMBER_ADD, :group_id => group.id, :user_id => user.id )
+      self.create :event_type    => Goz::EventType::MEMBER_ADD,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :user          => user,
+                  :user_id       => user.id
     end
 
     def self.member_remove(group, user)
-      self.create( :event_type_id => Goz::EventType::MEMBER_REMOVE, :group_id => group.id, :user_id => user.id )
+      self.create :event_type    => Goz::EventType::MEMBER_REMOVE,
+                  :group         => group,
+                  :group_id      => group.id,
+                  :user          => user,
+                  :user_id       => user.id
     end
 
     def self.service_add(service)
-      self.create( :event_type_id => Goz::EventType::SERVICE_ADD, :service_id => service.id )
+      self.create :event_type    => Goz::EventType::SERVICE_ADD,
+                  :service       => service,
+                  :service_id    => service.id
     end
 
     def self.service_remove(service)
-      self.create( :event_type_id => Goz::EventType::SERVICE_REMOVE, :service_id => service.id )
+      self.create :event_type    => Goz::EventType::SERVICE_REMOVE,
+                  :service       => service,
+                  :service_id    => service.id
     end
 
     def self.service_sync(service)
-      self.create( :event_type_id => Goz::EventType::SERVICE_SYNC, :service_id => service.id )
+      self.create :event_type    => Goz::EventType::SERVICE_SYNC,
+                  :service       => service,
+                  :service_id    => service.id
+    end
+
+    def self.user_add(user)
+      self.create :event_type    => Goz::EventType::USER_ADD,
+                  :user          => user,
+                  :user_id       => user.id
+    end
+
+    def self.user_remove(user)
+      self.create :event_type    => Goz::EventType::USER_REMOVE,
+                  :user          => user,
+                  :user_id       => user.id
     end
 
     def self.user_sync(user)
-      self.create( :event_type_id => Goz::EventType::USER_SYNC, :user_id => user.id )
+      self.create :event_type    => Goz::EventType::USER_SYNC,
+                  :user          => user,
+                  :user_id       => user.id
     end
 
+
     #
     # Perform model valiations.
     #
     def validate
       super
-      validates_presence  :event_type_id
-      validates_type      Integer, [ :event_type_id, :group_id, :service_id, :user_id ]
+      validates_presence  :event_type
+      validates_includes  Goz::EventType::TYPES, :event_type
+      validates_type      Integer, [ :group_id, :service_id, :user_id ]
     end
     
     

data/lib/goz/event_type.rb

@@ -19,8 +19,8 @@ module Goz # :nodoc:
 
     plugin :validation_helpers
 
-    TYPES = EventType.to_hash(:name, :id)
-    TYPES.each_pair { |k, v| const_set k.upcase.to_s, v }
+    TYPES = EventType.map(:name)
+    TYPES.each { |t| const_set t.upcase.to_s, t }
 
 
     #
@@ -41,7 +41,7 @@ module Goz # :nodoc:
       self.created_at ||= Time.now
     end
 
-  end # class EventType
+  end
 
-end # module Goz
+end
 

data/lib/goz/group.rb

@@ -1,8 +1,11 @@
 # encoding: utf-8
 
+require 'active_support/inflector'
 require 'goz/database'
 require 'goz/event'
 require 'goz/group_service'
+require 'goz/logger'
+
 
 module Goz # :nodoc:
  
@@ -34,7 +37,6 @@ module Goz # :nodoc:
   # https://github.com/blairc/goz/
   #
   class Group < Sequel::Model
-    include Comparable
 
     plugin :validation_helpers
 
@@ -57,67 +59,85 @@ module Goz # :nodoc:
                   :right_key    => :service_id,
                   :join_table   => :group_services,
                   :class        => :'Goz::Service',
-                  :after_add    => proc { |g, s| Goz::Event.group_service_add(g, s) },
-                  :after_remove => proc { |g, s| Goz::Event.group_service_remove(g, s) }
+                  :after_add    => proc { |g, s| after_add_service g, s },
+                  :after_remove => proc { |g, s| after_remove_service g, s }
+
+
+    ATTRIBUTES = [ :display_name, :identifier, :klass, :name ]
+    TAG        = self.name
+
+    @@api = Goz::Group
 
 
     #
-    # Initialize new (non-persistent) Goz::Group object
+    # Return groups where user is an admin.
     #
-    def initialize(*params)
-      super
-      yield self if block_given?
-      self
+    def self.admin(user)
+      Goz::Logger.debug TAG, "admin( user=#{user.login} )"
+      return user.groups if Goz::Group.name == @@api.name
+      groups = self.api.groups(user).collect { |g| self.find_or_create g.to_hash }
+      groups.each { |g| yield g } if block_given?
+      groups
     end
 
-    #
-    # Compare equality.
-    #
-    def <=>(other)
-      if    self.display_name < other.display_name  ||
-            self.identifier   < other.identifier    ||
-            self.name         < other.name
-        -1
-      elsif self.display_name > other.display_name  ||
-            self.identifier   > other.identifier    ||
-            self.name         > other.name
-        1
-      else
-        0
-      end
+    # TODO DRY w/ "Service"
+    def self.after_add_service(g, s)
+      s.create(g) && Goz::Event.group_service_add(g, s)
+    end
+
+    # TODO DRY w/ "Service"
+    def self.after_remove_service(g, s)
+      s.destroy(g) && Goz::Event.group_service_remove(g, s)
     end
 
     #
-    # Create Goz::Group or raise +RuntimeError+
+    # TODO
     #
-    def self.create( params = {} )
-      params = {} unless params.kind_of?(Hash)
-      [ :display_name, :identifier, :name ].each do |k|
-        raise( "invalid #{k.to_s}" ) if ( params[k].nil? || params[k].empty? )
-      end
-      super
+    def self.api( klass = nil, configuration = {} )
+      return @@api if klass.nil?
+      Goz::Logger.info TAG, "changing api from #{@@api} to #{klass}"
+      klass_name = klass.kind_of?(String) ? klass : klass.name
+      require klass_name.underscore
+      klass = klass.constantize if klass.kind_of?(String)
+      klass.configuration configuration
+      @@api = klass
     end
 
     #
     # Find Goz::Group by name or return +nil+
     #
     def self.find_by_name(name)
-      self.find( :name => name )
+      Goz::Logger.debug TAG, "find_by_name( name=#{name} )"
+      g = self.find :name => name
+      return g   unless g.nil?
+      return nil if     Goz::Group == self.api
+      g = self.api.find_by_name name
+      return nil if g.nil?
+      return self.find_or_create g.to_hash
+    end
+
+    #
+    # Return groups where user is a member.
+    #
+    def self.member(user)
+      Goz::Logger.debug TAG, "member( user=#{user.login} )"
+      return user.memberships if Goz::Group.name == @@api.name
+      groups = self.api.memberships(user).collect { |g| self.find_or_create g.to_hash }
+      groups.each { |g| yield g } if block_given?
+      groups
     end
 
     #
     # Synchronize group with external data sources (if relevant).
     # 
     def sync(force = false)
-      if force || synchronized_at.nil? || synchronized_at < ( Time.now - ( 1 * 60 * 60 ) ) # XXX
-        # XXX Synchronize group from remote source (if necessary)
-        # XXX Synchronize admins
-        # XXX Synchronize members
-        self.services.each { |s| self.sync_service(s, force) }
-        self.synchronized_at = Time.now
-        self.save
-        Goz::Event.group_sync(self)
-        return true
+      Goz::Logger.debug TAG, "#{self.name} - #sync( force=#{force} )"
+      if sync_group && sync_admins && sync_members
+          self.services.each { |s| self.sync_service(s, force) } # TODO
+          self.synchronized_at = Time.now
+          self.save
+          Goz::Event.group_sync(self)
+          return true
       end
       false
     end
@@ -126,7 +146,12 @@ module Goz # :nodoc:
     # Synchronize group service with external data soruces (if relevant).
     # 
     def sync_service(service, force = false )
-      Goz::GroupService.first( :group_id => self.id, :service_id => service.id ).sync(force)
+      Goz::Logger.debug TAG, "#{self.name} - #sync_service( service.name=#{service.name}, force=#{force} )"
+      service.sync_group(self) # XXX
+    end
+
+    def to_hash
+      Hash[ ATTRIBUTES.map { |k| [ k, self[k] ] } ]
     end
 
     #
@@ -134,7 +159,7 @@ module Goz # :nodoc:
     #
     def validate
       super
-      validates_presence  [ :display_name, :identifier, :name ]
+      validates_presence  [ :display_name, :identifier, :klass, :name ]
       validates_type      Time, [ :created_at, :modified_at, :synchronized_at ]
       validates_unique    [ :display_name, :identifier, :name ]
     end
@@ -168,7 +193,59 @@ module Goz # :nodoc:
       self.modified_at = Time.now
     end
 
-  end # class Group
+    def klass_instance
+      return @@api if @@api.name == self.klass
+      unless @k
+        @k = self.klass.constantize
+        require self.klass.underscore
+      end
+      return @k
+    end
+
+    # Synchronize group admins with external data source
+    def sync_admins
+      Goz::Logger.debug TAG, "#{self.name} - #sync_admins()"
+      return true if Goz::Group.name == self.klass
+      g = klass_instance.find_by_name self.name
+      return false if g.nil?
+      t = g.admins.collect { |u| Goz::User.find_by_login u.login } # TODO Should be .find( key => value )
+      t.delete_if { |_| _.nil? }
+      t.each           { |_| self.add_admin(_)    unless self.admins.include?(_) }
+      self.admins.each { |_| self.remove_admin(_) unless t.include?(_)           }
+      # TODO Log! if modified?
+      true
+    end
+
+    # Synchronize group with external data source
+    def sync_group
+      Goz::Logger.debug TAG, "#{self.name} - #sync_group()"
+      return true if Goz::Group.name == self.klass
+      g = klass_instance.find_by_name self.name
+      return false if g.nil?
+      [ :display_name, :identifier, :name ].each do |attr|
+        unless self[attr] == g[attr]
+          Goz::Logger.info TAG, "#{self.name} = #sync_group() - #{attr} changed"
+          self[attr] = g[attr]
+        end
+      end
+      true
+    end
+
+    # Synchronize groups members with external data source
+    def sync_members
+      Goz::Logger.debug TAG, "#{self.name} - #sync_members()"
+      return true if Goz::Group.name == self.klass
+      g = klass_instance.find_by_name self.name
+      return false if g.nil?
+      t = g.members.collect { |u| Goz::User.find_by_login u.login } # TODO Should be .find( key => value )
+      t.delete_if { |_| _.nil? }
+      t.each            { |_| self.add_member(_)    unless self.members.include?(_) }
+      self.members.each { |_| self.remove_member(_) unless t.include?(_)            }
+      # TODO Log! if modified?
+      true
+    end
+
+  end
 
-end # module Goz
+end