diff --git a/app/views/clients/_job.html.erb b/app/views/clients/_job.html.erb
index 567ed70..48f8c1d 100644
--- a/app/views/clients/_job.html.erb
+++ b/app/views/clients/_job.html.erb
@@ -1,19 +1,19 @@
 <tr>
   <td><%= job.name %></td>
   <td><%= job.job_type %></td>
   <td>
     <%= link_to job.fileset.name, '#',
       data: { toggle: 'modal', target: ".js-fileset-#{job.fileset_id}:first"} %>
   </td>
   <td>
     <%= link_to job.schedule_human, '#',
       data: { toggle: 'modal', target: ".js-schedule-#{job.schedule_id}:first"} %>
   </td>
   <td><%= I18n.l(job.created_at, format: :long) %></td>
   <td>
     <% if job.enabled? && job.baculized? && job.backup? %>
-      <%= link_to 'Backup Now', backup_now_host_job_path(job.host, job),
+      <%= link_to 'Full Backup Now', backup_now_host_job_path(job.host, job),
                   method: :post, class: "btn btn-success", role: "button" %>
     <% end %>
   </td>
 </tr>
diff --git a/lib/bacula_handler.rb b/lib/bacula_handler.rb
index 5327c2b..c111566 100644
--- a/lib/bacula_handler.rb
+++ b/lib/bacula_handler.rb
@@ -1,201 +1,201 @@
 class BaculaHandler
   require 'net/scp'
 
   attr_accessor :host, :templates, :client, :jobs, :schedules, :filesets
 
   # Initializes a BaculaHandler instance.
   #
   # Sets `host` and `templates` attributes.
   # Sets the temporal files that contain the client's configuration
   #
   # @param host[Host] A the host instance the the bacula handler will act upon
   def initialize(host)
     @host = host
     @templates = host.job_templates.includes(:fileset, :schedule)
 
     @client = get_client_file
     @jobs = get_jobs_file
     @schedules = get_schedules_file
     @filesets = get_filesets_file
   end
 
   # Deploys the host's config to the bacula director by
   #
   # * uploading the configuration
   # * reloadind the bacula director
   #
   # Updates the host's status accordingly
   #
   # @return [Boolean] false if something went wrong
   def deploy_config
     return false unless send_config
     if reload_bacula
       if host.bacula_ready?
         host.set_deployed
       else
         host.set_inactive
       end
     else
       host.dispatch || host.redispatch
     end
   end
 
   # Removes the host's configuration from the bacula director by
   #
   # * removing the host's configuration files
   # * reloading the bacula director
   #
   # Updates the host's status accordingly
   #
   # @return [Boolean] false if something went wrong
   def undeploy_config
     return false unless remove_config
     host.disable if reload_bacula
   end
 
   # Schedules an immediate backup to the bacula director for the given host and job
   #
   # @param job_name[String] the job's name
   def backup_now(job_name)
     job = host.job_templates.enabled.find_by(name: job_name)
     return false unless job
-    command = "echo \"run job=\\\"#{job.name_for_config}\\\" yes\" | #{bconsole}"
+    command = "echo \"run level=full job=\\\"#{job.name_for_config}\\\" yes\" | #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   # Schedules an immediate restore to the bacula director for the given host.
   #
   # @param job_ids[Array] contains the jobs that compose the restore for this fileset
   # @param file_set_name[String] the fileset that is going to be restored
   # @param restore_point[String] the restore datetime
   # @param location[String] the desired restore location
   def restore(job_ids, file_set_name, restore_point, location="/tmp/bacula-restore")
     command = "echo \"restore client=\\\"#{host.name}\\\" "
     command << "jobid=#{job_ids.join(',')} "
     command << "where=\\\"#{location}\\\" "
     command << "fileset=\\\"#{file_set_name}\\\" "
     if restore_point
       command << "before=\\\"#{restore_point}\\\" "
     else
       command << "current "
     end
     command << "select all done yes\" "
     command << "| #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   private
 
   def get_client_file
     file = a_tmpfile
     file.write host.to_bacula_config_array.join("\n")
     file.close
     file
   end
 
   def get_jobs_file
     file = a_tmpfile
     file.write templates.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def get_schedules_file
     file = a_tmpfile
     file.write templates.map(&:schedule).uniq.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def get_filesets_file
     file = a_tmpfile
     file.write templates.map(&:fileset).uniq.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def send_config
     begin
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         client.path,
         ssh_settings[:path] + 'clients/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         jobs.path,
         ssh_settings[:path] + 'jobs/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         schedules.path,
         ssh_settings[:path] + 'schedules/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         filesets.path,
         ssh_settings[:path] + 'filesets/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
     rescue
       return false
     end
     true
   end
 
   def remove_config
     begin
       Net::SSH.start(ssh_settings[:host], ssh_settings[:username],
                      keys: ssh_settings[:key_file]) do |ssh|
         ssh.exec!("rm #{ssh_settings[:path]}*/#{host.name}.conf")
       end
     rescue
       return false
     end
     true
   end
 
   def reload_bacula
     command = "echo \"reload quit\" | #{bconsole}"
     exec_with_timeout(command, 2)
   end
 
   def exec_with_timeout(command, sec)
     begin
       Timeout::timeout(sec) do
         `#{command}`
       end
     rescue
       return false
     end
     true
   end
 
   def bconsole
     "bconsole -c #{Rails.root}/config/bconsole.conf"
   end
 
   def ssh_settings
     @ssh_settings ||= YAML::load(File.open("#{Rails.root}/config/ssh.yml"))[Rails.env].
       symbolize_keys
   end
 
   def a_tmpfile
     file = Tempfile.new(host.name)
     file.chmod(0666)
     file
   end
 
   def log(msg)
     Rails.logger.warn("[BaculaHandler]: #{msg}")
   end
 end