freighter 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86abd16d687a7906bc20e78b1e69a23f2e93b44b
-  data.tar.gz: 1ea374580cf78e8364c54736e0cafc32c39a5d22
+  metadata.gz: af0c274acce168e3b23f92161069ddc4271fe463
+  data.tar.gz: 20ef8715cd51bb1dae81d921e8029d2653f045e1
 SHA512:
-  metadata.gz: e3d16301fe59fe48e5f8be7e28566f44703840a914908d47c927d337750dbb2058c91d5cdbb305b8eaaf5b27e64ded5079b835cf14796a524cd00155b2978cbf
-  data.tar.gz: e38f3ae9f03470365b70042d6f5a95b0f7936cb5a6d535f11a78b8b602779637e5502b6715a8e34b0d692b56bbfd9fb1ca7c7f9b11c93b4b81de69f74994408d
+  metadata.gz: b759d8a9dcfe91c6c9d03eaacb1662e084eb556fc26b0ea096c96bd7f8c06cfd97e7dfb6d18d9f19425b9364f51bdc8888ac63b8cdfca6fe9d46f29860a9d549
+  data.tar.gz: 6dee9418ec37852e3c8a925cb78dbc68d11146d635137f9a0f7f5f1482224d9dc54e9fb7188b0ae795823fe8e7877ceac49a4836ea4e3e0b729ae4aef569e8f7

data/.gitignore

@@ -12,3 +12,5 @@
 *.o
 *.a
 mkmf.log
+
+/config/freighter.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -4,3 +4,11 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'net-ssh'
+gem 'docker-api'
+
+group :test do
+  gem 'rspec'
+  gem 'vcr'
+  gem 'pry'
+  gem 'pry-nav'
+end

data/README.md

@@ -1,28 +1,95 @@
-# This gem is not ready yet. Just a gem stub at this point.
-
 # Freighter
 
-TODO: Write a gem description
+Freighter's goal is to make it easy to deploy docker containers over ssh. Freighter uses one YAML file to describe the environments, servers, images, and containers in your environment.
+
+Freighter goals:
+* Simple docker container deployment
+* Straight forward configuration
+* Users new to freighter should be able to deploy in minutes
+* Minimal server-side configuration
+* Fast and reliable
 
 ## Installation
+Freighter is a ruby gem and requires ruby 1.9 or higher.
 
-Add this line to your application's Gemfile:
+    gem install freighter
 
-```ruby
-gem 'freighter'
+## Configuration
+
+After freighter is installed, run the configuration installer.
+```
+freighter configure
 ```
+This copies an example template of a YAML configuration file into ./config/freighter.yml
 
-And then execute:
+### Docker REST API
+
+The way that freighter does not require that users have sudo access on the hosts it deploys to is that it interacts with the docker rest api running on the hosts. This means that docker must be configured to expose its REST API on each host.
+
+```
+echo 'DOCKER_OPTS="-H tcp://127.0.0.1:2375 -H unix:///var/run/docker.sock"' | sudo cat >> /etc/default/docker
+```
 
-    $ bundle
+The docker service, on the host(s), will need to be restarted.
 
-Or install it yourself as:
+Running the docker REST API this way should be secure since all communication to the API is over an SSH tunnel, and the REST API is only available locally on the host.
 
-    $ gem install freighter
+### Authentication
+
+Currently, this gem supports pulling images from hub.docker.com. This means that you must authenticate. 
+It is not recommended to store your personal authentication credentials in freighter.yml since that file 
+should be added to source control. Freighter needs the following environment variables set on your local machine:
+
+* DOCKER_HUB_USER_NAME
+* DOCKER_HUB_PASSWORD
+* DOCKER_HUB_EMAIL
+
+A recommendation would be to create a file only accessible to your machine's user account that defines these environment variables.
+
+```shell
+export DOCKER_HUB_USER_NAME=<yourDockerHubUserName>
+export DOCKER_HUB_PASSWORD=<yourDockerHubPassword>
+export DOCKER_HUB_EMAIL=<yourDockerHubEmail>
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+For quick reference:
+```
+freighter --help
+```
+
+Example of how to deploy:
+```
+freighter -e staging --all deloy
+```
+
+If you want to deploy one app:
+```
+freighter -e staging --app my_app deploy
+```
+
+The apps are defined in freighter.yml.
+
+## freighter.yml
+
+When you run `freighter configure` it will copy an example freighter.yml file that you can use as a template. The structure of the YAML file is important. More documentation on configuration to come.
+
+## Fun facts
+
+If you find yourself in a pickle of not being able to Ctrl+c (interupt) the command. Ctrl+z (suspend) the process and the kill the pid with `kill -6 <pid>`. I'll try to fix it so that this scenario is more avoidable.
+
+# Status
+
+Needed:
+* Needs more testing with more complex scenarios
+
+Nice to haves:
+* Container linking options
+* Volume mounting options
+* Container cleanup
+
+Freighter is currently deploying quickly and reliably as far as I can tell.
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,12 @@
 require "bundler/gem_tasks"
 
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end
+

data/bin/freighter

@@ -2,45 +2,84 @@
 
 require 'optparse'
 require 'bundler/setup'
-require 'ostruct'
 require 'freighter'
 require 'pry'
 
-@options = OpenStruct.new
+options = Freighter.options
 
 if defined?(Rails)
-  @options.config_path = "#{Rails.root}/config/freighter.yml" 
+  options.config_path = "#{Rails.root}/config/freighter.yml" 
 else
-  @options.config_path = "./config/freighter.yml" 
+  options.config_path = "./config/freighter.yml" 
 end
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: freigter [options] (deploy)"
+  opts.banner = "Usage: freigter [options] (deploy|configure|verify-config)"
 
-  opts.on('-v', '--verbose', 'verbose logging') do |v|
-    @options.verbose = true
+  opts.on('-e ENV', 'environment * required') do |env|
+    options.environment = env
   end
 
-  opts.on('-c', '--config', 'path to yml config') do |opt|
+  opts.on('-v', '--verbose', 'verbose logging') do
+    options.verbose = true
+  end
+
+  opts.on('-c', '--config PATH', 'path to yml config. Default is ./config/freighter.yml') do |opt|
     if opt
-      @options.config_path = opt
+      options.config_path = opt
     elsif defiend?(Rails) && Rails.root
-      @options.config_path = "#{Rails.root}/config/freighter.yml"
+      options.config_path = "#{Rails.root}/config/freighter.yml"
     end
   end
-end.parse!
 
-logger = Freighter::Logger.new(@options)
+  opts.on('-a', '--app APP_NAME', 'The name of the app to deploy') do |app_name|
+    options.app_name = app_name
+  end
+
+  opts.on('--all', 'Deploy all apps for the environment') do
+    raise "Can not use options --app and --all as they conflict" if options.app_name
+    options.deploy_all = true
+  end
+
+  # This option is not yet implemented because the docker REST api is not the best at searching available images
+  # opts.on('--no-pull', 'specify if you do not wish to pull the image') do
+  #   options.pull_image = false
+  # end
+end.parse!
 
-logger.log "All hand on deck. Toot toot."
-logger.log "app is chatty", :verbose
+logger  = Freighter.logger
 
-config = Freighter::Parse.new(@options)
+# todo - brush up on nautical jargon to find a better way of saying the freighter is to depart
+logger.info "All hand on deck. Toot toot."
 
 case ARGV[0]
 when "deploy"
-  :deploy
+  unless options.environment
+    logger.error "Must specify an environment with the -e option" 
+  end
+  # check to see if the container name is specified or all containers should be deployed
+  unless (options.app_name || options.deploy_all)
+    logger.error "Must specify either container(s) with --app or --all option" 
+  end
+  Freighter::Deploy.new
+when "configure"
+  if File.exist?('./config/freighter.yml')
+    logger.info "./config/freighter.yml already exists"
+  else
+    example_path = File.expand_path('../../config/freighter.example.yml', __FILE__)
+    begin
+      FileUtils.mkdir('config')
+    rescue Errno::EEXIST
+    end
+    FileUtils.cp(example_path, 'config/freighter.yml')
+    logger.info "Example configuration copied to ./config/freighter.yml"
+    logger.info "Edit the file with your configuration."
+    logger.info "Please remember to prefer to use ENV vars instead of passwords when editing the configuration."
+  end
+when "verify-config"
+  Freighter::Parser.new(options.config_path)
+  logger.info "Your configuration checks out"
 else
-  logger.log "unexpected command given: #{ARGV[0]}. See usage. freighter --help", :error
+  logger.error "unexpected command given: #{ARGV[0]}. See usage. freighter --help"
 end
 

data/config/freighter.example.yml

@@ -0,0 +1,56 @@
+# Please use the examples in this file as a starting place for your own configuration.
+# This file should contain all the information needed to deploy with freighter,
+# aside from environment variables: DOCKER_HUB_USER_NAME, DOCKER_HUB_PASSWORD, DOCKER_HUB_EMAIL
+
+connection:
+  type: ssh
+  ssh_options:
+    user_name: user name on host
+    keys:
+      - "~/.config/id_rsa"
+
+docker:
+  port: 2375
+
+environments:
+  staging:
+    hosts:
+      - host: staging.example.com
+        images:
+          - name: organization/imageName:latest
+            containers:
+              - name: app
+                port_mapping: 0.0.0.0:80->80
+                env:
+                  DB_USERNAME: fooBar
+                  DB_PASSWORD: My53cr37
+
+  # a more complex example for production showing a way to reduce redundancy
+  production:
+    shared_env: &shared_app_env
+      DB_USERNAME: fooBar
+      DB_PASSWORD: My53cr37
+    hosts:
+      - host: prod1.example.com
+        images:
+          - name: organization/imageName:latest
+            containers:
+              - name: app
+                port_mapping: 0.0.0.0:80->80
+                env:
+                  <<: *shared_app_env
+                  ADDITIONAL_VAR: someValue
+          - name: organization/otherImage:latest
+            containers:
+              - name: otherApp
+                port_mapping: 0.0.0.0:2000->80
+                env:
+                  <<: *shared_app_env
+      - host: prod2.example.com
+        images:
+          - name: organization/imageName:latest
+            containers:
+              - name: otherApp
+                port_mapping: 0.0.0.0:2000->80
+                env:
+                  <<: *shared_app_env

data/lib/freighter/deploy.rb

@@ -0,0 +1,166 @@
+require 'docker'
+
+module Freighter
+  class Deploy
+    attr_reader :logger, :config
+
+    def initialize
+      @parser = Parser.new OPTIONS.config_path
+      @logger = LOGGER
+      @config = OPTIONS.config
+      @connection_config = @config.fetch('connection')
+      environments = @config.fetch('environments')
+      @environment = environments.fetch(OPTIONS.environment) rescue logger.config_error("environments/#{OPTIONS.environment}")
+
+      connection_type = @connection_config['type']
+      case connection_type
+      when 'ssh'
+        deploy_with_ssh
+      else
+        logger.error "Unknown configuration option for type: #{connection_type}"
+      end
+    end
+
+    def deploy_with_ssh
+      ssh_options = @connection_config.fetch('ssh_options')
+      ssh_options.extend Helpers::Hash
+      ssh_options = ssh_options.symbolize_keys
+
+      @environment.fetch('hosts').each_with_index do |host, i|
+        host_name = host.fetch('host')
+        images = @parser.images(host_name)
+
+        ssh = SSH.new(host_name, ssh_options)
+        local_port = 7000 + i
+        # docker_api = DockerRestAPI.new("http://localhost:#{local_port}")
+
+        ssh.tunneled_proxy(local_port) do |session|
+          msg = ->(m) { "#{host_name}: #{m}" } 
+
+          logger.debug msg["Connected"]
+          begin
+            # The timeout is needed in the case that we are unable to communicate with the docker REST API
+            Timeout::timeout(5) do
+              setup_docker_client(local_port)
+            end
+          rescue Timeout::Error
+            ssh.thread.exit
+            logger.error msg["Could not reach the docker REST API"]
+          end
+
+          
+          images.each do |image|
+            image_name = image['name']
+            # pull image
+            if OPTIONS.pull_image
+              logger.info msg["Pulling image: #{image_name}"] 
+              pull_response = Docker::Image.create 'fromImage' => image_name
+            else
+              logger.info msg["Skip pull image"]
+              logger.error msg["Skipping is not yet implemented. Please run again without the --no-pull option"]
+            end
+
+            # find existing images on the machine
+            image_ids = Docker::Image.all.select do |img|
+              img.info['RepoTags'].member?(image_name)
+            end.map { |img| img.id[0...12] }
+
+            logger.info msg["Existing image(s) found #{image_ids.join(', ')}"]
+
+            # determine if a the latest version of the image is currently running
+            matching_containers = containers_matching_port_map(Docker::Container.all, image['containers'].map { |c| c['port_mapping'] })
+            if image_ids.member?(pull_response.id) && !matching_containers.empty?
+              logger.info msg["Container already running with the latest image: #{pull_response.id}"]
+            else 
+              # stop previous container and start up a new container with the latest image
+              results = update_containers matching_containers, image
+              logger.info msg["Finished:"]
+              logger.info msg["  started: #{results[:started]}"]
+              logger.info msg["  stopped: #{results[:stopped]}"]
+              logger.info msg["  started container ids: #{results[:container_ids_started]}"]
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+      # Sets up the Docker gem by setting the local URL and authenticating to the host's REST API
+      def setup_docker_client(local_port)
+        Docker.url = "http://localhost:#{local_port}"
+        begin
+          logger.debug "Requesting docker version"
+          response = Docker.version
+          logger.debug "Docker version: #{response.inspect}"
+          logger.debug "Requesting docker authenticaiton"
+          response = Docker.authenticate!('username' => ENV['DOCKER_HUB_USER_NAME'], 'password' => ENV['DOCKER_HUB_PASSWORD'], 'email' => ENV['DOCKER_HUB_EMAIL'])
+          logger.debug "Docker authentication: #{response.inspect}"
+        rescue Excon::Errors::SocketError => e
+          logger.error e.message
+        end
+      end
+
+      def containers_matching_port_map(containers, port_mappings)
+        port_mappings.map do |port_map|
+          ports = ports(port_map)
+          containers.select do |c|
+            c.info['Ports'].detect do |p|
+              p['PrivatePort'] == ports.container && p['PublicPort'] == ports.host
+            end
+          end
+        end.flatten
+      end
+
+      PortMap = Struct.new(:ip, :host, :container)
+      def ports(port_map)
+        port_map.match(/^(\d{1,3}\.[\.0-9]*)?:?(\d+)->(\d+)$/)
+        begin
+          raise if $2.nil? or $3.nil?
+          PortMap.new($1, $2.to_i, $3.to_i)
+        rescue
+          raise "port_mappings needs to be in the format of <ip-address>:<host-port-number>-><container-port-number>. received: #{port_map}"
+        end
+      end
+
+      def update_containers existing_containers=[], image
+        totals = { stopped: 0, started: 0, container_ids_started: [] }
+        # stop the existing matching containers
+        existing_containers.map do |container|
+          Thread.new do
+            existing_container = Docker::Container.get(container.id)
+            logger.info "Stopping container: #{contianer.id}"
+            existing_container.stop
+            existing_container.wait()
+            logger.info "Container stopped (#{container.id}"
+            totals[:stopped] += 1
+          end
+        end.join
+
+        # start up some new containers
+        image['containers'].map do |container|
+          port_map = ports(container['port_mapping'])
+
+          # env = container['env'].inject("") { |r, (k,v)| r << "#{k}='#{v}',\n" }
+          env = container['env'].map { |k,v| "#{k}=#{v}" }
+          container_options = {
+            "Image" => image['name'],
+            "ExposedPorts" => { "#{port_map.container}/tcp" => {} },
+            "Env" => env
+          }
+
+          new_container = Docker::Container.create container_options
+          logger.info "Starting container with port_mapping: host #{[port_map.ip, port_map.host].join(':')}, container #{port_map.container}"
+          new_container.start(
+            "PortBindings" => { "#{port_map.container}/tcp" => [{ "HostPort" => port_map.host.to_s, "HostIp" => port_map.ip }] }
+          )
+          totals[:container_ids_started] << new_container.id
+          logger.info "New container started with id: #{new_container.id}"
+          totals[:started] += 1
+        end
+        
+        totals
+      end
+
+  end
+end

data/lib/freighter/docker_rest_api.rb

@@ -0,0 +1,68 @@
+require 'excon'
+require 'json'
+
+module Freighter
+  class DockerRestAPI
+    
+    def initialize(url)
+      @base_url = url
+      @http = Excon.new url
+    end
+
+    # authentication should not be necessary if the user is already authenticated with the docker client on the host
+    def authenticate
+      request { post(path: '/auth', body: JSON.dump({ 'username' => ENV['DOCKER_HUB_USER_NAME'], 'password' => ENV['DOCKER_HUB_PASSWORD'], 'email' => ENV['DOCKER_HUB_EMAIL'] }), headers: { "Content-Type" => "application/json" }) }
+    end
+
+    # This pulls a specified image
+    # def pull(image, repo, tag='latest')
+    def pull(tag)
+      request do
+        post(path: "/images/create", query: { tag: tag })
+      end
+    end
+
+    # returns all running containers
+    def running_containers
+      request do
+        get(path: '/containers/json')
+      end
+    end
+
+    def list_images
+      request { get path: '/images/json' }
+    end
+
+    protected
+
+      ResponseObject = Struct.new(:body_hash, :status)
+
+      def request(&block)
+        begin
+          binding.pry
+          response = yield
+        rescue Excon::Errors::SocketError => e
+          logger.error e.message
+        end
+
+        status = response.status
+        if status >= 200 and status < 300
+          begin
+          ResponseObject.new JSON.parse(response.body), status
+          rescue JSON::ParserError => e
+            binding.pry
+          end
+        else
+          LOGGER.error "Could not process request:\n    request: #{@last_request_args.inspect}\n    response: #{response.inspect}"
+        end
+      end
+
+      %w[get post put delete].each do |verb|
+        define_method verb.to_sym do |*args|
+          @last_request_args = args
+          @http.send(verb.to_sym, *args)
+        end
+      end
+
+  end
+end

data/lib/freighter/helpers.rb

@@ -0,0 +1,10 @@
+module Freighter
+  module Helpers
+    module Hash
+      # this is not convert nested keys
+      def symbolize_keys
+        self.inject({}) { |result, (key,val)| result[key.to_sym] = val; result }
+      end
+    end
+  end
+end

data/lib/freighter/logger.rb

@@ -1,19 +1,29 @@
+require 'logger'
+require 'pry'
+
 module Freighter
   class Logger
-    def initialize(options)
-      @verbose = options.verbose
+    attr_reader :logger
+
+    def initialize
+      @logger = ::Logger.new(STDOUT)
+      logger.formatter = ->(severity, time, progname, msg) { "#{severity}: #{msg}\n" }
+    end
+
+    def method_missing(meth, *args, &block)
+      logger.level = OPTIONS.verbose ? ::Logger::DEBUG : ::Logger::INFO
+      logger.send(meth, *args)
     end
 
-    def log(str, verbose=false)
-      if @verbose or verbose != :verbose
-        puts str
-      end
+    def config_error(str)
+      error "Config error: #{str} not defined"
     end
 
     def error(str)
-      puts str
-      puts "Freighter hit an iceburg. To the life boats. All is lost. :("
+      logger.error str
+      logger.error "Freighter hit an iceburg. To the life boats. All is lost. A truely unfortunate day in nautical affairs :("
       exit -1
     end
+     
   end
 end

data/lib/freighter/parser.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+
+module Freighter
+  class Parser
+    attr_reader :config
+
+    def initialize(config_path)
+      begin
+        @config = opts.config = YAML.load_file(config_path)
+        LOGGER.debug "config file parsed"
+      rescue Errno::ENOENT, Psych::SyntaxError => e
+        LOGGER.error "Error parsing freighter config file.\n  path: #{config_path}\n  #{e}"
+      rescue
+        LOGGER.error "There is something wrong with the path to your yaml config file: #{config_path}\n  #{$!.message}"
+      end
+      
+      # Do some basic checking to make sure the config file has what we need
+      %w[environments connection/type].each { |option| test_config_option option }
+      set_defaults
+    end
+
+    def opts
+      OPTIONS
+    end
+
+    # recursively tests for keys in a nested hash by separating nested keys with '/'
+    def test_config_option(option, opt_array=[], context=nil)
+      opts_2_test = option.split('/')
+      opts_2_test.each_with_index do |opt, i|
+        opt_array << opt
+        context ||= opts.config
+        begin
+          if next_opt = opts_2_test[i+1]
+            new_context = context.fetch(opt)
+            test_config_option(next_opt, opt_array.clone, new_context.clone)
+          end
+        rescue KeyError
+          LOGGER.config_error opt_array.join('/')
+        end
+      end
+    end
+
+    def images(host)
+      host_config = environment.fetch('hosts').detect { |h| h.fetch('host') == host }
+      host_images = host_config.fetch('images')
+      raise "app(s) to deploy not specified" unless opts.deploy_all or opts.app_name
+      if opts.deploy_all
+        host_images
+      else
+        host_images.select do |host_image|
+          !host_image.fetch('containers').detect do |container|
+            container['name'] == opts.app_name
+          end.nil?
+        end
+      end
+    end
+
+    def environment
+      begin
+        config.fetch('environments').fetch(opts.environment)
+      rescue KeyError => e
+        LOGGER.error "Error fetching environment: #{e.message}"
+      end
+    end
+    
+    private
+
+      def set_defaults
+        opts.config.tap do |conf|
+          conf['connection']['docker'] ||= {}
+          conf['connection']['docker']['socket'] ||= 'unix:///var/run/docker.sock'
+          conf['connection']['docker']['port']   ||= nil
+        end
+        opts.deploy_all ||= false
+        opts.pull_image = true if opts.pull_image.nil?
+      end
+
+  end
+end

data/lib/freighter/ssh.rb

@@ -0,0 +1,47 @@
+require 'net/ssh'
+require 'net/ssh/proxy/socks5'
+
+module Freighter
+  class SSH
+    attr_reader :thread
+
+    def initialize(host, ssh_conf)
+      @host = host
+      @user = ssh_conf.fetch(:user_name)
+      ssh_conf.delete(:user_name)
+      @ssh_options = ssh_conf
+    end
+
+    def proxy
+      docker_port = OPTIONS.config['connection']['docker']['port']
+      Net::SSH::Proxy::SOCKS5.new(@host, docker_port, {user: @user}.merge(@ssh_options))
+    end
+
+    def tunneled_proxy(local_port, use_proxy=false, &block)
+      options = use_proxy ? { proxy: proxy } : @ssh_options
+      docker_port = OPTIONS.config['docker']['port']
+
+      LOGGER.debug "Connecting\n  host: #{@host}, user: #{@user}, options: #{options.inspect}"
+      @thread = Thread.new do
+        Thread.current.thread_variable_set(:ssh_tunnel_established, false)
+
+        Net::SSH.start(@host, @user, options) do |session|
+          session.forward.local(local_port, "0.0.0.0", docker_port)
+          LOGGER.debug "Connected to #{@host} and port #{local_port} is forwarded to host's docker REST API port ##{docker_port}."
+
+          Thread.current.thread_variable_set(:ssh_tunnel_established, true)
+          int_pressed = false
+          trap("INT") { int_pressed = true }
+          session.loop(0.1) { !session.closed? && !int_pressed }
+        end
+      end
+
+      while @thread.thread_variable_get(:ssh_tunnel_established) != true
+        sleep 0.1
+      end
+
+      yield
+    end
+
+  end
+end

data/lib/freighter/version.rb

@@ -1,3 +1,3 @@
 module Freighter
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/freighter.rb

@@ -1,7 +1,15 @@
-require "freighter/version"
-require "freighter/logger"
-require "freighter/parse"
+Dir[File.join(File.dirname(__FILE__), 'freighter', '*')].each do |file|
+  require file
+end
+require 'ostruct'
 
 module Freighter
-  # Your code goes here...
+
+  def self.options; OPTIONS end
+  def self.logger; LOGGER end
+
+  OPTIONS = OpenStruct.new
+  LOGGER  = Logger.new
+
 end
+

data/spec/lib/freighter/deploy_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Freighter::Deploy do
+
+  before do
+    options = Freighter.options
+    options.config_path = "#{BASE_DIR}/config/freighter.example.yml"
+    options.environment = "staging"
+    expect_any_instance_of(Freighter::Deploy).to receive(:deploy_with_ssh)
+  end
+  
+  context "private methods" do
+    subject { Freighter::Deploy.new }
+
+    describe "ports" do
+
+      it "should match port mapping with IP address" do
+        mapping = "0.0.0.0:80->90"
+        port_map = subject.send(:ports, mapping)
+        expect(port_map.ip).to eq "0.0.0.0"
+        expect(port_map.host).to eq 80
+        expect(port_map.container).to eq 90
+      end
+
+      it "should be able to accept a mapping without an IP address" do
+        mapping = "80->90"
+        port_map = subject.send(:ports, mapping)
+        expect(port_map.ip).to be_nil
+        expect(port_map.host).to eq 80
+        expect(port_map.container).to eq 90
+      end
+
+      it "should raise an exception if port mapping format is incorrect" do
+        mapping = ""
+        expect { subject.send(:ports, mapping) }.to raise_error
+      end
+    end  
+  end
+end

data/spec/lib/freighter/parser_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'pry'
+
+describe Freighter::Parser do
+  let(:config_path) { File.expand_path('../../../../config/freighter.example.yml', __FILE__) }
+
+  before do
+    # allow(YAML).to receive(:load_file).and_return(:sample_config)
+    Freighter.options.environment = 'staging'
+  end
+
+  subject { Freighter::Parser.new(config_path) }
+
+  describe "images" do
+    subject do
+      Freighter.options.environment = 'production'
+      Freighter::Parser.new(config_path).images('prod1.example.com')
+    end
+
+    context "deploy all" do
+      before do
+        Freighter.options.deploy_all = true
+        Freighter.options.app_name = nil
+      end
+
+      it "should retrieve images" do
+        expect(subject.map { |h| h['name'] }).to eq ["organization/imageName:latest", "organization/otherImage:latest"]
+      end
+    end
+
+    context "deploy one app" do
+      before do
+        Freighter.options.deploy_all = false
+        Freighter.options.app_name = 'otherApp'
+      end
+
+      it "should find one image" do
+        expect(subject.length).to eq 1
+        expect(subject.first['name']).to eq "organization/otherImage:latest"
+      end
+    end
+
+    context "app not found" do
+      before do
+        Freighter.options.deploy_all = false
+        Freighter.options.app_name = nil
+      end
+
+      it "should raise an exception" do
+        expect { subject }.to raise_error RuntimeError, "app(s) to deploy not specified"
+      end
+    end
+  end # images
+
+  describe "environment" do
+    it "should fetch the right environment" do
+      expect(subject.environment).to have_key('hosts')
+      expect(subject.environment['hosts'].first.fetch('host')).to eq 'staging.example.com'
+    end
+  end # environment
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,95 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'freighter'
+require 'pry-nav'
+BASE_DIR = File.expand_path('../../', __FILE__)
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freighter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Sean McCleary
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-02 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,16 +61,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/freighter
+- config/freighter.example.yml
 - freighter.gemspec
 - lib/freighter.rb
+- lib/freighter/deploy.rb
+- lib/freighter/docker_rest_api.rb
+- lib/freighter/helpers.rb
 - lib/freighter/logger.rb
-- lib/freighter/parse.rb
+- lib/freighter/parser.rb
+- lib/freighter/ssh.rb
 - lib/freighter/version.rb
+- spec/lib/freighter/deploy_spec.rb
+- spec/lib/freighter/parser_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/mrinterweb/freighter
 licenses:
 - MIT
@@ -95,4 +104,7 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Ruby gem to deploy docker containers
-test_files: []
+test_files:
+- spec/lib/freighter/deploy_spec.rb
+- spec/lib/freighter/parser_spec.rb
+- spec/spec_helper.rb

data/lib/freighter/parse.rb

@@ -1,18 +0,0 @@
-require 'yaml'
-require 'pry'
-require 'freighter/logger'
-
-module Freighter
-  class Parse
-    def initialize(options)
-      @logger = Logger.new options
-      @config_path = options.config_path
-      begin
-        @config = YAML.load_file(@config_path)
-        @logger.log "config file parsed", :verbose
-      rescue Errno::ENOENT => e
-        @logger.error "Error parsing freighter config file.\n  path: #{@config_path}\n  #{e}"
-      end
-    end
-  end
-end