boxlet 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d5950f183d1274de5cd16237709c40ad58c65cf
+  data.tar.gz: 7ebc60f5a772512343f7d6778eb25ca227b2998f
+SHA512:
+  metadata.gz: 94c93357b399e5855256009dc8bd9edcd3c18d4537cca5fdb2927d773021570148292b2d081b4b0db34d02a261093fab7f43827d6b9387ec0d353dfdf9171b72
+  data.tar.gz: 0667cdd101c8ebaf9c0a34d2975d3ec573a3b0eff0a08fb24ebdff0714f765108927efbd233eeb3da861bb6093831161e94ada72394f63ae5f47c39758753857

data/bin/boxlet

@@ -1,12 +1,15 @@
-#! /usr/bin/env ruby
+#!/usr/bin/env ruby
 
-require "boxlet"
+require 'boxlet'
 
-# Check to make sure we aren't running in Windows
-if RUBY_PLATFORM =~ /(win|w)32$/ then
-  puts "Sorry, Boxlet is currently only available for Unix/Linux."
-  exit!
+argv = *ARGV
+command = argv.count % 2 != 0 ? argv.shift : 'run'
+argv_hash = Hash[*argv]
+
+config = argv_hash["-c"] || argv_hash["--config"]
+if !config
+  puts "WARNING: config file not specified, looking in current directory..."
+  config = 'config.yml'
 end
 
-server = Boxlet::Server.new
-server.run
+Boxlet.run! argv_hash, command, config

data/boxlet.gemspec

@@ -6,22 +6,30 @@ require "boxlet/version"
 Gem::Specification.new do |spec|
   spec.name          = "boxlet"
   spec.version       = Boxlet::VERSION
-  spec.authors       = ["Clayton Liggitt", "arktisklada"]
+  spec.authors       = ["arktisklada"]
   spec.email         = ["mail@enorganik.com"]
-  spec.description   = %q{A server for Boxlet, a DIY, self-hosted file storage system}
-  spec.summary       = spec.description
-  spec.homepage      = "http://github.com/arktisklada/boxlet"
+  spec.summary       = %q{Upload pics from your phone}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/arktisklada/boxlet"
   spec.license       = "MIT"
 
-  # spec.files         = `git ls-files`.split($/)
   spec.files         = %w[config.yml LICENSE.txt README.md Rakefile boxlet.gemspec]
   spec.files         += Dir.glob('lib/**/*.rb')
+  spec.files         += Dir.glob('lib/boxlet/app/*.rb')
 
-  # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.executables   = 'boxlet'
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = %w[lib]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rack", "~> 1.5"
+  spec.add_dependency "rack-contrib", "~> 1.1"
+  spec.add_dependency "thin", "~> 1.6"
+
+  spec.add_runtime_dependency 'multi_json', '~> 1.10', '>= 1.10.1'
+  spec.add_runtime_dependency 'mongo', '~> 1.10', '>= 1.10.2'
+  spec.add_runtime_dependency 'bson_ext', '~> 1.10', '>= 1.10.2'
+  spec.add_runtime_dependency 'sys-filesystem', '~> 1.1', '>= 1.1.2'
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-end
+  spec.add_development_dependency "rake", "~> 10.3"
+end

data/config.yml

@@ -1,8 +1,32 @@
 # Boxlet configuration file
 
-# TCP Debug mode changes logging level between WARN (false) and DEBUG (true)
-tcp_debug: true
+# Environment
+environment: development
+debug: true
 
-# Server configuration
-tcp_listen_ip: 127.0.0.1
-tcp_listen_port: 8077
+# File system parameters
+# path: ./
+# upload_dir: ./uploads
+# tmp_dir: /tmp
+# file_system_root: /
+
+# Capacity is either a percentage of available space on the drive or number in MB
+capacity: 90%
+
+# Server type and listen parameters
+port: 8077
+host: localhost
+server_type: thin
+daemonize: false
+
+# Database config
+db:
+  development:
+    host: localhost
+    db: boxlet_dev
+  production:
+    host: localhost
+    # port:
+    # user:
+    # pass:
+    db: boxlet

data/lib/boxlet.rb

@@ -1,33 +1,73 @@
-require "fileutils"
 require "yaml"
-
+require "rack/contrib"
 require "boxlet/version"
-require "boxlet/log"
-require "boxlet/tcp_server"
+require "boxlet/app"
+require "boxlet/config"
+require "boxlet/runner"
+require "pp" #unless ENV['RACK_ENV'] == 'production'
+
+
+APP_ROOT = Dir.pwd
 
 
 module Boxlet
-  
-  class Server
-    def initialize()
-      # Load the config
-      @@config = YAML.load_file("config.yml")
-      
-      if @@config['git_debug'] then
-        Grit.debug = true
-      end
-      
-      @server = TcpServer.new
-    end
-    
-    public
-    
-    def self.config
-      return @@config
-    end
+
+  extend self
+  extend Boxlet::Config
+
+  attr_accessor :runner, :config, :raw_params, :raw_config
+
+  def run!(argv, command='run', config_file='config.yml', &blk)
+    populate_params!(argv, config_file)
     
-    def run
-      @server.start
+    app = Boxlet::App.new
+
+    case command
+      when 'run'
+        @runner = Boxlet::Runner.new
+        @runner.start(app.bind, &blk)
+      else
+        app.send(command, Boxlet.config)
     end
+
+    app
+  end
+
+  def stop!
+    @runner.stop
+    app
+  end
+
+
+  def debug?
+    @config[:debug] == true ? true : false
+  end
+
+  def config
+    @config
+  end
+
+  def params
+    @params
   end
+
 end
+
+
+# Configure our temporary folder
+class Dir  
+  def Dir::tmpdir
+    tmp = './tmp'
+    if $SAFE > 0
+      tmp = @@systmpdir
+    else
+      for dir in [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], @@systmpdir, '/tmp']
+        if dir and stat = File.stat(dir) and stat.directory? and stat.writable?
+          tmp = dir
+          break
+        end rescue nil
+      end
+      File.expand_path(tmp)
+    end
+  end
+end

data/lib/boxlet/app.rb

@@ -0,0 +1,133 @@
+require "sys/filesystem"
+#require "rack/boxlet_url_builder"
+require "rack/request"
+require "rack/response"
+require "rack/file_upload"
+require "boxlet/db"
+require "boxlet/app/router"
+
+
+module Boxlet
+  class App
+
+    include Sys
+
+    def self.routes
+      routes = {
+        ["/", :get]                 => :index,
+        # ["/auth"]                   => :auth,
+        # ["/register_device", :post] => :register_device,
+        # ["/notifications", :*]   => :notifications,
+        ["/stats", :post]           => :stats,
+        ["/push_files", :post]      => :push_files,
+        ["/file_list"]              => :file_list,
+        ["/file_info"]              => :file_info
+      }
+    end
+
+    def initialize
+      usage = Boxlet::App.app_space_usage
+      capacity = Boxlet::App.app_space_capacity
+      puts "Space Utilization: #{usage}MB / #{capacity}MB (#{(usage.to_f / capacity).round(3)}%)"
+    end
+
+    def bind
+      Rack::Builder.new do
+        use Rack::Reloader
+        # use Rack::Static, :urls => ["/public"]
+        use Rack::FileUpload, :upload_dir => [Boxlet.config[:upload_dir] || APP_ROOT + '/uploads']
+
+        Boxlet::App.routes.each do |route, action|
+          map route[0] do
+            run Boxlet::Router.new(route[1] || :*, action)
+          end
+        end
+
+      end.to_app
+    end
+
+
+    def setup(config)
+      begin
+        # Check for free space
+        if Boxlet::App.free_space <= 50
+          raise "Not enough free space"
+        end
+        if Boxlet::App.app_space_usage / Boxlet::App.app_space_capacity >= 0.9
+          puts "App is over 90% full"
+        end
+
+        # Create upload and tmp directories
+        upload_dir = Boxlet.config[:upload_dir]
+        tmp_dir = Boxlet.config[:tmp_dir]
+        if !File.exists?(upload_dir) || !File.exists?(tmp_dir)
+          if !File.exists?(upload_dir)
+            puts "Upload directory (#{upload_dir}) does not exist.  Create? [y/n]"
+            create = gets.chomp
+            if create =~ /y/i
+              Dir.mkdir(upload_dir)
+              puts "Upload directory created!"
+            end
+          end
+          if !File.exists?(tmp_dir)
+            puts "Temp directory (#{tmp_dir}) does not exist.  Create? [y/n]"
+            create = gets.chomp
+            if create =~ /y/i
+              Dir.mkdir(tmp_dir)
+              puts "Temp directory created!"
+            end
+          end
+          if File.exists?(upload_dir) && File.exists?(tmp_dir)
+            puts "Done creating directories."
+          else
+            raise "Error creating directories.  Please check your config and file permissions, and retry."
+          end
+        end
+
+        puts "\nBoxlet setup is done!"
+      rescue => e
+        puts "\nERROR: #{e}"
+      end
+    end
+
+
+    # App disk space functions
+
+    def self.free_space
+      Boxlet::App.app_space_capacity - Boxlet::App.app_space_usage
+    end
+
+    def self.app_space_capacity
+      drive_free_space = Boxlet::App.drive_free_space
+      if Boxlet.config[:capacity].is_a? String
+        Boxlet::App.drive_free_space * Boxlet.config[:capacity].to_i / 100
+      else
+        Boxlet.config[:capacity]
+      end
+    end
+
+    def self.app_space_usage
+      raise RuntimeError, "#{Boxlet.config[:upload_dir]} is not a directory" unless File.directory?(Boxlet.config[:upload_dir])
+
+      total_size = 0
+      Dir["#{Boxlet.config[:upload_dir]}/**/*"].each do |f|
+        total_size += File.size(f) if File.file?(f) && File.size?(f)
+      end
+      total_size / 1000000 # / 1048576 # to megabytes
+    end
+
+    # Drive disk space functions
+
+    def self.drive_free_space
+      stat = Filesystem.stat(Boxlet.config[:file_system_root])
+      (stat.block_size * stat.blocks_available).to_mb
+    end
+
+    def self.drive_capacity
+      stat = Filesystem.stat(Boxlet.config[:file_system_root])
+      (stat.block_size * stat.blocks).to_mb
+    end
+
+
+  end
+end

data/lib/boxlet/app/controller.rb

@@ -0,0 +1,168 @@
+require 'date'
+
+# routes = {
+#   ["/", :get]                 => :index,
+#   ["/auth"]                   => :auth,
+#   ["/register_device", :post] => :register_device,
+#   ["/notifications", :post]   => :notifications,
+#   ["/push_files", :post]      => :push_files,
+#   ["/file_list"]              => :file_list,
+#   ["/file_info"]              => :file_info
+# }
+
+
+module Boxlet
+  class Controller
+    attr_accessor :request, :format, :params
+
+    def initialize(request)
+      @request = request
+      @params = Boxlet.symbolize_keys request.params
+      pp request.params
+
+      @format = :html
+    end
+
+    def action(action)
+      action_response = self.send(action)
+      set_user if action =~ /push_files|file_list|file_info/
+      
+      {format: @format, content: action_response}
+    end
+
+
+    # actions
+
+    def index
+      '<html><body><form action="/push_files" method="post" enctype="multipart/form-data">UUID:<input type="text" name="uuid"><br><input type="file" name="file"><input type="submit"></form>'
+    end
+
+    # def auth
+    #   @format = :json
+    #   "auth"
+    # end
+
+    # def register_device
+    #   @format = :json
+
+    #   pp @params if Boxlet.config[:debug]
+
+    #   uuid = @params[:uuid]
+    #   # user = user_model.merge { uuid: uuid }
+    #   if db.collection('users').insert(user)
+    #     {response: true}
+    #   else
+    #     {response: false}
+    #   end
+    # end
+
+    # def notifications
+    #   @format = :json
+
+    #   uuid = @params[:uuid]
+    #   notifications = @params[:notifications]
+    #   pp uuid
+    #   # @user
+    #   "notifications"
+    # end
+
+    def stats
+      @format = :json
+
+      {
+        capacity: Boxlet::App.app_space_capacity,
+        usage: Boxlet::App.app_space_usage,
+        free_space: free_space?
+      }
+    end
+
+    def push_files
+      @format = :json
+      
+      upload_path = user_upload_dir || './uploads'
+      upload_file = @params[:file]
+      asset_path = @params[:asset_path]
+      asset_path_params = Rack::Utils.parse_nested_query(asset_path[asset_path.index('?') + 1..-1])
+
+      new_filename = "#{asset_path_params["id"]}.#{asset_path_params["ext"]}"
+      new_path = File.join(upload_path, new_filename)
+      FileUtils.mv(upload_file[:tempfile].path, new_path)
+
+      if File.exists? new_path
+        file = File.open(new_path, 'r')
+        # asset_date = Date.parse(@params[:asset_date])
+        asset = {
+          filename: upload_file[:filename],
+          size: file.size,
+          local_date: file.mtime.to_i,
+          asset_path: @params[:asset_path],
+          asset_date: @params[:asset_date],
+          uuid: @params[:uuid]
+        }
+        db.collection('assets').insert(asset)
+        {response: true}
+      else
+        {response: false}
+      end
+    end
+
+    def file_list
+      @format = :json
+
+      uuid = @params[:uuid]
+      db.collection('assets').find({uuid: uuid}).to_a
+    end
+
+    def file_info
+      @format = :json
+
+      uuid = @params[:uuid]
+      asset_path = @params[:asset_path]
+      file_model.merge db.collection('assets').find({asset_path: asset_path, uuid: uuid}).to_a.first || {}
+    end
+
+
+    private
+
+    def db
+      Boxlet::Db.connection
+    end
+
+    def set_user
+      user_model.merge db.collection('users').find({uuid: @params[:uuid]}).to_a.first || {}
+    end
+
+    def user_upload_dir
+      user_upload_dir_name = Boxlet.config[:upload_dir] + "/" + (@params[:uuid] || '')
+      Dir.mkdir(user_upload_dir_name) unless File.exists?(user_upload_dir_name)
+      user_upload_dir_name
+    end
+
+    def free_space?
+      Boxlet::App.free_space > 50
+    end
+
+
+    # Models
+
+    def file_model
+      {
+        filename: '',
+        size: 0,
+        local_date: 0,
+        asset_path: '',
+        asset_date: '',
+        uuid: []
+      }
+    end
+
+    def user_model
+      {
+        uuid: '',
+        notifications: 1,
+        last_activity: Time.now
+      }
+    end
+
+  end
+end

data/lib/boxlet/app/router.rb

@@ -0,0 +1,45 @@
+require "rack/request"
+require "rack/response"
+require "boxlet/app/controller"
+require "json"
+
+
+module Boxlet
+  class Router
+
+    attr_accessor :method, :action
+
+    def initialize(method, action)
+      @method = method
+      @action = action
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if Boxlet.debug?
+        puts "\n#{env["REMOTE_ADDR"]} - [#{Time.now.to_s}] #{@method.upcase} #{env["SERVER_PROTOCOL"]} => #{env["REQUEST_PATH"]}"
+      end
+
+      response = Rack::Response.new
+      controller = Boxlet::Controller.new(request)
+      if (@method == :* || request.get? && @method == :get) || (request.post? && @method == :post)
+        puts "Responding: #{@method.upcase} => #{@action}" if Boxlet.debug?
+        action_response = controller.action(@action)
+        response.status = 200
+      else
+        response.status = 404
+        raise "404"
+      end
+
+      if action_response[:format] == :json
+        response.write action_response[:content].to_json
+      else
+        response.write action_response[:content]
+      end
+
+      response.finish
+    end
+
+  end
+end

data/lib/boxlet/config.rb

@@ -0,0 +1,119 @@
+module Boxlet
+  module Config
+
+    ARGS  = {
+      :path => {
+        :short      => 'f',
+        :default    => Proc.new { Dir.pwd }
+      },
+      :port => {
+        :short      => 'p',
+        :default    => 8077,
+        :sanitizer  => Proc.new { |p| p.to_i }
+      },
+      :host => {
+        :short      => 'o',
+        :default    => 'localhost'
+      },
+      :server_type => {
+        :short      => 's',
+        :default    => 'rack',
+        :sanitizer  => Proc.new { |p| p.to_sym }
+      },
+      :environment => {
+        :short      => 'E',
+        :default    => 'development'
+      },
+      :daemonize => {
+        :short      => 'D',
+        :default    => 'false',
+        :sanitizer  => Proc.new { |p| p == 'true' }
+      },
+      :debug => {
+        :short      => 'd',
+        :default    => 'true',
+        :sanitizer  => Proc.new { |p| p == 'true' }
+      },
+      :upload_dir => {
+        :short      => 'U',
+        :default    => './uploads'
+      },
+      :tmp_dir => {
+        :short      => 'T',
+        :default    => './tmp'
+      },
+      :file_system_root => {
+        :short      => 'r',
+        :default    => '/'
+      },
+      :capacity => {
+        :short      => 'C',
+        :default    => '90%',
+        :sanitizer  => Proc.new { |p| (p.to_i.to_s == p) ? p.to_i : p }
+      }
+    }
+
+
+    def populate_params!(argv, path_to_config)
+      @raw_config = load_config_file(path_to_config)
+      @raw_params = parse_arguments(argv)
+      # @config = @raw_params.merge(@raw_config)
+      @config = @raw_config.merge(@raw_params)
+
+      @config[:debug] = @raw_config[:debug] || @raw_params[:debug]
+      if @config[:debug]
+        pp @config
+      end
+    end
+
+
+    def symbolize_keys(hash)
+      hash.inject({}){|result, (key, value)|
+        new_key = key.instance_of?(String) ? key.to_sym : key
+        new_value = value.instance_of?(Hash) ? symbolize_keys(value) : value
+
+        result[new_key] = new_value
+        result
+      }
+    end
+
+    private
+
+    def parse_arguments(argv)
+      params = Hash.new
+
+      ARGS.each_pair do |param_name, param_attrs|
+        param_short_name = param_attrs[:short]
+        config_value = @raw_config[param_name.to_sym]
+        default = param_attrs[:default]
+        sanitizer = param_attrs[:sanitizer]
+
+        param_value = argv["--#{param_name}"] ||
+                      (param_short_name.nil? ? nil : argv["-#{param_short_name}"]) ||
+                      (config_value.nil? ? nil : config_value) ||
+                      (default.is_a?(Proc) ? default.call : default)
+
+        param_value = sanitizer.call(param_value) if sanitizer.is_a?(Proc)
+
+        if !param_value.nil?
+          params[param_name] = param_value
+        end
+      end
+
+      params
+    end
+
+    def load_config_file(path_to_config)
+      begin
+        loaded_config = YAML.load_file(path_to_config)
+        symbolize_keys(loaded_config)
+      rescue
+        puts "Error loading config file!  Using defaults..."
+        {}
+      end
+    end
+
+  end
+
+  
+end

data/lib/boxlet/db.rb

@@ -0,0 +1,29 @@
+require 'mongo'
+
+
+module Boxlet
+  module Db
+
+    extend self
+    include Mongo
+
+    attr_accessor :db
+
+    def connection
+      @db ||= self.connect
+    end
+
+    def connect
+      config = Boxlet.config
+      db_config = config[:db][config[:environment].to_sym || :development]
+
+      host = db_config[:host] || 'localhost'
+      port = db_config[:port] || MongoClient::DEFAULT_PORT
+      puts "Connecting to #{host}:#{port}" if Boxlet.debug?
+      client  = MongoClient.new(host, port)
+      db = client.db(db_config[:db] || 'boxlet_development')
+      return db
+    end
+
+  end
+end

data/lib/boxlet/log.rb

@@ -1,6 +1,7 @@
 require "logger"
 require "fileutils"
 
+
 module Log
   def get_logger(name, shift_age, shift_size, level)
     # create the directory for the log if it doesn't exist

data/lib/boxlet/runner.rb

@@ -0,0 +1,37 @@
+require "handlers/thin"
+
+
+module Boxlet
+  class Runner
+    attr_accessor :server, :server_instance
+
+    def start(app, &block)
+      params = Boxlet.config
+      environment  = ENV['RACK_ENV'] || params[:environment] rescue 'development'
+      default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+
+      params[:Host] = params.delete(:host) || default_host
+      params[:Port] = params.delete(:port) || 8077
+
+      server_type = params.delete(:server_type) || :thin
+      @server_instance = self.send server_type.to_sym, app, params
+      @server_instance.start do |server|
+        self.server = server
+        block.call(server) if block_given?
+      end
+    end
+
+    def stop
+      @server.stop!
+    end
+
+    def rack(app, params)
+      Rack::Server.new(params.merge({app: app}))
+    end
+
+    def thin(app, params)
+      Boxlet::Handlers::Thin.new(app, params)
+    end
+
+  end
+end

data/lib/boxlet/version.rb

@@ -1,3 +1,3 @@
 module Boxlet
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/handlers/thin.rb

@@ -0,0 +1,34 @@
+require "thin"
+require "rack/content_length"
+require "rack/chunked"
+
+
+module Boxlet
+  module Handlers
+    class Thin
+      attr_accessor :app, :params
+
+      def initialize(app, params={})
+        @app = app
+        @params = params
+        # super
+      end
+
+      # ported from https://github.com/rack/rack/tree/master/lib/rack/handler/thin.rb
+      def start
+        # environment  = ENV['RACK_ENV'] || 'development'
+        # default_host = environment == 'development' ?  : '0.0.0.0'
+        host = @params.delete(:Host) || 'localhost'
+        port = @params.delete(:Port) || 8077
+
+        args = [host, port, @app, @params]
+
+        # Thin versions below 0.8.0 do not support additional options
+        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
+        server = ::Thin::Server.new(*args)
+        yield server if block_given?
+        server.start
+      end
+    end
+  end
+end

data/lib/rack/boxlet_url_builder.rb

@@ -0,0 +1,16 @@
+require "rack"
+require "rack/boxlet_url_map"
+
+
+module Rack
+  class BoxletUrlBuilder < Builder
+
+    private
+
+    def generate_map(default_app, mapping)
+      mapped = default_app ? {'/' => default_app} : {}
+      mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b) }
+      BoxletUrlMap.new(mapped)
+    end
+  end
+end

data/lib/rack/boxlet_url_map.rb

@@ -0,0 +1,66 @@
+require "rack"
+
+
+module Rack
+  class BoxletUrlMap < URLMap
+
+    def remap(map)
+      @mapping = map.map { |location, app|
+        if location.is_a? String
+          if location =~ %r{\Ahttps?://(.*?)(/.*)}
+            host, location = $1, $2
+          else
+            host = nil
+          end
+
+          unless location[0] == ?/
+            raise ArgumentError, "paths need to start with /"
+          end
+
+          location = location.chomp('/')
+          match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
+        elsif location.is_a? Regexp
+          match = location
+        else
+          raise ArgumentError, "location should be an instance of String or Regexp"
+        end
+
+        [host, location, match, app]
+      }.sort_by do |(host, location, _, _)|
+        [host ? -host.size : INFINITY, (location.is_a?(String) ? -location.size : INFINITY)]
+      end
+
+      @mapping
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      script_name = env['SCRIPT_NAME']
+      hHost = env['HTTP_HOST']
+      sName = env['SERVER_NAME']
+      sPort = env['SERVER_PORT']
+
+      @mapping.each do |host, location, match, app|
+        unless hHost == host \
+            || sName == host \
+            || (!host && (hHost == sName || hHost == sName+':'+sPort))
+          next
+        end
+
+        next unless m = match.match(path.to_s)
+
+        rest = m[1]
+        next unless !rest || rest.empty? || rest[0] == ?/
+
+        return app.call(env)
+      end
+
+      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+
+    ensure
+      env['PATH_INFO'] = path
+      env['SCRIPT_NAME'] = script_name
+    end
+
+  end
+end

data/lib/rack/file_upload.rb

@@ -0,0 +1,121 @@
+# ported from https://github.com/New-Bamboo/rack-raw-upload
+require 'multi_json'
+
+
+module Rack
+  class FileUpload
+
+    def initialize(app, options={})
+      @app = app
+      @paths = [options[:upload_dir]]
+      @explicit = options[:explicit]
+      @tmpdir = options[:tmp_dir] || Dir::tmpdir
+      @paths = [@paths] if @paths.kind_of?(String)
+    end
+
+    def call(env)
+      kick_in?(env) ? convert_and_pass_on(env) : @app.call(env)
+    end
+
+    def upload_path?(request_path)
+      return true if @paths.nil?
+
+      @paths.any? do |candidate|
+        literal_path_match?(request_path, candidate) || wildcard_path_match?(request_path, candidate)
+      end
+    end
+
+
+    private
+
+    def convert_and_pass_on(env)
+      if env['rack.input'].kind_of?(Tempfile)
+        env['rack.input'].extend(EqlFix)
+        tempfile = env['rack.input']
+      else
+        tempfile = Tempfile.new('raw-upload.', @tmpdir)
+
+        env['rack.input'].each do |chunk|
+          if chunk.respond_to?(:force_encoding)
+            tempfile << chunk.force_encoding('UTF-8')
+          else
+            tempfile << chunk
+          end
+        end
+        env['rack.input'].rewind
+
+        tempfile.flush
+        tempfile.rewind
+      end
+      fake_file = {
+        :filename => env['HTTP_X_FILE_NAME'],
+        :type => env['CONTENT_TYPE'],
+        :tempfile => tempfile,
+      }
+      env['rack.request.form_input'] = env['rack.input']
+      env['rack.request.form_hash'] ||= {}
+      env['rack.request.query_hash'] ||= {}
+      env['rack.request.form_hash']['file'] = fake_file
+      env['rack.request.query_hash']['file'] = fake_file
+      if env['HTTP_X_QUERY_PARAMS']
+        env['rack.errors'].puts("Warning! The header X-Query-Params is deprecated. Please use X-JSON-Params instead.")
+        inject_json_params!(env, env['HTTP_X_QUERY_PARAMS'])
+      end
+      if env['HTTP_X_JSON_PARAMS']
+        inject_json_params!(env, env['HTTP_X_JSON_PARAMS'])
+      end
+      if env['HTTP_X_PARAMS']
+        inject_query_params!(env, env['HTTP_X_PARAMS'])
+      end
+      @app.call(env)
+    end
+
+    def kick_in?(env)
+      env['HTTP_X_FILE_UPLOAD'] == 'true' ||
+        ! @explicit && env['HTTP_X_FILE_UPLOAD'] != 'false' && raw_file_upload?(env) ||
+        env.has_key?('HTTP_X_FILE_UPLOAD') && env['HTTP_X_FILE_UPLOAD'] != 'false' && raw_file_upload?(env)
+    end
+
+    def raw_file_upload?(env)
+      upload_path?(env['PATH_INFO']) &&
+        %{POST PUT}.include?(env['REQUEST_METHOD']) &&
+        content_type_of_raw_file?(env['CONTENT_TYPE']) &&
+        env['CONTENT_LENGTH'].to_i > 0
+    end
+
+    def literal_path_match?(request_path, candidate)
+      candidate == request_path
+    end
+
+    def wildcard_path_match?(request_path, candidate)
+      return false unless candidate.include?('*')
+      regexp = '^' + candidate.gsub('.', '\.').gsub('*', '[^/]*') + '$'
+      !! (Regexp.new(regexp) =~ request_path)
+    end
+
+    def content_type_of_raw_file?(content_type)
+      case content_type
+        when %r{^application/x-www-form-urlencoded}, %r{^multipart/form-data}
+          false
+        else
+          true
+      end
+    end
+
+    def random_string
+      (0...8).map{65.+(rand(25)).chr}.join
+    end
+
+    def inject_json_params!(env, params)
+      json = MultiJson.load(params)
+      env['rack.request.form_hash'].merge!(json)
+      env['rack.request.query_hash'].merge!(json)
+    end
+
+    def inject_query_params!(env, params)
+      json = Rack::Utils.parse_query(params)
+      env['rack.request.form_hash'].merge!(json)
+      env['rack.request.query_hash'].merge!(json)
+    end
+  end
+end

metadata

@@ -1,50 +1,166 @@
 --- !ruby/object:Gem::Specification
 name: boxlet
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
-- Clayton Liggitt
 - arktisklada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-02 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rack-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.1
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.2
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.2
+- !ruby/object:Gem::Dependency
+  name: sys-filesystem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: A server for Boxlet, a DIY, self-hosted file storage system
+        version: '10.3'
+description: Upload pics from your phone
 email:
 - mail@enorganik.com
 executables:
@@ -52,39 +168,47 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- config.yml
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/boxlet
 - boxlet.gemspec
+- config.yml
+- lib/boxlet.rb
+- lib/boxlet/app.rb
+- lib/boxlet/app/controller.rb
+- lib/boxlet/app/router.rb
+- lib/boxlet/config.rb
+- lib/boxlet/db.rb
 - lib/boxlet/log.rb
-- lib/boxlet/tcp_server.rb
+- lib/boxlet/runner.rb
 - lib/boxlet/version.rb
-- lib/boxlet.rb
-- bin/boxlet
-homepage: http://github.com/arktisklada/boxlet
+- lib/handlers/thin.rb
+- lib/rack/boxlet_url_builder.rb
+- lib/rack/boxlet_url_map.rb
+- lib/rack/file_upload.rb
+homepage: https://github.com/arktisklada/boxlet
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
-summary: A server for Boxlet, a DIY, self-hosted file storage system
+specification_version: 4
+summary: Upload pics from your phone
 test_files: []

data/lib/boxlet/tcp_server.rb

@@ -1,62 +0,0 @@
-require "socket"
-
-class TcpServer
-
-  include Log
-
-  def initialize()
-    @listen_ip = Boxlet::Server.config['tcp_listen_ip'] || '127.0.0.1'
-    @listen_port = Boxlet::Server.config['tcp_listen_port'] || 11311
-    
-    @log = get_logger('log/tcp.log', 10, 1024000, Boxlet::Server.config['tcp_debug'] ? Logger::DEBUG : Logger::WARN);
-    @log.info("Initializing TCP server on #{@listen_ip}:#{@listen_port}")
-    @server = TCPServer.open(@listen_ip, @listen_port)
-
-    @connections = Hash.new
-  end
-
-  def start
-    @log.info("Starting TCP server")
-    
-    # Start a new thread for the TCP server so that it does not block and
-    # hold up the rest of the program execution
-    # Thread.start() do 
-      loop {
-        # When a new connection comes in, create a new thread and begin handling
-        # requests
-        Thread.start(@server.accept) do |client|
-          @log.info("Client connected!")
-          
-          # Output welcome messages
-          client.puts Time.now.ctime
-          client.puts "Welcome to Boxlet!"
-          
-          # Read input from TCP client
-          while line = client.gets
-            entry = line.split
-            cmd = entry.shift
-            
-            case cmd
-              # Retrieve config value
-              when "config_get" then client.puts(Boxlet::Server.config[entry[0]] || "ERROR")
-              
-              # Halt the server
-              when "stop" then
-                client.puts "Daemon halting!"
-                @log.info("Daemon halting!")
-                exit(0)
-              
-              # Disconnect the client
-              when "quit" then
-                client.puts "Goodbye!"
-                client.close
-              else
-                client.puts "INVALID"
-            end
-          end
-        end
-      }
-    # end
-  end
-
-end