jungle_path 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7c640c8f8482983063d216433074adca552b14c
+  data.tar.gz: 26812a3c5aa1cfacf98b9fd787fd56b6620a3df1
+SHA512:
+  metadata.gz: 2250667bf6a1780bd176fff62161379246a7eb358ae8fe0f497db34d2540087756ee291221f32f73628fc085b516aad4c2eeb492c379da123d51b5567a3009f2
+  data.tar.gz: 597fbde8599a34552c5e7db85cf9a0efdf03b6a9463ccf51c1f6840d5c6f5cc6c94971952aa66dc5147121112491e9e77a7103fcc9fc2672cc49c42839e686f1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.devnotes
+.greenbar
+.yardoc
+.rubocop-*
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bin

data/.ruby-gemset

@@ -0,0 +1 @@
+junglepathdev

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/Gemfile

@@ -0,0 +1,22 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+# gem "rails"
+gem 'pry'
+gem 'pry-byebug'
+gem 'sequel'
+gem 'pg'
+gem 'sequel_pg', :require=>'sequel'
+gem 'sinatra'
+gem 'rack-contrib'
+gem 'rack-mobile-detect'
+gem 'sinatra-param'
+gem 'sinatra-basic-auth'
+gem 'oj', '2.17.4'
+gem 'http'
+gem 'redis'
+gem 'cache'
+gem 'tiny_tds'
+gem 'aws-sdk', '~> 2'
+gem 'memory_profiler'
+gem 'celluloid'

data/README.md

@@ -0,0 +1,5 @@
+# Jungle Path
+
+A new Ruby framework (and gem) for writing modern API services.
+
+Version 0.0.0

data/jungle_path.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jungle_path'
+  spec.version       = '0.0.0'
+  spec.authors       = ['Michael VanZant']
+  spec.email         = ['mxvanzant@yahoo.com']
+  spec.summary       = 'Full-stack web application framework for creating API services.'
+  spec.description   = 'Jungle Path is a full-stack web application framework for creating API services.'
+  spec.homepage      = 'https://rubygems.org/gems/jungle_path'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  #spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.3.1'
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+
+  #spec.files         = `git ls-files -- lib/* CHANGELOG.md LICENSE.md README.md hanami-utils.gemspec`.split($/)
+	#spec.files         = ['lib/jungle_path-json.rb', 'lib/jungle_path/json.rb']
+  #spec.files         = `git ls-files`.split($/)
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  #spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  #spec.require_paths = ['lib']
+  #spec.required_ruby_version = '>= 2.3.1'
+  #spec.add_runtime_dependency 'oj', '2.17.4'
+  #spec.add_runtime_dependency 'sequel', '>= 4.0.0'
+  #spec.add_runtime_dependency 'pg'
+  #spec.add_runtime_dependency 'sequel_pg'
+  #spec.add_runtime_dependency 'sinatra', '~> 1.3'
+  #spec.add_runtime_dependency 'rack-contrib'
+  #spec.add_runtime_dependency 'sinatra-param'
+  #spec.add_runtime_dependency 'sinatra-basic-auth'
+  #spec.add_development_dependency 'bundler', '~> 1.6'
+  #spec.add_development_dependency 'rake',    '~> 11'
+end

data/lib/jungle_path/api/helpers/auth.rb

@@ -0,0 +1,45 @@
+module JunglePath
+	require 'jungle_path/authentication/data_provider/default'
+	module API
+		module Helpers
+			module Auth
+				def authenticate auth_provider=nil, data_provider=nil, no_cache=false
+					puts "Auth.authenticate"
+					data_provider = JunglePath::Authentication::DataProvider::Default.new unless data_provider
+					auth_provider = JunglePath::Authentication::AuthProvider::Default.new unless auth_provider
+					@current_identity = auth_provider.authenticate(data_provider, no_cache)
+					halt 401 unless @current_identity and @current_identity.valid?
+					request.body.rewind
+				end
+
+				def current_identity
+					@current_identity
+				end
+
+				def current_user
+					@current_identity and @current_identity.user
+				end
+
+				def current_key
+					@current_identity and @current_identity.key
+				end
+
+				def current_roles
+					@current_identity and @current_identity.roles
+				end
+
+				def current_role
+					@current_identity and @current_identity.default_role
+				end
+
+				def current_auth
+					@current_identity and @current_identity.auth
+				end
+
+				def current_query_filters
+					@current_identity and @current_identity.query_filters
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/api/helpers/auth_local_user.rb

@@ -0,0 +1,284 @@
+module JunglePath
+	module API
+		module Helpers
+			module AuthLocalUser
+				class Identity
+					attr_accessor :remote_user, :remote_password, :user_name, :user, :key, :valid, :roles, :auth
+					def to_s
+						"AuthLocalUser::Identity: {\n  remote_user: #{@remote_user},\n  remote_password: #{@remote_password},\n  user_name: #{@user_name},\n  user: #{@user},\n  key: #{@key},\n  valid: #{@valid},\n  roles: #{@roles},\n  auth: #{@auth}\n}"
+					end
+				end
+
+				# If you are using this module, make sure your user table has these columns:
+				#    id,
+				#    user_name,
+				#    phone,
+				#    sms_verification_code,
+				#    hash,
+				#    key,
+				#    role
+				def authenticate no_cache=false
+					puts "AuthLocalUser.authenticate !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+					remote_user = request.env['REMOTE_USER']
+					remote_password = request.env['REMOTE_PASSWORD']
+					puts "remote_user: #{remote_user}."
+					puts "remote_password: #{remote_password}."
+					is_authenticated = basic_authentication(remote_user, remote_password, no_cache)
+					unless is_authenticated
+						# force no_cache = true
+						halt 401 unless basic_authentication(remote_user, remote_password, true)
+					end
+					#puts "content-type: #{request.content_type}."
+					request.body.rewind
+					#puts "body:\n#{request.body.read}."
+					#puts "params:\n#{params}."
+				end
+
+				def basic_authentication remote_user, remote_password, no_cache=false
+					identity, assume_identity = parse_identities(remote_user, remote_password)
+					puts "identity: #{identity}"
+					puts "assume_identity: #{assume_identity}"
+					#puts "APIHelpers::AuthLocalUser.#{__method__}."
+					#if user_name and user_name.start_with?("sk_")
+
+					#valid = authenticate_user(auth.user_name, password, no_cache)
+					valid = false
+					identity = authenticate_identity(identity, no_cache)
+					if identity.valid
+						identity.roles = get_roles(identity.key, no_cache)
+						identity.auth = get_auth(identity.roles, no_cache)
+						#set_current_roles roles
+						#set_current_auth
+						if assume_identity
+							puts "assume_identity..."
+							assume_identity = authenticate_assumed_identity(assume_identity, no_cache)
+							assume_identity.roles = get_roles(assume_identity.key, no_cache)
+							assume_identity.auth = get_auth(assume_identity.roles, no_cache)
+							valid = assume_identity.valid
+							set_current_identity assume_identity, no_cache
+						else
+							valid = identity.valid
+							set_current_identity identity, no_cache
+						end
+					else
+						#set_current_roles nil
+						set_current_identity identity, no_cache
+					end
+					valid
+				end
+
+				def authenticate_identity identity, no_cache=false
+					id = identity.dup
+					id.user = get_user(identity.user_name, identity.remote_password, no_cache)
+					id.key = id.user
+					id.valid = (id.user and id.user.is_valid)
+					id
+				end
+
+				def authenticate_assumed_identity identity, no_cache=false
+					id = identity.dup
+					id.user = get_assumed_user(identity.user_name, no_cache)
+					id.key = id.user
+					id.valid = (id.user and id.user.is_valid)
+					id
+				end
+
+				def authenticate_user user_name, password, no_cache=false
+					user = get_user(user_name, password, no_cache)
+					set_current_user(user)
+					valid = (user and user.is_valid)
+				end
+
+				def get_assumed_user user_name, no_cache=false
+					cache_key = "#{user_name}.password"
+					user = cache[cache_key]
+					if user == nil or no_cache
+						lowercase_user_name = nil
+						lowercase_user_name = user_name.downcase if user_name
+						ds = db.base['select id, user_name, name, first_name, last_name, phone, email, hash, key, active from "user" where user_name = ? or email = ?', lowercase_user_name, lowercase_user_name]
+						hash = ds.first
+						#puts "get_user: hash: #{hash}."
+						user = Schema::User.new(hash, false) if hash
+						halt 401, "Unauthorized" unless user
+						halt 401, "Unauthorized: user #{user.user_name} is not marked as active." unless user.active
+						user.is_valid = true
+						cache[cache_key] = user if user
+					end
+					user
+				end
+
+				def get_user user_name, password, no_cache=false
+					# is this username/password valid?
+					cache_key = "#{user_name}.#{password}"
+					user = cache[cache_key]
+					if user == nil or no_cache
+						#assumed_user = nil
+						ds = nil
+						if user_name_is_key? user_name
+							ds = db.base['select id, user_name, name, first_name, last_name, phone, email, hash, key, active from "user" where key = ?', user_name.downcase]
+						else
+							lowercase_user_name = nil
+							lowercase_user_name = user_name.downcase if user_name
+							ds = db.base['select id, user_name, name, first_name, last_name, phone, email, hash, key, active from "user" where user_name = ?', lowercase_user_name]
+						end
+						hash = ds.first
+						#puts "get_user: hash: #{hash}."
+						user = Schema::User.new(hash, false) if hash
+						halt 401, "Unauthorized" unless user
+						halt 401, "Unauthorized: user #{user.user_name} is not marked as active." unless user.active
+						if user_name_is_key? user_name
+							user.is_valid = true
+						else
+							user.is_valid = valid_user?(user, password)
+						end
+						cache[cache_key] = user if user
+					end
+					user.password = password
+					user
+				end
+
+				def user_name_is_key? user_name
+					user_name and user_name.start_with?("sk_") and !user_name.include?("@")
+				end
+
+				def parse_identities remote_user, remote_password
+					identity = Identity.new
+					identity.remote_user = remote_user
+					identity.remote_password = remote_password
+					assume_identity = nil
+					if remote_user and remote_user.include?("|")
+						parts = remote_user.split('|')
+						identity.user_name = parts[1]
+						assume_identity = Identity.new
+						assume_identity.user_name = parts[0]
+						assume_identity.remote_user = remote_user
+						assume_identity.remote_password = remote_password
+					else
+						identity.user_name = remote_user
+					end
+					return identity, assume_identity
+				end
+
+				def valid_user?(user, password)
+					valid = (user and PasswordHash.validatePassword(password, user.hash))
+				end
+
+				def get_roles key, no_cache=false
+					return nil unless key
+					cache_key = "#{key.id}_roles"
+					roles = cache.get(cache_key)
+					if roles == nil or no_cache
+						roles = SQL::Role.by_user(db, key)
+						cache.set cache_key, roles if roles
+					end
+					roles
+				end
+
+				def zget_roles no_cache=false
+					return nil unless current_key
+					cache_key = "#{current_key.id}_roles"
+					roles = cache.get(cache_key)
+					if roles == nil or no_cache
+						roles = SQL::Role.by_user(db, current_key)
+						cache.set cache_key, roles if roles
+					end
+					roles
+				end
+
+				def get_auth roles, no_cache=false
+					cache_key = "#{roles}_auth"
+					puts "get_auth cache_key: #{cache_key}."
+					auth = cache.get(cache_key)
+					if auth == nil or no_cache
+						auth = JunglePath::Authorization::Filter.new roles, Schema::Base.models, configatron.application.role_permissions, configatron.application.role_restrictions, configatron.application.role_schema_filters, configatron.schema.filters
+					end
+					auth
+				end
+
+				def get_query_filters no_cache=false
+					# get filters from query_filter table.
+					return nil unless current_key
+					cache_key = "#{current_key.id}_query_filters"
+					query_filters = cache.get(cache_key)
+					if query_filters == nil or no_cache
+						query_filters = []
+						#filters = SQL::QueryFilter.by_key(db, current_key)
+						#filters.each do |filter|
+						#  query_filters << Query::Filter.new(filter[:base_table_name], filter[:sub_select])
+						#end
+						if app_defined_query_filters
+							app_defined_query_filters.each do |filter|
+								query_filters << filter
+							end
+						end
+						cache.set cache_key, query_filters
+					end
+					query_filters
+				end
+
+				def set_current_identity identity, no_cache=false
+					puts "set_current_identity: #{identity.user.user_name}" if identity and identity.user
+					@current_identity = identity
+					set_current_user identity.user
+					set_current_roles identity.roles
+					set_current_auth identity.auth
+					set_current_query_filters no_cache
+				end
+
+				def set_current_user user
+					@current_user = user
+				end
+
+				def set_current_roles roles
+					@current_role = nil #configatron.default.role
+					@current_roles = roles
+					if roles
+						roles.each do |role|
+							@current_role = role[:name]
+							break
+						end
+					end
+				end
+
+				def set_current_auth auth
+					#@current_auth = ::Authorization::Filter.new current_roles, configatron.application.role_permissions, configatron.application.role_restrictions
+					@current_auth = auth
+					@current_user.auth = @current_auth if @current_user
+				end
+
+				def set_current_query_filters no_cache=false
+					@current_query_filters = get_query_filters(no_cache)
+					@current_user.query_filters = @current_query_filters
+				end
+
+				def current_identity
+					@current_identity
+				end
+
+				def current_user
+					@current_user
+				end
+
+				def current_key
+					@current_user
+				end
+
+				def current_roles
+					@current_roles
+				end
+
+				def current_role
+					@current_role
+				end
+
+				def current_auth
+					@current_auth
+				end
+
+				def current_query_filters
+					@current_query_filters
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/api/helpers/auth_old.rb

@@ -0,0 +1,232 @@
+module JunglePath
+	module API
+		module Helpers
+			module AuthOld
+				def authenticate no_cache=false
+					user_name = request.env['REMOTE_USER']
+					password = request.env['REMOTE_PASSWORD']
+					valid, authentication_messages = basic_authentication(user_name, password, no_cache)
+					unless valid
+						valid, authentication_messages = basic_authentication(user_name, password, true)
+						halt 401, authentication_messages.join("\n") unless valid
+					end
+					request.body.rewind
+				end
+
+				def basic_authentication user_name, password, no_cache=false
+					authentication_messages = []
+					if user_name and user_name.start_with?("sk_")
+						valid = authenticate_key(user_name, no_cache)
+						if valid
+							authentication_messages << "key is valid: #{current_key.to_h}."
+							user = get_user_from_key(current_key, no_cache)
+							unless user
+								authentication_messages << "User not found for current_key."
+								valid = false
+							end
+							set_current_user user
+						else
+							authentication_messages << "key #{user_name} is not valid."
+							set_current_user nil
+						end
+					else
+						valid = authenticate_user(user_name, password, no_cache)
+						if valid
+							authentication_messages << "User is valid: #{current_user.to_h}."
+							key = get_default_key(current_user.id, no_cache)
+							unless key
+								authentication_messages << "Default key not found for current_user."
+								valid = false
+							end
+							set_current_key(key)
+						else
+							authentication_messages << "User #{user_name} is not valid."
+							set_current_key( nil)
+						end
+					end
+					messages = authentication_messages.join("\n    ")
+					if valid
+						roles = get_roles(no_cache)
+						set_current_roles roles
+						set_current_auth
+						set_current_query_filters(no_cache)
+					else
+						set_current_roles nil
+					end
+					[valid, authentication_messages]
+				end
+
+				def authenticate_key key_string, no_cache=false
+					key = get_key(key_string, no_cache)
+					set_current_key(key)
+					valid = (key and key.valid?)
+				end
+
+				def authenticate_user user_name, password, no_cache=false
+					user = get_user(user_name, password, no_cache)
+					set_current_user(user)
+					valid = (user and user.is_valid)
+				end
+
+				def get_user user_name, password, no_cache=false
+					cache_key = "#{user_name}.#{password}"
+					user = cache.get(cache_key)
+					#puts "user: #{user}."
+					if user == nil or no_cache
+						hash = SQL::User.by_user_name(db, user_name)
+						puts "hash: #{hash}."
+						user = Schema::User.new(hash, false) if hash
+						user.is_valid = valid_user?(user, password) if user
+						cache.set cache_key, user if user
+					end
+					user
+				end
+
+				def get_user_from_key key, no_cache=false
+					user = nil
+					if key
+						cache_key = "user_by_key_#{key.key}"
+						user = cache.get(cache_key)
+						if user == nil or no_cache
+							user = Controller::User.new(current_user, current_key, {id: key.user_id}, db).select
+							cache.set cache_key, user if user
+						end
+					end
+					user
+				end
+
+				def get_any_user user_name, password, no_cache=false
+					cache_key = "#{user_name}.#{password}"
+					user = cache.get(cache_key)
+					puts "user: #{user}."
+					if user == nil or no_cache
+						hash = SQL::AnyUser.by_user_name(db, user_name)
+						puts "hash: #{hash}."
+						user = Schema::User.new(hash, false) if hash
+						user.is_valid = valid_user?(user, password) if user
+						cache.set cache_key, user if user
+					end
+					user
+				end
+
+				def valid_user? user, password
+					valid = (user and PasswordHash.validatePassword(password, user.hash))
+				end
+
+				def get_key key_string, no_cache=false
+					key = cache.get(key_string)
+					if key == nil or no_cache
+						array = SQL::Key.by_key(db, key_string)
+						hash = array.first if array
+						key = Schema::Key.new(hash) if hash
+						cache.set key_string, key if key
+					end
+					puts "key.key: #{key.key}."
+					key
+				end
+
+				def get_default_key user_id, no_cache=false
+					cache_key = "#{user_id}.key"
+					key = cache.get(cache_key)
+					if key == nil or no_cache
+						array = SQL::Key.default_by_user_id(db, user_id)
+						hash = array.first if array
+						key = Schema::Key.new(hash) if hash
+						cache.set cache_key, key if key
+					end
+					if key
+						puts "default key.key: #{key.key}."
+					else
+						puts "A default key was not found for user ID: #{user_id}."
+					end
+					key
+				end
+
+				def get_roles no_cache=false
+					return nil unless current_key
+					cache_key = "#{current_key.id}_roles"
+					roles = cache.get(cache_key)
+					if roles == nil or no_cache
+						roles = SQL::Role.by_key(db, current_key)
+						cache.set cache_key, roles if roles
+					end
+					roles
+				end
+
+				def get_query_filters no_cache=false
+					# get filters from query_filter table.
+					return nil unless current_key
+					cache_key = "#{current_key.id}_query_filters"
+					query_filters = cache.get(cache_key)
+					if query_filters == nil or no_cache
+						query_filters = []
+						filters = SQL::QueryFilter.by_key(db, current_key)
+						filters.each do |filter|
+							query_filters << Query::Filter.new(filter[:base_table_name], filter[:sub_select])
+						end
+						if app_defined_query_filters
+							app_defined_query_filters.each do |filter|
+								query_filters << filter
+							end
+						end
+						cache.set cache_key, query_filters
+					end
+					query_filters
+				end
+
+				def set_current_user(user)
+					@current_user = user
+				end
+
+				def set_current_key(value)
+					@current_key = value
+				end
+
+				def set_current_roles roles
+					@current_role = nil
+					@current_roles = roles
+					if roles
+						roles.each do |role|
+							@current_role = role[:name]
+							break
+						end
+					end
+				end
+
+				def set_current_auth
+					@current_auth = ::Authorization::Filter.new current_roles, configatron.application.role_permissions, configatron.application.role_restrictions
+					@current_user.auth = @current_auth
+				end
+
+				def set_current_query_filters no_cache=false
+					@current_query_filters = get_query_filters(no_cache)
+					@current_user.query_filters = @current_query_filters
+				end
+
+				def current_user
+					@current_user
+				end
+
+				def current_key
+					@current_key
+				end
+
+				def current_roles
+					@current_roles
+				end
+
+				def current_role
+					@current_role
+				end
+
+				def current_auth
+					@current_auth
+				end
+
+				def current_query_filters
+					@current_query_filters
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/api/helpers/data_cache.rb

@@ -0,0 +1,20 @@
+require 'jungle_path/cache'
+
+module JunglePath
+	module API
+		module Helpers
+			module DataCache
+				#def zcache
+				#  if @cache == nil
+				#    raw_client = Redis.new
+				#    @cache = Cache.wrap(raw_client)
+				#  end
+				#  @cache
+				#end
+				def cache
+					JunglePath::Cache
+				end
+			end
+		end
+	end
+end