deployku 0.0.1

data/lib/deployku/plugins/postgres.rb

@@ -0,0 +1,139 @@
+require 'fileutils'
+require 'yaml'
+require 'securerandom'
+require 'open3'
+
+module Deployku
+  class PostgresPlugin < Deployku::Plugin
+    include Deployku::Configurable
+    include Deployku::Containerable
+
+    def initialize
+      @config = {
+        'from' => 'postgres',
+        'env' => {}
+      }
+    end
+
+    describe :create, '<NAME>', 'creates new PostgreSQL instance', acl_sys: :admin
+    def create(name)
+      app_dir = dir(name)
+      unless Dir.exists?(app_dir)
+        FileUtils.mkdir_p(app_dir)
+      end
+      app_dir
+    end
+
+    describe :delete, '<NAME>', 'deletes an existing PostgreSQL instance', acl_sys: :admin
+    def delete(name)
+      app_dir = dir(name)
+      if Dir.exists?(app_dir)
+        FileUtils.rm_rf(app_dir)
+      end
+    end
+
+    describe :list, '', 'lists available PostgreSQL instances', acl_sys: :admin
+    def list
+      Dir.glob(File.join(Deployku::Config.home, '.postgres', '*')) do |path|
+        puts File.basename(path) if File.directory?(path)
+      end
+    end
+
+    describe 'db:create', '<NAME> <DB_NAME>', 'create a database in postgres instance', acl_sys: :admin
+    def db_create(name, db_name)
+      config_load(name)
+      cid = get_container_id(name)
+      unless Deployku::Engine.running?(cid)
+        puts "Database instance '#{name}' is not running."
+        exit 1
+      end
+      ip = Deployku::Engine.ip(cid)
+      db = Deployku.sanitize_app_name(db_name)
+      system "echo \"#{@config['env']['POSTGRES_PASSWORD']}\n\" 'CREATE DATABASE #{db};' | psql -h #{ip} -U postgres"
+    end
+
+    describe 'db:drop', '<NAME> <DB_NAME>', 'destroy a database in postgres instance', acl_sys: :admin
+    def db_drop(name, db_name)
+      config_load(name)
+      cid = get_container_id(name)
+      unless Deployku::Engine.running?(cid)
+        puts "Database instance '#{name}' is not running."
+        exit 1
+      end
+      ip = Deployku::Engine.ip(cid)
+      db = Deployku.sanitize_app_name(db_name)
+      system "echo \"#{@config['env']['POSTGRES_PASSWORD']}\n\" 'DROP DATABASE #{db};' | psql -h #{ip} -U postgres"
+    end
+
+    describe 'db:link', '<NAME> <DB_NAME> <APP>', 'connect appliaction with database', acl_sys: :admin
+    def db_link(name, db_name, app_name)
+      config_load(name)
+      db_id = get_container_id(name)
+      ip = Deployku::Engine.ip(db_id)
+      db = Deployku.sanitize_app_name(db_name)
+      user_name = 'user_' + SecureRandom.uuid.gsub('-','')
+      user_passwd = SecureRandom.uuid
+      database_url = "postgres://#{user_name}:#{user_passwd}@#{container_name(name)}/#{db}"
+      system "echo \"#{@config['env']['POSTGRES_PASSWORD']}\n\" \"CREATE USER #{user_name} WITH PASSWORD '#{user_passwd}';\" | psql -h #{ip} -U postgres"
+      system "echo \"#{@config['env']['POSTGRES_PASSWORD']}\n\" 'GRANT ALL ON DATABASE #{db} TO #{user_name};' | psql -h #{ip} -U postgres"
+      if $?.exitstatus == 0
+        Deployku::AppPlugin.run('config:set', [app_name, 'DATABASE_URL', database_url])
+        Deployku::AppPlugin.run(:link, [app_name, container_name(name)])
+      else
+        puts "Unable to create user in database."
+        exit 1
+      end
+    end
+
+    describe 'db:connect', '<NAME> <DB_NAME>', 'connect to database and enter prompt', acl_sys: :admin
+    def db_connect(name, db_name)
+      config_load(name)
+      db_id = get_container_id(name)
+      dbname = Deployku.sanitize_app_name(db_name)
+      ip = Deployku::Engine.ip(db_id)
+      system "PGPASSWORD=\"#{@config['env']['POSTGRES_PASSWORD']}\" psql -h #{ip} -U postgres #{dbname}"
+    end
+
+    # methods from containerable
+    describe :start, '<NAME>', 'starts container', acl_sys: :admin
+    def start(app_name)
+      config_load(app_name)
+      unless @config['volumes']
+        @config['volumes'] = {
+          File.join(dir(app_name), 'data') => '/postgresql/'
+        }
+      end
+      @config['env']['PGDATA'] = '/postgresql/' unless @config['env']['PGDATA']
+      @config['env']['POSTGRES_PASSWORD'] = SecureRandom.uuid unless @config['env']['POSTGRES_PASSWORD']
+      config_save(app_name)
+
+      Deployku::Config.merge!(@config)
+      app_hash = Deployku::Engine.start(@config['from'], dir(app_name), container_name(app_name))
+      exit 1 if $?.nil? || $?.exitstatus != 0
+      set_container_id(app_name, container_name(app_name))
+      puts "Container #{app_hash} started."
+    end
+
+    describe :status, '<NAME>', 'show container status', acl_sys: :admin
+    describe :stop, '<NAME>', 'stops running container', acl_sys: :admin
+    describe :restart, '<NAME>', 'restarts container', acl_sys: :admin
+    describe :logs, '<NAME>', 'show app logs', acl_sys: :admin
+
+    # methods from configurable
+    describe 'config:show', '<NAME>', 'shows instance configuration', acl_sys: :admin
+    describe 'config:set', '<NAME> <ENV_VARIABLE> <VALUE>', 'sets environment variable', acl_sys: :admin
+    describe 'config:unset', '<NAME> <ENV_VARIABLE>', 'unsets environment variable', acl_sys: :admin
+    describe 'config:set_from', '<NAME> <VALUE>', 'sets base image name for container', acl_sys: :admin
+    describe 'config:unset_from', '<NAME>', 'sets base image to default', acl_sys: :admin
+    describe 'config:set_engine', '<NAME> <ENGINE>', 'sets container engine (docker, lxc)', acl_sys: :admin
+    describe 'config:unset_engine', '<NAME>', 'sets engine to default', acl_sys: :admin
+
+    def dir(name)
+      File.join(Deployku::Config.home, '.postgres', Deployku.sanitize_app_name(name))
+    end
+
+    def container_name(app_name)
+      "deployku-postgres-#{app_name}"
+    end
+  end
+end

data/lib/deployku/plugins/rails.rb

@@ -0,0 +1,100 @@
+require 'fileutils'
+
+module Deployku
+  class RailsPlugin < Deployku::Plugin
+    PACKAGES = ['nodejs']
+
+    def volumes
+      ['/app/public/']
+    end
+
+    def port
+      3000
+    end
+
+    def build_start_script(path)
+      app_path = File.join(path, 'app')
+      start_path = File.join(path, 'start')
+      custom_start_path = File.join(app_path, 'start')
+      if File.exists?(custom_start_path)
+        FileUtils.cp(custom_start_path, start_path)
+      else
+        File.open(start_path, 'w') do |f|
+          f << <<EOF
+#!/usr/bin/env bash
+source /usr/local/rvm/scripts/rvm
+cd app
+export RAILS_ENV=production
+bundle exec rake db:migrate RAILS_ENV=production
+bundle exec rake assets:precompile RAILS_ENV=production
+
+bundle exec rails s -p #{Deployku::Config.port} -b 0.0.0.0 -e production
+EOF
+        end
+      end
+      File.chmod(0755, start_path)
+    end
+
+    def build_dockerfile(path)
+      app_path = File.join(path, 'app')
+      ruby_version = detect_ruby_version(app_path)
+      dockerfile_path = File.join(path, 'Dockerfile')
+      # TODO: process Dockerfile with erubis
+      custom_docker_file = File.join(app_path, 'Dockerfile')
+      if File.exists?(custom_docker_file)
+        FileUtils.cp(custom_docker_file, dockerfile_path)
+      else
+        File.open(dockerfile_path, 'w') do |f|
+          f << <<EOF
+FROM #{Deployku::Config.from}
+
+ENV DEBIAN_FRONTEND noninteractive
+
+RUN apt-get update
+
+RUN /bin/bash -l -c 'rvm install #{ruby_version} && rvm use #{ruby_version} --default'
+RUN /bin/bash -l -c 'rvm rubygems current'
+RUN /bin/bash -l -c 'gem install bundler'
+
+RUN /bin/bash -l -c 'rvm cleanup all'
+
+RUN apt-get install -y #{packages.join(' ')}
+
+RUN apt-get -y autoclean
+RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+EXPOSE #{Deployku::Config.port}
+CMD []
+ENTRYPOINT ["/start"]
+
+ADD start /start
+
+ADD app /app
+RUN /bin/bash -l -c 'cd app && RAILS_ENV=production bundle install --without development test'
+EOF
+        end
+      end
+    end
+
+    def detect(path)
+      gem_file_path = File.join(path, 'Gemfile')
+      if File.exists?(gem_file_path)
+        if File.read(gem_file_path) =~ %r{^\s*gem\s+['"](rails)['"]}m
+          return true
+        end
+      end
+      false
+    end
+
+    def detect_ruby_version(path)
+      gem_file_path = File.join(path, 'Gemfile')
+      if File.exists?(gem_file_path)
+        ruby_version = File.read(gem_file_path).gsub(%r{.*ruby\s+['"]([^'"]+)['"].*}m, '\1')
+      end
+      if not ruby_version || ruby_version == ''
+        ruby_version = '2.1.7'
+      end
+      ruby_version
+    end
+  end
+end

data/lib/deployku/plugins.rb

@@ -0,0 +1,111 @@
+module Deployku
+
+  class Plugin
+    @plugins = []
+
+    class NoMethod < NoMethodError
+    end
+
+    class << self
+      attr_reader :plugins
+    end
+
+    def self.<<(plugin)
+      @plugins << plugin
+    end
+
+    def self.find_plugin(name)
+      plugin_name = "Deployku::#{name.capitalize}Plugin"
+      @plugins.each do |plugin|
+        return plugin if plugin.name == plugin_name
+      end
+      nil
+    end
+
+    def self.filter_plugins(fn)
+      plugins = []
+      @plugins.each do |plugin|
+        plug = plugin.instance
+        plugins << plug if plug.respond_to?(fn)
+      end
+      plugins
+    end
+
+    def self.inherited(plugin)
+      Plugin << plugin
+      plugin.instance_eval do
+        @help_register = []
+        class << self
+          attr_reader :help_register
+        end
+        def describe(fn_name, args, description, acl={})
+          @help_register << { name: fn_name, arg_list: args, desc: description, acl_app: acl[:acl_app], acl_sys: acl[:acl_sys] }
+        end
+      end
+    end
+
+    # collects info from 'describe' and returns it as a string
+    def self.help
+      str = ''
+      help_register = []
+      max_name_length = 0
+      max_arg_length = 0
+      max_desc_length = 0
+      @plugins.each do |plugin|
+        plugin.name =~ /Deployku::(.*?)Plugin/
+        next unless $1
+        name = $1.downcase
+        plugin.help_register.each do |reg|
+          new_reg = { name: "#{name}:#{reg[:name]}", args: reg[:arg_list], desc: reg[:desc] }
+          max_name_length = new_reg[:name].length if new_reg[:name].length > max_name_length
+          max_arg_length = new_reg[:args].length if new_reg[:args].length > max_arg_length
+          max_desc_length = new_reg[:desc].length if new_reg[:desc].length > max_desc_length
+          help_register << new_reg
+        end
+      end
+      help_register.each do |reg|
+        str << "   %-#{max_name_length}s %-#{max_arg_length}s %s\n" % [reg[:name], reg[:args], reg[:desc]]
+      end
+      str
+    end
+
+    # run command in a plugin
+    def self.run(fn, args=[])
+      fn_name = fn.to_s.gsub(':', '_')
+      fn_desc = command_description(fn)
+      unless fn_desc
+        puts "Unknown command '#{fn}'."
+        exit 1
+      end
+      if fn_desc[:acl_app]
+        fn_desc[:acl_app].each do |idx, right|
+          Deployku::AccessPlugin.instance.check_app_rights(args[idx], right, true)
+        end
+      end
+      if fn_desc[:acl_sys]
+        Deployku::AccessPlugin.instance.check_system_rights(fn_desc[:acl_sys], true)
+      end
+      plug = instance
+      raise Deployku::Plugin::NoMethod.new("no method '#{plug.class.name}.#{fn}'") unless plug.respond_to?(fn_name)
+      plug.send(fn_name, *args)
+    end
+
+    def self.instance
+      @instance ||= self.new
+    end
+
+    def self.command_description(fn)
+      self.help_register.each do |reg|
+        return reg if reg[:name].to_s == fn.to_s
+      end
+      nil
+    end
+
+    # concatenate system wide packages and packages required by plugin
+    def packages
+      Deployku::Config.packages + self.class::PACKAGES
+    end
+
+  end
+
+end

data/lib/deployku.rb

@@ -0,0 +1,19 @@
+dir = File.expand_path(File.dirname(__FILE__))
+$:.unshift(dir) unless $:.include?(dir)
+
+require 'deployku/config'
+require 'deployku/helpers'
+require 'deployku/configurable'
+require 'deployku/containerable'
+require 'deployku/plugins'
+require 'deployku/engine'
+
+# load core plugins
+require 'deployku/plugins/access'
+require 'deployku/plugins/docker'
+require 'deployku/plugins/lxc'
+require 'deployku/plugins/app'
+require 'deployku/plugins/git'
+require 'deployku/plugins/postgres'
+require 'deployku/plugins/rails'
+require 'deployku/plugins/nginx'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: deployku
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Petr Kovář
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-09 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: pejuko@gmail.com
+executables:
+- deployku
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/deployku
+- deployku.gemspec
+- lib/deployku.rb
+- lib/deployku/config.rb
+- lib/deployku/configurable.rb
+- lib/deployku/containerable.rb
+- lib/deployku/engine.rb
+- lib/deployku/helpers.rb
+- lib/deployku/plugins.rb
+- lib/deployku/plugins/access.rb
+- lib/deployku/plugins/app.rb
+- lib/deployku/plugins/docker.rb
+- lib/deployku/plugins/git.rb
+- lib/deployku/plugins/lxc.rb
+- lib/deployku/plugins/nginx.rb
+- lib/deployku/plugins/postgres.rb
+- lib/deployku/plugins/rails.rb
+homepage: http://github.com/deployku/deployku
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Deploy applications using git with zero down time
+test_files: []