shelly 0.2.28 → 0.3.0

data/lib/shelly/client/configs.rb

@@ -0,0 +1,21 @@
+class Shelly::Client
+  def app_configs(cloud)
+    get("/apps/#{cloud}/configs")
+  end
+
+  def app_config(cloud, path)
+    get("/apps/#{cloud}/configs/#{CGI.escape(path)}")
+  end
+
+  def app_create_config(cloud, path, content)
+    post("/apps/#{cloud}/configs", :config => {:path => path, :content => content})
+  end
+
+  def app_update_config(cloud, path, content)
+    put("/apps/#{cloud}/configs/#{CGI.escape(path)}", :config => {:content => content})
+  end
+
+  def app_delete_config(cloud, path)
+    delete("/apps/#{cloud}/configs/#{CGI.escape(path)}")
+  end
+end

data/lib/shelly/client/database_backups.rb

@@ -0,0 +1,21 @@
+class Shelly::Client
+  def database_backups(code_name)
+    get("/apps/#{code_name}/database_backups")
+  end
+
+  def database_backup(code_name, handler)
+    get("/apps/#{code_name}/database_backups/#{handler}")
+  end
+
+  def restore_backup(code_name, filename)
+    put("/apps/#{code_name}/database_backups/#{filename}/restore")
+  end
+
+  def request_backup(code_name, kind = nil)
+    post("/apps/#{code_name}/database_backups", :kind => kind)
+  end
+
+  def download_backup_url(code_name, filename)
+    get("/apps/#{code_name}/database_backups/#{filename}/download_url")["url"]
+  end
+end

data/lib/shelly/client/deployment_logs.rb

@@ -0,0 +1,9 @@
+class Shelly::Client
+  def deploy_logs(cloud)
+    get("/apps/#{cloud}/deployment_logs")
+  end
+
+  def deploy_log(cloud, log)
+    get("/apps/#{cloud}/deployment_logs/#{log}")
+  end
+end

data/lib/shelly/client/deploys.rb

@@ -0,0 +1,9 @@
+class Shelly::Client
+  def redeploy(cloud)
+    post("/apps/#{cloud}/deploys")
+  end
+
+  def deployment(cloud, deployment_id)
+    get("/apps/#{cloud}/deploys/#{deployment_id}")
+  end
+end

data/lib/shelly/client/errors.rb

@@ -0,0 +1,49 @@
+class Shelly::Client
+  class APIException < Exception
+    attr_reader :status_code, :body, :request_id
+
+    def initialize(body = {}, status_code = nil, request_id = nil)
+      @status_code = status_code
+      @body = body
+      @request_id = request_id
+    end
+
+    def [](key)
+      body[key.to_s]
+    end
+  end
+
+  class UnauthorizedException < APIException; end
+
+  class ForbiddenException < APIException; end
+
+  class ConflictException < APIException; end
+
+  class GemVersionException < APIException; end
+
+  class GatewayTimeoutException < APIException; end
+
+  class LockedException < APIException; end
+
+  class ValidationException < APIException
+    def errors
+      self[:errors]
+    end
+
+    def each_error
+      errors.each do |field, message|
+        yield [field.gsub('_',' ').capitalize, message].join(" ")
+      end
+    end
+  end
+
+  class NotFoundException < APIException
+    def resource
+      self[:resource].to_sym
+    end
+
+    def id
+      self[:id]
+    end
+  end
+end

data/lib/shelly/client/organizations.rb

@@ -0,0 +1,21 @@
+class Shelly::Client
+  def organizations
+    get("/organizations")
+  end
+
+  def organization(name)
+    get("/organizations/#{name}")
+  end
+
+  def members(name)
+    get("/organizations/#{name}/memberships")
+  end
+
+  def send_invitation(name, email, owner = false)
+    post("/organizations/#{name}/memberships", :email => email, :owner => owner)
+  end
+
+  def delete_member(name, email)
+    delete("/organizations/#{name}/memberships/#{email}")
+  end
+end

data/lib/shelly/client/shellyapp.rb

@@ -0,0 +1,5 @@
+class Shelly::Client
+  def shellyapp_url
+    get("/shellyapp")["url"]
+  end
+end

data/lib/shelly/client/ssh_keys.rb

@@ -0,0 +1,9 @@
+class Shelly::Client
+  def add_ssh_key(ssh_key)
+    post("/ssh_keys", :ssh_key => ssh_key)
+  end
+
+  def delete_ssh_key(ssh_key)
+    delete("/ssh_keys", :ssh_key => ssh_key)
+  end
+end

data/lib/shelly/client/users.rb

@@ -0,0 +1,5 @@
+class Shelly::Client
+  def register_user(email, password, ssh_key)
+    post("/users", :user => {:email => email, :password => password, :ssh_key => ssh_key})
+  end
+end

data/lib/shelly/helpers.rb

@@ -74,8 +74,7 @@ More info at http://git-scm.com/book/en/Git-Basics-Getting-a-Git-Repository}
 
     def logged_in?
       user = Shelly::User.new
-      user.token
-      user
+      user.authorize!
     rescue Client::UnauthorizedException
       say_error "You are not logged in. To log in use: `shelly login`"
     end

data/lib/shelly/model.rb

@@ -1,13 +1,11 @@
 module Shelly
   class Model
     def current_user
-      @user = User.new
-      @user.load_credentials
-      @user
+      @current_user ||= User.new
     end
 
     def shelly
-      @shelly ||= Client.new(current_user.email, current_user.password)
+      @shelly ||= Client.new
     end
   end
 end

data/lib/shelly/user.rb

@@ -2,13 +2,6 @@ require 'shelly/organization'
 
 module Shelly
   class User < Model
-    attr_accessor :email, :password
-
-    def initialize(email = nil, password = nil)
-      @email = email
-      @password = password
-    end
-
     def apps
       shelly.apps.map do |attributes|
         Shelly::App.from_attributes(attributes)
@@ -21,33 +14,34 @@ module Shelly
       end
     end
 
-    def register
+    def email
+      shelly.user_email
+    end
+
+    def register(email, password)
       ssh_key = File.read(ssh_key_path) if ssh_key_exists?
       shelly.register_user(email, password, ssh_key)
-      save_credentials
     end
 
-    def login
-      client = Client.new(email, password)
-      # test if credentials are valid
-      # if not RestClient::Unauthorized will be raised
-      client.token
-      save_credentials
+    def authorize!
+      if credentials_exists?
+        email, password = File.read(credentials_path).split("\n")
+        shelly.authorize_with_email_and_password(email, password)
+        delete_credentials
+      else
+        shelly.authorize!
+      end
     end
 
-    def token
-      shelly.token["token"]
-    end
+    def login(email, password)
+      delete_credentials # clean up previous auth storage
 
-    def load_credentials
-      return unless credentials_exists?
-      @email, @password = File.read(credentials_path).split("\n")
+      shelly.authorize_with_email_and_password(email, password)
     end
 
-    def save_credentials
-      FileUtils.mkdir_p(config_dir) unless credentials_exists?
-      File.open(credentials_path, 'w') { |file| file << "#{email}\n#{password}" }
-      set_credentials_permissions
+    def logout
+      delete_credentials # clean up previous auth storage
+      shelly.forget_authorization
     end
 
     def delete_credentials
@@ -55,8 +49,8 @@ module Shelly
     end
 
     def delete_ssh_key
-      shelly.logout(File.read(dsa_key)) if File.exists?(dsa_key)
-      shelly.logout(File.read(rsa_key)) if File.exists?(rsa_key)
+      shelly.delete_ssh_key(File.read(dsa_key)) if File.exists?(dsa_key)
+      shelly.delete_ssh_key(File.read(rsa_key)) if File.exists?(rsa_key)
     end
 
     def ssh_key_exists?
@@ -97,11 +91,6 @@ module Shelly
       def credentials_exists?
         File.exists?(credentials_path)
       end
-
-      def set_credentials_permissions
-        FileUtils.chmod(0700, config_dir)
-        FileUtils.chmod(0600, credentials_path)
-      end
     end
 end
 

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.2.28"
+  VERSION = "0.3.0"
 end

data/shelly.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "json"
   s.add_runtime_dependency "progressbar"
   s.add_runtime_dependency "launchy"
+  s.add_runtime_dependency "netrc"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/shelly/cli/backup_spec.rb

@@ -8,7 +8,7 @@ describe Shelly::CLI::Backup do
     @backup = Shelly::CLI::Backup.new
     Shelly::CLI::Backup.stub(:new).and_return(@backup)
     @client = mock
-    @client.stub(:token).and_return("abc")
+    @client.stub(:authorize!)
     Shelly::Client.stub(:new).and_return(@client)
     FileUtils.mkdir_p("/projects/foo")
     Dir.chdir("/projects/foo")

data/spec/shelly/cli/config_spec.rb

@@ -13,7 +13,7 @@ describe Shelly::CLI::Config do
     $stdout.stub(:print)
     FileUtils.mkdir_p("/projects/foo")
     Dir.chdir("/projects/foo")
-    @client.stub(:token).and_return("abc")
+    @client.stub(:authorize!)
     File.open("Cloudfile", 'w') {|f| f.write("foo-production:\n") }
     FileUtils.mkdir_p("/tmp")
     Dir.stub(:tmpdir).and_return("/tmp")

data/spec/shelly/cli/deploy_spec.rb

@@ -18,7 +18,7 @@ describe Shelly::CLI::Deploy do
       FileUtils.mkdir_p("/projects/foo")
       Dir.chdir("/projects/foo")
       File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
-      @client.stub(:token).and_return("abc")
+      @client.stub(:authorize!)
     end
 
     it "should ensure user has logged in" do
@@ -55,7 +55,7 @@ describe Shelly::CLI::Deploy do
       FileUtils.mkdir_p("/projects/foo")
       Dir.chdir("/projects/foo")
       File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\n") }
-      @client.stub(:token).and_return("abc")
+      @client.stub(:authorize!)
     end
 
     it "should ensure user has logged in" do

data/spec/shelly/cli/file_spec.rb

@@ -8,7 +8,7 @@ describe Shelly::CLI::File do
     Shelly::CLI::File.stub(:new).and_return(@cli_files)
     @client = mock
     Shelly::Client.stub(:new).and_return(@client)
-    @client.stub(:token).and_return("abc")
+    @client.stub(:authorize!)
     FileUtils.mkdir_p("/projects/foo")
     Dir.chdir("/projects/foo")
     @app = Shelly::App.new("foo-production")

data/spec/shelly/cli/logs_spec.rb

@@ -8,7 +8,7 @@ describe Shelly::CLI::Logs do
     Shelly::CLI::Logs.stub(:new).and_return(@cli_logs)
     @client = mock
     Shelly::Client.stub(:new).and_return(@client)
-    @client.stub(:token).and_return("abc")
+    @client.stub(:authorize!)
     FileUtils.mkdir_p("/projects/foo")
     Dir.chdir("/projects/foo")
     @app = Shelly::App.new("foo-production")

data/spec/shelly/cli/main_spec.rb

@@ -3,17 +3,20 @@ require "spec_helper"
 require "shelly/cli/main"
 
 describe Shelly::CLI::Main do
+  let(:user) { Shelly::User.new }
   before do
+    FileUtils.mkpath(File.expand_path("~"))
     FileUtils.stub(:chmod)
     @main = Shelly::CLI::Main.new
     Shelly::CLI::Main.stub(:new).and_return(@main)
     @client = mock
-    @client.stub(:token).and_return("abc")
+    @client.stub(:authorize!)
     @client.stub(:shellyapp_url).and_return("https://example.com")
     Shelly::Client.stub(:new).and_return(@client)
     Shelly::User.stub(:guess_email).and_return("")
     $stdout.stub(:puts)
     $stdout.stub(:print)
+    Shelly::User.stub(:new => user)
   end
 
   describe "#version" do
@@ -67,13 +70,10 @@ describe Shelly::CLI::Main do
 
   describe "#register" do
     before do
-      @client.stub(:register_user)
       @key_path = File.expand_path("~/.ssh/id_rsa.pub")
-      @user = Shelly::User.new
       FileUtils.mkdir_p("~/.ssh")
       File.open("~/.ssh/id_rsa.pub", "w") { |f| f << "ssh-key AAbbcc" }
-      @client.stub(:ssh_key_available?)
-      Shelly::User.stub(:new).and_return(@user)
+      user.stub(:register).with("better@example.com", "secret") { true }
     end
 
     it "should register user without local SSH Key and show message to create SSH Key" do
@@ -96,22 +96,16 @@ describe Shelly::CLI::Main do
     end
 
     it "should suggest email and use it if user enters blank email" do
+      user.should_receive(:register).with("kate@example.com", "secret")
       Shelly::User.stub(:guess_email).and_return("kate@example.com")
       $stdout.should_receive(:print).with("Email (kate@example.com - default): ")
-      @client.should_receive(:register_user).with("kate@example.com", "secret", "ssh-key AAbbcc")
       fake_stdin(["", "secret", "secret", "yes"]) do
         invoke(@main, :register)
       end
     end
 
-    it "should use email provided by user" do
-      @client.should_receive(:register_user).with("better@example.com", "secret", "ssh-key AAbbcc")
-      fake_stdin(["better@example.com", "secret", "secret", "yes"]) do
-        invoke(@main, :register)
-      end
-    end
-
     it "should not ask about email if it's provided as argument" do
+      user.should_receive(:register).with("kate@example.com", "secret")
       $stdout.should_receive(:puts).with("Registering with email: kate@example.com")
       fake_stdin(["secret", "secret", "yes"]) do
         invoke(@main, :register, "kate@example.com")
@@ -135,7 +129,7 @@ describe Shelly::CLI::Main do
         FileUtils.mkdir_p("~/.ssh")
         File.open(@key_path, "w") { |f| f << "key" }
         $stdout.should_receive(:puts).with("Uploading your public SSH key from #{@key_path}")
-        fake_stdin(["kate@example.com", "secret", "secret", "yes"]) do
+        fake_stdin(["better@example.com", "secret", "secret", "yes"]) do
           invoke(@main, :register)
         end
       end
@@ -143,10 +137,10 @@ describe Shelly::CLI::Main do
 
     context "public SSH key doesn't exist" do
       it "should register user without the public SSH key" do
-        @user.stub(:ssh_key_registered?)
+        user.stub(:ssh_key_registered?)
         FileUtils.rm_rf(@key_path)
         $stdout.should_not_receive(:puts).with("Uploading your public SSH key from #{@key_path}")
-        fake_stdin(["kate@example.com", "secret", "secret", "yes"]) do
+        fake_stdin(["better@example.com", "secret", "secret", "yes"]) do
           invoke(@main, :register)
         end
       end
@@ -154,10 +148,9 @@ describe Shelly::CLI::Main do
 
     context "on successful registration" do
       it "should display message about registration and email address confirmation" do
-        @client.stub(:register_user).and_return(true)
         $stdout.should_receive(:puts).with(green "Successfully registered!")
         $stdout.should_receive(:puts).with(green "Check you mailbox for email address confirmation")
-        fake_stdin(["kate@example.com", "pass", "pass", "yes"]) do
+        fake_stdin(["better@example.com", "secret", "secret", "yes"]) do
           invoke(@main, :register)
         end
       end
@@ -167,10 +160,10 @@ describe Shelly::CLI::Main do
       it "should display errors and exit with 1" do
         body = {"message" => "Validation Failed", "errors" => [["email", "has been already taken"]]}
         exception = Shelly::Client::ValidationException.new(body)
-        @client.stub(:register_user).and_raise(exception)
+        user.stub(:register).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mEmail has been already taken\e[0m")
         lambda {
-          fake_stdin(["kate@example.com", "pass", "pass", "yes"]) do
+          fake_stdin(["better@example.com", "secret", "secret", "yes"]) do
             invoke(@main, :register)
           end
         }.should raise_error(SystemExit)
@@ -191,27 +184,22 @@ describe Shelly::CLI::Main do
 
   describe "#login" do
     before do
-      @user = Shelly::User.new
+      user.stub(:upload_ssh_key)
       @key_path = File.expand_path("~/.ssh/id_rsa.pub")
       FileUtils.mkdir_p("~/.ssh")
       File.open("~/.ssh/id_rsa.pub", "w") { |f| f << "ssh-key AAbbcc" }
-      @user.stub(:upload_ssh_key)
-      @client.stub(:token).and_return("abc")
       @client.stub(:apps).and_return([
           {"code_name" => "abc", "state" => "running",
             "state_description" => "running"},
           {"code_name" => "fooo", "state" => "no_code",
             "state_description" => "turned off (no code pushed)"},])
-      Shelly::User.stub(:new).and_return(@user)
     end
 
-    it "should ask about email and password" do
-      fake_stdin(["megan@example.com", "secret"]) do
-        invoke(@main, :login)
+    context "on successful login" do
+      before do
+        user.stub(:login).with("megan@example.com", "secret") { true }
       end
-    end
 
-    context "on successful login" do
       it "should display message about successful login" do
         $stdout.should_receive(:puts).with(green "Login successful")
         fake_stdin(["megan@example.com", "secret"]) do
@@ -227,7 +215,7 @@ describe Shelly::CLI::Main do
       end
 
       it "should upload user's public SSH key" do
-        @user.should_receive(:upload_ssh_key)
+        user.should_receive(:upload_ssh_key)
         $stdout.should_receive(:puts).with("Uploading your public SSH key")
         fake_stdin(["megan@example.com", "secret"]) do
           invoke(@main, :login)
@@ -260,7 +248,7 @@ describe Shelly::CLI::Main do
       it "should exit with 1 and display error message" do
         response = {"message" => "Unauthorized", "url" => "https://admin.winniecloud.com/users/password/new"}
         exception = Shelly::Client::UnauthorizedException.new(response)
-        @client.stub(:token).and_raise(exception)
+        @client.stub(:authorize_with_email_and_password).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mWrong email or password\e[0m")
         $stdout.should_receive(:puts).with("\e[31mYou can reset password by using link:\e[0m")
         $stdout.should_receive(:puts).with("\e[31mhttps://admin.winniecloud.com/users/password/new\e[0m")
@@ -308,7 +296,7 @@ More info at http://git-scm.com/book/en/Git-Basics-Getting-a-Git-Repository\e[0m
     # This spec tests logged_in? hook
     it "should exit with message if user is not logged in" do
       exception = Shelly::Client::UnauthorizedException.new
-      @client.stub(:token).and_raise(exception)
+      @client.stub(:authorize!).and_raise(exception)
       $stdout.should_receive(:puts).with(red "You are not logged in. To log in use: `shelly login`")
       lambda {
         fake_stdin(["", ""]) do
@@ -1209,16 +1197,8 @@ Wait until cloud is in 'turned off' state and try again.")
 
   describe "#logout" do
     before do
-      @user = Shelly::User.new
-      @client.stub(:token).and_return("abc")
-      Shelly::User.stub(:new).and_return(@user)
-      FileUtils.mkdir_p("~/.ssh")
-      FileUtils.mkdir_p("~/.shelly")
-      File.open("Cloudfile", 'w') { |f| f.write("foo-production:\n") }
-      File.open("~/.ssh/id_rsa.pub", "w") { |f| f << "ssh-key AAbbcc" }
-      @key_path = File.expand_path("~/.ssh/id_rsa.pub")
-      File.open("~/.shelly/credentials", "w") { |f| f << "megan@fox.pl\nsecret" }
-      @client.stub(:logout).and_return(true)
+      user.stub(:logout => true)
+      user.stub(:delete_ssh_key => false)
     end
 
     it "should ensure user has logged in" do
@@ -1226,17 +1206,16 @@ Wait until cloud is in 'turned off' state and try again.")
     end
 
     it "should logout from shelly cloud and show message" do
-      $stdout.should_receive(:puts).with("Your public SSH key has been removed from Shelly Cloud")
       $stdout.should_receive(:puts).with("You have been successfully logged out")
+      user.should_receive(:logout)
       invoke(@main, :logout)
-      File.exists?("~/.shelly/credentials").should be_false
     end
 
-    it "should remove only credentiales when local ssh key doesn't exist" do
-      FileUtils.rm_rf(@key_path)
-      $stdout.should_receive(:puts).with("You have been successfully logged out")
+    it "should notify user that ssh key was removed" do
+      user.stub(:delete_ssh_key => true)
+      $stdout.should_receive(:puts).with("Your public SSH key has been removed from Shelly Cloud")
+      user.should_receive(:delete_ssh_key)
       invoke(@main, :logout)
-      File.exists?("~/.shelly/credentials").should be_false
     end
   end