deployku 0.0.1

data/lib/deployku/plugins/access.rb

@@ -0,0 +1,161 @@
+require 'yaml'
+
+module Deployku
+  class AccessPlugin < Deployku::Plugin
+    describe :add, '<USER>', 'adds ssh key for user from STDIN'
+    def add(user_name)
+      allow = check_system_rights(:admin)
+      if !allow && get_users.count > 0
+        # allow add first user without privileges
+        puts "No rights."
+        exit 1
+      end
+      key = $stdin.gets
+      key.chomp! if key
+      if !key || key == ''
+        puts "No key."
+        exit 1
+      end
+      name = Deployku.sanitize_app_name(user_name)
+      user_add(user_name, key)
+      puts "User '#{user_name}' has been added."
+      unless allow
+        # first user
+        acl_system_set(user_name, 'admin')
+      end
+    end
+
+    describe :delete, '<USER>', 'deletes user keys from authorized_keys', acl_sys: :admin
+    def delete(user_name)
+      user_delete(user_name)
+      acl_system_set(user_name, '')
+      apps = Deployku::AppPlugin.instance.get_app_list
+      apps.each { |app| acl_set(app, user_name, '') }
+      puts "All keys for user '#{name}' has been removed."
+    end
+
+    describe :show, '', 'shows authorized_keys file', acl_sys: :admin
+    def show
+      puts File.read(authorized_keys_path)
+    end
+
+    describe :list, '', 'list user names', acl_sys: :admin
+    def list
+      p get_users
+    end
+
+    describe 'acl:set', '<APP> <USER> [LIST OF RIGHTS]', 'add user priviledges to application', acl_sys: :admin
+    def acl_set(app_name, user_name, rights='')
+      name = Deployku.sanitize_app_name(user_name)
+      urights = { name => rights.split(',').map { |r| r.chomp } }
+      rights = {}
+      if File.exists?(app_acl_path(app_name))
+        rights = YAML.load_file(app_acl_path(app_name))
+      end
+      rights.merge!(urights)
+      File.open(app_acl_path(app_name), 'w') do |f|
+        f << rights.to_yaml
+      end
+      puts "Application acl has been updated."
+    end
+
+    describe 'acl:system_set', '<USER> [LIST OF RIGHTS]', 'add system wide privileges', acl_sys: :admin
+    def acl_system_set(user_name, rights='')
+      name = Deployku.sanitize_app_name(user_name)
+      urights = { name => rights.split(',').map { |r| r.chomp } }
+      rights = {}
+      if File.exists?(system_acl_path)
+        rights = YAML.load_file(system_acl_path)
+      end
+      rights.merge!(urights)
+      File.open(system_acl_path, 'w') do |f|
+        f << rights.to_yaml
+      end
+      puts "System rights has been updated."
+    end
+
+    describe 'acl:list', '', 'lists all acls', acl_sys: :admin
+    def acl_list
+      users = get_users
+      apps = Deployku::AppPlugin.instance.get_app_list
+      rights = File.exists?(system_acl_path) ? YAML.load_file(system_acl_path) : {}
+      users.each do |user|
+        puts "#{user}:"
+        puts "  system wide rights: #{rights[user]}"
+        apps.each do |app|
+          app_rights = File.exists?(app_acl_path(app)) ? YAML.load_file(app_acl_path(app)) : {}
+          puts "  #{app}: #{app_rights[user]}"
+        end
+      end
+    end
+
+    describe 'acl:list_rights', '', 'lists available rights', acl_sys: :admin
+    def acl_list_rights
+      puts 'admin'
+      puts 'commit'
+    end
+
+    def check_app_rights(app_name, right, ex=false)
+      p [app_name, right, ex]
+      name = Deployku.sanitize_app_name(ENV['NAME'].to_s)
+      app_rights = File.exists?(app_acl_path(app_name)) ? YAML.load_file(app_acl_path(app_name)) : {}
+      return true if app_rights[name] && (app_rights[name].include?(right.to_s) || app_rights[name].include?('admin'))
+      return check_system_rights(right, ex)
+    end
+
+    def check_system_rights(right, ex=false)
+      p [right, ex]
+      name = Deployku.sanitize_app_name(ENV['NAME'].to_s)
+      rights = File.exists?(system_acl_path) ? YAML.load_file(system_acl_path) : {}
+      return true if rights[name] && (rights[name].include?(right.to_s) || rights[name].include?('admin'))
+      if ex
+        puts "No rights."
+        exit 1
+      end
+      false
+    end
+
+    def user_add(user_name, key)
+      name = Deployku.sanitize_app_name(user_name)
+      File.open(authorized_keys_path, 'a') do |f|
+        f << "command=\"NAME=#{name} `cat #{sshcommand_path}` $SSH_ORIGINAL_COMMAND\",no-agent-forwarding,no-user-rc,no-X11-forwarding,no-port-forwarding #{key}\n"
+      end
+    end
+
+    def user_delete(user_name)
+      name = Deployku.sanitize_app_name(user_name)
+      lines = File.readlines(authorized_keys_path)
+      File.open(authorized_keys_path, 'w') do |f|
+        lines.each do |line|
+          f << "#{line}\n" unless line =~ /NAME=#{name}/
+        end
+      end
+    end
+
+    def get_users
+      users = []
+      File.open(authorized_keys_path, 'r') do |f|
+        while l = f.gets
+          users << $1 if l =~ /NAME=([^\s]+)/
+        end
+      end if File.exists?(authorized_keys_path)
+      users
+    end
+
+    def app_acl_path(app_name)
+      File.join(Deployku::AppPlugin.instance.dir(app_name), 'DEPLOYKU_ACL.yml')
+    end
+
+    def system_acl_path
+      File.join(Deployku::Config.home, '.deployku_acl.yml')
+    end
+
+    def sshcommand_path
+      File.join(Deployku::Config.home, '.sshcommand')
+    end
+
+    def authorized_keys_path
+      File.join(Deployku::Config.home, '.ssh/authorized_keys')
+    end
+  end
+end

data/lib/deployku/plugins/app.rb

@@ -0,0 +1,211 @@
+module Deployku
+  class AppPlugin < Deployku::Plugin
+    include Deployku::Configurable
+    include Deployku::Containerable
+
+    def initialize
+      @config = {
+        'env' => {},
+        'links' => []
+      }
+    end
+
+    describe :create, '<APP>', 'creates new application', acl_sys: :admin
+    def create(app_name)
+      app_dir = dir(app_name)
+      unless Dir.exists?(app_dir)
+        Dir.mkdir(app_dir)
+        system "git init -q --bare '#{app_dir}'"
+      end
+      app_dir
+    end
+
+    describe :delete, '<APP>', 'deletes an existing application', acl_sys: :admin
+    def delete(app_name)
+      app_dir = dir(app_name)
+      if Dir.exists?(app_dir)
+        FileUtils.rm_rf(app_dir)
+      end
+    end
+
+    describe :list, '', 'list available applications', acl_sys: :admin
+    def list
+      apps = get_app_list
+      apps.each { |app| puts app }
+    end
+
+    describe :status, '<APP>', 'show container status', acl_app: { 0 => :commit }
+    describe :start, '<APP>', 'starts container', acl_app: { 0 => :admin }
+    def start(app_name)
+      super(app_name)
+      result = true
+      plugins = Deployku::Plugin.filter_plugins(:after_start)
+      plugins.each do |plug|
+        result = result && plug.after_start(app_name)
+      end
+      result
+    end
+    describe :run, '<APP> <CMD>', 'starts a cmd in application environment', acl_app: { 0 => :admin }
+    describe :stop, '<APP>', 'stops running container', acl_app: { 0 => :admin }
+    describe :restart, '<APP>', 'restarts container', acl_app: { 0 => :admin }
+    describe :logs, '<APP>', 'show app logs', acl_app: { 0 => :admin }
+
+    describe :rebuild, '<APP> [REV]', 'rebuild container', acl_app: { 0 => :admin }
+    def rebuild(app_name, new_rev=nil)
+      app_dir = dir(app_name)
+      app_name = File.basename(app_dir)
+      Dir.mktmpdir('deployku_') do |tmp_dir|
+        tmp_app_dir = File.join(tmp_dir, 'app')
+        Dir.mkdir(tmp_app_dir)
+        system "git clone -q '#{app_dir}' '#{tmp_app_dir}'"
+        Dir.chdir(tmp_app_dir)
+        system "unset GIT_DIR GIT_WORK_TREE && git checkout #{new_rev}" if new_rev
+        system 'unset GIT_DIR GIT_WORK_TREE && git submodule update --init --recursive'
+        Dir.chdir(tmp_dir)
+
+        plugins = Deployku::Plugin.filter_plugins(:detect)
+        plugin = nil
+        plugins.each do |plug|
+          if plug.detect(tmp_app_dir)
+            plugin = plug
+            break
+          end
+        end
+
+        deployku_config_path = File.join(tmp_app_dir, 'deployku.yml')
+        Deployku::Config.load(deployku_config_path)
+        Deployku::Config.load(config_path(app_name))
+        config_load(app_name)
+
+        unless plugin
+          puts "Unsupported application type"
+          exit 1
+        else
+          if plugin.respond_to?(:port) && !@config['port']
+            config_set_port(app_name, plugin.port)
+            Deployku::Config.merge!({ port: plugin.port })
+          end
+
+          plugin.build_start_script(tmp_dir)
+          case Deployku::Config.engine
+            when 'docker'
+              plugin.build_dockerfile(tmp_dir)
+            when 'lxc'
+              puts 'not implemented'
+          end
+        end
+
+        if Deployku::Engine.rebuild(app_name, tmp_dir)
+          plugin.volumes.each do |volume|
+            config_add_volume(app_name, volume)
+          end if plugin.respond_to?(:volumes)
+
+          restart(app_name)
+        else
+          exit 1
+        end
+      end
+    end
+
+    describe 'config:show', '<APP>', 'shows app configuration', acl_app: { 0 => :admin }
+    describe 'config:set', '<APP> <ENV_VARIABLE> <VALUE>', 'sets environment variable', acl_app: { 0 => :admin }
+    describe 'config:unset', '<APP> <ENV_VARIABLE>', 'unsets environment variable', acl_app: { 0 => :admin }
+    describe 'config:set_from', '<APP> <VALUE>', 'sets base image name for container', acl_app: { 0 => :admin }
+    describe 'config:unset_from', '<APP>', 'sets base image to default', acl_app: { 0 => :admin }
+    describe 'config:set_engine', '<APP> <ENGINE>', 'sets container engine (docker, lxc)', acl_app: { 0 => :admin }
+    describe 'config:unset_engine', '<APP>', 'sets engine to default', acl_app: { 0 => :admin }
+    describe 'config:set_port', '<APP> <PORT>', 'sets port on which will application listen', acl_app: { 0 => :admin }
+    describe 'config:unset_port', '<APP>', 'remove port setting', acl_app: { 0 => :admin }
+
+    describe 'config:add_domain', '<APP> <DOMAIN>', 'bind domain with application', acl_app: { 0 => :admin }
+    def config_add_domain(app_name, domain)
+      config_load(app_name)
+      @config['domains'] ||= []
+      @config['domains'] << domain
+      config_save(app_name)
+    end
+
+    describe 'config:rm_domain', '<APP> <DOMAIN>', 'removes domain from the list', acl_app: { 0 => :admin }
+    def config_rm_domain(app_name, package)
+      config_load(app_name)
+      if @config['domains']
+        @config['domains'].delete(package)
+        config_save(app_name)
+      end
+    end
+
+    describe 'config:add_package', '<APP> <PACKAGE>', 'will install additional package when rebuild', acl_app: { 0 => :admin }
+    def config_add_package(app_name, package)
+      config_load(app_name)
+      @config['packages'] ||= []
+      @config['packages'] << package
+      config_save(app_name)
+    end
+
+    describe 'config:rm_package', '<APP> <PACKAGE>', 'removes package from the list', acl_app: { 0 => :admin }
+    def config_rm_package(app_name, package)
+      config_load(app_name)
+      if @config['packages']
+        @config['packages'].delete(package)
+        config_save(app_name)
+      end
+    end
+
+    describe 'config:add_volume', '<APP> <PATH>', 'mounts container path to app directory', acl_app: { 0 => :admin }
+    def config_add_volume(app_name, path)
+      config_load(app_name)
+      vpath = volume_path(app_name, path)
+      unless Dir.exists?(vpath)
+        FileUtils.mkpath(vpath)
+      end
+      @config['volumes'] ||= {}
+      @config['volumes'][vpath] = path unless @config['volumes'][vpath]
+      config_save(app_name)
+    end
+
+    describe 'config:rm_volume', '<APP> <PATH>', 'removes volume', acl_app: { 0 => :admin }
+    def config_rm_volume(app_name, path)
+      config_load(app_name)
+      vpath = volume_path(app_name, path)
+      if @config['volumes']
+        @config['volumes'].delete(vpath)
+        config_save(app_name)
+      end
+    end
+
+    describe 'link', '<APP> <LINK>', 'adds link', acl_sys: :admin
+    def link(app_name, link)
+      config_load(app_name)
+      @config['links'] ||= []
+      @config['links'] << link
+      config_save(app_name)
+    end
+
+    describe 'unlink', '<APP> <LINK>', 'removes link', acl_sys: :admin
+    def unlink(app_name, link)
+      config_load(app_name)
+      if @config['links']
+        @config['links'].delete(link)
+        config_save(app_name)
+      end
+    end
+
+    def volume_path(app_name, path)
+      volume = Deployku.sanitize_app_name(path)
+      File.join(dir(app_name), 'DEPLOYKU_VOLUMES', volume)
+    end
+
+    def dir(app_name)
+      File.join(Deployku::Config.home, Deployku.sanitize_app_name(app_name))
+    end
+
+    def get_app_list
+      apps = []
+      Dir.glob(File.join(Deployku::Config.home, '*')) do |path|
+        apps << File.basename(path) if File.directory?(path)
+      end
+      apps
+    end
+
+  end
+end

data/lib/deployku/plugins/docker.rb

@@ -0,0 +1,77 @@
+require 'json'
+
+module Deployku
+  class DockerEngine < Deployku::Plugin
+    include Deployku::Engine
+
+    def start(app_name, app_dir=nil, name=nil)
+      args = build_args(app_name, app_dir, name)
+      hash = `docker run -d -P #{args.join(' ')} #{app_name}:latest`.chomp
+      if $?.exitstatus != 0 && name
+        hash = `docker start '#{name}'`.chomp
+      end
+      hash
+    end
+
+    def run(app_name, app_dir, *cmd)
+      args = build_args(app_name, app_dir)
+      system "docker run -t -i --rm --entrypoint=/bin/bash #{args.join(' ')} #{app_name}:latest -c \"#{cmd.join(' ')}\""
+    end
+
+    def stop(app_hash)
+      system "docker stop #{app_hash}"
+    end
+
+    def logs(app_hash)
+      system "docker logs #{app_hash}"
+    end
+
+    def rebuild(app_name, dir)
+      system "docker build -t #{app_name}:latest #{dir}"
+    end
+
+    def running?(app_hash)
+      stat = JSON.parse(`docker inspect #{app_hash}`).first
+      return stat['State']['Running'] if stat && stat['State']
+      nil
+    end
+
+    def ip(app_hash)
+      stat = JSON.parse(`docker inspect #{app_hash}`).first
+      return stat['NetworkSettings']['IPAddress'] if stat && stat['NetworkSettings']
+      nil
+    end
+
+    protected
+
+    def build_args(app_name, app_dir, name=nil)
+      args = []
+      if app_dir && Deployku::Config.env
+        env_path = File.join(app_dir, 'DEPLOYKU_ENV')
+        File.open(env_path, 'w') do |f|
+          Deployku::Config.env.each do |key, value|
+            f << "#{key}=#{value}\n"
+          end
+        end
+        args << "--env-file='#{env_path}'"
+      end
+
+      if app_dir && Deployku::Config.volumes && Deployku::Config.volumes.count > 0
+        Deployku::Config.volumes.each do |src, dst|
+          args << "--volume='#{src}:#{dst}'"
+        end
+      end
+
+      if app_dir && Deployku::Config.links && Deployku::Config.links.count > 0
+        Deployku::Config.links.each do |link|
+          args << "--link='#{link}'"
+        end
+      end
+
+      if name
+        args << "--name='#{name}'"
+      end
+      args
+    end
+  end
+end

data/lib/deployku/plugins/git.rb

@@ -0,0 +1,56 @@
+require 'tmpdir'
+
+module Deployku
+  class GitPlugin < Deployku::Plugin
+    # describe :receive_pack, '<APP>', 'receives new commit'
+    def receive_pack app_name
+      unless app_name
+        exit 1
+      end
+      app_name = app_name.gsub(%r{'([^']+)'}, '\1')
+      app_dir = Deployku::AppPlugin.instance.create(app_name)
+      create_receive_hook(app_dir, File.basename(app_dir))
+      system "git-shell -c \"git-receive-pack '#{app_dir}'\""
+    end
+
+    describe :hook, '<APP>', 'receives new commit and builds new image', acl_app: { 0 => :commit }
+    def hook(app_name)
+      exit 1 unless app_name
+      app_dir = Deployku::AppPlugin.instance.dir(app_name)
+      app_name = File.basename(app_dir)
+      unless Dir.exists?(app_dir)
+        puts "Application directory '#{app_dir}' does not exist."
+        exit 1
+      end
+
+      while line = $stdin.gets
+        old_rev, new_rev, branch = line.chomp.split(' ')
+        if branch != 'refs/heads/master'
+          puts 'Only master branch is supported now.'
+          exit 1
+        end
+      end
+      unless new_rev
+        puts 'Missing new revision number'
+        exit 1
+      end
+      Deployku::AppPlugin.instance.rebuild(app_name, new_rev)
+    end
+
+    protected
+
+    def create_receive_hook(app_dir, app_name)
+      receive_hook_path = File.join(app_dir, 'hooks/pre-receive')
+      File.open(receive_hook_path, 'w') do |f|
+        f << <<EOF
+#!/usr/bin/env bash
+set -e; set -o pipefail;
+
+cat | #{$0} git:hook '#{app_name}'
+EOF
+      end
+      File.chmod(0755, receive_hook_path)
+      receive_hook_path
+    end
+  end
+end

data/lib/deployku/plugins/lxc.rb

@@ -0,0 +1,5 @@
+module Deployku
+  class LxcEngine < Deployku::Plugin
+    include Deployku::Engine
+  end
+end

data/lib/deployku/plugins/nginx.rb

@@ -0,0 +1,140 @@
+require 'securerandom'
+require 'net/http'
+
+module Deployku
+  class NginxPlugin < Deployku::Plugin
+    describe :enable, '<APP>', 'enable nginx for application', acl_app: { 0 => :admin }
+    def enable(app_name)
+      app_plug = Deployku::AppPlugin.new
+      app_plug.config_load(app_name)
+      app_plug.config['nginx'] = {} unless app_plug.config['nginx']
+      app_plug.config['nginx']['enabled'] = true
+      app_plug.config['nginx']['port'] = 80 unless app_plug.config['nginx']['port']
+      app_plug.config['nginx']['wait'] = 300 unless app_plug.config['nginx']['wait']
+      app_plug.config['nginx']['public_volume'] = '/app/public/' unless app_plug.config['nginx']['public_volume']
+      app_plug.config_save(app_name)
+    end
+
+    describe :disable, '<APP>', 'disable nginx for application', acl_app: { 0 => :admin }
+    def disable(app_name)
+      app_plug = Deployku::AppPlugin.new
+      app_plug.config_load(app_name)
+      if app_plug.config['nginx']
+        app_plug.config['nginx']['enabled'] = false
+        app_plug.config_save(app_name)
+      end
+    end
+
+    describe 'config:set', '<APP> <NAME> <VALUE>', 'sets nginx parametr', acl_app: { 0 => :admin }
+    def config_set(app_name, name, value)
+      app_plug = Deployku::AppPlugin.new
+      app_plug.config_load(app_name)
+      app_plug.config['nginx'] = {} unless app_plug.config['nginx']
+      app_plug.config['nginx'][name] = value
+      app_plug.config_save(app_name)
+    end
+
+    describe 'config:unset', '<APP> <NAME>', 'unsets nginx parametr', acl_app: { 0 => :admin }
+    def config_unset(app_name, name, value)
+      app_plug = Deployku::AppPlugin.new
+      app_plug.config_load(app_name)
+      if app_plug.config['nginx']
+        app_plug.config['nginx'].delete(name)
+        app_plug.config_save(app_name)
+      end
+    end
+
+    describe 'config:build', '<APP>', 'rebuild config for an application', acl_app: { 0 => :admin }
+    def config_build(app_name)
+      app_plug = Deployku::AppPlugin.new
+      app_plug.config_load(app_name)
+      cid = app_plug.get_container_id(app_name)
+      ip = Deployku::Engine.ip(cid)
+      upstream = SecureRandom.uuid.gsub('-', '')
+      vpath = app_plug.volume_path(app_name, app_plug.config['nginx']['public_volume'])
+      domains = app_plug.config['domains']
+      if !domains || domains.empty?
+        puts "No domains."
+        exit 1
+      end
+      unless app_plug.config['port']
+        puts "No application port."
+        exit 1
+      end
+      File.open(config_path(app_name), 'w') do |f|
+        f << <<EOF
+upstream #{upstream} {
+  server #{ip}:#{app_plug.config['port']};
+}
+
+server {
+  listen #{app_plug.config['nginx']['port']};
+  server_name #{domains.join(' ')};
+  root #{vpath};
+
+  gzip on;
+  gzip_http_version 1.1;
+  gzip_vary on;
+  gzip_comp_level 6;
+  gzip_proxied any;
+  gzip_types text/plain text/html text/css application/json application/javascript application/x-javascript text/javascript text/xml application/xml application/rss+xml application/atom+xml application/rdf+xml;
+
+  location / {
+    try_files $uri @#{upstream};
+  }
+
+  location @#{upstream} {
+    proxy_read_timeout 300;
+    proxy_connect_timeout 300;
+    proxy_redirect off;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    proxy_set_header Host $http_host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header CLIENT_IP $remote_addr;
+    proxy_set_header GEOIP_COUNTRY_CODE $geoip_country_code;
+    proxy_pass http://#{upstream};
+  }
+}
+EOF
+      end
+    end
+
+    def after_start(app_name)
+      app_plug = Deployku::AppPlugin.new
+      app_plug.config_load(app_name)
+      if app_plug.config['nginx'] && app_plug.config['nginx']['enabled']
+        config_build(app_name)
+        cid = app_plug.get_container_id(app_name)
+        ip = Deployku::Engine.ip(cid)
+        counter = 0
+        $stdout.sync = true
+        while counter <= app_plug.config['nginx']['wait'].to_i && !up?(ip, app_plug.config['port'])
+          puts "wainting for webserver...#{counter+1}"
+          sleep 1
+          counter += 1
+        end
+        if counter > app_plug.config['nginx']['wait'].to_i
+          puts "timeouted"
+          return false
+        else
+          system 'sudo nginx -s reload'
+        end
+      end
+      true
+    end
+
+    def up?(server, port)
+      begin
+        http = Net::HTTP.start(server, port, {open_timeout: 5, read_timeout: 5})
+        response = http.head("/")
+        response.code == "200"
+      rescue #Timeout::Error, SocketError
+        false
+      end
+    end
+
+    def config_path(app_name)
+      File.join(Deployku::AppPlugin.instance.dir(app_name), 'nginx.conf')
+    end
+  end
+end