staticd 0.0.1

data/lib/staticd/app.rb

@@ -0,0 +1,130 @@
+require "rack"
+require "rack/request_time"
+
+require "staticd/config"
+require "staticd/database"
+require "staticd/datastore"
+require "staticd/api"
+require "staticd/http_cache"
+require "staticd/http_server"
+
+module Staticd
+
+  # Staticd App.
+  #
+  # This class manage the app initialization and runtime.
+  #
+  # Example:
+  #   app = Staticd::App.new(config)
+  #   app.run
+  class App
+
+    # Initialize the Staticd app.
+    #
+    # General configuration:
+    # * environment: the app environment (test, development or production)
+    # * domain: base to generate per app sub-domain
+    # * public_port: port used to generate application and endpoint url,
+    #   (default to 80)
+    # * database: database url to store resources metadata
+    # * datastore: datastore url to store resources
+    # * host: host to listen to
+    # * port: port to listen to
+    #
+    # API service configuration:
+    # * api: enable the API service
+    # * access_id: HMAC authentication access ID for the API service
+    # * secret_key: HMAC authentication secret key for the API service
+    #
+    # HTTP service configuration:
+    # * http: enable the HTTP service
+    # * http_cache: folder where resources are cached
+    def initialize(config)
+      @config = config
+      @config[:public_port] ||= "80"
+      require_settings(:environment, :domain, :database, :datastore)
+
+      env = @config[:environment]
+      puts "Starting Staticd in #{env} environment." unless env == "test"
+      display_current_config if env == "development"
+
+      init_database
+      init_datastore
+    end
+
+    # Start the application.
+    def run
+      require_settings(:host, :port)
+      require_settings(:http_cache) if @config[:http]
+      require_settings(:access_id, :secret_key) if @config[:api]
+
+      routes = {}
+      routes["/"] = build_http_service if @config[:http]
+      routes["/api/#{Staticd::API::VERSION}"] = build_api_service if @config[:api]
+      router = Rack::URLMap.new(routes)
+
+      Rack::Server.start(
+        Host: @config[:host],
+        Port: @config[:port],
+        app: router,
+        environment: @config[:environment]
+      )
+    end
+
+    private
+
+    def require_settings(*settings)
+      settings.each do |setting|
+        unless @config.key?(setting) && !@config[setting].nil?
+          raise "Missing '#{setting}' setting"
+        end
+      end
+    end
+
+    def display_current_config
+      puts "Configuration:"
+      puts "* Database: #{@config[:database]}"
+      puts "* Datastore: #{@config[:datastore]}"
+
+      if Staticd::Config[:api]
+        puts "* Host: #{@config[:host]}"
+        puts "* Port: #{@config[:port]}"
+        puts "* Domain: #{@config[:domain]}"
+        puts "* Public Port: #{@config[:public_port]}"
+        puts "* Access ID: #{@config[:access_id]}"
+        puts "* Secret Key: #{@config[:secret_key]}"
+      end
+
+      if Staticd::Config[:http]
+        puts "* HTTP cache: #{@config[:http_cache]}"
+      end
+    end
+
+    def init_database
+      Staticd::Database.setup(@config[:environment], @config[:database])
+    end
+
+    def init_datastore
+      Staticd::Datastore.setup(@config[:datastore])
+    end
+
+    def build_api_service
+      api_service = Staticd::API.new(@config)
+
+      # Bind the API service with the HMAC middleware.
+      raise "No access ID provided" unless @config[:access_id]
+      raise "No secret_key provided" unless @config[:secret_key]
+      Rack::Auth::HMAC.new(
+        api_service, except: Staticd::API::PUBLIC_URI
+      ) do |access_id|
+        @config[:secret_key] if access_id == @config[:access_id].to_s
+      end
+    end
+
+    def build_http_service
+      http_service = Staticd::HTTPServer.new(@config[:http_cache])
+      cache_middleware = Staticd::HTTPCache.new(@config[:http_cache], http_service)
+      Rack::RequestTime.new(cache_middleware)
+    end
+  end
+end

data/lib/staticd/cache_engine.rb

@@ -0,0 +1,45 @@
+require "open-uri"
+require "sendfile"
+
+module Staticd
+
+  # Class to manage HTTP resources caching.
+  #
+  # Example:
+  #   cache_engine = CacheEngine.new("/tmp/cache")
+  #   unless cache.cached?("/index.html")
+  #     cache_engine.cache("/index.html", "http://storage.tld/0000000")
+  #   end
+  #
+  # TODO: add a purge method based on file's atime attribute
+  class CacheEngine
+
+    def initialize(http_root)
+      @http_root = http_root
+      check_cache_directory
+    end
+
+    def cache(resource_path, resource_url)
+      open(resource_url, "rb") do |resource|
+        FileUtils.mkdir_p(File.dirname(local_path(resource_path)))
+        File.open(local_path(resource_path), "w+") do |file|
+          resource.each { |chunk| file.write(chunk) }
+        end
+      end
+    end
+
+    def cached?(resource_path)
+      File.exist?(local_path(resource_path))
+    end
+
+    private
+
+    def local_path(resource_path)
+      @http_root + resource_path
+    end
+
+    def check_cache_directory
+      FileUtils.mkdir_p(@http_root) unless File.directory?(@http_root)
+    end
+  end
+end

data/lib/staticd/cli.rb

@@ -0,0 +1,70 @@
+require "staticd_utils/gli_object"
+require "staticd"
+
+module Staticd
+  class CLI
+
+    def initialize
+      @gli = GLIObject.new
+      @gli.program_desc("Staticd HTTP and API server")
+      @gli.version(Staticd::VERSION)
+      @gli.on_error { |exception| raise exception }
+      build_commands
+    end
+
+    def run(*args)
+      @gli.run(*args)
+    end
+
+    private
+
+    def build_commands
+      build_command_server
+    end
+
+    def build_command_server
+      @gli.desc("Start the staticd API and HTTP services")
+      @gli.command(:server) do |c|
+        c.switch([:api], desc: "enable the API service", default_value: true)
+        c.switch([:http], desc: "enable the HTTP service", default_value: true)
+        c.flag(
+          [:environment],
+          desc: "application environment",
+          default_value: :development
+        )
+        c.flag(
+          [:domain],
+          desc: "base to generate per app sub-domain"
+        )
+        c.flag(
+          [:public_port],
+          desc: "port used to generate application and endpoint url"
+        )
+        c.flag([:access_id], desc: "HMAC auth access id for the API service")
+        c.flag([:secret_key], desc: "HMAC auth secret key for the API service")
+        c.flag([:database], desc: "URL for the database")
+        c.flag([:datastore], desc: "URL for the datastore")
+        c.flag(
+          [:http_cache],
+          desc: "directory path where HTTP resources are cached",
+          default_value: "/var/cache/staticd"
+        )
+        c.flag([:host], desc: "address to listen to", default_value: "0.0.0.0")
+        c.flag([:port], desc: "port to listen to", default_value: 80)
+        c.flag([:config], desc: "load a config file")
+        c.action do |global_options, options,args|
+
+          # Load configuration from command line options, environment variables
+          # options and config file.
+          Staticd::Config << options
+          Staticd::Config.load_env
+          Staticd::Config.load_file(options[:config]) if options[:config]
+
+          # Initialize and start the Staticd app.
+          app = Staticd::App.new(Staticd::Config)
+          app.run
+        end
+      end
+    end
+  end
+end

data/lib/staticd/config.rb

@@ -0,0 +1,115 @@
+require "singleton"
+
+module Staticd
+
+  # Manage Staticd Configuration.
+  #
+  # Can load configuration from a hash, from environment variables with the
+  # STATICD_ prefix or from a config file in yaml format.
+  #
+  # Once loaded,configuration is available from anywhere in the app using
+  # Staticd::Config[:setting].
+  class Config
+    include Singleton
+
+    # Load configuration from environment variables.
+    #
+    # Example:
+    #   ENV["STATICD_FOO"] = "bar"
+    #   Staticd::Config.load_env
+    #   Staticd::Config[:foo]
+    #   # => "bar"
+    def self.load_env
+      settings = {}
+      env = ENV.select { |name, value| name =~ /^STATICD_/ }
+      env.each do |name, value|
+        setting = name[/^STATICD_(.*)/, 1].downcase.to_sym
+        settings[setting] = value
+      end
+      instance << settings
+    end
+
+    # Load configuration from a YAML file.
+    #
+    # The configuration file can contain ERB code.
+    #
+    # Example (config file)
+    #   ---
+    #   foo: bar
+    #
+    # Example:
+    #   Staticd::Config.load_file("/etc/staticd/staticd.yml")
+    #   Staticd::Config[:foo]
+    #   # => "bar"
+    def self.load_file(config_file)
+      content = File.read(config_file)
+      erb = ERB.new(content)
+      settings = YAML.load(erb.result)
+      instance << settings
+    end
+
+    # Push settings into Staticd global configuration.
+    #
+    # String setting keys are converted to symbols.
+    #
+    # Example:
+    #   Staticd::Config << {"foo" => bar}
+    #   Staticd::Config[:foo]
+    #   # => "bar"
+    def self.<<(settings)
+      instance << settings
+    end
+
+    # Same as << method.
+    def self.[]=(setting, value)
+      instance << {setting => value}
+    end
+
+    # Get a setting value from the Staticd global configuration.
+    def self.[](setting)
+      instance[setting]
+    end
+
+    def self.key?(setting_name)
+      instance.key?(setting_name)
+    end
+
+    def self.to_s
+      instance.to_s
+    end
+
+    def initialize
+      @settings = {}
+    end
+
+    def <<(settings)
+      settings = hash_symbolize_keys(settings)
+      mutex.synchronize { @settings.merge!(settings) }
+    end
+
+    def [](setting)
+      mutex.synchronize { @settings.key?(setting) ? @settings[setting] : nil }
+    end
+
+    def key?(setting_name)
+      mutex.synchronize { @settings.key?(setting_name) }
+    end
+
+    def to_s
+      mutex.synchronize { @settings.to_s }
+    end
+
+    private
+
+    def hash_symbolize_keys(hash)
+      hash.keys.each do |key|
+        hash[(key.to_sym rescue key) || key] = hash.delete(key)
+      end
+      hash
+    end
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+  end
+end

data/lib/staticd/database.rb

@@ -0,0 +1,41 @@
+require "data_mapper"
+
+# Load models.
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each do |model_library|
+  require model_library
+end
+
+module Staticd
+  module Database
+
+    # Initialize the database.
+    #
+    # It support the test, development and production environment.
+    # Database logger is silent in test environment, verbose in development
+    # environment, and only displaying errors in production.
+    def self.setup(environment, database_url)
+      raise "No environment given for the database" unless environment
+      raise "No database_url given" unless database_url
+
+      environment = environment.to_sym
+
+      log_enabled, destination, level =
+        case environment
+        when :development
+          [true, '$stdout', :debug]
+        when :production
+          [true, '$stderr', :error]
+        else
+          [false]
+        end
+
+      if log_enabled
+        DataMapper::Logger.new(eval(destination), level)
+      end
+
+      DataMapper.setup(:default, database_url)
+      DataMapper.finalize
+      environment == :test ? DataMapper.auto_migrate! : DataMapper.auto_upgrade!
+    end
+  end
+end

data/lib/staticd/datastore.rb

@@ -0,0 +1,64 @@
+require "singleton"
+require "uri"
+
+# Load datastores libraries.
+Dir["#{File.dirname(__FILE__)}/datastores/*.rb"].each do |datastore_library|
+  require datastore_library
+end
+
+module Staticd
+
+  # Load the corresponding datastore driver from an URL.
+  #
+  # This class use an URL to choose wich datastore library to use.
+  # It create a datastore instance with the correct driver and proxies its
+  # calls to it.
+  # It use the URL scheme to guess wich datastore library to use.
+  #
+  # Example:
+  #   Staticd::Datastore.setup("s3://[...]")   # Staticd::Datastores::S3
+  #   Staticd::Datastore.setup("local:/[...]") # Staticd::Datastores::Local
+  #   Staticd::Datastore.put(file_path)
+  class Datastore
+    include Singleton
+
+    def self.setup(url)
+      instance.setup(url)
+    end
+
+    def self.put(file_path)
+      instance.put(file_path)
+    end
+
+    def self.exist?(file_path)
+      instance.exist?(file_path)
+    end
+
+    def setup(url)
+      @uri = URI(url)
+    end
+
+    def put(file_path)
+      datastore.put(file_path)
+    end
+
+    def exist?(file_path)
+      datastore.exist?(file_path)
+    end
+
+    private
+
+    def datastoreClass
+      @datastoreClass ||= Datastores.const_get(@uri.scheme.capitalize)
+    end
+
+    def datastore
+      @datastore ||= datastoreClass.new(
+        host: @uri.host,
+        path: @uri.path,
+        username: @uri.user,
+        password: @uri.password
+      )
+    end
+  end
+end