zzdeploy 0.0.5

data/lib/commands/deploy_group_create.rb

@@ -0,0 +1,128 @@
+module Commands
+  class DeployGroupCreate
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+          :amazon_elb => ''
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+          :group,
+          :app_name,
+          :rails_env,
+          :vhost,
+          :email_host,
+          :app_git_url,
+          :amazon_security_key,
+          :amazon_security_group,
+          :amazon_image,
+          :database_host,
+          :database_username,
+          :database_password,
+          :database_schema
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: create_deploy_group [options]"
+      opts.description = "Create a deploy group"
+
+      opts.on('-g', "--group name", "Required - Name of this deploy group.") do |v|
+        options[:group] = v
+      end
+
+      opts.on("--app_name appname", "Required - Name of the application.") do |v|
+        options[:app_name] = v
+      end
+
+      opts.on("--rails_env rails_env", "Required - The rails environment to use on deploy.") do |v|
+        options[:rails_env] = v
+      end
+
+      opts.on("--vhost vhost", "Required - The vhost your server will be deployed as.") do |v|
+        options[:vhost] = v
+      end
+
+      opts.on("--email_host emailhost", "Required - The email host name to use for incomming email processing.") do |v|
+        options[:email_host] = v
+      end
+
+      opts.on("--app_git_url app_git_url", "Required - Git URL to fetch code from.") do |v|
+        options[:app_git_url] = v
+      end
+
+      opts.on("--extra_json_file extra", "Optional - A file with JSON that has application custom context associated with this deploy group.") do |v|
+        options[:extra_json_file] = v
+      end
+
+      opts.on("--zone availability_zone", MetaOptions.availability_zones, "The amazon availability zone - currently only east coast.") do |v|
+        options[:availability_zone] = v
+      end
+
+      opts.on("--amazon_security_key key", "Required - The SSH key name to use, assumes pre-configured on Amazon.") do |v|
+        options[:amazon_security_key] = v
+      end
+
+      opts.on("--amazon_security_group group", "Required - The amazon security group, assumes pre-configured on Amazon.") do |v|
+        options[:amazon_security_group] = v
+      end
+
+      opts.on("--amazon_image ami", "Required - The baseline Amazon image to use, assumes pre-configured on Amazon.") do |v|
+        options[:amazon_image] = v
+      end
+
+      opts.on("--amazon_elb load_balancer", "Optional - The elastic load balancer we operate under.") do |v|
+        options[:amazon_elb] = v
+      end
+
+      opts.on("--database_host database", "Required - The database host name.") do |v|
+        options[:database_host] = v
+      end
+
+      opts.on("--database_username username", "Required - The database user name name.") do |v|
+        options[:database_username] = v
+      end
+
+      opts.on("--database_password password", "Required - The database password.") do |v|
+        options[:database_password] = v
+      end
+
+      opts.on("--database_schema schema", "Required - The database schema name.") do |v|
+        options[:database_schema] = v
+      end
+
+    end
+
+
+    def run(global_options, amazon)
+      group_name = options[:group]
+      extra_file = options[:extra_json_file]
+      if !extra_file.nil?
+        # they are passing a path to a file containing custom json so add it to the extra field
+        options.delete(:extra_json_file)
+        json = File.open(extra_file, 'r') {|f| f.read }
+        # make sure we can parse into a hash
+        extra = JSON.parse(json)
+        options[:extra] = extra
+      end
+      config_json = JSON.fast_generate(options)
+
+      # first see if already exists
+      deploy_group = ZZSharedLib::DeployGroupSimpleDB.find_by_zz_object_type_and_group(ZZSharedLib::DeployGroupSimpleDB.object_type, group_name, :auto_load => true)
+
+      if !deploy_group.nil?
+        raise "This deploy group already exists.  Doing nothing."
+      end
+
+      deploy_group = ZZSharedLib::DeployGroupSimpleDB::create(:zz_object_type => ZZSharedLib::DeployGroupSimpleDB.object_type, :group => group_name,
+                                                              :config_json => config_json, :recipes_deploy_tag => "origin/master", :app_deploy_tag => "master",
+                                                              :created_at => Time.now.strftime('%Y-%m-%dT%H:%M:%S%z'))
+
+    end
+  end
+end

data/lib/commands/deploy_group_delete.rb

@@ -0,0 +1,42 @@
+module Commands
+  class DeployGroupDelete
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+          :group,
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: delete_deploy_group [options]"
+      opts.description = "Delete a deploy group"
+
+      opts.on('-g', "--group name", "Required - Name of this deploy group.") do |v|
+        options[:group] = v
+      end
+
+    end
+
+
+    def run(global_options, amazon)
+      group_name = options[:group]
+
+      # first see if already exists
+      deploy_group = amazon.find_deploy_group(group_name)
+
+      if deploy_group.nil? || deploy_group[:group] != group_name
+        raise "Deploy group not found.  Doing nothing."
+      end
+
+      deploy_group.delete
+    end
+  end
+end

data/lib/commands/deploy_group_list.rb

@@ -0,0 +1,41 @@
+module Commands
+  class DeployGroupList
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: list_deploy_groups [options]"
+      opts.description = "List the deploy groups"
+
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+
+      # first see if already exists
+      deploy_groups = ZZSharedLib::DeployGroupSimpleDB.find_all_by_zz_object_type(ZZSharedLib::DeployGroupSimpleDB.object_type, :auto_load => true)
+
+      deploy_groups.each do |deploy_group|
+        puts "Name: #{deploy_group[:group]}"
+        puts "Recipes_deploy_tag: #{deploy_group[:recipes_deploy_tag]}"
+        puts "App_deploy_tag: #{deploy_group[:app_deploy_tag]}"
+        puts "Config Json:"
+        pretty = JSON.pretty_generate(deploy_group.config)
+        puts "#{pretty}"
+        puts
+      end
+    end
+  end
+end

data/lib/commands/deploy_group_modify.rb

@@ -0,0 +1,65 @@
+module Commands
+  class DeployGroupModify
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+          :group,
+          :extra_json_file
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+          :group,
+          :extra_json_file
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: deploy_group_modify [options]"
+      opts.description = "Lets you modify the app extra data by replacing the current extra data with the new data supplied."
+
+      opts.on('-g', "--group name", "Required - Name of this deploy group.") do |v|
+        options[:group] = v
+      end
+
+      opts.on('-e', "--extra_json_file extra", "Required - A file with JSON that has application custom context associated with this deploy group.") do |v|
+        options[:extra_json_file] = v
+      end
+
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+
+      group_name = options[:group]
+      extra_file = options[:extra_json_file]
+      if !extra_file.nil?
+        # they are passing a path to a file containing custom json so add it to the extra field
+        json = File.open(extra_file, 'r') {|f| f.read }
+        # make sure we can parse into a hash
+        extra = JSON.parse(json)
+        options[:extra] = extra
+      end
+
+      # get the existing deploy group
+      deploy_group = amazon.find_deploy_group(group_name)
+      config = deploy_group.config
+      extra_file = options[:extra_json_file]
+
+      # open up the specified file with the json and parse
+      json = File.open(extra_file, 'r') {|f| f.read }
+      # make sure we can parse into a hash
+      extra = JSON.parse(json)
+
+      # ok, now set or replace any existing extra data
+      config[:extra] = extra
+      deploy_group.config = config
+      deploy_group.save
+    end
+  end
+end

data/lib/commands/deploy_instances.rb

@@ -0,0 +1,108 @@
+module Commands
+  class DeployInstances
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+          :migrate_command => '',
+          :downtime => false,
+          :no_restart => false
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+          :group,
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: deploy [options]"
+      opts.description = "Deploy the applications for the specified group"
+
+      opts.on('-g', "--group name", "Required - Name of this deploy group.") do |v|
+        options[:group] = v
+      end
+
+      opts.on('-t', "--tag tag", "Required - Git tag to use for pulling chef code.") do |v|
+        options[:tag] = v
+      end
+
+      opts.on('-m', "--migrate [command]", "Migrate command to run.  Does not force downtime, use the --downtime option for that.") do |v|
+        options[:migrate_command] = v || 'rake db:migrate'
+      end
+
+      opts.on('-d', "--downtime", "If this flag is set we bring the server down and bring up the maint page during the restart phase.") do |v|
+        options[:downtime] = v
+      end
+
+      opts.on("--no_restart", "Set this if you only want the deploy without a restart, useful for creating AMI images.") do |v|
+        options[:no_restart] = v
+      end
+
+      opts.on('-f', "--force", "Force a deploy even if the current status says we are deploying.  You should only do this if you are certain the previous deploy is stuck.") do |v|
+        options[:force] = v
+      end
+
+      opts.on('-p', "--print path", "The directory into which we output the data as a file per host.") do |v|
+        options[:result_path] = v
+      end
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+      utils = ZZSharedLib::Utils.new(amazon)
+
+      group_name = options[:group]
+      migrate_command = options[:migrate_command]
+      downtime = options[:downtime]
+      app_deploy_tag = options[:tag]
+      no_restart = options[:no_restart]
+
+      # first see if already exists
+      deploy_group = amazon.find_deploy_group(group_name)
+
+      group_config = deploy_group.config
+      gitrepo = group_config[:app_git_url]
+
+      # verify that the chef deploy tag exists
+      full_ref = "refs/heads/#{app_deploy_tag}"
+      cmd = "git ls-remote #{gitrepo} #{full_ref} | egrep #{full_ref}"
+      if ZZSharedLib::CL.do_cmd_result(cmd) != 0
+        # now try to see if it's a tag
+        full_ref = "refs/tags/#{app_deploy_tag}"
+        cmd = "git ls-remote #{gitrepo} #{full_ref} | egrep #{full_ref}"
+        if ZZSharedLib::CL.do_cmd_result(cmd) != 0
+          raise "Could not find the tag or ref: #{app_deploy_tag} in the remote #{gitrepo} repository."
+        end
+      end
+
+      deploy_group.app_deploy_tag = app_deploy_tag
+      deploy_group.save
+      deploy_group.reload # save corrupts the in memory state so must reload, kinda lame
+
+
+      instances = amazon.find_and_sort_named_instances(group_name)
+
+      # see if already deploying
+      if !options[:force]
+        # raises an exception if not all in the ready or error state
+        utils.check_deploy_state(instances, [:deploy_chef, :deploy_app])
+      end
+
+
+      # tag is good, go ahead and deploy to all the machines in the group
+      # this is a two phase operation.  The first pushes the code and preps everything
+      # up to the point of a before restart operation.  We then call again to
+      # perform the restart.  This ensures that all servers were prepped before
+      # we try to restart to minimize the chance of issues.
+      BuildDeployConfig.do_app_deploy(utils, amazon, instances, group_name, deploy_group, migrate_command, downtime, no_restart, options[:result_path])
+      ui = Printer.new(STDOUT, STDERR, STDIN)
+      ui.msg(ui.color("Your app has been successfully deployed - open for business.", :green, :bold, :reverse))
+
+    end
+  end
+end

data/lib/commands/list_instances.rb

@@ -0,0 +1,56 @@
+require "set"
+
+module Commands
+  class ListInstances
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+          :group
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: add [options]"
+      opts.description = "Add a server instance"
+
+      opts.on('-r', "--role role", MetaOptions.roles, "Role to look for.") do |v|
+        options[:role] = v
+      end
+
+      opts.on('-g', "--group deploy_group", "Required: Group to look for.") do |v|
+        options[:group] = v
+      end
+
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+
+      instances = amazon.find_and_sort_named_instances(options[:group], options[:role])
+
+      first = true
+      instances.each do |instance|
+        if first
+          s = sprintf("%-40s%-14s%-40s","Name", "Instance", "Public Host")
+          puts s
+          first = false
+        end
+        name = instance[:Name]
+        resource_id = instance[:resource_id]
+        public_host = instance[:public_hostname]
+        s = sprintf("%-40s%-14s%-40s",name, resource_id, public_host)
+        puts s
+      end
+
+    end
+  end
+end

data/lib/commands/maint_instances.rb

@@ -0,0 +1,63 @@
+module Commands
+  class MaintInstances
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+          :migrate_command => '',
+          :downtime => false
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+          :group,
+          :maint,
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: maint [options]"
+      opts.description = "Put up or take down the maintenance page."
+
+      opts.on('-g', "--group name", "Required - Name of this deploy group.") do |v|
+        options[:group] = v
+      end
+
+      opts.on('-m', "--[no-]maint", "Required - Use --maint if you want the maint page, --no-maint to remove the maint page.") do |v|
+        options[:maint] = v
+      end
+
+      opts.on('-p', "--print path", "The directory into which we output the data as a file per host.") do |v|
+        options[:result_path] = v
+      end
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+      utils = ZZSharedLib::Utils.new(amazon)
+
+      group_name = options[:group]
+      maint = options[:maint]
+
+      # first see if already exists
+      deploy_group = amazon.find_deploy_group(group_name)
+
+      instances = amazon.find_and_sort_named_instances(group_name)
+
+      # see if already deploying
+      if !options[:force]
+        # raises an exception if not all in the ready or error state
+        utils.check_deploy_state(instances, [:deploy_chef, :deploy_app])
+      end
+
+
+      # put up or take down the maint page
+      BuildDeployConfig.do_maint_deploy(utils, amazon, instances, group_name, deploy_group, maint, options[:result_path])
+
+    end
+  end
+end

data/lib/commands/meta_options.rb

@@ -0,0 +1,26 @@
+# this class defines the valid meta options we allow
+# such as the role types allowed, apps allowed, environments allowed
+#
+module Commands
+  class MetaOptions
+    # the roles that a given server can play
+    # only one role per server is allowed.  If we
+    # need custom functionality we define a role that
+    # has the functionality we need.
+    # The meaning of the roles is defined in the chef script
+    # mapping from a role to recipes
+    def self.roles
+      [:app_master, :app, :db, :util, :db_slave, :solo]
+    end
+
+    def self.availability_zones
+      ["us-east-1a", "us-east-1b", "us-east-1c", "us-east-1d"]
+    end
+
+    # the valid apps we can deploy
+    def self.apps
+      [:photos, :zza, :rollup]
+    end
+
+  end
+end

data/lib/commands/multi_ssh_instance.rb

@@ -0,0 +1,87 @@
+require "set"
+require 'readline'
+
+module Commands
+  class MultiSSHInstance
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+        :group
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: ssh [options]"
+      opts.description = "SSH into a server"
+
+      opts.on('-i', "--instances instance1,instance2,etc", Array, "The instance(s) to connect to.") do |v|
+        options[:instances] = v
+      end
+
+      opts.on('-r', "--role role", MetaOptions.roles, "Role to look for.") do |v|
+        options[:role] = v
+      end
+
+      opts.on('-g', "--group deploy_group", "Required: Group to look for.") do |v|
+        options[:group] = v
+      end
+
+      opts.on('-f', "--file file", "A file that contains the commands to execute.") do |v|
+        options[:file] = v
+      end
+
+      opts.on('-p', "--print path", "The directory into which we output the data as a file per host.") do |v|
+        options[:result_path] = v
+      end
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+
+      file_path = options[:file]
+      if file_path.nil?
+        if ARGV.length != 1
+          raise "Must include the remote command to run.  Make sure you quote it so it appears as one argument"
+        end
+        remote_cmd = ARGV[0]
+      else
+        remote_cmd = File.open(file_path, 'r') {|f| f.read }
+      end
+
+      group_name = options[:group]
+      deploy_group = amazon.find_deploy_group(group_name)
+      group_config = deploy_group.config
+
+      user_instances = options[:instances]
+      if user_instances.nil?
+        instances = amazon.find_and_sort_named_instances(options[:group], options[:role])
+      else
+        instances = []  # build the instances wanted here
+        server_instances = amazon.find_and_sort_named_instances(nil, nil, false)
+        server_instances.each do |server_instance|
+          server_instance_id = server_instance[:resource_id]
+          if user_instances.include?(server_instance_id)
+            instances << server_instance
+          end
+        end
+      end
+
+      if instances.empty?
+         raise "No instances matched your search criteria."
+      end
+
+      multi = MultiSSH.new(amazon, group_name, deploy_group)
+      multi.run_instances(instances, remote_cmd)
+      multi.output_tracked_data_to_files("multi_ssh", options[:result_path])
+    end
+  end
+end