diff --git a/app/controllers/hosts_controller.rb b/app/controllers/hosts_controller.rb
index c4eab29..9bd7605 100644
--- a/app/controllers/hosts_controller.rb
+++ b/app/controllers/hosts_controller.rb
@@ -1,94 +1,103 @@
 class HostsController < ApplicationController
   before_action :fetch_host, only: [:show, :edit, :update, :destroy, :submit_config,
-                                    :revoke, :restore]
+                                    :revoke, :restore, :run_restore]
 
   # GET /hosts/new
   def new
     @host = Host.new
   end
 
   # POST /hosts
   def create
     @host = Host.new(fetch_params)
     if @host.save
       flash[:success] = 'Host created successfully'
       current_user.hosts << @host
       redirect_to host_path @host
     else
       flash[:error] = 'Host was not created'
       render :new
     end
   end
 
   # GET /hosts/1
   def show; end
 
   # GET /hosts/1/edit
   def edit; end
 
   # PATCH /hosts/1
   def update
     updates = fetch_params.slice(:port, :password)
     if updates.present? && @host.update_attributes(updates)
       @host.recalculate
       flash[:success] = 'Host updated successfully. You must update your file deamon accordingly.'
       redirect_to host_path @host
     else
       render :edit
     end
   end
 
   # DELETE /hosts/1
   def destroy
     if @host.destroy
       flash[:success] = 'Host destroyed successfully'
     else
       flash[:error] = 'Host not destroyed'
     end
 
     redirect_to root_path
   end
 
   # POST /hosts/1/submit_config
   def submit_config
     if @host.dispatch_to_bacula
       flash[:success] = 'Host configuration sent to Bacula successfully'
     else
       flash[:error] = 'Something went wrong, try again later'
     end
 
     redirect_to host_path(@host)
   end
 
   # DELETE /hosts/1/revoke
   def revoke
     if @host.remove_from_bacula
       flash[:success] = 'Host configuration removed from Bacula successfully'
     else
       flash[:error] = 'Something went wrong, try again later'
     end
 
     redirect_to root_path
   end
 
-  # POST /hosts/1/restore
+  # GET /hosts/1/restore
   def restore
-    if @host.restore
-      flash[:success] = 'Restore job issued successfully, files will be soon available in your restore location'
+    if !@host.restorable?
+      flash[:error] = "Can not issue a restore for this client"
+      redirect_to @host.client.present? ? client_path(@host.client) : root_path
+    end
+  end
+
+  # POST /hosts/1/run_estore
+  def run_restore
+    location = params[:restore_location]
+    if location.present? && @host.restore(location)
+      flash[:success] = "Restore job issued successfully, files will be soon available in #{location}"
     else
       flash[:error] = 'Something went wrong, try again later'
     end
 
     redirect_to client_path(@host.client)
   end
 
   private
 
   def fetch_host
     @host = current_user.hosts.includes(job_templates: [:fileset, :schedule]).find(params[:id])
   end
 
   def fetch_params
     params.require(:host).permit(:fqdn, :port, :password)
   end
 end
diff --git a/app/models/host.rb b/app/models/host.rb
index dad6f63..4f9353b 100644
--- a/app/models/host.rb
+++ b/app/models/host.rb
@@ -1,199 +1,208 @@
 class Host < ActiveRecord::Base
   establish_connection Baas::settings[:local_db]
 
   FILE_RETENTION_DAYS = 60
   JOB_RETENTION_DAYS = 180
   CATALOG = 'MyCatalog'
   AUTOPRUNE = 1
 
   STATUSES = {
     pending: 0,
     configured: 1,
     dispatched: 2,
     deployed: 3,
     updated: 4,
     redispatched: 5,
     for_removal: 6
   }
 
   has_many :ownerships
   has_many :users, through: :ownerships, inverse_of: :hosts
 
   belongs_to :client, class_name: :Client, foreign_key: :name, primary_key: :name
 
   has_many :filesets, dependent: :destroy
   has_many :job_templates, dependent: :destroy
   has_many :schedules, dependent: :destroy
 
   validates :file_retention, :job_retention,
     :port, :password, presence: true
   validates :port, numericality: true
 
   validates :fqdn, presence: true, uniqueness: true
 
   validate :fqdn_format
 
   scope :not_baculized, -> {
     joins("left join Client on Client.Name = hosts.name").where(Client: { Name: nil })
   }
 
   before_validation :set_retention, :unset_baculized, :sanitize_name
 
   state_machine :status, initial: :pending do
     STATUSES.each do |status_name, value|
       state status_name, value: value
     end
 
     after_transition [:dispatched, :redispatched, :configured, :updated] => :deployed do |host|
       host.job_templates.enabled.
         update_all(baculized: true, baculized_at: Time.now, updated_at: Time.now)
     end
 
     event :add_configuration do
       transition [:pending, :dispatched] => :configured
     end
 
     event :dispatch do
       transition :configured => :dispatched
     end
 
     event :redispatch do
       transition :updated => :redispatched
     end
 
     event :set_deployed do
       transition [:dispatched, :redispatched, :configured, :updated] => :deployed
     end
 
     event :change_deployed_config do
       transition [:deployed, :redispatched, :for_removal] => :updated
     end
 
     event :mark_for_removal do
       transition [:dispatched, :deployed, :updated, :redispatched] => :for_removal
     end
 
     event :disable do
       transition all => :pending
     end
   end
 
   def baculize_config
     templates = job_templates.enabled.includes(:fileset, :schedule)
 
     result = [self] + templates.map {|x| [x, x.fileset, x.schedule] }.flatten.compact.uniq
     result.map(&:to_bacula_config_array)
   end
 
   def to_bacula_config_array
     [
       "Client {",
       "  Name = #{name}",
       "  Address = #{fqdn}",
       "  FDPort = #{port}",
       "  Catalog = #{CATALOG}",
       "  Password = \"#{password}\"",
       "  File Retention = #{file_retention} days",
       "  Job Retention = #{job_retention} days",
       "  AutoPrune = yes",
       "}"
     ]
   end
 
   def auto_prune_human
     AUTOPRUNE == 1 ? 'yes' : 'no'
   end
 
   # Uploads the host's config to bacula
   # Reloads bacula server
   #
   # It updates the host's status accordingly
   def dispatch_to_bacula
     return false if not needs_dispatch?
     bacula_handler.deploy_config
   end
 
   # Removes a Host from bacula configuration.
   # Reloads bacula server
   #
   # If all go well it changes the host's status and returns true
   def remove_from_bacula
     return false unless needs_revoke?
     bacula_handler.undeploy_config
   end
 
   # Restores a host's backup to a preselected location
-  def restore
-    return false if client.jobs.backup_type.empty?
-    bacula_handler.restore
+  #
+  # @param location[String] the desired restore location
+  def restore(location)
+    return false if not restorable?
+    bacula_handler.restore(location)
   end
 
   # Runs the given backup job ASAP
   def backup_now(job_name)
     bacula_handler.backup_now(job_name)
   end
 
   def needs_dispatch?
     verified? && (can_dispatch? || can_redispatch?)
   end
 
   def needs_revoke?
     for_removal?
   end
 
   # Handles the host's job changes by updating the host's status
   def recalculate
     if job_templates(true).enabled.any?
       add_configuration || change_deployed_config
     else
       mark_for_removal || disable
     end
   end
 
   def display_message
     if !verified?
       { message: 'Your host needs to be verified by an admin', severity: :alert }
     elsif pending?
       { message: 'client not configured yet', severity: :alert }
     elsif configured? || dispatched?
       { message: 'client not deployed to Bacula', severity: :alert }
     elsif updated? || redispatched?
       { message: 'client configuration changed, deploy needed', severity: :alert }
     elsif for_removal?
       { message: 'pending client configuration withdraw', severity: :error }
     elsif inactive?
       { message: 'client disabled', severity: :alert }
     end
   end
 
+  # Determines if a host can issue a restore job.
+  #
+  # @returns [Boolean] true if the host's client can issue a restore job
+  def restorable?
+    client.present? && client.is_backed_up?
+  end
+
   private
 
   # automatic setters
 
   def sanitize_name
     self.name = fqdn
   end
 
   def set_retention
     self.file_retention = FILE_RETENTION_DAYS
     self.job_retention = JOB_RETENTION_DAYS
   end
 
   def unset_baculized
     self.baculized = false if new_record?
     true
   end
 
   # validation
 
   def fqdn_format
     regex = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$)/
     unless fqdn =~ regex
       self.errors.add(:fqdn)
     end
   end
 
   def bacula_handler
     BaculaHandler.new(self)
   end
 end
diff --git a/app/views/clients/_client_details.html.erb b/app/views/clients/_client_details.html.erb
index 8057c98..da00b57 100644
--- a/app/views/clients/_client_details.html.erb
+++ b/app/views/clients/_client_details.html.erb
@@ -1,54 +1,50 @@
 <div class="col-xs-4">
   <div class="table-responsive">
     <table class="table table-striped table-bordered table-condensed ">
       <tr>
         <td>Name</td>
         <td><%= @client.name %></td>
       </tr>
       <tr>
         <td>Uname</td>
         <td><%= @client.uname %></td>
       </tr>
       <tr>
         <td>Active Jobs</td>
         <td><%= @client.running_jobs %></td>
       </tr>
       <tr>
         <td>Last Backup</td>
         <td>
           <%= @client.last_job_date_formatted %>
         </td>
       </tr>
       <tr>
         <td>File Retention</td>
         <td><%= @client.file_retention_days %> days</td>
       </tr>
       <tr>
         <td>Job Retention</td>
         <td><%= @client.job_retention_days %> days</td>
       </tr>
       <tr>
         <td>Total Space Used</td>
         <td><%= number_to_human_size @client.backup_jobs_size %></td>
       </tr>
       <tr>
         <td>Files count</td>
         <td><%= number_by_magnitude(@client.files_count) %></td>
       </tr>
       <tr>
         <td>Auto Prune</td>
         <td><%= @client.auto_prune_human %></td>
       </tr>
     </table>
   </div>
   <div>
     <% if @client.is_backed_up? %>
       <%= link_to 'Restore Files', restore_host_path(@client.host),
-        class: "btn btn-warning", role: "button", method: :post,
-        data: {
-          confirm: "This will restore all your files at the most recent backup (#{@client.last_job_date_formatted})"
-        }
-        %>
+        class: "btn btn-warning", role: "button" %>
     <% end %>
   </div>
 </div>
diff --git a/app/views/hosts/restore.html.erb b/app/views/hosts/restore.html.erb
new file mode 100644
index 0000000..ae62b45
--- /dev/null
+++ b/app/views/hosts/restore.html.erb
@@ -0,0 +1,26 @@
+<h1>Restore files for "<%= @host.name %>"</h1>
+
+<div class="row">
+  <div class="col-xs-6">
+    <% if @host.restorable? %>
+      <% restore_point = @host.client.last_job_date_formatted %>
+      <div class="container graybox">
+        <%= bootstrap_form_tag(url: run_restore_host_path(@host), layout: :horizontal,
+                               label_col: 'col-xs-4', control_col: 'col-xs-8' ) do |f| %>
+          <%= f.text_field(:restore_point, value: restore_point, disabled: true) %>
+          <%= f.text_field(:restore_location) %>
+          </br>
+          <%= f.submit 'Restore Files', class: 'btn btn-warning right',
+              data: { confirm: "This will restore all your files at the most recent backup (#{restore_point})" }
+          %>
+        <% end %>
+      </div>
+    <% else %>
+      <div class="alert alert-warning">
+        <p>Can not issue a restore for this host. It is either not deployed or has no successful backups</p>
+      </div>
+    <% end %>
+
+    <%= link_to 'Cancel', client_path(@host.client), class: 'btn btn-danger', role: 'button' %>
+  </div>
+</div>
diff --git a/config/routes.rb b/config/routes.rb
index dad4797..b2d7f87 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -1,23 +1,24 @@
 Rails.application.routes.draw do
   resources :clients, only: [:index, :show]
 
   resources :hosts, only: [:new, :create, :show, :edit, :update, :destroy] do
     member do
       post :submit_config
-      post :restore
+      get :restore
+      post :run_restore
       delete :revoke
     end
 
     resources :jobs, only: [:new, :create, :show, :edit, :update, :destroy] do
       member do
         patch :toggle_enable
         post :backup_now
       end
     end
 
     resources :filesets, only: [:show, :new, :create, :destroy]
     resources :schedules, only: [:show, :new, :edit, :create, :update, :destroy]
   end
 
   root 'clients#index'
 end
diff --git a/lib/bacula_handler.rb b/lib/bacula_handler.rb
index 8d34fa5..40aa651 100644
--- a/lib/bacula_handler.rb
+++ b/lib/bacula_handler.rb
@@ -1,129 +1,131 @@
 class BaculaHandler
   require 'net/scp'
 
   attr_accessor :host, :tempfile
 
   # Initializes a BaculaHandler instance.
   #
   # Sets `host` and `template` attributes.
   #
   # @param host[Host] A the host instance the the bacula handler will act upon
   def initialize(host)
     @host = host
     @tempfile = get_config_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
       host.set_deployed
     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
   #
-  # @params job_name[String] the job's name
+  # @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}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   # Schedules an immediate restore to the bacula director for the given host.
-  def restore
-    command = "echo \"restore client=\\\"#{host.name}\\\" where=\\\"/tmp/bacula-restore\\\" select current all done yes\" | #{bconsole}"
+  #
+  # @param location[String] the desired restore location
+  def restore(location="/tmp/bacula-restore")
+    command = "echo \"restore client=\\\"#{host.name}\\\" where=\\\"#{location}\\\" select current all done yes\" | #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   private
 
   def get_config_file
     file = Tempfile.new(host.name)
     file.chmod(0666)
     file.write host.baculize_config.join("\n")
     file.close
     file
   end
 
   def send_config
     begin
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         tempfile.path,
         ssh_settings[:path] + 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 log(msg)
     Rails.logger.warn("[BaculaHandler]: #{msg}")
   end
 end
diff --git a/spec/routing/host_routing_spec.rb b/spec/routing/host_routing_spec.rb
index 3d02b1c..60de023 100644
--- a/spec/routing/host_routing_spec.rb
+++ b/spec/routing/host_routing_spec.rb
@@ -1,42 +1,47 @@
 require 'spec_helper'
 
 describe HostsController do
   it 'routes GET /hosts/new' do
     expect(get('/hosts/new')).to route_to(controller: 'hosts', action: 'new')
   end
 
   it 'routes POST /hosts' do
     expect(post('/hosts')).to route_to(controller: 'hosts', action: 'create')
   end
 
   it 'routes GET /hosts/1' do
     expect(get('/hosts/1')).to route_to(controller: 'hosts', action: 'show', id: '1')
   end
 
   it 'routes GET /hosts/1/edit' do
     expect(get('/hosts/1/edit')).to route_to(controller: 'hosts', action: 'edit', id: '1')
   end
 
   it 'routes PUT /hosts/1' do
     expect(put('/hosts/1')).to route_to(controller: 'hosts', action: 'update', id: '1')
   end
 
   it 'routes DELETE /hosts/1' do
     expect(delete('/hosts/1')).to route_to(controller: 'hosts', action: 'destroy', id: '1')
   end
 
   it 'routes POST /hosts/1/submit_config' do
     expect(post('/hosts/1/submit_config')).
       to route_to(controller: 'hosts', action: 'submit_config', id: '1')
   end
 
   it 'routes DELETE /hosts/1/revoke' do
     expect(delete('/hosts/1/revoke')).
       to route_to(controller: 'hosts', action: 'revoke', id: '1')
   end
 
   it 'routes POST /hosts/1/restore' do
-    expect(post('/hosts/1/restore')).
+    expect(post('/hosts/1/run_restore')).
+      to route_to(controller: 'hosts', action: 'run_restore', id: '1')
+  end
+
+  it 'routes GET /hosts/1/restore' do
+    expect(get('/hosts/1/restore')).
       to route_to(controller: 'hosts', action: 'restore', id: '1')
   end
 end