pagoda 0.1.0

data/lib/pagoda/tunnel_proxy.rb

@@ -0,0 +1,130 @@
+require "socket"
+require 'openssl'  
+
+module Pagoda
+  class TunnelProxy
+    include Pagoda::Helpers
+    
+    def initialize(type, user, pass, app, instance)
+      @type     = type
+      @user     = user
+      @pass     = pass
+      @app      = app
+      @instance = instance 
+    end
+    
+    def start
+      
+      [:INT, :TERM].each do |sig|
+        Signal.trap(sig) do
+          display "Tunnel Closed."
+          display "-----------------------------------------------"
+          display
+          exit
+        end
+      end
+      
+      local_port   = 3307
+      remote_host = "www.pagodabox.com"
+      remote_port = 3306
+
+      max_threads     = 20
+      threads         = []
+
+      chunk           = 4096
+
+      #puts "start TCP server"
+      display "+> Opening Tunnel"
+      bound = false
+      until bound
+        begin
+          proxy_server = TCPServer.new('0.0.0.0', local_port)
+          bound = true
+        rescue Errno::EADDRINUSE
+          local_port += 1
+        end
+      end
+      
+      display
+      display "Tunnel Established!  Accepting connections on :"
+      display "-----------------------------------------------"
+      display
+      display "HOST : 127.0.0.1 (or localhost)", true, 2
+      display "PORT : #{local_port}", true, 2
+      display "USER : (found in pagodabox dashboard)", true, 2
+      display "PASS : (found in pagodabox dashboard)", true, 2
+      display
+      display "-----------------------------------------------"
+      display "(note : ctrl-c To close this tunnel)"
+      
+      loop do
+
+        #puts "start a new thread for every client connection"
+        threads << Thread.new(proxy_server.accept) do |client_socket|
+
+          begin
+            # puts "client connection"
+            begin
+              server_socket         = TCPSocket.new(remote_host, remote_port)
+              ssl_context           = OpenSSL::SSL::SSLContext.new()  
+              ssl_socket            = OpenSSL::SSL::SSLSocket.new(server_socket, ssl_context)  
+              ssl_socket.sync_close = true  
+              ssl_socket.connect
+            rescue Errno::ECONNREFUSED
+              # puts "connection refused"
+              client_socket.close
+              raise
+            end
+
+            # puts "authenticate"
+            if ssl_socket.readpartial(chunk) == "auth"
+              # puts "authentication"
+              ssl_socket.write "auth=#{@user}:#{@pass}:#{@app}:#{@instance}" 
+              if ssl_socket.readpartial(chunk) == "success"
+                # puts "successful connection"
+              else
+                # puts "failed connection"
+              end
+            else
+              # puts "danger will robbinson! abort!"
+            end
+
+            loop do
+              # puts "wait for data on either socket"
+              (ready_sockets, dummy, dummy) = IO.select([client_socket, ssl_socket])
+
+              # puts "full duplex connection until data stream ends"
+              begin
+                ready_sockets.each do |socket|
+                  data = socket.readpartial(chunk)
+                  if socket == client_socket
+                    #puts "read from client and write to server"
+                    ssl_socket.write data
+                    ssl_socket.flush
+                  else
+                    #puts "read from server and write to client."
+                    client_socket.write data
+                    client_socket.flush
+                  end
+                end
+              rescue EOFError
+                break
+              end
+            end
+
+          rescue StandardError => error
+          end
+          client_socket.close rescue StandardError
+          ssl_socket.close rescue StandardError
+        end
+
+        #puts "clean up the dead threads, and wait until we have available threads"
+        threads = threads.select { |thread| thread.alive? ? true : (thread.join; false) }
+        while threads.size >= max_threads
+          sleep 1
+          threads = threads.select { |thread| thread.alive? ? true : (thread.join; false) }
+        end
+      end
+    end
+  end
+end

data/lib/pagoda/version.rb

@@ -0,0 +1,3 @@
+module Pagoda
+  VERSION = "0.1.1"
+end

data/lib/pagoda.rb

@@ -0,0 +1,3 @@
+module Pagoda
+  
+end

data/pagoda.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pagoda/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pagoda"
+  s.version     = Pagoda::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["lyon hill"]
+  s.email       = ["hal@pagodabox.com"]
+  s.homepage    = "http://www.pagodabox.com/"
+  s.summary     = %q{Terminal client for interacting with the pagodabox}
+  s.description = %q{Terminal client for interacting with the pagodabox. This client does not contain full api functionality, just functionality that will enhance the workflow experience.}
+
+  s.rubyforge_project = "pagoda"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "webmock"
+
+  s.add_dependency "crack"
+  s.add_dependency "iniparse"
+  s.add_dependency "json_pure"
+  s.add_dependency "rest-client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/base.rb

@@ -0,0 +1,21 @@
+require 'webmock/rspec'
+
+require 'pagoda/command'
+require 'pagoda/commands/base'
+
+Dir["#{File.dirname(__FILE__)}/../lib/pagoda/commands/*"].each { |c| require c }
+
+include WebMock::API
+
+def stub_api_request(method, path)
+  stub_request(method, "http://www.pagodabox.com#{path}")
+end
+
+def prepare_command(klass)
+  command = klass.new(['--app', 'myapp'])
+  command.stub!(:args).and_return([])
+  command.stub!(:display)
+  command.stub!(:pagoda).and_return(mock('pagoda client', :host => 'pagoda.com'))
+  command.stub!(:extract_app).and_return('myapp')
+  command
+end

data/spec/client_spec.rb

@@ -0,0 +1,255 @@
+require "#{File.dirname(__FILE__)}/base"
+require "#{File.dirname(__FILE__)}/../lib/pagoda/client"
+
+describe Pagoda::Client do
+  
+  before do
+    @client   = Pagoda::Client.new(nil, nil)
+  end
+  
+  describe "app" do
+    
+    # errors come back like this:
+    # <?xml version="1.0" encoding="UTF-8"?>
+    # <errors>
+    #  <error>Username can't be blank</error>
+    #  <error>Email can't be blank</error>
+    #  <error>Password can't be blank</error>
+    # </errors>
+    
+    it "should display information" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <app>
+          <name>testapp</name>
+          <git-url>git@github.com:tylerflint/pagoda-pilot.git</git-url>
+          <owner>
+            <username>owner1</username>
+            <email>owner1@test.com</email>
+          </owner>
+          <collaborators type="array">
+            <collaborator>
+              <username>guy1</username>
+              <email>guy1@test.com</email>
+            </collaborator>
+            <collaborator>
+              <username>guy2</username>
+              <email>guy2@test.com</email>
+            </collaborator>
+          </collaborators>
+          <transactions type="array">
+            <transaction>
+              <id>1</id>
+              <name>app.init</name>
+              <description>Deploying app to the Pagoda grid</description>
+              <state>started</state>
+              <status></status>
+            </transaction>
+          </transactions>
+        </app>
+      }
+      stub_api_request(:get, "/apps/testapp.xml").to_return(:body => stub)
+      @client.app_info('testapp').should == {
+        :name           => 'testapp',
+        :git_url        => 'git@github.com:tylerflint/pagoda-pilot.git',
+        :owner          => {
+          :username     => 'owner1',
+          :email        => 'owner1@test.com'
+        },
+        :collaborators => [
+          {:username   => 'guy1', :email => 'guy1@test.com'},
+          {:username   => 'guy2', :email => 'guy2@test.com'}
+        ],
+        :transactions => [
+          {:id => '1', :name => 'app.init', :description => 'Deploying app to the Pagoda grid', :state => 'started', :status => nil}
+        ]
+      }
+    end
+    
+    it "lists incomplete transactions" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transactions type="array">
+          <transaction>
+            <id>1</id>
+            <name>app.increment</name>
+            <description>spawn new instance of app</description>
+            <state>started</state>
+            <status></status>
+          </transaction>
+          <transaction>
+            <id>2</id>
+            <name>app.deploy</name>
+            <description>deploy code</description>
+            <state>ready</state>
+            <status></status>
+          </transaction>
+        </transactions>
+      }
+      stub_api_request(:get, "/apps/testapp/transactions.xml").to_return(:body => stub)
+      @client.transaction_list('testapp').should == [
+        {:id => '1', :name => 'app.increment', :description => 'spawn new instance of app', :state => 'started', :status => nil},
+        {:id => '2', :name => 'app.deploy', :description => 'deploy code', :state => 'ready', :status => nil}
+      ]
+    end
+    
+    it "lists details of a transaction" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transaction>
+          <id>1</id>
+          <name>app.increment</name>
+          <description>spawn new instance of app</description>
+          <state>started</state>
+          <status></status>
+        </transaction>
+      }
+      stub_api_request(:get, "/apps/testapp/transactions/123.xml").to_return(:body => stub)
+      @client.transaction_status('testapp', '123').should == {:id => '1', :name => 'app.increment', :description => 'spawn new instance of app', :state => 'started', :status => nil}
+    end
+    
+    it "deploys" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transaction>
+          <id>1</id>
+          <name>app.deploy</name>
+          <description>deploy new code</description>
+          <state>started</state>
+          <status></status>
+        </transaction>
+      }
+      stub_api_request(:put, "/apps/testapp/deploy.xml").to_return(:body => stub)
+      @client.deploy('testapp').should == {:id => '1', :name => 'app.deploy', :description => 'deploy new code', :state => 'started', :status => nil}      
+    end
+    
+    it "rewinds deploy list" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transaction>
+          <id>1</id>
+          <name>app.traverse</name>
+          <description>traverse the code</description>
+          <state>started</state>
+          <status></status>
+        </transaction>
+      }
+      stub_api_request(:put, "/apps/testapp/rewind.xml").to_return(:body => stub)
+      @client.rewind('testapp', 1).should == {:id => '1', :name => 'app.traverse', :description => 'traverse the code', :state => 'started', :status => nil}
+    end
+    
+    it "fast-forwards deploy list" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transaction>
+          <id>1</id>
+          <name>app.traverse</name>
+          <description>traverse the code</description>
+          <state>started</state>
+          <status></status>
+        </transaction>
+      }
+      stub_api_request(:put, "/apps/testapp/fast-forward.xml").to_return(:body => stub)
+      @client.fast_forward('testapp', 1).should == {:id => '1', :name => 'app.traverse', :description => 'traverse the code', :state => 'started', :status => nil}
+    end
+
+    it "scales up" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transaction>
+          <id>1</id>
+          <name>app.scaleup</name>
+          <description>scaling app</description>
+          <state>started</state>
+          <status></status>
+        </transaction>
+      }
+      stub_api_request(:put, "/apps/testapp/scale-up.xml").to_return(:body => stub)
+      @client.scale_up('testapp', 1).should == {:id => '1', :name => 'app.scaleup', :description => 'scaling app', :state => 'started', :status => nil}
+    end
+    
+    it "scales down" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <transaction>
+          <id>1</id>
+          <name>app.scaledown</name>
+          <description>scaling app</description>
+          <state>started</state>
+          <status></status>
+        </transaction>
+      }
+      stub_api_request(:put, "/apps/testapp/scale-down.xml").to_return(:body => stub)
+      @client.scale_down('testapp', 1).should == {:id => '1', :name => 'app.scaledown', :description => 'scaling app', :state => 'started', :status => nil}
+    end
+    
+  end
+  
+  describe "user" do
+    
+    it "should list all active apps" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <apps type="array">
+          <app>
+            <id>1</id>
+            <name>burt</name>
+            <git-url>git@github.com:tylerflint/pagoda-pilot.git</git-url>
+          </app>
+          <app>
+            <id>2</id>
+            <name>ernie</name>
+            <git-url>git@github.com:tylerflint/pagoda-pilot.git</git-url>
+          </app>
+        </apps>
+      }
+      stub_api_request(:get, "/apps.xml").to_return(:body => stub)
+      @client.app_list.should == [{:id => '1', :name => 'burt', :git_url => 'git@github.com:tylerflint/pagoda-pilot.git'}, {:id => '2', :name => 'ernie', :git_url => 'git@github.com:tylerflint/pagoda-pilot.git'}]
+    end
+    
+    it "should create a new app" do
+      stub = %{
+        <?xml version='1.0' encoding='UTF-8'?>
+        <app>
+          <name>testapp</name>
+           <git-url>git@github.com:tylerflint/pagoda-pilot.git</git-url>
+           <owner>
+             <username>tylerflint</username>
+             <email>tylerflint@gmail.com</email>
+           </owner>
+           <collaborators>
+           </collaborators>
+           <transactions type="array">
+             <transaction>
+               <id>1</id>
+               <name>app.init</name>
+               <description>Deploying app to the Pagoda grid</description>
+               <state>started</state>
+               <status></status>
+             </transaction>
+           </transactions>
+        </app>
+      }
+      stub_api_request(:post, '/apps.xml').with(:body => "app[name]=testapp&app[git_url]=git%40github.com%3Atylerflint%2Fpagoda-pilot.git").to_return(:body => stub)
+      @client.app_create('testapp', 'git@github.com:tylerflint/pagoda-pilot.git').should == {
+        :name => 'testapp',
+        :git_url => 'git@github.com:tylerflint/pagoda-pilot.git',
+        :owner => {
+          :username => 'tylerflint',
+          :email => 'tylerflint@gmail.com'
+        },
+        :collaborators => [],
+        :transactions => [
+          {:id => '1', :name => 'app.init', :description => 'Deploying app to the Pagoda grid', :state => 'started', :status => nil}
+        ]
+      }
+    end
+    
+    it "should destroy an active app" do
+      stub_api_request(:delete, '/apps/testapp.xml')
+      @client.app_destroy('testapp')
+    end
+    
+  end
+  
+end

data/spec/command_spec.rb

@@ -0,0 +1,26 @@
+
+describe Pagoda::Command do
+  
+  it "extracts error messages from response when available in XML" do
+    Pagoda::Command.extract_error('<errors><error>Invalid app name</error></errors>').should == ' !   Invalid app name'
+  end
+
+  it "shows Internal Server Error when the response doesn't contain a XML" do
+    Pagoda::Command.extract_error('<h1>HTTP 500</h1>').should == ' !   Internal server error'
+  end
+
+  it "handles a nil body in parse_error_xml" do
+    lambda { Pagoda::Command.parse_error_xml(nil) }.should_not raise_error
+  end
+  
+  it "correctly resolves commands" do
+    class Pagoda::Command::Test; end
+    class Pagoda::Command::Test::Multiple; end
+
+    Pagoda::Command.parse("foo").should == [ Pagoda::Command::App, :foo ]
+    Pagoda::Command.parse("test").should == [ Pagoda::Command::Test, :index ]
+    Pagoda::Command.parse("test:foo").should == [ Pagoda::Command::Test, :foo   ]
+    Pagoda::Command.parse("test:multiple:foo").should == [ Pagoda::Command::Test::Multiple, :foo ]
+  end
+  
+end

data/spec/commands/auth_spec.rb

@@ -0,0 +1,57 @@
+module Pagoda::Command
+  describe Auth do
+    before do
+      @cli = prepare_command(Auth)
+      @sandbox = "#{Dir.tmpdir}/cli_spec_#{Process.pid}"
+      File.open(@sandbox, "w") { |f| f.write "user\npass\n" }
+      @cli.stub!(:credentials_file).and_return(@sandbox)
+      @cli.stub!(:running_on_a_mac?).and_return(false)
+    end
+
+    after do
+      FileUtils.rm_rf(@sandbox)
+    end
+
+    it "reads credentials from the credentials file" do
+      @cli.read_credentials.should == %w(user pass)
+    end
+
+    it "takes the user from the first line and the password from the second line" do
+      @cli.user.should == 'user'
+      @cli.password.should == 'pass'
+    end
+
+    it "asks for credentials when the file doesn't exist" do
+      FileUtils.rm_rf(@sandbox)
+      @cli.should_receive(:ask_for_credentials).and_return([ 'u', 'p'])
+      @cli.should_receive(:save_credentials)
+      @cli.get_credentials.should == [ 'u', 'p' ]
+    end
+
+    it "writes the credentials to a file" do
+      @cli.stub!(:credentials).and_return(['one', 'two'])
+      @cli.should_receive(:set_credentials_permissions)
+      @cli.write_credentials
+      File.read(@sandbox).should == "one\ntwo\n"
+    end
+
+    it "sets ~/.pagoda/credentials to be readable only by the user" do
+      unless RUBY_PLATFORM =~ /mswin32|mingw32/
+        sandbox = "#{Dir.tmpdir}/cli_spec_#{Process.pid}"
+        FileUtils.rm_rf(sandbox)
+        FileUtils.mkdir_p(sandbox)
+        fname = "#{sandbox}/file"
+        system "touch #{fname}"
+        @cli.stub!(:credentials_file).and_return(fname)
+        @cli.set_credentials_permissions
+        File.stat(sandbox).mode.should == 040700
+        File.stat(fname).mode.should == 0100600
+      end
+    end
+
+    it "deletes the credentials file" do
+      FileUtils.should_receive(:rm_f).with(@cli.credentials_file)
+      @cli.delete_credentials
+    end
+  end
+end