phantom_proxy 1.2.17 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54b0f0d023b215fda611a4fa487a2e7610ad3b29
+  data.tar.gz: 314bcd2a4a6551e9f741bb852dd57b108c87dd1e
+SHA512:
+  metadata.gz: 4d98501212d94d5b96f304150b57c255a521af55855c63234d24faa11f5e2057b29196f97f485ae9aa652c7c96ac85d70ebc3f0e98997d1e1da8dcc70a144090
+  data.tar.gz: 245b3c3b6e7ef879309824b3dff8537d22262bb68bfc9e4b93eedd0cbcfd882b89dc24128e3975cab8a12c1d1f3879dcfbbbaa247b59593922bfdf2bd0ddf128

data/.gitignore

@@ -1,12 +1,14 @@
-phantom_proxy-*.gem
-.rvmrc
-log/
-
-#IDE
-.redcar
-.project
-.rbenv-gemsets
-
-doc
-!.keep
-Gemfile.lock
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rbenv-gemsets

@@ -0,0 +1 @@
+phantom_proxy2

data/.ruby-version

@@ -1 +1 @@
-ree-1.8.7-2012.02
+2.0.0-p481

data/Gemfile

@@ -1,5 +1,4 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
+# Specify your gem's dependencies in phantom_proxy2.gemspec
 gemspec
-
-gem 'rack'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Suddani
+
+MIT License
+
+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/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/phantom_proxy

@@ -1,60 +1,53 @@
 #!/usr/bin/env ruby
 
-require 'thin'
-
-require 'fileutils'
-require 'timeout'
-require 'stringio'
-require 'time'
-require 'forwardable'
-require 'rack'
-require 'daemons'
-
-module PhantomJSProxy
-	CONFIG = File.expand_path(File.dirname(__FILE__))+"/../lib/phantom_proxy/config.ru"
-end
-
-require 'phantom_proxy'
-
-# Become a daemon
-options = {
-  :app_name		=> "phantom_proxy",
-  :backtrace  => true,
-  :ontop      => true,
-  :log_output => true
-}
-#Daemons.daemonize(options)
+require "goliath/runner"
+require "phantom_proxy"
+require 'optparse'
+
+module PhantomProxy
+  def self.load_config
+    options = {}
+    optparse = OptionParser.new do|opts|
+      opts.banner = "Usage: "
+      opts.on( '-l [FILE]', '--logfile [FILE]', 'Write log to FILE' ) do |file|
+        # PhantomProxy2.logger = Logger.new(file)
+        options[:log_file] = file
+      end
+      opts.on('--hmac [STRING]', 'Use a hmac key to secure the connection' ) do |hmac|
+        # PhantomProxy2.hmac_key = hmac
+        options[:hmac_key] = hmac
+      end
+    end
+    args = ARGV.dup
+    remaining = []
+    while !args.empty?
+      begin
+        head = args.shift
+        remaining.concat(optparse.parse([head, args].flatten))
+      rescue OptionParser::InvalidOption
+        remaining << head
+        retry
+      end
+    end
+    PhantomProxy.logger    = Logger.new(options[:log_file]) if options[:log_file]
+    PhantomProxy.hmac_key  = options[:hmac_key] if options[:hmac_key]
+    remaining
+  end
+  def self.run_phantom_proxy(args)
+    puts "Run with #{args}"
+    runner = Goliath::Runner.new(args, nil)
+    runner.logger=PhantomProxy.logger
+    runner.port = PhantomProxy.port if PhantomProxy.respond_to?(:port)
+    runner.address = PhantomProxy.address if PhantomProxy.respond_to?(:address)
 
-PARAMETERS = Array.new
+    Goliath.env = PhantomProxy.env if PhantomProxy.respond_to?(:env)
 
-hmac_key = nil
-phantom = false
-last_arg = nil
-ARGV.each { |arg|
-  if !/-hmac/.match(arg) && !/-hmac/.match(last_arg) && !/-self/.match(arg)
-    PARAMETERS << arg
-  end
-  phantom = true if /-self/.match(arg)
-  hmac_key = arg if /-hmac/.match(last_arg)
-  last_arg = arg
-}
+    runner.api = PhantomProxy::Service.new
+    runner.app = Goliath::Rack::Builder.build(PhantomProxy::Service, runner.api)
 
-if hmac_key
-  if !File.directory?("/tmp/phantom_proxy")
-    Dir.mkdir("/tmp/phantom_proxy")
-  end
-  
-  File.open("/tmp/phantom_proxy/key", 'w+') {|f| f.write(hmac_key) }
-else
-  begin
-    File.delete("/tmp/phantom_proxy/key")
-  rescue
+    puts "Now starting PhantomProxy #{PhantomProxy::VERSION}...."
+    runner.run
   end
 end
 
-if !phantom
-  startoptions = ["start", "-R", PhantomJSProxy::CONFIG, "-P", "/tmp/pids/phantom_proxy.pid", "--tag", "phantom_proxy"]+PARAMETERS
-  runner = Thin::Runner.new(startoptions).run!
-else
-  Thin::Server.start(PhantomJSProxy::PhantomJSServer.new, ARGV[0], ARGV[1], ARGV[2])
-end
+PhantomProxy.run_phantom_proxy PhantomProxy.load_config

data/lib/phantom_proxy/helper/http.rb

@@ -0,0 +1,46 @@
+module PhantomProxy
+  module Http
+    def self.renderer
+      @@renderer||=TemplateRenderer.create(binding)
+    end
+    def self.error_object_binding(obj)
+      obj||={}
+      def obj.get_binding
+        binding
+      end
+      def obj.title
+        self[:title]
+      end
+      def obj.content
+        self[:content]
+      end
+      def obj.error_code
+        self[:error_code]
+      end
+      obj.get_binding
+    end
+
+    def self.error_massages
+      @error_massages||={"Not Found" => 404, "Server Error" => 500, "Not Allowed" => 403, "Not Authorized" => 401}
+    end
+
+    error_massages.each do |error_name, error_code|
+      define_singleton_method error_name.gsub(" ", "").to_sym do |data=error_name, content_type="text/html"|
+        Response(error_code, renderer.render("error_page", error_object_binding(:title=>error_name, :content=>data, :error_code => 404)), content_type)
+      end
+    end
+
+    def self.NextApi(data="Not Found", content_type="text/plain")
+      Response(600, data, content_type)
+    end
+    def self.OK(data="", content_type="text/plain")
+      Response(200, data, content_type)
+    end
+    def self.Response(status_code=200, data="", content_type="text/plain")
+      [status_code, {"Content-Type" => content_type}, data]
+    end
+    def self.OK_no_data(data="", content_type="text/plain")
+      [204, {}, ""]
+    end
+  end
+end

data/lib/phantom_proxy/helper/jsonizer.rb

@@ -0,0 +1,46 @@
+module PhantomProxy
+  module Jsonizer
+    def json_var(*var_names)
+      @json_vars = (@json_vars||[])+var_names.flatten
+    end
+
+    def json_vars
+      @json_vars||= []
+    end
+
+    module Methods
+      def render_json(obj=nil)
+        Http.OK (obj||self).to_json, "application/json"
+      end
+
+      def render_xml(obj=nil)
+        obj = Nokogiri::XML::Builder.new do |xml|
+          yield xml
+        end if block_given?
+        Http.OK (obj||self).to_xml, "application/xml"
+      end
+
+      def to_json
+        stuff = Hash.new
+        self.class.json_vars.each{|var_name|
+          stuff[var_name.to_sym]=send(var_name)# if respond_to?(var_name)
+        }
+        puts stuff
+        stuff.to_json
+      end
+      
+      def to_xml()
+        xml = Nokogiri::XML::Builder.new do |xml|
+        xml.PhantomProxyStatus() {
+          self.class.json_vars.each{|var_name|
+            var = send(var_name)
+            var = var.to_xml if var.respond_to?(:to_xml)
+            xml.send(var_name, var)# if respond_to?(var_name)
+          }
+        }
+        end
+        xml.to_xml
+      end
+    end
+  end
+end

data/lib/phantom_proxy/helper/logable.rb

@@ -0,0 +1,36 @@
+module PhantomProxy
+
+  class PhantomProxyLogger
+    def initialize logger, req_id
+      @logger=logger
+      @req_id=req_id
+    end
+    def info msg
+      @logger.info "[#{@req_id}] -> #{msg}"
+    end
+    def warn msg
+      @logger.warn "[#{@req_id}] -> #{msg}"
+    end
+    def error msg
+      @logger.error "[#{@req_id}] -> #{msg}"
+    end
+    def debug msg
+      @logger.debug "[#{@req_id}] -> #{msg}"
+    end
+  end
+
+  module Logable
+    def logger
+      @logger ||= PhantomProxy.logger
+    end
+
+    def logger=(_logger)
+      @logger=_logger
+    end
+
+    def self.next_id
+      @req_id ||= 0
+      @req_id+=1
+    end
+  end
+end

data/lib/phantom_proxy/helper/status_info.rb

@@ -0,0 +1,42 @@
+module PhantomProxy
+  module StatusInfo
+    def self.boot_up
+      @start_time=Time.now
+    end
+    boot_up
+    
+    def self.uptime
+      Time.now-@start_time
+    end
+    def self.cache_hit
+      @cache_hit||=0
+    end
+    def self.cache_hit=(obj)
+      @cache_hit=obj
+    end
+    def self.cache_miss
+      @cache_miss||=0
+    end
+    def self.cache_miss=(obj)
+      @cache_miss=obj
+    end
+    def self.cache_error
+      @cache_error||=0
+    end
+    def self.cache_error=(obj)
+      @cache_error=obj
+    end
+    def self.cache_access
+      @cache_access||=0
+    end
+    def self.cache_access=(obj)
+      @cache_access=obj
+    end
+    def self.connections
+      @connections||=0
+    end
+    def self.connections=(obj)
+      @connections=obj
+    end
+  end
+end

data/lib/phantom_proxy/helper/template_renderer.rb

@@ -0,0 +1,43 @@
+module PhantomProxy
+  class ReloadTemplateRenderer
+    def initialize(binding_)
+      @binding = binding_
+    end
+
+    def render(template_name, bind=nil)
+      TemplateRenderer.new(bind||@binding).render(template_name)
+    end
+  end
+
+  class TemplateRenderer
+    def self.create(binding_)
+      (PhantomProxy.respond_to?(:env) && PhantomProxy.env == :production) ? TemplateRenderer.new(binding_) : ReloadTemplateRenderer.new(binding_)
+    end
+
+    def initialize(controller_binding_)
+      @controller_binding=controller_binding_
+    end
+
+    def render(template_name, bind=nil)
+      template(template_name).result(bind||controller_binding)
+    end
+
+    private
+
+    def controller_binding
+      @controller_binding
+    end
+
+    def template(template_name)
+      begin
+        templates[template_name]||=::ERB.new(File.read(PhantomProxy.root.join("views", "#{template_name}.erb")))
+      rescue Errno::ENOENT => e
+        templates[template_name]||=::ERB.new(File.read(PhantomProxy.root_gem.join("templates/views", "#{template_name}.erb")))
+      end
+    end
+
+    def templates
+      @templates||={}
+    end
+  end
+end

data/lib/phantom_proxy/phantomjs/phantomjs.rb

@@ -0,0 +1,105 @@
+require 'tempfile'
+
+module PhantomProxy
+  class PhantomJS
+    attr_accessor :dom
+    attr_accessor :image
+    attr_accessor :ready
+
+    include ::PhantomProxy::Logable
+  
+    def initialize()
+      @ready = 503
+    end
+    
+    def getUrl(url, pictureOnly=true, loadIFrames=true)
+      logger.info("PhantomJS: "+url)
+      @ready = 503
+      
+      pictureFile = nil
+      picture = "none"
+      
+      loadFrames = "false"
+      
+      if loadIFrames
+        loadFrames = "true"
+      end
+      
+      if pictureOnly
+        pictureFile = Tempfile.new(["phantom_proxy_page", ".png"])
+        picture = pictureFile.path
+      end
+      
+      url_args = ""
+      url_args_ = []
+      
+      if /\?/.match(url)
+        url_args = url.split('?')[1]
+        url = url.split('?')[0]
+        
+        if url_args
+          url_args_ = url_args.split('&')
+          url_args = url_args_.join(' ')
+        end
+      end
+      
+      @dom = invokePhantomJS(PhantomProxy.script_path, [picture, loadFrames, "\""+url+"\"", url_args_.length, url_args])
+      
+      logger.info("Opened page: "+ /Open page: (.*?) END/.match(@dom)[1])
+      
+      @ready = 503
+      dom_text = "Failed to load page"
+      
+      if /DONE_LOADING_URL/.match(@dom)
+        logger.info("LOAD_DOM_TEXT")
+        dom_text = getDOMText @dom
+        logger.info("LOAD_DOM_TEXT_DONE")
+        if pictureOnly && File.exist?(picture) 
+          logger.info("File is there")
+          @image = File.open(picture, "rb")# {|f| f.read }
+          pictureFile.close!
+        else
+          logger.info("No file to load at: "+picture)
+          @image = ""
+        end
+        @ready = 200
+      end
+      if /URL_ERROR_CODE/.match(@dom)
+        logger.info("LOAD_ERROR_CODE")
+        @ready = getHTTPCode @dom
+        logger.info("LOAD_ERROR_CODE_DONE: #{@ready}")
+      end
+      @dom = dom_text
+      return @dom
+    end
+    
+    def getDOMText data
+      tmp = data.split('PHANTOMJS_DOMDATA_WRITE:')[1];
+      tmp = tmp.split('PHANTOMJS_DOMDATA_END')[0]
+      tmp
+    end
+    
+    def getHTTPCode data
+      tmp = data.split('URL_ERROR_CODE: ')[1];
+      tmp = tmp.split('URL_ERROR_CODE_END')[0]
+      #tmp = /FAILED_LOADING_URL: (.*?)FAILED_LOADING_URL_END/.match(data)[1]
+      tmp.to_i
+    end
+    
+    def getAsImageResponse(type='png')
+      return "HTTP/1.0 200 OK\r\nConnection: close\r\nContent-Type: image/"+type+"\r\n\r\n"+@image;
+    end
+  
+    def invokePhantomJS(script, args)
+      argString = " "+args.join(" ")
+      logger.info("Call phantomJS with: "+argString)
+      out = ""
+
+      IO.popen(PhantomProxy.phantomjs_bin+" --ignore-ssl-errors=yes --web-security=false "+script+argString) {|io|
+        out = io.readlines.join
+      }
+      #logger.info("PHANTOMJS_OUT: "+out)
+      return out
+    end
+  end
+end

data/lib/phantom_proxy/proxy/proxy_api.rb

@@ -0,0 +1,86 @@
+module PhantomProxy
+  class ProxyApi < AppRouterBase
+    get "/*path", :handle_proxy_request
+    get "/", :handle_proxy_request
+
+    put "*any", :next_api
+    delete "*any", :next_api
+    head "*any", :next_api
+    post "*any", :next_api
+
+    private
+      def handle_proxy_request
+        return Http.NotAuthorized unless !PhantomProxy.hmac_key || check_request_security
+        phJS = PhantomJS.new
+        PhantomProxy.wait_for(lambda {
+          phJS.getUrl(canonical_url, as_image?, iframes?)
+        })
+        return image_response(phJS) if as_image?
+        html_response(phJS)
+      end
+
+      def html_response(phJS)
+        [phJS.ready > 0 ? phJS.ready : 404 , {'Content-Type' => 'text/html'}, phJS.dom]
+      end
+
+      def image_response(phJS)
+        [200 , {'Content-Type' => 'image/png'}, phJS.image]
+      end
+
+      def host
+        env['SERVER_NAME']
+      end
+
+      def path
+        env[nil] ? env[nil][:path] : ""
+      end
+
+      def iframes?
+        env["HTTP_GET_PAGE_WITH_IFRAMES"] == "true" || PhantomProxy.always_iframe?
+      end
+
+      def as_image?
+        env["HTTP_GET_PAGE_AS_IMAGE"] == "true" || PhantomProxy.always_image?
+      end
+
+      def https?
+        env["SERVER_PORT"] == "443"
+      end
+
+      def protocoll
+        https? ? "https" : "http"
+      end
+
+      def canonical_path
+        ["#{protocoll}://#{host}",path].join("/")
+      end
+
+      def canonical_url
+        [canonical_path, env["params"] ? env["params"].map{|k,v| "#{k}=#{v}"}.join('&') : nil].join("?")
+      end
+
+      def check_request_security
+        if !hmac_hash || !hmac_time
+          return false
+        end
+        
+        client_time= Time.parse(hmac_time)
+        remote_time= Time.now
+        remote_key = PhantomProxy.hmac_key.update(env['REQUEST_URI']+env['HTTP_HMAC_TIME']).hexdigest
+
+        if (hmac_hash != remote_key || (remote_time-client_time).abs > 120)
+          # control_panel.add_special_request "@did not pass security check"
+          logger.info "@did not pass security check"
+          return false
+        end
+        return true
+      end
+
+      def hmac_hash
+        env['HTTP_HMAC_KEY']
+      end
+      def hmac_time
+        env['HTTP_HMAC_TIME']
+      end
+  end
+end

data/lib/phantom_proxy/router/app_router.rb

@@ -0,0 +1,72 @@
+module PhantomProxy
+  class AppRouterBase
+
+    extend Jsonizer
+    include Jsonizer::Methods
+    include Logable
+
+    attr_accessor :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    def next_api
+      Http.NextApi
+    end
+
+    def renderer
+      @@renderer||=TemplateRenderer.create(binding)
+    end
+
+    def render(template_name, status_code=200, bind=nil)
+      begin
+        Http.Response(status_code, renderer.render(template_name, bind||binding), "html")
+      rescue Errno::ENOENT => e
+        Http.NotFound
+      end
+    end
+
+    def self.options(opt)
+      opt = {:function => opt.to_sym} if opt.class != Hash
+      {:controller => self.name, :function => :call}.merge(opt)
+    end
+
+    def self.http_verbs
+      @http_verbs||=["GET", "POST", "PUT", "DELETE", "HEAD"]
+    end
+
+    http_verbs.each do |method|
+      define_singleton_method method.downcase.to_sym do |path, opt = {}|
+        path  = Journey::Path::Pattern.new path
+        router.routes.add_route(lambda{|env| call_controller(options(opt), env)}, path, {:request_method => method}, {})
+      end
+    end
+
+    def self.call(env)
+      PhantomProxy::StatusInfo.connections+=1
+      print_ram_usage("RAM USAGE Before")
+      result=router.call(env)
+      print_ram_usage("RAM USAGE After")
+      PhantomProxy::StatusInfo.connections-=1
+      result
+    end
+
+    def self.print_ram_usage(text)
+      PhantomProxy.logger.info "#{text}[#{Process.pid}]: " + `pmap #{Process.pid} | tail -1`[10,40].strip
+    end
+
+    def self.call_controller(options, env)
+      options[:controller].respond_to?(options[:function]) ? options[:controller].send(options[:function], env) : PhantomProxy.const_get(options[:controller]).new(env).send(options[:function])
+    end
+
+    private
+      def self.routes()
+        (@@routes ||= {})[self.name] ||= Journey::Routes.new
+      end
+
+      def self.router()
+        (@@router ||= {})[self.name] ||= Journey::Router.new routes, {}
+      end
+  end
+end