athlete 0.0.1

data/lib/athlete/cli.rb

@@ -0,0 +1,118 @@
+require 'thor'
+
+module Athlete
+  class CLI < Thor
+    include Thor::Actions
+    include Logging
+    
+    # Allow specifying a custom path to the config file
+    class_option :config, :desc => "Path to config file", :aliases => "-f"
+    
+    # Verbose (turns loglevel to DEBUG)
+    class_option :verbose, :desc => "Output verbose logging", :aliases => "-v", :type => :boolean, :default => false
+    
+    desc 'list [TYPE]', 'List all builds and/or deployments'
+    long_desc <<-LONGDESC
+      `athlete list` will show all builds and deployments.
+      `athlete list builds` will show only builds, and `athlete list deployments` will
+      list only deployments.
+    LONGDESC
+    def list(type = nil)
+      setup
+      output_builds if type.nil? || type == 'builds'
+      output_deployments if type.nil? || type == 'deployments'
+    end
+      
+    
+    desc 'build BUILD_NAME', 'Build and push the Docker image specified by BUILD_NAME'
+    long_desc <<-LONGDESC
+      `athlete build` will build the named Docker image(s) specified in the build section
+      of your Athlete configuration file. It will then push this image to the remote
+      registry you have specified, unless you specify the `--no-push` flag (`--push` is
+      the default).
+    LONGDESC
+    method_option :push, :desc => "Specify whether the image should be pushed to the configured registry", :type => :boolean, :default => true
+    def build(build_name)
+      setup
+      
+      build = Athlete::Build.builds[build_name]
+      if build
+        do_build(build, options[:push])
+      else
+        fatal "Could not locate a build in the configuration named '#{build_name}'"
+        exit 1
+      end
+    end
+    
+    desc 'deploy DEPLOYMENT_NAME', 'Run the deployment specified by DEPLOYMENT_NAME'
+    long_desc <<-LONGDESC
+      `athlete deploy` will deploy container(s) (to Marathon) of the Docker image(s) specified in the deployment
+      section of your Athlete configuration file.
+    LONGDESC
+    def deploy(deployment_name)
+      setup
+      
+      deployment = Athlete::Deployment.deployments[deployment_name]
+      if deployment
+       do_deploy(deployment)
+      else
+       fatal "Could not locate a deployment in the configuration named '#{deployment_name}'"
+       exit 1
+      end
+    end
+    
+    private
+    
+    def setup
+      handle_verbose
+      load_config
+    end
+    
+    # Basic configuration loading and safety checking of the DSL
+    def load_config
+      config_file = options[:config] || 'config/athlete.rb'
+      if !File.exists?(config_file)
+        fatal "Config file '#{config_file}' does not exist or cannot be read"
+        exit 1
+      end
+      debug "Using configuration file at #{config_file}"
+      begin
+        load config_file
+      rescue Exception => e
+        fatal "Exception loading the config file - #{e.class}: #{e.message} at #{e.backtrace[0]}"
+        exit 1
+      end
+    end
+    
+    def handle_verbose
+      options[:verbose] ? loglevel(Logger::DEBUG) : loglevel(Logger::INFO)
+    end
+    
+    def do_build(build, should_push)
+      info "Beginning build of '#{build.name}'"
+      build.perform(should_push)
+      info "Build complete"
+    end
+    
+    def do_deploy(deployment)
+      info "Beginning deployment of '#{deployment.name}'"
+      deployment.perform
+      info "Deployment complete"
+    end
+    
+    def output_builds
+      puts "Builds"
+      Athlete::Build.builds.keys.sort.each do |name|
+        Athlete::Build.builds[name].readable_output
+      end
+    end
+    
+    def output_deployments
+      puts "Deployments"
+      Athlete::Deployment.deployments.keys.sort.each do |name|
+        Athlete::Deployment.deployments[name].readable_output
+      end
+    end
+    
+  end
+end

data/lib/athlete/deployment.rb

@@ -0,0 +1,285 @@
+module Athlete
+  class Deployment
+    include Logging
+    
+    @deployments = {}
+    
+    class << self
+      attr_accessor :deployments
+    end
+    
+    # Define valid properties
+    @@valid_properties =  %w{
+      name
+      marathon_url
+      build_name
+      image_name
+      command
+      arguments
+      cpus
+      memory
+      environment_variables
+      instances
+      minimum_health_capacity
+    }
+    
+    # Define properties that cannot be overridden or inherited
+    @@locked_properties = %w{
+      name
+      marathon_url
+      build_name
+      image_name
+      command
+      arguments
+      environment_variables
+    }
+    
+    def initialize
+      @inherit_properties = []
+      @override_properties = []
+      setup_dsl_methods
+    end
+    
+    def setup_dsl_methods
+      @@valid_properties.each do |property|
+        self.class.class_eval {
+          
+          # Define property settings methods for the DSL
+          define_method(property) do |property_value, override_or_inherit = nil|
+            instance_variable_set("@#{property}", property_value)
+            if not @@locked_properties.include?(property)
+              case override_or_inherit
+              when :override
+                @override_properties << property
+              when :inherit
+                @inherit_properties << property
+              else
+                raise Athlete::ConfigurationInvalidException, 
+                  "Property '#{property}' of deployment '#{@name}' specified behaviour as '#{override_or_inherit}', which is not one of :override or :inherit"
+              end
+            end
+            self.class.class_eval{attr_reader property.to_sym}
+          end
+          
+        }
+      end
+    end
+    
+    def self.define(name, &block)
+      deployment = Athlete::Deployment.new
+      deployment.name name
+      deployment.instance_eval(&block)
+      deployment.fill_default_values
+      deployment.validate
+      deployment.connect_to_marathon
+      @deployments[deployment.name] = deployment
+    end
+    
+    def fill_default_values
+      if !@instances
+        @instances = 1
+        @inherit_properties << 'instances'
+      end
+    end
+    
+    def validate
+      errors = []
+      
+      # Must specify a Docker image (either from a build or some upstream source)
+      errors << "You must set one of image_name or build_name" unless @build_name || @image_name
+      
+      # If a build name is specified, it must match something in the file
+      if @build_name && linked_build.nil?
+        errors << "Build name '#{@build_name}' doesn't match a build in the config file"
+      end
+      
+      # Marathon URL is required
+      errors << "You must specify marathon_url" unless @marathon_url
+      
+      # Environment variables must be a hash
+      errors << "environment_variables must be a hash" if @environment_variables && !@environment_variables.kind_of?(Hash)
+      
+      # Can't supply both command and args
+      errors << "You must specify only one of command or arguments" if @command && @arguments
+      
+      # Arguments must be in an array
+      error << "The arguments parameter must be specified as an array" if @arguments && !@arguments.kind_of?(Array)
+      
+      unless errors.empty?
+        raise ConfigurationInvalidException, @errors
+      end
+    end
+    
+    def connect_to_marathon
+      @marathon_client = Marathon::Client.new(@marathon_url)
+    end
+    
+    def perform
+      response = deploy_or_update
+      @deploy_response = response.parsed_response
+      debug "Entire deployment response: #{response.inspect}"
+      
+      # Check to see if the deployment actually happened
+      if response.code == 409
+        fatal "Deployment did not start; another deployment is in progress"
+        exit 1
+      end
+      
+      info "Polling for deployment state"
+      state = poll_for_deploy_state
+      case state
+      when :retry_exceeded
+        fatal "App failed to start on Marathon; cancelling deploy"
+        exit 1
+      when :complete
+        info "App is running on Marathon; deployment complete"
+      else
+        fatal "App is in unknown state on Marathon"
+        exit 1
+      end
+    end
+    
+    def deploy_or_update
+      if app_running?
+        debug "App is running in Marathon; performing a warm deploy"
+        prepare_for_warm_deploy
+        return @marathon_client.update(@name, marathon_json)
+      else
+        debug "App is not running in Marathon; performing a cold deploy"
+        prepare_for_cold_deploy
+        return @marathon_client.start(@name, marathon_json)
+      end
+    end
+    
+    # Poll Marathon to see if the deploy has completed for the
+    # given deployed version
+    def poll_for_deploy_state
+      debug "Entering deploy state polling"
+      while (not deployment_completed?) && (not retry_exceeded?)
+        if has_task_failures?
+          warn "Task failures have occurred during the deploy attempt - this deploy may not succeed"
+          sleep 1
+          increment_retry
+        else
+          debug "Deploy still in progress with no task failures; sleeping and retrying"
+          sleep 1
+          increment_retry
+        end
+      end
+      
+      # We bailed because we exceeded retry or the deploy completed, determine
+      # which of these states it is
+      deployment_completed? ? :complete : :retry_exceeded
+    end
+    
+    def deployment_completed?
+      @marathon_client.find_deployment_by_name(@name) == nil
+    end
+    
+    def retry_exceeded?
+      @retry_count == 10
+    end
+    
+    def increment_retry
+      @retry_count ||= 0
+      @retry_count = @retry_count + 1
+    end
+    
+    def has_task_failures?
+      app_config = @marathon_client.find(@name)
+      return false if app_config.parsed_response['app']['lastTaskFailure'].nil?
+      app_config.parsed_response['app']['lastTaskFailure']['version'] == @deploy_response['version']
+    end
+    
+    # A 'warm' deploy is one where the app is running in Marathon and 
+    # we're making changes to it. For each declared configuration property, 
+    # determine whether it will be always inserted into the remote configuration
+    # (:override) or not (:inherit). Think of :override as "Athlete is 
+    # authoritative for this property", and :inherit as "Marathon is
+    # authoritative for this property".
+    # The way this works in practice is we unset any instance variables
+    # that are specified as "inherit", so that when the Marathon JSON
+    # is generated by `to_marathon_json` they do not appear in the final
+    # deployment JSON.
+    def prepare_for_warm_deploy
+      @inherit_properties.each do |property|
+        debug "Property '#{property}' is specified as :inherit; not supplying to Marathon"
+        instance_variable_set("@#{property}", nil)
+      end
+    end
+    
+    # A 'cold' deploy is one where the app is not running in Marathon.
+    # We have to do additional validation to ensure we can deploy the app, since
+    # we don't have a set of valid parameters in Marathon.
+    def prepare_for_cold_deploy
+      errors = []
+      errors << "You must specify the parameter 'cpus'" unless @cpus
+      errors << "You must specify the parameter 'memory'" unless @memory
+      unless errors.empty?
+        raise ConfigurationInvalidException, @errors
+      end
+    end
+    
+    # Locate the linked build
+    def linked_build
+      @build_name ? Athlete::Build.builds[@build_name] : nil
+    end
+    
+    # Find the app if it's already in Marathon (if it's not there, we get nil)
+    def get_running_config
+      if @running_config
+        return @running_config
+      else
+        response = @marathon_client.find(@name)
+        @running_config = response.error? ? nil : response.parsed_response
+        debug "Retrieved running Marathon configuration: #{@running_config}"
+        return @running_config
+      end
+    end
+    
+    def app_running?
+      get_running_config != nil
+    end
+    
+    def marathon_json
+      json = {}
+      
+      json['id'] = @name
+      json['cmd'] = @command if @command
+      json['args'] = @arguments if @arguments
+      json['cpus'] = @cpus if @cpus
+      json['mem'] = @memory if @memory
+      json['env'] = @environment_variables if @environment_variables
+      json['instances'] = @instances if @instances
+      if @minimum_health_capacity
+        json['upgradeStrategy'] = {
+          'minimumHealthCapacity' => @minimum_health_capacity
+        }
+      end
+      
+      if @image_name || @build_name
+        image = @image_name || linked_build.final_image_name
+        json['container'] = {
+          'type' => 'DOCKER',
+          'docker' => {
+            'image' => image,
+            'network' => 'BRIDGE'
+          }
+        }
+      end
+      debug("Generated Marathon JSON: #{json.to_json}")
+      json
+    end
+    
+    def readable_output
+      lines = []
+      lines << "  Deployment name: #{@name}"
+      @@valid_properties.sort.each do |property|
+        next if property == 'name'
+        lines << sprintf("    %-26s: %s", property, instance_variable_get("@#{property}")) if instance_variable_get("@#{property}")
+      end
+      puts lines.join("\n")
+    end
+    
+  end
+end

data/lib/athlete/logging.rb

@@ -0,0 +1,34 @@
+module Athlete
+  module Logging
+    
+    @@logger = Logger.new(STDOUT)
+    @@logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{datetime} [#{severity}]: #{msg.to_s.chomp}\n"
+    end
+    
+    def loglevel(level)
+      @@logger.level = level
+    end
+    
+    def get_loglevel
+      @@logger.level
+    end
+    
+    def info(msg)
+      @@logger.info(msg)
+    end
+    
+    def warn(msg)
+      @@logger.warn(msg)
+    end
+    
+    def fatal(msg)
+      @@logger.fatal(msg)
+    end
+    
+    def debug(msg)
+      @@logger.debug(msg)
+    end
+    
+  end
+end

data/lib/athlete/utils.rb

@@ -0,0 +1,34 @@
+module Athlete
+  module Utils
+    
+    # A moderately decent way of dealing with running commands
+    # and coping with stdout/stderr
+    class Subprocess
+      extend Logging
+      def self.run(cmd, &block)
+        info "Running command '#{cmd}'"
+        log_command = "#{cmd.split(' ')[0]}"
+        # see: http://stackoverflow.com/a/1162850/83386
+        Open3.popen3(cmd) do |stdin, stdout, stderr, thread|
+          # read each stream from a new thread
+          { :out => stdout, :err => stderr }.each do |key, stream|
+            Thread.new do
+              until (line = stream.gets).nil? do
+                # yield the block depending on the stream
+                if key == :out
+                  debug("[#{log_command}] [stdout] #{line}") unless line.nil?
+                else
+                  debug("[#{log_command}] [stderr] #{line}") unless line.nil?
+                end
+              end
+            end
+          end
+  
+          thread.join # don't exit until the external process is done
+          return thread.value
+        end
+      end
+    end
+    
+  end
+end