ixtlan-remote 0.1.0

data/lib/ixtlan-remote.rb

@@ -0,0 +1,23 @@
+#
+# ixtlan-remote - helper sync data between miniapps or communicate wth realtime
+# rest-services
+# Copyright (C) 2012 Christian Meier
+#
+# This file is part of ixtlan-remote.
+#
+# ixtlan-remote is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# ixtlan-remote is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with ixtlan-remote.  If not, see <http://www.gnu.org/licenses/>.
+#
+if defined?(Rails)
+  require 'ixtlan/remote/railtie'
+end

data/lib/ixtlan/passwords.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+require 'erb'
+module Ixtlan
+  class HashWithDefault < ::Hash
+    def get( key, default = HashWithDefault.new )
+      self[ key ] || default
+    end
+  end
+
+  class Passwords
+
+    def self.symbolize_keys(h)
+      result = HashWithDefault.new
+
+      h.each do |k, v|
+        v = ' ' if v.nil?
+        if v.is_a?(Hash)
+          result[k.to_sym] = symbolize_keys(v) unless v.size == 0
+        else
+          result[k.to_sym] = v unless k.to_sym == v.to_sym
+        end
+      end
+      result
+    end
+
+    def self.load( file )
+      rel_file = File.expand_path( file ).sub( /#{File.expand_path '.' }\/?/, '' )
+      if File.exists?( file )
+        warn "[Passwords] Loaded #{rel_file} file"
+        symbolize_keys( YAML::load( ERB.new( IO.read( file ) ).result ) )
+      else
+        warn "[Passwords] No #{rel_file} file to load"
+      end
+    end
+
+    def self.config( file = 'password.yml' )
+      @config ||= load( file ) || HashWithDefault.new
+    end
+
+    def self.[]( key )
+      @config[ key ]
+    end
+
+    def self.get( key, default = nil )
+      if default
+        @config.get( key, default )
+      else
+        @config.get( key )
+      end
+    end
+  end
+end

data/lib/ixtlan/passwords.rb~

@@ -0,0 +1,47 @@
+require 'yaml'
+require 'erb'
+module Ixtlan
+  class Hash < ::Hash
+    def get( key, default = {} )
+      self[ key ] || default
+    end
+  end
+
+  class Passwords
+
+    def self.symbolize_keys(h)
+      result = Hash.new
+
+      h.each do |k, v|
+        v = ' ' if v.nil?
+        if v.is_a?(Hash)
+          result[k.to_sym] = symbolize_keys(v) unless v.size == 0
+        else
+          result[k.to_sym] = v unless k.to_sym == v.to_sym
+        end
+      end
+
+      result
+    end
+
+    def self.load( file )
+      if File.exists?(file)
+        symbolize_keys(YAML::load(ERB.new(IO.read(file)).result))
+      else
+        warn "no #{file} file to load"
+      end
+    end
+
+    def self.config( file = 'password.yml' )
+      @config ||= load( file ) || {}
+    end
+
+    def self.[]( key )
+      @config[ key ]
+    end
+
+    def self.get( key )
+      @config.get( key )
+    end
+  end
+end

data/lib/ixtlan/railtie.rb~

@@ -0,0 +1,17 @@
+require 'ixtlan/remote/rest'
+require 'ixtlan/gettext/manager'
+module Ixtlan
+  module Remote
+
+    class Railtie < Rails::Railtie
+
+      config.rest = Ixtlan::Remote::Rest.new
+
+      config.gettext = Ixtlan::Gettext::Manager.new
+
+      rake_tasks do
+        load 'ixtlan/gettext/translation.rake'
+      end
+    end
+  end
+end

data/lib/ixtlan/remote.rb

@@ -0,0 +1,23 @@
+#
+# ixtlan-remote - helper sync data between miniapps or communicate wth realtime
+# rest-services
+# Copyright (C) 2012 Christian Meier
+#
+# This file is part of ixtlan-remote.
+#
+# ixtlan-remote is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# ixtlan-remote is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with ixtlan-remote.  If not, see <http://www.gnu.org/licenses/>.
+#
+if defined?(Rails)
+  require 'ixtlan/remote/railtie'
+end

data/lib/ixtlan/remote/access_controller.rb

@@ -0,0 +1,62 @@
+#
+# ixtlan-remote - helper sync data between miniapps or communicate wth realtime
+# rest-services
+# Copyright (C) 2012 Christian Meier
+#
+# This file is part of ixtlan-remote.
+#
+# ixtlan-remote is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# ixtlan-remote is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with ixtlan-remote.  If not, see <http://www.gnu.org/licenses/>.
+#
+require 'ixtlan/remote/constant_time_compare'
+module Ixtlan
+  module Remote
+    module AccessController
+
+      private
+
+      include Ixtlan::Remote::ConstantTimeCompare
+
+      # this implementation uses rails request instance
+      def x_service_token
+        request.headers['X-SERVICE-TOKEN']
+      end
+
+      protected
+
+      def permission_model
+        Permission
+      end
+
+      public
+
+      def remote_permission
+        @_remote_permission ||= 
+          begin
+            # constant time for finding the right permission
+            perm = nil
+            token = x_service_token
+            raise "ip #{request.remote_ip} sent no token" unless token
+            permission_model.all.each do |rp|
+              perm = rp if rp.authentication_token && constant_time_compare(rp.authentication_token, token)
+            end
+            raise "ip #{request.remote_ip} wrong authentication" unless perm 
+            # if the perm.ip == nil then do not check IP 
+            # server clusters have many IPs then use perm.ip = nil
+            raise "ip #{request.remote_ip} not allowed" if (!perm.allowed_ip.blank? && request.remote_ip != perm.allowed_ip)
+            perm
+          end
+      end
+    end
+  end
+end

data/lib/ixtlan/remote/access_controller.rb~

@@ -0,0 +1,25 @@
+require 'ixtlan/remote/constant_time_compare'
+module Ixtlan
+  module Remote
+    module AccessController
+      include Ixtlan::Remote::ConstantTimeCompare
+
+      def x_service_token
+        @_x_service_token ||= request.headers['X-SERVICE-TOKEN']
+      end
+
+      def remote_permission
+        # constant time for finding the right permission
+        perm = nil
+        Permission.all.each do |rp|
+          perm = rp if constant_time_compare(rp.token, x_service_token)
+        end
+        raise "ip #{request.remote_ip} wrong authentication" unless perm 
+        # if the perm.ip == nil then do not check IP 
+        # server clusters have many IPs then use perm.ip = nil
+        raise "ip #{request.remote_ip} not allowed" if (!perm.ip.blank? && request.remote_ip != perm.ip)
+        perm
+      end
+    end
+  end
+end

data/lib/ixtlan/remote/constant_time_compare.rb

@@ -0,0 +1,39 @@
+#
+# ixtlan-remote - helper sync data between miniapps or communicate wth realtime
+# rest-services
+# Copyright (C) 2012 Christian Meier
+#
+# This file is part of ixtlan-remote.
+#
+# ixtlan-remote is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# ixtlan-remote is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with ixtlan-remote.  If not, see <http://www.gnu.org/licenses/>.
+#
+module Ixtlan
+  module Remote
+    module ConstantTimeCompare
+
+      # from https://github.com/django/django/blob/master/django/utils/crypto.py#L82
+      # time to compare is independent of the number of matching characters
+      def constant_time_compare(val1, val2)
+        if val1.size != val2.size
+          return false
+        end
+        result = 0
+        val1.unpack('*C').zip(val2.unpack('*C')).each do |a|
+          result |= a[0][0] ^ a[1][0]
+        end
+        result == 0
+      end
+    end
+  end
+end

data/lib/ixtlan/remote/constant_time_compare.rb~

@@ -0,0 +1,19 @@
+module Ixtlan
+  module Remote
+    module ConstantTimeCompare
+
+      # from https://github.com/django/django/blob/master/django/utils/crypto.py#L82
+      # time to compare is independent of the number of matching characters
+      def constant_time_compare(val1, val2)
+        if val1.size != val2.size
+          return false
+        end
+        result = 0
+        val1.chars.zip(val2.chars).each do |a|
+          result |= a[0][0] ^ a[1][0]
+        end
+        result == 0
+      end
+    end
+  end
+end

data/lib/ixtlan/remote/heartbeat.rb~

@@ -0,0 +1,80 @@
+class Ixtlan::Remote::Heartbeat
+
+  class Summary
+    attr_reader :clazz
+    attr_accessor :count, :failures
+
+    def initialize(clazz)
+      @count = 0
+      @failures = 0
+      @clazz = clazz
+    end
+
+    def to_log
+      "update #{@clazz} - total: #{@count + @failures}  success: #{@count}  failures: #{@failures}"
+    end
+  end
+
+  def initialize(restserver)
+    @count = 0
+    @failures = 0
+    @restserver = restserver
+  end
+
+  def clazzes
+    @clazzes ||= []
+  end
+
+  def register(clazz)
+    c = clazz.to_s.pluralize.underscore
+    clazzes << c unless clazzes.member?(c)
+  end
+
+  if defined? ActiveRecord
+    def max(clazz)
+      @restserver.to_class(clazz).maximum(:updated_at)
+    end
+  else
+    def max(clazz)
+      @restserver.to_class(clazz).max(:updated_at)
+    end
+  end
+  private :max
+
+  def last_update(clazz)
+    @last_update ||= begin 
+                       last_date = (max(clazz) || 2000.years.ago).utc
+                       p last_date
+                       last_date.strftime('%Y-%m-%d %H:%M:%S.') + ("%06d" % (last_date.sec_fraction / Date::NANOSECONDS_IN_DAY / 1000))
+                     end
+  end
+  private :last_update
+
+  def beat(set = clazzes)
+    @last_result = []
+    set.to_a.each do |clazz|
+      summary = Summary.new(clazz)
+      @last_result << summary
+      @restserver.retrieve(clazz, :last_changes, :updated_at => last_update(clazz)).each do |item|
+        p item
+        result = item.save
+        if result
+          summary.count = summary.count + 1
+        else
+          p item.new?
+          p item.errors
+          summary.failures = summary.failures + 1
+        end
+      end
+    end
+    to_log
+  end
+  def to_log
+    if @last_result
+      @last_result.collect { |r| r.to_log }.join("\n\t")
+    else
+      "no results yet"
+    end
+  end
+  alias :to_s :to_log
+end

data/lib/ixtlan/remote/model_conversion.rb~

@@ -0,0 +1,245 @@
+require 'rest-client'
+module Ixtlan
+  module Remote
+    module ModelHelpers
+
+      def to_model_underscore(data)
+        to_model(data).to_s.underscore
+      end
+
+      def to_model_singular_underscore(data)
+        to_model.underscore.singular
+      end
+
+      def to_model(data)
+        case data
+        when Hash
+          data.keys.first
+        when Array
+          if data.empty?
+            #TODO
+          else
+            to_model_class(data[0].class)
+          end
+        when String
+          data
+        when Symbol
+          data
+        when Class
+          to_model_class(data)
+        else
+          to_model_class(data.class)
+        end
+      end
+
+      def to_model_class(obj)
+        obj.respond_to?(:model_name) ? obj.model_name.constantize : obj.class
+      end
+
+      def model_map
+        @_model_map ||= {}
+      end
+    end
+
+    class RestResourceConfig
+
+      def register(server_name, url, options = {})
+        models = options.delete(:models).dup
+        #model_map = 
+          case models
+          when Array
+            map = {}
+            models.each do |model|
+              model_map[to_model_singular_underscore(model)] = model
+            end
+            map
+          when Hash
+            models
+          else
+            {}
+          end
+        
+        s = servers[server_name.to_sym] = RestResourceFactory.new(url, model_map, options)
+       
+        model_map.keys.each do |k|
+          model_to_servers[k] = s
+        end
+        s
+      end
+      
+      def model_to_servers
+        @_models ||= {}
+      end
+
+      def new_resource(model)
+        model_to_servers[model].new
+      end
+
+      def to_class(model)
+        key = to_model_singular_underscore(model)
+        model_to_servers[key].to_class(key)
+      end
+
+      def servers
+        @_servers ||= {}
+      end
+
+      def server(name)
+        servers[name.to_sym]
+      end
+
+      def create(model, *args)
+        new_resource(model).create(model, *args).send
+      end
+
+      def retrieve(model, *args)
+        resource = new_resource(model)
+        if args.last.is_a? Hash
+          params = args.delete_at(args.size - 1)
+          resource.retrieve(model, *args).query_params(params)
+        else
+          resource.retrieve(model, *args)
+        end
+        resource.send
+      end
+
+      def update(model, *args)
+         new_resource(model).update(model, *args).send
+      end
+
+      def delete(model, *args)
+        new_resource(model).delete(model, *args).send
+      end
+
+      include ModelHelpers
+    end
+
+    class RestResource
+
+      include ModelHelpers
+
+      def initialize(resource, model_map = {})
+        @base = resource
+        @map = model_map
+      end
+
+      def send(&block)
+        raise "no method given - call any CRUD method first" unless @method
+        headers = {:content_type => :json, :accept => :json}
+        headers[:params] = @params if @params
+        result =
+          if @payload
+            @resource.send @method, @payload.to_json, headers, &block
+          else
+            @resource.send @method, headers, &block
+          end
+        result = JSON.load(result)
+        if @model
+          root = @model_key || @model.to_s.underscore
+          if result.is_a? Array
+            result.collect do |r|
+              first_or_new(r[root])
+            end
+          else
+            first_or_new(result[root])
+          end
+        else
+          result
+        end
+      end
+
+      def query_params(params)
+        @params = params
+        self
+      end
+
+      # retrieve(Locale) => GET /locales
+      # retrieve(Locale, 1) => GET /locales/1
+      # retrieve(:locales) => GET /locales
+      # retrieve(:locales, 1) => GET /locales/1
+      def retrieve(*args)
+        @method = :get
+        @payload = nil
+        @params = nil
+        @resource = @base[path(*args)]
+        self
+      end
+
+      # create(locale) => POST /locales
+      # create(:locale => {:code => 'en'}) => POST /locales
+      def create(*obj_or_hash)
+        @method = :post
+        @payload = nil#obj_or_hash.is_a?(Class)? nil : obj_or_hash
+        @params = nil
+        @resource = @base[path(*obj_or_hash)]
+        self
+      end
+
+      def update(*obj_or_hash)
+        @method = :put
+        @payload = nil#obj_or_hash.is_a?(Class)? nil : obj_or_hash
+        @params = nil
+        @resource = @base[path(*obj_or_hash)]
+        self
+      end
+
+      def delete(*obj_or_hash)
+        @method = :delete
+        @payload = nil #obj_or_hash.is_a?(Class)? nil : obj_or_hash
+        @params = nil
+        @resource = @base[path(*obj_or_hash)]
+        self
+      end
+
+      private
+
+      def first_or_new(attributes)
+        cond = {}
+        @model.key.each { |k| cond[k.name] = attributes[k.name.to_s] }
+        m = @model.first_or_new(cond)
+        m.attributes = attributes
+        m
+      end
+
+      def path(*parts)
+        parts.collect {|p| path_part(p)} * '/'
+      end
+
+      def model=(model)
+        m = @map[model.singularize]
+        m ||= model.singularize.camelize.constantize rescue nil
+        if m
+          @model = m 
+          @model_key = model.singularize.underscore
+        end
+      end
+
+      def path_part(data)
+        model = to_model_underscore(data)
+        case data
+        when Hash
+          @payload = data
+          self.model = model
+          model = model.pluralize
+        when Array
+          @payload = data
+          self.model = model
+          model = model.pluralize
+        when String
+          self.model = model
+        when Fixnum
+        when Symbol
+          self.model = model
+        when Class
+          model = model.pluralize
+        else
+          @payload = data
+          self.model = model
+          model = model.pluralize
+        end
+        model.underscore
+      end
+
+    end
+  end
+end