appril 0.0.0

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

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,197 @@
+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__)).freeze
+
+  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 "
+      === Install a new app ===
+      $ appril [app || a] [install || i] [dir || .]
+
+      === Update existing app ===
+      $ appril [app || a] [update || u] [dir || .]
+
+      === Generate a new API ===
+      $ appril [generate || g] [api || a] [api name] [dir || .]
+
+      === Install Docker recipes ===
+      $ appril [docker || d] [install || i] [dir || .]
+
+      === Update Docker recipes ===
+      $ 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)
+          })
+
+        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'

data/lib/appril/rtcp_controller.rb

@@ -0,0 +1,103 @@
+module Appril
+  class RTCPController < BaseController
+    attr_reader :socket
+
+    def get
+      return unless websocket?
+
+      @router = RocketIO::Router.new(*RocketIO.controllers)
+
+      @socket = Tubesock.hijack(env)
+      @socket.onopen(&method(:on_open))
+      @socket.onmessage(&method(:on_message))
+      @socket.onclose(&method(:on_close))
+      @socket.listen
+
+      halt websocket_response
+    end
+
+    private
+
+    def on_open
+      connected
+      write(serial: 0, data: __initialization_data__.update(initialization_data))
+    end
+
+    def __initialization_data__
+      {
+        client_url: Cfg.client_url
+      }
+    end
+
+    def on_message msg
+
+      msg = indifferent_params(JSON.parse(msg))
+      if controller = resolve_controller(msg[:controller])
+        status, _, body = call_controller(controller, msg[:method], msg[:arguments], msg[:serial])
+        if body.is_a?(Proc)
+          body.call
+          return
+        end
+        if status == 200
+          write(serial: msg[:serial], data: body) if msg[:reply]
+          return
+        end
+      else
+        body = '404: Not Found'
+      end
+
+      error = if body.is_a?(Array) && body.size == 1
+        body[0]
+      else
+        body
+      end
+
+      if msg && msg[:serial]
+        write(serial: msg[:serial], error: error)
+      else
+        write(error: error)
+      end
+
+    rescue Errno::EPIPE => e
+      close
+    rescue Exception => e
+      __error__(500, e)
+    end
+
+    def on_close
+      @socket.close! if @socket
+      @socket, @user, @router = nil
+      disconnected
+    end
+
+    def resolve_controller url
+      @router.resolve_path(url)[0]
+    end
+
+    def call_controller controller, method, arguments, serial
+      controller.initialize_controller(method, arguments).call(env.merge(rtcp_serial: serial).update(rtcp_env))
+    end
+
+    def write data
+      @socket.send_data(data.to_json)
+    end
+
+    # called after socket connection established
+    def connected
+    end
+
+    # data sent to client after connection established
+    def initialization_data
+      {}
+    end
+
+    # merged into original env when calling a controller
+    def rtcp_env
+      {}
+    end
+
+    # called when socket connection closed
+    def disconnected
+    end
+  end
+end

data/lib/appril/version.rb

@@ -0,0 +1,3 @@
+module Appril
+  VERSION = '0.0.0'.freeze
+end

data/lib/appril.rb

@@ -0,0 +1,124 @@
+require 'rocketio'
+
+module Appril
+  extend self
+
+  def load_config dir, env = RocketIO.environment
+
+    config = load_config_file("#{dir}/config.yml")
+    config.update(load_config_file("#{dir}/env/#{env}.yml"))
+    config[:environment] = env.to_s.freeze
+
+    Dir["#{dir}/**/*.yml"].each do |file|
+      next if File.dirname(file) == './env'
+
+      key = File.basename(file, '.yml')
+      next if key == 'config' || key == 'appril'
+
+      key_config = load_config_file(file)
+      key_config_keys = key_config.keys.map(&:to_s)
+
+      config[key] = if key_config_keys.include?(env.to_s)
+        # current environment found, use it
+        key_config[env]
+      else
+        if RocketIO::ENVIRONMENTS.keys.find {|k| key_config_keys.include?(k)}
+          # there are some environment(s), but no current one so set current environment to nil
+          nil
+        else
+          # there are no environments, so this config is available on any environment
+          key_config
+        end
+      end
+
+    end
+
+    def config.method_missing key
+      self[key]
+    end
+
+    config
+  end
+
+
+  def load_config_file file
+    RocketIO.indifferent_params(YAML.load(File.read(file)) || {})
+  end
+
+
+  def controllers_map dir
+    path_to_api = File.expand_path('base/api', dir)
+    RocketIO.controllers.each_with_object([]) do |controller,o|
+      next unless controller.dirname[path_to_api]
+
+      o << {
+        path: controller.dirname.sub(path_to_api, '').gsub(/\A\/|\/\Z/, ''),
+        url: controller.url,
+        url_pattern: url_pattern(controller),
+        name: controller.name.gsub('::', '__'),
+        api: controller.api
+      }
+    end.sort do |a,b|
+      b[:url].split('/').size <=> a[:url].split('/').size
+    end
+  end
+
+
+  def webpack_entries dir, controllers
+    entries = controllers.each_with_object({}) do |controller,o|
+
+      next unless entry = %w[
+        ./base/api/%s/client.js
+        ./base/api/%s/client.coffee
+      ].map {|p| p % controller[:path]}.find {|f| File.file?(File.expand_path(f, dir))}
+
+      o[controller[:path]] = File.join('./base/api', controller[:path], File.basename(entry))
+    end
+
+    if core = %w[
+        ./base/core.js
+        ./base/core.coffee
+      ].find {|f| File.file?(File.expand_path(f, dir))}
+      entries[:core] = core
+    end
+
+    entries
+  end
+
+
+  def generate_configs dir
+    config = load_config("#{dir}/config", :development)
+
+    controllers = controllers_map(dir)
+    webpack_entries = webpack_entries(dir, controllers)
+
+    File.open File.expand_path('config.json', dir), 'w' do |f|
+      f << JSON.pretty_generate({
+        controllers: controllers,
+        webpack: {
+          path: config[:client_path],
+          url: config[:client_url],
+          entries: webpack_entries
+        }
+      })
+    end
+  end
+
+
+  def url_pattern controller
+    controller.url *controller.instance_method(:get).parameters.each_with_object([]) {|param,o|
+      pattern = if param[0] == :rest
+        "*"
+      elsif param[0] == :req
+        ":#{param[1]}"
+      elsif param[0] == :opt
+        ":#{param[1]}?"
+      end
+      o << pattern if pattern
+    }
+  end
+
+end
+
+require 'appril/base_controller'
+require 'appril/rtcp_controller'