fulmar 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94c412b27a13af7d2c5954307361b2afedb2a065
-  data.tar.gz: b1630fd62123dfaeab9167648a07e3af90f8f840
+  metadata.gz: 86d6596b35b141aa77a6e85f919123ba13f2524e
+  data.tar.gz: ed72cbe277ea44d85c0487427d7a6c5abf24be20
 SHA512:
-  metadata.gz: 30f6993150e391316a3a706b45237f271adc249fee20d94fc5fbe44e43edd6f473b9c813dcbd4d9fb651467fe8a49231fd3836e19100c515d208cad89b6e72b7
-  data.tar.gz: 7a94a81d220d6c3536d98291bfa3cdd15af8c0aff7ea3a7db79c612509ce5c6cbfc60717d8dd7b387f46c21ce6ee5648b8ac5de7100ee2496752823a44508a43
+  metadata.gz: 6226c3b6326906ef3167475aa68b5e96603b681d6a8003d602489b57c711555b127fc61b00174243230308f785f8b4b0438f0942ade12aa98bf7d24c504d23e5
+  data.tar.gz: 6023777a09ddd21d853aa61a2fed8724376e48c67448a71d8a3f37c6fc45ac058e7bfc2090620049d39fba34a9cb3f5f4d88c8b59feb08e71650e1367c0d9d0f

data/README.md

@@ -1,9 +1,28 @@
 # Fulmar
 
-Fulmar is a task manager for deployments.
+Fulmar is a task manager for deployments. It is build on top of rake to use its powerful
+task system and adds host and environment configuration. It provides methods to easily
+access the current deployment configuration and simplifies especially file transfers and
+remote shell execution.
 
-This project is still under heavy development for the next few weeks. You might want to check back in May 2015. We hope
-to get this somehow stable until then.
+A deployment can create a new version folder on the remote system in which you can warm up
+the cache and the publish via a symlink. This avoids an inconsistent state on the production
+machine and allows a quick revert to the old version, as long as other dependencies are
+compatible (i.e. database).
+
+It has (yet limited) support for MySQL / MariaDB and git. Remote databases can be accessed
+through an ssh tunnel.
+
+## Prerequisites
+
+Fulmar currently requires the [mysql2](https://github.com/brianmario/mysql2) gem which
+requires the mysql header files. So on a linux system, you want to install
+libmariadbclient-dev/libmysqlclient-dev or similar.
+
+You also need cmake to build the dependencies.
+
+- OSX: brew install mariadb cmake
+- Ubuntu: apt-get install libmariadbclient-dev build-essential cmake
 
 ## Installation
 
@@ -23,4 +42,288 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Fulmar works like Rake. In fact it is just a collection of services on top of Rake.
+
+## A simple start
+
+Start by creating a file named "Fulmarfile" in your project root. Then add a Folder "Fulmar" with a project.config.yml in it. The name of the config file doesn't matter, it just needs to end with .config.yml. All \*.config.yml in the Fulmar directory are merged so you can split you configuration into
+several files.
+
+    $ touch Fulmarfile
+    $ mkdir Fulmar
+    $ touch Fulmar/project.config.yml
+
+You can now now test your configuration.
+
+    $ fulmar test:config
+
+Everything should be fine. With `fulmar -T` you can get a quick overview on the available tasks. That is probably just one, the fulmar console. We'll come back to this later.
+
+Now let's start with a first configuration. You might want to have a server ready which you can access via ssh and public key authentication. Add this to you configuration file (Fulmar/project.config.yml):
+
+```yaml
+environments:
+  all:
+    local_path: .
+  my_server:
+    files:
+      hostname: my-ssh-server
+      remote_path: /tmp
+      type: rsync
+      rsync:
+        delete: false
+```
+
+Now you can run a second test: `fulmar test:hosts`. This will test the ssh connection to your remote machine. You can add a username to the ssh configuration in the files section (below the hostname). However, if you need a finer grained host configuration, you should use your [ssh config file](http://www.cyberciti.biz/faq/create-ssh-config-file-on-linux-unix/).
+
+Most fulmar tasks need to run within a configured environment. Within the configuration, environments are split into targets. So actually, a task works within a target. In our example, we set up an environment named 'my_server' with a target named 'files'. You might want to use one environment for your development server, one for a preview server and one for the production machine. Within each environment you might have different hosts for the file and the database, so each environment can be split up into multiple targets (e.g. 'files' and 'database').
+
+There is one special environment 'all' which contains settings you want to use in all targets of all environements. These globally configured settings are overwritten with the specific ones from a target if they exist. Useful examples for this are 'local_path' and 'debug'.
+
+### Tasks
+
+As you can see (`fulmar -T`), you cannot do anything more useful now. So it is time to write a first task. If you are familiar with rake, this should not be a problem.
+
+```ruby
+namespace :deploy do
+  task :test do
+    configuration.environment = :my_server
+    configuration.target = :files
+    file_sync.transfer
+  end
+end
+```
+
+This creates a task 'test' within the namespace 'deploy', which means you can access the task by running `fulmar deploy:test`. The task will load the configuration for 'myserver/files' and start a file sync (via rsync) to your remote host.
+
+If you log in to your remote machine, you should now see the Fulmar directory and the Fulmarfile in /tmp.
+```bash
+ssh my-ssh-server "ls -l /tmp | grep Fulmar"
+```
+
+This task can be even shorter. Fulmar creates some helper tasks automatically from your configuration. Just like in rake, you can list them via `fulmar -T -A`:
+```
+fulmar console                      # Open an interactive terminal within fulmar
+fulmar deploy:test                  # Deploy to test system
+fulmar environment:my_server        #
+fulmar environment:my_server:files  #
+fulmar test:config                  #
+fulmar test:hosts                   #
+```
+
+Fulmar creates task for every environment/target with this scheme. So you can just set a dependency to these tasks to load the configuration. Your task now only needs one line:
+
+```ruby
+namespace :deploy do
+  task :test => 'environment:my_server:files' do
+    file_sync.transfer
+  end
+end
+```
+
+Task can have multiple dependencies, just put them into an array:
+
+```ruby
+task :test => ['environment:my_server:files', 'prepare_files', 'do_some_more'] do
+end
+```
+
+If you call one task from another, your configuration will be given to the subtask. If you change the target in the subtask it will be reverted when returning to your main task unless you did not set any configuration in the main task. This means the following:
+- You can use the dependency to a 'environment:' task to set the target initially (as it will be the first subtask to run)
+- You can call a subtask and and you don't have to worry it might change your target.
+
+*The configuration object is a singleton. So if you change the actual configuration of a target, it will affect other tasks*
+
+## Features
+
+So now you can deploy the Fulmarfiles itself which is nice. So what else can you do within a task?
+
+### Shell
+
+Very often you need to call other programs or script from a shell to compile your assets or clear the cache. Within a task, you can access the local and remote shell:
+
+```ruby
+task :tutorial => 'environment:my_server:files' do
+  local_shell.run 'echo Wheeeeee'
+  remote_shell.run 'ls -l | grep Fulmar'
+  puts remote_shell.last_output
+end
+```
+
+You can run multiple commands. If one fails, everything stops immediately. This is intended to stop the deployment of broken files.
+
+```ruby
+task :tutorial => 'environment:my_server:files' do
+  local_shell.run [
+    'echo Wheeeee',
+    'false',
+    'echo Does not get executed'
+  ]
+  info "This does not get executed, either"
+end
+```
+
+### Output
+
+If you want your tasks to output some status messages, you can call `info`, `warning` or `error`.
+
+```ruby
+task :tutorial => 'environment:my_server:files' do
+  info "Everything is fine."
+  warning "Or probably not."
+  error "Yepp, it's borken"
+end
+```
+
+### File synchronisation
+
+At the moment, there are two ways to synchronize your files to a remote host. The basic rsync and "rsync with versions". You already know how to set up the simple file sync. You can add a few options, if you like:
+
+```yaml
+environments:
+  all:
+    local_path: .
+  my_server:
+    files:
+      hostname: my-ssh-server
+      remote_path: /tmp
+      type: rsync
+      rsync:
+        # Default values are:
+        delete: true
+        exclude: nil,
+        exclude_file: .rsyncignore,
+        chown: nil,
+        chmod: nil,
+        direction: up
+```
+
+These are:
+- **delete**: true/false, Should additional files be deleted from the remote host? The default is "true", as you don't want to have legacy files opening security holes on your server.
+- **exclude**: regexp, which works with "--exclude" from rsync. Usually, you should prefer the next option
+- **exclude_file**: Filename of the exclude file relative to "local_path". If you have a file called .rsyncignore in "local_path" this will be used automatically.
+- **chown**: chown files on remote machine to this user
+- **chmod**: change mode of files on remote machines
+- **direction**: up/down, Should the files be uploaded or downloaded? The latter is useful if you want to download images created by a cms on the remote machine.
+
+### rsync with versions
+
+When deploying to a production machine, you want your minimize the downtime for the website. Fulmar can help by syncing different versions which are symlinked after they are set up.
+
+```yaml
+environments:
+  all:
+    local_path: .
+  my_server:
+    files:
+      hostname: my-ssh-server
+      remote_path: /tmp
+      type: rsync_with_versions
+      shared:
+        - data
+      limit_releases: 10
+      #temp_dir: temp
+      #releases_dir: releases
+      #shared_dir: shared
+```
+
+You do no necessarily need to set "limit_releases" or "shared". "temp_dir", "releases_dir" and "shared_dir" are relative to the remote_path and usually do not need to be changed.
+
+So what does this all mean?
+
+If you still have your deploy:test task you can now deploy a first version of your files. Probably create the "data" dir first and put a file in to see what happens. Fulmar will sync you project into a temporary directory ("temp_dir") and then copy it the the releases directory with the current timestamp as a directory name. So in this case, a directory like "/tmp/releases/2015-04-27_123456" will be created. Fulmar will then look of shared/data exists and if not, copy it from the releases directory. Shared directories in releases will be deleted an symlinked to shared. So you want to list all directories which are filled by you web application (images uploaded from the cms, etc).
+
+Then you can build up the cache or whatever needs to be done within that directory before putting it live. This last step is not yet covered in our little deployment task. So:
+
+```ruby
+namespace :deploy do
+  task :test => 'environment:my_server:files' do
+    releases_dir = file_sync.transfer
+    puts release_dir # Something like 'releases/2015-04-27_123456'
+    remote_shell [
+      "cd #{release_dir}",
+      'php app/console cache:clear --env=dev'
+    ]
+    file_sync.publish # create
+  end
+end
+```
+
+The transfer() method of the file_sync service returns the created release dir and you can do what needs to be done before calling file_sync.publish to create the symlink (current => releases/2015-04-27_123456).
+
+As you probably figured out, your webserver uses the "current" symlink to get the base directory of your web application. Here, you would point it to /tmp/current/public or something like that.
+
+### Database access
+
+Within a task you can access and update databases (mariadb/mysql at the time of writing). Remote databases do not need to be accessible directly since fulmar uses an ssh tunnel to connect to the host first. So the database host is often just "localhost" (the default value). You can specify a different host if you database server is on another host, which is the case on most simple web spaces.
+
+The field "maria:database" is required for type "maria". The other fields are optional, though you probably need the fields "user" and "password". Below you can see the default values for the optional fields.
+
+```yaml
+environments:
+  staging:
+    database:
+      host: project-staging
+      type: maria
+      maria:
+        database: db_name
+        user: root
+        password:
+        port: 3306
+        host: localhost
+        encoding: utf-8
+```
+
+```ruby
+require 'pp'
+
+task :database => 'environment:staging:database' do
+  database.create 'test_db'
+  database.clear # deletes all tables within the database
+  remote_file_name = database.dump # dumps the database to the returned file
+  database.load_dump(remote_file_name) # loads an sql dump
+  local_filename = database.download_dump # downloads an sql dump to your machine
+end
+```
+
+You can query the database like this:
+
+```ruby
+results = database.query 'SELECT name, email FROM users'
+results.each do |row|
+  puts "#{row['name']} <#{row['email']}>"
+end
+```
+
+You can use all features of the mysql2 gem via `database.client`.
+
+If you configured more than one database on different environments, fulmar will
+create task to sync these databases via mysql_dump. This allows you to update a
+staging or preview database with the data from the production system.
+
+```
+fulmar database:update:preview:from_live
+```
+
+The task to copy data *to* the live database is hidden (it has no description).
+
+### Configuration templates
+
+Sometimes you need different versions of files on your different environments. An exmaple might be the .htaccess file. You can use the [Ruby ERB templating engine](http://www.stuartellis.eu/articles/erb/) to generate the different versions. The configuration of your environment are available via the `@config` variable.
+
+Templates need to be named with the schema `<original_filename>.erb`. All files you want to render need to be listed in the configuration:
+
+```yaml
+environments:
+  staging:
+    files:
+      config_templates:
+        - .htaccess.erb
+      application_environment: Production/Live
+```
+
+Then add the variable to your template:
+
+```
+SetEnv APPLICATION_ENVIRONMENT "<%= @config['application_environment'] %>"
+```

data/bin/fulmar

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
 
-if ARGV[0] == 'init'
-  system('touch Fulmarfile')
-end
+system('touch Fulmarfile') if ARGV[0] == 'init'
 
 require 'fulmar/task_manager'

data/lib/fulmar/domain/service/application_service.rb

@@ -50,12 +50,14 @@ module Fulmar
         def standard_rake_options
           options = super
           options.reject { |option| option[0] == '--version' }
-          options << ['--version', '-V',
-              'Display the program version.',
-              lambda { |_value|
+          options << [
+            '--version',
+            '-V',
+            'Display the program version.',
+            lambda do |_value|
               puts "fulmar #{Fulmar::VERSION} (using rake, version #{RAKEVERSION})"
               exit
-            }
+            end
           ]
         end
       end

data/lib/fulmar/domain/service/config_rendering_service.rb

@@ -12,15 +12,20 @@ module Fulmar
         def render
           return unless @config[:config_templates]
           @config[:config_templates].each do |template_file|
-            template = "#{@config[:local_path]}/#{template_file}"
-            fail "Template filenames must end in .erb - '#{template}' does not" unless template[-4, 4] == '.erb'
-            fail "Cannot render missing config file '#{template}'" unless File.exist? template
+            template = template_path(template_file)
 
             renderer = ERB.new(File.read(template))
             result_path = File.dirname(template) + '/' + File.basename(template, '.erb')
             File.open(result_path, 'w') { |config_file| config_file.write(renderer.result(binding)) }
           end
         end
+
+        def template_path(template_file)
+          template = "#{@config[:local_path]}/#{template_file}"
+          fail "Template filenames must end in .erb - '#{template}' does not" unless template[-4, 4] == '.erb'
+          fail "Cannot render missing config file '#{template}'" unless File.exist? template
+          template
+        end
       end
     end
   end

data/lib/fulmar/domain/service/config_test_service.rb

@@ -0,0 +1,143 @@
+require 'erb'
+
+module Fulmar
+  module Domain
+    module Service
+      # Tests the configuration
+      class ConfigTestService
+        def initialize(config)
+          @config = config
+          @config.load_user_config = false
+          @config.reset
+        end
+
+        # Runs all methods beginning with test_ and returns the report
+        def run
+          @report = []
+          tests = methods.select { |name| name.to_s[0, 5] == 'test_' }
+          tests.each do |test|
+            send(test)
+          end
+          @report
+        end
+
+        def test_hostnames_exist
+          @config.each do |env, target, data|
+            if data[:hostname].blank? && !data[:host].blank?
+              @report << {
+                message: "#{env}:#{target} has a host (#{data[:host]}) but is missing a hostname",
+                severity: :warning
+              }
+            end
+          end
+        end
+
+        def test_project_name_exists
+          if @config.configuration[:project][:name].blank?
+            add_report 'Project is missing a name', :warning
+          end
+        end
+
+        def test_hostnames_in_ssh_config
+          hostnames = ssh_hostnames
+
+          @config.each do |env, target, data|
+            next if data[:hostname].blank?
+
+            unless hostnames.include? data[:hostname]
+              @report << {
+                message: "#{env}:#{target} has a hostname (#{data[:hostname]}) which is not found in your ssh config",
+                severity: :info
+              }
+            end
+          end
+        end
+
+        def test_required_hostnames
+          types = %i(rsync rsync_with_version maria)
+          @config.each do |env, target, data|
+            if types.include?(data[:type]) && data[:hostname].blank?
+              @report << {
+                message: "#{env}:#{target} requires a hostname (#{data[:hostname]})",
+                severity: :error
+              }
+            end
+          end
+        end
+
+        def test_vhost_template_is_set
+          vhost_template = false
+
+          @config.each do |_env, _target, data|
+            vhost_template = true unless data[:vhost_template].blank?
+          end
+
+          add_report(
+            'The configuration uses the vhost feature but misses a valid configuration for it (missing :vhost_template)',
+            :warning
+          ) if @config.feature?(:vhost) && !vhost_template
+        end
+
+        # Run simple test which only require one configuration
+        def test_simple_tests
+          @config.each do |env, target, data|
+            tests = methods.select { |name| name.to_s[0, 12] == 'simple_test_' }
+            tests.each do |test|
+              send(test, env, target, data)
+            end
+          end
+        end
+
+        def simple_test_local_path_exists(env, target, data)
+          unless File.exist? data[:local_path]
+            add_report("#{env}:#{target} has no valid local_path (#{data[:local_path]})", :warning)
+          end
+        end
+
+        def simple_test_mariadb_feature_is_set(env, target, data)
+          if data[:type] == :maria && !@config.feature?(:database)
+            @report << {
+              message: "#{env}:#{target} uses mysql/mariadb but your config is missing the database feature",
+              severity: :notice
+            }
+          end
+        end
+
+        def simple_test_vhost_feature_is_set(env, target, data)
+          if data[:vhost_template] && !@config.feature?(:vhost)
+            @report << {
+              message: "#{env}:#{target} refers to a vhost_template but your config is missing the vhost feature",
+              severity: :warning
+            }
+          end
+        end
+
+        def simple_test_maria_db_config_exists(env, target, data)
+          if data[:type] == :maria && data[:maria][:database].blank?
+            add_report "#{env}:#{target} is missing a database name in maria:database", :error
+          end
+        end
+
+        def simple_test_remote_path_exists_for_rsync(env, target, data)
+          types = [:rsync, :rsync_with_version]
+          if types.include?(data[:type]) && data[:remote_path].blank?
+            add_report "#{env}:#{target} is missing a remote path", :error
+          end
+        end
+
+        protected
+
+        def add_report(message, severity)
+          @report << {
+            message: message,
+            severity: severity
+          }
+        end
+
+        def ssh_hostnames
+          `grep -E '^Host [^ *]+$' ~/.ssh/config | sort | uniq | cut -d ' ' -f 2`.split("\n")
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/domain/service/configuration_service.rb

@@ -13,6 +13,7 @@ module Fulmar
         DEPLOYMENT_CONFIG_FILE = 'deployment.yml'
 
         BLANK_CONFIG = {
+          project: {},
           environments: {},
           features: {},
           hosts: {},
@@ -22,10 +23,12 @@ module Fulmar
         include Singleton
 
         attr_reader :environment, :target
+        attr_accessor :load_user_config
 
         def initialize
           @environment = nil
           @target = nil
+          @load_user_config = true
         end
 
         # Allow access of configuration via array/hash access methods (read access)
@@ -120,10 +123,17 @@ module Fulmar
 
         def config_files
           files = Dir.glob(File.join(base_path, FULMAR_CONFIGURATION_DIR, '*.config.yml')).sort
-          files << "#{ENV['HOME']}/.fulmar.yml" if File.exist? "#{ENV['HOME']}/.fulmar.yml"
+          files << "#{ENV['HOME']}/.fulmar.yml" if File.exist?("#{ENV['HOME']}/.fulmar.yml") && @load_user_config
           files
         end
 
+        # Reset the loaded configuration, forcing a reload
+        # this is currently used for reloading the config without the user config file
+        # to test the project configuration
+        def reset
+          @config = nil
+        end
+
         protected
 
         def lookup_base_path
@@ -145,12 +155,9 @@ module Fulmar
           return if @config[:environments][env][target][:host].blank?
 
           host = @config[:environments][env][target][:host].to_sym
-          if @config[:hosts] && @config[:hosts][host]
-            @config[:hosts][host].each do
-              @config[:environments][env][target] = @config[:hosts][host].deep_merge(@config[:environments][env][target])
-            end
-          else
-            fail "Host #{host} is not configured."
+          return unless @config[:hosts] && @config[:hosts][host]
+          @config[:hosts][host].each do
+            @config[:environments][env][target] = @config[:hosts][host].deep_merge(@config[:environments][env][target])
           end
         end
 

data/lib/fulmar/domain/service/dependency_service.rb

@@ -26,7 +26,7 @@ module Fulmar
             if git.branches.select { |b| b.name.split('/').last == data[:ref] }.any?
               checkout_branch(git, data[:ref])
             elsif git.tags.map(&:name).include?(data[:ref])
-              git.checkout('refs/tags/'+data[:ref])
+              git.checkout("refs/tags/#{data[:ref]}")
             elsif data[:ref].match(/^[a-zA-Z0-9]{40}$/) && git.exists?(data[:ref])
               git.checkout(data[:ref])
             else
@@ -34,7 +34,7 @@ module Fulmar
             end
 
             # Pull
-            shell = Fulmar::Infrastructure::Service::ShellService.new @config[:local_path]+'/'+data[:path]
+            shell = Fulmar::Infrastructure::Service::ShellService.new "#{@config[:local_path]}/#{data[:path]}"
             unless shell.run 'git pull --rebase -q'
               fail "Cannot update repository #{data[:path]}. Please update manually."
             end

data/lib/fulmar/domain/service/helper/common_helper.rb

@@ -17,6 +17,10 @@ module Fulmar
             (@_config_service ||= Fulmar::Domain::Service::ConfigurationService.instance)
           end
 
+          def project
+            full_configuration[:project]
+          end
+
           def composer(command, arguments = Fulmar::Infrastructure::Service::ComposerService::DEFAULT_PARAMS)
             (storage['composer'] ||= Fulmar::Infrastructure::Service::ComposerService.new(local_shell)).execute(command, arguments)
           end
@@ -64,15 +68,15 @@ module Fulmar
           end
 
           def info(text)
-            puts (ENV['TERM'] == 'xterm-256color' ? text.blue : "* Info: #{text}") if verbose
+            puts(ENV['TERM'] == 'xterm-256color' ? text.blue : "* Info: #{text}") if verbose
           end
 
-          def warn(text)
-            STDERR.puts (ENV['TERM'] == 'xterm-256color' ? text.magenta : "* Warning: #{text}")
+          def warning(text)
+            STDERR.puts(ENV['TERM'] == 'xterm-256color' ? text.magenta : "* Warning: #{text}")
           end
 
           def error(text)
-            STDERR.puts (ENV['TERM'] == 'xterm-256color' ? text.light_red : "* Error: #{text}")
+            STDERR.puts(ENV['TERM'] == 'xterm-256color' ? text.light_red : "* Error: #{text}")
           end
         end
       end

data/lib/fulmar/domain/task/base.rake

@@ -18,4 +18,4 @@ end
 
 if configuration.feature?(:vhost) && configuration.any? { |data| !data[:vhost_template].blank? }
   require 'fulmar/domain/task/optional/vhost'
-end
+end

data/lib/fulmar/domain/task/configuration.rake

@@ -0,0 +1,43 @@
+require 'pp'
+
+namespace :test do
+  task :config do
+    require 'fulmar/domain/service/config_test_service'
+    test_service = Fulmar::Domain::Service::ConfigTestService.new(configuration)
+    results = test_service.run
+
+    results.each do |report|
+      case report[:severity]
+      when :warning
+        warning "Warning: #{report[:message]}"
+      when :error
+        error "Error: #{report[:message]}"
+      else
+        info "Notice: #{report[:message]}"
+      end
+    end
+
+    info "Feelin' fine." if results.empty?
+  end
+
+  task :hosts do
+    error_count = 0
+    configuration.each do |env, target, _data|
+      configuration.environment = env
+      configuration.target = target
+
+      next if configuration[:hostname].blank?
+      remote_shell.quiet = true
+      remote_shell.strict = false
+
+      message = "Cannot open remote shell to host '#{configuration[:hostname]}' (#{env}:#{target})"
+
+      begin
+        remote_shell.run 'true' || error(message)
+      rescue
+        error(message)
+      end
+    end
+    info "Feelin' fine." if error_count == 0
+  end
+end

data/lib/fulmar/domain/task/console.rake

@@ -1,7 +1,12 @@
 desc 'Open an interactive terminal within fulmar'
-task :console do
+task :console, [:environment] do |t, args|
   require 'irb'
   require 'irb/completion'
   ARGV.clear
+  if args[:environment] && args[:environment].include?(':')
+    environment, target = args[:environment].split(':')
+    configuration.environment = environment
+    configuration.target = target
+  end
   IRB.start
-end
+end

data/lib/fulmar/domain/task/environment.rake

@@ -2,7 +2,6 @@
 # so that these tasks might be a dependency for other tasks
 
 namespace :environment do
-
   full_configuration[:environments].each_key do |env|
     # Sets the environment to #{env}
     task env do

data/lib/fulmar/domain/task/optional/vhost.rb

@@ -3,8 +3,7 @@ include Fulmar::Domain::Service::Helper::VhostHelper
 
 VHOST_DEFAULT_CONFIG = {
   webserver: 'nginx',
-  sites_enabled_dir: '../sites-enabled',
-
+  sites_enabled_dir: '../sites-enabled'
 }
 
 vhost_count = 0
@@ -14,8 +13,10 @@ namespace :vhost do
   configuration.each do |env, target, data|
     next if data[:vhost_template].blank?
 
+    task_environment = vhost_count > 1 ? ":#{env}" : ''
+
     desc "Create a vhost for #{env}"
-    task (vhost_count > 1 ? "create:#{env}" : 'create') do
+    task "create#{task_environment}" do
       configuration.environment = env
       configuration.target      = target
       configuration.merge(VHOST_DEFAULT_CONFIG)
@@ -36,17 +37,19 @@ namespace :vhost do
       upload config_file_name
       config_remote_path = configuration[:sites_available_dir] + '/' + File.basename(config_file_name)
       remote_shell.run [
-                         "rm -f #{configuration[:sites_enabled_dir]}/#{File.basename(config_file_name)}", # remove any existing link
-                         "ln -s #{config_remote_path} #{configuration[:sites_enabled_dir]}/#{File.basename(config_file_name)}",
-                         "service #{configuration[:webserver]} reload"
-                       ]
+        "rm -f #{configuration[:sites_enabled_dir]}/#{File.basename(config_file_name)}", # remove any existing link
+        "ln -s #{config_remote_path} #{configuration[:sites_enabled_dir]}/#{File.basename(config_file_name)}",
+        "service #{configuration[:webserver]} reload"
+      ]
+
+      FileUtils.rm config_file_name
 
       # recover remote path
       configuration[:remote_path] = remote_path
     end
 
     desc "List existing vhosts for #{env}"
-    task (vhost_count > 1 ? "list:#{env}" : 'list') do
+    task "list#{task_environment}" do
       configuration.environment = env
       configuration.target      = target
       configuration.merge(VHOST_DEFAULT_CONFIG)
@@ -62,16 +65,16 @@ namespace :vhost do
     end
 
     desc "Delete a vhost for #{env}"
-    task (vhost_count > 1 ? "delete:#{env}" : 'delete'), [:name] do |_t, argv|
+    task "delete#{task_environment}", [:name] do |_t, argv|
       configuration.environment = env
       configuration.target      = target
       configuration.merge(VHOST_DEFAULT_CONFIG)
 
       remote_shell.run [
-                         "rm auto_vhost_#{argv[:name]}.conf",
-                         "rm #{configuration[:sites_enabled_dir]}/auto_vhost_#{argv[:name]}.conf",
-                         "service #{configuration[:webserver] || 'nginx'} reload"
-                       ]
+        "rm auto_vhost_#{argv[:name]}.conf",
+        "rm #{configuration[:sites_enabled_dir]}/auto_vhost_#{argv[:name]}.conf",
+        "service #{configuration[:webserver] || 'nginx'} reload"
+      ]
     end
   end
 end

data/lib/fulmar/domain/task/versions.rake

@@ -14,31 +14,40 @@ namespace :versions do
   unless @versioned_servers.empty?
 
     @versioned_servers.each_key do |env|
-      target_count = @versioned_servers.keys.reduce(0) { |sum, target| target.split(':').first == env.split(':').first ? sum + 1 : sum }
-      namespace :list do
+      target_count = @versioned_servers.keys.reduce(0) { |a, e| e.split(':').first == env.split(':').first ? a + 1 : a }
+
+      task_environment = (target_count > 1 ? env : env.split(':').first)
 
+      namespace :list do
         # Count of there are multiple targets within the environment
         # if not, we can omit the target name in the task and shorten it a bit
-        # This should work in most cases.
+        # This should apply for almost all cases.
 
         desc "List available versions for environment/target \"#{env}\""
-        task (target_count > 1 ? env : env.split(':').first) do
+        task task_environment do
           configuration.environment = env.split(':').first
           configuration.target = env.split(':').last
           file_sync.list_releases(false).each { |item| puts item }
         end
       end
 
-
       namespace :clean do
         desc "Delete obsolete versions for target \"#{env}\""
-        task (target_count > 1 ? env : env.split(':').first) do
+        task task_environment do
           configuration.environment = env.split(':').first
           configuration.target = env.split(':').last
           file_sync.cleanup
         end
       end
-    end
 
+      namespace :revert do
+        desc "Revert to the previous version for \"#{env}\""
+        task task_environment do
+          configuration.environment = env.split(':').first
+          configuration.target = env.split(':').last
+          error 'Cannot revert to previous version.' unless file_sync.revert
+        end
+      end
+    end
   end
 end

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

@@ -73,12 +73,14 @@ module Fulmar
           end
 
           def dump(filename = backup_filename)
+            filename = "#{@config[:remote_path]}/#{filename}" unless filename[0, 1] == '/'
+
             diffable = @config[:maria][:diffable_dump] ? '--skip-comments --skip-extended-insert ' : ''
 
             @shell.run "mysqldump -h #{@config[:maria][:host]} -u #{@config[:maria][:user]} --password='#{@config[:maria][:password]}' " \
                        "#{@config[:maria][:database]} --single-transaction #{diffable}-r \"#{filename}\""
 
-            @config[:remote_path] + '/' + filename
+            filename
           end
 
           def load_dump(dump_file, database = @config[:maria][:database])
@@ -98,6 +100,25 @@ module Fulmar
             end
           end
 
+          def clear
+            clear_statements = <<-EOD.gsub(/^\s+\|/, '')
+              |SET FOREIGN_KEY_CHECKS = 0;
+              |SET GROUP_CONCAT_MAX_LEN=32768;
+              |SET @tables = NULL;
+              |SELECT GROUP_CONCAT('`', table_name, '`') INTO @tables
+              |FROM information_schema.tables
+              |WHERE table_schema = (SELECT DATABASE());
+              |SELECT IFNULL(@tables,'dummy') INTO @tables;
+              |
+              |SET @tables = CONCAT('DROP TABLE IF EXISTS ', @tables);
+              |PREPARE stmt FROM @tables;
+              |EXECUTE stmt;
+              |DEALLOCATE PREPARE stmt;
+              |SET FOREIGN_KEY_CHECKS = 1;
+            EOD
+            @client.query clear_statements
+          end
+
           protected
 
           def try_connect(options, i)

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

@@ -115,9 +115,11 @@ module Fulmar
           #
           # @params release [String] the release folder or time string (which is found in the output list)
           # @return [true, false] success
-          def revert(release)
+          def revert(release = last_release)
             prepare unless @prepared
 
+            return false if release.nil?
+
             # 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)
@@ -128,6 +130,13 @@ module Fulmar
 
           protected
 
+          def last_release
+            list = list_releases
+            current = current_release
+            current_index = list.index(current)
+            (current_index.nil? || current_index == 0) ? nil : list[current_index - 1]
+          end
+
           # Creates all necessary paths on the remote machine
           # @return [true, false] success
           def create_paths

data/lib/fulmar/version.rb

@@ -1,4 +1,4 @@
 # Provides a global version number
 module Fulmar
-  VERSION = '1.5.2'
+  VERSION = '1.6.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fulmar
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Jonas Siegl
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-20 00:00:00.000000000 Z
+date: 2015-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -139,6 +139,7 @@ files:
 - fulmar.gemspec
 - lib/fulmar/domain/service/application_service.rb
 - lib/fulmar/domain/service/config_rendering_service.rb
+- lib/fulmar/domain/service/config_test_service.rb
 - lib/fulmar/domain/service/configuration_service.rb
 - lib/fulmar/domain/service/dependency_service.rb
 - lib/fulmar/domain/service/file_sync_service.rb
@@ -149,6 +150,7 @@ files:
 - lib/fulmar/domain/service/helper/vhost_helper.rb
 - lib/fulmar/domain/service/initialization_service.rb
 - lib/fulmar/domain/task/base.rake
+- lib/fulmar/domain/task/configuration.rake
 - lib/fulmar/domain/task/console.rake
 - lib/fulmar/domain/task/database_sync.rake
 - lib/fulmar/domain/task/environment.rake