ecsutil 0.1.0

data/lib/ecsutil/command.rb

@@ -0,0 +1,24 @@
+require "ecsutil/helpers"
+require "ecsutil/aws"
+require "ecsutil/vault"
+require "ecsutil/shared"
+
+module ECSUtil
+  module Commands
+  end
+
+  class Command
+    include ECSUtil::Helpers
+    include ECSUtil::AWS
+    include ECSUtil::Vault
+    include ECSUtil::Shared
+
+    attr_reader :config, :action, :args
+
+    def initialize(config, action = nil, args = [])
+      @config = config
+      @action = action
+      @args   = args
+    end
+  end
+end

data/lib/ecsutil/commands/deploy.rb

@@ -0,0 +1,70 @@
+class ECSUtil::Commands::DeployCommand < ECSUtil::Command
+  def run
+    confirm
+
+    load_active_task_definitions
+    load_secrets
+    load_services
+
+    register_tasks
+    register_scheduled_tasks
+    register_services
+
+    deregister_tasks
+    deregister_scheduled_tasks
+    deregister_services
+  end
+
+  protected
+
+  def register_tasks
+    config["tasks"].each_pair do |name, task_config|
+      step_info "Registering task definition: #{name}"
+      task_def = generate_task_definition(config, name)
+      result   = register_task_definition(task_def)
+      arn      = result["taskDefinitionArn"]
+
+      config["tasks"][name]["arn"] = arn
+      step_info "Registered #{name}: #{arn}"
+    end
+  end
+
+  def register_scheduled_tasks
+    config["scheduled_tasks"].each_pair do |name, schedule|
+      step_info "Creating event rule for #{name}"
+
+      task      = config["tasks"][schedule["task"]]
+      rule_name = sprintf("%s-%s-%s", config["app"], config["env"], name)
+      rule_exp  = schedule["expression"]
+
+      rule_data = generate_event_rule(
+        name:       rule_name,
+        expression: rule_exp,
+        enabled:    schedule.key?("enabled") ? schedule["enabled"] == true : true
+      )
+
+      result = put_rule(rule_data)
+      config["scheduled_tasks"][name]["rule_name"] = rule_name
+      config["scheduled_tasks"][name]["rule_arn"] = result["RuleArn"]
+
+      step_info "Creating event target for #{name}"
+      rule_targets = generate_event_target(config, schedule["task"], name)
+      put_targets(rule_targets)
+    end
+
+    def register_services
+      config["services"].each_pair do |service_name, service|
+        full_name = sprintf("%s-%s-%s", config["app"], config["env"], service_name)
+        service["exists"] = @existing_services.include?(full_name)
+  
+        if service["exists"]
+          step_info "Updating service #{service_name}"
+          update_service(config, service_name)
+        else
+          step_info "Creating service #{service_name}"
+          create_service(config, service_name)
+        end
+      end
+    end
+  end
+end

data/lib/ecsutil/commands/destroy.rb

@@ -0,0 +1,19 @@
+class ECSUtil::Commands::DestroyCommand < ECSUtil::Command
+  def run
+    confirm "DANGER: You are about to deprovision all tasks and services! Proceed?"
+    confirm "Are you absolutely sure?"
+
+    config["tasks"]           = {}
+    config["scheduled_tasks"] = {}
+    config["services"]        = {}
+
+    load_active_task_definitions
+    load_secrets
+    load_services
+
+    deregister_tasks
+    deregister_scheduled_tasks
+    deregister_services
+    deregister_secrets
+  end
+end

data/lib/ecsutil/commands/help.rb

@@ -0,0 +1,14 @@
+class ECSUtil::Commands::HelpCommand < ECSUtil::Command
+  def run
+    puts [
+      "Usage: escutil <stage> <command>",
+      "Available commands:",
+      "* deploy  - Perform a deployment",
+      "* run     - Run a task",
+      "* scale   - Change service quantities",
+      "* status  - Show current status",
+      "* secrets - Manage secrets",
+      "* destroy - Delete all cloud resources"
+    ].join("\n")
+  end
+end

data/lib/ecsutil/commands/init.rb

@@ -0,0 +1,94 @@
+require "securerandom"
+
+class ECSUtil::Commands::InitCommand < ECSUtil::Command
+  def run
+    check_dependencies
+    init_password_file
+    check_password_contents
+    check_gitignore
+    init_secrets
+    init_terraform
+  end
+
+  private
+
+  def password_path
+    @password_path ||= config.secrets_vaultpass
+  end
+
+  def gitignore_path
+    @gitignore_path ||= File.join(Dir.pwd, ".gitignore")
+  end
+
+  def secrets_path
+    @secrets_path ||= File.join(Dir.pwd, "deploy", config.stage,  "secrets")
+  end
+
+  def terraform_path
+    @terraform_path ||= File.join(Dir.pwd, "terraform", config.stage)
+  end
+
+  def check_dependencies
+    step_info "Checking AWS CLI"
+    if `which aws`.strip.empty?
+      terminate("AWS CLI is not installed")
+    end
+  end
+
+  def init_password_file
+    if !password_path || password_path && !File.exists?(password_path)
+      create_password_file
+    end
+  end
+
+  def create_password_file
+    step_info "Vault password file not found at #{password_path}, creating..."
+    File.write(password_path, SecureRandom.hex(20))
+  end
+
+  def check_password_contents
+    if File.read(password_path).strip.empty?
+      terminate "Your vault password file is empty!"
+    end
+  end
+
+  def check_gitignore
+    unless File.exists?(gitignore_path)
+      step_info "Creating .gitignore file"
+      FileUtils.touch(gitignore_path)
+    end
+
+    data = File.read(gitignore_path)
+    return if data.include?("vaultpass")
+    
+    step_info "Adding vaultpass to .gitignore"
+    data += "\nvaultpass"
+    File.write(gitignore_path, data.strip + "\n")
+  end
+
+  def init_secrets
+    step_info "Setting up secrets file at #{secrets_path}"
+
+    FileUtils.mkdir_p(File.dirname(secrets_path))
+
+    if File.exists?(secrets_path)
+      step_info "Secrets file already exists, skipping..."
+      return
+    end
+
+    vault_write(secrets_path, config.secrets_vaultpass, "# This is your secrets file")
+  end
+
+  def init_terraform
+    step_info "Checking if Terraform is installed"
+    if `which terraform`.strip.empty?
+      step_info "Terraform is not found, skipping..."
+      return
+    end
+
+    unless File.exists?(terraform_path)
+      step_info "Setting up Terraform directory at #{terraform_path}"
+      FileUtils.mkdir_p(terraform_path)
+    end
+  end
+end

data/lib/ecsutil/commands/run.rb

@@ -0,0 +1,47 @@
+class ECSUtil::Commands::RunCommand < ECSUtil::Command
+  def run
+    task_name = args.shift
+    terminate("Task name is required") unless task_name
+
+    task   = config["tasks"][task_name]
+    family = sprintf("%s-%s-%s", config["app"], config["env"], task_name)
+
+    arn = load_active_task_definitions.find do |task_arn|
+      task_arn.split("/", 2).last.start_with?(family)
+    end
+
+    if !arn
+      terminate "Cant find task definition for #{family}"
+    end
+
+    opts = {
+      startedBy: config["user"],
+      cluster: config["cluster"],
+      taskDefinition: arn,
+      launchType: "FARGATE",
+      networkConfiguration: {
+        awsvpcConfiguration: {
+          subnets: [config["subnets"]].flatten,
+          securityGroups: [task["security_groups"]].flatten,
+          "assignPublicIp": "ENABLED"
+        }
+      }
+    }
+    
+    if args && args.any?
+      step_info "Using override command: #{args}"
+
+      opts[:overrides] = {
+        containerOverrides: [
+          {
+            name: task_name,
+            command: args,
+          }
+        ]
+      }
+    end
+
+    step_info "Running task using #{arn}"
+    aws_call("ecs", "run-task", opts)
+  end
+end

data/lib/ecsutil/commands/scale.rb

@@ -0,0 +1,24 @@
+class ECSUtil::Commands::ScaleCommand < ECSUtil::Command
+  def run
+    services = config["services"] || {}
+    terminate("No services found") if services.empty?
+
+    services.each_pair do |service_name, service|
+      info = describe_service(config, service_name)
+      service["exists"] = true
+      config["tasks"][service["task"]]["arn"] = info["taskDefinition"]
+
+      if info["runningCount"] != service["desired_count"]
+        step_info "Scaling #{service_name} from %d to %d",
+          info["runningCount"],
+          service["desired_count"]
+
+        update_service(config, service_name)
+      else
+        step_info "Scaling is skipped on #{service_name}. Requested: %d, actual %d",
+          service["desired_count"],
+          info["runningCount"]
+      end
+    end
+  end
+end

data/lib/ecsutil/commands/secrets.rb

@@ -0,0 +1,91 @@
+class ECSUtil::Commands::SecretsCommand < ECSUtil::Command
+  def run
+    case action
+    when nil, "show"
+      show_local_secrets
+    when "edit"
+      edit_secrets
+    when "push"
+      push_secrets
+    when "live"
+      load_secrets
+      show_live_secrets
+    when "delete"
+      confirm
+      load_secrets
+      deregister_secrets
+    else
+      fail "Invalid action: #{action}"
+    end
+  end
+
+  private
+
+  def load_local_secrets
+    vault_read(config["secrets_file"], config["secrets_vaultpass"])
+  end
+
+  def show_local_secrets
+    step_info "Loading secrets from %s", config["secrets_file"]
+    puts load_local_secrets
+  end
+
+  def show_live_secrets
+    if config["secrets_data"].empty?
+      puts "No secrets found for prefix #{config["secrets_prefix"]}"
+      return
+    end
+    
+    config["secrets_data"].each do |secret|
+      printf("%s=%s\n", secret[:key], secret[:value])
+    end
+  end
+
+  def edit_secrets
+    step_info "Editing secrets file %s", config["secrets_file"]
+    vault_edit(config["secrets_file"], config["secrets_vaultpass"])
+  end
+
+  def push_secrets
+    confirm("Will push secrets live to #{config["secrets_prefix"]}")
+    load_secrets
+
+    local = parse_env_data(load_local_secrets)
+    live  = config["secrets_data"].map { |item| [item[:key], item[:value]] }.to_h
+
+    added_count   = 0
+    skipped_count = 0
+    removed_count = 0
+
+    local.each_pair do |key, value|
+      if live[key] == value
+        step_info "Skipping #{key}, already set"
+        skipped_count += 1
+        next
+      end
+
+      step_info "Setting #{key} to #{value}"
+      aws_call("ssm", "put-parameter", {
+        Type:      "SecureString",
+        Name:      sprintf("%s/%s", config["secrets_prefix"], key),
+        Value:     value,
+        KeyId:     config["secrets_key"],
+        Overwrite: true
+      })
+      added_count += 1
+    end
+
+    config["secrets_data"].each do |secret|
+      if !local[secret[:key]]
+        step_info "Removing #{secret[:key]}"
+        aws_call("ssm", "delete-parameter", "--name=#{secret[:name]}")
+        removed_count += 1
+      end
+    end
+
+    step_info "Skipped: %d, Added: %d, Removed: %d\n",
+      skipped_count,
+      added_count,
+      removed_count
+  end
+end

data/lib/ecsutil/commands/status.rb

@@ -0,0 +1,41 @@
+class ECSUtil::Commands::StatusCommand < ECSUtil::Command
+  def run
+    step_info "Fetching active task definitions..."
+    active_task_definitions.each do |name|
+      puts name
+    end
+
+    step_info "Fetching services..."
+    fetch_active_services.each do |service|
+      deployment = service["deployments"].first || {}
+
+      printf(
+        "%s STATUS=%s DESIRED=%d PENDING=%d RUNNING=%d\n",
+        service["serviceName"],
+        service["status"],
+        deployment["desiredCount"],
+        deployment["pendingCount"],
+        deployment["runningCount"]
+      )
+    end
+  end
+
+  private
+
+  def active_task_definitions
+    list_active_task_definitions.select do |arn|
+      arn.include?(config.namespace)
+    end
+  end
+
+  def active_services
+    list_services(config.cluster).select do |name|
+      name.include?(config.namespace)
+    end
+  end
+
+  def fetch_active_services
+    names = active_services
+    names.any? ? describe_services(config, names) : []
+  end
+end

data/lib/ecsutil/config.rb

@@ -0,0 +1,60 @@
+require "yaml"
+require "hashie"
+
+module ECSUtil
+  class Config < Hashie::Mash
+    # Do not show any Hashie warnings
+    disable_warnings
+
+    def self.read(path, stage, outputs = {})
+      data = File.read(path).gsub(/(\$tf.([\w]+))+/i) do |m|
+        key = $2
+        fail "Terraform output key #{key} not found!" unless outputs[key]
+        outputs[key]
+      end
+
+      result = YAML.load(data).tap do |config|
+        fail "App name is required"   unless config["app"]
+        fail "App env is required"    unless config["env"]
+        fail "Cluster is required"    unless config["cluster"]
+        fail "Repository is required" unless config["repository"]
+        
+        # Check AWS configuration
+        if !config["aws_profile"] && !ENV["AWS_PROFILE"]
+          fail "AWS profile is not set! Set 'aws_profile' var in config or use AWS_PROFILE env var!"
+        end
+
+        # Override environment variable in case if it was set
+        ENV["AWS_PROFILE"] = config["aws_profile"]
+
+        # Set stage and namespace
+        config["user"] ||= `whoami`.strip
+        config["stage"] ||= stage
+        config["namespace"] ||= sprintf("%s-%s", config["app"], config["env"])
+
+        # Set default sections
+        config["tasks"] ||= {}
+        config["scheduled_tasks"] ||= {}
+        config["services"] ||= {}
+
+        # Parent dir
+        parent_dir = File.expand_path(File.join(File.dirname(path), ".."))
+
+        # Set secrets
+        config.merge!(
+          "secrets_vaultpass" => File.join(parent_dir, "vaultpass"),
+          "secrets_file"      => File.join(File.dirname(path), "#{stage}/secrets"),
+          "secrets_key"       => outputs["kms_key"],
+          "secrets_prefix"    => sprintf("/%s", config["namespace"]),
+          "secrets_data"      => {}
+        )
+
+        # Set default vars
+        config["git_commit"] ||= `git rev-parse HEAD`.strip
+        config["git_branch"] ||= `git rev-parse --abbrev-ref HEAD`.strip
+      end
+
+      Config.new(result)
+    end
+  end
+end