firebase-ruby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 693b989e038daf52ac6f06a2a978614a3d0fee2b
+  data.tar.gz: 4c88d12f7167b180dc8cc5b7707a700e1e803f63
+SHA512:
+  metadata.gz: 8a8319b29c0b88f9640d86604fae62bec3a323a243f40caf4a0c32b56db2f5d6914945ed0d3ed80367a5a751cf98565367679cbe55118ffe3680f54c63687b4f
+  data.tar.gz: 75677e5b82c80ebf6302abf25a995ba7126c3af2f467db9a59f6605b288bb1434fd9e325b1cd68e61ce66a64acda1fed70e879586a2c2f95f46d86a0615ee93d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Ken J.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+# firebase-ruby-private
+Pure simple Ruby based Firebase REST library

data/bin/fbrb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require 'firebase-ruby/trollop'
+require 'firebase-ruby'
+
+
+opts = Trollop::options do
+  banner "fbrb [options] <URL>"
+  opt :data, 'HTTP POST data', type: :string
+  opt :id, 'Project ID', type: :string
+  opt :key, 'JSON file with private key', type: :string
+  opt :log, 'Log file', type: :string
+  opt :path, 'Path', type: :string
+  opt :request, 'Specify request command to use', type: :string, short: 'X', default: 'get'
+  opt :verbose, 'Verbose mode'
+end
+
+if opts[:log_given]
+  Firebase.logger = Logger.new(opts[:log])
+  Firebase.logger.level = Logger::WARN
+end
+
+if opts[:verbose]
+  Firebase.logger = Logger.new(STDOUT) unless opts[:log_given]
+  Firebase.logger.level = Logger::DEBUG
+end
+log = Firebase.logger
+
+log.debug("Command line arguments: #{opts}")
+
+path = opts[:path]
+path ||= ARGV.shift
+
+Trollop::die :path, "is missing" if path.nil?
+
+db = Firebase::Database.new()
+db.set_auth_with_keyfile(opts[:key])
+
+method = opts[:request].downcase.to_sym
+
+case method
+when :get, :delete
+  data = db.public_send(method, path)
+when :put, :patch, :post
+  if opts[:data_given]
+    data = db.public_send(method, path, opts[:data])
+  else
+    Trollop::die :data, "is missing"
+  end
+end
+
+puts data if data

data/firebase-ruby.gemspec

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'firebase-ruby/version'
+
+
+Gem::Specification.new do |s|
+  s.name          = 'firebase-ruby'
+  s.version       = Firebase::Version
+  s.authors       = ['Ken J.']
+  s.email         = ['kenjij@gmail.com']
+  s.summary       = %q{Pure simple Ruby based Firebase REST library}
+  s.description   = %q{Firebase REST library written in pure Ruby without external dependancy.}
+  s.homepage      = 'https://github.com/kenjij/firebase-ruby'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/lib/firebase-ruby.rb

@@ -0,0 +1,4 @@
+require 'firebase-ruby/logger'
+require 'firebase-ruby/database'
+require 'firebase-ruby/auth'
+require 'firebase-ruby/http'

data/lib/firebase-ruby/auth.rb

@@ -0,0 +1,85 @@
+require 'jwt'
+
+module Firebase
+
+  class Auth
+
+    GOOGLE_JWT_SCOPE = 'https://www.googleapis.com/auth/firebase.database https://www.googleapis.com/auth/userinfo.email'
+    GOOGLE_JWT_AUD = 'https://www.googleapis.com/oauth2/v4/token'
+    GOOGLE_ALGORITHM = 'RS256'
+    GOOGLE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+    GOOGLE_TOKEN_URL = 'https://www.googleapis.com/oauth2/v4/token'
+
+    attr_reader :project_id
+    attr_reader :client_email
+    attr_reader :access_token
+    attr_reader :expires
+
+    def initialize(path)
+      load_privatekeyfile(path)
+    end
+
+    # Return a valid access token; it will retrieve a new token if necessary
+    def valid_token
+      return access_token if access_token && !expiring?
+      return access_token if request_access_token
+      return nil
+    end
+
+    # If token is expiring within a minute
+    def expiring?
+      return true if expires - Time.now < 60
+      return false
+    end
+
+    # If token has already expired
+    def expired?
+      return true if expires - Time.now <= 0
+      return false
+    end
+
+    private
+
+    # @param path [String] JSON file with private key
+    def load_privatekeyfile(path)
+      raise ArgumentError, 'private key file path missing' unless path
+      Firebase.logger.debug("Loading private key file: #{path}")
+      cred = JSON.parse(IO.read(path), {symbolize_names: true})
+      @private_key = cred[:private_key]
+      @project_id = cred[:project_id]
+      @client_email = cred[:client_email]
+      Firebase.logger.info('Auth.load_privatekeyfile done.')
+    end
+
+    # Request new token from Google
+    def request_access_token
+      Firebase.logger.info('Requesting access token to Google')
+      res = HTTP.post_form(GOOGLE_TOKEN_URL, jwt)
+      Firebase.logger.debug("HTTP response code: #{res[:code]}")
+      if res.class == Hash && res[:code] == 200
+        data = JSON.parse(res[:body], {symbolize_names: true})
+        @access_token = data[:access_token]
+        @expires = Time.now + data[:expires_in]
+        return true
+      end
+      return false
+    end
+
+    # Generate JWT claim
+    def jwt
+      pkey = OpenSSL::PKey::RSA.new(@private_key)
+      now_ts = Time.now.to_i
+      payload = {
+        iss: client_email,
+        scope: GOOGLE_JWT_SCOPE,
+        aud: GOOGLE_JWT_AUD,
+        iat: now_ts,
+        exp: now_ts + 60
+      }
+      jwt = JWT.encode payload, pkey, GOOGLE_ALGORITHM
+      return {grant_type: GOOGLE_GRANT_TYPE, assertion: jwt}
+    end
+
+  end
+
+end

data/lib/firebase-ruby/database.rb

@@ -0,0 +1,86 @@
+module Firebase
+
+  class Database
+
+    FIREBASE_URL_TEMPLATE = 'https://%s.firebaseio.com/'
+
+    attr_accessor :auth, :print, :shallow
+
+    def initialize()
+    end
+
+    def set_auth_with_keyfile(filepath)
+      @auth = Auth.new(filepath)
+    end
+
+    def project_id=(id)
+      @project_id = id
+    end
+
+    def project_id
+      return @project_id if @project_id
+      return auth.project_id if auth
+      return nil
+    end
+
+    def get(path)
+      return operate(__method__, path)
+    end
+
+    def put(path, data)
+      return operate(__method__, path, data)
+    end
+
+    def patch(path, data)
+      return operate(__method__, path, data)
+    end
+
+    def post(path, data)
+      return operate(__method__, path, data)
+    end
+
+    def delete(path)
+      return operate(__method__, path)
+    end
+
+    private
+
+    def operate(method, path, data = nil)
+      case method
+      when :get, :delete
+        res_data = http.public_send(method, path: format_path(path))
+      when :put, :patch, :post
+        data = JSON.fast_generate(data) if data.class == Hash
+        res_data = http.public_send(method, path: format_path(path), body: data)
+      end
+      return handle_response_data(res_data)
+    end
+
+    def http
+      unless @http
+        url = FIREBASE_URL_TEMPLATE % project_id
+        headers = {
+          'Authorization' => "Bearer #{auth.valid_token}",
+          'Content-Type' => 'application/json'
+        }
+        @http = HTTP.new(url, headers)
+      end
+      return @http
+    end
+
+    def format_path(path)
+      path = '/' + path unless path.start_with?('/')
+      return path + '.json'
+    end
+
+    def handle_response_data(data)
+      if data[:code] != 200
+        Firebase.logger.error("HTTP response error: #{data[:code]}\n#{data[:message]}")
+        return nil
+      end
+      return JSON.parse(data[:body], {symbolize_names: true})
+    end
+
+  end
+
+end

data/lib/firebase-ruby/http.rb

@@ -0,0 +1,172 @@
+require 'net/http'
+require 'openssl'
+
+
+module Firebase
+
+  class HTTP
+
+    METHOD_HTTP_CLASS = {
+      get: Net::HTTP::Get,
+      put: Net::HTTP::Put,
+      patch: Net::HTTP::Patch,
+      post: Net::HTTP::Post,
+      delete: Net::HTTP::Delete
+    }
+
+    def self.get(url, params)
+      h = HTTP.new(url)
+      data = h.get(params: params)
+      h.close
+      return data
+    end
+
+    def self.post_form(url, params)
+      h = HTTP.new(url)
+      data = h.post(params: params)
+      h.close
+      return data
+    end
+
+    attr_reader :init_uri, :http
+    attr_accessor :headers
+
+    def initialize(url, hdrs = nil)
+      @init_uri = URI(url)
+      raise ArgumentError, 'Invalid URL' unless @init_uri.class <= URI::HTTP
+      @http = Net::HTTP.new(init_uri.host, init_uri.port)
+      http.use_ssl = init_uri.scheme == 'https'
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      self.headers = hdrs
+    end
+
+    def get(path: nil, params: nil, query: nil)
+      return operate(__method__, path: path, params: params, query: query)
+    end
+
+    def post(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def put(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def patch(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def delete(path: nil, params: nil, query: nil)
+      return operate(__method__, path: path, params: params, query: query)
+    end
+
+    def close
+      http.finish if http.started?
+    end
+
+    private
+
+    def operate(method, path: nil, params: nil, body: nil, query: nil)
+      uri = uri_with_path(path)
+      case method
+      when :get, :delete
+        if params
+          query = URI.encode_www_form(params)
+          Firebase.logger.info('Created urlencoded query from params')
+        else
+          uri.query = query
+        end
+        req = METHOD_HTTP_CLASS[method].new(uri)
+      when :put, :patch, :post
+        uri.query = query if query
+        req = METHOD_HTTP_CLASS[method].new(uri)
+        if params
+          req.form_data = params
+          Firebase.logger.info('Created form data from params')
+        elsif body
+          req.body = body
+        end
+      else
+        return nil
+      end
+      data = send(req)
+      data = redirect(method, uri, params: params, body: body, query: query) if data.class <= URI::HTTP
+      return data
+    end
+
+    def uri_with_path(path)
+      uri = init_uri.clone
+      uri.path = path unless path.nil?
+      return uri
+    end
+
+    def send(req)
+      inject_headers_to(req)
+      unless http.started?
+        Firebase.logger.info('HTTP session not started; starting now')
+        http.start
+        Firebase.logger.debug("Opened connection to #{http.address}:#{http.port}")
+      end
+      Firebase.logger.debug("Sending HTTP #{req.method} request to #{req.path}")
+      Firebase.logger.debug("Body size: #{req.body.length}") if req.request_body_permitted?
+      res = http.request(req)
+      return handle_response(res)
+    end
+
+    def inject_headers_to(req)
+      return if headers.nil?
+      headers.each do |k, v|
+        req[k] = v
+      end
+      Firebase.logger.info('Header injected into HTTP request header')
+    end
+
+    def handle_response(res)
+      if res.connection_close?
+        Firebase.logger.info('HTTP response header says connection close; closing session now')
+        close
+      end
+      case res
+      when Net::HTTPRedirection
+        Firebase.logger.info('HTTP response was a redirect')
+        data = URI(res['Location'])
+        if data.class == URI::Generic
+          data = uri_with_path(res['Location'])
+          Firebase.logger.debug("Full URI object built for local redirect with path: #{data.path}")
+        end
+      # when Net::HTTPSuccess
+      # when Net::HTTPClientError
+      # when Net::HTTPServerError
+      else
+        data = {
+          code: res.code.to_i,
+          headers: res.to_hash,
+          body: res.body,
+          message: res.msg
+        }
+      end
+      return data
+    end
+
+    def redirect(method, uri, params: nil, body: nil, query: nil)
+      if uri.host == init_uri.host && uri.port == init_uri.port
+        Firebase.logger.info("Local #{method.upcase} redirect, reusing HTTP session")
+        new_http = http
+      else
+        Firebase.logger.info("External #{method.upcase} redirect, spawning new HTTP object")
+        new_http = HTTP.new("#{uri.scheme}://#{uri.host}#{uri.path}", headers)
+      end
+      case method
+      when :get, :delete
+        data = operate(method, uri, params: params, query: query)
+      when :put, :patch, :post
+        data = new_http.public_send(method, uri, params: params, body: body, query: query)
+      else
+        data = nil
+      end
+      return data
+    end
+
+  end
+
+end