navyrb 0.0.1

data/lib/navy/container.rb

@@ -0,0 +1,75 @@
+class Navy::Container
+  attr_reader :specification, :dependencies, :options
+
+  def initialize(options = {})
+    @specification = options[:specification] || {}
+    @dependencies = options[:dependencies] || []
+    @logger = options[:logger] || Navy::Logger.new
+  end
+
+  def daemon?
+    specification[:type] == "application"
+  end
+
+  def name
+    specification[:container_name]
+  end
+
+  def app
+    specification[:name]
+  end
+
+  def can_be_started?(etcd)
+    dependencies.each do |dep|
+      return false unless desired?(etcd, dep)
+    end
+    true
+  end
+
+  def can_never_be_started?(etcd)
+    dependencies.each do |dep|
+      return true if errored?(etcd, dep)
+    end
+    false
+  end
+
+  def start
+    if daemon?
+      cmd = command_builder.build
+      Navy::Runner.launch(cmd)
+    else
+      commands.each do |command|
+        cmd = command_builder.build :command => command
+        success = Navy::Runner.launch(cmd, :logger => @logger)
+        return false unless success
+      end
+      true
+    end
+  end
+
+  def stop
+    cmd = ["docker rm -f", name]
+    Navy::Runner.launch(cmd)
+  end
+
+  private
+
+  def commands
+    specification[:cmds] || []
+  end
+
+  def command_builder
+    @command_builder ||= Navy::CommandBuilder.new(self)
+  end
+
+  def errored?(etcd, container_name)
+    actual  = etcd.getJSON("/navy/containers/#{container_name}/actual")
+    actual["state"] == "error" if actual
+  end
+
+  def desired?(etcd, container_name)
+    desired = etcd.getJSON("/navy/containers/#{container_name}/desired")
+    actual  = etcd.getJSON("/navy/containers/#{container_name}/actual")
+    desired == actual
+  end
+end

data/lib/navy/container_building.rb

@@ -0,0 +1,67 @@
+module Navy::ContainerBuilding
+  private
+
+  def build_container
+    Navy::Container.new :dependencies => @dependencies,
+                              :specification => @specification
+  end
+
+  def build_app_dependencies(app, config)
+    links = app.dependencies(config)
+    flags = {:convoy => options[:convoy]}
+    links.each do |link|
+      name = config.container_name(link, flags)
+      dependencies << name
+    end
+  end
+
+  def build_app_links(app, config)
+    links = app.linked_apps(config)
+    links.each do |link|
+      fqdn = app_fqdn(link, config)
+      env = app_env_addr(link)
+      specification[:env][env] = "https://#{fqdn}"
+      specification[:links] << ['host_proxy', fqdn]
+    end
+  end
+   
+
+  def build_dep_links(app, config)
+    links = app.dependencies(config)
+    flags = {:convoy => options[:convoy]}
+    links.each do |link|
+      name = config.container_name(link, flags)
+      specification[:links] << [name, link]
+    end
+  end
+
+  def app_fqdn(app, config)
+    parts = []
+    parts << @convoy_id
+    parts << app
+    parts << @cluster
+    parts.compact.join('-')
+  end
+
+  def app_env_addr(app)
+    "#{app.upcase}_HOST_ADDR"
+  end
+  
+  def build_env_flags(app, config)
+    if app.env_var?
+      specification[:env][app.env_var] = config.environment
+    end
+  end
+  
+  def build_volumes_flags(app, config)
+    app.volumes_from.each do |v|
+      specification[:volumes_from] << v
+    end
+  end
+
+  def build_additional_args(app, config)
+    specification[:docker_args] = config.docker_args(app.name)
+  end
+
+
+end

data/lib/navy/etcd.rb

@@ -0,0 +1,133 @@
+require 'json'
+require 'net/http'
+
+module Navy
+  class Etcd
+    Response = Struct.new(:etcd_index, :action, :node, :prevNode) do
+      def key
+        node.key
+      end
+    end
+
+    class Node
+      attr_reader :createdIndex, :modifiedIndex, :value, :key
+
+      def initialize(data)
+        data ||= {}
+        parse_data data, :createdIndex, :modifiedIndex,
+                         :value, :key
+      end
+
+      private
+
+      def parse_data(data, *attrs)
+        attrs.each do |attr|
+          instance_variable_set("@#{attr}", data[attr.to_s])
+        end
+      end
+
+    end
+
+    def self.client(options)
+      new(options)
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def get(key, params = {})
+      response = make_get(key, params)
+      json = JSON.parse(response.body)
+      Response.new response['X-Etcd-Index'].to_i,
+                   json['action'],
+                   Node.new(json['node']),
+                   Node.new(json['prevNode'])
+    end
+
+    def getJSON(key, params = {})
+      record = get(key, params)
+      json = record.node.value
+      JSON.parse(json) if json
+    end
+
+    def watch(key, options = {})
+      options[:wait] = true
+      get(key, options)
+    end
+
+    def set(key, value)
+      make_put(key, :value => value)
+    end
+
+    def setJSON(key, value)
+      make_put(key, :value => value.to_json)
+    end
+
+    def queueJSON(key, value)
+      make_post(key, :value => value.to_json)
+    end
+
+    def ls(dir)
+      response = make_get(dir)
+      dir = JSON.parse(response.body)["node"]
+      dir["nodes"].map {|i| i["key"]}
+    end
+
+    def delete(key, params = {})
+      response = make_delete(key, params)
+      (200...299).include? response.code.to_i
+    end
+
+    private
+
+    def make_uri(path)
+      host = @options[:host]
+      port = @options[:port] || 4001
+      uri = URI("http://#{host}:#{port}")
+      uri.path = "/v2/keys" + path
+      uri
+    end
+
+    def make_http(uri)
+      Net::HTTP.new(uri.host, uri.port)
+    end
+
+    def make_query(params)
+      params.map do |k, v|
+        "#{k}=#{v}"
+      end.join '&'
+    end
+
+    def make_request(path, type, params = {})
+      uri = make_uri(path)
+      http = make_http(uri)
+      if params.length > 0
+        uri.query = make_query(params)
+      end
+      request = type.new(uri)
+      yield request if block_given?
+      http.request(request)
+    end
+
+    def make_delete(path, params = {})
+      make_request(path, Net::HTTP::Delete, params)
+    end
+
+    def make_put(path, postdata = {})
+      http, request = make_request(path, Net::HTTP::Put) do |request|
+        request.set_form_data(postdata)
+      end
+    end
+
+    def make_post(path, postdata = {})
+      http, request = make_request(path, Net::HTTP::Post) do |request|
+        request.set_form_data(postdata)
+      end
+    end
+
+    def make_get(path, params = {})
+      make_request(path, Net::HTTP::Get, params)
+    end
+  end
+end

data/lib/navy/logger.rb

@@ -0,0 +1,53 @@
+class Navy::Logger
+  COLOURS = {
+    :black          => 30,
+    :red            => 31,
+    :green          => 32,
+    :yellow         => 33,
+    :blue           => 34,
+    :magenta        => 35,
+    :cyan           => 36,
+    :bright_black   => 30,
+    :bright_red     => 31,
+    :bright_green   => 32,
+    :bright_yellow  => 33,
+    :bright_blue    => 34,
+    :bright_magenta => 35,
+    :bright_cyan    => 36
+  }
+
+  attr_reader :prefix
+
+  def color(color, message)
+    "\033[0;#{COLOURS[color]}m#{message}\033[0;00m"
+  end
+
+  def notice(message)
+    log color(:cyan,message)
+  end
+
+  def info(message)
+    log color(:yellow, message)
+  end
+
+  def error(message)
+    log color(:red, message)
+  end
+
+  def debug(message)
+    log message
+  end
+
+  def threaded!
+    thread = Thread.current.object_id
+    colorid = (thread/7) % COLOURS.count
+    colorkey = COLOURS.keys[colorid]
+    @prefix = color(colorkey, "(#{thread}):")
+  end
+
+  private
+
+  def log(message)
+    puts [prefix, message].join(' ')
+  end
+end

data/lib/navy/router.rb

@@ -0,0 +1,64 @@
+class Navy::Router
+  class NullHandler; end
+
+  class Routes
+    def route(pattern, handlers)
+      pattern = pattern.gsub(/:([a-z]+)/, '(?<\1>[a-z0-9\-_]+)')
+      regex = Regexp.new(pattern)
+      maps[regex] = handlers
+    end
+
+    def maps
+      @maps ||= {}
+    end
+
+    def obtain(path)
+      @maps.each do |pattern, handler|
+        matches = pattern.match(path)
+        if matches
+          params = extract_params(matches)
+          return handler.new, params
+        end
+      end
+      return NullHandler.new, {}
+    end
+
+    private
+
+    def extract_params(matches)
+      params = {}
+      matches.names.each do |name|
+        params[name] = matches[name]
+      end
+      params
+    end
+
+  end
+
+  def initialize(options = {})
+    @routes = Routes.new
+    @options = options
+    yield @routes if block_given?
+  end
+
+  def route(request, options = {})
+    opts = @options.merge(options)
+    handler, params = @routes.obtain(request.key)
+    params = opts.merge params
+    dispatch(handler, params, request)
+  end
+
+  private
+
+  def dispatch(handler, params, request)
+    action = request.action
+    message = handler_method(action)
+    if handler.respond_to? message
+      handler.public_send(message, params, request)
+    end
+  end
+
+  def handler_method(action)
+    "handle_#{action}"
+  end
+end

data/lib/navy/runner.rb

@@ -0,0 +1,17 @@
+require 'open3'
+
+
+class Navy::Runner
+  def self.launch(cmd, options={})
+    logger = options[:logger] || Navy::Logger.new
+
+    command = cmd.join(' ')
+    logger.notice("Launching #{command}")
+    stdout, stderr, status = Open3.capture3(cmd.join(' '))
+    unless status.success?
+      logger.color(:red, "Error")
+      logger.color(:red, stderr)
+    end
+    status.success?
+  end
+end

data/lib/navy/task_container_builder.rb

@@ -0,0 +1,70 @@
+class Navy::TaskContainerBuilder
+  include Navy::ContainerBuilding
+
+  attr_reader :app, :config, :options, :dependencies, :specification, :convoy_id, :cluster
+
+  def initialize(app, config, options)
+    @app = app
+    @config = config
+    @options = options
+    @convoy_id = options[:convoy]
+    @cluster = options[:cluster]
+    @specification = {
+      :type => "task",
+      :env => {},
+      :links => [],
+      :volumes_from => []
+    }
+    @dependencies = []
+  end
+
+  def build_pre
+    tasks = config.pre_tasks(app.name)
+    unless tasks.empty?
+      build_task_container_settings(:pre, app, config, tasks)
+      build_app_dependencies(app, config)
+      build_dep_links(app, config)
+      build_env_flags(app, config)
+      build_volumes_flags(app, config)
+      build_additional_args(app, config)
+      build_container
+    end
+  end
+
+  def build_post
+    tasks = config.post_tasks(app.name)
+    unless tasks.empty?
+      build_task_container_settings(:post, app, config, tasks)
+      build_mode_dependencies(app, config)
+      build_app_links(app, config)
+      build_dep_links(app, config)
+      build_env_flags(app, config)
+      build_volumes_flags(app, config)
+      build_additional_args(app, config)
+      build_container
+    end
+  end
+
+  private
+
+  def build_task_container_settings(type, app, config, cmds)
+    flags = {:mode => "#{type}tasks", :convoy => @convoy_id}
+    specification[:name] = app.name
+    specification[:container_name] = config.container_name(app.name, flags)
+    specification[:image] = app.image
+    specification[:cmds] = cmds
+  end
+
+  def build_mode_dependencies(app, config)
+    if app.modes
+      app.modes.each do |mode, cmd|
+        flags = {:mode => mode, :scale => 1, :convoy => @convoy_id}
+        dependencies << config.container_name(app.name, flags)
+      end
+    else
+      flags = {:scale => 1, :convoy => @convoy_id}
+      dependencies << config.container_name(app.name, flags)
+    end
+  end
+
+end