appril 0.0.3 → 0.0.4

data/lib/appril/cli/docker/build.rb

@@ -1,150 +0,0 @@
-module Appril
-  class CLI
-    module Docker
-      class Build
-
-        def initialize dir, update_runner_only: false, push_opted: false
-          Dir.chdir dir do
-
-            config = load_config
-            validate_config(config)
-
-            build_dir = Pathname.new(File.expand_path('__tmpbuildir__'))
-
-            prepare_build_dir(build_dir)
-
-            install_files(build_dir)
-
-            app_dir = Pathname.new(File.expand_path(config['APP_DIR']))
-
-            if update_runner_only
-              puts "Skipping image building"
-            else
-              prepare_build(build_dir, app_dir)
-
-              image_built = build_image(build_dir, config['IMAGE_NAME'], config['BUILD_OPTS'])
-
-              if image_built && push_opted
-                push_image(config['IMAGE_NAME'])
-              end
-            end
-
-            puts "Installing run script"
-            install_run_script(app_dir, *config.values_at('IMAGE_NAME', 'CONTAINER_NAME', 'RUN_SCRIPT', 'RUN_OPTS'))
-
-            FileUtils.rm_rf(build_dir)
-          end
-        end
-
-        def load_config
-          YAML.load(File.read(CONFIG_FILE))
-        end
-
-        def validate_config config
-          {
-            'IMAGE_NAME' => :validate_config__image_name,
-            'CONTAINER_NAME' => :validate_config__container_name,
-            'APP_DIR' => :validate_config__app_dir,
-            'RUN_SCRIPT' => :validate_config__run_script,
-          }.each_pair do |key,validator|
-            next if send(validator, config[key])
-            puts "", "\t::: Please set #{key} in config.yml :::", ""
-            exit 1
-          end
-        end
-
-        def validate_config__image_name value
-          !value.nil? && !value.empty?
-        end
-
-        def validate_config__container_name value
-          !value.nil? && !value.empty? && value.values.any?
-        end
-
-        def validate_config__app_dir value
-          !value.nil? && !value.empty?
-        end
-
-        def validate_config__run_script value
-          !value.nil? && !value.empty?
-        end
-
-        def prepare_build_dir dir
-          FileUtils.rm_rf(dir)
-          FileUtils.mkdir_p(dir / 'build')
-        end
-
-        def install_files dir
-          install_dockerfile(dir)
-          install_start_file(dir)
-          install_build_files(dir)
-          install_cleanup_file(dir)
-        end
-
-        def install_dockerfile dir
-          FileUtils.cp(BASE_DIR / 'Dockerfile', dir)
-        end
-
-        def install_start_file dir
-          File.open dir / 'start', 'w' do |f|
-            f << File.read(BASE_DIR / 'start').sub('{start}', File.read(START_FILE))
-          end
-        end
-
-        def install_build_files dir
-          FileUtils.cp(PREPARE_BUILD_FILE, dir / 'build')
-          FileUtils.cp(BUILD_FILE, dir / 'build/build')
-        end
-
-        def install_cleanup_file dir
-          FileUtils.cp(CLEANUP_FILE, dir / 'build/cleanup')
-        end
-
-        def prepare_build dir, app_dir
-          Dir.chdir dir / 'build' do
-            CLI.run "APP_DIR=#{app_dir} #{PREPARE_BUILD_FILE}"
-            exit 1 unless $? && $?.success?
-          end
-        end
-
-        def build_image dir, image_name, build_opts
-          CLI.run "docker build -t #{image_name} #{build_opts} '#{dir}'"
-          $? && $?.success?
-        end
-
-        def push_image image_name
-          CLI.run "docker push #{image_name}"
-          $? && $?.success?
-        end
-
-        def install_run_script app_dir, image_name, container_name, run_script, run_opts
-          FileUtils.mkdir_p(app_dir / File.dirname(run_script))
-
-          script_path = app_dir / run_script
-
-          File.open script_path, 'w' do |f|
-            f << File.read(BASE_DIR / 'run').
-              gsub('{image}', image_name).
-              gsub('{script_path_traversal}', script_path_traversal(run_script)).
-              gsub('{run_opts}', run_opts).
-              gsub('{environments}', container_name.keys.join(' ')).
-              gsub('{container_definitions}', container_definitions(container_name))
-          end
-
-          FileUtils.chmod('+x', script_path)
-        end
-
-        def container_definitions container_name
-          container_name.map do |kv|
-            '[ "$APP_ENV" = "%s" ] && CONTAINER_NAME="%s"' % kv
-          end.join("\n")
-        end
-
-        def script_path_traversal run_script
-          run_script.gsub(/\A\/+|\/+\Z/, '').scan(/\/+/).map {'..'}*'/'
-        end
-
-      end
-    end
-  end
-end

data/lib/appril/cli/docker/install.rb

@@ -1,21 +0,0 @@
-module Appril
-  class CLI
-    module Docker
-      class Install
-        include Helpers
-
-        def initialize dir, working_dir_opted: false
-          install(dir, working_dir_opted)
-          make_executable(dir / PREPARE_BUILD_FILE)
-          puts "Done. All files installed into #{dir}"
-        end
-
-        def install dir, working_dir_opted
-          src = working_dir_opted ? BASE_DIR.to_path + '/skel/.' : BASE_DIR / 'skel'
-          FileUtils.cp_r(src, dir)
-        end
-
-      end
-    end
-  end
-end

data/lib/appril/cli/docker/update.rb

@@ -1,24 +0,0 @@
-module Appril
-  class CLI
-    module Docker
-      class Update
-        include Helpers
-
-        def initialize dir
-          Dir.chdir BASE_DIR / 'skel' do
-
-            Dir['**/*'].select {|e| File.file?(e)}.each do |file|
-              next if File.file?(dir / file)
-              create_dirname_for(dir / file)
-              puts "Installing #{File.basename(dir)}/#{file}"
-              FileUtils.cp(file, dir / file)
-            end
-
-          end
-          puts "Done"
-        end
-
-      end
-    end
-  end
-end

data/lib/appril/cli/docker.rb

@@ -1,16 +0,0 @@
-module Appril
-  class CLI
-    module Docker
-      BASE_DIR = (Appril::BASE_DIR / 'docker').freeze
-      CONFIG_FILE = './config.yml'.freeze
-      START_FILE  = './start.sh'.freeze
-      PREPARE_BUILD_FILE = './prepare_build.sh'.freeze
-      BUILD_FILE = './build.sh'.freeze
-      CLEANUP_FILE = './cleanup.sh'.freeze
-    end
-  end
-end
-
-require 'appril/cli/docker/install'
-require 'appril/cli/docker/build'
-require 'appril/cli/docker/update'

data/lib/appril/cli/generator.rb

@@ -1,15 +0,0 @@
-module Appril
-  class CLI
-    class Generator
-      class API
-        include Helpers
-
-        def initialize gen_dir, api_dir, api_name
-          FileUtils.cp_r(gen_dir, api_dir)
-          puts "Done"
-        end
-
-      end
-    end
-  end
-end

data/lib/appril/cli/helpers.rb

@@ -1,47 +0,0 @@
-module Appril
-  class CLI
-    module Helpers
-
-      def display_error error
-        puts "", "\t::: #{error} :::", ""
-      end
-
-      def fatal_error! error, exit_code = 1
-        display_error(error)
-        exit exit_code
-      end
-
-      def expanded_path *path
-        Pathname.new(File.expand_path(File.join(*path.map(&:to_s))))
-      end
-
-      def create_dirname_for dir
-        FileUtils.mkdir_p(File.dirname(dir))
-      end
-
-      def make_executable *entries
-        entries.flatten.each {|e| FileUtils.chmod('+x', e)}
-      end
-
-      def working_dir_opted? opted_dir
-        opted_dir == '.'
-      end
-
-      def extract_namespace args
-        return unless index = args.index('-n')
-        return unless namespace = args[index + 1]
-        if namespace =~ /::/
-          fatal_error! "Nested namespaces not supported"
-        end
-        if namespace =~ /\W/
-          fatal_error! "Namespace may contain only alphanumerics"
-        end
-        unless namespace =~ /\A[A-Z]/
-          fatal_error! "Namespace should start with a capital letter"
-        end
-        namespace
-      end
-
-    end
-  end
-end

data/lib/appril/cli.rb

@@ -1,204 +0,0 @@
-require 'fileutils'
-require 'pathname'
-require 'yaml'
-require 'pty'
-require 'appril/version'
-require 'appril/cli/helpers'
-require 'appril/cli/assertions'
-
-module Appril
-  BASE_DIR = Pathname.new(File.expand_path('../../..', __FILE__))
-  BOILERPLATE_DIR = BASE_DIR / 'boilerplate'
-
-  class CLI
-    include Helpers
-    include Assertions
-
-    def initialize args
-      case command = args[0]
-      when 'a', 'app'
-        app(args)
-      when 'g', 'gen', 'generate'
-        generator(args)
-      when 'd', 'docker'
-        docker(args)
-      when 'v', '-v', '--version'
-        puts Appril::VERSION
-      when nil, '-h', '--help'
-        usage
-      else
-        display_error "Unknown command #{command}"
-        usage
-      end
-    end
-
-
-    def usage
-      puts "
-      Arguments in round brackets are required.
-      Arguments in square brackets are optional.
-
-
-      === Install a new app ===
-      $ appril (app || a) (install || i) (dir || .) [-crudle]
-      * If -crudle option provided it will install a Crudle app
-
-      === Update existing app ===
-      $ appril (app || a) (update || u) (dir || .)
-
-      === Generate a new API ===
-      $ appril (generate || g) (api) (api name) (dir || .)
-
-      === Install Docker builder ===
-      $ appril (docker || d) (install || i) (dir || .)
-
-      === Update Docker builder ===
-      $ appril (docker || d) (update || u) (dir || .)
-
-      === Build Docker image and install run script ===
-      $ appril (docker || d) (build || b) (dir || .) [-u] [-p]
-      * If -u option provided it will only update the run script without building the image.
-      * If -p option provided it will try to push the image to Docker registry after successful build.
-
-      === Usage ===
-      $ appril [-h || --help]
-      ".split("\n").map {|l| "\t" + l.strip}.join("\n")
-    end
-
-
-    begin # App
-      def app args
-        opted_dir = args[2]
-        assert_directory_provided(opted_dir)
-        dir = expanded_path(opted_dir)
-
-        case instruction = args[1]
-        when 'i', 'install'
-
-          app_install(dir, {
-            working_dir_opted: working_dir_opted?(opted_dir),
-            namespace: extract_namespace(args),
-            crudle_app: args.find {|a| a == '-crudle'}
-          })
-
-        when 'u', 'update'
-
-          app_update(dir)
-
-        else
-          unknown_instruction_error!(instruction, 'install (or i)', 'update (or u)')
-        end
-      end
-
-      def app_install dir, opts
-        create_dirname_for(dir)
-        assert_installable_dir(dir, opts[:working_dir_opted])
-        App::Install.new(dir, opts)
-      end
-
-      def app_update dir
-        assert_is_app_dir(dir)
-        App::Update.new(dir)
-      end
-    end
-
-
-    begin # Generator
-      def generator args
-
-        case instruction = args[1]
-        when 'api', 'a'
-          api_name = args[2]
-          assert_valid_api_name_given(api_name)
-
-          app_dir = args[3]
-          assert_directory_provided(app_dir)
-          app_dir = expanded_path(app_dir)
-          assert_is_app_dir(app_dir)
-
-          gen_dir = app_dir / 'generators/api'
-          assert_directory_exists(gen_dir)
-
-          api_dir = app_dir / "base/api/#{api_name}"
-          assert_directory_does_not_exists(api_dir)
-
-          Generator::API.new(gen_dir, api_dir, api_name)
-        else
-          unknown_instruction_error!(instruction, 'api (or a)')
-        end
-      end
-    end
-
-
-    begin # Docker
-      def docker args
-        opted_dir = args[2]
-        assert_directory_provided(opted_dir)
-        dir = expanded_path(opted_dir)
-
-        case instruction = args[1]
-        when 'i', 'install'
-
-          docker_install(dir, working_dir_opted: working_dir_opted?(opted_dir))
-
-        when 'b', 'build'
-
-          docker_build(dir, {
-            update_runner_only: args.find {|a| a == '-u'},
-            push_opted: args.find {|a| a == '-p'}
-          })
-
-        when 'u', 'update'
-
-          docker_update(dir)
-
-        else
-          unknown_instruction_error!(instruction, 'install (or i)', 'build (or b)', 'update (or u)')
-        end
-      end
-
-      def docker_install dir, opts
-        create_dirname_for(dir)
-        assert_installable_dir(dir, opts[:working_dir_opted])
-        Docker::Install.new(dir, opts)
-      end
-
-      def docker_build dir, opts
-        assert_directory_exists(dir)
-        assert_config_file_exists(dir)
-        Docker::Build.new(dir, opts)
-      end
-
-      def docker_update dir
-        assert_is_docker_dir(dir)
-        Docker::Update.new(dir)
-      end
-    end
-
-
-    def unknown_instruction_error! instruction, *available_instructions
-      fatal_error! "Unknown instruction #{instruction}. Use one of #{available_instructions*', '}"
-    end
-
-
-    def self.run cmd
-      puts "", "$ #{cmd}"
-      PTY.spawn cmd do |r, w, pid|
-        begin
-          r.sync
-          r.each_char do |char|
-            print(char)
-          end
-        rescue Errno::EIO => e
-          # simply ignoring this
-        ensure
-          Process.wait(pid)
-        end
-      end
-    end
-  end
-end
-
-require 'appril/cli/app'
-require 'appril/cli/generator'
-require 'appril/cli/docker'