indocker 0.0.6 → 0.1.4

data/lib/indocker/docker_api/docker_api.rb

@@ -1,207 +0,0 @@
-require 'docker-api'
-require 'io/console'
-
-Docker.options = { read_timeout: 600, write_timeout: 600, chunk_size: 1 }
-
-class Indocker::DockerAPI
-  include SmartIoC::Iocify
-  include Indocker::ImageHelper
-
-  bean :docker_api
-
-  inject :logger
-
-  def check_docker_installed!
-    Docker.info
-    nil
-  rescue Excon::Error::Socket
-    raise Indocker::Errors::DockerDoesNotInstalled
-  end
-
-  def authenticate!(serveraddress:, email:, password:, username:)
-    params = {
-      'serveraddress' => serveraddress,
-      'email'         => email,
-      'password'      => password,
-      'username'      => username
-    }.delete_if {|_, value| value.to_s.empty?}
-
-    Docker.authenticate!(params)
-  end
-
-  # Networks
-
-  def create_network(name)
-    Docker::Network.create(name.to_s).id
-  end
-
-  def add_container_to_network(network_name:, container_name:)
-    container_id = get_container_id(container_name.to_s)
-
-    Docker::Network.get(network_name.to_s).connect(container_id.to_s)
-  end
-
-  def delete_network(name)
-    Docker::Network.get(name.to_s).remove
-  end
-
-  def network_exists?(name)
-    !Docker::Network.get(name.to_s).nil? rescue false
-  end
-
-  def get_network_id(name)
-    Docker::Network.get(name.to_s).id
-  end
-
-  def inspect_network(name)
-    Docker::Network.get(name.to_s).info
-  end
-
-  def delete_networks_where(&condition)
-    Docker::Network.all.select(&condition).map do |network|
-      network.remove
-    end
-  end
-
-  # Images
-
-  def get_image_id(repo, tag: nil)
-    Docker::Image.get(full_name(repo, tag)).id rescue nil
-  end
-
-  def image_exists?(repo, tag: nil)
-    Docker::Image.exist?(full_name(repo, tag))
-  end
-
-  def delete_image(repo, tag: nil)
-    Docker::Image.get(full_name(repo, tag)).remove(force: true)
-  end
-
-  def build_from_dir(repo:, tag:, build_dir:)
-    image = Docker::Image.build_from_dir(build_dir, { 't' => "#{repo}:#{tag}" }) do |x|
-      x.split("\r\n").each do |y|
-        if (log = JSON.parse(y)) && log.has_key?("stream")
-          yield log["stream"].strip
-        end
-      end
-    end
-
-    image.id
-  end
-
-  def tag(repo:, tag: nil, new_repo:, new_tag:)
-    Docker::Image.get(full_name(repo, tag)).tag('repo' => new_repo, 'tag' => new_tag)
-
-    nil
-  end
-
-  def push(repo:, tag:, push_to_repo:, push_to_tag:)
-    Docker::Image.get(full_name(repo, tag)).push(nil, repo_tag: full_name(push_to_repo, push_to_tag))
-
-    nil
-  end
-
-  def pull(opts)
-    image = Docker::Image.create(opts)
-
-    image.id
-  end
-
-  def delete_images_where(&condition)
-    Docker::Image.all.select(&condition).map do |image|
-      image.remove(force: true)
-    end
-  end
-
-  #Volumes
-
-  def create_volume(name)
-    Docker::Volume.create(name.to_s).id
-  end
-
-  def get_volume_id(name)
-    Docker::Volume.get(name.to_s).id
-  end
-
-  def all_volumes(name)
-    Docker::Volume.all
-  end
-
-  def delete_volume(name)
-    Docker::Volume.get(name.to_s).remove
-  end
-
-  def volume_exists?(name)
-    !Docker::Volume.get(name.to_s).nil? rescue false
-  end
-
-  def inspect_volume(name)
-    Docker::Volume.get(name.to_s).info
-  end
-
-  def delete_volumes_where(&condition)
-    Docker::Volume.all.select(&condition).map do |volume|
-      volume.remove
-    end
-  end
-
-  # Containers
-
-  def inspect_container(name)
-    Docker::Container.get(name.to_s).info
-  end
-
-  def get_container_id(name)
-    Docker::Container.get(name.to_s).id rescue nil
-  end
-
-  def get_container_image_id(name)
-    Docker::Container.get(name.to_s).info['Image'] rescue nil
-  end
-
-  def get_container_state(name)
-    Docker::Container.get(name.to_s).info["State"]["Status"]
-  end
-
-  def container_exists?(name)
-    !Docker::Container.get(name.to_s).nil? rescue false
-  end
-
-  def start_container(name, attach: false)
-    container = Docker::Container.get(name.to_s).start!
-
-    if attach
-      STDIN.raw do |stdin| 
-        container.attach(stdin: stdin, tty: true) do |chunk|
-          logger << chunk
-        end
-      end
-    end
-
-    container.id
-  end
-
-  def stop_container(name)
-    Docker::Container.get(name.to_s).stop rescue nil
-  end
-
-  def copy_from_container(name:, path:, &block)
-    Docker::Container.get(name.to_s).copy(path, &block)
-  end
-
-  # TODO: Add contract
-  def create_container(container_config)
-    Docker::Container.create(container_config.to_hash).id
-  end
-
-  def delete_container(name)
-    Docker::Container.get(name.to_s).delete(:force => true)
-  end
-
-  def delete_containers_where(&condition)
-    Docker::Container.all(all: true).select(&condition).map do |container|
-      container.stop
-      container.delete(force: true)
-    end
-  end
-end

data/lib/indocker/dsl_context.rb

@@ -1,21 +0,0 @@
-class Indocker::DSLContext
-  attr_reader :storage
-
-  def initialize(storage = {})
-    @storage = storage
-  end
-
-  def method_missing(method, *args)
-    super unless @storage.key?(method)
-
-    @storage.fetch(method)
-  end
-
-  def set_value(key, value)
-    @storage[key] = value
-  end
-
-  def +(other)
-    Indocker::DSLContext.new(@storage.merge(other.storage))
-  end
-end

data/lib/indocker/envs/env_metadata.rb

@@ -1,39 +0,0 @@
-module Indocker::Envs
-  class EnvMetadata
-    def initialize(variables = {})
-      @variables = variables
-    end
-
-    def to_hash
-      @variables
-    end
-
-    def to_json
-      to_hash.to_json
-    end
-
-    def to_array
-      to_hash.inject([]) do |all, (k, v)|
-        all.push "#{k}=#{v}"
-      end
-    end
-
-    def to_s
-      to_array.join(' ')
-    end
-
-    def set(key:, value:)
-      overwritten = @variables.has_key?(key) and @variables[key] != value
-
-      @variables[key] = value
-
-      overwritten
-    end
-
-    def +(other)
-      combined_hash = to_hash.merge(other.to_hash)
-
-      Indocker::Envs::EnvMetadata.new(combined_hash)
-    end
-  end
-end

data/lib/indocker/envs/loader.rb

@@ -1,19 +0,0 @@
-class Indocker::Envs::Loader
-  include SmartIoC::Iocify
-
-  bean :envs_loader
-
-  def parse(path)
-    raise Indocker::Errors::EnvFileDoesNotExist if !File.exists?(path)
-
-    env_metadata = Indocker::Envs::EnvMetadata.new
-
-    File.foreach(path) do |line|
-      key, value = line.split('=').map(&:strip)
-
-      env_metadata.set(key: key, value: value)
-    end
-
-    env_metadata
-  end
-end

data/lib/indocker/errors.rb

@@ -1,21 +0,0 @@
-module Indocker::Errors         
-  class ImageIsNotDefined                 < StandardError; end 
-  class ImageIsNotBuilded                 < StandardError; end 
-  class PartialIsNotDefined               < StandardError; end 
-  class ContainerIsNotDefined             < StandardError; end
-  class CircularImageDependency           < StandardError; end
-  class ImageForContainerDoesNotExist     < StandardError; end
-  class DockerDoesNotInstalled            < StandardError; end
-  class ConfigFilesDoesNotFound           < StandardError; end
-  class ConfigOptionTypeMismatch          < StandardError; end
-  class DockerRegistryAuthenticationError < StandardError; end
-  class EnvFileDoesNotExist               < StandardError; end
-  class ContainerTimeoutError             < StandardError; end
-  class ReservedKeywordUsed               < StandardError; end
-  class VolumeIsNotDefined                < StandardError; end
-
-  class ContainerImageAlreadyDefined      < StandardError; end
-  class NetworkAlreadyDefined             < StandardError; end
-  
-  class InvalidParams                     < StandardError; end
-end

data/lib/indocker/git/git_api.rb

@@ -1,32 +0,0 @@
-require 'git'
-
-class Indocker::Git::GitAPI
-  include SmartIoC::Iocify
-
-  bean :git_api
-
-  DEFAULT_REMOTE = 'origin'
-  
-  def get_remote_from_directory(dir)
-    Git.open(dir).remote(DEFAULT_REMOTE).url
-  rescue ArgumentError
-    nil
-  end
-
-  def fetch(dir)
-    Git.open(dir).pull
-  end
-
-  def clone(repository:, dir:)
-    dir = File.expand_path(dir)
-
-    git_path = File.dirname(dir)
-    app_name = File.basename(dir)
-
-    Git.clone(repository, app_name, path: git_path)
-  end
-
-  def checkout(revision:, dir:)
-    Git.open(dir).checkout(revision)
-  end
-end

data/lib/indocker/git/git_helper.rb

@@ -1,34 +0,0 @@
-module Indocker::Git
-  class GitHelper
-    include SmartIoC::Iocify
-
-    bean :git_helper
-
-    inject :config
-    inject :git_service
-
-    def method_missing(method, *args)
-      git_config    = config.git.send(method)
-      git_cache_dir = config.git.cache_dir.join(method.to_s)
-
-      return git_cache_dir if updated?(git_config.repository)
-
-      git_service.update(
-        repository: git_config.repository,
-        revision:   git_config.branch || git_config.tag,
-        workdir:    git_cache_dir
-      )
-      git_cache.push(git_config.repository)
-
-      Pathname.new(git_cache_dir)
-    end
-
-    def git_cache
-      @git_cache ||= []
-    end
-
-    def updated?(url)
-      git_cache.include?(url)
-    end
-  end
-end

data/lib/indocker/git/git_service.rb

@@ -1,21 +0,0 @@
-class Indocker::Git::GitService
-  include SmartIoC::Iocify
-
-  bean :git_service
-
-  inject :git_api
-
-  def update(repository:, revision:, workdir:)
-    workdir_repository = git_api.get_remote_from_directory(workdir)
-
-    if workdir_repository == repository
-      git_api.fetch(workdir)
-      git_api.checkout(revision: revision, dir: workdir)
-    else
-      FileUtils.rm_rf(workdir)
-      
-      git_api.clone(repository: repository, dir: workdir)
-      git_api.checkout(revision: revision, dir: workdir)
-    end
-  end
-end

data/lib/indocker/handlers/container_run.rb

@@ -1,20 +0,0 @@
-class Indocker::Handlers::ContainerRun
-  include SmartIoC::Iocify
-
-  bean   :run_container_handler
-  
-  inject :container_manager
-  inject :container_metadata_repository
-  inject :image_builder
-
-  include Indocker::Handlers::Performable
-
-  def handle(name:, current_path:)
-    name = name.to_s
-
-    container_metadata = container_metadata_repository.get_by_name(name)
-    image_builder.build(container_metadata.repo, tag: container_metadata.tag)
-    
-    container_manager.run(name)
-  end
-end

data/lib/indocker/handlers/container_stop.rb

@@ -1,17 +0,0 @@
-class Indocker::Handlers::ContainerStop
-  include SmartIoC::Iocify
-  
-  bean   :stop_container_handler
-
-  inject :container_manager
-  inject :container_metadata_repository
-  inject :image_builder
-
-  include Indocker::Handlers::Performable
-
-  def handle(name:, current_path:)
-    name = name.to_s
-
-    container_manager.stop(name)
-  end
-end

data/lib/indocker/handlers/performable.rb

@@ -1,22 +0,0 @@
-module Indocker
-  module Handlers
-    module Performable
-      def self.included(klass)
-        klass.inject(:logger)
-        klass.inject(:application_initializer)
-      end
-
-      def perform(options)
-        env = options.delete(:env)
-
-        application_initializer.init_app(options[:current_path], env: env)
-
-        self.method(:handle).call(options)
-      rescue Docker::Error::ClientError => e
-        logger.error e.message
-      rescue Docker::Error::NotFoundError => e
-        logger.error(e.message)
-      end
-    end
-  end
-end