cassiopeia 0.0.7 → 0.0.8

data/README.rdoc

@@ -7,6 +7,7 @@
 - Yet another custom CAS client/server implementation. This plugin allows you to perform single-server authorization between two different rails applications. 
 
 = Changelog:
+- 0.0.8: Full request saving support via rack middleware.
 - 0.0.7: Some code for redirection added. Added webpath prefix support.
 - 0.0.6: Tiny refactoring.
 - 0.0.5: Some important fixes for configuration exceptions handling.

data/Rakefile

@@ -10,7 +10,7 @@ PKG_FILES = FileList[ '[a-zA-Z]*',  'lib/**/*' ]
 
 spec = Gem::Specification.new do |s|
   s.name = "cassiopeia"
-  s.version = "0.0.7"
+  s.version = "0.0.8"
   s.author = "smecsia"
   s.email = "smecsia@gmail.com"
   #s.homepage = ""

data/lib/cassiopeia/action_controller_client_mixin.rb

@@ -35,16 +35,16 @@ module Cassiopeia
       end
       def cas_request_ticket_id
         cas_store_location
-        redirect_to Cassiopeia::Client::instance.cas_check_url(session) 
+        redirect_to Cassiopeia::Client::instance.cas_check_url(session, params) 
       end
       def cas_request_current_user
         session[CAS_TICKET_ID_KEY] = cas_current_ticket_id
-        @ticket = Cassiopeia::Client::instance.cas_current_ticket(session)
+        @ticket = Cassiopeia::Client::instance.cas_current_ticket(session, params)
+        raise Cassiopeia::Exception::AccessDenied.new "Cannot identify current user" unless (@ticket.include? :user)
         @current_user = Cassiopeia::User.new(@ticket[:user])
         logger.debug "\nCurrent user identified (#{@current_user.login}), storing to session\n" + "="*50
         cas_store_current_user(@ticket, @current_user)
-        logger.debug "\nShould redirect user to #{session[:return_to]}\n" + "="*50
-        cas_redirect_back_or_default root_path
+        logger.debug "\nTicket_id is in request, should process the old request... #{session[:return_to]}\n" + "="*50
       end
       def cas_required_roles
         self.class.cas_required_roles if self.class.respond_to? :cas_required_roles 

data/lib/cassiopeia/action_controller_server_mixin.rb

@@ -94,7 +94,7 @@ module Cassiopeia
       end
 
       def cas_proceed_auth
-        service_url = Cassiopeia::Server::instance.service_url(session)
+        service_url = Cassiopeia::Server::instance.service_url(session, params)
         if cas_current_ticket_valid? && current_user
           logger.debug "\nCurrentTicketValid, current_user exists redirecting to service...\n" + "="*50
           return cas_redirect_to service_url

data/lib/cassiopeia/client.rb

@@ -8,17 +8,24 @@ require 'rexml/document'
 ##################
 module Cassiopeia
   class Client < Base
+    SERVICE_URL = Cassiopeia::CONFIG[:service_url]
+    SERVICE_ID = Cassiopeia::CONFIG[:service_id]
+    SERVICE_URL_KEY = Cassiopeia::CONFIG[:service_url_key]
+    SERVICE_ID_KEY = Cassiopeia::CONFIG[:service_id_key]
+    TICKET_ID_KEY = Cassiopeia::CONFIG[:ticket_id_key]
+    REQ_KEY = Cassiopeia::CONFIG[:rack_unique_req_key]
     private
     @instance = nil
     def server_url
       Cassiopeia::CONFIG[:server_url] + "/" + Cassiopeia::CONFIG[:server_controller] + "." + Cassiopeia::CONFIG[:format]
     end
 
-    def cas_data(session)
+    def cas_data(session, params)
       {
-        Cassiopeia::CONFIG[:service_url_key] => Cassiopeia::CONFIG[:service_url],
-        Cassiopeia::CONFIG[:service_id_key] => Cassiopeia::CONFIG[:service_id],
-        Cassiopeia::CONFIG[:ticket_id_key] => session[Cassiopeia::CONFIG[:ticket_id_key]]
+        SERVICE_URL_KEY => SERVICE_URL,
+        SERVICE_ID_KEY => SERVICE_ID,
+        TICKET_ID_KEY => session[TICKET_ID_KEY],
+        REQ_KEY => params[REQ_KEY]
       }
     end
 
@@ -38,8 +45,8 @@ module Cassiopeia
       @instance = Cassiopeia::Client.new
     end
 
-    def cas_current_ticket(session)
-      res = do_post(server_url, cas_data(session))
+    def cas_current_ticket(session, request)
+      res = do_post(server_url, cas_data(session, request))
       case res
       when Net::HTTPSuccess
         begin
@@ -50,8 +57,8 @@ module Cassiopeia
       return {}
     end
 
-    def cas_check_url(session)
-      server_url + "?" + hash_to_query(cas_data(session))
+    def cas_check_url(session, params)
+      server_url + "?" + hash_to_query(cas_data(session, params))
     end
 
   end

data/lib/cassiopeia/config.rb

@@ -9,13 +9,19 @@ module Cassiopeia
     :ticket_id_key => "cas_ticket_id",
     :service_id_key => "cas_service_id",
     :service_url_key => "cas_service_url",
-    :server_url => "https://localhost/cassiopeia",
-    :service_url => "https://localhost/",
+    :server_url => nil,
+    :service_url => nil,
     :webpath_prefix => "",
     :return_to_key => "cas_return_to",
-    :service_id => "casclient",
+    :service_id => nil,
     :current_user_key => "current_user",
-    :format => "js"
+    :format => "js",
+    :rack_session_store => "cas_rack_session",
+    :rack_session_key => "rack.session",
+    :rack_request_uri_key => "REQUEST_URI",
+    :rack_query_string_key => "QUERY_STRING",
+    :rack_save_keys => "REQUEST_METHOD QUERY_STRING REQUEST_URI",
+    :rack_unique_req_key => "cas_req_key"
   }
   CONFIG_PATH = "#{RAILS_ROOT}/config/cassiopeia.yml"
   @@conf = {}

data/lib/cassiopeia/rack_restore_request.rb

@@ -0,0 +1,90 @@
+module Cassiopeia
+  class RackRestoreRequest
+    CAS_RACK_SESSION_STORE = Cassiopeia::CONFIG[:rack_session_store] 
+    CAS_RACK_SESSION_KEY = Cassiopeia::CONFIG[:rack_session_key]
+    CAS_TICKET_ID_KEY = Cassiopeia::CONFIG[:ticket_id_key]
+    CAS_REQUEST_URI_KEY = Cassiopeia::CONFIG[:rack_request_uri_key]
+    CAS_QUERY_STRING_KEY = Cassiopeia::CONFIG[:rack_query_string_key]
+    CAS_SAVE_KEYS = Cassiopeia::CONFIG[:rack_save_keys]
+    CAS_UNIQUE_REQ_KEY = Cassiopeia::CONFIG[:rack_unique_req_key]
+
+    def initialize( app )
+      @app = app
+    end
+
+    def call( env )
+      if restore_headers_required?(env)
+        env = restore_headers(env)
+      else
+        save_headers(env)
+      end
+      @status, @headers, @body = @app.call env
+      [@status, @headers, @body]
+    end
+
+    def query_to_hash(query)
+      CGI.parse(query)
+    end
+
+    def hash_to_query(hash)
+      pairs = []
+      hash.each do |k, vals|
+        vals = [vals] unless vals.kind_of? Array
+        vals.each {|v| pairs << "#{CGI.escape(k.to_s)}=#{(v)?CGI.escape(v.to_s):''}"}
+      end
+      pairs.join("&")
+    end
+
+    def restore_headers_required?(env)
+      env[CAS_QUERY_STRING_KEY] && env[CAS_QUERY_STRING_KEY].match(CAS_TICKET_ID_KEY.to_s) && env[CAS_RACK_SESSION_KEY] && env[CAS_RACK_SESSION_KEY][CAS_RACK_SESSION_STORE]
+    end
+
+    def save_headers(env)
+      if(env[CAS_RACK_SESSION_KEY])
+        req_key = store_req_key(env)
+        env[CAS_RACK_SESSION_KEY][CAS_RACK_SESSION_STORE] = { req_key => {}}
+        env.each do |key,value|
+          if env[key] && (key.is_a? String) && (key.match("HTTP_") || CAS_SAVE_KEYS.match(key))
+            env[CAS_RACK_SESSION_KEY][CAS_RACK_SESSION_STORE][req_key][key] = value
+          end
+        end
+      end
+    end
+
+    def add_ticket_id_to_req(env, key, value)
+      newparams = query_to_hash(value)
+      params = query_to_hash(env[key])
+      newparams[CAS_TICKET_ID_KEY] = params[CAS_TICKET_ID_KEY]
+      newparams.delete CAS_UNIQUE_REQ_KEY
+      env[key] = hash_to_query(newparams)
+    end
+
+    def restore_req_key(env)
+      newparams = query_to_hash(env[CAS_QUERY_STRING_KEY])
+      newparams[CAS_UNIQUE_REQ_KEY]
+    end
+
+    def store_req_key(env)
+      params = query_to_hash(env[CAS_QUERY_STRING_KEY])
+      params[CAS_UNIQUE_REQ_KEY] = UUIDTools::UUID.timestamp_create.to_s
+      env[CAS_QUERY_STRING_KEY] = hash_to_query(params)
+      params[CAS_UNIQUE_REQ_KEY]
+    end
+
+    def restore_headers(env)
+      current_req_key = restore_req_key(env)
+      stored_keys = env[CAS_RACK_SESSION_KEY][CAS_RACK_SESSION_STORE][current_req_key.to_s]
+      if(env[CAS_RACK_SESSION_KEY] && stored_keys)
+        stored_keys.each do |key,value|
+          if(key.match(CAS_QUERY_STRING_KEY))
+            add_ticket_id_to_req(env,key,value)
+          else
+            env[key] = value
+          end
+        end
+        env[CAS_RACK_SESSION_KEY][CAS_RACK_SESSION_STORE].delete current_req_key.to_s
+      end
+      env
+    end
+  end
+end

data/lib/cassiopeia/server.rb

@@ -2,11 +2,13 @@ module Cassiopeia
   class Server < Base
     SERVICE_KEY = Cassiopeia::CONFIG[:service_url_key]
     TICKET_KEY = Cassiopeia::CONFIG[:ticket_id_key]
+    REQ_KEY = Cassiopeia::CONFIG[:rack_unique_req_key]
     private
     @instance = nil
-    def cas_data(session)
+    def cas_data(session, params)
       {
-        TICKET_KEY => session[TICKET_KEY]
+        TICKET_KEY => session[TICKET_KEY],
+        REQ_KEY => params[REQ_KEY]
       }
     end
     public 
@@ -15,9 +17,9 @@ module Cassiopeia
       @instance = Cassiopeia::Server.new
     end
 
-    def service_url(session)
+    def service_url(session, params)
       if session && session[SERVICE_KEY] && session[TICKET_KEY]
-        session[SERVICE_KEY] + "?" + hash_to_query(cas_data(session))
+        session[SERVICE_KEY] + "?" + hash_to_query(cas_data(session, params))
       end
     end
 

data/lib/cassiopeia.rb

@@ -1,7 +1,7 @@
 $:.unshift(File.dirname(__FILE__)) unless
 $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 module Cassiopeia
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
   autoload :User, 'cassiopeia/user'
   autoload :Base, 'cassiopeia/base'
   autoload :Exception, 'cassiopeia/base'
@@ -11,12 +11,15 @@ module Cassiopeia
   autoload :ActiveRecordServerMixin, 'cassiopeia/active_record_server_mixin'
   autoload :ActionControllerServerMixin, 'cassiopeia/action_controller_server_mixin'
   autoload :ActionControllerClientMixin, 'cassiopeia/action_controller_client_mixin'
+  autoload :RackRestoreRequest, 'cassiopeia/rack_restore_request'
 
   class << self
     def enable
       ActionController::Base.send :extend, ActionControllerServerMixin
       ActiveRecord::Base.send :extend, ActiveRecordServerMixin
       ActionController::Base.send :extend, ActionControllerClientMixin
+      Rails.configuration.middleware.use RackRestoreRequest if CONFIG[:service_id]
+      puts "Cassiopeia 0.0.8 enabled"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cassiopeia
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - smecsia
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-07 00:00:00 +04:00
+date: 2010-04-08 00:00:00 +04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ files:
 - lib/cassiopeia/config.rb
 - lib/cassiopeia/server.rb
 - lib/cassiopeia/user.rb
+- lib/cassiopeia/rack_restore_request.rb
 - lib/cassiopeia/client.rb
 - lib/cassiopeia/tickets_controller_config.rb
 - lib/cassiopeia/action_controller_client_mixin.rb