strobe 0.1.6 → 0.2.0.beta.1

data/lib/strobe/cli/users.rb

@@ -18,7 +18,8 @@ module Strobe
     end
 
     application_path_option
-    action "add", "give a user access to this application" do |email|
+    action "add", "give a user access to this application",
+           :usage => "users add <email>"  do |email|
       @team = get_current_team!
       @team.memberships.create! :email => email
 
@@ -26,7 +27,8 @@ module Strobe
     end
 
     application_path_option
-    action "remove", "remove a user's access from this application" do |email|
+    action "remove", "remove a user's access from this application",
+           :usage => "users remove <email>" do |email|
       @team = get_current_team!
       @team.memberships.each do |m|
         m.destroy if (m.user ? m.user[:email] : m[:email]) == email

data/lib/strobe/collection.rb

@@ -22,7 +22,7 @@ module Strobe
             klass.new(hash)
           end
         else
-          raise "Something went wrong"
+          raise ServerError.new("Something went wrong", :request => resp.request, :response => resp)
         end
       end
     end

data/lib/strobe/config.rb

@@ -0,0 +1,181 @@
+require 'json'
+
+module Strobe
+  class Config
+    class InPlaceEditException < RuntimeError; end
+
+    # This function is specifically to migrate legacy applications
+    # still using .strobe/config to track the application ID
+    def self.new_or_stub(application_root)
+      application_root = File.expand_path(application_root.to_s)
+
+      IdentityMap.identify self, application_root do
+        config_path     = "#{application_root}/strobe/config.json"
+        old_config_path = "#{application_root}/.strobe/config"
+
+        if File.exist?(config_path)
+          new(config_path)
+        elsif File.exist?(old_config_path)
+          c = YAML.load_file(old_config_path)
+          if Hash === c && application_id = c['STROBE_APPLICATION_ID']
+            c.delete('STROBE_APPLICATION_ID')
+            stub!(application_root, application_id.to_i)
+          end
+        end
+      end
+    end
+
+    def self.stub!(path, application_id = nil)
+      config_path = "#{path}/strobe/config.json"
+
+      if File.exist?(config_path)
+        raise "There already is a config file, cannot stub"
+      end
+
+      inst = new(config_path)
+      inst.set_application_id!(application_id || "[PENDING DEPLOY]")
+      inst
+    end
+
+    def initialize(path)
+      @path, @hash = path, nil
+      update!
+    end
+
+    def application_path
+      File.expand_path('../..', @path)
+    end
+
+    def [](key)
+      key = key.to_s
+
+      if key.blank?
+        raise ArgumentError, "Key cannot be blank"
+      end
+
+      if key == "application_id"
+        if @hash["application_id"] =~ /^\s*\d+\s*$/
+          return @hash["application_id"].to_i
+        end
+
+        return
+      end
+
+      key.split('.').inject(@hash) do |val, key|
+        val && val[key]
+      end
+    end
+
+    def unset_application_id!
+      set_application_id! "[PENDING DEPLOY]"
+    end
+
+    # MEGA HACK WARNING!
+    # We need to be able to update the application_id in the json file
+    # after the first deploy. It would be nice to do this without modifying
+    # anything else, so we find the spot where the old value is, swap in
+    # the new value
+    def set_application_id!(id)
+      id     = id.to_s
+      old_id = @hash["application_id"]
+      self[:application_id] = id
+
+      # First make sure that there already is an application_id value
+      if old_id
+        first, rest = "", raw_json
+        raw_id      = old_id.to_json
+
+        while m = /#{Regexp.escape(raw_id)}/.match(rest)
+          new_str  = "#{first}#{m.pre_match}#{id.to_json}#{m.post_match}"
+          new_hash = JSON.parse(new_str) rescue nil
+
+          if @hash == new_hash
+            write_raw_json(new_str)
+            return
+          end
+
+          rest = m.post_match
+          first << m.pre_match << m[0]
+        end
+
+        raise InPlaceEditException, "Was unable to set application_id to #{id}"
+
+      # check if there are any other keys, if there are, then we need
+      # to inject the application_id key at the very beginning
+      elsif @hash.keys.length > 1
+        json = raw_json
+        json.sub!(/^(\s*){\s*(})?/m) do |m|
+          lines = "#{$1}{\n" \
+                  "#{$1}  // The Strobe Platform ID for the application. This is how the local\n" \
+                  "#{$1}  // application is mapped to one on the server.\n" \
+                  "#{$1}  \"application_id\": #{id.to_json},\n\n"
+
+          if $3
+            lines << "#{$1}}"
+          else
+            lines << "#{$1}  "
+          end
+
+          lines
+        end
+
+        write_raw_json(json)
+
+      # Otherwise, the json file is basically empty, so we probably can just
+      # fully reset it
+      else
+
+        stub!(id)
+
+      end
+    end
+
+    def update!
+      parsed = parsed_json
+      @hash = parsed
+    end
+
+  private
+
+    def stub!(application_id = nil)
+      FileUtils.mkdir_p(File.dirname(@path))
+      write_raw_json <<-JSON
+// Strobe Platform application configuration file. This file should
+// be checked into revision control.
+{
+
+  // The Strobe Platform ID for the application. This is how the local
+  // application is mapped to one on the server.
+  "application_id": "#{application_id || "[PENDING DEPLOY]"}"
+
+}
+      JSON
+    end
+
+    def []=(key, val)
+      keys = key.to_s.split('.')
+
+      node = keys[0..-2].inject(@hash) do |val, key|
+        val[key]
+      end
+
+      node[keys.last] = val
+    end
+
+    def write_raw_json(str)
+      File.open(@path, 'w') { |f| f.write str }
+    end
+
+    def parsed_json
+      if str = raw_json
+        JSON.parse(str)
+      else
+        {}
+      end
+    end
+
+    def raw_json
+      File.read(@path) if File.exist?(@path)
+    end
+  end
+end

data/lib/strobe/connection.rb

@@ -45,11 +45,12 @@ module Strobe
     end
 
     class Response
-      attr_reader :headers
+      attr_reader :headers, :request
 
-      def initialize(response)
+      def initialize(response, request)
         @response = response
         @headers  = {}
+        @request  = request
 
         response.each_header do |key, val|
           @headers[key] = val
@@ -86,12 +87,20 @@ module Strobe
         when 404
           raise ResourceNotFoundError, msg
         when 500...600
-          raise ServerError, "The server puked :(. Don't worry, the error has been reported."
+          raise ServerError.new("The server puked :(", :response => to_hash, :request => @request.to_hash)
         end
 
         self
       end
 
+      def to_hash
+        {
+          :body => body,
+          :headers => headers,
+          :status => status
+        }
+      end
+
     private
 
       def mime_type
@@ -103,6 +112,50 @@ module Strobe
       end
     end
 
+    class Request
+      attr_reader :connection, :method, :path, :body, :headers
+
+      def initialize(connection, method, path, body, headers)
+        @connection, @path, @body, @headers = connection, path, body, headers
+        @method = method.to_s.upcase
+      end
+
+      def host; connection.host end
+      def port; connection.port end
+
+      def send
+        http    = build_http
+        request = Net::HTTPGenericRequest.new(method, !!body, true, path, headers)
+
+        body = self.body
+        if body.respond_to?(:read)
+          request.body_stream = body
+          body = nil
+        end
+
+        http.request(request, body)
+      end
+
+      def to_hash
+        {
+          :method => method,
+          :path => path,
+          :body => body,
+          :headers => headers
+        }
+      end
+
+      private
+
+      def build_http
+        http = Net::HTTP.new host, port || 80
+        http.read_timeout = 60
+        http.open_timeout = 10
+        http
+      end
+
+    end
+
     def request(method, path, body = nil, headers = {})
       headers.keys.each do |key|
         headers[key.to_s.downcase] = headers.delete(key)
@@ -124,27 +177,13 @@ module Strobe
         end
       end
 
-      http    = build_http
-      request = Net::HTTPGenericRequest.new(
-        method.to_s.upcase, !!body, true, path, headers)
-
-      if body.respond_to?(:read)
-        request.body_stream = body
-        body = nil
-      end
+      request = Request.new(self, method, path, body, headers)
 
-      Response.new(http.request(request, body))
+      Response.new(request.send, request)
     end
 
   private
 
-    def build_http
-      http = Net::HTTP.new host, port || 80
-      http.read_timeout = 60
-      http.open_timeout = 10
-      http
-    end
-
     def authorization_header
       auth = Base64.encode64("#{@user}:#{@password}")
       auth.gsub!("\n", "")

data/lib/strobe/exception_notifier.rb

@@ -0,0 +1,59 @@
+module Strobe
+  class ExceptionNotifier
+    class << self
+      attr_accessor :enabled
+      alias_method :enabled?, :enabled
+
+      def notify(e, options = {})
+        return unless enabled?
+        message = "Something went wrong with the request. Send an error report to Strobe? [Yn] "
+        if options[:force] || Strobe::CLI::Input.new.agree(message)
+          new(e, options).notify
+        end
+      end
+    end
+
+    self.enabled = true
+    attr_reader :exception, :action
+
+    def initialize(e, options = {})
+      @exception = e
+      @options   = options
+
+      extract_action
+    end
+
+    def notify
+      params = {
+        :error_class   => error_class,
+        :error_message => error_message,
+        :strobe_action => action,
+        :parameters    => parameters,
+        :backtrace     => exception.backtrace.join("\n")
+      }
+      Strobe.connection.post "/errors", params
+    end
+
+    private
+
+    def error_class
+      exception.class.name
+    end
+
+    def error_message
+      "#{error_class}: #{exception.message}"
+    end
+
+    def parameters
+      exception.data if exception.respond_to? :data
+    end
+
+    def extract_action
+      if @options[:action]
+        @action = @options[:action]
+      elsif exception.respond_to?(:data) && exception.data.is_a?(Hash)
+        @action = exception.data.delete(:action)
+      end
+    end
+  end
+end

data/lib/strobe/identity_map.rb

@@ -34,11 +34,13 @@ module Strobe
     end
 
     def [](klass, key)
-      @map[klass.to_s][klass.key.typecast(key)]
+      key = klass.key.typecast(key) if klass.respond_to?(:key)
+      @map[klass.to_s][key]
     end
 
     def []=(klass, key, val)
-      @map[klass.to_s][klass.key.typecast(key)] = val
+      key = klass.key.typecast(key) if klass.respond_to?(:key)
+      @map[klass.to_s][key] = val
     end
 
     def reset!

data/lib/strobe/middleware/addons.rb

@@ -0,0 +1,73 @@
+module Strobe
+  module Middleware
+    class Addons
+      ADDON_PATH = %r[/_strobe/([^/]+)(/.*)?]i
+
+      class Config
+        def initialize(config, settings)
+          @config, @settings = config || {}, settings || {}
+        end
+
+        def [](key)
+          @config[key] || @settings[key]
+        end
+      end
+
+      def initialize(app, opts = {})
+        @app, @opts = app, opts
+      end
+
+      def call(env)
+        if env['PATH_INFO'] =~ ADDON_PATH
+          addon, path = $1, $2
+          call_addon(env, addon, path)
+        else
+          @app.call(env)
+        end
+      end
+
+      def call_addon(env, addon, path)
+        script_name, path_info = "/_strobe/#{addon}", path || ""
+        env = env.merge("SCRIPT_NAME" => script_name, "PATH_INFO" => path_info)
+
+        begin
+          addon_klass = find_addon(addon)
+        rescue Exception => e
+          msg = "Not found"
+          return [ 404, {"Content-Length" => msg.bytesize.to_s}, [msg]]
+        end
+
+        status, hdrs, body = addon_klass.new(config).call(env)
+
+        if Proxy.proxy_response?(status, hdrs)
+          is_head = env['REQUEST_METHOD'] == 'HEAD'
+          Proxy.strobe_redirect(is_head, hdrs, body, env['async.callback'])
+          # Warp speed mr. zulu
+          throw :async
+        else
+          [ status, hdrs, body ]
+        end
+      rescue Exception => e
+        msg = "Something went wrong.\n#{e.message}\n" + e.backtrace.join("\n")
+        [ 500, {"Content-Length" => msg.bytesize.to_s}, [msg]]
+      end
+
+    private
+
+      def config
+        Config.new(@opts[:config], @opts[:settings])
+      end
+
+      def find_addon(addon)
+        klass_name = addon.camelize
+        klass =
+          begin
+            Strobe::Addons.const_get klass_name
+          rescue Exception
+            require "strobe/addons/#{addon}"
+            Strobe::Addons.const_get klass_name
+          end
+      end
+    end
+  end
+end