centurion 1.0.6

data/.gitignore

@@ -0,0 +1,10 @@
+.bundle
+.config
+coverage/
+*.gem
+Gemfile.lock
+pkg/
+*.rbc
+*.swp
+*.swo
+tmp/

data/CONTRIBUTORS.md

@@ -0,0 +1,42 @@
+Contributors
+============
+
+Post-release
+------------
+
+Your name could be here!
+
+Pre-release
+-----------
+
+A lot of work was done on Centurion before its public release. Those statistics
+are not reflected in the current history. Many of the ideas for the project
+originally came from Nic Benders and the Insights team at New Relic.  At the
+time of public release, here's how the contributors list looked:
+
+ * 343 commits
+ * 12 branches
+ * 0 releases
+ * 19 contributors
+
+```
+kmatthias 97 commits / 3,870 ++ / 3,658 --
+nic       36 commits / 1,481 ++ / 971 --
+bryan     15 commits / 355 ++ / 236 --
+andrew    47 commits / 326 ++ / 55 --
+jdearing  31 commits / 300 ++ / 152 --
+jon       17 commits / 242 ++ / 26 --
+dkerr      7 commits / 212 ++ / 6 --
+aaron      2 commits / 111 ++ / 23 --
+bkayser    7 commits / 106 ++ / 74 --
+jlepper    7 commits / 96 ++ / 46 --
+didip      5 commits / 93 ++ / 18 --
+dcelis     4 commits / 66 ++ / 12 --
+jthurman   2 commits / 40 ++ / 6 --
+amjith     7 commits / 38 ++ / 22 --
+brett      1 commit  / 26 ++ / 0 --
+merlyn     2 commits / 15 ++ / 2 --
+jonathan   1 commit  / 13 ++ / 10 --
+ehyland    5 commits / 6 ++ / 2 --
+franky     1 commit  / 2 ++ / 0 --
+```

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://WiPJLMV2QdeRQ2XRu3Yt@gem.fury.io/newrelic/'
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in centurion.gemspec
+gemspec
+gem 'rspec_junit_formatter', group: "test"

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 New Relic, Inc. All Rights Reserved.
+
+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,239 @@
+Centurion
+=========
+
+A deployment tool for Docker. Takes containers from a Docker registry and runs
+them on a fleet of hosts with the correct environment variables, host mappings,
+and port mappings. Supports rolling deployments out of the box, and makes it
+easy to ship applications to Docker servers.
+
+We're using it to run our production infrastructure.
+
+Centurion works in a two part deployment process where the build process ships
+a container to the registry, and Centurion ships containers from the registry
+to the Docker fleet. Registry support is handled by the Docker command line
+tools directly so you can use anything they currently support via the normal
+registry mechanism.
+
+If you haven't been using a registry, you should read up on how to do that
+before trying to deploy anything with Centurion.  Docker, Inc [provide
+repositories](https://index.docker.io/), including the main public repository.
+Alternatively, you can [host your
+own](https://github.com/dotcloud/docker-registry), or
+[Quay.io](https://quay.io) is another commercial option.
+
+Status
+------
+
+This project is under active development! The initial release on GitHub contains
+one roll-up commit of all our internal code. But all internal development will
+now be on public GitHub. See the CONTRIBUTORS file for the contributors to the
+original internal project.
+
+Installation
+------------
+
+Centurion is a Ruby gem. It assumes that you have a working, modern-ish Ruby
+(1.9.3 or higher). On Ubuntu 12.04 you can install this with the `ruby-1.9.1`
+system package, for example. On OSX this is best accomplished via `rbenv` and
+`ruby-build` which can be installed with [Homebrew](http://brew.sh/) or from 
+[GitHub](https://github.com/sstephenson/rbenv).
+
+Once you have a running, modern Ruby, you simply:
+
+```
+$ gem install centurion
+```
+
+With rbenv you will now need to do an `rbenv rehash` and the commands should
+be available. With a non-rbenv install, assuming the gem dir is in your path,
+the commands should just work now.
+
+Configuration
+-------------
+
+Centurion expects to find configuration tasks in the current working directory.
+Soon it will also support reading configuration from etcd.
+
+We recommend putting all your configuration for multiple applications into a
+single repo rather than spreading it around by project. This allows a central
+choke point on configuration changes between applications and tends to work
+well with the hand-off in many organizations between the build and deploy
+steps. If you only have one application, or don't need this you can
+decentralize the config into each repo.
+
+It will look for configuration files in either `./config/centurion` or `.`.
+
+The pattern at New Relic is to have a configs repo with a `Gemfile` that
+sources the Centurion gem. If you want Centurion to set up the structure for
+you and to create a sample config, you can simply run `centurionize` once you
+have the Ruby Gem installed.
+
+Centurion ships with a simple scaffolding tool that will setup a new config repo for
+you, as well as scaffold individual project configs. Here's how you run it:
+
+```bash
+$ centurionize -p <your_project>
+```
+
+`centurionize` relies on Bundler being installed already. Running the command
+will have the following effects:
+
+ * Ensure that a `config/centurion` directory exists
+ * Scaffold an example config for your project (you can specify the registry)
+ * Ensure that a Gemfile is present
+ * Ensure that Centurion is in the Gemfile (if absent it just appends it)
+
+Any time you add a new project you can scaffold it in the same manner even
+in the same repo.
+
+###Writing configs
+
+If you used `centurionize` you will have a base config scaffolded for you.
+But you'll still need to specify all of your configuration.
+
+Configs are in the form of a Rake task that uses a built-in DSL to make them
+easy to write. Here's a sample config for a project called "radio-radio" that
+would go into `config/centurion/radio-radio.rake`:
+
+```ruby
+namespace :environment do
+  task :common do
+    set :image, 'example.com/newrelic/radio-radio'
+    host 'docker-server-1.example.com'
+	host 'docker-server-2.example.com'
+  end
+
+  desc 'Staging environment'
+  task :staging => :common do
+	set_current_environment(:staging)
+	env_var YOUR_ENV: 'staging'
+	env_var MY_DB: 'radio-db.example.com'
+    host_port 10234, container_port: 9292
+    host_port 10235, container_port: 9293
+	hot_volume '/mnt/volume1', container_volume: '/mnt/volume2'
+  end
+
+  desc 'Production environment'
+  task :production => :common do
+	set_current_environment(:production)
+	env_var YOUR_ENV: 'production'
+	env_var MY_DB: 'radio-db-prod.example.com'
+    host_port 22234, container_port: 9292
+    host_port 23235, container_port: 9293
+  end
+end
+```
+
+This sets up a staging and production environment and defines a `common` task
+that will be run in either case. Note the dependency call in the task
+definition for the `production` and `staging` tasks.  Additionally, it
+defines some host ports to map and sets which servers to deploy to. Some
+configuration will provided to the containers at startup time, in the form of
+environment variables.
+
+All of the DSL items (`host_port`, `host_volume`, `env_var`, `host`) can be
+specified more than once and will append to the configuration.
+
+Deploying
+---------
+
+Centurion supports a number of tasks out of the box that make working with
+distributed containers easy.  Here are some examples:
+
+###Do a rolling deployment to a fleet of Docker servers
+
+A rolling deployment will stop and start each container one at a time to make
+sure that the application stays available from the viewpoint of the load
+balancer.  Currently assumes a valid response in the 200 range on
+`/status/check` by default. This is configurable by adding
+`set(:status_endpoint, '/somewhere')` in your config.
+
+````bash
+$ bundle exec centurion -p radio-radio -e staging -a rolling_deploy
+````
+
+###Deploy a project to a fleet of Docker servers
+
+This will hard stop, then start containers on all the specified hosts. This
+is not recommended for apps where one endpoint needs to be available at all
+times.
+
+````bash
+$ bundle exec centurion -p radio-radio -e staging -a deploy
+````
+
+###Deploy a bash console on a host
+
+This will give you a command line shell with all of your existing environment
+passed to the container. The `CMD` from the `Dockerfile` will be replaced
+with `/bin/bash`. It will use the first host from the host list.
+
+````bash
+$ bundle exec centurion -p radio-radio -e staging -a deploy_console
+````
+
+###List all the tags running on your servers for a particular project
+
+Returns a nicely-formatted list of all the current tags and which machines they
+are running on. Gives a unique list of tags across all hosts as well.  This is
+useful for validating the state of the deployment in the case where something
+goes wrong mid-deploy.
+
+```bash
+$ bundle exec centurion -p radio-radio -e staging -a list:running_container_tags
+```
+
+###List all the containers currently running for this project
+
+Returns a (as yet not very nicely formatted) list of all the containers for
+this project on each of the servers from the config.
+
+```bash
+$ bundle exec centurion -p radio-radio -e staging -a list:running_containers
+```
+
+###List registry containers
+
+Returns a list of all the containers for this project in the registry.
+
+````bash
+$ bundle exec centurion -p radio-radio -e staging -a list
+````
+
+Future Additions
+----------------
+
+We're currently looking at the following feature additions:
+
+ * [etcd](https://github.com/coreos/etcd) integration for configs and discovery
+ * Add the ability to show all the available tasks on the command line
+ * Certificate authentication
+ * Customized tasks
+ * Dynamic host allocation to a pool of servers
+
+Contributions
+-------------
+
+Contributions are more than welcome. Bug reports with specific reproduction
+steps are great. If you have a code contribution you'd like to make, open a
+pull request with suggested code.
+
+Pull requests should:
+
+ * Clearly state their intent in the title
+ * Have a description that explains the need for the changes
+ * Include tests!
+ * Not break the public API
+
+If you are simply looking to contribute to the project, taking on one of the
+items in the "Future Additions" section above would be a great place to start.
+Ping us to let us know you're working on it by opening a GitHub Issue on the
+project.
+
+By contributing to this project you agree that you are granting New Relic a
+non-exclusive, non-revokable, no-cost license to use the code, algorithms,
+patents, and ideas in that code in our products if we so choose. You also agree
+the code is provided as-is and you provide no warranties as to its fitness or
+correctness for any purpose
+
+Copyright (c) 2014 New Relic, Inc. All rights reserved.

data/Rakefile

@@ -0,0 +1,15 @@
+$: << File.expand_path("lib")
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w[--color --format=documentation]
+    t.pattern = "spec/**/*_spec.rb"
+  end
+
+  task :default => [:spec]
+rescue LoadError
+  # don't generate Rspec tasks if we don't have it installed
+end

data/bin/centurion

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require_relative '../lib/centurion'
+require 'capistrano_dsl'
+
+self.extend Capistrano::DSL
+self.extend Centurion::DeployDSL
+self.extend Centurion::Logging
+
+#
+# Initialize Rake engine
+#
+require 'rake'
+Rake.application.options.trace = true
+
+task_dir = File.expand_path(File.join(File.dirname(__FILE__), *%w{.. lib tasks}))
+Dir.glob(File.join(task_dir, '*.rake')).each { |file| load file }
+
+possible_environments = %w[development integration staging production local_integration]
+def possible_environments.to_s
+  join(', ').sub(/, (\w+)$/, ', or \1')
+end
+
+#
+# Trollup option setup
+#
+require 'trollop'
+
+opts = Trollop::options do
+  opt :project,     'project (dirac, rubicon...)',                 type: String, required: true,  short: '-p'
+  opt :environment, "environment (#{possible_environments})",      type: String, required: true,  short: '-e'
+  opt :action,      'action (deploy, list...)',                    type: String, default: 'list', short: '-a'
+  opt :image,       'image (analytics/rubicon...)',                type: String, required: false, short: '-i'
+  opt :tag,         'tag (latest...)',                             type: String, required: false, short: '-t'
+  opt :hosts,       'hosts, comma separated',                      type: String, required: false, short: '-h'
+  opt :docker_path, 'path to docker executable (default: docker)', type: String, default: 'docker', short: '-d'
+end
+
+unless possible_environments.include?(opts[:environment])
+  Trollop::die :environment, "is unknown; must be #{possible_environments}"
+end
+
+set_current_environment(opts[:environment].to_sym)
+set :project, opts[:project]
+set :environment, opts[:environment]
+
+# Load the per-project config and execute the task for the current environment
+projects_dir = File.join(Dir.getwd(), 'config', 'centurion')
+config_file  = "#{opts[:project]}.rake"
+if File.exists?(File.join(projects_dir, config_file))
+  load File.join(File.join(projects_dir, config_file))
+elsif File.exists?(config_file)
+  load config_file
+else
+  raise "Can't find '#{config_file}'!"
+end
+invoke("environment:#{opts[:environment]}")
+
+# Override the config with command line values if given
+set :image, opts[:image] if opts[:image]
+set :tag,   opts[:tag] if opts[:tag]
+set :hosts, opts[:hosts].split(",") if opts[:hosts]
+
+# Default tag should be "latest"
+set :tag, 'latest' unless any?(:tag)
+
+# Specify a path to docker executable
+set :docker_path, opts[:docker_path]
+
+invoke(opts[:action])

data/bin/centurionize

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'trollop'
+
+opts = Trollop::options do
+  opt :project,       'The short name (no spaces) of the project to scaffold', required: true, type: String
+  opt :registry_base, 'The base url for your registry (ex: example.com/yourcompany/) slash terminated', default: ''
+  opt :centurion_dir, 'The base dir for centurion configs', default: File.join(Dir.getwd, 'config', 'centurion')
+end
+
+project_file  = File.join(opts[:centurion_dir], "#{opts[:project]}.rake")
+
+unless Dir.exists?(opts[:centurion_dir])
+  puts "Creating #{opts[:centurion_dir]}"
+  FileUtils.mkdir_p(opts[:centurion_dir])
+end
+
+unless File.exists?(project_file)
+  puts "Writing example config to #{project_file}"
+  File.write(project_file, <<-EOS.gsub(/^\s{4}/, ''))
+    namespace :environment do
+      task :common do
+        set :image, '#{opts[:registry_base]}#{opts[:project]}'
+      end
+    
+      desc 'Staging environment'
+      task :staging => :common do
+        set_current_environment(:staging)
+        #env_var YOUR_ENV: 'staging'
+        #host_port 10234, container_port: 9292
+        #host 'docker-server-staging-1.example.com'
+        #host 'docker-server-staging-2.example.com'
+      end
+    
+      desc 'Production environment'
+      task :production => :common do
+        set_current_environment(:production)
+        #env_var YOUR_ENV: 'production'
+        #host_port 23235, container_port: 9293
+        #host 'docker-server-prod-1.example.com'
+        #host 'docker-server-prod-2.example.com'
+        #host_volume '/mnt/volume1', container_volume: '/mnt/volume1'
+      end
+    end
+  EOS
+end
+
+gemfile = File.join(opts[:centurion_dir], *%w{.. .. Gemfile})
+unless File.exists?(gemfile)
+  raise "Error creating Gemfile: $!" unless system("bash -c 'cd #{File.dirname(gemfile)} && bundle init'")
+end
+
+unless File.read(gemfile) =~ /centurion/s
+  puts 'Adding Centurion to the Gemfile'
+  File.open(gemfile, 'a') { |f| f << "gem 'centurion'" }
+  puts "\n\nRemember to run `bundle install` before running Centurion\n\n"
+end
+
+puts 'Done!'