stormpath-sdk 0.4.0 → 1.0.0.beta

data/lib/stormpath-sdk/cache/redis_store.rb

@@ -0,0 +1,32 @@
+require 'redis'
+
+module Stormpath
+  module Cache
+    class RedisStore
+      def initialize(opts = {})
+        @redis = Redis.new opts
+      end
+
+      def get(key)
+        entry = @redis.get key
+        entry && Stormpath::Cache::CacheEntry.from_h(MultiJson.load(entry))
+      end
+
+      def put(key, entry)
+        @redis.set key, MultiJson.dump(entry.to_h)
+      end
+
+      def delete(key)
+        @redis.del key
+      end
+
+      def clear
+        @redis.flushdb
+      end
+
+      def size
+        @redis.dbsize
+      end
+    end
+  end
+end

data/lib/stormpath-sdk/client.rb

@@ -0,0 +1,111 @@
+#
+# Copyright 2012 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'java_properties'
+
+module Stormpath
+
+  class Client
+    include Stormpath::Util::Assert
+
+    attr_reader :data_store, :application
+
+    def initialize(options)
+      api_key = options[:api_key]
+      base_url = options[:base_url]
+      cache_opts = options[:cache] || {}
+
+      api_key = if api_key
+        case api_key
+        when ApiKey then api_key
+        when Hash then ApiKey.new api_key[:id], api_key[:secret]
+        end
+      elsif options[:api_key_file_location]
+        load_api_key_file options[:api_key_file_location],
+          options[:api_key_id_property_name],
+          options[:api_key_secret_property_name]
+      end
+
+      assert_not_nil api_key, "No API key has been provided.  Please " +
+          "pass an 'api_key' or 'api_key_file_location' to the " +
+          "Stormpath::Client constructor."
+
+      request_executor = Stormpath::Http::HttpClientRequestExecutor.new(api_key, proxy: options[:proxy])
+      @data_store = Stormpath::DataStore.new(request_executor, cache_opts, self, base_url)
+    end
+
+    def tenant
+      Stormpath::Resource::Tenant.new '/tenants/current', self
+    end
+
+    def client
+      self
+    end
+
+    def cache_stats
+      @data_source.cache_stats
+    end
+
+    include Stormpath::Resource::Associations
+
+    has_many :applications, href: '/applications', can: [:get, :create], delegate: true
+    has_many :directories, href: '/directories', can: [:get, :create], delegate: true
+    has_many(:accounts, href: '/accounts', can: :get) do
+      def verify_email_token(token)
+        token_href = "#{href}/emailVerificationTokens/#{token}"
+        token = Stormpath::Resource::EmailVerificationToken.new(
+          token_href,
+          client
+        )
+        data_store.save token, Stormpath::Resource::Account
+      end
+    end
+    has_many :groups, href: '/groups', can: :get
+    has_many :group_memberships, href: '/groupMemberships', can: [:get, :create]
+
+    private
+
+    def load_api_key_file(api_key_file_location, id_property_name, secret_property_name)
+      begin
+        api_key_properties = JavaProperties::Properties.new api_key_file_location
+      rescue
+        raise ArgumentError,
+          "No API Key file could be found or loaded from '" +
+          api_key_file_location +
+          "'."
+      end
+
+      id_property_name ||= 'apiKey.id'
+      secret_property_name ||= 'apiKey.secret'
+
+      api_key_id = api_key_properties[id_property_name]
+      assert_not_nil api_key_id,
+        "No API id in properties. Please provide a 'apiKey.id' property in '" +
+        api_key_file_location +
+        "' or pass in an 'api_key_id_property_name' to the Stormpath::Client " +
+        "constructor to specify an alternative property."
+
+      api_key_secret = api_key_properties[secret_property_name]
+      assert_not_nil api_key_secret,
+        "No API secret in properties. Please provide a 'apiKey.secret' property in '" +
+        api_key_file_location +
+        "' or pass in an 'api_key_secret_property_name' to the Stormpath::Client " +
+        "constructor to specify an alternative property."
+
+      ApiKey.new api_key_id, api_key_secret
+    end
+
+  end
+end

data/lib/stormpath-sdk/data_store.rb

@@ -0,0 +1,241 @@
+#
+# Copyright 2012 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+class Stormpath::DataStore
+  include Stormpath::Http
+  include Stormpath::Util::Assert
+
+  DEFAULT_SERVER_HOST = "api.stormpath.com"
+  DEFAULT_API_VERSION = 1
+
+  CACHE_REGIONS = %w( applications directories accounts groups groupMemberships tenants )
+
+  attr_reader :client, :request_executor
+
+  def initialize(request_executor, cache_opts, client, *base_url)
+    assert_not_nil request_executor, "RequestExecutor cannot be null."
+
+    @client = client
+    @base_url = get_base_url(*base_url)
+    @request_executor = request_executor
+    initialize_cache cache_opts
+  end
+
+  def initialize_cache(cache_opts)
+    @cache_manager = Stormpath::Cache::CacheManager.new
+    regions_opts = cache_opts[:regions] || {}
+    CACHE_REGIONS.each do |region|
+      region_opts = regions_opts[region.to_sym] || {}
+      region_opts[:store] ||= cache_opts[:store]
+      @cache_manager.create_cache region, region_opts
+    end
+  end
+
+  def instantiate(clazz, properties = {})
+    clazz.new properties, client
+  end
+
+  def get_resource(href, clazz, query=nil)
+    q_href = if needs_to_be_fully_qualified href
+               qualify href
+             else
+               href
+             end
+
+    data = execute_request('get', q_href, nil, query)
+    instantiate clazz, data.to_hash
+  end
+
+  def create(parent_href, resource, return_type)
+    save_resource(parent_href, resource, return_type).tap do |returned_resource|
+      if resource.kind_of? return_type
+        resource.set_properties to_hash(returned_resource)
+      end
+    end
+  end
+
+  def save(resource, clazz = nil)
+    assert_not_nil resource, "resource argument cannot be null."
+    assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
+
+    href = resource.href
+    assert_true href.length > 0, "save may only be called on objects that have already been persisted (i.e. they have an existing href)."
+
+    href = if needs_to_be_fully_qualified(href)
+             qualify(href)
+           else
+             href
+           end
+
+    clazz ||= resource.class
+
+    save_resource(href, resource, clazz).tap do |return_value|
+      resource.set_properties return_value
+    end
+  end
+
+  def delete(resource)
+    assert_not_nil resource, "resource argument cannot be null."
+    assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
+
+    execute_request('delete', resource.href)
+  end
+
+  def cache_manager
+    @cache_manager
+  end
+
+  protected
+
+  def needs_to_be_fully_qualified(href)
+    !href.downcase.start_with? 'http'
+  end
+
+  def qualify(href)
+    slash_added = ''
+
+    if !href.start_with? '/'
+      slash_added = '/'
+    end
+
+    @base_url + slash_added + href
+  end
+
+  private
+
+  def execute_request(http_method, href, body=nil, query=nil)
+    if http_method == 'get' && (cache = cache_for href)
+      cached_result = cache.get href
+      return cached_result if cached_result
+    end
+
+    request = Request.new(http_method, href, query, Hash.new, body)
+    apply_default_request_headers request
+    response = @request_executor.execute_request request
+
+    result = response.body.length > 0 ? MultiJson.load(response.body) : ''
+
+    if response.error?
+      error = Stormpath::Resource::Error.new result
+      #puts "Error with request: #{http_method.upcase}: #{href}"
+      raise Stormpath::Error.new error
+    end
+
+    if http_method == 'delete'
+      cache = cache_for href
+      cache.delete href if cache
+      return nil
+    end
+
+    if result['href']
+      cache_walk result
+    else
+      result
+    end
+  end
+
+  def cache_walk(resource)
+    assert_not_nil resource['href'], "resource must have 'href' property"
+    items = resource['items']
+
+    if items # collection resource
+      resource['items'] = items.map do |item|
+        cache_walk item
+        { 'href' => item['href'] }
+      end
+    else     # single resource
+      resource.each do |attr, value|
+        if value.is_a? Hash
+          walked = cache_walk value
+          resource[attr] = { 'href' => value['href'] }
+          resource[attr]['items'] = walked['items'] if walked['items']
+        end
+      end
+      cache resource if resource.length > 1
+    end
+    resource
+  end
+
+  def cache(resource)
+    cache = cache_for resource['href']
+    cache.put resource['href'], resource if cache
+  end
+
+  def cache_for(href)
+    @cache_manager.get_cache(region_for href)
+  end
+
+  def region_for(href)
+    return nil unless href
+    region = href.split('/')[-2]
+    CACHE_REGIONS.include?(region) ? region : nil
+  end
+
+  def apply_default_request_headers(request)
+    request.http_headers.store 'Accept', 'application/json'
+    request.http_headers.store 'User-Agent', 'Stormpath-RubySDK/' + Stormpath::VERSION
+
+    if !request.body.nil? and request.body.length > 0
+      request.http_headers.store 'Content-Type', 'application/json'
+    end
+  end
+
+  def save_resource(href, resource, return_type)
+    assert_not_nil resource, "resource argument cannot be null."
+    assert_not_nil return_type, "returnType class cannot be null."
+    assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
+
+    q_href = if needs_to_be_fully_qualified href
+               qualify href
+             else
+               href
+             end
+
+    response = execute_request('post', q_href, MultiJson.dump(to_hash(resource)))
+    instantiate return_type, response.to_hash
+  end
+
+  def get_base_url(*base_url)
+    (!base_url.empty? and !base_url[0].nil?) ?
+      base_url[0] :
+      "https://" + DEFAULT_SERVER_HOST + "/v" + DEFAULT_API_VERSION.to_s
+  end
+
+  def to_hash(resource)
+    Hash.new.tap do |properties|
+      resource.get_property_names.each do |name|
+        property = resource.get_property name
+
+        if property.kind_of? Hash
+          property = to_simple_reference name, property
+        end
+
+        properties.store name, property
+      end
+    end
+  end
+
+  def to_simple_reference(property_name, hash)
+    href_prop_name = Stormpath::Resource::Base::HREF_PROP_NAME
+    assert_true(
+      (hash.kind_of?(Hash) and !hash.empty? and hash.has_key?(href_prop_name)),
+      "Nested resource '#{property_name}' must have an 'href' property."
+    )
+
+    href = hash[href_prop_name]
+
+    {href_prop_name => href}
+  end
+end

data/lib/stormpath-sdk/{client/api_key.rb → error.rb}

@@ -13,21 +13,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-module Stormpath
+class Stormpath::Error < RuntimeError
 
-  module Client
+  def initialize error = nil
+    super !error.nil? ? error.message : ''
+    @error = error
+  end
 
-    class ApiKey
+  def status
+    !@error.nil? ? @error.status : -1
+  end
 
-      attr_accessor :id, :secret
+  def code
+    !@error.nil? ? @error.code : -1
+  end
 
-      def initialize(id, secret)
-        @id = id
-        @secret = secret
-      end
-    end
+  def developer_message
+    !@error.nil? ? @error.developer_message : nil
+  end
 
+  def more_info
+    !@error.nil? ? @error.more_info : nil
   end
 
 end
-

data/lib/stormpath-sdk/{util → ext}/hash.rb

@@ -15,8 +15,6 @@
 #
 class Hash
 
-  # implementation borrowed from the vine project at
-  # https://github.com/guangnan/vine/blob/master/lib/vine.rb
   def access(path, separator)
     ret = self
     path.split(separator).each do |p|
@@ -29,4 +27,5 @@ class Hash
     end
     ret
   end
+
 end

data/lib/stormpath-sdk/http/authc/sauthc1_signer.rb

@@ -23,7 +23,7 @@ module Stormpath
 
         include OpenSSL
         include UUIDTools
-        include Stormpath::Util
+        include Stormpath::Http::Utils
 
         DEFAULT_ALGORITHM = "SHA256"
         HOST_HEADER = "Host"
@@ -40,20 +40,24 @@ module Stormpath
         #noinspection RubyConstantNamingConvention
         NL = "\n"
 
+        def initialize(uuid_generator=UUID.method(:random_create))
+          @uuid_generator = uuid_generator
+        end
+
         def sign_request request, api_key
 
           time = Time.now
           time_stamp = time.utc.strftime TIMESTAMP_FORMAT
           date_stamp = time.utc.strftime DATE_FORMAT
 
-          nonce = UUID.random_create.to_s
+          nonce = @uuid_generator.call.to_s
 
           uri = request.resource_uri
 
           # SAuthc1 requires that we sign the Host header so we
           # have to have it in the request by the time we sign.
           host_header = uri.host
-          if !RequestUtils.default_port?(uri)
+          if !default_port?(uri)
 
             host_header << ":" << uri.port.to_s
           end
@@ -180,7 +184,7 @@ module Stormpath
           if resource_path.nil? or resource_path.empty?
             '/'
           else
-            RequestUtils.encode_url resource_path, true, true
+            encode_url resource_path, true, true
           end
         end