kensa 1.2.0rc7 → 1.2.0

data/lib/heroku/kensa/client.rb

@@ -1,64 +1,17 @@
 require 'restclient'
 require 'term/ansicolor'
 require 'launchy'
+require 'optparse'
 
 module Heroku
-  class Git
-    class << self
-      def verify_create(app_name, template)
-        raise CommandInvalid.new("template #{clone_url(template)} does not exist") unless template_exists?(template)
-        raise CommandInvalid.new("Need git to clone repository") unless git_installed?
-      end
-
-      def template_exists?(template)
-        true
-      end
-
-      def git_installed?
-        `git` rescue false
-      end
-
-      def clone(app_name, template)
-        verify_create(app_name, template)
-        cmd = "git clone #{clone_url(template)} #{app_name}" 
-        puts cmd
-        `#{cmd}`
-        raise Exception.new("couldn't clone the repository from #{clone_url(template)}") unless File.directory?("#{app_name}")
-        puts "Created #{app_name} from #{template} template"
-      end
-
-      def clone_url(name)
-        prefix = ENV['REPO_PREFIX'] || "heroku"
-        if name.include? "://"  #its a full url
-          return name
-        elsif name.include? "/" #its a non-heroku repo
-          name = "#{prefix}/#{name}" 
-        else                    #its one of ours 
-          name = "#{prefix}/kensa-create-#{name}" 
-        end
-
-        "git://github.com/#{name}"
-      end
-    end
-  end
-
   module Kensa
-    class UserError < RuntimeError; end
-
     class Client
-      def initialize(args, options)
+      def initialize(args, options = {})
         @args    = args
-        @options = options
+        @options = OptParser.parse(args).merge(options)
       end
 
-      def filename
-        @options[:filename]
-      end
-
-      #you fucked up
       class CommandInvalid < Exception; end
-      #we fucked up
-      class CommandFailed  < Exception; end
 
       def run!
         command = @args.shift || @options[:command]
@@ -67,63 +20,44 @@ module Heroku
       end
 
       def init
-        Manifest.new(filename, @options).write
-        Screen.new.message "Initialized new addon manifest in #{filename}\n"
+        Manifest.new(@options).write
+        screen.message "Initialized new addon manifest in #{filename}\n" 
+        if @options[:foreman]
+          screen.message "Initialized new .env file for foreman\n"
+        end
       end
 
       def create
         app_name = @args.shift
         template = @options[:template]
-        raise CommandInvalid.new("Need git to supply a template") unless template
-        raise CommandInvalid.new("Need git to supply an application name") unless app_name
-
+        raise CommandInvalid.new("Need to supply an application name") unless app_name
+        raise CommandInvalid.new("Need to supply a template") unless template
         begin
-          Git.clone(app_name, template)
+          Git.clone(app_name, template) and screen.message "Created #{app_name} from #{template} template\n"
+          Dir.chdir(app_name)
+          @options[:foreman] = true
+          init
         rescue Exception => e
-          raise CommandFailed.new("error cloning #{Git.clone_url(template)} into #{app_name}") 
+          raise CommandInvalid.new("error cloning #{Git.clone_url(template)} into #{app_name}") 
         end
-
-        Dir.chdir("./#{app_name}")
-        `./after_clone #{app_name}` if File.exist?('./after_clone')
       end
 
-
       def test
         case check = @args.shift
           when "manifest"
-            require "#{File.dirname(__FILE__)}/../../../test/manifest_test"
-            require 'test/unit/ui/console/testrunner'
-            $manifest = Yajl::Parser.parse(resolve_manifest)
-            Test::Unit.run = true
-            Test::Unit::UI::Console::TestRunner.new(ManifestTest.suite).start
+            run_check ManifestCheck
           when "provision"
-            require "#{File.dirname(__FILE__)}/../../../test/provision_test"
-            require 'test/unit/ui/console/testrunner'
-            $manifest = Yajl::Parser.parse(resolve_manifest)
-            Test::Unit.run = true
-            Test::Unit::UI::Console::TestRunner.new(ProvisionTest.suite).start
+            run_check ManifestCheck, ProvisionCheck
           when "deprovision"
             id = @args.shift || abort("! no id specified; see usage")
-            require "#{File.dirname(__FILE__)}/../../../test/deprovision_test"
-            require 'test/unit/ui/console/testrunner'
-            $manifest = Yajl::Parser.parse(resolve_manifest).merge("user_id" => id)
-            Test::Unit.run = true
-            Test::Unit::UI::Console::TestRunner.new(DeprovisionTest.suite).start
+            run_check ManifestCheck, DeprovisionCheck, :id => id
           when "planchange"
             id   = @args.shift || abort("! no id specified; see usage")
             plan = @args.shift || abort("! no plan specified; see usage")
-            require "#{File.dirname(__FILE__)}/../../../test/plan_change_test"
-            require 'test/unit/ui/console/testrunner'
-            $manifest = Yajl::Parser.parse(resolve_manifest).merge("user_id" => id)
-            Test::Unit.run = true
-            Test::Unit::UI::Console::TestRunner.new(PlanChangeTest.suite).start
+            run_check ManifestCheck, PlanChangeCheck, :id => id, :plan => plan
           when "sso"
             id = @args.shift || abort("! no id specified; see usage")
-            require "#{File.dirname(__FILE__)}/../../../test/sso_test"
-            require 'test/unit/ui/console/testrunner'
-            $manifest = Yajl::Parser.parse(resolve_manifest).merge("user_id" => id)
-            Test::Unit.run = true
-            Test::Unit::UI::Console::TestRunner.new(SsoTest.suite).start
+            run_check ManifestCheck, SsoCheck, :id => id
           else
             abort "! Unknown test '#{check}'; see usage"
         end
@@ -177,12 +111,20 @@ module Heroku
       end
 
       def version
-        puts "Kensa #{Kensa::VERSION}"
+        puts "Kensa #{VERSION}"
       end
 
       private
+        def filename
+          @options[:filename]
+        end
+
+        def screen
+          @screen ||= @options[:silent] ? NilScreen.new : Screen.new
+        end
+
         def headers
-          { :accept => :json, "X-Kensa-Version" => "1", "User-Agent" => "kensa/#{Kensa::VERSION}" }
+          { :accept => :json, "X-Kensa-Version" => "1", "User-Agent" => "kensa/#{VERSION}" }
         end
 
         def heroku_host
@@ -206,7 +148,6 @@ module Heroku
           options = args.pop if args.last.is_a?(Hash)
 
           args.each do |klass|
-            screen = Screen.new
             data   = Yajl::Parser.parse(resolve_manifest)
             check  = klass.new(data.merge(@options.merge(options)), screen)
             result = check.call
@@ -298,6 +239,43 @@ module Heroku
           $stdout.puts "done."
         end
       end
+
+
+      class OptParser
+        def self.defaults
+          {
+            :filename => 'addon-manifest.json',
+            :env      => "test",
+            :async    => false,
+          }
+        end
+        
+        def self.parse(args)
+          self.defaults.tap do |options|
+            OptionParser.new do |o|
+              o.on("-f file", "--file") { |filename| options[:filename] = filename }
+              o.on("--async")           { options[:async] = true }
+              o.on("--production")      { options[:env] = "production" }
+              o.on("--without-sso")     { options[:sso] = false }
+              o.on("-h", "--help")      { command = "help" }
+              o.on("-p plan", "--plan") { |plan| options[:plan] = plan }
+              o.on("-v", "--version")   { options[:command] = "version" }
+              o.on("-s sso", "--sso")   { |method| options[:method] = method }
+              o.on("--foreman")         { options[:foreman] = true }
+              o.on("-t name", "--template") do |template|
+                options[:template] = template
+              end
+
+              begin
+                o.parse!(args)
+              rescue OptionParser::InvalidOption
+                #skip over invalid options
+                retry
+              end
+            end
+          end
+        end
+      end 
     end
   end
 end

data/lib/heroku/kensa/git.rb

@@ -0,0 +1,39 @@
+module Heroku
+  module Kensa
+    class Git
+      class << self
+        def verify_create(app_name, template)
+          raise CommandInvalid.new("Need git to clone repository") unless git_installed?
+        end
+
+        def git_installed?
+          `git` rescue false
+        end
+
+        def clone(app_name, template)
+          verify_create(app_name, template)
+          run("git clone #{clone_url(template)} #{app_name}")
+        end
+
+        def run(cmd)
+          puts cmd
+          system(cmd)
+        end
+
+        def heroku_prefix
+          ENV["REPO_PREFIX"] || "heroku/kensa-create-"
+        end
+
+        def clone_url(name)
+          if name.include? "://" #its a full url not on github
+            return name
+          elsif !name.include? "/" #its one of ours 
+            name = heroku_prefix + name
+          end
+
+          "git://github.com/#{name}"
+        end
+      end
+    end
+  end
+end

data/lib/heroku/kensa/manifest.rb

@@ -2,28 +2,59 @@ module Heroku
   module Kensa
     class Manifest
 
-      def initialize(filename = 'addon-manifest.json', options = {})
-        @filename, @options = filename, options
+      def initialize(options = {})
+        @method   = options.fetch(:method, 'post').to_sym
+        @filename = options.fetch(:filename, 'addon-manifest.json')
+        @options  = options
       end
 
       def skeleton_json
+        @password = generate_password(16)
+        @port     = @options[:foreman] ? 5000 : 4567
+        (@method == :get) ? get_skeleton : post_skeleton
+      end
+
+      def get_skeleton
+        <<-JSON
+{
+  "id": "myaddon",
+  "api": {
+    "config_vars": [ "MYADDON_URL" ],
+    "password": "#{@password}",#{ sso_key }
+    "production": "https://yourapp.com/",
+    "test": "http://localhost:#{@port}/"
+  }
+}
+JSON
+      end
+
+      def post_skeleton
         <<-JSON
 {
   "id": "myaddon",
   "api": {
-    "config_vars": [ "MYADDON_USER", "MYADDON_URL" ],
-    "password": "#{generate_password(16)}",#{ sso_key }
+    "config_vars": [ "MYADDON_URL" ],
+    "password": "#{@password}",#{ sso_key }
     "production": {
       "base_url": "https://yourapp.com/heroku/resources",
       "sso_url": "https://yourapp.com/sso/login"
     },
     "test": {
-      "base_url": "http://localhost:4567/heroku/resources",
-      "sso_url": "http://localhost:4567/sso/login"
+      "base_url": "http://localhost:#{@port}/heroku/resources",
+      "sso_url": "http://localhost:#{@port}/sso/login"
     }
   }
 }
 JSON
+
+      end
+
+      def foreman
+        <<-ENV
+SSO_SALT=#{@sso_salt}
+HEROKU_USERNAME=myaddon
+HEROKU_PASSWORD=#{@password}
+ENV
       end
 
       def skeleton
@@ -31,14 +62,16 @@ JSON
       end
 
       def write
-        open(@filename, 'w') { |f| f << skeleton_json }
+        File.open(@filename, 'w') { |f| f << skeleton_json }
+        File.open('.env', 'w') { |f| f << foreman } if @options[:foreman]
       end
 
       private
 
         def sso_key
+          @sso_salt = generate_password(16) 
           unless @options[:sso] === false
-            %{\n    "sso_salt": #{ generate_password(16).inspect },}
+            %{\n    "sso_salt": "#{@sso_salt}",}
           end
         end
 

data/lib/heroku/kensa/screen.rb

@@ -0,0 +1,37 @@
+module Heroku
+  module Kensa
+
+    class NilScreen
+      def test(msg)
+      end
+
+      def check(msg)
+      end
+
+      def error(msg)
+      end
+
+      def result(status)
+      end
+
+      def message(msg)
+      end
+    end
+
+    class IOScreen
+      attr_accessor :output
+
+      def initialize(io)
+        @output = io
+      end
+
+      def to_s
+        @output.closed_read? ? '' : @output.tap{|o| o.rewind }.read
+      end
+
+      [:test, :check, :error, :result, :message].each do |method|
+        eval %{ def #{method}(*args)\n @output.puts *args\n end }
+      end
+    end
+  end
+end

data/lib/heroku/kensa/sso.rb

@@ -1,43 +1,40 @@
 require 'restclient'
+require 'uri'
 
 module Heroku
   module Kensa
     class Sso
-      attr_accessor :id, :url, :proxy_port, :timestamp, :token, :sso_url
+      attr_accessor :id, :url, :proxy_port, :timestamp, :token
 
       def initialize(data)
         @id   = data[:id]
         @salt = data['api']['sso_salt']
 
         env   = data.fetch :env, 'test'
-        if data["api"][env].is_a?(Hash)
-          @url  = data["api"][env]["base_url"].chomp('/')
-          @sso_url = data["api"][env]["sso_url"].chomp('/')
-          @use_post = true
+        if @url = data['api'][env]['sso_url']
+          @use_post   = true
+          @proxy_port = find_available_port
         else
           @url  = data["api"][env].chomp('/')
-          @use_post = false
-        end
-        @proxy_port = find_available_port
+        end 
         @timestamp  = Time.now.to_i
         @token      = make_token(@timestamp)
       end
 
       def path
-        extra = self.post? ? '/sso' : ''
-        if self.post?
-          self.sso_url
+        if self.POST? 
+          URI.parse(url).path
         else
           "/heroku/resources/#{id}"
         end
       end
 
-      def post?
+      def POST?
         @use_post
       end
 
       def sso_url
-        if self.post?
+        if self.POST?
           "http://localhost:#{@proxy_port}/"
         else
           full_url
@@ -50,13 +47,13 @@ module Heroku
       alias get_url full_url
 
       def post_url
-        @sso_url
+        url
       end
 
       def timestamp=(other)
         @timestamp = other
         @token = make_token(@timestamp)
-      end
+      end 
 
       def make_token(t)
         Digest::SHA1.hexdigest([@id, @salt, t].join(':'))
@@ -64,7 +61,7 @@ module Heroku
 
       def querystring
         return '' unless @salt
-        '?' + query_data
+        '?' + query_data 
       end
 
       def query_data
@@ -72,10 +69,13 @@ module Heroku
       end
 
       def query_params
-        { 'token' => @token,
+        { 'token'     => @token,  
           'timestamp' => @timestamp.to_s,
-          'nav-data' => sample_nav_data,
-          'user'     => 'username@example.com' }
+          'nav-data'  => sample_nav_data,
+          'email'     => 'username@example.com' 
+        }.tap do |params|
+          params.merge!('id' => @id) if self.POST?
+        end
       end
 
       def sample_nav_data
@@ -97,7 +97,7 @@ module Heroku
       end
 
       def message
-        if self.post?
+        if self.POST?
           "POSTing #{query_data} to #{post_url} via proxy on port #{@proxy_port}"
         else
           "Opening #{full_url}"
@@ -117,13 +117,13 @@ module Heroku
       end
 
       def run_proxy
-        return unless self.post?
+        return unless self.POST?
         server = PostProxy.new self
         @proxy = server
 
         trap("INT") { server.stop }
         pid = fork do
-          server.start
+          server.start 
         end
         at_exit { server.stop; Process.waitpid pid }
       end