docker_brick 0.0.1

data/lib/brick/cli.rb

@@ -0,0 +1,230 @@
+require 'mixlib/cli'
+require 'brick/application'
+require 'brick/monkey_patches/cli'
+module Brick
+  class CLI
+    
+    extend Brick::Mixin::ConvertToClassName
+    include Mixlib::CLI
+    #include Application
+    
+    
+    def self.logger
+      @@logger ||= Logger.new(STDOUT)
+      @@logger.level = Logger::INFO
+      @@logger.formatter = proc do |severity, datetime, progname, msg|
+          "#{msg}\n"
+       end
+      @@logger
+    end
+    
+    
+    def self.inherited(subclass)
+      unless subclass.unnamed?
+        subcommands[subclass.snake_case_name] = subclass
+      end
+    end
+    
+    def self.unnamed?
+      name.nil? || name.empty?
+    end
+    
+     # Run command line for the given +args+ (ARGV), adding +options+ to the list of
+    # CLI options that the subcommand knows how to handle.
+    # ===Arguments
+    # args::: usually ARGV
+    # options::: A Mixlib::CLI option parser hash. These +options+ are how
+    # subcommands know about global knife CLI options
+    def self.run(args, options={})
+      #configure brick for common attributes
+      #common_optparser.configure_brick
+      common_optparser.opt_parser.banner="Usage: brick SUBCOMMAND (options)"
+      CLI_Validator::validate
+      #logger.info "begin to run the comand #{args}"
+      load_commands
+      subcommand_class = subcommand_class_from(args)
+      subcommand_class.options = common_optparser.class.options.merge!(subcommand_class.options)
+      subcommand_class.load_deps
+      instance = subcommand_class.new(args)
+      #instance.configure_brick
+      instance.run_with_pretty_exceptions
+    end
+    
+    def self.common_optparser
+      @@common_optparser ||= Application.new
+    end
+    
+    def self.subcommand_class_from(args)
+      command_words = args.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
+
+      subcommand_class = nil
+
+      while ( !subcommand_class ) && ( !command_words.empty? )
+        snake_case_class_name = command_words.join("_")
+        unless subcommand_class = subcommands[snake_case_class_name]
+          command_words.pop
+        end
+      end
+      # see if we got the command as e.g., brick model create
+      subcommand_class ||= subcommands[args.first.gsub('-', '_')]
+      subcommand_class || subcommand_not_found!(args)
+    end
+    
+    def self.subcommands
+      @@subcommands ||= {}
+    end
+    
+    def self.subcommand_not_found!(args)
+      logger.fatal("Cannot find sub command for: '#{args.join(' ')}'")
+
+     
+      list_commands
+      
+
+      exit 10
+    end
+    
+    def self.list_parameters
+      puts common_optparser.opt_parser.to_s
+      puts ""
+    end
+    
+     # is given, only subcommands in that category are shown
+    def self.list_commands(preferred_category=nil)
+      load_commands
+
+      category_desc = preferred_category ? preferred_category + " " : ''
+      logger.info "Available #{category_desc}subcommands: (for details, brick SUB-COMMAND --help)\n\n"
+
+      if preferred_category && subcommands_by_category.key?(preferred_category)
+        commands_to_show = {preferred_category => subcommands_by_category[preferred_category]}
+      else
+        commands_to_show = subcommands_by_category
+      end
+
+      commands_to_show.sort.each do |category, commands|
+        next if category =~ /deprecated/i
+        logger.info "** #{category.upcase} COMMANDS **"
+        commands.sort.each do |command|
+          logger.info subcommands[command].banner if subcommands[command]
+        end
+        logger.info 
+      end
+    end
+    
+    def self.subcommands_by_category
+      unless @subcommands_by_category
+        @subcommands_by_category = Hash.new { |hash, key| hash[key] = [] }
+        subcommands.each do |snake_cased, klass|
+          @subcommands_by_category[klass.subcommand_category] << snake_cased
+        end
+      end
+      @subcommands_by_category
+    end
+    
+    def self.snake_case_name
+      convert_to_snake_case(name.split('::').last) unless unnamed?
+    end
+    
+    def self.load_commands
+      @commands_loaded ||= subcommand_loader.load_commands
+    end
+    
+    
+    def self.subcommand_loader
+      @subcommand_loader ||= CLI::SubcommandLoader.new
+    end
+    
+    #Add catergory 
+     def self.category(new_category)
+      @category = new_category
+    end
+
+    def self.subcommand_category
+      @category || snake_case_name.split('_').first unless unnamed?
+    end
+    
+    def self.dependency_loaders
+      @dependency_loaders ||= []
+    end
+    
+    def self.deps(&block)
+      dependency_loaders << block
+    end
+    
+     def self.load_deps
+      dependency_loaders.each do |dep_loader|
+        dep_loader.call
+      end
+    end
+    
+    def initialize(argv=[])
+      
+      super() 
+      command_name_words = self.class.snake_case_name.split('_')
+      
+      # Mixlib::CLI ignores the embedded name_args
+      @cmd_args = ARGV.dup - command_name_words
+      
+      @cmd_args = parse_options @cmd_args
+      @cmd_args.delete(command_name_words.join('-'))
+      #@name_args.reject! { |name_arg| command_name_words.delete(name_arg) }
+      
+      
+      Brick::Config.merge!(config)
+      
+      project_name = ::Brick::Config[:project]
+      
+      config_file = ::Brick::Config[:config_file]
+      
+      project_dir = File.dirname(config_file)
+      
+      ::Brick::Config[:project_dir] = project_dir
+=begin
+      if config[:help]
+        logger.info opt_parser
+        exit 1
+      end
+=end
+      
+    end
+    
+  
+    def run_with_pretty_exceptions
+      unless self.respond_to?(:run)
+        logger.error "You need to add a #run method to your brick command before you can use it"
+      end
+      run
+    rescue Exception => e
+      raise 
+      humanize_exception(e)
+      exit 100
+    end
+    
+     def humanize_exception(e)
+      case e
+      when SystemExit
+        raise # make sure exit passes through.
+      when Errno::ECONNREFUSED, Timeout::Error, Errno::ETIMEDOUT, SocketError
+        logger.error "Network Error: #{e.message}"
+        logger.info "Check your network settings"
+      else
+        logger.error "#{e.class.name}: #{e.message}"
+      end
+    end
+    
+   def show_usage
+      puts( self.opt_parser.to_s)
+    end
+    
+#     def configure_brick
+#      begin
+ #     parse_options
+#     rescue => e
+#        ::Brick::CLI::logger.error e.message
+#        exit 1
+#      end
+#      Brick::Config.merge!(config)
+#   end
+  end
+end

data/lib/brick/cli__validator.rb

@@ -0,0 +1,28 @@
+module Brick
+  class CLI_Validator
+    NO_COMMAND_GIVEN = "You need to pass a sub-command (e.g., brick SUB-COMMAND)\n"
+    
+    def self.validate
+      if  no_command_given?
+        print_help_and_exit(1, NO_COMMAND_GIVEN)
+      end
+      
+    end
+    
+    def self.no_subcommand_given?
+      ARGV[0] =~ /^-/
+    end
+    
+    def self.no_command_given?
+      ARGV.empty?
+    end
+    
+    def self.print_help_and_exit(exitcode=1, fatal_message=nil)
+      Brick::CLI::logger.error(fatal_message) if fatal_message
+      Brick::CLI.list_parameters
+      Brick::CLI.list_commands
+      exit exitcode
+    end
+    
+  end
+end

data/lib/brick/config.rb

@@ -0,0 +1,9 @@
+require 'mixlib/cli'
+require 'mixlib/config'
+module Brick
+  class Config
+    extend ::Mixlib::Config
+    
+    
+  end
+end

data/lib/brick/docker/docker_client.rb

@@ -0,0 +1,160 @@
+require 'monitor'
+require "docker"
+require 'json'
+require 'uri'
+#require 'byebug'
+module Brick
+  module Docker
+    
+  end
+end
+
+module Brick
+  module Docker
+    class DockerClient
+      include Brick::Mixin::DockerSupport
+      
+      @@default_client = nil
+      
+      @@lock = Monitor.new
+      
+      to_aliase_methods = [:run]
+      
+      attr_accessor :base_url, :connection
+      
+      @@connection_pool = Hash.new
+      
+      @base_url = ENV['DOCKER_URL']
+      
+      def self.connection base_url
+        
+      conn = nil
+        
+        @@lock.synchronize do
+          conn ||= @@connection_pool[base_url.to_sym]
+          
+          if(conn.nil?)
+            conn = ::Docker::Connection.new(base_url, {}) 
+            @@connection_pool[base_url.to_sym] = @connection
+          end
+        end 
+        
+        conn
+      end
+      
+      def initialize(options={})
+        
+        unless(options[:base_url].nil?)
+          @base_url = options[:base_url]
+        end
+        
+        
+          @base_url ||= 'unix:///var/run/docker.sock'
+        
+        
+        @connection= self.class.connection @base_url
+        
+        puts "#{__method__} #{__LINE__} @connection=#{@connection}"
+      end
+      
+      def self.default
+        @@default_client ||= DockerClient.new
+        #puts "client=#{@@default_client}"       
+        return @@default_client
+      end
+      
+      def create config_hash, name=nil
+        
+       docker_hash= create_config(config_hash)
+        
+       docker_hash['name'] = name unless name.nil?
+        
+        begin
+          container = ::Docker::Container.create(docker_hash.dup, connection)
+          #get full information of the container
+          container = ::Docker::Container.get(container.id,connection)
+        rescue ::Docker::Error::NotFoundError => exception
+            if exception.message.include? 'No such image'
+              ::Docker::Image.create({'fromImage'=> config_hash['image']},{}, connection)
+               container = ::Docker::Container.create(docker_hash.dup, connection)
+               #get full information of the container
+               container = ::Docker::Container.get(container.id,connection)
+            else
+              raise exception
+          end
+          return container
+        end
+      end
+      
+      
+      #if the container is already existed, reuse it
+      #if the container is not started, start it
+      def run config_hash, name=nil
+        #byebug        
+        container = get_container_by_name name
+        
+        
+        if container.nil?
+          container = create config_hash, name
+        else
+          Brick::CLI::logger.info "container #{name} has already existed."
+        end
+        
+        Brick::CLI::logger.debug "container #{container}."
+        
+        
+        unless container.is_running?
+          container.start(start_config(config_hash))
+        else
+          Brick::CLI::logger.info "container #{name} is #{container.info["Status"]}"
+        end
+        
+        container
+      end
+      
+      def get_container_by_name  name=nil
+        
+        container = nil
+        
+        unless name.nil?
+          container = ::Docker::Container.search_by_name name, connection
+        end
+        
+        container.first
+        
+      end
+      
+      def get_container_by_id id
+        ::Docker::Container.get(id,connection)
+      end
+      
+      
+      def build_from_dir options={}
+        
+        image_name = options[:image_name]
+        
+        dockerfile_path = options[:build_dir]
+        
+        project_dir = options[:project_dir]
+        
+        no_cache = options[:no_cache]
+        
+        dockerfile_path = determine_dockerfile_path(dockerfile_path, project_dir)
+        
+        
+        image = ::Docker::Image.build_from_dir(dockerfile_path, {"t"=>image_name, "nocache" =>no_cache }) { 
+        |chunk| h1 = ::JSON.parse(chunk); 
+                
+                value = h1.values[0].to_s;
+                
+                puts(::URI.unescape(value)) 
+        
+        }
+      
+        
+        image
+      end
+      
+    end
+  end
+end

data/lib/brick/generators/new_project_generator.rb

@@ -0,0 +1,51 @@
+require "thor/group"
+require "fileutils"
+
+module Brick::Generators
+  class NewProjectGenerator < Thor::Group
+     include Thor::Actions
+    
+     argument :working_dir
+     argument :project_name
+     
+     attr_accessor :project_root
+     
+     def self.source_root
+        File.join(File.dirname(__FILE__), "new_project_generator", "templates")
+     end
+    
+     def create_root
+        self.destination_root = File.expand_path(working_dir)
+        empty_directory(project_name)
+        self.project_root=File.join(working_dir,project_name)
+        FileUtils.cd(project_root)
+    end
+    
+    def fig_file
+      copy_file("fig.yml","#{project_name}/fig.yml")
+      puts "the project is created at #{project_root}"
+    end
+    
+    def init_git
+      puts "Initializing git repo in #{project_root}"
+      FileUtils.cd(project_root)
+      git :init
+      git :add => "."
+      git :commit => "-m 'Initial commit'"
+      
+    end
+    
+    private
+    
+     def git(commands={})
+        if commands.is_a?(Symbol)
+          `git #{commands}`
+        else
+          commands.each do |cmd, options|
+           `git #{cmd} #{options}`
+          end
+        end
+      end
+    
+  end
+end

data/lib/brick/generators/new_service_generator.rb

@@ -0,0 +1,24 @@
+require "thor/group"
+
+module Brick::Generators
+  class NewServiceGenerator < Thor::Group
+     argument :working_dir
+     
+   
+      
+    def create_a
+      puts "a"
+      'a'    
+    end
+    
+    def create_b
+      puts "b"
+      'b'
+    end
+    
+    def create_c
+      puts "c"
+      'c'
+    end
+  end
+end

data/lib/brick/generators.rb

@@ -0,0 +1,10 @@
+module Brick
+  module Generators
+    
+  end
+end
+
+
+require 'brick/generators/new_project_generator'
+
+require 'brick/generators/new_service_generator'

data/lib/brick/mixin/aliasing.rb

@@ -0,0 +1,24 @@
+module Brick::Mixin::Aliasing
+  
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
+    without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+    when public_method_defined?(without_method)
+      public target
+    when protected_method_defined?(without_method)
+      protected target
+    when private_method_defined?(without_method)
+      private target
+    end
+  end
+end

data/lib/brick/mixin/colors.rb

@@ -0,0 +1,24 @@
+require 'set'
+require 'colorize'
+
+module Brick::Mixin::Colors
+  COLORS = [:blue, :red, :yellow, :light_red, :green, :light_green, :light_yellow, :black, :light_black,  :light_blue, :magenta, :light_magenta, :cyan, :light_cyan, :white, :light_white]
+  
+  @@current = -1
+  
+  def determine_color
+    if $stdout.isatty
+      @@current = (@@current+1)%COLORS.size
+    end
+  end
+  
+  def color_generator str
+    
+    if $stdout.isatty
+      
+      str=str.colorize(COLORS[@@current])
+    end
+    
+    str
+  end
+end

data/lib/brick/mixin/convert_to_class_name.rb

@@ -0,0 +1,52 @@
+module Brick
+  module Mixin    
+  end
+end
+
+
+module Brick
+  module Mixin
+    module ConvertToClassName
+      extend self
+
+      def convert_to_class_name(str)
+        str = str.dup
+        str.gsub!(/[^A-Za-z0-9_]/,'_')
+        rname = nil
+        regexp = %r{^(.+?)(_(.+))?$}
+        
+        mn = str.match(regexp)
+        if mn
+          rname = mn[1].capitalize
+
+          while mn && mn[3]
+            mn = mn[3].match(regexp)          
+            rname << mn[1].capitalize if mn
+          end
+        end
+
+        rname
+      end
+      
+      def convert_to_snake_case(str, namespace=nil)
+        str = str.dup
+        str.sub!(/^#{namespace}(\:\:)?/, '') if namespace
+        str.gsub!(/[A-Z]/) {|s| "_" + s}
+        str.downcase!
+        str.sub!(/^\_/, "")
+        str
+      end
+      
+      def snake_case_basename(str)
+        with_namespace = convert_to_snake_case(str)
+        with_namespace.split("::").last.sub(/^_/, '')
+      end
+      
+      def filename_to_qualified_string(base, filename)
+        file_base = File.basename(filename, ".rb")
+        base.to_s + (file_base == 'default' ? '' : "_#{file_base}")
+      end
+      
+    end
+  end
+end