gordon 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e387d6a84bd0ece96fcb121d5cced6827ef009e1
-  data.tar.gz: e097dc48d7ba2bb4ec8ff51c99acd01fc293a8ab
+  metadata.gz: f96bc9082e1fa53d17474c0ad13eaf2b4724a487
+  data.tar.gz: c3bab3732ee745e380e937da11c8018200a706c4
 SHA512:
-  metadata.gz: 8bc452a000d48d86f71432d503576078e81bc4fb3e565921265ff6b9b52bbadc438a231a95c3284fab283d565b1b6271448eeac08a6c17661246d91887bffb37
-  data.tar.gz: 020661459f394a86c7ba8ab9ea701407c8ac774088ee2a254c70a1abc382cbda843e9c5179eff7e3b2e74740c108109945cd40ff6907dd83bd7aff8b934a5360
+  metadata.gz: 7e58da1e400b4cfec597b3203f7f9d19dc7dc865a071708af7f07e8b334a2aca3da44fe1f253d1cb2838ca5bfa6fec88f0f23afd0a4d7bed6f1c83515ee9cfb3
+  data.tar.gz: e8d17b489e533aa2638b9c360c10eea86c9f272ad605c91e65fa0afb0dd72bab0367b919716488ba7825645d16464e5a60f742df4504fefab5b297fc11771a3b

data/README.md

@@ -30,9 +30,9 @@ Per example: create a user that will run app with credentials, whose $HOME is th
 
 * Apps supported:
 
-    * Ruby Web App (resides based on Http Server of choice)
-    * Ruby Standalone App (resides on /opt/*app_name*)
-    * Java Web App (resides based on Web Server of choice)
+    * Ruby Web (resides based on Http Server of choice)
+    * Ruby Standalone (resides on /opt/*app_name*)
+    * Java Web (resides based on Web Server of choice)
 
 ## Installation
 
@@ -59,12 +59,13 @@ First, you need to vendorize all gems in deployment mode:
 Here a simple example to build a Ruby Web App that runs Nginx and uses Systemd as init process. Just enter on source folder of your app and run in your terminal:
 
     $ ruby -S gordon                     \
-      --app-type         ruby_web_app    \
+      --app-type         web             \
       --app-name         $APP_NAME       \
       --app-desc         $APP_DESC       \
       --app-home         $APP_HOME       \
       --app-version      $APP_VERSION    \
       --app-source       .               \
+      --runtime-name     ruby            \
       --runtime-version  $MRI_VERSION    \
       --http-server-type nginx           \
       --init-type        systemd         \
@@ -83,6 +84,15 @@ Due for conventions, remember:
 
 Sounds good?
 
+## And for Java Web applications?
+
+First, generate war files. After, do the following steps:
+
+* Set --app-source with the path of war file;
+* Set --runtime-name to java-oracle (only for CentOS platform at this time) or java-openjdk;
+* Set --runtime-version (1.7.0_60, 1.8.0_31; Gordon checks and inject correct version into package metadata).
+* You can avoid --init-type because war files are handled by application server of choice (Tomcat or Jetty).
+
 ## Why you not use Omnibus or Heroku buildpacks?
 
 Because I want a tool able to create Linux packages that can be extensible based on my needs.
@@ -91,15 +101,18 @@ Because I want a tool able to create Linux packages that can be extensible based
 
 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 you can't handle all recipes into a single one and abstract build and install?
+
+Because I need to call some protected methods on FPM::Cookery::Recipe and adding dynamic mixins will be a nightmare due for complexity to maintain.
+
 ## Why Gordon?
 
 Because I like Gordon Ramsay.
 
 ## TODO
 
+* Add Oracle JRE support for Debian (oracle-jre-installer?)
 * Validate outputs
-* Refactor to have only one FPM::Cookery recipe.
-* Integrate directly with FPM::Cookery classes
 * Debian check (gem heavly developed under CentOS environment)
 
 ## Contributing

data/lib/gordon/application/factory.rb

@@ -1,9 +1,13 @@
 module Gordon
   module Application
     class Factory
-      def self.create(application_type)
+      def self.create(options)
         namespace = "Application::Types"
 
+        runtime_name = options.runtime_name
+        runtime_name = :java if runtime_name =~ /java/
+        application_type = "#{runtime_name}_#{options.app_type}_app"
+
         ::Gordon::Factory.create_instance(namespace, application_type)
       end
     end

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

@@ -21,10 +21,10 @@ class JavaWebApp < FPM::Cookery::Recipe
 
   source      $env_vars.app_source, with: :local_path
 
-  depends     *resolve_dependencies($env_vars)
+  depends     *resolve_dependencies($env_vars, platform)
 
-  fpm_attributes[:rpm_user]   = 'tomcat'
-  fpm_attributes[:rpm_group]  = 'tomcat'
+  fpm_attributes["#{FPM::Cookery::Facts.target}_user".to_sym]   = 'tomcat'
+  fpm_attributes["#{FPM::Cookery::Facts.target}_group".to_sym]  = 'tomcat'
 
   def build
     web_server_path = get_skeleton_path_from_type($env_vars, $env_vars.web_server_type)

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

@@ -21,7 +21,7 @@ class RubyStandaloneApp < FPM::Cookery::Recipe
 
   source      $env_vars.app_source, with: :local_path
 
-  depends     *resolve_dependencies($env_vars)
+  depends     *resolve_dependencies($env_vars, platform)
 
   def build
     home_path = get_skeleton_path_from_type($env_vars, :misc)

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

@@ -21,7 +21,7 @@ class RubyWebApp < FPM::Cookery::Recipe
 
   source      $env_vars.app_source, with: :local_path
 
-  depends     *resolve_dependencies($env_vars)
+  depends     *resolve_dependencies($env_vars, platform)
 
   def build
     home_path = get_skeleton_path_from_type($env_vars, $env_vars.http_server_type)

data/lib/gordon/cookery/dependency_resolver.rb

@@ -1,63 +1,70 @@
-require 'fpm/cookery/facts'
-
 module Gordon
   module Cookery
     module DependencyResolver
       include Common
 
-      def resolve_dependencies(env_vars)
-        fragments = env_vars.app_type.split('_')
-        app_runtime, app_type = fragments[0], fragments[1]
-
+      def resolve_dependencies(env_vars, platform)
         dependencies = []
-        dependencies << get_runtime_package_name(app_runtime, env_vars)
-        dependencies << get_http_server_package_name(env_vars)  unless env_vars.http_server_type.empty?
-        dependencies << get_init_package_name(env_vars)         unless env_vars.init_type.empty?
-        dependencies << get_web_server_package_name(env_vars)   unless env_vars.web_server_type.empty?
+
+        dependencies << get_runtime_package_name(env_vars, platform)
+        dependencies << get_http_server_package_name(env_vars, platform)  unless env_vars.http_server_type.empty?
+        dependencies << get_init_package_name(env_vars, platform)         unless env_vars.init_type.empty?
+        dependencies << get_web_server_package_name(env_vars, platform)   unless env_vars.web_server_type.empty?
 
         dependencies.collect(&:to_s)
       end
 
       private
 
-      def get_runtime_package_name(app_runtime, env_vars)
-        if app_runtime == 'java'
-          # TODO: get a way to handle openjdk
-          runtime_name = :jre
+      def get_runtime_package_name(env_vars, platform)
+        runtime_name, runtime_version = env_vars.runtime_name, env_vars.runtime_version
 
-          if damn_oracle_8_jre?(env_vars.runtime_version)
-            runtime_version = "#{runtime_name}#{env_vars.runtime_version}"
+        if runtime_name =~ /java/
+          package_name = get_java_package_name(runtime_name, runtime_version, platform)
+        else
+          package_name = "#{runtime_name} = #{runtime_version}"
+        end
+
+        package_name
+      end
+
+      def get_java_package_name(runtime_name, runtime_version, platform)
+        centos = platform == :centos
+
+        if runtime_name =~ /oracle/ && centos
+          if damn_oracle_8_jre?(runtime_version)
+            package_name = "jre#{runtime_version}"
           else
-            runtime_version = "#{runtime_name} = #{env_vars.runtime_version}"
+            package_name = "jre = #{runtime_version}"
           end
         else
-          runtime_name = app_runtime
-
-          runtime_version = "#{runtime_name} = #{env_vars.runtime_version}"
+          if centos
+            package_name = "java-#{runtime_version[0..4]}-openjdk"
+          else
+            package_name = "openjdk-#{runtime_version[2]}-jre"
+          end
         end
 
-        runtime_version
+        package_name
       end
 
       def damn_oracle_8_jre?(runtime_version)
         runtime_version[2].to_s == '8'
       end
 
-      def get_http_server_package_name(env_vars)
-        get_os_package_name(env_vars, :http_server_type)
+      def get_http_server_package_name(env_vars, platform)
+        get_os_package_name(env_vars, :http_server_type, platform)
       end
 
-      def get_init_package_name(env_vars)
-        get_os_package_name(env_vars, :init_type)
+      def get_init_package_name(env_vars, platform)
+        get_os_package_name(env_vars, :init_type, platform)
       end
 
-      def get_web_server_package_name(env_vars)
-        get_os_package_name(env_vars, :web_server_type)
+      def get_web_server_package_name(env_vars, platform)
+        get_os_package_name(env_vars, :web_server_type, platform)
       end
 
-      def get_os_package_name(env_vars, attribute)
-        platform = FPM::Cookery::Facts.platform.to_sym
-
+      def get_os_package_name(env_vars, attribute, platform)
         skeleton_type = create_skeleton_type(env_vars.send(attribute))
         os_package_name = skeleton_type.get_os_package_name(platform)
 

data/lib/gordon/recipe.rb

@@ -4,20 +4,7 @@ module Gordon
 
     def initialize(options)
       @options = options
-      @application = Application::Factory.create(options.app_type)
-    end
-
-    def platform
-      map = {
-        rpm: :centos,
-        deb: :debian,
-      }
-
-      map[options.package_type.to_sym]
-    end
-
-    def requires_platform?
-      !!platform
+      @application = Application::Factory.create(options)
     end
 
     def application_template_path

data/lib/gordon/version.rb

@@ -1,3 +1,3 @@
 module Gordon
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/spec/gordon/application/factory_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Gordon::Application::Factory do
+  let(:options) { instance_double Gordon::Options, app_type: :web, runtime_name: :java }
+
+  it 'returns a instance of specified runtime and type' do
+    expect(described_class.create(options)).to be_instance_of(Gordon::Application::Types::JavaWebApp)
+  end
+end
+

data/spec/gordon/cookery/dependency_resolver_spec.rb

@@ -12,7 +12,7 @@ describe Gordon::Cookery::DependencyResolver do
   describe 'resolving dependencies' do
     context 'given a ruby app' do
       it 'returns all dependencies for web' do
-        expect(env_vars).to receive(:app_type).and_return("ruby_web_app")
+        expect(env_vars).to receive(:runtime_name).and_return("ruby")
         expect(env_vars).to receive(:runtime_version).and_return("2.2.0")
         allow(env_vars).to receive(:http_server_type).and_return("apache")
         expect(env_vars).to receive(:web_server_type).and_return("")
@@ -24,11 +24,11 @@ describe Gordon::Cookery::DependencyResolver do
           "systemd",
         ]
 
-        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
       end
 
       it 'returns all dependencies for standalone' do
-        expect(env_vars).to receive(:app_type).and_return("ruby_standalone_app")
+        expect(env_vars).to receive(:runtime_name).and_return("ruby")
         expect(env_vars).to receive(:runtime_version).and_return("2.1.5")
         expect(env_vars).to receive(:http_server_type).and_return("")
         expect(env_vars).to receive(:web_server_type).and_return("")
@@ -39,14 +39,14 @@ describe Gordon::Cookery::DependencyResolver do
           "systemd",
         ]
 
-        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
       end
     end
 
     context 'given a java standalone app' do
       it 'returns all dependencies for web' do
-        expect(env_vars).to receive(:app_type).and_return("java_web_app")
         allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("java-oracle")
         allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
@@ -57,12 +57,12 @@ describe Gordon::Cookery::DependencyResolver do
           "tomcat",
         ]
 
-        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
       end
 
       it 'handles damn Oracle JRE 8 package name' do
-        expect(env_vars).to receive(:app_type).and_return("java_web_app")
         allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("java-oracle")
         allow(env_vars).to receive(:runtime_version).and_return("1.8.0_25")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
@@ -73,7 +73,55 @@ describe Gordon::Cookery::DependencyResolver do
           "tomcat",
         ]
 
-        expect(subject.resolve_dependencies(env_vars)).to eq(expected)
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
+      end
+
+      it 'handles OpenJDK package name for centos' do
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("java-openjdk")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        allow(env_vars).to receive(:web_server_type).and_return("tomcat")
+        expect(env_vars).to receive(:init_type).and_return("")
+
+        expected = [
+          "java-1.7.0-openjdk",
+          "httpd",
+          "tomcat",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
+      end
+
+      it 'assigns java-oracle to OpenJDK for debian' do
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("java-oracle")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        allow(env_vars).to receive(:web_server_type).and_return("tomcat")
+        expect(env_vars).to receive(:init_type).and_return("")
+
+        expected = [
+          "openjdk-7-jre",
+          "apache2",
+          "tomcat7",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars, :debian)).to eq(expected)
+      end
+
+      it 'handles OpenJDK package name for debian' do
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("java-openjdk")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        allow(env_vars).to receive(:web_server_type).and_return("tomcat")
+        expect(env_vars).to receive(:init_type).and_return("")
+
+        expected = [
+          "openjdk-7-jre",
+          "apache2",
+          "tomcat7",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars, :debian)).to eq(expected)
       end
     end
   end

data/spec/gordon/recipe_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Gordon::Recipe do
-  let(:options)   { instance_double Gordon::Options, app_type: :ruby_web_app }
+  let(:options)   { instance_double Gordon::Options, app_type: :web, runtime_name: :ruby }
   let(:app_type)  { Gordon::Application::Types::RubyWebApp.new }
 
   subject do
@@ -14,16 +14,6 @@ describe Gordon::Recipe do
     end
   end
 
-  # TODO: check if is really needed
-  describe 'getting a platform' do
-    pending
-  end
-
-  # TODO: check if is really needed
-  describe 'checking if requires platform' do
-    pending
-  end
-
   describe 'getting application template path' do
     it 'returns expected path based on app type' do
       expect(subject.application_template_path).to eq(app_type.get_template_path)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gordon
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Marcelo Pinheiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2015-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -110,6 +110,7 @@ files:
 - lib/gordon/skeleton/factory.rb
 - lib/gordon/skeleton/types.rb
 - lib/gordon/version.rb
+- spec/gordon/application/factory_spec.rb
 - spec/gordon/application/templates/java_web_app_spec.rb
 - spec/gordon/application/templates/ruby_standalone_app_spec.rb
 - spec/gordon/application/templates/ruby_web_app_spec.rb
@@ -158,6 +159,7 @@ signing_key:
 specification_version: 4
 summary: A tool to create application OS packages
 test_files:
+- spec/gordon/application/factory_spec.rb
 - spec/gordon/application/templates/java_web_app_spec.rb
 - spec/gordon/application/templates/ruby_standalone_app_spec.rb
 - spec/gordon/application/templates/ruby_web_app_spec.rb