ey_cli 0.1.0

data/lib/ey_cli/commands/create_app.rb

@@ -0,0 +1,76 @@
+module EYCli
+  module Command
+    class CreateApp < Base
+      def initialize
+        @accounts = EYCli::Controller::Accounts.new
+        @apps     = EYCli::Controller::Apps.new
+        @envs     = EYCli::Controller::Environments.new
+      end
+
+      def invoke
+        account = @accounts.fetch_account(options.delete(:account))
+        app = @apps.create(account, Dir.pwd, options)
+        if app
+          @envs.create(app, CreateEnv::EnvParser.new.fill_create_env_options(options)) unless options[:no_env]
+          EYCli.term.say("You can run now 'ey_cli show #{app.name}' to know the status of the application")
+        end
+        app
+      end
+
+      def help
+        <<-EOF
+
+It takes its arguments(name, git repository and application type) from the base directory.
+Usage: ey_cli create_app
+
+Options:
+       --account name             Name of the account to add the application to.
+       --name name                Name of the app.
+       --git uri                  Git repository uri.
+       --type type                Application type, either rack, rails2 or rails3.
+       --env_name name            Name of the environment to create.
+       --framework_env env        Type of the environment (production, staging...).
+       --url url                  Domain name for the app. It accepts comma-separated values.
+       --app_instances number     Number of application instances.
+       --db_instances number      Number of database slaves.
+       --solo                     A single instance for application and database.
+       --stack                    App server stack, either passenger, unicorn or trinidad.
+       --no_env                   Prevent to not create a default environment.
+EOF
+      end
+
+      def options_parser
+        AppParser.new
+      end
+
+      class AppParser
+        require 'slop'
+
+        def parse(args)
+          opts = Slop.parse(args, {:multiple_switches => false}) do
+            on :account, true
+            on :name, true
+            on :git, true
+            on :type, true
+            on :env_name, true
+            on :framework_env, true
+            on :url, true
+            on :app_instances, true, :as => :integer
+            on :db_instances, true, :as => :integer
+            #on :util_instances, true, :as => :integer # FIXME: utils instances are handled differently
+            on :solo, false, :default => false
+            on :stack, true, :matches => /passenger|unicorn|trinidad/
+            on :no_env, false, :default => false
+            on :app_size, true do |size|
+              CreateEnv::EnvParser.check_instance_size(size)
+            end
+            on :db_size, true do |size|
+              CreateEnv::EnvParser.check_instance_size(size)
+            end
+          end
+          opts.to_hash
+        end
+      end
+    end
+  end
+end

data/lib/ey_cli/commands/create_env.rb

@@ -0,0 +1,106 @@
+module EYCli
+  module Command
+    class CreateEnv < Base
+      def initialize
+        @accounts     = EYCli::Controller::Accounts.new
+        @apps         = EYCli::Controller::Apps.new
+        @environments = EYCli::Controller::Environments.new
+      end
+
+      def invoke
+        account = @accounts.fetch_account(options[:account]) if options[:account]
+        app = @apps.fetch_app(account, {:app_name => options[:app]})
+        @environments.create(app, options_parser.fill_create_env_options(options))
+      end
+
+      def help
+        <<-EOF
+
+It takes the information from the current directory. It will guide you if it cannot reach all that information.
+Usage: ey_cli create_env
+
+Options:
+       --app name                 Name of the app to create the environment for.
+       --name name                Name of the environment.
+       --framework_env env        Type of the environment (production, staging...).
+       --url url                  Domain name for the app. It accepts comma-separated values.
+       --app_instances number     Number of application instances.
+       --db_instances number      Number of database slaves.
+       --solo                     A single instance for application and database.
+       --stack                    App server stack, either passenger, unicorn or trinidad.
+EOF
+      end
+
+      def options_parser
+        EnvParser.new
+      end
+
+
+      class EnvParser
+        require 'slop'
+
+        def parse(args)
+          opts = Slop.parse(args, {:multiple_switches => false}) do
+            on :app, true
+            on :name, true
+            on :framework_env, true
+            on :url, true
+            on :app_instances, true, :as => :integer
+            on :db_instances, true, :as => :integer
+            #on :util_instances, true, :as => :integer # FIXME: utils instances are handled differently
+            on :solo, false, :default => false
+            on :stack, true, :matches => /passenger|unicorn|trinidad/
+            on :app_size, true do |size|
+              EnvParser.check_instance_size(size)
+            end
+            on :db_size, true do |size|
+              EnvParser.check_instance_size(size)
+            end
+          end
+          opts.to_hash
+        end
+
+        def self.check_instance_size(size)
+          sizes_list = [
+            'm1.small', 'm1.large', 'm1.xlarge',
+            'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge',
+            'c1.medium', 'c1.xlarge'
+          ]
+          unless sizes_list.include?(size)
+            EYCli.term.say("Unknown instance size: #{size}. Please, use one of the following list:")
+            EYCli.term.say(sizes_list.inspect)
+            exit 1
+          end
+        end
+
+        def fill_create_env_options(options)
+          opts = {:name => options[:name], :framework_env => options[:framework_env]}
+          if options[:stack]
+            case options[:stack].to_sym
+            when :passenger then options[:stack] = 'nginx_passenger3'
+            when :unicorn   then options[:stack] = 'nginx_unicorn'
+            when :trinidad  then options[:ruby_version] = 'JRuby'
+            end
+          end
+
+          if options[:app_instances] || options[:db_instances] || options[:solo] ||
+             options[:app_size] || options[:db_size]
+            cluster_conf = options.dup
+            if options[:solo]
+              EYCli.term.say('~> creating solo environment, ignoring instance numbers')
+              cluster_conf[:configuration] = 'single'
+            else
+              cluster_conf[:configuration]    = 'custom'
+            end
+
+            opts[:cluster_configuration] = cluster_conf
+          else
+            opts[:cluster_configuration] = {:configuration => 'cluster'}
+          end
+
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/ey_cli/commands/deploy.rb

@@ -0,0 +1,23 @@
+module EYCli
+  module Command
+    class Deploy < Base
+      def initialize
+        @apps = EYCli::Controller::Apps.new
+        @environments = EYCli::Controller::Environments.new
+      end
+
+      def invoke
+        app = @apps.fetch_app(nil, options)
+        @environments.deploy(app, options)
+      end
+
+      def help
+        <<-EOF
+
+Usage: ey_cli deploy
+Note: takes the application's information from the current directory. It will guide you if it cannot reach that information.
+EOF
+      end
+    end
+  end
+end

data/lib/ey_cli/commands/help.rb

@@ -0,0 +1,65 @@
+module EYCli
+  module Command
+    class Help < Base
+
+      def invoke
+        name = options[:command_name] || 'help'
+        if name == 'commands'
+          print_commands
+        else
+          print_command_help(name)
+        end
+      end
+
+      def print_command_help(name)
+        command = EYCli.command_manager[name]
+        if command_help = (command and command.help)
+          EYCli.term.say(command_help)
+        else
+          EYCli.term.say("help not available for command: '#{name}'")
+        end
+      end
+
+      def print_commands
+        EYCli.term.say("available commands:")
+        command_names = EYCli.command_manager.commands.keys.map {|name| "- #{name}"}.sort
+        EYCli.term.say("\t" + command_names.join("\n\t"))
+      end
+
+      def options_parser
+        HelpParser.new
+      end
+
+      def help
+        <<-EOF
+
+Usage: ey_cli command [args]
+Try `ey_cli help commands' to list the available commands.
+Try `ey_cli help [command]' for more information about a command.
+
+Currently available commands:
+
+  General info
+    accounts                     List the accounts associated to a user.
+    console                      Start an interactive session to use ey_cli.
+    help                         Show commands information.
+
+  Applications
+    apps                         List the applications associated to a user.
+    create_app                   Create a new application. It takes the information from the current directory.
+    show                         Show information and status of an application.
+
+  Environments
+    create_env                   Create a new environment for an application.
+    deploy                       Run a deploy for an application.
+EOF
+      end
+
+      class HelpParser
+        def parse(args)
+          {:command_name => args.shift}
+        end
+      end
+    end
+  end
+end

data/lib/ey_cli/commands/show.rb

@@ -0,0 +1,65 @@
+module EYCli
+  module Command
+    class Show < Base
+      def initialize
+        @apps = EYCli::Controller::Apps.new
+      end
+
+      def invoke
+        app = @apps.fetch_app(nil, options)
+        if app
+          EYCli.term.say info(app)
+          EYCli.term.say status(app)
+        end
+      end
+
+      def info(app)
+        %Q{
+#{app.name}:
+  - Info:
+     + git repository: #{app.git_repository}}
+      end
+
+      def status(app)
+        status = %Q{
+
+  - Status per environment:}
+        app.environments.each do |env|
+          status << %Q{
+     + #{env.name}:
+        - environment: #{env.framework_env}
+        - stack:       #{env.app_server_stack_name}
+        - status:      #{env.instance_status}}
+          status << %Q{
+        - instances:}
+          env.instances.each do |instance|
+            status << %Q{
+           + #{instance.role}:
+              - Amazon ID: #{instance.amazon_id}
+              - status:    #{instance.status}}
+          end
+        end
+        status
+      end
+
+      def help
+        <<-EOF
+
+Show information and status of an application. If a name is not supplied it assumes the current directory as application base.
+Usage: `ey_cli show app_name'
+EOF
+      end
+
+      def options_parser
+        ShowParser.new
+      end
+
+      class ShowParser
+        def parse(args)
+          name = args.empty? ? nil : args.shift.downcase
+          {:app_name => name}
+        end
+      end
+    end
+  end
+end

data/lib/ey_cli/controllers/accounts.rb

@@ -0,0 +1,23 @@
+module EYCli
+  module Controller
+    class Accounts
+      def fetch_account(name = nil)
+        accounts = fetch_accounts
+        if name
+          EYCli::Model::Account.find_by_name(name, accounts)
+        else
+          return accounts.first if accounts.empty? || accounts.size == 1
+
+          name = EYCli.term.choose_resource(accounts,
+                  "I don't know which account you want to use.",
+                  'Please, select an account:')
+          EYCli::Model::Account.find_by_name(name, accounts)
+        end
+      end
+
+      def fetch_accounts
+        EYCli::Model::Account.all.sort_by {|account| account.name}
+      end
+    end
+  end
+end

data/lib/ey_cli/controllers/apps.rb

@@ -0,0 +1,66 @@
+module EYCli
+  module Controller
+    class Apps
+      include EYCli::GitUtils
+
+      def create(account, base = Dir.pwd, options = {})
+        if git_repository?(base) || options[:git]
+          app = EYCli::Model::App.create({
+            :account               => account,
+            'app[name]'            => options[:name] || File.basename(base),
+            'app[app_type_id]'     => options[:type] || fetch_type(base).to_s,
+            'app[repository_uri]'  => options[:git]  || fetch_repository(base)
+          })
+
+          if app.errors?
+            EYCli.term.print_errors(app.errors, "App creation failed:")
+          else
+            EYCli.term.success("App '#{app.name}' created successfully")
+          end
+          app
+        else
+          EYCli.term.error("Not a git repository: #{base}")
+        end
+      end
+
+      def fetch_type(base)
+        if File.exist?(File.join(base, 'config.ru')) && File.exist?(File.join(base, 'config', 'environment.rb'))
+          :rails3
+        elsif File.exist?(File.join(base, 'config', 'environment.rb'))
+          :rails2
+        elsif File.exist?(File.join(base, 'config.ru'))
+          :rack
+        else # Raise unkown application type?
+          :rails3
+        end
+      end
+
+      def fetch_app(account = nil, options = {}, base = Dir.pwd)
+        if account
+          # search for account. Should we really care?
+        else
+          all_apps = fetch_apps
+          return all_apps.first if all_apps.empty? || all_apps.size == 1
+
+          app = if options[:app_name]
+            EYCli::Model::App.find_by_name(options[:app_name], all_apps)
+          elsif git_repository?(base)
+            EYCli::Model::App.find_by_repository_uri(fetch_repository(base), all_apps)
+          end
+
+          unless app
+            choice = EYCli.term.choose_resource(all_apps,
+                                       "I don't know which app you want to use.",
+                                       "Please, select an application:")
+            app = EYCli::Model::App.find_by_name(choice, all_apps)
+          end
+          app
+        end
+      end
+
+      def fetch_apps
+        EYCli::Model::App.all.sort_by {|app| app.name}
+      end
+    end
+  end
+end

data/lib/ey_cli/controllers/environments.rb

@@ -0,0 +1,78 @@
+module EYCli
+  module Controller
+    class Environments
+      def create(app, options = {})
+        framework_env = options[:framework_env] || 'production'
+        env_name      = options[:name] || "#{app.name}_#{framework_env}"
+
+        create_options = {
+          :app                               => app,
+          'environment[name]'                => env_name,
+          'environment[framework_env]'       => framework_env
+        }
+        create_options.merge! fetch_custom_arguments(options)
+
+        create_options.merge! fetch_cluster_options(options[:cluster_configuration])
+        env = EYCli::Model::Environment.create(create_options)
+
+        if env.errors?
+          EYCli.term.print_errors(env.errors, "Environment creation failed:")
+        else
+          EYCli.term.success("Environment '#{env.name}' created successfully")
+        end
+        env
+      end
+
+      def deploy(app, options = {})
+        if !app.environments? || app.environments.empty?
+          EYCli.term.error <<-EOF
+You don't have any environment associated to this application.
+Try running `ey_cli create_env' to create your first environment.
+EOF
+        elsif app.environments.size == 1
+          env = app.environments.first
+        else
+          name = EYCli.term.choose_resource(app.environments,
+                                            "I don't know which environment deploy on.",
+                                            "Please, select and environment")
+          env = EYCli::Model::Environment.find_by_name(name, app.environments)
+        end
+
+        if env
+          deploy = env.deploy(app, options)
+
+          if deploy.errors?
+            EYCli.term.print_errors(deploy.errors, "Application deployment failed:")
+          else
+            EYCli.term.success('Application deployed successfully')
+          end
+        else
+          EYCli.term.say('Nothing deployed')
+        end
+      end
+
+      def fetch_cluster_options(options)
+        return {} unless options
+        cluster = {
+          'cluster_configuration[configuration]' => options[:configuration],
+          'cluster_configuration[ip_id]'         => 'new'
+        }
+        if options[:configuration] == 'custom'
+          cluster['cluster_configuration[app_server_count]'] = options[:app_instances] || 2
+          cluster['cluster_configuration[db_slave_count]']   = options[:db_instances] || 0
+          cluster['cluster_configuration[instance_size]']    = options[:app_size] if options[:app_size]
+          cluster['cluster_configuration[db_instance_size]'] = options[:db_size] if options[:db_size]
+        end
+        cluster
+      end
+
+      def fetch_custom_arguments(options)
+        custom = {}
+        custom['app_deployment[new][domain_name]'] = options[:url] if options[:url]
+        custom['environment[app_server_stack_name]'] = options[:stack] if options[:stack]
+        custom['environment[ruby_version]'] = options[:ruby_version] if options[:ruby_version]
+        custom
+      end
+    end
+  end
+end

data/lib/ey_cli/git_utils.rb

@@ -0,0 +1,12 @@
+module EYCli
+  module GitUtils
+    def git_repository?(base)
+      File.exist?(File.join(base, '.git'))
+    end
+
+    def fetch_repository(base)
+      config = File.join(base, '.git', 'config')
+      `git config -f #{config} --get 'remote.origin.url'`
+    end
+  end
+end

data/lib/ey_cli/models/account.rb

@@ -0,0 +1,6 @@
+module EYCli
+  module Model
+    class Account < Base
+    end
+  end
+end

data/lib/ey_cli/models/app.rb

@@ -0,0 +1,15 @@
+module EYCli
+  module Model
+    class App < Base
+      def self.find_by_repository_uri(repository_uri, collection = all)
+        collection.find {|resource| resource.repository_uri == repository_uri}
+      end
+
+      def self.create_collection_path(hash)
+        account = hash.delete(:account)
+        raise Faraday::Error::ClientError, {:body => MultiJson.encode({:errors => {:account => 'Not found'}})} unless account
+        (account.class.base_path + '/%s/apps') % account.id
+      end
+    end
+  end
+end

data/lib/ey_cli/models/base.rb

@@ -0,0 +1,54 @@
+module EYCli
+  module Model
+    class Base < Hashie::Mash
+      extend EYCli::SmartyParser
+
+      def self.all
+        resp = EYCli.api.get(base_path)
+        parse resp.body[base_path]
+      end
+
+      def self.find(*args)
+        resp = EYCli.api.get(resolve_child_path(args))
+        parse resp.body[class_name]
+      end
+
+      def self.find_by_name(name, collection = all)
+        # FIXME: EY api doesn't have filters. Let's do it by hand.
+        collection.select {|a| a.name == name }.first
+      end
+
+      def self.base_path(path = "#{class_name}s") # HAX: pluralize!
+        @base_path ||= path
+      end
+
+      def self.class_name
+        self.name.split('::').last.downcase
+      end
+
+      def self.resolve_child_path(args)
+        collection_path = base_path % args[0..-1]
+        "#{collection_path}/#{args.last}"
+      end
+
+      def self.create(hash)
+        path = create_collection_path(hash)
+
+        response = EYCli.api.post(path, nil, hash)
+        new response.body[class_name]
+      rescue Faraday::Error::ClientError => e
+        new MultiJson.decode(e.response[:body])
+      end
+
+      # Overrides Hashie::Mash#convert_value to not convert already parsed Mashes again
+      def convert_value(val, duping=false) #:nodoc:
+        return val.dup if val.is_a?(Hashie::Mash)
+        super(val, duping)
+      end
+
+      def self.create_collection_path(hash)
+        raise "Not implemented. Override this method for each model"
+      end
+    end
+  end
+end

data/lib/ey_cli/models/environment.rb

@@ -0,0 +1,32 @@
+module EYCli
+  module Model
+    class Environment < Base
+      base_path 'apps/%s/environments'
+
+      def self.create_collection_path(hash)
+        app = hash.delete(:app)
+        raise Faraday::Error::ClientError, {:body => MultiJson.encode({:errors => {:app => 'Not found'}})} unless app
+        base_path % app.id
+      end
+
+      def deploy(app, options = {})
+        deployment_options = deployment_configurations[app.name]
+
+        post_params = {
+          'deployment[migrate]'         => options.key?(:migrate) ? options[:migrate] : deployment_options.migrate.perform,
+          'deployment[migrate_command]' => options[:migrate_command] || deployment_options.migrate.command,
+          'deployment[ref]'             => options[:ref] || deployment_options.ref || 'HEAD'
+        }
+
+        response = EYCli.api.post(deploy_path(app), nil, post_params)
+        Hashie::Mash.new response['deployment']
+      rescue Faraday::Error::ClientError => e
+        Hashie::Mash.new MultiJson.decode(e.response[:body])
+      end
+
+      def deploy_path(app)
+        "#{self.class.resolve_child_path([app.id, id])}/deployments/deploy"
+      end
+    end
+  end
+end

data/lib/ey_cli/options_parser.rb

@@ -0,0 +1,47 @@
+module EYCli
+  class OptionsParser
+    require 'optparse'
+
+    attr_reader :options
+
+    def self.parse(args)
+      new.parse(args)
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def parse(args)
+      options_parser.parse!(args)
+      options
+    rescue OptionParser::InvalidOption => e
+      p e, options_parser
+      exit 1
+    end
+
+    def options_parser
+      ::OptionParser.new do |opts|
+        opts.banner = 'ey_cli options:'
+        opts.separator ' '
+
+        opts.on('-v', '--version', 'display the current version') do
+          puts "ey_cli #{EYCli::VERSION}"
+          exit
+        end
+
+        opts.on('-a', '--account ACCOUNT_NAME') do |account|
+          options[:account] = account
+        end
+
+        opts.on('-p', '--app APP_NAME') do |app|
+          options[:app] = app
+        end
+
+        opts.on('-e', '--environment ENVIRONMENT_NAME') do |environment|
+          options[:environment] = environment
+        end
+      end
+    end
+  end
+end