harbor 0.16.1

data/lib/harbor/file_store/file.rb

@@ -0,0 +1,100 @@
+module Harbor
+  class FileStore
+    class File
+
+      attr_accessor :store, :path
+
+      def initialize(store, path)
+        @store = store
+        @path = path
+        
+        @pending_writes = []
+      end
+
+      def copy_on_write
+        return @copy_on_write if @copy_on_write
+
+        @copy_on_write = []
+        if store.options[:copy_on_write]
+          store.options[:copy_on_write].each do |name|
+            @copy_on_write << Harbor::FileStore[name].get(@path)
+          end
+        end
+
+        @copy_on_write
+      end
+
+      def copy_on_read
+        return @copy_on_read if @copy_on_read
+
+        @copy_on_read = []
+        if store.options[:copy_on_read]
+          store.options[:copy_on_read].each do |name|
+            @copy_on_read << Harbor::FileStore[name].get(@path)
+          end
+        end
+
+        @copy_on_read
+      end
+
+      def write(data)
+        open("wb")
+
+        copy_on_write.each do |file|
+          if store.options[:async_copy]
+            @pending_writes << lambda { file.write(data) }
+          else
+            file.write(data)
+          end
+        end
+
+        if data
+          @stream.write(data)
+        else
+          @stream.close
+          @stream = nil
+          
+          Thread.new {
+            @pending_writes.each { |write| write.call }
+            @pending_writes = []
+          } if store.options[:async_copy]
+        end
+      end
+
+      def read(bytes = nil)
+        open("r")
+
+        data = @stream.read(bytes)
+
+        copy_on_read.each { |file| file.write(data) }
+
+        unless bytes && data
+          @stream.close
+          @stream = nil
+        end
+
+        data
+      end
+
+      def size
+        store.size(path)
+      end
+
+      def open(mode = "r")
+        @stream ||= store.open(path, mode)
+      end
+
+      ##
+      # Returns the full path to this file
+      ##
+      def absolute_path
+        (@store.root + @path).to_s
+      end
+      
+      def exists?
+        store.exists?(path)
+      end
+
+    end
+  end
+end

data/lib/harbor/file_store/local.rb

@@ -0,0 +1,71 @@
+module Harbor
+  class FileStore
+    class Local < Harbor::FileStore
+
+      attr_accessor :root, :options
+
+      def initialize(path, options = {})
+        path = "#{path}/" unless path =~ /.*\/$/
+        @root = Pathname(path)
+
+        @options = options
+
+        ::FileUtils.mkdir_p(path.to_s)
+      end
+
+      def get(path)
+        path = strip_leading_slash(path)
+        Harbor::FileStore::File.new(self, path)
+      end
+
+      def put(path, absolute_path)
+        raise ArgumentError.new("Harbor::FileStore::Local#put[absolute_path] should be a path but was an IO") if absolute_path.is_a?(IO)
+        path = strip_leading_slash(path)
+        file = Harbor::FileStore::File.new(self, path)
+
+        ::FileUtils.mkdir_p((@root + path).parent.to_s) unless (@root + path).parent.exist?
+
+        ::FileUtils::cp(absolute_path, file.absolute_path)
+        file
+      end
+
+      def delete(path)
+        path = strip_leading_slash(path)
+        ::FileUtils.rm(@root + path)
+        Harbor::File.rmdir_p((@root + path).parent.to_s)
+      end
+
+      def exists?(path)
+        path = strip_leading_slash(path)
+        (@root + path).exist?
+      end
+
+      def open(path, mode = "r", &block)
+        path = strip_leading_slash(path)
+        ::FileUtils.mkdir_p((@root + path).parent.to_s) unless (@root + path).parent.exist?
+        ::File.open(@root + path, mode, &block)
+      end
+
+      def size(path)
+        path = strip_leading_slash(path)
+        ::File.size(@root + path)
+      end
+
+      def local?
+        true
+      end
+
+      private
+
+      def __size__
+        `du -sk #{Shellwords.escape(@root.to_s)} | awk '{ print $1; }'`.chomp.to_i * 1024
+      end
+      
+      def strip_leading_slash(path)
+        path = path[1..path.size - 1] if path =~ /^\//
+        path
+      end
+
+    end
+  end
+end

data/lib/harbor/file_store/mosso.rb

@@ -0,0 +1,154 @@
+require "vendor/cloudfiles-1.3.0/cloudfiles"
+
+module Harbor
+  class FileStore
+    class Mosso < Harbor::FileStore
+
+      attr_accessor :container, :options
+
+      def initialize(username, api_key, container_name, options = {})
+        @username = username
+        @api_key = api_key
+        @container_name = container_name
+        @options = options
+      end
+
+      def get(path)
+        path = strip_leading_slash(path)
+        Harbor::FileStore::File.new(self, path)
+      end
+
+      def put(filename, file)
+        filename = strip_leading_slash(filename)
+        url = container.connection.storagehost + container.connection.storagepath + "/#{container.name}/#{filename}"
+        token = container.connection.authtoken
+
+        path = nil
+
+        if file.is_a?(::File)
+          path = file.path
+        elsif file.is_a?(Harbor::FileStore::File) && file.store.local?
+          path = file.store.path + file.path
+        end
+        
+        make_path(::File.dirname(path))
+
+        command = <<-CMD
+        curl -X "PUT" \\
+             -T #{path ? Shellwords.escape(path.to_s) : "-"} \\
+             -H "X-Auth-Token: #{token}" \\
+             -H "Content-Type: text/plain" \\
+             https://#{url}
+        CMD
+
+        if path
+          system(command)
+        else
+          IO::popen(command, "w") do |session|
+            case file
+            when ::File
+              while data = file.read(500_000)
+                session.write(data)
+              end
+            when Harbor::FileStore::File
+              file.read do |block|
+                session.write(block)
+              end
+            end
+          end
+        end
+      end
+
+      def delete(filename)
+        filename = strip_leading_slash(filename)
+        container.delete_object(filename)
+      end
+
+      def exists?(filename)
+        filename = strip_leading_slash(filename)
+        container.object_exists?(filename)
+      end
+
+      def open(filename, mode = "r", &block)
+        filename = strip_leading_slash(filename)
+        url = container.connection.storagehost + container.connection.storagepath + "/#{container.name}/#{filename}"
+        token = container.connection.authtoken
+
+        if mode == "r"
+          command = <<-CMD
+          curl -s -X "GET" \\
+               -D - \\
+               -H "X-Auth-Token: #{token}" \\
+               https://#{url}
+          CMD
+
+          stream = IO::popen(command, "r")
+
+          headers = []
+
+          while line = stream.gets
+            break if line == "\r\n"
+            headers << line
+          end
+        elsif mode =~ /w/
+          make_path(::File.dirname(filename))
+          
+          command = <<-CMD
+          curl -X "PUT" \\
+               -T #{"-"} \\
+               -H "X-Auth-Token: #{token}" \\
+               -H "Content-Type: text/plain" \\
+               https://#{url}
+          CMD
+
+          stream = IO::popen(command, "w")
+        end
+
+        if block_given?
+          yield stream
+          stream.close
+        else
+          stream
+        end
+      end
+
+      def size(filename)
+        filename = strip_leading_slash(filename)
+        container.object(filename).bytes.to_i
+      end
+
+      def container
+        @container ||= connect!
+      end
+
+      private
+
+      def connect!
+        @connection = CloudFiles::Connection.new(@username, @api_key, true)
+        @container = @connection.container(@container_name)
+      end
+
+      def connected?
+        @connection && @connection.authok?
+      end
+      
+      def make_path(path)
+        if path == "." || path == "/"
+          return
+        else
+          unless @container.object_exists?(path)
+            object = @container.create_object(path)
+            object.write(nil, { 'Content-Type' => 'application/directory'} )
+          end
+          make_path(::File.dirname(path))
+        end
+      end
+      
+      def strip_leading_slash(path)
+        path = path[1..path.size - 1] if path =~ /^\//
+        path
+      end
+
+    end
+  end
+end

data/lib/harbor/file_store/mosso/private.rb

@@ -0,0 +1,8 @@
+module Harbor
+  class FileStore
+    class Mosso
+      class Private < Harbor::FileStore::Mosso
+      end
+    end
+  end
+end

data/lib/harbor/generator.rb

@@ -0,0 +1,56 @@
+require 'pathname'
+require 'erubis'
+
+module Harbor
+
+  class Generator
+
+    class GeneratorError < StandardError; end
+    class UnknownCommandError < GeneratorError; end
+    class GeneratorArgumentError < GeneratorError; end
+
+    attr_accessor :app, :command, :klass, :description, :help
+
+    def initialize(app, command, klass, description, help)
+      @app, @command, @klass, @description, @help = app, command, klass, description, help
+    end
+
+    def self.run(app, command, options = [])
+      executor = if generator = @@generators["#{app}:#{command}"]
+        generator.klass.new(options)
+      else
+        puts usage(app)
+
+        exit(1)
+      end
+
+      executor.run
+    end
+
+    def self.usage(app)
+      usage = []
+      usage << "Usage #{app} command [options]"
+      usage << ""
+      usage << "Available commands:"
+
+      @@generators.select { |key,| key =~ /^#{app}/ }.sort.each do |key, generator|
+        usage << "%12s   %s" % [generator.command, generator.description]
+      end
+
+      usage
+    end
+
+    @@generators = {}
+    def self.register(app, command, klass, description = "", help = "")
+      @@generators["#{app}:#{command}"] = new(app, command, klass, description, help)
+    end
+
+    def self.generators
+      @@generators
+    end
+
+    require Pathname(__FILE__).dirname + "generator/help"
+    require Pathname(__FILE__).dirname + "generator/setup"
+  end
+
+end

data/lib/harbor/generator/help.rb

@@ -0,0 +1,34 @@
+module Harbor
+  class Generator
+
+    class HelpCommand
+      Harbor::Generator.register('harbor', 'help', self)
+
+      def initialize(options)
+        @command = options.first
+      end
+
+      def run
+        if @command
+          generator = Harbor::Generator.generators["harbor:#{@command}"]
+
+          if !generator
+            puts "Command '#{@command}' does not exist."
+          else
+            if generator.help.empty?
+              puts "No help available for '#{@command}'."
+            else
+              puts generator.help
+            end
+          end
+
+          exit(1)
+        else
+          puts Harbor::Generator.usage('harbor')
+          exit(1)
+        end
+      end
+    end
+
+  end
+end

data/lib/harbor/generator/setup.rb

@@ -0,0 +1,82 @@
+require "fileutils"
+
+module Harbor
+  class Generator
+    class SetupCommand
+      HELP = <<-HELP
+Usage: harbor setup app_name
+
+Sets up a new Harbor port using the conventional directory
+structure. The application can be booted using your server
+of choice:
+
+  > rackup                  # http://localhost:9292/
+  > unicorn                 # http://localhost:8080/
+  > thin -R config.ru start # http://localhost:3000/
+
+HELP
+
+      Harbor::Generator.register('harbor', 'setup', self, "Sets up a new harbor project.", HELP)
+
+      attr_reader :app_name
+
+      def initialize(options)
+        @app_name = options.first
+
+        unless @app_name
+          puts HELP
+          exit(1)
+        end
+      end
+
+      def log(action, message)
+        puts "%12s  %s" % [action, message]
+      end
+
+      def run
+        unless File.exists?(@app_name)
+          log("create", @app_name)
+          `mkdir #{@app_name}`
+        end
+
+        skeleton_path = Pathname(__FILE__).dirname + 'skeletons/basic'
+        Dir[skeleton_path + "**/*"].each do |item|
+          item = Pathname(item)
+          relative_path = "#{@app_name}/#{item.relative_path_from(skeleton_path)}"
+          relative_path.sub!("appname", @app_name)
+
+          if File.exists?(relative_path.sub(/\.skel$/, ""))
+            log("exists", relative_path.sub(/\.skel$/, ""))
+            next
+          end
+
+          if item.directory?
+            log("create", relative_path)
+
+            `mkdir #{relative_path}`
+          elsif relative_path.sub!(/\.skel$/, "")
+            log("create", relative_path)
+
+            ::File.open(relative_path, 'w') do |file|
+              file.puts Erubis::FastEruby.new(::File.read(item), :pattern => '##> <##').evaluate(self)
+            end
+          else
+            log("create", relative_path)
+
+            FileUtils.cp(item, relative_path)
+          end
+            
+        end
+
+        `chmod +x #{@app_name}/config.ru`
+      end
+
+      def app_class
+        # 'sample' => 'Sample'
+        # 'cool_app' => 'CoolApp'
+        @app_name.gsub(/(^|-|_)[a-z0-9]{1}/) { |m| m.sub(/-|_/, '').upcase }
+      end
+
+    end
+  end
+end