foreman 0.85.0 → 0.87.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e43a0881882bfbd5a312184407cf297c245774fd31dd194bc7921f88de02187
-  data.tar.gz: e836814f151cd348c8744a158c2c5e0aaa35edc567d5482fef75b0b7943c8063
+  metadata.gz: b4561719e71efe2d57cb77e271499273d03dd6e3ce1566c2ea448b9924f3986b
+  data.tar.gz: 317cb62ea6013742326098d8e4942aafaed4f3c8ba1eee63bf52c269c514d3b8
 SHA512:
-  metadata.gz: 9ddc414ab8833e61463cc686cbffe9cb0cb3f6c745963854d57a048f044308d84f6a026378f1b1c90ae1e78a3988f327b86187ffd3871065582bef1623e0c6d6
-  data.tar.gz: 25ea476d1f02817f63040855c45c07f9e2e05753c18b190a715be3f0ff0f61b7dcca82ef2c8a3dc05522a7089a89c8e614e923b2019d0c891104bbab61318b3c
+  metadata.gz: 5af45a820751188c14a474634687b8a088aa436c0de20cf828e1ced1f3c4cdec51da0f6e1566dc78a0f04faa1f14c8a5e516005d96a0abc3c5833e689dd2d217
+  data.tar.gz: a35df2258df75633fdeb5835e5f6d82290be0c7c573fac3b2da482c9d61565db7acea6e80c6d1b0663b11924b825139502c0553d231f941a2fa0033cf7cee85a

data/README.md

@@ -10,7 +10,7 @@ Manage Procfile-based applications
 
     $ gem install foreman
 
-Ruby users should take care *not* to install foreman in their project's `Gemfile`.
+Ruby users should take care *not* to install foreman in their project's `Gemfile`. See this [wiki article](https://github.com/ddollar/foreman/wiki/Don't-Bundle-Foreman) for more details.
 
 ## Getting Started
 

data/data/export/systemd/master.target.erb

@@ -1,5 +1,5 @@
 [Unit]
-Wants=<%= process_master_names.join(' ') %>
+Wants=<%= service_names.join(' ') %>
 
 [Install]
 WantedBy=multi-user.target

data/data/export/systemd/process.service.erb

@@ -1,15 +1,18 @@
 [Unit]
-PartOf=<%= app %>-<%= name %>.target
+PartOf=<%= app %>.target
+StopWhenUnneeded=yes
 
 [Service]
 User=<%= user %>
 WorkingDirectory=<%= engine.root %>
-Environment=PORT=%i
+Environment=PORT=<%= port %>
+Environment=PS=<%= process_name %>
 <% engine.env.each_pair do |var,env| -%>
 Environment="<%= var %>=<%= env %>"
 <% end -%>
-ExecStart=/bin/bash -lc 'exec <%= process.command %>'
+ExecStart=/bin/bash -lc 'exec -a "<%= app %>-<%= process_name %>" <%= process.command %>'
 Restart=always
+RestartSec=14s
 StandardInput=null
 StandardOutput=syslog
 StandardError=syslog

data/lib/foreman/cli.rb

@@ -6,9 +6,9 @@ require "foreman/export"
 require "foreman/version"
 require "shellwords"
 require "yaml"
-require "thor"
+require "foreman/vendor/thor/lib/thor"
 
-class Foreman::CLI < Thor
+class Foreman::CLI < Foreman::Thor
 
   include Foreman::Helpers
 
@@ -157,6 +157,6 @@ private ######################################################################
     original_options = super
     return original_options unless File.file?(".foreman")
     defaults = ::YAML::load_file(".foreman") || {}
-    Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
+    Foreman::Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
   end
 end

data/lib/foreman/export/systemd.rb

@@ -17,22 +17,16 @@ class Foreman::Export::Systemd < Foreman::Export::Base
       clean_dir file
     end
 
-    process_master_names = []
+    service_names = []
 
     engine.each_process do |name, process|
-      service_fn = "#{app}-#{name}@.service"
-      write_template "systemd/process.service.erb", service_fn, binding
-
-      create_directory("#{app}-#{name}.target.wants")
-      1.upto(engine.formation[name])
-        .collect { |num| engine.port_for(process, num) }
-        .collect { |port| "#{app}-#{name}@#{port}.service" }
-        .each do |process_name|
-        create_symlink("#{app}-#{name}.target.wants/#{process_name}", "../#{service_fn}") rescue Errno::EEXIST # This is needed because rr-mocks do not call the origial cleanup
+      1.upto(engine.formation[name]) do |num|
+        port = engine.port_for(process, num)
+        process_name = "#{name}.#{num}"
+        service_filename = "#{app}-#{process_name}.service"
+        write_template "systemd/process.service.erb", service_filename, binding
+        service_names << service_filename
       end
-
-      write_template "systemd/process_master.target.erb", "#{app}-#{name}.target", binding
-      process_master_names << "#{app}-#{name}.target"
     end
 
     write_template "systemd/master.target.erb", "#{app}.target", binding

data/lib/foreman/vendor/thor/lib/thor/actions/create_file.rb

@@ -0,0 +1,103 @@
+require "foreman/vendor/thor/lib/thor/actions/empty_directory"
+
+class Foreman::Thor
+  module Actions
+    # Create a new file relative to the destination root with the given data,
+    # which is the return value of a block or a data string.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # data<String|NilClass>:: the data to append to the file.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   create_file "lib/fun_party.rb" do
+    #     hostname = ask("What is the virtual hostname I should use?")
+    #     "vhost.name = #{hostname}"
+    #   end
+    #
+    #   create_file "config/apache.conf", "your apache config"
+    #
+    def create_file(destination, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      data = args.first
+      action CreateFile.new(self, destination, block || data.to_s, config)
+    end
+    alias_method :add_file, :create_file
+
+    # CreateFile is a subset of Template, which instead of rendering a file with
+    # ERB, it gets the content from the user.
+    #
+    class CreateFile < EmptyDirectory #:nodoc:
+      attr_reader :data
+
+      def initialize(base, destination, data, config = {})
+        @data = data
+        super(base, destination, config)
+      end
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && File.binread(destination) == render
+      end
+
+      # Holds the content to be added to the file.
+      #
+      def render
+        @render ||= if data.is_a?(Proc)
+          data.call
+        else
+          data
+        end
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          File.open(destination, "wb") { |f| f.write render }
+        end
+        given_destination
+      end
+
+    protected
+
+      # Now on conflict we check if the file is identical or not.
+      #
+      def on_conflict_behavior(&block)
+        if identical?
+          say_status :identical, :blue
+        else
+          options = base.options.merge(config)
+          force_or_skip_or_conflict(options[:force], options[:skip], &block)
+        end
+      end
+
+      # If force is true, run the action, otherwise check if it's not being
+      # skipped. If both are false, show the file_collision menu, if the menu
+      # returns true, force it, otherwise skip.
+      #
+      def force_or_skip_or_conflict(force, skip, &block)
+        if force
+          say_status :force, :yellow
+          yield unless pretend?
+        elsif skip
+          say_status :skip, :yellow
+        else
+          say_status :conflict, :red
+          force_or_skip_or_conflict(force_on_collision?, true, &block)
+        end
+      end
+
+      # Shows the file collision menu to the user and gets the result.
+      #
+      def force_on_collision?
+        base.shell.file_collision(destination) { render }
+      end
+    end
+  end
+end

data/lib/foreman/vendor/thor/lib/thor/actions/create_link.rb

@@ -0,0 +1,59 @@
+require "foreman/vendor/thor/lib/thor/actions/create_file"
+
+class Foreman::Thor
+  module Actions
+    # Create a new file relative to the destination root from the given source.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # source<String|NilClass>:: the relative path to the source root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #   :: give :symbolic => false for hard link.
+    #
+    # ==== Examples
+    #
+    #   create_link "config/apache.conf", "/etc/apache.conf"
+    #
+    def create_link(destination, *args)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      source = args.first
+      action CreateLink.new(self, destination, source, config)
+    end
+    alias_method :add_link, :create_link
+
+    # CreateLink is a subset of CreateFile, which instead of taking a block of
+    # data, just takes a source string from the user.
+    #
+    class CreateLink < CreateFile #:nodoc:
+      attr_reader :data
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && File.identical?(render, destination)
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          # Create a symlink by default
+          config[:symbolic] = true if config[:symbolic].nil?
+          File.unlink(destination) if exists?
+          if config[:symbolic]
+            File.symlink(render, destination)
+          else
+            File.link(render, destination)
+          end
+        end
+        given_destination
+      end
+
+      def exists?
+        super || File.symlink?(destination)
+      end
+    end
+  end
+end

data/lib/foreman/vendor/thor/lib/thor/actions/directory.rb

@@ -0,0 +1,118 @@
+require "foreman/vendor/thor/lib/thor/actions/empty_directory"
+
+class Foreman::Thor
+  module Actions
+    # Copies recursively the files from source directory to root directory.
+    # If any of the files finishes with .tt, it's considered to be a template
+    # and is placed in the destination without the extension .tt. If any
+    # empty directory is found, it's copied and all .empty_directory files are
+    # ignored. If any file name is wrapped within % signs, the text within
+    # the % signs will be executed as a method and replaced with the returned
+    # value. Let's suppose a doc directory with the following files:
+    #
+    #   doc/
+    #     components/.empty_directory
+    #     README
+    #     rdoc.rb.tt
+    #     %app_name%.rb
+    #
+    # When invoked as:
+    #
+    #   directory "doc"
+    #
+    # It will create a doc directory in the destination with the following
+    # files (assuming that the `app_name` method returns the value "blog"):
+    #
+    #   doc/
+    #     components/
+    #     README
+    #     rdoc.rb
+    #     blog.rb
+    #
+    # <b>Encoded path note:</b> Since Foreman::Thor internals use Object#respond_to? to check if it can
+    # expand %something%, this `something` should be a public method in the class calling
+    # #directory. If a method is private, Foreman::Thor stack raises PrivateMethodEncodedError.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #                If :recursive => false, does not look for paths recursively.
+    #                If :mode => :preserve, preserve the file mode from the source.
+    #                If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
+    #
+    # ==== Examples
+    #
+    #   directory "doc"
+    #   directory "doc", "docs", :recursive => false
+    #
+    def directory(source, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source
+      action Directory.new(self, source, destination || source, config, &block)
+    end
+
+    class Directory < EmptyDirectory #:nodoc:
+      attr_reader :source
+
+      def initialize(base, source, destination = nil, config = {}, &block)
+        @source = File.expand_path(base.find_in_source_paths(source.to_s))
+        @block  = block
+        super(base, destination, {:recursive => true}.merge(config))
+      end
+
+      def invoke!
+        base.empty_directory given_destination, config
+        execute!
+      end
+
+      def revoke!
+        execute!
+      end
+
+    protected
+
+      def execute!
+        lookup = Util.escape_globs(source)
+        lookup = config[:recursive] ? File.join(lookup, "**") : lookup
+        lookup = file_level_lookup(lookup)
+
+        files(lookup).sort.each do |file_source|
+          next if File.directory?(file_source)
+          next if config[:exclude_pattern] && file_source.match(config[:exclude_pattern])
+          file_destination = File.join(given_destination, file_source.gsub(source, "."))
+          file_destination.gsub!("/./", "/")
+
+          case file_source
+          when /\.empty_directory$/
+            dirname = File.dirname(file_destination).gsub(%r{/\.$}, "")
+            next if dirname == given_destination
+            base.empty_directory(dirname, config)
+          when /#{TEMPLATE_EXTNAME}$/
+            base.template(file_source, file_destination[0..-4], config, &@block)
+          else
+            base.copy_file(file_source, file_destination, config, &@block)
+          end
+        end
+      end
+
+      if RUBY_VERSION < "2.0"
+        def file_level_lookup(previous_lookup)
+          File.join(previous_lookup, "{*,.[a-z]*}")
+        end
+
+        def files(lookup)
+          Dir[lookup]
+        end
+      else
+        def file_level_lookup(previous_lookup)
+          File.join(previous_lookup, "*")
+        end
+
+        def files(lookup)
+          Dir.glob(lookup, File::FNM_DOTMATCH)
+        end
+      end
+    end
+  end
+end

data/lib/foreman/vendor/thor/lib/thor/actions/empty_directory.rb

@@ -0,0 +1,135 @@
+class Foreman::Thor
+  module Actions
+    # Creates an empty directory.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   empty_directory "doc"
+    #
+    def empty_directory(destination, config = {})
+      action EmptyDirectory.new(self, destination, config)
+    end
+
+    # Class which holds create directory logic. This is the base class for
+    # other actions like create_file and directory.
+    #
+    # This implementation is based in Templater actions, created by Jonas Nicklas
+    # and Michael S. Klishin under MIT LICENSE.
+    #
+    class EmptyDirectory #:nodoc:
+      attr_reader :base, :destination, :given_destination, :relative_destination, :config
+
+      # Initializes given the source and destination.
+      #
+      # ==== Parameters
+      # base<Foreman::Thor::Base>:: A Foreman::Thor::Base instance
+      # source<String>:: Relative path to the source of this file
+      # destination<String>:: Relative path to the destination of this file
+      # config<Hash>:: give :verbose => false to not log the status.
+      #
+      def initialize(base, destination, config = {})
+        @base = base
+        @config = {:verbose => true}.merge(config)
+        self.destination = destination
+      end
+
+      # Checks if the destination file already exists.
+      #
+      # ==== Returns
+      # Boolean:: true if the file exists, false otherwise.
+      #
+      def exists?
+        ::File.exist?(destination)
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          ::FileUtils.mkdir_p(destination)
+        end
+      end
+
+      def revoke!
+        say_status :remove, :red
+        ::FileUtils.rm_rf(destination) if !pretend? && exists?
+        given_destination
+      end
+
+    protected
+
+      # Shortcut for pretend.
+      #
+      def pretend?
+        base.options[:pretend]
+      end
+
+      # Sets the absolute destination value from a relative destination value.
+      # It also stores the given and relative destination. Let's suppose our
+      # script is being executed on "dest", it sets the destination root to
+      # "dest". The destination, given_destination and relative_destination
+      # are related in the following way:
+      #
+      #   inside "bar" do
+      #     empty_directory "baz"
+      #   end
+      #
+      #   destination          #=> dest/bar/baz
+      #   relative_destination #=> bar/baz
+      #   given_destination    #=> baz
+      #
+      def destination=(destination)
+        return unless destination
+        @given_destination = convert_encoded_instructions(destination.to_s)
+        @destination = ::File.expand_path(@given_destination, base.destination_root)
+        @relative_destination = base.relative_to_original_destination_root(@destination)
+      end
+
+      # Filenames in the encoded form are converted. If you have a file:
+      #
+      #   %file_name%.rb
+      #
+      # It calls #file_name from the base and replaces %-string with the
+      # return value (should be String) of #file_name:
+      #
+      #   user.rb
+      #
+      # The method referenced can be either public or private.
+      #
+      def convert_encoded_instructions(filename)
+        filename.gsub(/%(.*?)%/) do |initial_string|
+          method = $1.strip
+          base.respond_to?(method, true) ? base.send(method) : initial_string
+        end
+      end
+
+      # Receives a hash of options and just execute the block if some
+      # conditions are met.
+      #
+      def invoke_with_conflict_check(&block)
+        if exists?
+          on_conflict_behavior(&block)
+        else
+          say_status :create, :green
+          yield unless pretend?
+        end
+
+        destination
+      end
+
+      # What to do when the destination file already exists.
+      #
+      def on_conflict_behavior
+        say_status :exist, :blue
+      end
+
+      # Shortcut to say_status shell method.
+      #
+      def say_status(status, color)
+        base.shell.say_status status, relative_destination, color if config[:verbose]
+      end
+    end
+  end
+end