fulmar 0.6.3

data/lib/fulmar/infrastructure/service/database/database_service.rb

@@ -0,0 +1,151 @@
+require 'mysql2'
+require 'fulmar/infrastructure/service/tunnel_service'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      module Database
+        # Provides basic methods common to all database services
+        class DatabaseService
+          attr_accessor :client
+          attr_reader :shell
+
+          DEFAULT_CONFIG = {
+            maria: {
+              hostname: '127.0.0.1',
+              port: 3306,
+              user: 'root',
+              password: '',
+              encoding: 'utf8',
+              backup_path: '/tmp'
+            }
+          }
+
+          def initialize(config)
+            @config = config
+            @config.merge DEFAULT_CONFIG
+            @shell = Fulmar::Infrastructure::Service::ShellService.new(config[:local_path], config[:hostname])
+            @tunnel = nil
+            @client = nil
+            config_test
+          end
+
+          def connect
+            options = compile_options
+
+            if @config[:maria][:hostname] != 'localhost' && @config[:maria][:hostname] != '127.0.0.1'
+              tunnel.open
+              options[:port] = tunnel.local_port
+            end
+
+            # Wait max 3 seconds for the tunnel to establish
+            4.times do |i|
+              begin
+                @client = Mysql2::Client.new options
+                break
+              rescue Mysql2::Error => e
+                sleep 1 if i < 3
+                fail e.message if i == 3
+              end
+            end
+
+            @connected = true
+          end
+
+          def disconnect
+            @connected = false
+            @client.close
+            @tunnel.close if @tunnel # using the variable directly avoids creating a tunnel instance when closing the database connection
+          end
+
+          def connected?
+            @connected
+          end
+
+          def tunnel
+            @tunnel ||= Fulmar::Infrastructure::Service::TunnelService.new(@config[:maria][:hostname], @config[:maria][:port])
+          end
+
+          # shortcut for DatabaseService.client.query
+          def query(*arguments)
+            @client.query(arguments)
+          end
+
+          def create(name)
+            state_before = connected?
+            connect unless connected?
+            @client.query "CREATE DATABASE IF NOT EXISTS `#{name}`"
+            disconnect unless state_before
+          end
+
+          def dump(filename = nil)
+
+            if filename
+              # Ensure path is absolute
+              path = filename[0, 1] == '/' ? filename : @config[:maria][:backup_path] + '/' + filename
+            else
+              path = @config[:maria][:backup_path] + '/' + backup_filename
+            end
+
+            diffable = @config[:maria][:diffable_dump] ? '--skip-comments --skip-extended-insert ' : ''
+
+            @shell.run "mysqldump -u #{@config[:maria][:user]} --password='#{@config[:maria][:password]}' " \
+                       "#{@config[:maria][:database]} --single-transaction #{diffable}-r \"#{path}\""
+
+            path
+          end
+
+          def load_dump(dump_file, database = @config[:maria][:database])
+            @shell.run "mysql -u #{@config[:maria][:user]} --password='#{@config[:maria][:password]}' " \
+                       "-D #{database} < #{dump_file}"
+          end
+
+          def download_dump(filename = backup_filename)
+            local_path = filename[0, 1] == '/' ? filename : @config[:local_path] + '/' + filename
+            remote_path = dump
+            copy = system("scp -q #{@config[:maria][:hostname]}:#{remote_path} #{local_path}")
+            system("ssh #{@config[:maria][:hostname]} 'rm -f #{remote_path}'") # delete temporary file
+            if copy
+              local_path
+            else
+              ''
+            end
+          end
+
+          protected
+
+          # Test configuration
+          def config_test
+            fail 'Configuration option "database" missing.' unless @config[:maria][:database]
+            @shell.run "test -d '#{@config[:maria][:backup_path]}'"
+          end
+
+          # Builds the filename for a new database backup file
+          # NOTE: The file might already exist, for example if this is run at the same
+          # time from to different clients. I won't handle this as it is unlikely and
+          # would result in more I/O
+          def backup_filename
+            "#{@config[:maria][:database]}_#{Time.now.strftime('%Y-%m-%dT%H%M%S')}.sql"
+          end
+
+          # Compiles a mysql config hash from valid options of the fulmar config
+          def compile_options
+            possible_options = [:host, :username, :password, :port, :encoding, :socket, :read_timeout, :write_timeout,
+                             :connect_timeout, :reconnect, :local_infile, :secure_auth, :default_file, :default_group,
+                             :init_command
+                            ]
+            options = {}
+            options[:host] = '127.0.0.1'
+            options[:username] = @config[:maria][:user]
+            possible_options.each do |option|
+              options[option] = @config[:maria][option] unless @config[:maria][option].nil?
+            end
+
+            options
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/infrastructure/service/git_service.rb

@@ -0,0 +1,67 @@
+require 'git'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      # Provides access to to the local git repository
+      class GitService
+        attr_accessor :git
+
+        DEFAULT_CONFIG = {
+          local_path: '.',
+          git: {
+            branch: nil
+          }
+        }
+
+        def initialize(config)
+          @config = config
+          @config.merge(DEFAULT_CONFIG)
+
+          unless @config[:git][:branch]
+            @config[:git][:branch] = case config.environment
+                                     when :preview
+                                       'preview'
+                                     when :live
+                                       'release'
+                                     else
+                                       'master'
+                                     end
+          end
+
+          @git = Git.open(@config[:local_path]) # :log => Logger.new(STDOUT)
+        end
+
+        def branches
+          @git.branches
+        end
+
+        def feature_branches
+          @git.branches.collect { |b| b.full }.select { |name| name.match(/^feature_/) }.sort
+        end
+
+        def preview_branches
+          @git.branches.collect { |b| b.full }.select { |name| name.match(/^preview_/) }.sort
+        end
+
+        def checkout(branch_name = derive_branch_name)
+          branches = @git.branches.local.find(branch_name)
+          if branches.any?
+            @git.checkout(branches.first)
+          else
+            branches = @git.branches.remote.find(branch_name)
+            fail "Cannot find a valid branch, last search was for #{branch_name}" unless branches.any?
+            @git.branch(branches.first)
+            @git.checkout(branches.first)
+          end
+        end
+
+        # The current preview branch is the alphabetically last preview branch
+        def derive_branch_name
+          @config[:git][:branch] == 'preview' ? preview_branches.last : @config[:git][:branch]
+        end
+
+      end
+    end
+  end
+end

data/lib/fulmar/infrastructure/service/shell_service.rb

@@ -0,0 +1,10 @@
+require 'fulmar/shell'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      # This is only a wrapper to fit the shell into the naming scheme
+      class ShellService < Fulmar::Shell; end
+    end
+  end
+end

data/lib/fulmar/infrastructure/service/transfer/base.rb

@@ -0,0 +1,58 @@
+
+require 'fulmar/shell'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      module Transfer
+        # Abstract class for alle transfers, provides common methods
+        class Base
+          DEFAULT_CONFIG = {
+            debug: false,
+            user: '',
+            password: '',
+            remote_path: nil,
+            local_path: '.',
+            type: :rsync_with_versions
+          }
+
+          attr_accessor :config
+
+          def initialize(config)
+            @config = DEFAULT_CONFIG.merge(config)
+
+            # Remove trailing slashes
+            @config[:local_path] = @config[:local_path].chomp('/') if @config[:local_path]
+            @config[:remote_path] = @config[:remote_path].chomp('/') if @config[:remote_path]
+
+            @prepared = false
+          end
+
+          # Test the supplied config for required parameters
+          def test_config
+            required = [:host, :remote_path, :local_path]
+            required.each { |key| fail "Configuration is missing required setting '#{key}'." if @config.blank? }
+            fail ':remote_path must be absolute' if @config[:remote_path][0, 1] != '/'
+          end
+
+          def prepare
+            @local_shell = Fulmar::Infrastructure::Service::ShellService.new @config[:local_path]
+            @local_shell.debug = @config[:debug]
+            @prepared = true
+          end
+
+          def publish
+            # Placeholder for consistent api, currently only implemented in rsync_with_versions
+            true
+          end
+
+          protected
+
+          def ssh_user_and_host
+            @config[:user].blank? ? @config[:hostname] : @config[:user] + '@' + @config[:hostname]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/infrastructure/service/transfer/rsync.rb

@@ -0,0 +1,58 @@
+
+require 'fulmar/infrastructure/service/transfer/base'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      module Transfer
+        # Implements the rsync transfer
+        class Rsync < Base
+          DEFAULT_CONFIG = {
+            rsync: {
+              exclude: nil,
+              exclude_file: nil,
+              chown: nil,
+              chmod: nil,
+              delete: true,
+              direction: 'up'
+            }
+          }
+
+          def initialize(config)
+            @config = DEFAULT_CONFIG.deep_merge(config)
+
+            if @config[:rsync][:exclude_file].blank? && File.exist?(@config[:local_path] + '/.rsyncignore')
+              @config[:rsync][:exclude_file] = @config[:local_path] + '/.rsyncignore'
+            end
+
+            super(@config)
+          end
+
+          def transfer
+            prepare unless @prepared
+            @local_shell.run rsync_command
+          end
+
+          def rsync_command
+            options = ['-rl']
+            options << "--exclude='#{@config[:rsync][:exclude]}'" if @config[:rsync][:exclude]
+            options << "--exclude-from='#{@config[:rsync][:exclude_file]}'" if @config[:rsync][:exclude_file]
+            options << "--chown='#{@config[:rsync][:chown]}'" if @config[:rsync][:chown]
+            options << "--chmod='#{@config[:rsync][:chmod]}'" if @config[:rsync][:chmod]
+            options << '--delete' if @config[:rsync][:delete]
+
+            if @config[:rsync][:direction] == 'up'
+              from = @config[:local_path]
+              to = ssh_user_and_host + ':' + @config[:remote_path]
+            else
+              from = ssh_user_and_host + ':' + @config[:remote_path]
+              to = @config[:local_path]
+            end
+
+            "rsync #{options.join(' ')} '#{from}/' '#{to}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/infrastructure/service/transfer/rsync_with_versions.rb

@@ -0,0 +1,194 @@
+
+require 'fulmar/infrastructure/service/transfer/base'
+require 'time'
+require 'ruby_wings'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      module Transfer
+        # Provides syncing with versioning on the server
+        #
+        # Every deployment results in a new directory in the releases directory with the deployment time as
+        # the folder name. A symlink 'current' points to this new directory after publish() is called.
+        class RsyncWithVersions < Base
+          TIME_FOLDER = '%Y-%m-%d_%H%M%S'
+          TIME_READABLE = '%Y-%m-%d %H:%M:%S'
+
+          DEFAULT_CONFIG = {
+            temp_dir: 'temp',
+            releases_dir: 'releases',
+            shared_dir: 'shared',
+            rsync: {
+              exclude: nil,
+              exclude_file: nil,
+              chown: nil,
+              chmod: nil,
+              delete: true
+            },
+            symlinks: {},
+            limit_releases: 10,
+            shared: []
+          }
+
+          def initialize(config)
+            @config = DEFAULT_CONFIG.deep_merge(config)
+            super(@config)
+
+            if @config[:rsync][:exclude_file].blank? && File.exist?(@config[:local_path] + '/.rsyncignore')
+              @config[:rsync][:exclude_file] = @config[:local_path] + '/.rsyncignore'
+            end
+
+            @release_time = Time.now
+          end
+
+          # Ensures all needed services are set up
+          def prepare
+            super
+            @remote_shell = Fulmar::Infrastructure::Service::ShellService.new @config[:remote_path], ssh_user_and_host
+            @remote_shell.debug = @config[:debug]
+          end
+
+          # Copy the files via rsync to the release_path on the remote machine
+          # @return [true, false] success
+          def transfer
+            prepare unless @prepared
+
+            create_paths && @local_shell.run(rsync_command) && copy_temp_to_release && add_shared
+          end
+
+          # Publishes the current release (i.e. sets the 'current' symlink)
+          # @return [true, false] success
+          def publish
+            prepare unless @prepared
+            create_symlink
+          end
+
+          # Gets the currently generated absolute release path
+          # @return [String] the release directory
+          def release_path
+            @config[:remote_path] + '/' + release_dir
+          end
+
+          # Gets the currently generated release directory
+          # @return [String] the release directory
+          def release_dir
+            @config[:releases_dir] + '/' + @release_time.strftime('%Y-%m-%d_%H%M%S')
+          end
+
+          # Lists the existing releases on the remote machine
+          # @param plain [boolean] if the list should be plain directory names or more readable time strings with a star for the current release
+          # @return [Array] list of dirs or dates/times
+          def list_releases(plain = true)
+            prepare unless @prepared
+            @remote_shell.run "ls -1 '#{@config[:releases_dir]}'"
+            list = @remote_shell.last_output.select { |dir| dir.match(/^\d{4}-\d{2}-\d{2}_\d{6}/) }
+            return list if plain
+
+            current = current_release
+            list.collect do |item|
+              Time.strptime(item, TIME_FOLDER).strftime(TIME_READABLE) + (item == current ? ' *' : '')
+            end
+          end
+
+          # Cleans up old releases limited by :limit_releases
+          # @return [true, false] success
+          def cleanup
+            limit = @config[:limit_releases].to_i
+            return true unless limit > 0
+            releases = list_releases.sort
+            return true if releases.length <= limit
+            obsolete_dirs = releases[0, releases.length - limit].collect { |dir| "'#{@config[:releases_dir]}/#{dir}'" }
+            @remote_shell.run "rm -fr #{obsolete_dirs.join(' ')}"
+          end
+
+          # Return the release at which the "current" symlinks points at
+          def current_release
+            prepare unless @prepared
+            @remote_shell.run 'readlink -f current'
+            @remote_shell.last_output.first.split('/').last
+          end
+
+          # Reverts to a given release
+          #
+          # @params release [String] the release folder or time string (which is found in the output list)
+          # @return [true, false] success
+          def revert(release)
+            prepare unless @prepared
+
+            # Convenience: Allow more readable version string from output
+            if release.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/)
+              release = Time.strptime(item, TIME_READABLE).strftime(TIME_FOLDER)
+            end
+
+            create_symlink release
+          end
+
+          protected
+
+          # Creates all necessary paths on the remote machine
+          # @return [true, false] success
+          def create_paths
+            paths = [@config[:releases_dir], @config[:temp_dir], @config[:shared_dir]]
+            @remote_shell.run paths.collect { |path| "mkdir -p '#{@config[:remote_path]}/#{path}'" }
+          end
+
+          # Builds the rsync command
+          # @return [String] the command
+          def rsync_command
+            options = ['-rl']
+            options << "--exclude='#{@config[:rsync][:exclude]}'" if @config[:rsync][:exclude]
+            options << "--exclude-from='#{@config[:rsync][:exclude_file]}'" if @config[:rsync][:exclude_file]
+            options << "--chown='#{@config[:rsync][:chown]}'" if @config[:rsync][:chown]
+            options << "--chmod='#{@config[:rsync][:chmod]}'" if @config[:rsync][:chmod]
+            options << '--delete' if @config[:rsync][:delete]
+
+            "rsync #{options.join(' ')} '#{@config[:local_path]}/' '#{ssh_user_and_host}:#{@config[:remote_path]}/#{@config[:temp_dir]}'"
+          end
+
+          # Copies the data from the sync temp to the actual release directory
+          # @return [true, false] success
+          def copy_temp_to_release
+            @remote_shell.run "cp -r #{@config[:temp_dir]} #{release_dir}"
+          end
+
+          # Set the symlink to the given release or the return value of release_dir() otherwise
+          #
+          # @params release [String] the release folder
+          # @return [true, false] success
+          def create_symlink(release = nil)
+            @remote_shell.run [
+              "rm -f #{@config[:remote_path]}/current",
+              "ln -s #{release ? @config[:releases_dir] + '/' + release : release_dir} current"
+            ]
+          end
+
+          # Creates symlinks into the shared folder
+          #
+          # An entry in :shared might be "data/resources/images", so we first need to create
+          # the directory "data/resources" in the release dir and afterwards create the link
+          # @return [true, false] success
+          def add_shared
+            commands = [] # Collect all remote commands first, then execute them in one step to avoid reconnecting very often
+            @config[:shared].each do |dir|
+              if remote_dir_exists?("#{release_dir}/#{dir}") && !remote_dir_exists?("#{@config[:shared_dir]}/#{dir}")
+                commands << "mkdir -p \"#{@config[:shared_dir]}/#{File.dirname(dir)}\""
+                commands << "cp -r \"#{release_dir}/#{dir}\" \"#{@config[:shared_dir]}/#{File.dirname(dir)}\""
+              end
+
+              commands << "rm -fr \"#{release_dir}/#{dir}\""
+              commands << "mkdir -p \"#{release_dir}/#{File.dirname(dir)}\""
+              commands << "ln -s \"#{@config[:remote_path]}/#{@config[:shared_dir]}/#{dir}\" \"#{release_dir}/#{dir}\""
+            end
+
+            @remote_shell.run commands if commands.length > 0
+          end
+
+          def remote_dir_exists?(dir)
+            @remote_shell.run "test -d \"#{dir}\""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/infrastructure/service/tunnel_service.rb

@@ -0,0 +1,49 @@
+require 'socket'
+
+module Fulmar
+  module Infrastructure
+    module Service
+      class TunnelService
+        attr_reader :host, :remote_port, :local_port
+
+        def initialize(host, port)
+          @host = host
+          @remote_port = port
+          @local_port = 0
+          @tunnel_pid = 0
+        end
+
+        def open
+          @local_port = free_port
+          @tunnel_pid = Process.spawn "ssh #{@host} -L #{@local_port}:localhost:#{@remote_port} -N"
+          sleep 1
+        end
+
+        def close
+          Process.kill 'TERM', @tunnel_pid if @tunnel_pid > 0
+          @local_port = 0
+          @tunnel_pid = 0
+        end
+
+        def open?
+          @tunnel_pid > 0
+        end
+
+        def free_port
+          port = 60000
+          begin
+            1000.times do
+              socket = TCPSocket.new('localhost', port)
+              socket.close
+              port += 1
+            end
+          rescue Errno::ECONNREFUSED
+            return port
+          end
+          fail 'Cannot find an open local port'
+          0
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/service/bootstrap_service.rb

@@ -0,0 +1,14 @@
+module Fulmar
+  module Service
+    # Initializes the rake service and starts it
+    class BootstrapService
+      def initialize
+        $logger = Fulmar::Service::LoggerService.new(STDOUT)
+      end
+
+      def fly
+        Fulmar::Domain::Service::ApplicationService.new.run
+      end
+    end
+  end
+end

data/lib/fulmar/service/common_helper_service.rb

@@ -0,0 +1,48 @@
+require 'fulmar/domain/service/configuration_service'
+
+module Fulmar
+  module Domain
+    module Service
+      # Provides the helper methods used in the tasks
+      module CommonHelperService
+        attr_accessor :environment
+
+        def full_configuration
+          configuration.configuration
+        end
+
+        def configuration
+          (@_config_service ||= Fulmar::Domain::Service::ConfigurationService.instance)
+        end
+
+        def composer(command, arguments = [])
+          (@_composer ||= Fulmar::Infrastructure::Service::ComposerService.new).execute(command, arguments)
+        end
+
+        def local_shell
+          @_local_shell ||= Fulmar::Infrastructure::Service::ShellService.new configuration[:local_path]
+        end
+
+        def remote_shell
+          @_remote_shell ||= Fulmar::Infrastructure::Service::ShellService.new(configuration[:remote_path], configuration[:hostname])
+        end
+
+        def file_sync
+          @_file_sync ||= Fulmar::FileSync.create_transfer configuration
+        end
+
+        def database
+          @_database ||= Fulmar::Infrastructure::Service::Database::DatabaseService.new configuration
+        end
+
+        def render_templates
+          (Fulmar::Domain::Service::ConfigRenderingService.new configuration).render
+        end
+
+        def git
+          @_git ||= Fulmar::Infrastructure::Service::GitService.new configuration
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/service/helper_service.rb

@@ -0,0 +1,37 @@
+module Fulmar
+  module Service
+    # Provides internal helper methods
+    class HelperService
+      class << self
+        ##
+        # Reverse file lookup in path
+        # @param path [String]
+        def reverse_file_lookup(path, filename)
+          paths = get_parent_directory_paths(path)
+
+          paths.each do |directory|
+            file_path = directory + '/' + filename
+            return file_path if File.exist? file_path
+          end
+
+          false
+        end
+
+        private
+
+        ##
+        # Get paths of each parent directory
+        # @param path [String]
+        # @param paths [Array]
+        # @return [Array] A list of paths
+        def get_parent_directory_paths(path, paths = [])
+          paths << path
+
+          parent_dir_path = File.expand_path('..', path)
+
+          parent_dir_path == '/' ? paths : get_parent_directory_paths(parent_dir_path, paths)
+        end
+      end
+    end
+  end
+end