shelly 0.1.34 → 0.1.35

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.1.34 / 2012-12-06
+
+* [feature] Support for organizations
+
+* [feature] New cloud can be created with existing organizatino with --organization [-o] option
+
+Usage: ```shelly add --organization=ORGANIZATION_NAME```
+
+* Manage users within organization
+
+All ```shelly user``` commands affected
+
+* [feature] Show organizations with associated clouds
+
 ## 0.1.34 / 2012-11-11
 
 * [feature] Accept DSA keys when logging in or registering

data/lib/shelly.rb

@@ -13,6 +13,7 @@ require "shelly/model"
 
 module Shelly
   autoload :App, "shelly/app"
+  autoload :Organization, "shelly/organization"
   autoload :Cloudfile, "shelly/cloudfile"
   autoload :Client, "shelly/client"
   autoload :StructureValidator, "shelly/structure_validator"

data/lib/shelly/app.rb

@@ -10,7 +10,7 @@ module Shelly
 
     attr_accessor :code_name, :databases, :ruby_version, :environment,
       :git_url, :domains, :web_server_ip, :size, :thin, :redeem_code,
-      :content
+      :content, :organization
 
     def initialize(code_name = nil, content = nil)
       self.code_name = code_name
@@ -43,7 +43,9 @@ module Shelly
     end
 
     def create
-      attributes = {:code_name => code_name, :redeem_code => redeem_code}
+      attributes = {:code_name => code_name,
+                    :redeem_code => redeem_code,
+                    :organization_name => organization}
       response = shelly.create_app(attributes)
       self.git_url = response["git_url"]
       self.domains = response["domains"]
@@ -132,19 +134,6 @@ module Shelly
       "#{File.basename(Dir.pwd)}-#{guessed || 'staging'}".downcase.dasherize
     end
 
-    def collaborations
-      @collaborations ||= Array(shelly.collaborations(code_name)).
-        sort_by { |c| c["email"] }
-    end
-
-    def active_collaborations
-      collaborations.select { |c| c["active"] }
-    end
-
-    def inactive_collaborations
-      collaborations.select { |c| !c["active"] }
-    end
-
     def configs
       @configs ||= shelly.app_configs(code_name)
     end

data/lib/shelly/cli/main.rb

@@ -5,6 +5,7 @@ require "shelly/cli/backup"
 require "shelly/cli/deploy"
 require "shelly/cli/config"
 require "shelly/cli/file"
+require "shelly/cli/organization"
 
 module Shelly
   module CLI
@@ -14,6 +15,7 @@ module Shelly
       register_subcommand(Deploy, "deploy", "deploy <command>", "View deploy logs")
       register_subcommand(Config, "config", "config <command>", "Manage application configuration files")
       register_subcommand(File, "file", "file <command>", "Upload and download files to and from persistent storage")
+      register_subcommand(Organization, "organization", "organization <command>", "View organizations")
 
       check_unknown_options!(:except => :rake)
 
@@ -79,6 +81,8 @@ module Shelly
         :desc => "Server size [large, small]"
       method_option "redeem-code", :type => :string, :aliases => "-r",
         :desc => "Redeem code for free credits"
+      method_option "organization", :type => :string, :aliases => "-o",
+        :desc => "Add cloud to existing organization"
       method_option "skip-requirements-check", :type => :boolean,
         :desc => "Skip Shelly Cloud requirements check"
       desc "add", "Add a new cloud"
@@ -92,6 +96,7 @@ module Shelly
         app.databases = options["databases"] || ask_for_databases
         app.size = options["size"] || "large"
         app.redeem_code = options["redeem-code"]
+        app.organization = options["organization"]
         app.create
 
         if overwrite_remote?(app)
@@ -120,6 +125,12 @@ module Shelly
         say_new_line
         say_error "Fix erros in the below command and type it again to create your cloud" , :with_exit => false
         say_error "shelly add --code-name=#{app.code_name.downcase.dasherize} --databases=#{app.databases.join(',')} --size=#{app.size}"
+      rescue Client::ForbiddenException
+        say_error "You have to be the owner of '#{options[:organization]}' organization to add clouds"
+      rescue Client::NotFoundException => e
+        raise unless e.resource == :organization
+        say_error "Organization '#{options[:organization]}' not found", :with_exit => false
+        say_error "You can list organizations you have access to with `shelly organization list`"
       end
 
       map "status" => :list

data/lib/shelly/cli/organization.rb

@@ -0,0 +1,35 @@
+require "shelly/cli/command"
+
+module Shelly
+  module CLI
+    class Organization < Command
+      namespace :organization
+      include Helpers
+
+      before_hook :logged_in?, :only => [:list]
+
+      desc "list", "Lists organizations"
+      def list
+        user = Shelly::User.new
+        organizations = user.organizations
+        say "You have access to the following organizations and clouds:", :green
+        say_new_line
+        organizations.each do |organization|
+          say organization.name, :green
+          if organization.apps.present?
+            apps_table = organization.apps.map do |app|
+              state = app.state
+              msg = if state == "deploy_failed" || state == "configuration_failed"
+                " (deployment log: `shelly deploys show last -c #{app["code_name"]}`)"
+              end
+              [app.to_s, "|  #{state.humanize}#{msg}"]
+            end
+            print_table(apps_table, :ident => 2, :colwidth => 35)
+          else
+            print_wrapped "No clouds", :ident => 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shelly/cli/user.rb

@@ -1,4 +1,5 @@
 require "shelly/cli/command"
+require "shelly/cli/organization"
 
 module Shelly
   module CLI
@@ -7,46 +8,93 @@ module Shelly
       include Helpers
 
       before_hook :logged_in?, :only => [:list, :add, :delete]
-      class_option :cloud, :type => :string, :aliases => "-c", :desc => "Specify cloud"
 
-      desc "list", "List users with access to clouds defined in Cloudfile"
+      desc "list", "List users with access to organizations"
       def list
-        app = multiple_clouds(options[:cloud], "user list")
-        say "Cloud #{app}:"
-        app.active_collaborations.each { |c| say "  #{c["email"]}" }
-        app.inactive_collaborations.each { |c|
-          say "  #{c["email"]} (invited)" }
+        user = Shelly::User.new
+        organizations = user.organizations
+
+        say "Organizations with users:"
+
+        organizations.each do |organization|
+          say "  #{organization.name}", :green
+          if organization.memberships.present?
+            members_table = organization.owners.map { |owner| [owner["email"], "  | owner"] }
+            members_table += organization.members.map { |member| [member["email"], "  | member"] }
+            members_table += organization.inactive_members.map { |inactive| [inactive["email"] + " (invited)", "  | #{humman_owner(inactive["owner"])}"] }
+            print_table(members_table, :ident => 4, :colwidth => 45)
+            say_new_line
+          end
+        end
       end
 
-      desc "add [EMAIL]", "Add new developer to clouds defined in Cloudfile"
+      method_option :organization, :type => :string, :aliases => "-o", :desc => "Specify organization"
+      desc "add [EMAIL]", "Add new developer to organization"
       def add(email = nil)
-        user = Shelly::User.new
-        app = multiple_clouds(options[:cloud], "user add")
+        organization = organization_present?(options[:organization], "user add [EMAIL]")
+
         user_email = email || ask_for_email({:guess_email => false})
-        user.send_invitation(app.to_s, user_email)
-        say "Sending invitation to #{user_email} to work on #{app}", :green
+        owner = yes?("Should this user have owner privileges? (yes/no)")
+        organization.send_invitation(user_email, owner)
+
+        say "Sending invitation to #{user_email} to work on #{organization} organization", :green
+      rescue Client::ForbiddenException
+        say_error "You have to be organization's owner to add new members"
+      rescue Client::NotFoundException => e
+        raise unless e.resource == :organization
+        say_error "Organization '#{options[:organization]}' not found", :with_exit => false
+        say_error "You can list organizations you have access to with `shelly organization list`"
       rescue Client::ValidationException => e
-        if e.errors.include?(["email", "#{email} has already been taken"])
-          say_error "User #{email} is already in the cloud #{app}", :with_exit => false
+        if e.errors.include?(["email", "#{email} has been already taken"])
+          say_error "User #{email} is already in the organization #{organization}"
         else
           e.each_error { |error| say_error error, :with_exit => false }
           exit 1
         end
       end
 
-      desc "delete [EMAIL]", "Remove developer from clouds defined in Cloudfile"
+      method_option :organization, :type => :string, :aliases => "-o", :desc => "Specify organization"
+      desc "delete [EMAIL]", "Remove developer from organization"
       def delete(email = nil)
-        user = Shelly::User.new
-        app = multiple_clouds(options[:cloud], "user delete")
+        organization = organization_present?(options[:organization], "user delete [EMAIL]")
+
         user_email = email || ask_for_email({:guess_email => false})
-        user.delete_collaboration(app.to_s, user_email)
-        say "User #{user_email} deleted from cloud #{app}"
+        organization.delete_member(user_email)
+
+        say "User #{user_email} deleted from organization #{organization}"
+      rescue Client::ForbiddenException
+        say_error "You have to be organization's owner to remove members"
       rescue Client::ConflictException => e
         say_error e[:message]
       rescue Client::NotFoundException => e
-        raise unless e.resource == :user
-        say_error "User '#{user_email}' not found", :with_exit => false
-        say_error "You can list users with `shelly user list`"
+        if e.resource == :user
+          say_error "User '#{user_email}' not found", :with_exit => false
+          say_error "You can list users with `shelly user list`"
+        elsif e.resource == :organization
+          say_error "Organization '#{options[:organization]}' not found", :with_exit => false
+          say_error "You can list organizations you have access to with `shelly organization list`"
+        else
+          raise
+        end
+      end
+
+      no_tasks do
+        def humman_owner(owner)
+          owner ? "owner" : "member"
+        end
+
+        def organization_present?(name, action)
+          unless name
+            say_error "You have to specify organization", :with_exit => false
+            say "Select organization using `shelly #{action} --organization ORGANIZATION_NAME`"
+            Shelly::CLI::Organization.new.list
+            exit 1
+          else
+            Shelly::Organization.new("name" => name).tap do |org|
+              org.members
+            end
+          end
+        end
       end
     end
   end

data/lib/shelly/client.rb

@@ -19,6 +19,7 @@ module Shelly
     end
 
     class UnauthorizedException < APIException; end
+    class ForbiddenException < APIException; end
     class ConflictException < APIException; end
     class GemVersionException < APIException; end
     class GatewayTimeoutException < APIException; end
@@ -87,16 +88,17 @@ module Shelly
       delete("/apps/#{cloud}/configs/#{CGI.escape(path)}")
     end
 
-    def send_invitation(cloud, email)
-      post("/apps/#{cloud}/collaborations", :email => email)
+    def send_invitation(name, email, owner = false)
+      post("/organizations/#{name}/memberships", :email => email, :owner => owner)
     end
 
-    def delete_collaboration(cloud, email)
-      delete("/apps/#{cloud}/collaborations/#{email}")
+    def delete_member(name, email)
+      delete("/organizations/#{name}/memberships/#{email}")
     end
 
     def create_app(attributes)
-      post("/apps", :app => attributes)
+      organization = attributes.delete(:organization_name)
+      post("/apps", :app => attributes, :organization_name => organization)
     end
 
     def delete_app(code_name)
@@ -127,6 +129,14 @@ module Shelly
       get("/apps/#{code_name}")
     end
 
+    def organizations
+      get("/organizations")
+    end
+
+    def organization(name)
+      get("/organizations/#{name}")
+    end
+
     def statistics(code_name)
       get("/apps/#{code_name}/statistics")
     end
@@ -167,8 +177,8 @@ module Shelly
       post("/apps/#{code_name}/database_backups", :kind => kind)
     end
 
-    def collaborations(cloud)
-      get("/apps/#{cloud}/collaborations")
+    def members(name)
+      get("/organizations/#{name}/memberships")
     end
 
     def redeploy(cloud)
@@ -244,6 +254,7 @@ module Shelly
       if (400..599).include?(code)
         exception_class = case response.code
         when 401; UnauthorizedException
+        when 403; ForbiddenException
         when 404; NotFoundException
         when 409; ConflictException
         when 412; GemVersionException

data/lib/shelly/organization.rb

@@ -0,0 +1,45 @@
+module Shelly
+  class Organization < Model
+    attr_reader :name, :app_code_names
+
+    def initialize(attributes = {})
+      @name           = attributes["name"]
+      @app_code_names = attributes["app_code_names"]
+    end
+
+    def apps
+      app_code_names.map do |code_name|
+        Shelly::App.new(code_name)
+      end
+    end
+
+    def memberships
+      @members ||= Array(shelly.members(name)).
+        sort_by { |c| c["email"] }
+    end
+
+    def owners
+      memberships.select { |c| c["owner"] } - inactive_members
+    end
+
+    def members
+      memberships.select { |c| !c["owner"] } - inactive_members
+    end
+
+    def inactive_members
+      memberships.select { |c| !c["active"] }
+    end
+
+    def send_invitation(email, owner)
+      shelly.send_invitation(name, email, owner)
+    end
+
+    def delete_member(email)
+      shelly.delete_member(name, email)
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/shelly/user.rb

@@ -1,3 +1,5 @@
+require 'shelly/organization'
+
 module Shelly
   class User < Model
     attr_accessor :email, :password
@@ -11,6 +13,12 @@ module Shelly
       shelly.apps
     end
 
+    def organizations
+      shelly.organizations.map do |attributes|
+        Shelly::Organization.new(attributes)
+      end
+    end
+
     def register
       ssh_key = File.read(ssh_key_path) if ssh_key_exists?
       shelly.register_user(email, password, ssh_key)
@@ -29,14 +37,6 @@ module Shelly
       shelly.token["token"]
     end
 
-    def send_invitation(cloud, email)
-      shelly.send_invitation(cloud, email)
-    end
-
-    def delete_collaboration(cloud, email)
-      shelly.delete_collaboration(cloud, email)
-    end
-
     def load_credentials
       return unless credentials_exists?
       @email, @password = File.read(credentials_path).split("\n")

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.1.34"
+  VERSION = "0.1.35"
 end

data/spec/shelly/app_spec.rb

@@ -47,13 +47,6 @@ describe Shelly::App do
     end
   end
 
-  describe "#collaborations" do
-    it "should fetch app's users" do
-      @client.should_receive(:collaborations).with("foo-staging")
-      @app.collaborations
-    end
-  end
-
   describe "#add_git_remote" do
     before do
       @app.stub(:git_url).and_return("git@git.shellycloud.com:foo-staging.git")
@@ -283,7 +276,8 @@ describe Shelly::App do
       @app.redeem_code = "foo123"
       attributes = {
         :code_name => "fooo",
-        :redeem_code => "foo123"
+        :redeem_code => "foo123",
+        :organization_name => nil
       }
       @client.should_receive(:create_app).with(attributes).and_return("git_url" => "git@git.shellycloud.com:fooo.git",
         "domains" => %w(fooo.shellyapp.com))

data/spec/shelly/cli/main_spec.rb

@@ -27,29 +27,30 @@ describe Shelly::CLI::Main do
     it "should display available commands" do
       out = IO.popen("bin/shelly --debug").read.strip
       out.should include("Tasks:")
-      out.should include("shelly add               # Add a new cloud")
-      out.should include("shelly backup <command>  # Manage database backups")
-      out.should include("shelly check             # Check if application fulfills Shelly Cloud requirements")
-      out.should include("shelly config <command>  # Manage application configuration files")
-      out.should include("shelly console           # Open application console")
-      out.should include("shelly dbconsole         # Run rails dbconsole")
-      out.should include("shelly delete            # Delete the cloud")
-      out.should include("shelly deploy <command>  # View deploy logs")
-      out.should include("shelly file <command>    # Upload and download files to and from persistent storage")
-      out.should include("shelly help [TASK]       # Describe available tasks or one specific task")
-      out.should include("shelly info              # Show basic information about cloud")
-      out.should include("shelly list              # List available clouds")
-      out.should include("shelly login [EMAIL]     # Log into Shelly Cloud")
-      out.should include("shelly logout            # Logout from Shelly Cloud")
-      out.should include("shelly logs              # Show latest application logs")
-      out.should include("shelly open              # Open application page in browser")
-      out.should include("shelly rake TASK         # Run rake task")
-      out.should include("shelly redeploy          # Redeploy application")
-      out.should include("shelly register [EMAIL]  # Register new account")
-      out.should include("shelly setup             # Set up git remotes for deployment on Shelly Cloud")
-      out.should include("shelly start             # Start the cloud")
-      out.should include("shelly stop              # Shutdown the cloud")
-      out.should include("shelly user <command>    # Manage collaborators")
+      out.should include("shelly add                     # Add a new cloud")
+      out.should include("shelly backup <command>        # Manage database backups")
+      out.should include("shelly check                   # Check if application fulfills Shelly Cloud requirements")
+      out.should include("shelly config <command>        # Manage application configuration files")
+      out.should include("shelly console                 # Open application console")
+      out.should include("shelly dbconsole               # Run rails dbconsole")
+      out.should include("shelly delete                  # Delete the cloud")
+      out.should include("shelly deploy <command>        # View deploy logs")
+      out.should include("shelly file <command>          # Upload and download files to and from persistent storage")
+      out.should include("shelly help [TASK]             # Describe available tasks or one specific task")
+      out.should include("shelly info                    # Show basic information about cloud")
+      out.should include("shelly list                    # List available clouds")
+      out.should include("shelly login [EMAIL]           # Log into Shelly Cloud")
+      out.should include("shelly logout                  # Logout from Shelly Cloud")
+      out.should include("shelly logs                    # Show latest application logs")
+      out.should include("shelly open                    # Open application page in browser")
+      out.should include("shelly organization <command>  # View organizations")
+      out.should include("shelly rake TASK               # Run rake task")
+      out.should include("shelly redeploy                # Redeploy application")
+      out.should include("shelly register [EMAIL]        # Register new account")
+      out.should include("shelly setup                   # Set up git remotes for deployment on Shelly Cloud")
+      out.should include("shelly start                   # Start the cloud")
+      out.should include("shelly stop                    # Shutdown the cloud")
+      out.should include("shelly user <command>          # Manage collaborators")
       out.should include("Options")
       out.should include("[--debug]  # Show debug information")
       out.should include("-h, [--help]   # Describe available tasks or one specific task")
@@ -531,18 +532,45 @@ More info at http://git-scm.com/book/en/Git-Basics-Getting-a-Git-Repository\e[0m
         invoke(@main, :add)
       end
     end
+
+    it "should show forbidden exception" do
+      @main.options = {:organization => "foo"}
+      exception = Shelly::Client::ForbiddenException.new
+      @app.should_receive(:create).and_raise(exception)
+      $stdout.should_receive(:puts).with(red "You have to be the owner of 'foo' organization to add clouds")
+
+      expect do
+        fake_stdin(["foooo", "none"]) do
+          invoke(@main, :add)
+        end
+      end.to raise_error(SystemExit)
+    end
+
+    it "should show that organization was not found" do
+      @main.options = {:organization => "foo"}
+      response = {"resource" => "organization"}
+      exception = Shelly::Client::NotFoundException.new(response)
+      @app.should_receive(:create).and_raise(exception)
+      $stdout.should_receive(:puts).with(red "Organization 'foo' not found")
+      $stdout.should_receive(:puts).with(red "You can list organizations you have access to with `shelly organization list`")
+
+      expect do
+        fake_stdin(["foooo", "none"]) do
+          invoke(@main, :add)
+        end
+      end.to raise_error(SystemExit)
+    end
+
   end
 
   describe "#list" do
     before do
-      @user = Shelly::User.new
       @client.stub(:token).and_return("abc")
       @client.stub(:apps).and_return([
         {"code_name" => "abc", "state" => "running"},
         {"code_name" => "fooo", "state" => "deploy_failed"},
         {"code_name" => "bar", "state" => "configuration_failed"}
       ])
-      Shelly::User.stub(:new).and_return(@user)
     end
 
     it "should ensure user has logged in" do