gordon 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c54664a1e5359e5fd1fcbba7441631a573126523
+  data.tar.gz: f7891f315e9960dc15cec108bea040aa6158327f
+SHA512:
+  metadata.gz: 99b6cff85548e38b072b5d28750bb8da757117fdbb0c1ab03d60ae07fd12c89399f51d38c99f42b1a91f45469b4750b4de39acc23bbfa82d22ffa602fb9cee12
+  data.tar.gz: f97b983cf4239584ed6e007cba368f865792b18da71f944c7bc8f4f38650c43633c85134c2da5f8a149c28e92f199345e57ff974322f8b7d33d38573b4fef5b6

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rpm
+*.deb
+*.tar
+*.gz
+*.rbc
+.bash_history
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gordon.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Marcelo Pinheiro
+
+MIT License
+
+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,91 @@
+# Gordon
+
+We all know that build application packages is a pain. A lot of pain.
+
+Of course, [fpm](https://github.com/jordansissel/fpm) is a awesome tool to abstract package building for a lot of Operational Systems. Period.
+
+Of course, [fpm-cookery](https://github.com/bernd/fpm-cookery) is another great tool to approach building as a simple recipe.
+
+But, unfortunately, create recipes for each application can be boring and repetitive. You need to create init files (inittab, systemd, etc) for each project
+and, if a webserver changes (example: from Thin to Unicorn) you need to change script again, again and again.
+
+And when you are in front with a web application that breaks Nginx or Apache conventions? Do you remember that feel, bro?
+
+Gordon is a try to automagically create init files using Foreman and build artifacts using FPM. Make developers free to develop, while you take apps under a minimal control.
+
+## How it works?
+
+Gordon have a lot of restrictions:
+
+* Web Servers: Nginx or Apache (Tomcat soon);
+* Init scripts: all generated by Foreman;
+* Apps supported: at this time, Ruby. Java soon and others too.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'gordon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gordon
+
+## Usage
+
+A simple example to build a Ruby Web App that runs Nginx and uses Systemd as init process:
+
+    $ ruby -S gordon                    \
+      --app-type        ruby_web_app    \
+      --app-name        $APP_NAME       \
+      --app-desc        $APP_DESC       \
+      --app-repo        $APP_REPO       \
+      --app-version     $APP_VERSION    \
+      --package-type    rpm             \
+      --package-dir     .               \
+      --source-dir      .               \
+      --build-dir       /tmp            \
+      --skeleton-type   nginx           \
+      --init-type       systemd         \
+      --init-build-dir  /tmp/systemd
+
+It will generate a RPM package with the following structure:
+
+* /usr/share/nginx/html/*all-app-stuff*
+* /usr/lib/systemd/system/*app-name*/*all-systemd-stuff*
+
+Sounds good?
+
+## Why you not use Omnibus or Heroku buildpacks?
+
+Because I want to create a tool that can be used as a transition step.
+
+## Why you use fpm-cookery templates instead of fpm?
+
+Because I not found a trivial way to use fpm when you need to package a application under different directories (Apache2 and Systemd per example). If you show to me, I will think to abolish templates.
+
+## Why Gordon?
+
+Because I like Gordon Ramsay.
+
+## TODO
+
+* Very unstable, need to fix it
+* Validate outputs
+* Fix annoying --package-dir OptionParser::InvalidOption error
+* Add a way to map package dependencies
+* Adapt to use Debian and other OS conventions for Nginx and Apache
+* Create a better way to handle env vars than injecting a lot of global variables in fpm-cookery ruby-web-app template
+* Tests
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/gordon

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'gordon'
+
+Gordon::CLI.run
+

data/gordon.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gordon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gordon"
+  spec.version       = Gordon::VERSION
+  spec.authors       = ["Marcelo Pinheiro"]
+  spec.email         = ["salizzar@gmail.com"]
+  spec.description   = %q{Gordon is a tool to create artifacts using fpm-cookery and foreman.}
+  spec.summary       = %q{A tool to create application artifacts}
+  spec.homepage      = "https://github.com/salizzar/gordon"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "fpm-cookery"
+  spec.add_dependency "foreman"
+end

data/lib/gordon/application/templates/ruby_web_app.rb

@@ -0,0 +1,41 @@
+$app_name       = ENV['GORDON_APP_NAME']
+$app_desc       = ENV['GORDON_APP_DESC']
+$app_repo       = ENV['GORDON_APP_REPO']
+$app_version    = ENV['GORDON_APP_VERSION']
+#app_depends    = ENV['GORDON_APP_DEPENDS']
+$app_source_dir = ENV['GORDON_APP_SOURCE_DIR']
+
+$skeleton_type  = ENV['GORDON_SKELETON_TYPE']
+$skeleton_files = ENV['GORDON_SKELETON_FILES']
+
+$init_type      = ENV['GORDON_INIT_TYPE']
+$init_build_dir = ENV['GORDON_INIT_BUILD_DIR']
+
+path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib'))
+$LOAD_PATH.unshift path
+
+require 'gordon'
+
+class RubyWebApp < FPM::Cookery::Recipe
+  include Gordon::Cookery::Common,
+          Gordon::Cookery::Init,
+          Gordon::Cookery::Webserver
+
+  name        $app_name
+  description $app_desc
+  version     $app_version
+  homepage    $app_repo
+
+  source      $app_source_dir, with: :local_path
+# depends     $app_depends
+
+  def build
+    vendor_gems
+  end
+
+  def install
+    setup_init_files
+    setup_webserver_files
+  end
+end
+

data/lib/gordon/application/types.rb

@@ -0,0 +1,41 @@
+module Gordon
+  module Application
+    module Types
+      module Base
+        def template_path
+          curdir = File.dirname(__FILE__)
+          template_path = File.join(curdir, 'templates', "#{get_template}.rb")
+
+          File.expand_path(template_path)
+        end
+      end
+
+      class RubyWebApp
+        include Base
+
+        def get_template ; 'ruby_web_app' ; end
+      end
+
+      class JavaWebApp
+        include Base
+
+        def get_template ; 'java_web_app' ; end
+      end
+
+      class JavaStandaloneApp
+        include Base
+
+        def get_template ; 'java_standalone_app' ; end
+      end
+    end
+
+    class Factory
+      def self.create(application_type)
+        namespace = "Application::Types"
+
+        ::Gordon::Factory.create_instance(namespace, application_type)
+      end
+    end
+  end
+end
+

data/lib/gordon/cli.rb

@@ -0,0 +1,88 @@
+require 'optparse'
+
+module Gordon
+  class CLI
+    def self.run
+      options = Options.new
+      options.source_dir      = Dir.pwd
+      options.build_dir       = '/tmp'
+      options.package_dir     = Dir.pwd
+      options.init_build_dir  = '/tmp'
+
+      parser = create_option_parser(options)
+      parser.parse!
+
+      file_path = File.join(Dir.pwd, 'gordon.yml')
+
+      recipe = Recipe.new(options)
+      cooker = Cooker.new(recipe, options)
+      cooker.cook
+    end
+
+    def self.create_option_parser(options)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: gordon [options]'
+
+        opts.on('-t', '--app-type APP_TYPE', 'Application Type') do |type|
+          options.app_type = type
+        end
+
+        opts.on('-n', '--app-name APP_NAME', 'Application Name') do |name|
+          options.app_name = name
+        end
+
+        opts.on('-d', '--app-desc APP_DESC', 'Application Description') do |desc|
+          options.app_desc = desc
+        end
+
+        opts.on('-r', '--app-repo APP_REPO', 'Application Repository URL') do |repo|
+          options.app_repo = repo
+        end
+
+        opts.on('-V', '--app-version APP_VERSION', 'Application Version') do |version|
+          options.app_version = version
+        end
+
+        opts.on('-p', '--package-type PACKAGE', 'Package type') do |package_type|
+          options.package_type = package_type
+        end
+
+        opts.on('-P' '--package-dir PACKAGE_DIR', 'Package Directory') do |package_dir|
+          options.package_dir = package_dir
+        end
+
+        opts.on('-s', '--source-dir SOURCE_DIR', 'Source Directory') do |source_dir|
+          options.source_dir = source_dir
+        end
+
+        opts.on('-b', '--build-dir BUILD_DIR', 'Build Directory') do |build_dir|
+          options.build_dir = build_dir
+        end
+
+        opts.on('-S', '--skeleton-type SKELETON_TYPE', 'Skeleton Type') do |skeleton_type|
+          options.skeleton_type = skeleton_type
+        end
+
+        opts.on('-i', '--init-type INIT_TYPE', 'Init Type') do |init_type|
+          options.init_type = init_type
+        end
+
+        opts.on('-I', '--init-build-dir INIT_BUILD_DIR', 'Init Build Directory') do |init_build_dir|
+          options.init_build_dir = init_build_dir
+        end
+
+        opts.on('-D', '--debug DEBUG', 'Debug Mode') do |debug|
+          options.debug = debug
+        end
+
+        opts.on('-h', '--help', 'Displays Help') do
+          puts opts
+          exit
+        end
+      end
+
+      parser
+    end
+  end
+end
+

data/lib/gordon/cooker.rb

@@ -0,0 +1,56 @@
+module Gordon
+  class Cooker
+    attr_reader :options, :recipe
+
+    def initialize(recipe, options)
+      @recipe = recipe
+      @options = options
+    end
+
+    def cook
+      cook_args = []
+
+      cook_args << "--debug"    if options.debug?
+
+      cook_args << "--target #{options.package_type}"
+      cook_args << "--platform #{recipe.platform}" if recipe.requires_platform?
+      cook_args << "--cache-dir #{File.expand_path(options.build_dir)}"
+      cook_args << "--tmp-root #{File.expand_path(options.build_dir)}"
+      cook_args << "--pkg-dir #{File.expand_path(options.package_dir)}"
+      cook_args << "package"
+      cook_args << recipe.application_template_path
+
+      env_vars = get_env_vars
+      command = "#{env_vars.join " "} ruby -S fpm-cook #{cook_args.join " "}"
+
+      if options.debug?
+        STDOUT.puts ''
+        STDOUT.puts command
+        STDOUT.puts ''
+      end
+
+      Process.run(command)
+    end
+
+    private
+
+    def get_env_vars
+      env_vars = []
+
+      env_vars << "GORDON_APP_NAME=#{options.app_name}"
+      env_vars << "GORDON_APP_DESC=#{options.app_desc}"
+      env_vars << "GORDON_APP_REPO=#{options.app_repo}"
+      env_vars << "GORDON_APP_VERSION=#{options.app_version}"
+      env_vars << "GORDON_APP_SOURCE_DIR=#{File.expand_path(options.source_dir)}"
+
+      env_vars << "GORDON_SKELETON_TYPE=#{recipe.skeleton.type}"
+      env_vars << "GORDON_SKELETON_FILES=#{recipe.skeleton.artifacts.join(',')}"
+
+      env_vars << "GORDON_INIT_TYPE=#{options.init_type}"
+      env_vars << "GORDON_INIT_BUILD_DIR=#{File.expand_path(options.init_build_dir)}"
+
+      env_vars
+    end
+  end
+end
+

data/lib/gordon/cookery/common.rb

@@ -0,0 +1,18 @@
+module Gordon
+  module Cookery
+    module Common
+      def vendor_gems
+        safesystem('ruby -S bundle install --deployment --without development test')
+      end
+
+      def common_ruby_files
+        %w(.bundle Gemfile Gemfile.lock Procfile config.ru vendor)
+      end
+
+      def get_skeleton_path(skeleton_type)
+        skeleton_type.path(skeleton_type.requires_app_name? ? $app_name : '')
+      end
+    end
+  end
+end
+

data/lib/gordon/cookery/init.rb

@@ -0,0 +1,27 @@
+module Gordon
+  module Cookery
+    module Init
+      def setup_init_files
+        create_init_files
+        install_init_files
+      end
+
+      def create_init_files
+        init_build_dir_path = File.join($init_build_dir, $init_type)
+
+        command = "ruby -S foreman export --app #{$app_name} #{$init_type} #{init_build_dir_path}"
+        ::Gordon::Process.run(command)
+      end
+
+      def install_init_files
+        init_build_dir_path = File.join($init_build_dir, $init_type)
+
+        skeleton_type = ::Gordon::Skeleton::Types::Factory.create($init_type)
+        path = get_skeleton_path(skeleton_type)
+
+        root(path).install Dir["#{init_build_dir_path}/*"]
+      end
+    end
+  end
+end
+

data/lib/gordon/cookery/webserver.rb

@@ -0,0 +1,14 @@
+module Gordon
+  module Cookery
+    module Webserver
+      def setup_webserver_files
+        skeleton_type = ::Gordon::Skeleton::Types::Factory.create($skeleton_type)
+        skeleton_path = get_skeleton_path(skeleton_type)
+
+        root(skeleton_path).install common_ruby_files
+        root(skeleton_path).install $skeleton_files.split(',')
+      end
+    end
+  end
+end
+

data/lib/gordon/factory.rb

@@ -0,0 +1,19 @@
+module Gordon
+  class Factory
+    def self.create_instance(namespace, object_type)
+      fragments = object_type.split('_')
+
+      type = fragments.map do |fragment|
+        fragment[0].upcase + fragment[1..-1]
+      end.join('')
+
+      ns = "Gordon::#{namespace}::#{type}"
+
+      klass = ns.split('::').inject(Object) do |obj, ns|
+        obj.const_get(ns)
+      end
+
+      klass.new
+    end
+  end
+end

data/lib/gordon/options.rb

@@ -0,0 +1,12 @@
+module Gordon
+  class Options
+    attr_accessor :app_type, :app_name, :app_desc, :app_repo, :app_version
+    attr_accessor :package_type, :package_dir
+    attr_accessor :source_dir, :build_dir
+    attr_accessor :skeleton_type
+    attr_accessor :init_type, :init_build_dir
+    attr_accessor :debug
+
+    def debug? ; !!debug ; end
+  end
+end

data/lib/gordon/process.rb

@@ -0,0 +1,9 @@
+module Gordon
+  class Process
+    def self.run(command)
+      pid = ::Process.spawn(command, out: $stdout, err: $stderr)
+      _, status = ::Process.wait2(pid)
+    end
+  end
+end
+

data/lib/gordon/recipe.rb

@@ -0,0 +1,32 @@
+require 'forwardable'
+
+module Gordon
+  class Recipe
+    attr_reader :options, :skeleton
+
+    def initialize(options)
+      @options = options
+      @skeleton = Skeleton::Info.new(options.skeleton_type, options.source_dir)
+    end
+
+    def platform
+      map = {
+        'rpm' => 'centos',
+        'deb' => 'debian',
+      }
+
+      map[options.package_type]
+    end
+
+    def requires_platform?
+      !!platform
+    end
+
+    def application_template_path
+      application = Application::Factory.create(options.app_type)
+
+      application.template_path
+    end
+  end
+end
+

data/lib/gordon/skeleton/info.rb

@@ -0,0 +1,28 @@
+module Gordon
+  module Skeleton
+    class Info
+      attr_reader :type, :artifacts
+
+      BLACKLIST = %w(.git log spec Vagrantfile coverage tmp/cache)
+
+      def initialize(type, source_dir)
+        @type, @artifacts = type, clean_source_files(source_dir)
+      end
+
+      private
+
+      def clean_source_files(source_dir)
+        source_path = File.join(source_dir, '*')
+
+        all_files = Dir[source_path]
+
+        blacklist = BLACKLIST.map do |file|
+          File.join(source_dir, file)
+        end
+
+        all_files - blacklist
+      end
+    end
+  end
+end
+

data/lib/gordon/skeleton/types.rb

@@ -0,0 +1,56 @@
+module Gordon
+  module Skeleton
+    module Types
+      module Base
+        def path(app = '')
+          File.join(get_default_path, app)
+        end
+
+        def requires_app_name?
+          false
+        end
+      end
+
+      class Nginx
+        include Base
+
+        def get_default_path ; '/usr/share/nginx/html' ; end
+      end
+
+      class Httpd
+        include Base
+
+        def get_default_path ; '/var/www/html' ; end
+      end
+
+      class Misc
+        include Base
+
+        def get_default_path ; '/opt' ; end
+
+        def requires_app_name?
+          true
+        end
+      end
+
+      class Systemd
+        include Base
+
+        def get_default_path ; '/usr/lib/systemd/system' ; end
+
+        def requires_app_name?
+          true
+        end
+      end
+
+      class Factory
+        def self.create(skeleton_type)
+          namespace = "Skeleton::Types"
+
+          ::Gordon::Factory.create_instance(namespace, skeleton_type)
+        end
+      end
+    end
+  end
+end
+

data/lib/gordon/version.rb

@@ -0,0 +1,3 @@
+module Gordon
+  VERSION = "0.0.4"
+end

data/lib/gordon.rb

@@ -0,0 +1,17 @@
+require "gordon/version"
+
+module Gordon
+  require 'gordon/cli'
+  require 'gordon/cooker'
+  require 'gordon/recipe'
+  require 'gordon/factory'
+  require 'gordon/options'
+  require 'gordon/process'
+  require 'gordon/application/types'
+  require 'gordon/cookery/common'
+  require 'gordon/cookery/init'
+  require 'gordon/cookery/webserver'
+  require 'gordon/skeleton/info'
+  require 'gordon/skeleton/types'
+end
+

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: gordon
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Marcelo Pinheiro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fpm-cookery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: foreman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gordon is a tool to create artifacts using fpm-cookery and foreman.
+email:
+- salizzar@gmail.com
+executables:
+- gordon
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/gordon
+- gordon.gemspec
+- lib/gordon.rb
+- lib/gordon/application/templates/ruby_web_app.rb
+- lib/gordon/application/types.rb
+- lib/gordon/cli.rb
+- lib/gordon/cooker.rb
+- lib/gordon/cookery/common.rb
+- lib/gordon/cookery/init.rb
+- lib/gordon/cookery/webserver.rb
+- lib/gordon/factory.rb
+- lib/gordon/options.rb
+- lib/gordon/process.rb
+- lib/gordon/recipe.rb
+- lib/gordon/skeleton/info.rb
+- lib/gordon/skeleton/types.rb
+- lib/gordon/version.rb
+homepage: https://github.com/salizzar/gordon
+licenses:
+- MIT
+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.0.14
+signing_key: 
+specification_version: 4
+summary: A tool to create application artifacts
+test_files: []