deployku 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfe59e855f60f211b591d800f31a729fe253735e
+  data.tar.gz: 0c413f1ebc00d71e88b727a1929d1eb39d6dea84
+SHA512:
+  metadata.gz: ee135823a37281fc4cd377ded1c5bb522d9c295203d8e02237505f4f89c3b93b4bba685d7997c59b57e28b2654fad615b68ef8636baca70ddcff7361b32215db
+  data.tar.gz: 5c38b6c78b376b3e093dc06273988c66e0f778e487e8516ca43a962dee7b7bed1db9a01ad73d705079a24f2694d115fb9e3e948e90348cad00a413f27a1f72d2

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2015 Petr Kovář <pejuko@gmail.com> 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,234 @@
+# DEPLOYKU
+
+Deploy applications using git with zero down time. Inspired by dokku but should be distribution independent.
+
+## Instalation instructions
+
+### Required packages
+
+* docker or lxc (lxc not implemented yet)
+* ruby with rubygems (system wide)
+* postgresql client (psql command)
+* nginx (server)
+* sshd (server)
+* git
+
+### Installation
+
+```bash
+gem install deployku
+```
+
+### System configuration
+
+Add new user 'deployku' and add him to docker group
+```bash
+useradd -m deployku -G docker
+```
+
+Configure nginx to load nginx.conf files from ~deployku/*/nginx.conf. Eg.:
+```
+http {
+  ...
+  include /home/deployku/*/nginx.conf;
+}
+```
+
+To allow user deployku to reload nginx configuration via sudo add following line to /etc/sudoers
+```bash
+%deployku ALL=(ALL) NOPASSWD:/usr/bin/nginx -s reload
+```
+
+Store path to deployku into ~deployku/.sshcommand:
+```bash
+which deployku > /home/deployku/.sshcommand
+```
+
+As user deployku add first ssh key. The first user will be manager and will have admin privileges to all repositories.
+The command reads one line from stdin and expects the line to be a public ssh key. So you can do something like this:
+```bash
+su - deployku
+cat id_rsa.pub | deployku access:add peter
+```
+
+User peter is now deployku administrator and can do everything. Please notice that this works only for first time.
+Adding another deployku users can be done over ssh by deployku administrator. So user peter now can add another administrator:
+```bash
+cat id_rsa2.pub | ssh deployku@localhost access:add thomas
+ssh deployku@localhost access:acl:system_set thomas admin
+```
+
+For more information run command like this:
+```bash
+ssh deployku@localhost help
+```
+
+Replace 'localhost' with your domain.
+
+## Custom files
+
+### Custom start script
+
+After the container is started the `/start` script is executed. The `/start` script is generated by the application plugin.
+If you wish to use your own start script just create and commit your own start script. The custom start script has to be
+in your application root and has to expect that the application is in `/app` directory.
+
+Example of custom start script:
+```bash
+#!/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
+
+mkdir -p tmp/pids
+bundle exec sidekiq -c 2 -e production -d -L log/sidekiq.log -P tmp/pids/sidekiq.pid
+bundle exec puma -p 3000 -e production --pidfile tmp/pids/puma.pid
+```
+
+### Custom Dockerfile
+
+You may prepare your own image or for some other reasons you may want to create custom containers. Just create Dockerfile in your
+application root and commit it. When you push to deployku repository it will be used.
+
+Example of custom Dockerfile:
+```
+FROM pejuko/rvm-base
+
+ENV DEBIAN_FRONTEND noninteractive
+
+RUN apt-get update
+
+RUN /bin/bash -l -c 'rvm install 2.2.3 && rvm use 2.2.3 --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 libpq-dev
+
+RUN apt-get -y autoclean
+RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+EXPOSE 3000
+CMD []
+ENTRYPOINT ["/start"]
+
+ADD start /start
+
+ADD app /app
+RUN /bin/bash -l -c 'cd app && RAILS_ENV=production bundle install --without development test'
+```
+
+## Supported applications
+
+* Ruby on Rails
+
+## Examples
+
+### Create new project and assign commit rights to jane
+
+```bash
+ssh deployku@localhost app:create myapp
+cat jane.pub | ssh deployku@localhost access:add jane
+ssh deployku@localhost access:acl:set myapp jane commit
+```
+
+Jane now can deploy with git.
+
+### Create and start new PostgreSQL server
+
+```bash
+ssh deployku@localhost postgres:create dbserver
+ssh deployku@localhost postgres:start dbserver
+```
+
+### Create and configure new Rails application
+
+Create new repository on deployku server (replace localhost with name of your server)
+```bash
+ssh deployku@localhost app:create myapp
+```
+
+Create new database on running database server
+```bash
+ssh deployku@localhost postgres:db:create dbserver myapp-db
+```
+
+Link created database to our application
+```bash
+ssh deployku@localhost postgres:db:link dbserver myapp-db myapp
+```
+
+To say that we want to install postgresql dev tools in our container you can create file `deployku.yml` in your
+application directory:
+```yaml
+packages: ['libpq-dev']
+```
+
+OR you can setup this in the repository with:
+```bash
+ssh deployku@localhost app:config:add_package libpq-dev
+```
+
+Configure our server domains
+```bash
+ssh deployku@localhost app:config:add_domain myapp myapp.com
+ssh deployku@localhost app:config:add_domain myapp www.myapp.com
+```
+
+Enable nginx server
+```bash
+ssh deployku@localhost nginx:enable myapp
+```
+
+Check our configuration
+```bash
+ssh deployku@localhost app:config:show myapp
+```
+
+Setup application environment like SECRET_KEY_BASE for rails app
+```bash
+ssh deployku@localhost app:config:set myapp SECRET_KEY_BASE somesecretkey
+```
+
+Setup our deployku repository as remote branch
+```bash
+git remote add deployku deployku@localhost:myapp
+```
+
+Deploy.
+```bash
+git push deployku master
+```
+
+### Connect to database
+Use ssh with `-t` option.
+```bash
+ssh -t deployku@localhost postgres:db:connect dbserver myapp-db
+```
+
+### Exec command in container environment
+Following will run bash inside container. Use ssh with `-t` option.
+```bash
+ssh -t deployku@localhost app:run myapp bash
+```
+
+And then you can enter your app directory:
+```bash
+cd app
+```
+
+And run eg. rails console:
+```bash
+rails c
+```
+
+## ACL: rights
+- admin
+- commit

data/Rakefile

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# vi: fenc=utf-8:expandtab:ts=2:sw=2:sts=2
+# 
+# @author: Petr Kovar <pejuko@gmail.com>
+
+require 'rubygems/package_task'
+require 'rake/clean'
+
+CLEAN << "pkg"
+
+task :default => [:gem]
+
+Gem::PackageTask.new(eval(File.read("deployku.gemspec"))) {|pkg|}
+

data/bin/deployku

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+
+require 'deployku'
+
+cmd = ARGV.shift
+
+def print_help
+  puts <<EOF
+
+  deployku <command> [command-options]
+
+Commands:
+#{Deployku::Plugin.help}
+EOF
+end
+
+unless cmd
+  print_help
+  exit 1
+end
+
+Deployku::Config.load
+
+case cmd
+  when 'help'
+    print_help
+    exit 0
+
+  when /^([^:]+):(.*)$/
+    plugin = Deployku::Plugin.find_plugin($1)
+    unless plugin
+      print_help
+      exit 1
+    end
+    plugin.run($2, ARGV)
+
+  when 'git-receive-pack'
+    Deployku::GitPlugin.instance.receive_pack(ARGV.shift)
+
+  else
+    print_help
+    exit 1
+end

data/deployku.gemspec

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# vi: fenc=utf-8:expandtab:ts=2:sw=2:sts=2
+# 
+# @author: Petr Kovar <pejuko@gmail.com>
+
+require 'rubygems'
+require 'find'
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Deploy applications using git with zero down time"
+  s.homepage = "http://github.com/deployku/deployku"
+  s.email = "pejuko@gmail.com"
+  s.authors = ["Petr Kovář"]
+  s.name = 'deployku'
+  s.version = '0.0.1'
+  s.date = Time.now.strftime("%Y-%m-%d")
+  s.require_path = 'lib'
+  s.files = ["bin/deployku", "README.md", "deployku.gemspec", "Rakefile", "LICENSE"]
+  s.files += Dir["lib/**/*.rb"]
+  s.executables = ["deployku"]
+end
+

data/lib/deployku/config.rb

@@ -0,0 +1,92 @@
+require 'yaml'
+
+module Deployku
+  class Config
+    # TODO: read variables from config file
+
+    @config = nil
+
+    HOME = File::expand_path('~deployku')
+    FROM = 'pejuko/rvm-base'
+    PACKAGES = ['git']
+    DEFAULT_ENGINE = 'docker'
+    DEFAULT_PORT = 80
+
+    class << self
+      def home
+        HOME
+      end
+
+      def engine
+        (@config && @config['engine']) ? @config['engine'] : DEFAULT_ENGINE
+      end
+
+      def from
+        (@config && @config['from']) ? @config['from'] : FROM
+      end
+
+      def packages
+        (@config && @config['packages']) ? @config['packages'] : PACKAGES
+      end
+
+      def port
+        (@config && @config['port']) ? @config['port'] : DEFAULT_PORT
+      end
+
+      def method_missing(method, *args)
+        return nil unless @config
+        return @config[method.to_s]
+      end
+
+      def merge!(opts)
+        unless @config
+          @config = {
+            'from' => FROM,
+            'packages' => PACKAGES,
+            'engine' => DEFAULT_ENGINE
+          }
+        end
+        deep_merge!(@config, opts)
+      end
+
+      def deep_merge!(hash1, hash2)
+        hash2.each do |key, value|
+          k = key.to_s
+          unless hash1[k]
+            hash1[k] = value
+          else
+            if hash1[k].kind_of?(Hash)
+              deep_merge!(hash1[k], value)
+            elsif hash1[k].kind_of?(Array)
+              hash1[k] = hash1[k] + value
+            else
+              hash1[k] = value
+            end
+          end
+        end
+      end
+
+      def set_opts(key, opts)
+        @config[key.to_s] = opts[key.to_s] if opts[key.to_s]
+      end
+
+      def load(path=File.join(HOME, '.deployku.yaml'))
+        if File.exists?(path)
+          deployku_config = YAML.load_file(path)
+          Deployku::Config.merge!(deployku_config)
+          true
+        else
+          false
+        end
+      end
+
+      def save(path=File.join(HOME, '.deployku.yaml'))
+        if @config
+          File.open(path, 'w') do |f|
+            f << @config.to_yaml
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deployku/configurable.rb

@@ -0,0 +1,75 @@
+require 'fileutils'
+require 'yaml'
+
+module Deployku::Configurable
+  attr_reader :config
+
+  def config_show(app_name)
+    app_config_path = config_path(app_name)
+    puts File.read(app_config_path) if File.exists?(app_config_path)
+  end
+
+  def config_set(app_name, var, value)
+    config_load(app_name)
+    @config['env'][var.to_s] = value
+    config_save(app_name)
+  end
+
+  def config_unset(app_name, var)
+    config_load(app_name)
+    @config['env'].delete(var.to_s)
+    config_save(app_name)
+  end
+
+  def config_set_from(app_name, value)
+    config_load(app_name)
+    @config['from'] = value
+    config_save(app_name)
+  end
+
+  def config_unset_from(app_name)
+    config_load(app_name)
+    @config.delete('from')
+    config_save(app_name)
+  end
+
+  def config_set_engine(app_name, value)
+    config_load(app_name)
+    @config['engine'] = value
+    config_save(app_name)
+  end
+
+  def config_unset_engine(app_name)
+    config_load(app_name)
+    @config.delete('engine')
+    config_save(app_name)
+  end
+
+  def config_set_port(app_name, value)
+    config_load(app_name)
+    @config['port'] = value
+    config_save(app_name)
+  end
+
+  def config_unset_port(app_name)
+    config_load(app_name)
+    @config.delete('port')
+    config_save(app_name)
+  end
+
+  def config_load(app_name)
+    app_config_path = config_path(app_name)
+    @config.merge!(YAML.load_file(app_config_path)) if File.exists?(app_config_path)
+  end
+
+  def config_save(app_name)
+    app_config_path = config_path(app_name)
+    File.open(app_config_path, 'w') do |f|
+      f << @config.to_yaml
+    end
+  end
+
+  def config_path(app_name)
+    File.join(dir(app_name), 'DEPLOYKU_CONFIG.yml')
+  end
+end

data/lib/deployku/containerable.rb

@@ -0,0 +1,82 @@
+module Deployku::Containerable
+  def start(app_name)
+    Deployku::Config.load(config_path(app_name))
+    app_name = Deployku.sanitize_app_name(app_name)
+    app_hash = Deployku::Engine.start(app_name, dir(app_name))
+    exit 1 if $?.nil? || $?.exitstatus != 0
+    set_container_id(app_name, app_hash)
+    puts "Container #{app_hash} started."
+  end
+
+  def run(app_name, *cmd)
+    Deployku::Config.load(config_path(app_name))
+    app_name = Deployku.sanitize_app_name(app_name)
+    Deployku::Engine.run(app_name, dir(app_name), *cmd)
+    exit 1 if $?.nil? || $?.exitstatus != 0
+  end
+
+  def stop(app_name, cid: nil)
+    Deployku::Config.load(config_path(app_name))
+    app_hash = cid ? cid : get_container_id(app_name)
+    if app_hash
+      Deployku::Engine.stop(app_hash)
+    end
+  end
+
+  def restart(app_name)
+    old_cid = get_container_id(app_name)
+    if start(app_name)
+      # stops old application only if new instance was spawn
+      stop(app_name, cid: old_cid)
+    end
+  end
+
+  def logs(app_name)
+    Deployku::Config.load(config_path(app_name))
+    app_hash = get_container_id(app_name)
+    Deployku::Engine.logs(app_hash)
+  end
+
+
+  def container_id_path(app_name)
+    File.join(dir(app_name), 'CONTAINER_ID')
+  end
+
+  def get_container_id(app_name)
+    container_hash_path = container_id_path(app_name)
+    if File.exists?(container_hash_path)
+      File.read(container_hash_path)
+    else
+      nil
+    end
+  end
+
+  def set_container_id(app_name, hash)
+    container_hash_path = container_id_path(app_name)
+    File.open(container_hash_path, 'w') do |f|
+      f << hash
+    end
+  end
+
+  def status(app_name)
+    s = get_status(app_name)
+    if s == nil
+      puts 'Container does not exist.'
+    else
+      if s == true
+        puts 'Container is running.'
+      else
+        puts 'Container is not running.'
+      end
+    end
+  end
+
+  def get_status(app_name)
+    cid = get_container_id(app_name)
+    if cid
+      Deployku::Engine.running?(cid)
+    else
+      nil
+    end
+  end
+end

data/lib/deployku/engine.rb

@@ -0,0 +1,55 @@
+module Deployku::Engine
+  class MissingException < Exception
+  end
+
+  def self.find_engine(name)
+    plugin_name = "Deployku::#{name.capitalize}Engine"
+    Deployku::Plugin.plugins.each do |plugin|
+      return plugin if plugin.name == plugin_name
+    end
+    nil
+  end
+
+  def self.engines
+    engs = []
+    Deployku::Plugin.plugins.each do |plugin|
+      engs << plugin if plugin.name =~ /^Deployku::.*?Engine$/
+    end
+    engs
+  end
+
+  def self.method_missing(method, *args)
+    engine = find_engine(Deployku::Config.engine)
+    raise MissingException.new("no engine '#{Deployku::Config.engine}' found") unless engine
+    eng = engine.new
+    eng.send(method, *args)
+  end
+
+  def start(app_name, app_dir)
+    puts 'not implemented'
+  end
+
+  def run(app_name, app_dir, *cmd)
+    puts 'not implemented'
+  end
+
+  def stop(app_hash)
+    puts 'not implemented'
+  end
+
+  def logs(app_hash)
+    puts 'not implemented'
+  end
+
+  def rebuild(app_name, dir)
+    puts 'not implemented'
+  end
+
+  def running?(app_hash)
+    puts 'not implemented'
+  end
+
+  def ip(app_hash)
+    puts 'not implemented'
+  end
+end

data/lib/deployku/helpers.rb

@@ -0,0 +1,7 @@
+module Deployku
+  class << self
+    def sanitize_app_name(app_name)
+      app_name.gsub(%r{^\.+}, '').gsub(%r{\.+$}, '').gsub(%r{\.\./}, '').gsub(%r{^/+}, '').gsub(%r{/+$}, '').gsub(%r{/+}, '-').gsub(%r{\s+}, '_').gsub(%r{[^a-zA-Z0-9_\-\.]}, '')
+    end
+  end
+end