marathon-scooter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a9e6da40cf705b812b2eda984cb2d7f11c7c7fe
+  data.tar.gz: 60b3b689dbded24a6133867de8c2382a9d57e798
+SHA512:
+  metadata.gz: b92136c7742d8935ce94dcd5b9a111926bffc2309041e2cada4580a636dbb7e69748a477b0013e3676b1ca2c07fe5b51799a1031426ad6b16879664458999056
+  data.tar.gz: 8806ead8554859080f7b660bda1c583548badfa3b5144590fa4db162200cbd7e0ca580ede6a96f46961cb7257211dfafee22d6531143fe09c2a7ee45a830e279

data/CHANGELOG.md

@@ -0,0 +1 @@
+## 0.1.0 -- Initial Public Release

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Yieldbot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,94 @@
+# Scooter
+
+A CLI for the Marathon Rest API, with some opinionated configuration management of Marathon jobs.
+
+## Installation
+
+````
+gem install marathon-scooter
+````
+
+## Usage
+
+To see the a complete set of global and command specific command line arguments you can use the following:
+
+`scooter --help`
+
+and
+
+`scooter COMMAND --help`
+
+## Commands
+
+### app
+
+This command retrieves the configuration for a given application id, including the option of a specific application version, and output as JSON.
+
+### clean
+
+This command will remove job configurations *FROM* Marathon that do not exist within a given directory.
+
+*Note: This command is destructive and requires an additional flag to execute the clean*
+
+### delete
+
+This command will delete the job configuration *FROM* Marathon for a given application id.
+
+*Note: This command is destructive and requires an additional flag to execute the delete*
+
+### export
+
+This command provides a method of exporting Marathon job configurations to given directory.  By default all jobs are exported, however, a regex can be provided to export a certain subset as needed.
+
+### help
+
+This command provides general usage information.
+
+### info
+
+This command retrieves basic Marathon and job configuration data and presents it to the user.
+
+### scale
+
+This command scales the number of instances of a given application.  Setting instances to 0 (zero) will suspend the application.
+
+### sync
+
+This command will sync the given application file or directory with the Marathon.  Marathon will update the application configuration if the application already exists, otherwise, it will createa a new application.
+
+### tidy
+
+This command will clean up the JSON for a given file or directory of files, removing any unnecessary configuration, and sorting the keys to reduce file differences when storing job configuration in Git.
+
+## Environment Variables
+
+Scooter provides the ability to set global options via environment variables for the following:
+
+SCOOTER_COLOR
+SCOOTER_MARATHON_HOST
+SCOOTER_MARATHON_USER
+SCOOTER_MARATHON_PASS
+SCOOTER_MARATHON_PROXY_HOST
+SCOOTER_MARATHON_PROXY_PORT
+SCOOTER_MARATHON_PROXY_USER
+SCOOTER_MARATHON_PROXY_PASS
+SCOOTER_VERBOSE
+
+## Examples
+
+### General
+
+The following command will retrieve general Marathon information.
+
+````
+scooter info
+````
+
+### Specific Marathon Host
+
+By default Scooter looks for Marathon on localhost and provides an option to specify what Marathon host to target:
+
+````
+scooter --marathon=https://somecluster.marathon.service.consul info
+````
+

data/bin/scooter

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# Exit from interupt
+Signal.trap('INT') { exit 1 }
+
+begin
+  # Load the library path
+  lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $LOAD_PATH.unshift(lib_path)
+
+  # Bring in the app
+  require 'scooter'
+
+  # Let the GLI do its thing
+  Kernel.exit!(Scooter::GLI.new.execute!)
+rescue => e
+  $stderr.puts e.inspect
+  $stderr.puts e.message
+  $stderr.puts e.backtrace.join("\n")
+  exit e.respond_to?(:status_code) ? e.status_code : 999
+end

data/lib/extensions/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def except(*blacklist)
+    self.reject {|key, value| blacklist.include?(key.to_s) }
+  end
+  
+  def only(*whitelist)
+    self.reject {|key, value| !whitelist.include?(key.to_s) }
+  end
+end

data/lib/extensions/marathon/app.rb

@@ -0,0 +1,83 @@
+require 'marathon/app'
+require 'json'
+
+::Marathon::App.class_eval do
+
+  # `jq 'keys'` used on a full configuration to quickly extract keys
+  CONFIG_KEYS = [
+    'acceptedResourceRoles',
+    'args',
+    'backoffFactor',
+    'backoffSeconds',
+    'cmd',
+    'constraints',
+    'container',
+    'cpus',
+    'dependencies',
+    'env',
+    'executor',
+    'healthChecks',
+    'id',
+    'instances',
+    'labels',
+    'maxLaunchDelaySeconds',
+    'mem',
+    'ports',
+    'requirePorts',
+    'upgradeStrategy',
+    'uris'
+  ]
+
+  def filtered_info
+    # Remove the all non-configuration keys
+    sort_hash(deep_stringify_keys(info).reject { |key, value| !CONFIG_KEYS.include?(key) })
+  end
+
+  def filtered_info_to_json
+    JSON.pretty_generate(filtered_info)
+  end
+
+  def info_to_json
+    JSON.pretty_generate(sort_hash(info))
+  end
+
+  def write_to_file(file)
+    File.open(file, 'w') do |f|
+      f.write(filtered_info_to_json)
+    end
+  end
+
+  private
+
+  def deep_stringify_keys(hash)
+    transform_hash(hash, :deep => true) {|hash, key, value|
+      hash[key.to_s] = value
+    }                               
+  end
+
+  def slice_hash(hash, *keys)
+    transform_hash(hash, :deep => false) {|hash, key, value|
+      hash[key] = value if keys.include?(key)
+    }
+  end
+
+  def sort_hash(h)
+    {}.tap do |h2|
+      h.sort.each do |k,v|
+        h2[k] = v.is_a?(Hash) ? sort_hash(v) : v
+      end
+    end
+  end
+
+  def transform_hash(original, options={}, &block)
+    original.inject({}){|result, (key,value)|
+      value = if (options[:deep] && Hash === value) 
+                transform_hash(value, options, &block)
+              else 
+                value
+              end
+      block.call(result,key,value)
+      result
+    }
+  end
+end

data/lib/scooter.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+# Third Party
+require 'marathon'
+
+# Internal
+
+require 'scooter/command'
+require 'scooter/exceptions'
+require 'scooter/gli'
+require 'scooter/ui'
+require 'scooter/version'
+
+# Commands
+
+require 'scooter/commands/app'
+require 'scooter/commands/clean'
+require 'scooter/commands/delete'
+require 'scooter/commands/export'
+require 'scooter/commands/info'
+require 'scooter/commands/scale'
+require 'scooter/commands/sync'
+require 'scooter/commands/tidy'
+
+# Extensions
+require 'extensions/hash'
+require 'extensions/marathon/app'
+
+module Scooter
+  class << self
+    attr_writer :ui
+  end
+
+  class << self
+    attr_reader :ui
+  end
+end

data/lib/scooter/command.rb

@@ -0,0 +1,26 @@
+module Scooter
+  class Command
+    attr_reader :global_options, :options
+
+    def initialize(global_options, options)
+      @global_options, @options = global_options, options
+    end
+
+    def run
+      fail Scooter::Exception, 'Base command has no implementation of `run`'
+    end
+
+    def name
+      self.class.name.split('::').last.downcase
+    end
+
+    private
+
+    #
+    # Class Methods
+    #
+  end
+
+  # Create the commands namespace
+  module Commands; end
+end

data/lib/scooter/commands/app.rb

@@ -0,0 +1,29 @@
+require 'scooter/command'
+
+module Scooter
+  module Commands
+    class App < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+
+        begin
+          if options['version']
+            app = ::Marathon::App.version(options['id'], options['name'])
+          else
+            app = ::Marathon::App.get(options['id'])
+          end
+
+          if options['json']
+            Scooter.ui.info(app.info_to_json)
+          else
+            Scooter.ui.info(app.to_pretty_s)
+          end
+        rescue ::Marathon::Error::NotFoundError => e
+          Scooter.ui.warn(e)
+        end
+        
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/clean.rb

@@ -0,0 +1,52 @@
+require 'scooter/command'
+
+module Scooter
+  module Commands
+    class Clean < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+
+        local_ids  = []
+        
+        # Build the list of files
+
+        files = Dir.glob("#{options['dir']}/*.json*")
+
+        # Build a list of app ids from the local configuration files
+        files.each do |f|
+          ext = File.extname(f).delete('.')
+
+          # Load the job configuration
+          begin
+            config = JSON.parse(IO.read(f))
+          rescue Exception => e
+            Scooter.ui.warning("Error parsing #{f}.   #{e}")
+            next
+          end
+
+          local_ids << config['id']
+        end
+
+        # Iterate a 
+        apps = ::Marathon::App.list
+        ::Marathon::App.list.each do |app|
+
+          next if local_ids.include? app.id
+
+          # If delete is flagged do the actual delete
+          if options['delete']
+
+            # Delete the app
+            ::Marathon::App.delete(app.id)
+
+            Scooter.ui.info("Job '#{app.id}' removed.")
+          else
+            Scooter.ui.info("[DRYRUN] Job '#{app.id}' removed.")
+          end
+        end
+        
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/delete.rb

@@ -0,0 +1,31 @@
+require 'scooter/command'
+
+module Scooter
+  module Commands
+    class Delete < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+
+        begin
+
+          app = ::Marathon::App.get(options['id'])
+          
+          # If delete is flagged do the actual delete
+          if options['delete']
+
+            # Delete the app
+            ::Marathon::App.delete(app.id)
+
+            Scooter.ui.info("Job '#{app.id}' removed.")
+          else
+            Scooter.ui.info("[DRYRUN] Job '#{app.id}' removed.")
+          end
+        rescue ::Marathon::Error::NotFoundError => e
+          Scooter.ui.warn(e)
+        end
+        
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/export.rb

@@ -0,0 +1,53 @@
+require 'scooter/command'
+
+module Scooter
+  module Commands
+    class Export < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+        
+        # Convert the argument to a regex
+        app_regex = Regexp.new options['regex']
+        
+        begin
+          # Iterate each of the configured apps
+          ::Marathon::App.list.each do |app|
+            if app.id =~ app_regex
+
+              # Deterine the suffix
+              suffix        = '.json'
+              action_suffix = ''
+              action_suffix += '.suspend' if app.instances == 0
+              
+              # Determine the destination file
+              dest_file         = ::File.join(options['dir'], "#{app.id}#{suffix}")
+              action_dest_file  = dest_file + action_suffix
+
+              Scooter.ui.info("Exporting `#{app.id}` to #{action_dest_file}")
+              
+              # Delete any files that are for this application
+              Dir.glob(dest_file + '*').each do |filename|
+                # Do not delete the file we are going to write to
+                next if filename == action_dest_file
+
+                Scooter.ui.warn("      Removing stale configuration: #{filename}")
+
+                # Delete the file
+                File.delete(filename)
+              end
+              
+              # Write the file
+              app.write_to_file(action_dest_file)
+            else
+              Scooter.ui.info("`#{app.id}` excluded by regex.")
+            end
+          end
+        rescue ::Marathon::Error::NotFoundError => e
+          Scooter.ui.warn(e)
+        end
+
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/info.rb

@@ -0,0 +1,33 @@
+require 'scooter/command'
+require 'colorize'
+
+module Scooter
+  module Commands
+    class Info < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+        Scooter.ui.announce('---- Marathon Configuration ----')
+        Scooter.ui.out("Name:              #{::Marathon.info['name']}")
+        Scooter.ui.out("Checkpoint:        #{::Marathon.info['marathon_config']['checkpoint']}")
+        Scooter.ui.out("High Availability: #{::Marathon.info['marathon_config']['ha'].to_s.green}")
+        Scooter.ui.out("Version:           #{::Marathon.info['version']}")
+        Scooter.ui.out
+        
+        apps = ::Marathon::App.list
+        if apps.length > 0
+          Scooter.ui.announce('---- Application Configuration ----')
+          ::Marathon::App.list.each do |app|
+            # Derive the colors for the various output
+            read_only_color = app.read_only ? :red : :light_green
+            
+            Scooter.ui.out("#{printf('%-25s', app.id)}  I:#{app.instances} C:#{app.cpus} M:#{app.mem} D:#{app.disk} RO:#{Scooter.ui.color(app.read_only.to_s,read_only_color)}")
+          end
+        else
+          Scooter.ui.warn('There are no applications configured.')
+        end
+
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/scale.rb

@@ -0,0 +1,27 @@
+require 'scooter/command'
+
+module Scooter
+  module Commands
+    class Scale < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+
+        begin
+          app = ::Marathon::App.get(options['id'])
+
+          if app.instances != options['instances']
+            Scooter.ui.info("Scaling '#{options['id']}' from #{app.instances} to #{options['instances']}...")
+            app.scale!(options['instances'], global_options['force'])
+          else
+            Scooter.ui.info("'#{options['id']}' instances already set to #{options['instances']}.")
+          end
+          
+        rescue ::Marathon::Error::NotFoundError => e
+          Scooter.ui.warn(e)
+        end
+        
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/sync.rb

@@ -0,0 +1,73 @@
+require 'scooter/command'
+require 'json'
+
+module Scooter
+  module Commands
+    class Sync < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+
+        # Build the list of files
+
+        files = options['dir'].nil? ? [options['file']]: Dir.glob("#{options['dir']}/*.json*")
+
+        # Process each of the files based on file extension
+        files.each do |f|
+          ext = File.extname(f).delete('.')
+
+          # Load the job configuration
+          begin
+            config = JSON.parse(IO.read(f))
+          rescue Exception => e
+            Scooter.ui.warning("Error parsing #{f}.   #{e}")
+            next
+          end
+
+          app_id = config['id']
+
+          case ext
+          when 'json'
+            begin
+              # Attempt to get the app from the server
+              app = ::Marathon::App.get(app_id)
+              #### TODO:  Need a way to compare the config from disk to config from marathon to see if an udpate is required
+              Scooter.ui.info("Updating job '#{app_id}'...")
+              app.change!(config, global_options['force'])
+            rescue ::Marathon::Error::NotFoundError => e
+              Scooter.ui.info("Creating new job '#{app_id}'...")
+              # If the app isnt found, this is a new app so create the app
+              ::Marathon::App.create(config)
+            end
+          when 'delete'
+            begin
+              # Attempt to get the app from the server
+              ::Marathon::App.get(app_id)
+              Scooter.ui.info("Removing job '#{app_id}'...")
+              ::Marathon::App.delete(app_id)
+            rescue ::Marathon::Error::NotFoundError => e
+              # This is a NO-OP
+            end
+          when 'suspend'
+            begin
+              # Attempt to get the app from the server
+              app = ::Marathon::App.get(app_id)
+
+              # Do nothing if instances is already zero
+              next if app.instances == 0
+
+              Scooter.ui.info("Suspending job '#{app_id}'...")
+
+              app.suspend!(global_options['force'])
+            rescue ::Marathon::Error::NotFoundError => e
+              # This is a NO-OP
+            end
+          else
+            Scooter.ui.warning("Unknown file extension for #{f}.  Ignorning file.")
+          end
+        end
+
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/commands/tidy.rb

@@ -0,0 +1,38 @@
+require 'scooter/command'
+
+module Scooter
+  module Commands
+    class Tidy < Scooter::Command
+      def run
+        Scooter.ui.verbose("Executing the `#{name}` command.")
+
+        # Build the list of files
+        files = options['dir'].nil? ? [options['file']]: Dir.glob("#{options['dir']}/*.json*")
+
+        # Process each of the files
+        files.each do |f|
+          ext = File.extname(f).delete('.')
+
+          Scooter.ui.info("Tidying configuration: #{f}")
+
+          begin
+            # Load the job configuration
+            config = JSON.parse(IO.read(f))
+
+            # Create a local app object
+            app = Marathon::App.new(config)
+
+            # Write out the app
+            app.write_to_file(f)
+
+          rescue Exception => e
+            Scooter.ui.warning("Error parsing #{f}.   #{e}")
+            next
+          end
+        end
+
+        Scooter.ui.verbose("Execution of `#{name}` command has completed.")
+      end
+    end
+  end
+end

data/lib/scooter/exceptions.rb

@@ -0,0 +1 @@
+class Scooter::Exception < RuntimeError; end

data/lib/scooter/gli.rb

@@ -0,0 +1,267 @@
+# encoding: utf-8
+require 'gli'
+require 'scooter'
+
+module Scooter
+  # The GLI is the primary entry point into the app
+  class GLI
+    include ::GLI::App
+
+    APP_ID_REGEX = /^[a-zA-z0-9\.\-\/]+$/
+
+    def initialize
+      program_desc 'Opinionated synchronization of Marathon jobs from JSON files.'
+      version Scooter::Version::STRING.dup
+
+      # Global Accepts
+
+      accept(Fixnum) do |string|
+        string.to_i
+      end
+
+      # Global Options
+
+      desc 'Enable colorized output'
+      switch 'color', default_value: ENV['SCOOTER_COLOR'] || true
+
+      desc 'Marathon Host'
+      flag 'marathon', default_value: ENV['SCOOTER_MARATHON_HOST'] || 'http://localhost:8080'
+
+      desc 'Marathon HTTP User'
+      flag 'user', default_value: ENV['SCOOTER_MARATHON_USER'] || nil
+
+      desc 'Marathon HTTP Password'
+      flag 'pass', default_value: ENV['SCOOTER_MARATHON_PASS'] || nil
+
+      desc 'HTTP Proxy Host'
+      flag 'proxy-host', default_value: ENV['SCOOTER_MARATHON_PROXY_HOST'] || nil
+
+      desc 'HTTP Proxy Port'
+      flag 'proxy-port', default_value: ENV['SCOOTER_MARATHON_PROXY_PORT'] || nil
+
+      desc 'HTTP Proxy User'
+      flag 'proxy-user', default_value: ENV['SCOOTER_MARATHON_PROXY_USER'] || nil
+
+      desc 'HTTP Proxy Password'
+      flag 'proxy-pass', default_value: ENV['SCOOTER_MARATHON_PROXY_PASS'] || nil
+
+      desc 'Enable verbose output'
+      switch 'verbose', default_value: ENV['SCOOTER_VERBOSE'] || false
+
+      desc 'Attempt to force the desired operation'
+      switch 'force', default_value: false
+      
+      # Pre command execution
+
+      pre do |global_options, _command, _options, _args|
+
+        config = {}
+
+        # Basic HTTP Information
+        config[:username] = global_options[:user]
+        config[:password] = global_options[:pass]
+
+        # Basic SSL information
+        config[:verify]   = false
+
+        # Basic Proxy information
+        config[:http_proxyaddr] = global_options['proxy-host']
+        config[:http_proxyport] = global_options['proxy-port']
+        config[:http_proxyuser] = global_options['proxy-user']
+        config[:http_proxypass] = global_options['proxy-pass']
+        
+        # Set the Marathon credentials if given
+        ::Marathon.options = config 
+
+        # Set the Marathon URL
+        ::Marathon.url = global_options[:marathon]
+
+        # Setup the UI for the app -- let it use global_options
+        Scooter.ui = Scooter::UI.new($stdout, $stderr, $stdin, global_options)
+      end
+
+      # Post command execution
+
+      post do |_global_options, _command, _options, _args|
+        # Flush the output streams just in case there is anything left
+        $stdout.flush
+        $stderr.flush
+      end
+
+      # Error handling
+
+      on_error do |e|
+        #$stderr.puts e.inspect
+        $stderr.puts e.message
+        $stderr.puts e.backtrace
+        true
+      end
+      
+      # Commands
+
+      desc 'Retrieve the configuration for the given app.'
+      command :app do |c|
+
+        c.desc 'Application ID'
+        c.flag [:id], required: true, must_match: APP_ID_REGEX
+
+        c.desc 'Application Version'
+        c.flag [:version], default: nil, type: Fixnum
+
+        c.desc 'Enable JSON output'
+        c.switch [:json], default_value: false
+
+        c.action do |global_options, options, _args|
+          Scooter::Commands::App.new(global_options, options).run
+        end
+      end
+
+      desc 'Remove job configurations from Marathon that do not exist in the given directory.'
+      command :clean do |c|
+        
+        c.desc 'A job configuration directory'
+        c.flag [:dir, :directory]
+
+        c.desc 'Perform the actual deletion of the jobs in Marathon'
+        c.switch [:delete], default_value: false
+
+        c.action do |global_options, options, _args|
+
+          # Verify the source directory exists
+          if options['dir'] && !File.directory?(options['dir'])
+            Scooter.ui.error("Directory #{options['dir']} does not exist.  Exiting.")
+            Scooter.ui.exit(1)
+          end
+
+          Scooter::Commands::Clean.new(global_options, options).run
+        end
+      end
+
+      desc 'Delete the job configuration from Marathon for the given app.'
+      command :delete do |c|
+
+        c.desc 'Application ID'
+        c.flag [:id], required: true, must_match: APP_ID_REGEX
+
+        c.desc 'Perform the actual deletion of the jobs in Marathon'
+        c.switch [:delete], default_value: false
+
+        c.action do |global_options, options, _args|
+          Scooter::Commands::Delete.new(global_options, options).run
+        end
+      end
+      
+      desc 'Export the jobs configurations whose name matches the given regex.'
+      command :export do |c|
+
+        c.desc 'A job configuration directory'
+        c.flag [:dir, :directory]
+
+        c.desc 'Marathon Application Regex. (Note: nil implies `.*`)'
+        c.flag [:regex], default_value: /.*/
+
+        c.action do |global_options, options, _args|
+
+          # Verify the target directory exists
+          if options['dir'] && !File.directory?(options['dir'])
+            Scooter.ui.error("Directory #{options['dir']} does not exist.  Exiting.")
+            Scooter.ui.exit(1)
+          end
+
+          Scooter::Commands::Export.new(global_options, options).run
+        end
+      end
+
+      desc 'Retrieve Marathon configuration information for the given credentials.'
+      command :info do |c|
+        c.action do |global_options, options, _args|
+          Scooter::Commands::Info.new(global_options, options).run
+        end
+      end
+
+      desc 'Scale the number of instances of a given app.'
+      command :scale do |c|
+
+        c.desc 'Application ID'
+        c.flag [:id], required: true, must_match: APP_ID_REGEX
+
+        c.desc 'Specify the number of instances of the application'
+        c.flag [:instances], required: true, type: Fixnum
+
+        c.action do |global_options, options, _args|
+          Scooter::Commands::Scale.new(global_options, options).run
+        end
+      end
+
+      desc 'Synchronize the given job configuration(s) with Marathon.'
+      command :sync do |c|
+
+        c.desc 'A job configuration directory'
+        c.flag [:dir, :directory]
+
+        c.desc 'A job configuration file'
+        c.flag [:file]
+
+        c.action do |global_options, options, _args|
+          Scooter.ui.warn('Both `dir` and `file` options given.  Ignoring `file`.') if !options['dir'].nil? && !options['file'].nil?
+          
+          if options['dir'].nil? && options['file'].nil?
+            Scooter.ui.error('Either `dir` and `file` must be used.  Exiting.')
+            Scooter.ui.exit(1)
+          end
+
+          # Verify the file exists
+          if options['file'] && !File.exists?(options['file'])
+            Scooter.ui.error("File #{options['file']} does not exist.  Exiting.")
+            Scooter.ui.exit(1)
+          end
+
+          # Verify the directory exists
+          if options['dir'] && !File.directory?(options['dir'])
+            Scooter.ui.error("Directory #{options['dir']} does not exist.  Exiting.")
+            Scooter.ui.exit(1)
+          end
+
+          Scooter::Commands::Sync.new(global_options, options).run
+        end
+      end
+
+      desc 'Tidy the JSON format for the given job configuration(s).'
+      command :tidy do |c|
+
+        c.desc 'A job configuration directory'
+        c.flag [:dir, :directory]
+
+        c.desc 'A job configuration file'
+        c.flag [:file]
+
+        c.action do |global_options, options, _args|
+          Scooter.ui.warn('Both `dir` and `file` options given.  Ignoring `file`.') if !options['dir'].nil? && !options['file'].nil?
+          
+          if options['dir'].nil? && options['file'].nil?
+            Scooter.ui.error('Either `dir` and `file` must be used.  Exiting.')
+            Scooter.ui.exit(1)
+          end
+
+          # Verify the file exists
+          if options['file'] && !File.exists?(options['file'])
+            Scooter.ui.error("File #{options['file']} does not exist.  Exiting.")
+            Scooter.ui.exit(1)
+          end
+
+          # Verify the directory exists
+          if options['dir'] && !File.directory?(options['dir'])
+            Scooter.ui.error("Directory #{options['dir']} does not exist.  Exiting.")
+            Scooter.ui.exit(1)
+          end
+
+          Scooter::Commands::Tidy.new(global_options, options).run
+        end
+      end
+    end
+
+    def execute!
+      run(ARGV)
+    end
+  end
+end

data/lib/scooter/ui.rb

@@ -0,0 +1,88 @@
+require 'rbconfig'
+require 'colorize'
+require 'time'
+
+module Scooter
+  class UI
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :stdin
+    attr_reader :options
+
+    def initialize(stdout, stderr, stdin, options = {})
+      @stdout, @stderr, @stdin, @options = stdout, stderr, stdin, options
+
+      # Flush output immediately
+      stdout.sync = true
+      stderr.sync = true
+    end
+
+    def announce(message)
+      out("#{color(message, :green, :bold)} ")
+    end
+
+    def color(string, color = :light_green, style = :default)
+      if color?
+        string.colorize(color: color, mode: style)
+      else
+        string
+      end
+    end
+
+    def err(message)
+      stderr.puts("#{message}") unless @options[:quiet]
+    end
+
+    def error(message)
+      err("#{color('[ERROR]', :red, :bold)} #{message}")
+    end
+
+    def exit(code)
+      Kernel.exit!(code)
+    end
+
+    def fatal(message)
+      err("#{color('[FATAL]', :red, :bold)} #{message}")
+    end
+
+    def info(message='',color = :light_green)
+      out(color(message,color))
+    end
+
+    def out(message='')
+      stdout.puts("#{message}") unless @options[:quiet]
+    end
+
+    def verbose(message)
+      out(color(message)) if @options[:verbose]
+    end
+
+    def warn(message)
+      err("#{color('[WARNING]', :yellow, :bold)} #{message}")
+    end
+
+    private
+
+    def color?
+      @options[:color] && stdout.tty? && os != :windows
+    end
+
+    def os
+      @os ||= (
+        host_os = RbConfig::CONFIG['host_os']
+        case host_os
+        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+          :windows
+        when /darwin|mac os/
+          :macosx
+        when /linux/
+          :linux
+        when /solaris|bsd/
+          :unix
+        else
+          :other
+        end
+      )
+    end
+  end
+end

data/lib/scooter/version.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+# encoding: utf-8
+module Scooter
+  # This defines the version of the gem
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+
+    NAME   = 'Scooter'
+    BANNER = "#{NAME} v%s"
+
+    module_function
+
+    def version
+      format(BANNER, STRING)
+    end
+
+    def json_version
+      {
+        'version' => STRING
+      }.to_json
+    end
+  end
+end

data/spec/scooter_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Scooter do
+  it 'has a version number' do
+    expect(Scooter::Version::STRING.dup).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'scooter'

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: marathon-scooter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yieldbot
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+- !ruby/object:Gem::Dependency
+  name: marathon-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.26.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.26.1
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Opinionated synchronization of Marathon jobs from JSON files.
+email:
+- devops@yieldbot.com
+executables:
+- scooter
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/scooter
+- lib/extensions/hash.rb
+- lib/extensions/marathon/app.rb
+- lib/scooter/command.rb
+- lib/scooter/commands/app.rb
+- lib/scooter/commands/clean.rb
+- lib/scooter/commands/delete.rb
+- lib/scooter/commands/export.rb
+- lib/scooter/commands/info.rb
+- lib/scooter/commands/scale.rb
+- lib/scooter/commands/sync.rb
+- lib/scooter/commands/tidy.rb
+- lib/scooter/exceptions.rb
+- lib/scooter/gli.rb
+- lib/scooter/ui.rb
+- lib/scooter/version.rb
+- lib/scooter.rb
+- spec/scooter_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- CHANGELOG.md
+- README.md
+homepage: https://github.com/yieldbot/scooter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Opinionated synchronization of Marathon jobs from JSON files.
+test_files:
+- spec/scooter_spec.rb
+- spec/spec_helper.rb
+has_rdoc: