staticd 0.0.1

data/lib/staticd/datastores/local.rb

@@ -0,0 +1,48 @@
+require "digest/sha1"
+
+module Staticd
+  module Datastores
+
+    # Datastore storing files on local directory.
+    #
+    # It use the file SHA1 digest as a filename so two identical files are not
+    # stored twice.
+    #
+    # Example:
+    #   datastore = Staticd::Datastores::Local.new(path: "/tmp/datastore")
+    #   datastore.put(file_path) unless datastore.exist?(file_path)
+    #   # => "/tmp/datastore/sha1_digest"
+    class Local
+
+      def initialize(params)
+        @path = params[:path]
+        check_store_directory
+      end
+
+      def put(file_path)
+        datastore_file = stored_file_path(file_path)
+        FileUtils.copy_file(file_path, datastore_file) unless exist?(file_path)
+        datastore_file
+      end
+
+      def exist?(file_path)
+        datastore_file = stored_file_path(file_path)
+        File.exist?(datastore_file) ? datastore_file : false
+      end
+
+      private
+
+      def check_store_directory
+        FileUtils.mkdir_p(@path) unless File.directory?(@path)
+      end
+
+      def sha1(file_path)
+        Digest::SHA1.hexdigest(File.read(file_path))
+      end
+
+      def stored_file_path(file_path)
+        "#{@path}/#{sha1(file_path)}"
+      end
+    end
+  end
+end

data/lib/staticd/datastores/s3.rb

@@ -0,0 +1,63 @@
+require "digest/sha1"
+require "aws-sdk"
+
+module Staticd
+  module Datastores
+
+    # Datastore storing files on Amazon S3.
+    #
+    # It use the file SHA1 digest as a filename so two identical files are not
+    # stored twice.
+    # Each files can be accessed afterwards using a public HTTP(S) address.
+    #
+    # Example:
+    #   datastore = Staticd::Datastores::S3.new(
+    #     host: bucket_name,
+    #     username: access_key_id,
+    #     password: secret_access_key
+    #   )
+    #   datastore.put(file_path) unless datastore.exist?(file_path)
+    #   # => http://bucket_name.hostname/sha1_digest
+    class S3
+
+      def initialize(params)
+        @bucket_name = params[:host]
+        @access_key = ENV["AWS_ACCESS_KEY_ID"]
+        @secret_key = ENV["AWS_SECRET_ACCESS_KEY"]
+      end
+
+      def put(file_path)
+        s3_object = object(file_path)
+        s3_object.write(file: file_path)
+        s3_object.acl = :public_read
+        s3_object.public_url(secure: false).to_s
+      end
+
+      def exist?(file_path)
+        s3_object = object(file_path)
+        s3_object.exists? ? s3_object.public_url(secure: false) : false
+      end
+
+      private
+
+      def s3
+        @s3 ||= AWS::S3.new(
+          access_key_id: @access_key,
+          secret_access_key: @secret_key
+        )
+      end
+
+      def bucket
+        @bucket ||= s3.buckets[@bucket_name]
+      end
+
+      def object(file_path)
+        bucket.objects[sha1(file_path)]
+      end
+
+      def sha1(file_path)
+        Digest::SHA1.hexdigest(File.read(file_path))
+      end
+    end
+  end
+end

data/lib/staticd/domain_generator.rb

@@ -0,0 +1,42 @@
+module Staticd
+
+  # Domain name generator.
+  #
+  # This class can be used to generate random words of various length.
+  # Options:
+  # * length: the length of the random word
+  # * suffix: a suffix to append to the random world (default is none)
+  #
+  # Example:
+  #   DomainGenerator.new(length: 2, suffix: ".domain.tld")
+  #   # => rb.domain.tld
+  #
+  # A block can be used to validate the generated domain. It must return true
+  # to validate the domain, otherwise a new one is proposed. This feature can
+  # be used to validate the domain against certain rules.
+  #
+  # Example:
+  #   DomainGenerator.new(suffix: ".domain.tld") do |generated_domain|
+  #     ["admin", "www"].include?(generated_domain)
+  #   end
+  class DomainGenerator
+
+    def self.new(options={})
+      if block_given?
+        until domain = generate(options)
+          yield domain
+        end
+        domain
+      else
+        generate(options)
+      end
+    end
+
+    def self.generate(options={})
+      length = options[:length] || 6
+      suffix = options[:suffix] || ""
+      random = ("a".."z").to_a.shuffle[0, length].join
+      random + suffix
+    end
+  end
+end

data/lib/staticd/http_cache.rb

@@ -0,0 +1,65 @@
+require "staticd/database"
+require "staticd/cache_engine"
+
+module Staticd
+
+  # Rack middleware to manage remote HTTP resources caching.
+  #
+  # For each request, it will find the last release of the site associed with
+  # the requested domain name and cache the corresponding resource if not
+  # already cached.
+  class HTTPCache
+    include Staticd::Models
+
+    def initialize(http_root, app)
+      @app = app
+      @http_root = http_root
+
+      raise "No HTTP root folder provided" unless @http_root
+      raise "No rack app provided" unless @app
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @env = env
+
+      # Change the Request Path to '/index.html' if root path is asked.
+      @env["PATH_INFO"] = "/index.html" if @env["PATH_INFO"] == '/'
+
+      # Get the release from the request Host header.
+      release = Release.last(
+        Release.site.domain_names.name => Rack::Request.new(@env).host
+      )
+      return next_middleware unless release
+
+      # Change the script name to include the site name and release version.
+      @env["SCRIPT_NAME"] = "/#{release.site_name}/#{release}"
+
+      req = Rack::Request.new(@env)
+      cache_engine = CacheEngine.new(@http_root)
+
+      # Do nothing else if the resource is already cached.
+      return next_middleware if cache_engine.cached?(req.path)
+
+      # Get the resource to cache.
+      resource = Resource.first(
+        Resource.routes.release_id => release.id,
+        Resource.routes.path => req.path_info
+      )
+      return next_middleware unless resource
+
+      # Cache the resource.
+      cache_engine.cache(req.path, resource.url)
+      next_middleware
+    end
+
+    private
+
+    def next_middleware
+      @app.call(@env)
+    end
+  end
+end

data/lib/staticd/http_server.rb

@@ -0,0 +1,197 @@
+require "sendfile"
+
+module Staticd
+
+  # Simple HTTP server Rack app.
+  #
+  # If the resource is readable from the root folder at the path given by the
+  # request, the resource is sent to the client. Otherwise a 404 Not Found HTTP
+  # error is sent.
+  class HTTPServer
+
+    # Mime types served by the webserver (from NGiNX mime.types file).
+    EXT_MIME_TYPE = {
+      ".html"    => "text/html",
+      ".htm"     => "text/html",
+      ".shtml"   => "text/html",
+      ".css"     => "text/css",
+      ".xml"     => "text/xml",
+      ".rss"     => "text/xml",
+      ".gif"     => "image/gif",
+      ".jpeg"    => "image/jpeg",
+      ".jpg"     => "image/jpeg",
+      ".js"      => "application/x-javascript",
+      ".txt"     => "text/plain",
+      ".htc"     => "text/x-component",
+      ".mml"     => "text/mathml",
+      ".png"     => "image/png",
+      ".ico"     => "image/x-icon",
+      ".jng"     => "image/x-jng",
+      ".wbmp"    => "image/vnd.wap.wbmp",
+      ".jar"     => "application/java-archive",
+      ".war"     => "application/java-archive",
+      ".ear"     => "application/java-archive",
+      ".hqx"     => "application/mac-binhex40",
+      ".pdf"     => "application/pdf",
+      ".cco"     => "application/x-cocoa",
+      ".jardiff" => "application/x-java-archive-diff",
+      ".jnlp"    => "application/x-java-jnlp-file",
+      ".run"     => "application/x-makeself",
+      ".pm"      => "application/x-perl",
+      ".pl"      => "application/x-perl",
+      ".prc"     => "application/x-pilot",
+      ".pdb"     => "application/x-pilot",
+      ".rar"     => "application/x-rar-compressed",
+      ".rpm"     => "application/x-redhat-package-manager",
+      ".sea"     => "application/x-sea",
+      ".swf"     => "application/x-shockwave-flash",
+      ".sit"     => "application/x-stuffit",
+      ".tcl"     => "application/x-tcl",
+      ".tk"      => "application/x-tcl",
+      ".der"     => "application/x-x509-ca-cert",
+      ".pem"     => "application/x-x509-ca-cert",
+      ".crt"     => "application/x-x509-ca-cert",
+      ".xpi"     => "application/x-xpinstall",
+      ".zip"     => "application/zip",
+      ".deb"     => "application/octet-stream",
+      ".bin"     => "application/octet-stream",
+      ".exe"     => "application/octet-stream",
+      ".dll"     => "application/octet-stream",
+      ".dmg"     => "application/octet-stream",
+      ".eot"     => "application/octet-stream",
+      ".iso"     => "application/octet-stream",
+      ".img"     => "application/octet-stream",
+      ".msi"     => "application/octet-stream",
+      ".msp"     => "application/octet-stream",
+      ".msm"     => "application/octet-stream",
+      ".mp3"     => "audio/mpeg",
+      ".ra"      => "audio/x-realaudio",
+      ".mpeg"    => "video/mpeg",
+      ".mpg"     => "video/mpeg",
+      ".mov"     => "video/quicktime",
+      ".flv"     => "video/x-flv",
+      ".avi"     => "video/x-msvideo",
+      ".wmv"     => "video/x-ms-wmv",
+      ".asx"     => "video/x-ms-asf",
+      ".asf"     => "video/x-ms-asf",
+      ".mng"     => "video/x-mng"
+    }
+
+    # Mime type used when no type has been identified.
+    DEFAULT_MIME_TYPE = "application/octet-stream"
+
+    def initialize(http_root, access_logger=nil)
+      @http_root = http_root
+      unless (@access_logger = access_logger)
+        @access_logger = Logger.new(STDOUT)
+        @access_logger.formatter = proc { |_, _, _, msg| "#{msg}\n"}
+      end
+
+      raise "No HTTP root folder provided" unless @http_root
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @env = env
+      req = Rack::Request.new(@env)
+      file_path = @http_root + req.path
+      res = File.readable?(file_path) ? serve(file_path) : send_404
+      log(req, res)
+    end
+
+    private
+
+    # Log a request using the "Extended Log File Format".
+    # See: http://www.w3.org/TR/WD-logfile.html
+    #
+    # Use the request.time key setup by the Rack::RequestTime middleware.
+    #
+    # Version: 1.0
+    # Fields: time cs-dns cs-ip date cs-method cs-uri sc-status sc-byte sc-time-taken
+    def log(req, res)
+      request_stop_time = Time.now
+      request_start_time =
+        req.env.key?("request.time") ? req.env["request.time"] : nil
+      request_completed_time =
+        if request_start_time
+          (request_stop_time - request_start_time).round(4)
+        else
+          "-"
+        end
+      content_length =
+        res[1].key?("Content-Length") ? " #{res[1]["Content-Length"]}" : "-"
+
+      log_string = "#{request_stop_time.strftime("%Y-%m-%d %H:%M:%S")}"
+      log_string << " #{req.host}"
+      log_string << " #{req.env["REMOTE_ADDR"]}"
+      log_string << " #{req.env["REQUEST_METHOD"]} #{req.path_info}"
+      log_string << " #{res[0]}"
+      log_string << content_length
+      log_string << " #{request_completed_time}"
+      @access_logger.info(log_string)
+
+      res
+    end
+
+    # Serve a file.
+    #
+    # This method will return a Rack compatible response ready to be served to
+    # the client. It will use the appropriate method (loading file into memory
+    # vs serving file using the sendfile system call) based on availability.
+    def serve(file_path)
+      @env['rack.hijack?'] ? sendfile(file_path) : send(file_path)
+    end
+
+    # Send a file loading it in memory.
+    #
+    # Method used in the first implementation.
+    # Keep it for compatibility purpose when the Rack hijack API is not
+    # supported.
+    def send(file_path)
+      response = Rack::Response.new
+      response["Content-Type"] = mime(file_path)
+      File.foreach(file_path) { |chunk| response.write(chunk) }
+      response.finish
+    end
+
+    # Use sendfile system call to send file without loading it into memory.
+    #
+    # It use the sendfile gem and the rack hijacking api.
+    # See: https://github.com/codeslinger/sendfile
+    # See: http://blog.phusion.nl/2013/01/23/the-new-rack-socket-hijacking-api/
+    def sendfile(file_path)
+
+      response_header = {
+        "Content-Type" => mime(file_path),
+        "Content-Length" => size(file_path),
+        "Connection" => "close"
+      }
+      response_header["rack.hijack"] = lambda do |io|
+        begin
+          File.open(file_path) { |file| io.sendfile(file) }
+          io.flush
+        ensure
+          io.close
+        end
+      end
+      [200, response_header]
+    end
+
+    def send_404
+      res = Rack::Response.new(["Not Found"], 404, {})
+      res.finish
+    end
+
+    def mime(file_path)
+      ext = File.extname(file_path).downcase
+      EXT_MIME_TYPE.key?(ext) ? EXT_MIME_TYPE[ext] : DEFAULT_MIME_TYPE
+    end
+
+    def size(file_path)
+      File.size(file_path).to_s
+    end
+  end
+end

data/lib/staticd/json_request.rb

@@ -0,0 +1,15 @@
+require "json"
+
+module Staticd
+
+  # Simple JSON body parser for HTTP request.
+  #
+  # Example:
+  #   hash = JSONRequest.parse(request_body)
+  class JSONRequest
+
+    def self.parse(body)
+      body.empty? ? {} : JSON.parse(body)
+    end
+  end
+end

data/lib/staticd/json_response.rb

@@ -0,0 +1,29 @@
+require "json"
+
+module Staticd
+
+  # Simple HTTP response constructor for JSON content.
+  #
+  # Example:
+  #   response = JSONResponse.send(:success, {foo: :bar})
+  class JSONResponse
+
+    def self.send(type, content=nil)
+      case type
+      when :success
+        @status = 200
+        @body = content
+      when :success_no_content
+        @status = 204
+      when :error
+        @status = 403
+        @body = {error: content}
+      else
+        @status = 500
+        @body = {error: "Something went wrong on our side."}
+      end
+      json_body = @body ? JSON.generate(@body) : nil
+      [@status, json_body]
+    end
+  end
+end