cassiopeia 0.0.1

data/README

@@ -0,0 +1,8 @@
+Cassiopeia
+===================
+
+Yet another custom CAS client/server implementation
+
+===================
+
+Copyright (c) 2010 Waveaccess LLC

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+desc 'Default: .'
+task :default => :test
+
+PKG_FILES = FileList[ '[a-zA-Z]*',  'lib/**/*' ]
+
+spec = Gem::Specification.new do |s|
+  s.name = "cassiopeia"
+  s.version = "0.0.1"
+  s.author = "smecsia"
+  s.email = "smecsia@gmail.com"
+  #s.homepage = ""
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Rails plugin for custom CAS(Cassiopeia) server/client implementation"
+  s.add_dependency('uuidtools')
+  s.add_dependency('rails', '>=2.3.5')
+  s.files = PKG_FILES.to_a 
+  s.require_path = "lib"
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README"]
+end
+
+desc 'Turn this plugin into a gem.'
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+

data/lib/cassiopeia/action_controller_client_mixin.rb

@@ -0,0 +1,86 @@
+module Cassiopeia
+  module ActionControllerClientMixin
+    module ActionControllerMethods
+      ::CAS_USER_KEY = Cassiopeia::CONFIG[:current_user_key]
+      ::CAS_TICKET_ID_KEY = Cassiopeia::CONFIG[:ticket_id_key] 
+      ::CAS_TICKET_KEY = Cassiopeia::CONFIG[:ticket_key]
+      def cas_current_ticket
+        session[CAS_TICKET_KEY] || params[CAS_TICKET_KEY]
+      end
+      def cas_current_ticket_id
+        params[CAS_TICKET_ID_KEY] || session[CAS_TICKET_ID_KEY]
+      end
+      def cas_store_current_user(ticket, user)
+        session[CAS_TICKET_KEY] = ticket
+        session[CAS_USER_KEY] = current_user
+      end
+      def cas_erase_current_user
+        cas_store_current_user nil, nil
+        session[CAS_TICKET_ID_KEY] = nil
+      end
+      def cas_current_ticket_valid?
+        logger.debug "\n Ticket.expires_at= #{cas_current_ticket[:expires_at]} \n" + "="*50 if cas_current_ticket
+        logger.debug "\nCurrent ticket valid: #{DateTime.parse(cas_current_ticket[:expires_at])} >= #{DateTime.now}\n" + "="*50 if cas_current_ticket && cas_current_ticket[:expires_at]
+        cas_current_ticket && DateTime.parse(cas_current_ticket[:expires_at]) >= DateTime.now if cas_current_ticket && cas_current_ticket[:expires_at]
+      end
+      def cas_request_ticket_id
+        store_location if respond_to?('store_location')
+        redirect_to Cassiopeia::Client::instance.cas_check_url(session) 
+      end
+      def cas_request_current_user
+        session[CAS_TICKET_ID_KEY] = cas_current_ticket_id
+        @ticket = Cassiopeia::Client::instance.cas_current_ticket(session)
+        @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
+        redirect_back_or_default root_path if respond_to?('redirect_back_or_default')
+      end
+      def cas_required_roles
+        self.class.cas_required_roles if self.class.respond_to? :cas_required_roles 
+      end
+      def cas_check_required_roles
+        if cas_required_roles
+          logger.debug "\nCas check required roles #{cas_required_roles}...\n" + "="*50
+          cas_required_roles.each do |r|
+            raise Cassiopeia::AccessDeniedException.new "You don't have required roles for this controller" unless current_user.has_role? r
+          end
+        end
+      end
+      def cas_require_user
+        if !cas_current_ticket_id
+          logger.debug "\nNo cas_ticket_id, requesting from cassiopeia...\n" + "="*50
+          return cas_request_ticket_id
+        end
+        if cas_current_ticket && !cas_current_ticket_valid?
+          logger.debug "\nCurrent ticket is invalid, erasing current user\n" + "="*50
+          cas_erase_current_user
+          return cas_request_ticket_id
+        end
+        if cas_current_ticket_id && !cas_current_ticket
+          logger.debug "\nCas ticket_id is in request, retrieving current_ticket and user...\n\n" + "="*50
+          return cas_request_current_user
+        elsif cas_current_ticket
+          logger.debug "\nCurrent user session is valid (current user = #{current_user.login})\n" + "="*50
+        end
+      end
+      def current_user
+        return @current_user if @current_user
+        @current_user = session[CAS_USER_KEY]
+      end
+    end
+    def cas_required_roles
+      @required_roles
+    end
+    def cas_require_roles(*roles)
+      @required_roles = [] unless defined? @required_roles
+      @required_roles |= roles
+      logger.debug "\nCAS add required role #{roles}, now roles_required: #{@required_roles}...\n" + "="*50
+    end
+    def use_cas_authorization
+      @current_user = nil
+      before_filter :cas_require_user, :cas_check_required_roles
+      include ActionControllerMethods
+    end
+  end
+end

data/lib/cassiopeia/action_controller_server_mixin.rb

@@ -0,0 +1,142 @@
+module Cassiopeia
+  autoload :TicketsControllerConfig, 'cassiopeia/tickets_controller_config'
+
+  module ActionControllerServerMixin
+    module ActionControllerMethods
+      def ActionControllerMethods.rolesMethod=(m)
+        @@rolesMethod = m
+      end
+      def ActionControllerMethods.ticketClass=(c)
+        @@ticketClass = c
+      end
+      def cas_ticket_id
+        session[@ticket_id_key] || params[@ticket_id_key]
+      end
+      def cas_service_url
+        session[@service_url_key] || params[@service_url_key]
+      end
+      def cas_service_id
+        session[@service_id_key] || params[@service_id_key]
+      end
+
+      def cas_require_config
+        raise "ticketClass should be set to use this functionality" unless @@ticketClass
+      end
+
+      def cas_store_params
+        @ticket_id_key = Cassiopeia::CONFIG[:ticket_id_key]
+        @service_id_key = Cassiopeia::CONFIG[:service_id_key]
+        @service_url_key = Cassiopeia::CONFIG[:service_url_key]
+        session[@ticket_id_key] = cas_ticket_id
+        session[@service_id_key] = cas_service_id
+        session[@service_url_key] = cas_service_url
+      end
+
+      def cas_create_or_find_ticket
+        if current_user && !(cas_current_ticket_exists?) 
+          @ticket = @@ticketClass.new(:user_id => current_user.id)
+          @ticket.user = current_user
+          @ticket.service = cas_service_id
+          if @ticket.save
+            session[@ticket_id_key] = @ticket.identity
+            session[@service_id_key] = @ticket.service
+          else
+            @ticket = nil
+          end
+        else
+          @ticket = @@ticketClass.find_by_identity(cas_ticket_id.to_s)
+        end
+        @ticket
+      end
+
+      def cas_current_ticket
+        @ticket = cas_create_or_find_ticket unless @ticket
+        logger.debug "\nCurrentTicket = #{@ticket.identity if @ticket}\n" + "="*50
+        @ticket
+      end
+
+      def cas_current_ticket_exists?
+        logger.debug "\nTicketExists = #{@@ticketClass.exists?(cas_ticket_id)}\n" + "="*50
+        @@ticketClass.exists?(cas_ticket_id)
+      end
+
+      def cas_current_ticket_valid?
+        logger.debug "\nTicketValid = #{cas_current_ticket.valid_for?(cas_service_id)}\n" + "="*50 if cas_current_ticket_exists?
+        cas_current_ticket.valid_for?(cas_service_id) if cas_current_ticket_exists?
+      end
+
+      def cas_respond_current_ticket
+        ticket_hash = cas_current_ticket.attributes
+        if cas_current_ticket.user
+          user_hash = cas_current_ticket.user.attributes
+          roles = []
+          roles = (cas_current_ticket.user.send @@rolesMethod) if cas_current_ticket.user.respond_to? @@rolesMethod
+          roles_hash = roles
+          user_hash[:roles] = roles_hash
+        else
+          user_hash = nil
+        end
+        ticket_hash = ticket_hash.merge({:user => user_hash}) if cas_current_ticket.user
+        logger.debug "\n Rendering ticket: \n"
+        logger.debug ticket_hash.to_json + "\n" + "="*50
+        simple_rest ticket_hash, {:status => :ok}
+      end
+
+      def cas_process_request
+        if current_user
+          cas_respond_current_ticket
+        elsif cas_current_ticket_exists?
+          cas_respond_current_ticket
+        else
+          @res = {:error => "Ticket not found"}
+          simple_rest @res, {:status => :error}
+        end
+      end
+
+      def cas_proceed_auth
+        if cas_current_ticket_valid? && current_user
+          logger.debug "\nCurrentTicketValid, current_user exists redirecting to service...\n" + "="*50
+          return redirect_to Cassiopeia::Server::instance.service_url(session)
+        elsif current_user
+          logger.debug "\nCurrentTicketInvalid, but current_user exists, should create new ticket...\n" + "="*50
+          cas_current_ticket.destroy
+          cas_create_or_find_ticket
+          return redirect_to Cassiopeia::Server::instance.service_url(session)
+        elsif cas_current_ticket_exists?
+          logger.debug "\nCurrentTicketInvalid, but current_user exists, destroying ticket, redirecting to login...\n" + "="*50
+          cas_current_ticket.destroy
+        end
+        redirect_to login_url
+      end
+
+      def create
+        cas_process_request
+      end
+
+      def show
+        cas_proceed_auth
+      end
+
+      def index
+        cas_proceed_auth
+      end
+
+      def detroy(params)
+        cas_current_ticket.destroy if cas_current_ticket_exists?
+        simple_rest nil, {:status => :ok}
+      end
+    end
+    def acts_as_cas_controller
+      defaultTicketClass = Ticket if defined? Ticket
+      controllerConfig = Cassiopeia::TicketsControllerConfig.new defaultTicketClass, :roles
+      yield controllerConfig
+      ActionControllerMethods.rolesMethod = controllerConfig.rolesMethod
+      ActionControllerMethods.ticketClass = controllerConfig.ticketClass
+      ActiveRecordServerMixin.ticketClass = controllerConfig.ticketClass
+      skip_before_filter :verify_authenticity_token, :only=> [:create, :index]
+      before_filter :require_user, :except => [:create, :index]
+      before_filter :cas_store_params, :cas_create_or_find_ticket, :cas_require_config
+      include ActionControllerMethods
+    end
+  end
+end

data/lib/cassiopeia/active_record_server_mixin.rb

@@ -0,0 +1,36 @@
+require 'uuidtools'
+
+module Cassiopeia
+  module ActiveRecordServerMixin 
+    def ActiveRecordServerMixin.ticketClass=(c)
+      @@ticketClass = c
+    end
+    # cas ticket
+    def acts_as_cas_ticket
+      class_eval do
+        def valid_for?(service)
+          return false unless identity && user
+          (ticket = self.for_service service) && ticket.expires_at >= DateTime.now
+        end
+        def for_service(service)
+          @@ticketClass.find(:first, :conditions => {:service => service, :user_id => user.id })
+        end
+      end
+      instance_eval do
+        def generate_expiration
+          DateTime.now() + Cassiopeia::CONFIG[:ticket_max_lifetime] / 24.0 / 60.0
+        end
+        def generate_uuid
+          UUIDTools::UUID.timestamp_create.to_s
+        end
+        def exists?(ticket_id)
+          self.find_by_identity(ticket_id.to_s) != nil
+        end
+        before_create do |obj|
+          obj.identity = generate_uuid
+          obj.expires_at = generate_expiration
+        end
+      end
+    end
+  end
+end

data/lib/cassiopeia/base.rb

@@ -0,0 +1,20 @@
+module Cassiopeia
+  class Base
+    protected
+    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
+  end
+
+  class AccessDeniedException < Exception
+  end
+end

data/lib/cassiopeia/client.rb

@@ -0,0 +1,59 @@
+require 'uri'
+require 'cgi'
+require 'net/https'
+require 'rexml/document'
+
+##################
+# Client
+##################
+module Cassiopeia
+  class Client < Base
+    private
+    @instance = nil
+    def server_url
+      Cassiopeia::CONFIG[:server_url] + "/" + Cassiopeia::CONFIG[:server_controller] + "." + Cassiopeia::CONFIG[:format]
+    end
+
+    def cas_data(session)
+      {
+        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]]
+      }
+    end
+
+    # Submits some data to the given URI and returns a Net::HTTPResponse.
+    def do_post(uri, data)
+      uri = URI.parse(uri) unless uri.kind_of? URI
+      req = Net::HTTP::Post.new(uri.path)
+      req.set_form_data(data, ';')
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.use_ssl = (uri.scheme == 'https')
+      res = https.start {|conn| conn.request(req) }
+    end
+
+    public 
+    def self.instance
+      return @instance if @instance
+      @instance = Cassiopeia::Client.new
+    end
+
+    def cas_current_ticket(session)
+      res = do_post(server_url, cas_data(session))
+      case res
+      when Net::HTTPSuccess
+        begin
+          return ActiveSupport::JSON.decode(res.body).symbolize_keys if Cassiopeia::CONFIG[:format] == "js"
+        rescue 
+        end
+      end 
+      return {}
+    end
+
+    def cas_check_url(session)
+      server_url + "?" + hash_to_query(cas_data(session))
+    end
+
+  end
+end
+

data/lib/cassiopeia/config.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+
+module Cassiopeia
+  private
+  DEFAULT_CONFIG = {
+    :ticket_max_lifetime => 120,
+    :server_controller => "cas",
+    :session_id_key => "cassiopeia_sesion_id",
+    :ticket_id_key => "ticket_id",
+    :service_id_key => "service_id",
+    :service_url_key => "service_url",
+    :server_url => "https://localhost/cassiopeia",
+    :service_url => "https://localhost/test_rails",
+    :service_id => "test",
+    :current_user_key => "current_user"
+  }
+  CONFIG_PATH = "#{RAILS_ROOT}/config/cassiopeia.yml"
+  @@conf = {}
+  if !File.exist?(CONFIG_PATH)
+    raise "Cassiopeia config required! Please, create RAILS_ROOT/conf/cassiopeia.yml file with server/service url"
+  end
+  @@conf = YAML::load(ERB.new((IO.read(CONFIG_PATH))).result).symbolize_keys if File.exist?(CONFIG_PATH)
+  @@ticketClass = Class.class
+  @@controllerClass = Class.class
+  public
+  CONFIG = DEFAULT_CONFIG.merge(@@conf)
+end

data/lib/cassiopeia/server.rb

@@ -0,0 +1,22 @@
+module Cassiopeia
+  class Server < Base
+    private
+    @instance = nil
+    def cas_data(session)
+      {
+        Cassiopeia::CONFIG[:ticket_id_key] => session[Cassiopeia::CONFIG[:ticket_id_key]]
+      }
+    end
+    public 
+    def self.instance
+      return @instance if @instance
+      @instance = Cassiopeia::Server.new
+    end
+
+    def service_url(session)
+      session[Cassiopeia::CONFIG[:service_url_key]] + "?" + hash_to_query(cas_data(session))
+    end
+
+  end
+  
+end

data/lib/cassiopeia/tickets_controller_config.rb

@@ -0,0 +1,10 @@
+module Cassiopeia
+  class TicketsControllerConfig
+    attr_accessor :ticketClass
+    attr_accessor :rolesMethod
+    def initialize(tClass, rMethod)
+      @ticketClass = tClass
+      @rolesMethod = rMethod
+    end
+  end
+end

data/lib/cassiopeia/user.rb

@@ -0,0 +1,13 @@
+require 'ostruct'
+
+module Cassiopeia
+  class User < OpenStruct
+    def initialize(hash)
+      super(hash)
+    end
+
+    def has_role?(role)
+      roles && roles.respond_to?(:include?) && roles.include?(role.to_s)
+    end
+  end
+end

data/lib/cassiopeia.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+module Cassiopeia
+  VERSION = '0.0.1'
+  autoload :User, 'cassiopeia/user'
+  autoload :Base, 'cassiopeia/base'
+  autoload :AccessDeniedException, 'cassiopeia/base'
+  autoload :Server, 'cassiopeia/server'
+  autoload :Client, 'cassiopeia/client'
+  autoload :CONFIG, 'cassiopeia/config'
+  autoload :ActiveRecordServerMixin, 'cassiopeia/active_record_server_mixin'
+  autoload :ActionControllerServerMixin, 'cassiopeia/action_controller_server_mixin'
+  autoload :ActionControllerClientMixin, 'cassiopeia/action_controller_client_mixin'
+
+  class << self
+    def enable
+      ActionController::Base.send :extend, ActionControllerServerMixin
+      ActiveRecord::Base.send :extend, ActiveRecordServerMixin
+      ActionController::Base.send :extend, ActionControllerClientMixin
+    end
+  end
+end
+
+if defined? Rails && defined? RAILS_ROOT
+  Cassiopeia.enable
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: cassiopeia
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- smecsia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-03 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.5
+    version: 
+description: 
+email: smecsia@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- lib/cassiopeia.rb
+- lib/cassiopeia/active_record_server_mixin.rb
+- lib/cassiopeia/action_controller_server_mixin.rb
+- lib/cassiopeia/config.rb
+- lib/cassiopeia/server.rb
+- lib/cassiopeia/user.rb
+- lib/cassiopeia/client.rb
+- lib/cassiopeia/tickets_controller_config.rb
+- lib/cassiopeia/action_controller_client_mixin.rb
+- lib/cassiopeia/base.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Rails plugin for custom CAS(Cassiopeia) server/client implementation
+test_files: []
+