ey-core 3.0.5 → 3.1.0

data/lib/ey-core/cli/recipes.rb

@@ -0,0 +1,92 @@
+class Ey::Core::Cli::Recipes < Ey::Core::Cli::Subcommand
+  title "recipes"
+  summary "Chef specific commands"
+
+  Dir[File.dirname(__FILE__) + "/recipes/*.rb"].each { |file| load file }
+
+  Ey::Core::Cli::Recipes.descendants.each do |d|
+    mount d
+  end
+
+  def run_chef(type, environment)
+    request = environment.apply(type)
+    puts "Started #{type} chef run".green
+    request.wait_for { |r| r.ready? }
+    if request.successful
+      puts "#{type.capitalize} chef run completed".green
+    else
+      puts "#{type.capitalize} chef run failed".red
+      ap request
+    end
+  end
+
+  def gzip(tarfile)
+    gz = StringIO.new("")
+    z = Zlib::GzipWriter.new(gz)
+    z.write tarfile.string
+    z.close # this is necessary!
+
+    # z was closed to write the gzip footer, so
+    # now we need a new StringIO
+    StringIO.new gz.string
+  end
+
+  def archive_directory(path)
+    tarfile = StringIO.new("")
+    Gem::Package::TarWriter.new(tarfile) do |tar|
+      Dir[File.join(path, "**/*")].each do |file|
+        mode          = File.stat(file).mode
+        relative_file = "cookbooks/#{file.sub(/^#{Regexp::escape path}\/?/, '')}"
+
+        if File.directory?(file)
+          tar.mkdir relative_file, mode
+        else
+          tar.add_file relative_file, mode do |tf|
+            File.open(file, "rb") { |f| tf.write f.read }
+          end
+        end
+      end
+    end
+
+    tarfile.rewind
+    gzip(tarfile)
+  end
+
+  def upload_recipes(environment, path="cookbooks/")
+    recipes_path = Pathname.new(path)
+
+    if recipes_path.exist? && recipes_path.to_s.match(/\.(tgz|tar\.gz)/)
+      environment.upload_recipes(recipes_path)
+    elsif recipes_path.exist?
+      environment.upload_recipes(archive_directory(path))
+    else
+      raise Ey::Core::Cli::RecipesNotFound, "Recipes file not found: #{recipes_path}"
+    end
+  end
+
+  def ungzip(tarfile)
+    z = Zlib::GzipReader.new(tarfile)
+    unzipped = StringIO.new(z.read)
+    z.close
+    unzipped
+  end
+
+
+  def untar(io, destination)
+    Gem::Package::TarReader.new io do |tar|
+      tar.each do |tarfile|
+        destination_file = File.join destination, tarfile.full_name
+
+        if tarfile.directory?
+          FileUtils.mkdir_p destination_file
+        else
+          destination_directory = File.dirname(destination_file)
+          FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+          File.open destination_file, "wb" do |f|
+            f.print tarfile.read
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ey-core/cli/recipes/apply.rb

@@ -0,0 +1,34 @@
+class Ey::Core::Cli::Recipes::Apply < Ey::Core::Cli::Recipes
+  title "apply"
+  summary "Apply changes to an environment"
+  option :account, short: "c", long: "account", description: "Name or id of account", argument: "account"
+  option :environment, short: "e", long: "environment", description: "Name or id of environment", argument: "environment"
+
+  switch :main, short: "m", long: "main", description: "Apply main recipes only"
+  switch :custom, long: "custom", description: "Apply custom recipes only"
+  switch :quick, short: "q", long: "quick", description: "Quick chef run"
+  switch :full, short: "f", long: "full", description: "Run main and custom chef"
+
+  def handle
+    operator, environment = core_operator_and_environment_for(options)
+    raise "Unable to find matching environment" unless environment
+
+    run_type = if switch_active?(:main)
+                 "main"
+               elsif switch_active?(:custom)
+                 "custom"
+               elsif switch_active?(:quick)
+                 "quick"
+               elsif switch_active?(:full)
+                 "main"
+               else
+                 "main"
+               end
+
+    run_chef(run_type, environment)
+
+    if switch_active?(:full)
+      run_chef("custom", environment)
+    end
+  end
+end

data/lib/ey-core/cli/recipes/download.rb

@@ -0,0 +1,26 @@
+class Ey::Core::Cli::Recipes::Download < Ey::Core::Cli::Recipes
+  title "download"
+  summary "Download a copy of the custom chef recipes from this environment into the current directory"
+  description <<-DESC
+    The recipes will be unpacked into a directory called "cookbooks" in the
+    current directory. This is the opposite of 'recipes upload'.
+
+    If the cookbooks directory already exists, an error will be raised.
+  DESC
+
+  option :environment, short: "e", long: "environment", description: "Environment that will receive the recipes.", argument: "environment"
+  option :account,     short: "c", long: "account",     description: "Name of the account in which the environment can be found.", argument: "account"
+
+  def handle
+    if File.exist?("cookbooks")
+      raise Ey::Core::Clie::RecipesExist.new("Cannot download recipes, cookbooks directory already exists.")
+    end
+
+    operator, environment = core_operator_and_environment_for(options)
+    puts "Downloading recipes".green
+    recipes     = environment.download_recipes
+
+    puts "Extracting recipes to 'cookbooks/'".green
+    untar(ungzip(recipes), './')
+  end
+end

data/lib/ey-core/cli/recipes/upload.rb

@@ -0,0 +1,27 @@
+class Ey::Core::Cli::Recipes::Upload < Ey::Core::Cli::Recipes
+  title "upload"
+  summary "Upload custom recipes to an environment"
+  option :environment, short: "e", long: "environment", description: "Environment that will receive the recipes.", argument: "environment"
+  option :account,     short: "c", long: "account",     description: "Name of the account in which the environment can be found.", argument: "account"
+  option :file,        short: "f", long: "file",        description: "Path to recipes", argument: "path"
+
+  switch :apply, short: "a", long: "apply", description: "Apply the recipes immediately after they are uploaded"
+
+  def handle
+    operator, environment = core_operator_and_environment_for(options)
+    path = option(:file) || "cookbooks/"
+
+    puts "Uploading custom recipes for #{environment.name}".green
+    begin
+      upload_recipes(environment, path)
+      puts "Uploading custom recipes complete".green
+    rescue => e
+      abort "There was a problem uploading the recipes".red
+      puts e.inspect
+    end
+
+    if switch_active?(:apply)
+      run_chef("custom", environment)
+    end
+  end
+end

data/lib/ey-core/cli/scp.rb

@@ -0,0 +1,11 @@
+class Ey::Core::Cli::Scp < Ey::Core::Cli::Subcommand
+  title "scp"
+  summary "This command is deprecated"
+  description <<-DESC
+    The scp command has been deprecated.  We apologize for any inconvenience.
+  DESC
+
+  def handle
+    abort "This command is deprecated".red
+  end
+end

data/lib/ey-core/cli/servers.rb

@@ -0,0 +1,19 @@
+class Ey::Core::Cli::Servers < Ey::Core::Cli::Subcommand
+  title "servers"
+  summary "List servers you have access to"
+  option :account, short: 'c', long: 'account', description: 'Filter by account name or id', argument: 'Account'
+  option :environment, short: "-e", long: "environment", description: "Filter by environment.", argument: "environment"
+
+  def handle
+    servers = if option(:account)
+                account = core_account_for(options)
+                core_client.servers.all(account: account)
+              elsif environment = option(:environment)
+                (core_client.environments.get(environment) || core_client.environments.first(name: environment)).servers.all
+              else
+                core_client.servers.all
+              end
+
+    puts TablePrint::Printer.new(servers, [{id: {width: 10}}, :role, :provisioned_id]).table_print
+  end
+end

data/lib/ey-core/cli/ssh.rb

@@ -0,0 +1,94 @@
+class Ey::Core::Cli::Ssh < Ey::Core::Cli::Subcommand
+  title "ssh"
+  summary "Open an SSH session to the environment's application master"
+  option :account, short: "c", long: "account", description: "Name or id of account", argument: "account"
+  option :environment, short: "e", long: "environment", description: "Name or id of environment", argument: "environment"
+  option :server, short: 's', long: "server", description: "Specific server to ssh into. Id or amazon id (i-12345)", argument: "server"
+  option :utilities, long: "utilities", description: "Run command on the utility servers with the given names. Specify all to run the command on all utility servers.", argument: "'all,resque,redis,etc'"
+  option :command, long: "command", description: "Command to run", argument: "'command with args'"
+  option :shell, short: 's', long: "shell", description: "Run command in a shell other than bash", argument: "shell"
+  option :bind_address, long: "bind_address", description: "When no command is specified, pass -L to ssh", argument: "bind address"
+
+  switch :all,         long: "all",         description: "Run command on all servers"
+  switch :app_servers, long: "app_servers", description: "Run command on all application servers"
+  switch :db_servers,  long: "db_servers",  description: "Run command on all database servers"
+  switch :db_master,   long: "db_master",   description: "Run command on database master"
+  switch :db_slaves,   long: "db_slaves",   description: "Run command on database slaves"
+  switch :tty, short: 't', long: "tty",     description: "Allocated a tty for the command"
+
+  def handle
+    operator, environment = core_operator_and_environment_for(options)
+    abort "Unable to find matching environment".red unless environment
+
+    cmd      = option(:command)
+    ssh_opts = []
+    ssh_cmd  = ["ssh"]
+    exits    = []
+    user     = environment.username
+    servers  = []
+
+
+
+    if option(:command)
+      if shell = option(:shell)
+        cmd = Escape.shell_command([shell,'-lc',cmd])
+      end
+
+      if switch_active?(:tty)
+        ssh_opts << "-t"
+      elsif cmd.match(/sudo/)
+        puts "sudo commands often need a tty to run correctly. Use -t option to spawn a tty.".yellow
+      end
+
+      if switch_active?(:all)
+        servers += environment.servers.all.to_a
+      end
+
+      if switch_active?(:app_servers)
+        servers += (environment.servers.all(role: "app_master") + environment.servers.all(role: "app") + environment.servers.all(role: "solo")).to_a
+      end
+
+      if switch_active?(:db_servers)
+        servers += (environment.servers.all(role: "db_master") + environment.servers.all(role: "db_slave") + environment.servers.all(role: "solo")).to_a
+      end
+
+      if switch_active?(:db_master)
+        servers += (environment.servers.all(role: "db_master") + environment.servers.all(role: "solo")).to_a
+      end
+
+      if utils = option(:utilities)
+        if utils == 'all'
+          servers += environment.servers.all(role: "util").to_a
+        else
+          servers += environment.servers.all(role: "util", name: utils).to_a
+        end
+      end
+    else
+      if option(:bind_address)
+        ssh_opts += ["-L", option(:bind_address)]
+      end
+
+      if option(:server)
+        servers += [core_server_for(server: option[:server], operator: environment)]
+      else
+        servers += (environment.servers.all(role: "app_master") + environment.servers.all(role: "solo")).to_a
+      end
+    end
+
+    if servers.empty?
+      abort "Unable to find any matching servers. Aborting.".red
+    end
+
+    servers.each do |server|
+      host = server.public_hostname
+      name = server.name ? "#{server.role} (#{server.name})" : server.role
+      puts "\nConnecting to #{name} #{host}".green
+      sshcmd = Escape.shell_command((ssh_cmd + ["#{user}@#{host}"] + [cmd]).compact)
+      puts "Running command: #{sshcmd}".green
+      system sshcmd
+      exits << $?.exitstatus
+    end
+
+    exit exits.detect {|status| status != 0 } || 0
+  end
+end

data/lib/ey-core/cli/status.rb

@@ -0,0 +1,20 @@
+class Ey::Core::Cli::Status < Ey::Core::Cli::Subcommand
+  title "status"
+  summary "Show the deployment status of the app"
+
+  option :environment, short: "e", long: "environment", description: "Name or id of the environment to deploy to.", argument: "Environment"
+  option :account,     short: 'c', long: 'account',     description: 'Name or ID of the account that the environment resides in.  If no account is specified, the app will deploy to the first environment that meets the criteria, in the accounts you have access to.', argument: 'Account name or id'
+  option :app,         short: "a", long: "app",         description: "Application name or ID to deploy.  If :account is not specified, this will be the first app that matches the criteria in the accounts you have access to.", argument: "app"
+
+  description <<-DESC
+    Show the current status of the most recent deployment of the specifed application and environment
+  DESC
+
+  def handle
+    operator, environment = core_operator_and_environment_for(self.options)
+    app                   = core_application_for(self.options)
+    deployments           = core_client.deployments.all(environment_id: environment.id, application_id: app.id)
+
+    ap deployments.first
+  end
+end

data/lib/ey-core/cli/subcommand.rb

@@ -0,0 +1,114 @@
+class Ey::Core::Cli::Subcommand < Belafonte::App
+  def self.descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+
+  class << self
+    attr_accessor :core_file
+
+    def core_file
+      @core_file ||= File.expand_path("~/.ey-core")
+    end
+
+    def eyrc
+      @eyrc ||= File.expand_path("~/.eyrc")
+    end
+  end
+
+  def unauthenticated_core_client
+    @unauthenticated_core_client ||= Ey::Core::Client.new(token: nil, url: core_url)
+  end
+
+  def core_client
+    @core_client ||= Ey::Core::Client.new(url: core_url, config_file: self.class.core_file)
+  rescue RuntimeError => e
+    if legacy_token = e.message.match(/missing token/i) && eyrc_yaml["api_token"]
+      puts "Found legacy .eyrc token.  Migrating to core file".green
+      write_core_yaml(legacy_token)
+      retry
+    elsif e.message.match(/missing token/i)
+      abort "Missing credentials: Run 'ey login' to retrieve your Engine Yard Cloud API token.".yellow
+    else
+      raise e
+    end
+  end
+
+  def core_url
+    env_url = ENV["CORE_URL"] || ENV["CLOUD_URL"]
+    (env_url && File.join(env_url, '/')) || "https://api.engineyard.com/"
+  end
+
+  def current_accounts
+    core_client.users.current.accounts
+  end
+
+  def longest_length_by_name(collection)
+    collection.map(&:name).group_by(&:size).max.last.length
+  end
+
+  def write_core_yaml(token=nil)
+    core_yaml[core_url] = token if token
+    File.open(self.class.core_file, "w") { |f| f.puts core_yaml.to_yaml }
+  end
+
+  def eyrc_yaml
+    @eyrc_yaml ||= YAML.load_file(self.class.eyrc) || {}
+  rescue Errno::ENOENT => e # we don't really care if this doesn't exist
+    {}
+  end
+
+  def core_yaml
+    @core_yaml ||= YAML.load_file(self.class.core_file) || {}
+  rescue Errno::ENOENT => e
+    puts "Creating #{self.class.core_file}".yellow
+    FileUtils.touch(self.class.core_file)
+    retry
+  end
+
+  def core_account_for(options={})
+    @core_account ||= core_client.accounts.get(options[:account])
+    @core_account ||= core_client.users.current.accounts.first(name: options[:account])
+  end
+
+  def operator(options)
+    options[:account] ? core_account_for(options) : core_client
+  end
+
+  def core_operator_and_environment_for(options={})
+    operator = operator(options)
+    environment = operator.environments.get(options[:environment]) || operator.environments.first(name: options[:environment])
+    [operator, environment]
+  end
+
+  def core_environment_for(options={})
+    core_client.environments.get(options[:environment]) || core_client.environments.first(name: options[:environment])
+  end
+
+  def core_server_for(options={})
+    operator = options.fetch(:operator, core_client)
+    operator.servers.get(options[:server]) || operator.servers.first(provisioned_id: options[:server])
+  end
+
+  def core_application_for(options={})
+    return nil unless options[:app]
+
+    app = begin
+            Integer(options[:app])
+          rescue
+            options[:app]
+          end
+
+    actor = options[:environment].is_a?(Ey::Core::Client::Environment) ? options[:environment].account : operator(options)
+
+    if app.is_a?(Integer)
+      actor.applications.get(app)
+    else
+      applications = actor.applications.all(name: app)
+      if applications.count == 1
+        applications.first
+      else
+        raise Ey::Core::Cli::AmbiguousSearch.new("Found multiple applications that matched that search.  Please be more specific by specifying the account, environment, and application name.")
+      end
+    end
+  end
+end