From 1f35824317e7b875f42f49e24dfdbac866efa49b Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@hexad.dk>
Date: Thu, 30 Jul 2015 14:31:27 +0200
Subject: [PATCH] Converted to REST based API, with a wrapper layer for
 control.cgi so the current UI still works.

---
 .../HttpServerConnection.cs                   | 111 +-
 Duplicati/Server/Duplicati.Server.csproj      |  27 +-
 Duplicati/Server/Program.cs                   |   2 +-
 .../Server/WebServer/AuthenticationHandler.cs |   4 +-
 Duplicati/Server/WebServer/BodyWriter.cs      |  27 +-
 Duplicati/Server/WebServer/ControlHandler.cs  | 979 +++---------------
 .../ControlMethods/AddOrUpdateBackup.cs       | 167 ---
 .../WebServer/ControlMethods/DeleteBackup.cs  | 122 ---
 .../WebServer/ControlMethods/GetBackup.cs     |  53 -
 .../ControlMethods/GetFolderContents.cs       | 116 ---
 .../ControlMethods/ListFolderAsNodes.cs       |  86 --
 .../WebServer/ControlMethods/ReadLogData.cs   |  78 --
 .../ControlMethods/SearchBackupFiles.cs       |  65 --
 Duplicati/Server/WebServer/RESTHandler.cs     |   2 +-
 .../WebServer/RESTMethods/Acknowledgements.cs |  25 +
 .../Server/WebServer/RESTMethods/Backup.cs    |  25 +
 .../WebServer/RESTMethods/BackupDefaults.cs   |  27 +
 .../Server/WebServer/RESTMethods/Backups.cs   |   8 +-
 .../Server/WebServer/RESTMethods/BugReport.cs |  25 +
 .../Server/WebServer/RESTMethods/Changelog.cs |  25 +
 .../WebServer/RESTMethods/Filesystem.cs       |  25 +
 .../WebServer/RESTMethods/IRESTMethod.cs      |   2 +-
 .../WebServer/RESTMethods/Localizations.cs    |  25 +
 .../Server/WebServer/RESTMethods/LogData.cs   |  25 +
 .../WebServer/RESTMethods/Notification.cs     |  25 +
 .../WebServer/RESTMethods/Notifications.cs    |  25 +
 .../WebServer/RESTMethods/ProgressState.cs    |   2 +-
 .../WebServer/RESTMethods/RemoteOperation.cs  |  25 +
 .../WebServer/RESTMethods/RequestInfo.cs      |   4 +-
 .../WebServer/RESTMethods/ServerSetting.cs    |  25 +
 .../WebServer/RESTMethods/ServerSettings.cs   |   4 +-
 .../WebServer/RESTMethods/ServerState.cs      |   2 +-
 .../Server/WebServer/RESTMethods/Tags.cs      |  24 +
 .../Server/WebServer/RESTMethods/Task.cs      |  24 +
 .../Server/WebServer/RESTMethods/Tasks.cs     |  24 +
 .../WebServer/RESTMethods/UISettings.cs       |  25 +
 .../Server/WebServer/RESTMethods/Updates.cs   |  25 +
 .../Server/WebServer/RESTMethods/WebModule.cs |  28 +
 .../WebServer/RESTMethods/WebModules.cs       |  28 +
 39 files changed, 717 insertions(+), 1624 deletions(-)
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/AddOrUpdateBackup.cs
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/DeleteBackup.cs
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/GetBackup.cs
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/GetFolderContents.cs
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/ListFolderAsNodes.cs
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/ReadLogData.cs
 delete mode 100644 Duplicati/Server/WebServer/ControlMethods/SearchBackupFiles.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Acknowledgements.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Backup.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/BackupDefaults.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/BugReport.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Changelog.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Filesystem.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Localizations.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/LogData.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Notification.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Notifications.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/RemoteOperation.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/ServerSetting.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Tags.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Task.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Tasks.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/UISettings.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/Updates.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/WebModule.cs
 create mode 100644 Duplicati/Server/WebServer/RESTMethods/WebModules.cs

diff --git a/Duplicati/GUI/Duplicati.GUI.TrayIcon/HttpServerConnection.cs b/Duplicati/GUI/Duplicati.GUI.TrayIcon/HttpServerConnection.cs
index 72d490164..9ff96d119 100644
--- a/Duplicati/GUI/Duplicati.GUI.TrayIcon/HttpServerConnection.cs
+++ b/Duplicati/GUI/Duplicati.GUI.TrayIcon/HttpServerConnection.cs
@@ -9,16 +9,32 @@ namespace Duplicati.GUI.TrayIcon
 {
     public class HttpServerConnection : IDisposable
     {
-        private const string CONTROL_SCRIPT = "control.cgi";
         private const string LOGIN_SCRIPT = "login.cgi";
         private const string STATUS_WINDOW = "index.html";
-        private const string EDIT_WINDOW = "edit-window.html";
 
         private const string XSRF_COOKIE = "xsrf-token";
         private const string XSRF_HEADER = "X-XSRF-Token";
         private const string AUTH_COOKIE = "session-auth";
-        
-        private Uri m_controlUri;
+
+        private class BackgroundRequest
+        {
+            public string Method;
+            public string Endpoint;
+            public Dictionary<string, string> Query;
+
+            public BackgroundRequest() 
+            {
+            }
+
+            public BackgroundRequest(string method, string endpoint, Dictionary<string, string> query)
+            {
+                this.Method = method;
+                this.Endpoint = endpoint;
+                this.Query = query;
+            }
+        }
+
+        private string m_apiUri;
         private string m_baseUri;
         private string m_password;
         private bool m_saltedpassword;
@@ -46,22 +62,22 @@ namespace Duplicati.GUI.TrayIcon
         public IServerStatus Status { get { return m_status; } }
 
         private object m_lock = new object();
-        private Queue<Dictionary<string, string>> m_workQueue = new Queue<Dictionary<string,string>>();
+        private Queue<BackgroundRequest> m_workQueue = new Queue<BackgroundRequest>();
 
         public HttpServerConnection(Uri server, string password, bool saltedpassword)
         {
             m_baseUri = server.ToString();
             if (!m_baseUri.EndsWith("/"))
                 m_baseUri += "/";
-            
+
+            m_apiUri = m_baseUri + "api/v1";
+
             m_firstNotificationTime = DateTime.Now;
 
-            m_controlUri = new Uri(m_baseUri + CONTROL_SCRIPT);
             m_password = password;
             m_saltedpassword = saltedpassword;
 
             m_updateRequest = new Dictionary<string, string>();
-            m_updateRequest["action"] = "get-current-state";
             m_updateRequest["longpoll"] = "false";
             m_updateRequest["lasteventid"] = "0";
 
@@ -85,7 +101,7 @@ namespace Duplicati.GUI.TrayIcon
 
         private void UpdateStatus()
         {
-            m_status = PerformRequest<IServerStatus>(m_updateRequest);
+            m_status = PerformRequest<IServerStatus>("GET", "/serverstate", m_updateRequest);
             m_updateRequest["lasteventid"] = m_status.LastEventID.ToString();
 
             if (OnStatusUpdated != null)
@@ -101,9 +117,7 @@ namespace Duplicati.GUI.TrayIcon
         private void UpdateNotifications()
         {
             var req = new Dictionary<string, string>();
-            req["action"] = "get-notifications";
-
-            var notifications = PerformRequest<INotification[]>(req);
+            var notifications = PerformRequest<INotification[]>("GET", "/notifications", req);
             if (notifications != null)
             {
                 foreach(var n in notifications.Where(x => x.Timestamp > m_firstNotificationTime))
@@ -137,7 +151,7 @@ namespace Duplicati.GUI.TrayIcon
             {
                 try
                 {
-                    Dictionary<string, string> req;
+                    BackgroundRequest req;
                     bool any = false;
                     do
                     {
@@ -153,7 +167,7 @@ namespace Duplicati.GUI.TrayIcon
                         if (req != null)
                         {
                             any = true;
-                            PerformRequest<string>(req);
+                            PerformRequest<string>(req.Method, req.Endpoint, req.Query);
                         }
                     
                     } while (req != null);
@@ -267,7 +281,7 @@ namespace Duplicati.GUI.TrayIcon
 
         }
 
-        private T PerformRequest<T>(Dictionary<string, string> queryparams)
+        private T PerformRequest<T>(string method, string urlfragment, Dictionary<string, string> queryparams)
         {
             var hasTriedXSRF = false;
             var hasTriedPassword = false;
@@ -276,7 +290,7 @@ namespace Duplicati.GUI.TrayIcon
             {
                 try
                 {
-                    return PerformRequestInternal<T>(queryparams);
+                    return PerformRequestInternal<T>(method, urlfragment, queryparams);
                 }
                 catch (System.Net.WebException wex)
                 {
@@ -321,17 +335,14 @@ namespace Duplicati.GUI.TrayIcon
             }
         }
 
-        private T PerformRequestInternal<T>(Dictionary<string, string> queryparams)
+        private T PerformRequestInternal<T>(string method, string endpoint, Dictionary<string, string> queryparams)
         {
             queryparams["format"] = "json";
 
             string query = EncodeQueryString(queryparams);
-            byte[] data = ENCODING.GetBytes(query);
 
-            System.Net.HttpWebRequest req = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(m_controlUri);
-            req.Method = "POST";
-            req.ContentLength = data.Length;
-            req.ContentType = "application/x-www-form-urlencoded ; charset=" + ENCODING.BodyName;
+            System.Net.HttpWebRequest req = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(new Uri(m_apiUri + endpoint + '?' + query));
+            req.Method = method;
             req.Headers.Add("Accept-Charset", ENCODING.BodyName);
             if (m_xsrftoken != null)
                 req.Headers.Add(XSRF_HEADER, m_xsrftoken);
@@ -347,11 +358,8 @@ namespace Duplicati.GUI.TrayIcon
             //Wrap it all in async stuff
             Duplicati.Library.Utility.AsyncHttpRequest areq = new Library.Utility.AsyncHttpRequest(req);
 
-            using (System.IO.Stream s = areq.GetRequestStream())
-                s.Write(data, 0, data.Length);
-
             //Assign the timeout, and add a little processing time as well
-            if (queryparams["action"] == "get-current-state" && queryparams.ContainsKey("duration"))
+            if (endpoint.Equals("/serverstate", StringComparison.InvariantCultureIgnoreCase) && queryparams.ContainsKey("duration"))
                 areq.Timeout = (int)(Duplicati.Library.Utility.Timeparser.ParseTimeSpan(queryparams["duration"]) + TimeSpan.FromSeconds(5)).TotalMilliseconds;
 
             using(System.Net.HttpWebResponse r = (System.Net.HttpWebResponse)areq.GetResponse())
@@ -372,67 +380,54 @@ namespace Duplicati.GUI.TrayIcon
 
         }
 
-        private void ExecuteAndNotify(Dictionary<string, string> req)
+        private void ExecuteAndNotify(string method, string urifragment, Dictionary<string, string> req)
         {
             lock (m_lock)
             {
-                m_workQueue.Enqueue(req);
+                m_workQueue.Enqueue(new BackgroundRequest(method, urifragment, req));
                 m_waitLock.Set();
             }
         }
 
         public void Pause(string duration = null)
         {
-            Dictionary<string, string> req = new Dictionary<string, string>();
-            req.Add("action", "send-command");
-            req.Add("command", "pause");
+            var req = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(duration))
                 req.Add("duration", duration);
 
-            ExecuteAndNotify(req);
+            ExecuteAndNotify("POST", "/serverstate/pause", req);
         }
 
         public void Resume()
         {
-            Dictionary<string, string> req = new Dictionary<string, string>();
-            req.Add("action", "send-command");
-            req.Add("command", "resume");
-            ExecuteAndNotify(req);
+            var req = new Dictionary<string, string>();
+            ExecuteAndNotify("POST", "/serverstate/resume", req);
         }
 
-        public void StopBackup()
+        public void StopTask(long id)
         {
-            Dictionary<string, string> req = new Dictionary<string, string>();
-            req.Add("action", "send-command");
-            req.Add("command", "stop");
-            ExecuteAndNotify(req);
+            var req = new Dictionary<string, string>();
+            ExecuteAndNotify("POST", string.Format("/task/{0}/stop", Library.Utility.Uri.UrlPathEncode(id.ToString())), req);
         }
 
-        public void AbortBackup()
+        public void AbortTask(long id)
         {
-            Dictionary<string, string> req = new Dictionary<string, string>();
-            req.Add("action", "send-command");
-            req.Add("command", "abort");
-            ExecuteAndNotify(req);
+            var req = new Dictionary<string, string>();
+            ExecuteAndNotify("POST", string.Format("/task/{0}/abort", Library.Utility.Uri.UrlPathEncode(id.ToString())), req);
         }
 
         public void RunBackup(long id, bool forcefull = false)
         {
-            Dictionary<string, string> req = new Dictionary<string, string>();
-            req.Add("action", "send-command");
-            req.Add("command", "run-backup");
-            req.Add("id", id.ToString());
+            var req = new Dictionary<string, string>();
             if (forcefull)
                 req.Add("full", "true");
-            ExecuteAndNotify(req);
+            ExecuteAndNotify("POST", string.Format("/backup/{0}/start", Library.Utility.Uri.UrlPathEncode(id.ToString())), req);
         }
   
         public void DismissNotification(long id)
         {
-            Dictionary<string, string> req = new Dictionary<string, string>();
-            req.Add("action", "dismiss-notification");
-            req.Add("id", id.ToString());
-            ExecuteAndNotify(req);
+            var req = new Dictionary<string, string>();
+            ExecuteAndNotify("DELETE", string.Format("/notification/{0}", Library.Utility.Uri.UrlPathEncode(id.ToString())), req);
         }
 
         public void Dispose()
@@ -456,11 +451,5 @@ namespace Duplicati.GUI.TrayIcon
                 return m_baseUri + STATUS_WINDOW; 
             }
         }
-
-        public string EditWindowURL
-        {
-            get { return m_baseUri + EDIT_WINDOW; }
-        }
-
     }
 }
diff --git a/Duplicati/Server/Duplicati.Server.csproj b/Duplicati/Server/Duplicati.Server.csproj
index 2d9207ae4..eb4301658 100644
--- a/Duplicati/Server/Duplicati.Server.csproj
+++ b/Duplicati/Server/Duplicati.Server.csproj
@@ -85,13 +85,6 @@
     <Compile Include="WebServer\BodyWriter.cs" />
     <Compile Include="WebServer\IndexHtmlHandler.cs" />
     <Compile Include="WebServer\ControlHandler.cs" />
-    <Compile Include="WebServer\ControlMethods\ListFolderAsNodes.cs" />
-    <Compile Include="WebServer\ControlMethods\ReadLogData.cs" />
-    <Compile Include="WebServer\ControlMethods\SearchBackupFiles.cs" />
-    <Compile Include="WebServer\ControlMethods\GetFolderContents.cs" />
-    <Compile Include="WebServer\ControlMethods\DeleteBackup.cs" />
-    <Compile Include="WebServer\ControlMethods\AddOrUpdateBackup.cs" />
-    <Compile Include="WebServer\ControlMethods\GetBackup.cs" />
     <Compile Include="UpdatePollThread.cs" />
     <Compile Include="LogWriteHandler.cs" />
     <Compile Include="Database\Notification.cs" />
@@ -108,6 +101,25 @@
     <Compile Include="WebServer\RESTMethods\Help.cs" />
     <Compile Include="WebServer\RESTMethods\ServerSettings.cs" />
     <Compile Include="WebServer\RESTMethods\SystemWideSettings.cs" />
+    <Compile Include="WebServer\RESTMethods\Backup.cs" />
+    <Compile Include="WebServer\RESTMethods\Acknowledgements.cs" />
+    <Compile Include="WebServer\RESTMethods\Changelog.cs" />
+    <Compile Include="WebServer\RESTMethods\Tags.cs" />
+    <Compile Include="WebServer\RESTMethods\ServerSetting.cs" />
+    <Compile Include="WebServer\RESTMethods\Localizations.cs" />
+    <Compile Include="WebServer\RESTMethods\Filesystem.cs" />
+    <Compile Include="WebServer\RESTMethods\LogData.cs" />
+    <Compile Include="WebServer\RESTMethods\RemoteOperation.cs" />
+    <Compile Include="WebServer\RESTMethods\BugReport.cs" />
+    <Compile Include="WebServer\RESTMethods\Notifications.cs" />
+    <Compile Include="WebServer\RESTMethods\Notification.cs" />
+    <Compile Include="WebServer\RESTMethods\UISettings.cs" />
+    <Compile Include="WebServer\RESTMethods\BackupDefaults.cs" />
+    <Compile Include="WebServer\RESTMethods\Updates.cs" />
+    <Compile Include="WebServer\RESTMethods\Tasks.cs" />
+    <Compile Include="WebServer\RESTMethods\Task.cs" />
+    <Compile Include="WebServer\RESTMethods\WebModule.cs" />
+    <Compile Include="WebServer\RESTMethods\WebModules.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
@@ -239,6 +251,7 @@
   <ItemGroup>
     <Folder Include="webroot\" />
     <Folder Include="WebServer\RESTMethods\" />
+    <Folder Include="WebServer\ControlMethods\" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Duplicati/Server/Program.cs b/Duplicati/Server/Program.cs
index b51041cca..ae3d22b9d 100644
--- a/Duplicati/Server/Program.cs
+++ b/Duplicati/Server/Program.cs
@@ -417,7 +417,7 @@ namespace Duplicati.Server
                 {
                     PurgeTempFilesTimer = new System.Threading.Timer(purgeTempFilesCallback, null, TimeSpan.FromHours(1), TimeSpan.FromDays(1));
                 } 
-                catch (ArgumentOutOfRangeException aex)
+                catch (ArgumentOutOfRangeException)
                 {
                     //Bugfix for older Mono, slightly more resources used to avoid large values in the period field
                     PurgeTempFilesTimer = new System.Threading.Timer(purgeTempFilesCallback, null, TimeSpan.FromHours(1), TimeSpan.FromHours(1));
diff --git a/Duplicati/Server/WebServer/AuthenticationHandler.cs b/Duplicati/Server/WebServer/AuthenticationHandler.cs
index a60a8cd33..fb317e4a0 100644
--- a/Duplicati/Server/WebServer/AuthenticationHandler.cs
+++ b/Duplicati/Server/WebServer/AuthenticationHandler.cs
@@ -180,7 +180,7 @@ namespace Duplicati.Server.WebServer
                     m_activeNonces.Add(nonce, new Tuple<DateTime, string>(expires, pwd));
 
                     response.Cookies.Add(new HttpServer.ResponseCookie(NONCE_COOKIE_NAME, nonce, expires));
-                    using(var bw = new BodyWriter(response))
+                    using(var bw = new BodyWriter(response, request))
                     {
                         bw.OutputOK(new {
                             Status = "OK",
@@ -229,7 +229,7 @@ namespace Duplicati.Server.WebServer
                         m_activeTokens.Add(token, expires);
                         response.Cookies.Add(new  HttpServer.ResponseCookie(AUTH_COOKIE_NAME, token, expires));
 
-                        using(var bw = new BodyWriter(response))
+                        using(var bw = new BodyWriter(response, request))
                             bw.OutputOK();
 
                         return true;
diff --git a/Duplicati/Server/WebServer/BodyWriter.cs b/Duplicati/Server/WebServer/BodyWriter.cs
index 19f71043f..9757cb5b4 100644
--- a/Duplicati/Server/WebServer/BodyWriter.cs
+++ b/Duplicati/Server/WebServer/BodyWriter.cs
@@ -23,6 +23,7 @@ namespace Duplicati.Server.WebServer
     public class BodyWriter : System.IO.StreamWriter, IDisposable
     {
         private HttpServer.IHttpResponse m_resp;
+        private string m_jsonp;
         private static object SUCCESS_RESPONSE = new { Status = "OK" };
 
         // We override the format provider so all JSON output uses US format
@@ -31,10 +32,16 @@ namespace Duplicati.Server.WebServer
             get { return System.Globalization.CultureInfo.InvariantCulture; }
         }
 
-        public BodyWriter(HttpServer.IHttpResponse resp)
+        public BodyWriter(HttpServer.IHttpResponse resp, HttpServer.IHttpRequest request)
+            : this(resp, request.QueryString["jsonp"].Value)
+        {
+        }
+
+        public BodyWriter(HttpServer.IHttpResponse resp, string jsonp)
             : base(resp.Body,  resp.Encoding)
         {
             m_resp = resp;
+            m_jsonp = jsonp;
         }
 
         protected override void Dispose (bool disposing)
@@ -64,7 +71,23 @@ namespace Duplicati.Server.WebServer
         {
             if (!m_resp.HeadersSent)
                 m_resp.ContentType = "application/json";
-            Serializer.SerializeJson(this, o);
+
+            using(this)
+            {
+                if (!string.IsNullOrEmpty(m_jsonp))
+                {
+                    this.Write(m_jsonp);
+                    this.Write('(');
+                }
+
+                Serializer.SerializeJson(this, o, true);
+
+                if (!string.IsNullOrEmpty(m_jsonp))
+                {
+                    this.Write(')');
+                    this.Flush();
+                }
+            }
         }
     }
 
diff --git a/Duplicati/Server/WebServer/ControlHandler.cs b/Duplicati/Server/WebServer/ControlHandler.cs
index 3b2e740bb..6b207158b 100644
--- a/Duplicati/Server/WebServer/ControlHandler.cs
+++ b/Duplicati/Server/WebServer/ControlHandler.cs
@@ -43,7 +43,6 @@ namespace Duplicati.Server.WebServer
             SUPPORTED_METHODS.Add("get-current-state", GetCurrentState);
             SUPPORTED_METHODS.Add("get-progress-state", GetProgressState);
             SUPPORTED_METHODS.Add("list-application-settings", ListApplicationSettings);
-            SUPPORTED_METHODS.Add("list-options", ListCoreOptions);
             SUPPORTED_METHODS.Add("send-command", SendCommand);
             SUPPORTED_METHODS.Add("get-backup-defaults", GetBackupDefaults);
             SUPPORTED_METHODS.Add("get-folder-contents", GetFolderContents);
@@ -107,7 +106,7 @@ namespace Duplicati.Server.WebServer
                 #else
                 response.ContentType = "text/json";
                 #endif
-                using (BodyWriter bw = new BodyWriter(response))
+                using (BodyWriter bw = new BodyWriter(response, request))
                 {
                     try
                     {
@@ -156,110 +155,78 @@ namespace Duplicati.Server.WebServer
             bw.WriteJsonObject(new { Error = message });
         }
 
-        private List<Dictionary<string, object>> DumpTable(System.Data.IDbCommand cmd, string tablename, string pagingfield, string offset_str, string pagesize_str)
+        private void ReadLogData(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            var result = new List<Dictionary<string, object>>();
+            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
 
-            long pagesize;
-            if (!long.TryParse(pagesize_str, out pagesize))
-                pagesize = 100;
-
-            pagesize = Math.Max(10, Math.Min(500, pagesize));
-
-            cmd.CommandText = "SELECT * FROM \"" + tablename + "\"";
-            long offset = 0;
-            if (!string.IsNullOrWhiteSpace(offset_str) && long.TryParse(offset_str, out offset) && !string.IsNullOrEmpty(pagingfield))
+            if (string.IsNullOrEmpty(input["id"].Value))
+                RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.LogData));
+            else
             {
-                var p = cmd.CreateParameter();
-                p.Value = offset;
-                cmd.Parameters.Add(p);
-
-                cmd.CommandText += " WHERE \"" + pagingfield + "\" < ?";
+                var key = string.Format("{0}/{1}", input["id"].Value, Duplicati.Library.Utility.Utility.ParseBool(input["remotelog"].Value, false) ? "remotelog" : "log");
+                RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
             }
 
-            if (!string.IsNullOrEmpty(pagingfield))
-                cmd.CommandText += " ORDER BY \"" + pagingfield + "\" DESC";
-            cmd.CommandText += " LIMIT " + pagesize.ToString();
-
-            using(var rd = cmd.ExecuteReader())
-            {
-                var names = new List<string>();
-                for(var i = 0; i < rd.FieldCount; i++)
-                    names.Add(rd.GetName(i));
-
-                while (rd.Read())
-                {
-                    var dict = new Dictionary<string, object>();
-                    for(int i = 0; i < names.Count; i++)
-                        dict[names[i]] = rd.GetValue(i);
-
-                    result.Add(dict);                                    
-                }
-            }
-
-            return result;
         }
 
         private void LocateUriDb(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var uri = input["uri"].Value;
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/dbpath", Library.Utility.Uri.UrlPathEncode(input["uri"].Value));
+            RESTHandler.DoProcess(request, response, session, "GET", typeof(RESTMethods.RemoteOperation).Name.ToLowerInvariant(), key);
+        }
 
-            if (string.IsNullOrWhiteSpace(uri))
-            {
-                ReportError(response, bw, "Invalid request, missing uri");
-            }
-            else
-            {
-                var path = Library.Main.DatabaseLocator.GetDatabasePath(uri, null, false, false);
+        private void SearchBackupFiles(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
+        {
+            var input = request.Method.Equals("POST", StringComparison.InvariantCultureIgnoreCase) ? request.Form : request.QueryString;
+            var key = string.Format("{0}/files/{1}", input["id"].Value, input["filter"].Value);
 
-                bw.SetOK();
-                bw.WriteJsonObject(new {Exists = !string.IsNullOrWhiteSpace(path)});
-            }
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
+
+        }
+
+        private void GetFolderContents(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
+        {
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.Filesystem).Name.ToLowerInvariant(), Library.Utility.Uri.UrlPathEncode(request.QueryString["path"].Value));
+        }      
+
+
+        private void GetBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
+        {
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Backup));
+        }
+
+        private void DeleteBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
+        {
+            request.Method = HttpServer.Method.Delete;
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Backup));
+        }
+
+        private class AddOrUpdateBackupData
+        {
+            public Database.Schedule Schedule {get; set;}
+            public Database.Backup Backup {get; set;}
+        }
+
+        private void UpdateBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
+        {
+            request.Method = HttpServer.Method.Put;
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Backup));
+        }
+
+        private void AddBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
+        {
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Backups));
         }
 
         private void GetAcknowledgements(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            var path = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "acknowledgements.txt");
-                bw.SetOK();
-                bw.WriteJsonObject(new {
-                    Status = "OK",
-                    Acknowledgements = System.IO.File.ReadAllText(path)
-                });            
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Acknowledgements));
         }
 
         private void GetChangelog(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var fromUpdate = input["from-update"].Value;
-
-            if (!Library.Utility.Utility.ParseBool(fromUpdate, false))
-            {
-                var path = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "changelog.txt");
-                bw.SetOK();
-                bw.WriteJsonObject(new {
-                    Status = "OK",
-                    Version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(),
-                    Changelog = System.IO.File.ReadAllText(path)
-                });
-            }
-            else
-            {
-                var updateInfo = Program.DataConnection.ApplicationSettings.UpdatedVersion;
-                if (updateInfo == null)
-                {
-                    ReportError(response, bw, "No update found");
-                }
-                else
-                {
-                    bw.SetOK();
-                    bw.WriteJsonObject(new {
-                        Status = "OK",
-                        Version = updateInfo.Version,
-                        Changelog = updateInfo.ChangeInfo
-                    });
-                }
-            }
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Changelog));
         }
 
         private void GetLicenseData(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
@@ -269,146 +236,37 @@ namespace Duplicati.Server.WebServer
 
         private void RestoreFiles(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            var filters = input["paths"].Value.Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);
-            var time = Duplicati.Library.Utility.Timeparser.ParseTimeInterval(input["time"].Value, DateTime.Now);
-            var restoreTarget = input["restore-path"].Value;
-            var overwrite = Duplicati.Library.Utility.Utility.ParseBool(input["overwrite"].Value, false);
-
-            var permissions = Duplicati.Library.Utility.Utility.ParseBool(input["permissions"].Value, false);
-            var skip_metadata = Duplicati.Library.Utility.Utility.ParseBool(input["skip-metadata"].Value, false);
-
-            var task = Runner.CreateRestoreTask(bk, filters, time, restoreTarget, overwrite, permissions, skip_metadata);
-
-            Program.WorkThread.AddTask(task);
-
-            bw.OutputOK(new { TaskID = task.TaskID });
-
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/restore", input["id"].Value);
+            RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
         }
 
         private void ListBackupSets(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            var extra = new Dictionary<string, string>();
-            extra["list-sets-only"] = "true";
-            if (input["include-metadata"].Value != null)
-                extra["list-sets-only"] = (!Library.Utility.Utility.ParseBool(input["include-metadata"].Value, false)).ToString();
-            if (input["from-remote-only"].Value != null)
-                extra["no-local-db"] = Library.Utility.Utility.ParseBool(input["from-remote-only"].Value, false).ToString();
-
-            var r = Runner.Run(Runner.CreateTask(DuplicatiOperation.List, bk, extra), false) as Duplicati.Library.Interface.IListResults;
-
-            bw.OutputOK(r.Filesets);
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/filesets", input["id"].Value);
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
         }
 
         private void ListRemoteFolder(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            if (input["url"] == null || input["url"].Value == null)
-            {
-                ReportError(response, bw, "The url parameter was not set");
-                return;
-            }
-
-            try
-            {
-                using(var b = Duplicati.Library.DynamicLoader.BackendLoader.GetBackend(input["url"].Value, new Dictionary<string, string>()))
-                    bw.OutputOK(new { Status = "OK", Folders = b.List() });
-
-            }
-            catch (Exception ex)
-            {
-                ReportError(response, bw, ex.Message);
-            }
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/list", Library.Utility.Uri.UrlPathEncode(input["url"].Value));
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.RemoteOperation).Name.ToLowerInvariant(), key);
         }
+
         private void CreateRemoteFolder(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            if (input["url"] == null || input["url"].Value == null)
-            {
-                ReportError(response, bw, "The url parameter was not set");
-                return;
-            }
-
-            try
-            {
-                using(var b = Duplicati.Library.DynamicLoader.BackendLoader.GetBackend(input["url"].Value, new Dictionary<string, string>()))
-                    b.CreateFolder();
-
-                bw.OutputOK();
-            }
-            catch (Exception ex)
-            {
-                ReportError(response, bw, ex.Message);
-            }
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/create", Library.Utility.Uri.UrlPathEncode(input["url"].Value));
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.RemoteOperation).Name.ToLowerInvariant(), key);
         }
 
         private void TestBackend(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            if (input["url"] == null || input["url"].Value == null)
-            {
-                ReportError(response, bw, "The url parameter was not set");
-                return;
-            }
-
-            var modules = (from n in Library.DynamicLoader.GenericLoader.Modules
-                                    where n is Library.Interface.IConnectionModule
-                                    select n).ToArray();
-
-            try
-            {
-                var url = input["url"].Value;
-                var uri = new Library.Utility.Uri(url);
-                var qp = uri.QueryParameters;
-
-                var opts = new Dictionary<string, string>();
-                foreach(var k in qp.Keys.Cast<string>())
-                    opts[k] = qp[k];
-
-                foreach(var n in modules)
-                    n.Configure(opts);
-
-                using(var b = Duplicati.Library.DynamicLoader.BackendLoader.GetBackend(url, new Dictionary<string, string>()))
-                    b.Test();
-
-                bw.OutputOK();
-            }
-            catch (Duplicati.Library.Interface.FolderMissingException)
-            {
-                ReportError(response, bw, "missing-folder");
-            }
-            catch (Duplicati.Library.Utility.SslCertificateValidator.InvalidCertificateException icex)
-            {
-                if (string.IsNullOrWhiteSpace(icex.Certificate))
-                    ReportError(response, bw, icex.Message);
-                else
-                    ReportError(response, bw, "incorrect-cert:" + icex.Certificate);
-            }
-            catch (Exception ex)
-            {
-                ReportError(response, bw, ex.Message);
-            }
-            finally
-            {
-                foreach(var n in modules)
-                    if (n is IDisposable)
-                        ((IDisposable)n).Dispose();
-            }
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/test", Library.Utility.Uri.UrlPathEncode(input["url"].Value));
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.RemoteOperation).Name.ToLowerInvariant(), key);
         }
 
         private void ListSystemInfo(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
@@ -428,81 +286,14 @@ namespace Duplicati.Server.WebServer
 
         private void ListTags(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            var r = 
-                from n in 
-                Serializable.ServerSettings.CompressionModules
-                    .Union(Serializable.ServerSettings.EncryptionModules)
-                    .Union(Serializable.ServerSettings.BackendModules)
-                    .Union(Serializable.ServerSettings.GenericModules)
-                    select n.Key.ToLower();
-
-            // Append all known tags
-            r = r.Union(from n in Program.DataConnection.Backups select n.Tags into p from x in p select x.ToLower());
-            bw.OutputOK(r);
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Tags));
         }
 
         private void ValidatePath(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            if (input["path"] == null || input["path"].Value == null)
-            {
-                ReportError(response, bw, "The path parameter was not set");
-                return;
-            }
-
-            try
-            {
-                string path = SpecialFolders.ExpandEnvironmentVariables(input["path"].Value);                
-                if (System.IO.Path.IsPathRooted(path) && System.IO.Directory.Exists(path))
-                {
-                    bw.OutputOK();
-                    return;
-                }
-            }
-            catch
-            {
-            }
-
-            ReportError(response, bw, "File or folder not found");
-            return;
-        }
-
-        private bool LongPollCheck(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, BodyWriter bw, EventPollNotify poller, ref long id, out bool isError)
-        {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            if (Library.Utility.Utility.ParseBool(input["longpoll"].Value, false))
-            {
-                long lastEventId;
-                if (!long.TryParse(input["lasteventid"].Value, out lastEventId))
-                {
-                    ReportError(response, bw, "When activating long poll, the request must include the last event id");
-                    isError = true;
-                    return false;
-                }
-
-                TimeSpan ts;
-                try { ts = Library.Utility.Timeparser.ParseTimeSpan(input["duration"].Value); }
-                catch (Exception ex)
-                {
-                    ReportError(response, bw, "Invalid duration: " + ex.Message);
-                    isError = true;
-                    return false;
-                }
-
-                if (ts <= TimeSpan.FromSeconds(10) || ts.TotalMilliseconds > int.MaxValue)
-                {
-                    ReportError(response, bw, "Invalid duration, must be at least 10 seconds, and less than " + int.MaxValue + " milliseconds");
-                    isError = true;
-                    return false;
-                }
-
-                isError = false;
-                id = poller.Wait(lastEventId, (int)ts.TotalMilliseconds);
-                return true;
-            }
-
-            isError = false;
-            return false;
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/validate", Library.Utility.Uri.UrlPathEncode(input["path"].Value));
+            RESTHandler.DoProcess(request, response, session, "GET", typeof(RESTMethods.Filesystem).Name.ToLowerInvariant(), key);
         }
 
         private void GetProgressState(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
@@ -514,12 +305,7 @@ namespace Duplicati.Server.WebServer
         {
             RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.ServerState));
         }
-
-        private void ListCoreOptions(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.ServerSettings));
-        }
-
+            
         private void ListApplicationSettings(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
             RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.SystemWideSettings));
@@ -527,441 +313,82 @@ namespace Duplicati.Server.WebServer
 
         private void DownloadBugReport(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            long id;
-            long.TryParse(input["id"].Value, out id);
-
-            var tf = Program.DataConnection.GetTempFiles().Where(x => x.ID == id).FirstOrDefault();
-            if (tf == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            if (!System.IO.File.Exists(tf.Path))
-            {
-                ReportError(response, bw, "File is missing");
-                return;
-            }
-
-            var filename = "bugreport.zip";
-            using(var fs = System.IO.File.OpenRead(tf.Path))
-            {
-                response.ContentLength = fs.Length;
-                response.AddHeader("Content-Disposition", string.Format("attachment; filename={0}", filename));
-                response.ContentType = "application/octet-stream";
-
-                bw.SetOK();
-                response.SendHeaders();
-                fs.CopyTo(response.Body);
-                response.Send();
-            }
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.BugReport));
         }
 
         private void DeleteLocalData(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            System.IO.File.Delete(bk.DBPath);
-            bw.OutputOK();
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/deletedb", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+            RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
         }
 
         private void GetServerOptions(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            var adv_props = from n in Program.DataConnection.GetSettings(Database.Connection.APP_SETTINGS_ID)
-                            select new KeyValuePair<string, string>(n.Name, n.Value);
-
-            bw.OutputOK(adv_props.ToDictionary(x => x.Key, x => x.Value));
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.ServerSettings));
         }
 
         private void SetServerOptions(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            string str = request.Form["data"].Value;
-            if (string.IsNullOrWhiteSpace(str))
-            {
-                ReportError(response, bw, "Missing data object");
-                return;
-            }
-
-            Dictionary<string, string> data = null;
-            try
-            {
-                data = Serializer.Deserialize<Dictionary<string, string>>(new StringReader(str));
-                if (data == null)
-                {
-                    ReportError(response, bw, "Data object had no backup entry");
-                    return;
-                }
-
-                Program.DataConnection.ApplicationSettings.UpdateSettings(data);
-
-                bw.OutputOK();
-            }
-            catch (Exception ex)
-            {
-                if (data == null)
-                    ReportError(response, bw, string.Format("Unable to parse data object: {0}", ex.Message));
-                else
-                    ReportError(response, bw, string.Format("Unable to save settings: {0}", ex.Message));
-            }
-
+            request.Method = "PATCH";
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.ServerSettings));
         }
 
         private void CopyBackupToTemporary(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            //var ipx = new Database.Backup();
-            //Newtonsoft.Json.JsonConvert.PopulateObject(Newtonsoft.Json.JsonConvert.SerializeObject(bk), ipx);
-            var ipx = Serializer.Deserialize<Database.Backup>(new StringReader(Newtonsoft.Json.JsonConvert.SerializeObject(bk)));
-
-            using(var tf = new Duplicati.Library.Utility.TempFile())
-                ipx.DBPath = tf;
-            ipx.ID = null;
-
-            bw.OutputOK(new { status = "OK", ID = Program.DataConnection.RegisterTemporaryBackup(ipx) });
-
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/copytotemp", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+            RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
         }
             
         private void ExportBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            var cmdline = Library.Utility.Utility.ParseBool(input["cmdline"].Value, false);
-            if (cmdline)
-            {
-                bw.OutputOK(new { Command = Runner.GetCommandLine(Runner.CreateTask(DuplicatiOperation.Backup, bk)) });
-            }
-            else
-            {
-                var passphrase = input["passphrase"].Value;
-                var ipx = Program.DataConnection.PrepareBackupForExport(bk);
-
-                byte[] data;
-                using(var ms = new System.IO.MemoryStream())
-                using(var sw = new System.IO.StreamWriter(ms))
-                {
-                    Serializer.SerializeJson(sw, ipx, true);
-
-                    if (!string.IsNullOrWhiteSpace(passphrase))
-                    {
-                        ms.Position = 0;
-                        using(var ms2 = new System.IO.MemoryStream())
-                        using(var m = new Duplicati.Library.Encryption.AESEncryption(passphrase, new Dictionary<string, string>()))
-                        {
-                            m.Encrypt(ms, ms2);
-                            data = ms2.ToArray();
-                        }
-                    }
-                    else
-                        data = ms.ToArray();
-                }
-
-                var filename = Library.Utility.Uri.UrlEncode(bk.Name) + "-duplicati-config.json";
-                if (!string.IsNullOrWhiteSpace(passphrase))
-                    filename += ".aes";
-
-                response.ContentLength = data.Length;
-                response.AddHeader("Content-Disposition", string.Format("attachment; filename={0}", filename));
-                response.ContentType = "application/octet-stream";
-
-                bw.SetOK();
-                response.SendHeaders();
-                response.SendBody(data);
-            }
+            var input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
+            var key = string.Format("{0}/export", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+            RESTHandler.DoProcess(request, response, session, request.Method, typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
         }
 
         private void ImportBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            var output_template = "<html><body><script type=\"text/javascript\">var rp = null; try { rp = parent['CBM']; } catch (e) {}; rp = rp || alert; rp('MSG');</script></body></html>";
-            //output_template = "<html><body><script type=\"text/javascript\">alert('MSG');</script></body></html>";
-            try
-            {
-                HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-                var cmdline = Library.Utility.Utility.ParseBool(input["cmdline"].Value, false);
-                output_template = output_template.Replace("CBM", input["callback"].Value);
-                if (cmdline)
-                {
-                    response.ContentType = "text/html";
-                    bw.Write(output_template.Replace("MSG", "Import from commandline not yet implemented"));
-                }
-                else
-                {
-                    Serializable.ImportExportStructure ipx;
-
-                    var file = request.Form.GetFile("config");
-                    if (file == null)
-                        throw new Exception("No file uploaded");
-
-                    var buf = new byte[3];
-                    using(var fs = System.IO.File.OpenRead(file.Filename))
-                    {
-                        fs.Read(buf, 0, buf.Length);
-
-                        fs.Position = 0;
-                        if (buf[0] == 'A' && buf[1] == 'E' && buf[2] == 'S')
-                        {
-                            var passphrase = input["passphrase"].Value;
-                            using(var m = new Duplicati.Library.Encryption.AESEncryption(passphrase, new Dictionary<string, string>()))
-                            using(var m2 = m.Decrypt(fs))
-                            using(var sr = new System.IO.StreamReader(m2))
-                                ipx = Serializer.Deserialize<Serializable.ImportExportStructure>(sr);
-                        }
-                        else
-                        {
-                            using(var sr = new System.IO.StreamReader(fs))
-                                ipx = Serializer.Deserialize<Serializable.ImportExportStructure>(sr);
-                        }
-                    }
-
-                    ipx.Backup.ID = null;
-                    ((Database.Backup)ipx.Backup).DBPath = null;
-
-                    if (ipx.Schedule != null)
-                        ipx.Schedule.ID = -1;
-
-                    lock(Program.DataConnection.m_lock)
-                    {
-                        var basename = ipx.Backup.Name;
-                        var c = 0;
-                        while (c++ < 100 && Program.DataConnection.Backups.Where(x => x.Name.Equals(ipx.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
-                            ipx.Backup.Name = basename + " (" + c.ToString() + ")"; 
-                        
-                        if (Program.DataConnection.Backups.Where(x => x.Name.Equals(ipx.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
-                        {
-                            bw.SetOK();
-                            response.ContentType = "text/html";
-                            bw.Write(output_template.Replace("MSG", "There already exists a backup with the name: " + basename.Replace("\'", "\\'")));
-                        }
-
-                        Program.DataConnection.AddOrUpdateBackupAndSchedule(ipx.Backup, ipx.Schedule);
-                    }
-
-                    response.ContentType = "text/html";
-                    bw.Write(output_template.Replace("MSG", "OK"));
-
-                    //bw.OutputOK(new { status = "OK", ID = ipx.Backup.ID });
-                }
-            }
-            catch (Exception ex)
-            {
-                Program.DataConnection.LogError("", "Failed to import backup", ex);
-                response.ContentType = "text/html";
-                bw.Write(output_template.Replace("MSG", ex.Message.Replace("\'", "\\'").Replace("\r", "\\r").Replace("\n", "\\n")));
-            }
-
+            RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backups).Name.ToLowerInvariant(), "import");
         }
 
         private void GetNotifications(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            bw.OutputOK(Program.DataConnection.GetNotifications());
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Notifications));
         }
 
         private void DismissNotification(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var str = input["id"].Value;
-            long id;
-            long.TryParse(str, out id);
-
-            if (Program.DataConnection.DismissNotification(id))
-                bw.OutputOK();
-            else
-                ReportError(response, bw, "No such notification");
-
+            request.Method = "DELETE";
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.Notification));
         }
 
         private void GetUISettings(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var scheme = input["scheme"].Value;
-            if (string.IsNullOrWhiteSpace(scheme))
-            {
-                ReportError(response, bw, "No scheme supplied");
-                return;
-            }
-
-            bw.OutputOK(Program.DataConnection.GetUISettings(scheme));
+            request.Method = "GET";
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.UISettings));
         }
 
         private void SetUISettings(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var scheme = input["scheme"].Value;
-            var str = input["data"].Value;
-            if (string.IsNullOrWhiteSpace(scheme))
-            {
-                ReportError(response, bw, "No scheme supplied");
-                return;
-            }
-
-            if (string.IsNullOrWhiteSpace(str))
-            {
-                ReportError(response, bw, "No data supplied");
-                return;
-            }
-
-            IDictionary<string, string> data;
-            try
-            {
-                data = Serializer.Deserialize<Dictionary<string, string>>(new StringReader(str));
-            }
-            catch (Exception ex)
-            {
-                ReportError(response, bw, string.Format("Unable to parse settings object: {0}", ex.Message));
-                return;
-            }
-
-            if (data == null)
-            {
-                ReportError(response, bw, string.Format("Unable to parse settings object"));
-                return;
-            }
-
-            Program.DataConnection.SetUISettings(scheme, data);
-            bw.OutputOK();
+            request.Method = "POST";
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.UISettings));
         }
 
         private void GetUISettingSchemes(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            bw.OutputOK(Program.DataConnection.GetUISettingsSchemes());
-        }
-
-        private static void MergeJsonObjects(Newtonsoft.Json.Linq.JObject self, Newtonsoft.Json.Linq.JObject other)
-        {
-            foreach(var p in other.Properties())
-            {
-                var sp = self.Property(p.Name);
-                if (sp == null)
-                    self.Add(p);
-                else
-                {
-                    switch (p.Type)
-                    {
-                        // Primitives override
-                        case Newtonsoft.Json.Linq.JTokenType.Boolean:
-                        case Newtonsoft.Json.Linq.JTokenType.Bytes:
-                        case Newtonsoft.Json.Linq.JTokenType.Comment:
-                        case Newtonsoft.Json.Linq.JTokenType.Constructor:
-                        case Newtonsoft.Json.Linq.JTokenType.Date:
-                        case Newtonsoft.Json.Linq.JTokenType.Float:
-                        case Newtonsoft.Json.Linq.JTokenType.Guid:
-                        case Newtonsoft.Json.Linq.JTokenType.Integer:
-                        case Newtonsoft.Json.Linq.JTokenType.String:
-                        case Newtonsoft.Json.Linq.JTokenType.TimeSpan:
-                        case Newtonsoft.Json.Linq.JTokenType.Uri:
-                        case Newtonsoft.Json.Linq.JTokenType.None:
-                        case Newtonsoft.Json.Linq.JTokenType.Null:
-                        case Newtonsoft.Json.Linq.JTokenType.Undefined:
-                            self.Replace(p);
-                            break;
-
-                            // Arrays merge
-                        case Newtonsoft.Json.Linq.JTokenType.Array:
-                            if (sp.Type == Newtonsoft.Json.Linq.JTokenType.Array)
-                                sp.Value = new Newtonsoft.Json.Linq.JArray(((Newtonsoft.Json.Linq.JArray)sp.Value).Union((Newtonsoft.Json.Linq.JArray)p.Value));
-                            else
-                            {
-                                var a = new Newtonsoft.Json.Linq.JArray(sp.Value);
-                                sp.Value = new Newtonsoft.Json.Linq.JArray(a.Union((Newtonsoft.Json.Linq.JArray)p.Value));
-                            }
-
-                            break;
-
-                            // Objects merge
-                        case Newtonsoft.Json.Linq.JTokenType.Object:
-                            if (sp.Type == Newtonsoft.Json.Linq.JTokenType.Object)
-                                MergeJsonObjects((Newtonsoft.Json.Linq.JObject)sp.Value, (Newtonsoft.Json.Linq.JObject)p.Value);
-                            else
-                                sp.Value = p.Value;
-                            break;
-
-                            // Ignore other stuff                                
-                        default:
-                            break;
-                    }
-                }
-            }
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.UISettings));
         }
 
         private void GetBackupDefaults(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {   
-            // Start with a scratch object
-            var o = new Newtonsoft.Json.Linq.JObject();
-
-            // Add application wide settings
-            o.Add("ApplicationOptions", new Newtonsoft.Json.Linq.JArray(
-                from n in Program.DataConnection.Settings
-                select Newtonsoft.Json.Linq.JObject.FromObject(n)
-            ));
-
-            try
-            {
-                // Add built-in defaults
-                Newtonsoft.Json.Linq.JObject n;
-                using(var s = new System.IO.StreamReader(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name + ".newbackup.json")))
-                    n = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(s.ReadToEnd());
-
-                MergeJsonObjects(o, n);
-            }
-            catch
-            {
-            }
-
-            try
-            {
-                // Add install defaults/overrides, if present
-                var path = System.IO.Path.Combine(Duplicati.Library.AutoUpdater.UpdaterManager.InstalledBaseDir, "newbackup.json");
-                if (System.IO.File.Exists(path))
-                {
-                    Newtonsoft.Json.Linq.JObject n;
-                    n = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(System.IO.File.ReadAllText(path));
-
-                    MergeJsonObjects(o, n);
-                }
-            }
-            catch
-            {
-            }
-
-            bw.OutputOK(new
-            {
-                success = true,
-                data = o
-            });
+            RESTHandler.HandleControlCGI(request, response, session, bw, typeof(RESTMethods.BackupDefaults));
         }
 
         private void PollLogMessages(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
         {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var level_str = input["level"].Value ?? "";
-            var id_str = input["id"].Value ?? "";
-
-            Library.Logging.LogMessageType level;
-            long id;
-
-            long.TryParse(id_str, out id);
-            Enum.TryParse(level_str, true, out level);
-
-            bw.OutputOK(Program.LogHandler.AfterID(id, level));
+            RESTHandler.DoProcess(request, response, session, "GET", typeof(RESTMethods.LogData).Name.ToLowerInvariant(), "poll");
         }
 
         private void SendCommand(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
@@ -973,233 +400,81 @@ namespace Duplicati.Server.WebServer
             switch (command.ToLowerInvariant())
             {
                 case "check-update":
-                    Program.UpdatePoller.CheckNow();
-                    bw.OutputOK();
+                    RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Updates).Name.ToLowerInvariant(), "check");
                     return;
 
                 case "install-update":
-                    Program.UpdatePoller.InstallUpdate();
-                    bw.OutputOK();
+                    RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Updates).Name.ToLowerInvariant(), "install");
                     return;
 
                 case "activate-update":
-                    if (Program.WorkThread.CurrentTask != null || Program.WorkThread.CurrentTasks.Count != 0)
-                    {
-                        ReportError(response, bw, "Cannot activate update while task is running or scheduled");
-                    }
-                    else
-                    {
-                        Program.UpdatePoller.ActivateUpdate();
-                        bw.OutputOK();
-                    }
+                    RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Updates).Name.ToLowerInvariant(), "activate");
                     return;
 
                 case "pause":
-                    if (input.Contains("duration") && !string.IsNullOrWhiteSpace(input["duration"].Value))
-                    {
-                        TimeSpan ts;
-                        try
-                        {
-                            ts = Library.Utility.Timeparser.ParseTimeSpan(input["duration"].Value);
-                        }
-                        catch (Exception ex)
-                        {
-                            ReportError(response, bw, ex.Message);
-                            return;
-                        }
-                        if (ts.TotalMilliseconds > 0)
-                            Program.LiveControl.Pause(ts);
-                        else
-                            Program.LiveControl.Pause();
-                    }
-                    else
-                    {
-                        Program.LiveControl.Pause();
-                    }
-
-                    bw.OutputOK();
+                    RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.ServerState).Name.ToLowerInvariant(), "pause");
                     return;
+
                 case "resume":
-                    Program.LiveControl.Resume();
-                    bw.OutputOK();
+                    RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.ServerState).Name.ToLowerInvariant(), "resume");
                     return;
 
                 case "stop":
                 case "abort":
                     {
-                        var task = Program.WorkThread.CurrentTask;
-                        var tasks = Program.WorkThread.CurrentTasks;
-                        long taskid;
-                        if (!input.Contains("taskid") || !long.TryParse(input["taskid"].Value ?? "", out taskid))
-                        {
-                            ReportError(response, bw, "Invalid or missing taskid");
-                            return;
-                        }
-
-                        if (task != null)
-                            tasks.Insert(0, task);
-
-                        task = tasks.Where(x => x.TaskID == taskid).FirstOrDefault();
-                        if (task == null)
-                        {
-                            ReportError(response, bw, "No such task");
-                            return;
-                        }
-
-                        if (string.Equals(command, "abort", StringComparison.InvariantCultureIgnoreCase))
-                            task.Abort();
-                        else
-                            task.Stop();
-
-                        bw.OutputOK();
-                        return;
+                        var key = string.Format("{0}/{1}", input["taskid"].Value, command);
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Task).Name.ToLowerInvariant(), key);
                     }
+                    return;
 
                 case "is-backup-active":
                     {
-                        var backup = Program.DataConnection.GetBackup(input["id"].Value);
-                        if (backup == null)
-                        {
-                            ReportError(response, bw, string.Format("No backup found for id: {0}", input["id"].Value));
-                            return;
-                        }
-
-                        var t = Program.WorkThread.CurrentTask;
-                        var bt = t == null ? null : t.Backup;
-                        if (bt != null && backup.ID == bt.ID)
-                        {
-                            bw.OutputOK(new { Status = "OK", Active = true });
-                            return;
-                        }
-                        else if (Program.WorkThread.CurrentTasks.Where(x =>
-                        { 
-                            var bn = x == null ? null : x.Backup;
-                            return bn == null || bn.ID == backup.ID;
-                        }).Any())
-                        {
-                            bw.OutputOK(new { Status = "OK", Active = true });
-                            return;
-                        }
-                        else
-                        {
-                            bw.OutputOK(new { Status = "OK", Active = false });
-                            return;
-                        }
+                        var key = string.Format("{0}/isactive", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+                        RESTHandler.DoProcess(request, response, session, "GET", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
                     }
+                    return;
 
                 case "run":
                 case "run-backup":
                     {
-
-                        var backup = Program.DataConnection.GetBackup(input["id"].Value);
-                        if (backup == null)
-                        {
-                            ReportError(response, bw, string.Format("No backup found for id: {0}", input["id"].Value));
-                            return;
-                        }
-
-                        var t = Program.WorkThread.CurrentTask;
-                        var bt = t == null ? null : t.Backup;
-                        if (bt != null && backup.ID == bt.ID)
-                        {
-                            // Already running
-                        }
-                        else if (Program.WorkThread.CurrentTasks.Where(x => { 
-                            var bn = x == null ? null : x.Backup;
-                            return bn == null || bn.ID == backup.ID;
-                        }).Any())
-                        {
-                            // Already in queue
-                        }
-                        else
-                        {
-                            Program.WorkThread.AddTask(Runner.CreateTask(DuplicatiOperation.Backup, backup));
-                            Program.StatusEventNotifyer.SignalNewEvent();
-                        }
+                        var key = string.Format("{0}/start", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
                     }
-                    bw.OutputOK();
                     return;
 
                 case "run-verify":
                     {
-                        var backup = Program.DataConnection.GetBackup(input["id"].Value);
-                        if (backup == null)
-                        {
-                            ReportError(response, bw, string.Format("No backup found for id: {0}", input["id"].Value));
-                            return;
-                        }
-
-                        var task = Runner.CreateTask(DuplicatiOperation.Verify, backup);
-                        Program.WorkThread.AddTask(task);
-                        Program.StatusEventNotifyer.SignalNewEvent();
-
-                        bw.OutputOK(new {Status = "OK", ID = task.TaskID});
+                        var key = string.Format("{0}/verify", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
                     }
                     return;
 
                 case "run-repair-update":
+                    {
+                        var key = string.Format("{0}/repairupdate", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
+                    }
+                    return;
+
                 case "run-repair":
                     {
-                        var backup = Program.DataConnection.GetBackup(input["id"].Value);
-                        if (backup == null)
-                        {
-                            ReportError(response, bw, string.Format("No backup found for id: {0}", input["id"].Value));
-                            return;
-                        }
-
-                        string[] filters = null;
-                        var extra = new Dictionary<string, string>();
-                        if (input["only-paths"].Value != null)
-                            extra["repair-only-paths"] = (Library.Utility.Utility.ParseBool(input["only-paths"].Value, false)).ToString();
-                        if (input["time"].Value != null)
-                            extra["time"] = input["time"].Value;
-                        if (input["version"].Value != null)
-                            extra["version"] = input["version"].Value;
-                        if (input["paths"].Value != null)
-                            filters = input["paths"].Value.Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);
-
-                        var task = Runner.CreateTask(command.ToLowerInvariant() == "run-repair" ? DuplicatiOperation.Repair : DuplicatiOperation.RepairUpdate, backup, extra, filters);
-                        Program.WorkThread.AddTask(task);
-                        Program.StatusEventNotifyer.SignalNewEvent();
-
-                        bw.OutputOK(new {Status = "OK", ID = task.TaskID});
+                        var key = string.Format("{0}/repair", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
                     }
                     return;
                 case "create-report":
                     {
-                        var backup = Program.DataConnection.GetBackup(input["id"].Value);
-                        if (backup == null)
-                        {
-                            ReportError(response, bw, string.Format("No backup found for id: {0}", input["id"].Value));
-                            return;
-                        }
-
-                        var task = Runner.CreateTask(DuplicatiOperation.CreateReport, backup);
-                        Program.WorkThread.AddTask(task);
-                        Program.StatusEventNotifyer.SignalNewEvent();
-
-                        bw.OutputOK(new { Status = "OK", ID = task.TaskID });
+                        var key = string.Format("{0}/createreport", Library.Utility.Uri.UrlPathEncode(input["id"].Value));
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.Backup).Name.ToLowerInvariant(), key);
                     }
                     return;
 
                 default:
-
-                    var m = Duplicati.Library.DynamicLoader.WebLoader.Modules.Where(x => x.Key.Equals(command, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
-                    if (m == null)
                     {
-                        ReportError(response, bw, string.Format("Unsupported command {0}", command));
+                        var key = string.Format("{0}", Library.Utility.Uri.UrlPathEncode(input["command"].Value));
+                        RESTHandler.DoProcess(request, response, session, "POST", typeof(RESTMethods.WebModule).Name.ToLowerInvariant(), key);
                         return;
                     }
-
-                    bw.OutputOK(new { 
-                        Status = "OK", 
-                        Result = m.Execute(input.Where(x => 
-                            !x.Name.Equals("command", StringComparison.InvariantCultureIgnoreCase)
-                            &&
-                            !x.Name.Equals("action", StringComparison.InvariantCultureIgnoreCase)
-                        ).ToDictionary(x => x.Name, x => x.Value))
-                    });
-                    return;
             }
         }
 
diff --git a/Duplicati/Server/WebServer/ControlMethods/AddOrUpdateBackup.cs b/Duplicati/Server/WebServer/ControlMethods/AddOrUpdateBackup.cs
deleted file mode 100644
index e2deb83a8..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/AddOrUpdateBackup.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-using System.Linq;
-using Duplicati.Server.Serialization;
-using System.IO;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private class AddOrUpdateBackupData
-        {
-            public Database.Schedule Schedule {get; set;}
-            public Database.Backup Backup {get; set;}
-        }
-
-        private void UpdateBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            string str = request.Form["data"].Value;
-            if (string.IsNullOrWhiteSpace(str))
-            {
-                ReportError(response, bw, "Missing backup object");
-                return;
-            }
-
-            AddOrUpdateBackupData data = null;
-            try
-            {
-                data = Serializer.Deserialize<AddOrUpdateBackupData>(new StringReader(str));
-                if (data.Backup == null)
-                {
-                    ReportError(response, bw, "Data object had no backup entry");
-                    return;
-                }
-
-                if (data.Backup.ID == null)
-                {
-                    ReportError(response, bw, "Invalid or missing backup id");
-                    return;
-                }                    
-
-                if (data.Backup.IsTemporary)
-                {
-                    var backup = Program.DataConnection.GetBackup(data.Backup.ID);
-                    if (backup.IsTemporary)
-                        throw new InvalidDataException("External is temporary but internal is not?");
-
-                    Program.DataConnection.UpdateTemporaryBackup(backup);
-                    bw.OutputOK();
-                }
-                else
-                {                    
-                    lock(Program.DataConnection.m_lock)
-                    {
-                        var backup = Program.DataConnection.GetBackup(data.Backup.ID);
-                        if (backup == null)
-                        {
-                            ReportError(response, bw, "Invalid or missing backup id");
-                            return;
-                        }
-
-                        if (Program.DataConnection.Backups.Where(x => x.Name.Equals(data.Backup.Name, StringComparison.InvariantCultureIgnoreCase) && x.ID != data.Backup.ID).Any())
-                        {
-                            ReportError(response, bw, "There already exists a backup with the name: " + data.Backup.Name);
-                            return;
-                        }
-
-                        //TODO: Merge in real passwords where the placeholder is found
-                        Program.DataConnection.AddOrUpdateBackupAndSchedule(data.Backup, data.Schedule);
-
-                    }
-
-                    bw.OutputOK();
-                }
-            }
-            catch (Exception ex)
-            {
-                if (data == null)
-                    ReportError(response, bw, string.Format("Unable to parse backup or schedule object: {0}", ex.Message));
-                else
-                    ReportError(response, bw, string.Format("Unable to save backup or schedule: {0}", ex.Message));
-
-            }
-        }
-
-        private void AddBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            var str = request.Form["data"].Value;
-
-            if (string.IsNullOrWhiteSpace(str))
-            {
-                ReportError(response, bw, "Missing backup object");
-                return;
-            }
-
-            AddOrUpdateBackupData data = null;
-            try
-            {
-                data = Serializer.Deserialize<AddOrUpdateBackupData>(new StringReader(str));
-                if (data.Backup == null)
-                {
-                    ReportError(response, bw, "Data object had no backup entry");
-                    return;
-                }
-
-                data.Backup.ID = null;
-
-                if (Duplicati.Library.Utility.Utility.ParseBool(request.Form["temporary"].Value, false))
-                {
-                    using(var tf = new Duplicati.Library.Utility.TempFile())
-                        data.Backup.DBPath = tf;
-
-                    Program.DataConnection.RegisterTemporaryBackup(data.Backup);
-
-                    bw.OutputOK(new { status = "OK", ID = data.Backup.ID });
-                }
-                else
-                {
-                    if (Library.Utility.Utility.ParseBool(request.Form["existing_db"].Value, false))
-                    {
-                        data.Backup.DBPath = Library.Main.DatabaseLocator.GetDatabasePath(data.Backup.TargetURL, null, false, false);
-                        if (string.IsNullOrWhiteSpace(data.Backup.DBPath))
-                            throw new Exception("Unable to find remote db path?");
-                    }
-
-
-                    lock(Program.DataConnection.m_lock)
-                    {
-                        if (Program.DataConnection.Backups.Where(x => x.Name.Equals(data.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
-                        {
-                            ReportError(response, bw, "There already exists a backup with the name: " + data.Backup.Name);
-                            return;
-                        }
-
-                        Program.DataConnection.AddOrUpdateBackupAndSchedule(data.Backup, data.Schedule);
-                    }
-
-                    bw.OutputOK(new { status = "OK", ID = data.Backup.ID });
-                }
-            }
-            catch (Exception ex)
-            {
-                if (data == null)
-                    ReportError(response, bw, string.Format("Unable to parse backup or schedule object: {0}", ex.Message));
-                else
-                    ReportError(response, bw, string.Format("Unable to save schedule or backup object: {0}", ex.Message));
-            }
-        }
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/ControlMethods/DeleteBackup.cs b/Duplicati/Server/WebServer/ControlMethods/DeleteBackup.cs
deleted file mode 100644
index ae0dd0aec..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/DeleteBackup.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private void DeleteBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var backup = Program.DataConnection.GetBackup(input["id"].Value);
-            if (backup == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            if (Program.WorkThread.Active)
-            {
-                try
-                {
-                    //TODO: It's not safe to access the values like this, 
-                    //because the runner thread might interfere
-                    var nt = Program.WorkThread.CurrentTask;
-                    if (backup.Equals(nt == null ? null : nt.Backup))
-                    {
-                        bool force;
-                        if (!bool.TryParse(input["force"].Value, out force))
-                            force = false;
-
-                        if (!force)
-                        {
-                            bw.WriteJsonObject(new { status = "failed", reason = "backup-in-progress" });
-                            return;
-                        }
-
-                        bool hasPaused = Program.LiveControl.State == LiveControls.LiveControlState.Paused;
-                        Program.LiveControl.Pause();
-
-                        try
-                        {
-                            for(int i = 0; i < 10; i++)
-                                if (Program.WorkThread.Active)
-                                {
-                                    var t = Program.WorkThread.CurrentTask;
-                                    if (backup.Equals(t == null ? null : t.Backup))
-                                        System.Threading.Thread.Sleep(1000);
-                                    else
-                                        break;
-                                }
-                                else
-                                    break;
-                        }
-                        finally
-                        {
-                        }
-
-                        if (Program.WorkThread.Active)
-                        {
-                            var t = Program.WorkThread.CurrentTask;
-                            if (backup.Equals(t == null ? null : t.Backup))
-                            {
-                                if (hasPaused)
-                                    Program.LiveControl.Resume();
-                                bw.WriteJsonObject(new { status = "failed", reason = "backup-unstoppable" });
-                                return;
-                            }
-                        }
-
-                        if (hasPaused)
-                            Program.LiveControl.Resume();
-                    }
-                }
-                catch (Exception ex)
-                {
-                    bw.WriteJsonObject(new { status = "error", message = ex.Message });
-                    return;
-                }
-            }
-
-
-            //var dbpath = backup.DBPath;
-            Program.DataConnection.DeleteBackup(backup);
-
-            // TODO: Before we activate this, 
-            // we need some strategy to figure out
-            // if the db is shared with something else
-            // like the commandline or another backup
-            /*try
-            {
-                if (System.IO.File.Exists(dbpath))
-                    System.IO.File.Delete(dbpath);
-            }
-            catch (Exception ex)
-            {
-                Program.DataConnection.LogError(null, string.Format("Failed to delete database: {0}", dbpath), ex);
-            }*/
-
-            //We have fiddled with the schedules
-            Program.Scheduler.Reschedule();
-
-            bw.OutputOK();
-        }
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/ControlMethods/GetBackup.cs b/Duplicati/Server/WebServer/ControlMethods/GetBackup.cs
deleted file mode 100644
index bf079234a..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/GetBackup.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-using System.Linq;
-using System.Collections.Generic;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private void GetBackup(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-                ReportError(response, bw, "Invalid or missing backup id");
-            else
-            {
-                var scheduleId = Program.DataConnection.GetScheduleIDsFromTags(new string[] { "ID=" + bk.ID });
-                var schedule = scheduleId.Any() ? Program.DataConnection.GetSchedule(scheduleId.First()) : null;
-                var sourcenames = SpecialFolders.GetSourceNames(bk);
-
-                //TODO: Filter out the password in both settings and the target url
-
-                bw.OutputOK(new
-                {
-                    success = true,
-                    data = new {
-                        Schedule = schedule,
-                        Backup = bk,
-                        DisplayNames = sourcenames
-                    }
-                });
-            }
-        }
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/ControlMethods/GetFolderContents.cs b/Duplicati/Server/WebServer/ControlMethods/GetFolderContents.cs
deleted file mode 100644
index fd02ef2a1..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/GetFolderContents.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-using System.Linq;
-using System.Collections.Generic;
-using System.IO;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private void GetFolderContents(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            if (input["path"] == null || input["path"].Value == null)
-            {
-                ReportError(response, bw, "The path parameter was not set");
-                return;
-            }
-
-            bool skipFiles = Library.Utility.Utility.ParseBool(input["onlyfolders"].Value, false);
-
-            var path = input["path"].Value;
-            string specialpath = null;
-            string specialtoken = null;
-
-            if (path.StartsWith("%"))
-            {
-                var ix = path.IndexOf("%", 1);
-                if (ix > 0)
-                {
-                    var tk = path.Substring(0, ix + 1);
-                    var node = SpecialFolders.Nodes.Where(x => x.id.Equals(tk, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
-                    if (node != null)
-                    {
-                        specialpath = node.resolvedpath;
-                        specialtoken = node.id;
-                    }
-                }
-            }
-
-            path = SpecialFolders.ExpandEnvironmentVariables(path);
-
-            if (Duplicati.Library.Utility.Utility.IsClientLinux && !path.StartsWith("/"))
-            {
-                ReportError(response, bw, "The path parameter must start with a forward-slash");
-                return;
-            }
-
-            try
-            {
-                if (path != "" && path != "/")
-                    path = Duplicati.Library.Utility.Utility.AppendDirSeparator(path);
-
-                IEnumerable<Serializable.TreeNode> res;
-
-                if (!Library.Utility.Utility.IsClientLinux && (path.Equals("/") || path.Equals("")))
-                {
-                    res = 
-                        from di in System.IO.DriveInfo.GetDrives()
-                            where di.DriveType == DriveType.Fixed || di.DriveType == DriveType.Network || di.DriveType == DriveType.Removable
-                        select new Serializable.TreeNode()
-                    {
-                        id = di.RootDirectory.FullName,
-                        text = di.RootDirectory.FullName.Replace('\\', ' ') + "(" + di.DriveType + ")",
-                        iconCls = "x-tree-icon-drive"
-                    };
-                }
-                else
-                {
-                    res = ListFolderAsNodes(path, skipFiles);                        
-                }
-
-                if ((path.Equals("/") || path.Equals("")) && specialtoken == null) 
-                {
-                    // Prepend special folders
-                    res = SpecialFolders.Nodes.Union(res);
-                }
-
-                if (specialtoken != null)
-                {
-                    res = from n in res
-                        select new Serializable.TreeNode() {
-                        id = specialtoken + n.id.Substring(specialpath.Length),
-                        text = n.text,
-                        iconCls = n.iconCls,
-                        leaf = n.leaf,
-                        resolvedpath = n.id
-                    };
-                }
-
-                bw.OutputOK(res);
-            }
-            catch (Exception ex)
-            {
-                ReportError(response, bw, "Failed to process the path: " + ex.Message);
-            }
-        }       
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/ControlMethods/ListFolderAsNodes.cs b/Duplicati/Server/WebServer/ControlMethods/ListFolderAsNodes.cs
deleted file mode 100644
index 486bea63d..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/ListFolderAsNodes.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-using System.Linq;
-using System.Collections.Generic;
-using System.IO;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private static IEnumerable<Serializable.TreeNode> ListFolderAsNodes(string entrypath, bool skipFiles)
-        {
-            //Helper function for finding out if a folder has sub elements
-            Func<string, bool> hasSubElements = (p) => skipFiles ? Directory.EnumerateDirectories(p).Any() : Directory.EnumerateFileSystemEntries(p).Any();
-
-            //Helper function for dealing with exceptions when accessing off-limits folders
-            Func<string, bool> isEmptyFolder = (p) =>
-            {
-                try { return !hasSubElements(p); }
-                catch { }
-                return true;
-            };
-
-            //Helper function for dealing with exceptions when accessing off-limits folders
-            Func<string, bool> canAccess = (p) =>
-            {
-                try { hasSubElements(p); return true; }
-                catch { }
-                return false;
-            }; 
-
-            var systemIO = Library.Utility.Utility.IsClientLinux
-                ? (Duplicati.Library.Snapshots.ISystemIO)new Duplicati.Library.Snapshots.SystemIOLinux() 
-                : (Duplicati.Library.Snapshots.ISystemIO)new Duplicati.Library.Snapshots.SystemIOWindows();
-
-            foreach (var s in System.IO.Directory.EnumerateFileSystemEntries(entrypath))
-            {
-                Serializable.TreeNode tn = null;
-                try
-                {
-                    var attr = systemIO.GetFileAttributes(s);
-                    //var isSymlink = (attr & FileAttributes.ReparsePoint) != 0;
-                    var isFolder = (attr & FileAttributes.Directory) != 0;
-                    var isFile = !isFolder;
-                    //var isHidden = (attr & FileAttributes.Hidden) != 0;
-
-                    var accesible = isFile || canAccess(s);
-                    var isLeaf = isFile || !accesible || isEmptyFolder(s);
-
-                    var rawid = isFolder ? Library.Utility.Utility.AppendDirSeparator(s) : s;
-                    if (!skipFiles || isFolder)
-                        tn = new Serializable.TreeNode()
-                    {
-                        id = rawid,
-                        text = systemIO.PathGetFileName(s),
-                        iconCls = isFolder ? (accesible ? "x-tree-icon-parent" : "x-tree-icon-locked") : "x-tree-icon-leaf",
-                        leaf = isLeaf
-                    };
-                }
-                catch
-                {
-                }
-
-                if (tn != null)
-                    yield return tn;
-            }
-        }
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/ControlMethods/ReadLogData.cs b/Duplicati/Server/WebServer/ControlMethods/ReadLogData.cs
deleted file mode 100644
index b24e1b411..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/ReadLogData.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-using System.Collections.Generic;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private void ReadLogData(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-            var backupid = input["id"].Value;
-
-            if (string.IsNullOrWhiteSpace(backupid))
-            {
-                List<Dictionary<string, object>> res = null;
-                Program.DataConnection.ExecuteWithCommand(x =>
-                {
-                    res = DumpTable(x, "ErrorLog", "Timestamp", input["offset"].Value, input["pagesize"].Value);
-                });
-
-                bw.OutputOK(res);
-            }
-            else
-            {
-                var backup = Program.DataConnection.GetBackup(backupid);
-                if (backup == null)
-                {
-                    ReportError(response, bw, "Invalid or missing backup id");
-                    return;
-                }
-
-                using(var con = (System.Data.IDbConnection)Activator.CreateInstance(Duplicati.Library.SQLiteHelper.SQLiteLoader.SQLiteConnectionType))
-                {
-                    con.ConnectionString = "Data Source=" + backup.DBPath;
-                    con.Open();
-
-                    using(var cmd = con.CreateCommand())
-                    {
-                        if (Duplicati.Library.Utility.Utility.ParseBool(input["remotelog"].Value, false))
-                        {
-                            var dt = DumpTable(cmd, "RemoteOperation", "ID", input["offset"].Value, input["pagesize"].Value);
-
-                            // Unwrap raw data to a string
-                            foreach(var n in dt)
-                                try { n["Data"] = System.Text.Encoding.UTF8.GetString((byte[])n["Data"]); }
-                            catch { }
-
-                            bw.OutputOK(dt);
-                        }
-                        else
-                        {
-                            var dt = DumpTable(cmd, "LogData", "ID", input["offset"].Value, input["pagesize"].Value);
-                            bw.OutputOK(dt);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/ControlMethods/SearchBackupFiles.cs b/Duplicati/Server/WebServer/ControlMethods/SearchBackupFiles.cs
deleted file mode 100644
index 08c22013b..000000000
--- a/Duplicati/Server/WebServer/ControlMethods/SearchBackupFiles.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-//  Copyright (C) 2015, The Duplicati Team
-
-//  http://www.duplicati.com, info@duplicati.com
-//
-//  This library is free software; you can redistribute it and/or modify
-//  it under the terms of the GNU Lesser General Public License as
-//  published by the Free Software Foundation; either version 2.1 of the
-//  License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful, but
-//  WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
-using System.Collections.Generic;
-
-namespace Duplicati.Server.WebServer
-{
-    partial class ControlHandler
-    {
-        private void SearchBackupFiles(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw)
-        {
-            HttpServer.HttpInput input = request.Method.ToUpper() == "POST" ? request.Form : request.QueryString;
-
-            var filter = (input["filter"].Value ?? "").Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);
-            var timestring = input["time"].Value;
-            var allversion = Duplicati.Library.Utility.Utility.ParseBool(input["all-versions"].Value, false);
-
-            if (string.IsNullOrWhiteSpace(timestring) && !allversion)
-            {
-                ReportError(response, bw, "Invalid or missing time");
-                return;
-            }
-            var bk = Program.DataConnection.GetBackup(input["id"].Value);
-            if (bk == null)
-            {
-                ReportError(response, bw, "Invalid or missing backup id");
-                return;
-            }
-
-            var prefixonly = Duplicati.Library.Utility.Utility.ParseBool(input["prefix-only"].Value, false);
-            var foldercontents = Duplicati.Library.Utility.Utility.ParseBool(input["folder-contents"].Value, false);
-            var time = new DateTime();
-            if (!allversion)
-                time = Duplicati.Library.Utility.Timeparser.ParseTimeInterval(timestring, DateTime.Now);
-
-            var r = Runner.Run(Runner.CreateListTask(bk, filter, prefixonly, allversion, foldercontents, time), false) as Duplicati.Library.Interface.IListResults;
-
-            var result = new Dictionary<string, object>();
-
-            foreach(HttpServer.HttpInputItem n in input)
-                result[n.Name] = n.Value;
-
-            result["Filesets"] = r.Filesets;
-            result["Files"] = r.Files;
-
-            bw.OutputOK(result);
-        }
-    }
-}
-
diff --git a/Duplicati/Server/WebServer/RESTHandler.cs b/Duplicati/Server/WebServer/RESTHandler.cs
index 1183e3e87..aaa86424d 100644
--- a/Duplicati/Server/WebServer/RESTHandler.cs
+++ b/Duplicati/Server/WebServer/RESTHandler.cs
@@ -19,6 +19,6 @@ using System;
using System.Linq;
using HttpServer.HttpModules;
using System.Coll
 namespace Duplicati.Server.WebServer
 {
     public class RESTHandler : HttpModule
-    {
        public const string API_URI_PATH = "/api/v1";
        public static readonly int API_URI_SEGMENTS = API_URI_PATH.Split(new char[] {'/'}).Length;

        private static readonly Dictionary<string, IRESTMethod> _modules = new Dictionary<string, IRESTMethod>(StringComparer.InvariantCultureIgnoreCase);

        public static IDictionary<string, IRESTMethod> Modules { get { return _modules; } }

        /// <summary>
        /// Loads all REST modules in the Duplicati.Server.WebServer.RESTMethods namespace
        /// </summary>
        static RESTHandler()
        {
            var lst = 
                from n in typeof(RESTHandler).Assembly.DefinedTypes
                where
                    n.Namespace == typeof(IRESTMethod).Namespace
                    &&
                    typeof(IRESTMethod).IsAssignableFrom(n)
                    &&
                    !n.IsAbstract
                    &&
                    !n.IsInterface
                select n;

            foreach(var t in lst)
            {
                var m = (IRESTMethod)Activator.CreateInstance(t);
                _modules.Add(t.Name.ToLowerInvariant(), m);
            }
        }

        public static void HandleControlCGI(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw, Type module)
        {
            var method = request.Method;
            if (!string.IsNullOrWhiteSpace(request.Headers["X-HTTP-Method-Override"]))
                method = request.Headers["X-HTTP-Method-Override"];
            
            DoProcess(request, response, session, method, module.Name.ToLowerInvariant(), (request.Method.ToUpper() == "POST" ? request.Form : request.QueryString)["id"].ToString());
        }

        public static void DoProcess(RequestInfo info, string method, string module, string key)
        {
            IRESTMethod mod;
            _modules.TryGetValue(module, out mod);

            if (mod == null)
            {
                info.Response.Status = System.Net.HttpStatusCode.NotFound;
                info.Response.Reason = "No such module";
            }
            else if (method == HttpServer.Method.Get && mod is IRESTMethodGET)
                ((IRESTMethodGET)mod).GET(key, info);
            else if (method == HttpServer.Method.Put && mod is IRESTMethodPUT)
                ((IRESTMethodPUT)mod).PUT(key, info);
            else if (method == HttpServer.Method.Post && mod is IRESTMethodPOST)
                ((IRESTMethodPOST)mod).POST(key, info);
            else if (method == HttpServer.Method.Delete && mod is IRESTMethodDELETE)
                ((IRESTMethodDELETE)mod).DELETE(key, info);
            else
            {
                info.Response.Status = System.Net.HttpStatusCode.MethodNotAllowed;
                info.Response.Reason = "Method is not allowed";
            }
        }

        public static void DoProcess(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, string method, string module, string key)
        {
            using(var reqinfo = new RequestInfo(request, response, session))
                DoProcess(reqinfo, method, module, key);
        }
            
        public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
        {
            if (!request.Uri.AbsolutePath.StartsWith(API_URI_PATH, StringComparison.InvariantCultureIgnoreCase))
                return false;

            var module = request.Uri.Segments.Skip(API_URI_SEGMENTS).FirstOrDefault();
            if (string.IsNullOrWhiteSpace(module))
                module = "help";

            module = module.Trim('/');

            var key = string.Join("/", request.Uri.Segments.Skip(API_URI_SEGMENTS + 1)).Trim('/');

            var method = request.Method;
            if (!string.IsNullOrWhiteSpace(request.Headers["X-HTTP-Method-Override"]))
                method = request.Headers["X-HTTP-Method-Override"];

            DoProcess(request, response, session, method, module, key);

            return true;
        }
    }
+    {
        public const string API_URI_PATH = "/api/v1";
        public static readonly int API_URI_SEGMENTS = API_URI_PATH.Split(new char[] {'/'}).Length;

        private static readonly Dictionary<string, IRESTMethod> _modules = new Dictionary<string, IRESTMethod>(StringComparer.InvariantCultureIgnoreCase);

        public static IDictionary<string, IRESTMethod> Modules { get { return _modules; } }

        /// <summary>
        /// Loads all REST modules in the Duplicati.Server.WebServer.RESTMethods namespace
        /// </summary>
        static RESTHandler()
        {
            var lst = 
                from n in typeof(RESTHandler).Assembly.DefinedTypes
                where
                    n.Namespace == typeof(IRESTMethod).Namespace
                    &&
                    typeof(IRESTMethod).IsAssignableFrom(n)
                    &&
                    !n.IsAbstract
                    &&
                    !n.IsInterface
                select n;

            foreach(var t in lst)
            {
                var m = (IRESTMethod)Activator.CreateInstance(t);
                _modules.Add(t.Name.ToLowerInvariant(), m);
            }
        }

        public static void HandleControlCGI(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, BodyWriter bw, Type module)
        {
            var method = request.Method;
            if (!string.IsNullOrWhiteSpace(request.Headers["X-HTTP-Method-Override"]))
                method = request.Headers["X-HTTP-Method-Override"];
            
            DoProcess(request, response, session, method, module.Name.ToLowerInvariant(), (request.Method.ToUpper() == "POST" ? request.Form : request.QueryString)["id"].Value);
        }

        public static void DoProcess(RequestInfo info, string method, string module, string key)
        {
            try
            {
                IRESTMethod mod;
                _modules.TryGetValue(module, out mod);

                if (mod == null)
                {
                    info.Response.Status = System.Net.HttpStatusCode.NotFound;
                    info.Response.Reason = "No such module";
                }
                else if (method == HttpServer.Method.Get && mod is IRESTMethodGET)
                {
                    if (info.Request.Form != HttpServer.HttpForm.EmptyForm)
                    {
                        if (info.Request.QueryString == HttpServer.HttpInput.Empty)
                        {
                            var r = info.Request.GetType().GetField("_queryString", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                            r.SetValue(info.Request, new HttpServer.HttpInput("formdata"));
                        }

                        foreach(HttpServer.HttpInputItem v in info.Request.Form)
                            if (!info.Request.QueryString.Contains(v.Name))
                                info.Request.QueryString.Add(v.Name, v.Value);
                    }
                    ((IRESTMethodGET)mod).GET(key, info);
                }
                else if (method == HttpServer.Method.Put && mod is IRESTMethodPUT)
                    ((IRESTMethodPUT)mod).PUT(key, info);
                else if (method == HttpServer.Method.Post && mod is IRESTMethodPOST)
                {
                    if (info.Request.Form == HttpServer.HttpForm.EmptyForm)
                    {
                        var r = info.Request.GetType().GetMethod("AssignForm", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new Type[] { typeof(HttpServer.HttpForm) }, null);
                        r.Invoke(info.Request, new object[] { new HttpServer.HttpForm(info.Request.QueryString) });
                    }
                    else
                    {
                        foreach(HttpServer.HttpInputItem v in info.Request.QueryString)
                            if (!info.Request.Form.Contains(v.Name))
                                info.Request.Form.Add(v.Name, v.Value);
                    }
                    ((IRESTMethodPOST)mod).POST(key, info);
                }
                else if (method == HttpServer.Method.Delete && mod is IRESTMethodDELETE)
                    ((IRESTMethodDELETE)mod).DELETE(key, info);
                else if (method == "PATCH" && mod is IRESTMethodPATCH)
                    ((IRESTMethodPATCH)mod).PATCH(key, info);
                else
                {
                    info.Response.Status = System.Net.HttpStatusCode.MethodNotAllowed;
                    info.Response.Reason = "Method is not allowed";
                }
            }
            catch(Exception ex)
            {
                Program.DataConnection.LogError("", string.Format("Request for {0} gave error", info.Request.Uri), ex);
                Console.WriteLine(ex.ToString());

                try
                {
                    if (!info.Response.HeadersSent)
                    {
                        info.Response.Status = System.Net.HttpStatusCode.InternalServerError;
                        info.Response.Reason = "Error";
                        info.Response.ContentType = "text/plain";

                        var wex = ex;
                        while (wex is System.Reflection.TargetInvocationException && wex.InnerException != wex)
                            wex = wex.InnerException;
                            

                        info.BodyWriter.WriteJsonObject(new
                        {
                            Message = ex.Message,
                            Type = ex.GetType().Name,
                            #if DEBUG
                            Stacktrace = ex.ToString()
                            #endif
                        });
                        info.BodyWriter.Flush();
                    }
                }
                catch (Exception flex)
                {
                    Program.DataConnection.LogError("", "Reporting error gave error", flex);
                }
            }
        }

        public static void DoProcess(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session, string method, string module, string key)
        {
            using(var reqinfo = new RequestInfo(request, response, session))
                DoProcess(reqinfo, method, module, key);
        }
            
        public override bool Process(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
        {
            if (!request.Uri.AbsolutePath.StartsWith(API_URI_PATH, StringComparison.InvariantCultureIgnoreCase))
                return false;

            var module = request.Uri.Segments.Skip(API_URI_SEGMENTS).FirstOrDefault();
            if (string.IsNullOrWhiteSpace(module))
                module = "help";

            module = module.Trim('/');

            var key = string.Join("/", request.Uri.Segments.Skip(API_URI_SEGMENTS + 1)).Trim('/');

            var method = request.Method;
            if (!string.IsNullOrWhiteSpace(request.Headers["X-HTTP-Method-Override"]))
                method = request.Headers["X-HTTP-Method-Override"];

            DoProcess(request, response, session, method, module, key);

            return true;
        }
    }
 }
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/Acknowledgements.cs b/Duplicati/Server/WebServer/RESTMethods/Acknowledgements.cs
new file mode 100644
index 000000000..dbf437eb7
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Acknowledgements.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Acknowledgements : IRESTMethodGET, IRESTMethodDocumented
+    {
        private class GetResponse
        {
            public string Status;
            public string Acknowledgements;
        }

        public void GET(string key, RequestInfo info)
        {
            var path = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "acknowledgements.txt");
            info.OutputOK(new GetResponse() {
                Status = "OK",
                Acknowledgements = System.IO.File.ReadAllText(path)
            });            
        }

+        public string Description { get { return "Gets all acknowledgements"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(GetResponse)),
                };
            }
        }
    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Backup.cs b/Duplicati/Server/WebServer/RESTMethods/Backup.cs
new file mode 100644
index 000000000..c92a37e44
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Backup.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
using Duplicati.Server.Serialization;
using System.IO;
using System.Linq;
using Duplicati.Server.Serialization.Interface;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Backup : IRESTMethodGET, IRESTMethodPUT, IRESTMethodPOST, IRESTMethodDELETE, IRESTMethodDocumented
+    {
        public class GetResponse
        {
            public class GetResponseData
            {
                public Serialization.Interface.ISchedule Schedule;
                public Serialization.Interface.IBackup Backup;
                public Dictionary<string, string> DisplayNames;
            }
            
            public bool success;

            public GetResponseData data;
        }

        private void SearchFiles(IBackup backup, string filterstring, RequestInfo info)
        {
            var filter = (filterstring ?? "").Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);
            var timestring = info.Request.QueryString["time"].Value;
            var allversion = Duplicati.Library.Utility.Utility.ParseBool(info.Request.QueryString["all-versions"].Value, false);

            if (string.IsNullOrWhiteSpace(timestring) && !allversion)
            {
                info.ReportClientError("Invalid or missing time");
                return;
            }

            var prefixonly = Duplicati.Library.Utility.Utility.ParseBool(info.Request.QueryString["prefix-only"].Value, false);
            var foldercontents = Duplicati.Library.Utility.Utility.ParseBool(info.Request.QueryString["folder-contents"].Value, false);
            var time = new DateTime();
            if (!allversion)
                time = Duplicati.Library.Utility.Timeparser.ParseTimeInterval(timestring, DateTime.Now);

            var r = Runner.Run(Runner.CreateListTask(backup, filter, prefixonly, allversion, foldercontents, time), false) as Duplicati.Library.Interface.IListResults;

            var result = new Dictionary<string, object>();

            foreach(HttpServer.HttpInputItem n in info.Request.QueryString)
                result[n.Name] = n.Value;

            result["Filesets"] = r.Filesets;
            result["Files"] = r.Files;

            info.OutputOK(result);

        }

        private void ListFileSets(IBackup backup, RequestInfo info)
        {
            var input = info.Request.QueryString;
            var extra = new Dictionary<string, string>();
            extra["list-sets-only"] = "true";
            if (input["include-metadata"].Value != null)
                extra["list-sets-only"] = (!Library.Utility.Utility.ParseBool(input["include-metadata"].Value, false)).ToString();
            if (input["from-remote-only"].Value != null)
                extra["no-local-db"] = Library.Utility.Utility.ParseBool(input["from-remote-only"].Value, false).ToString();

            var r = Runner.Run(Runner.CreateTask(DuplicatiOperation.List, backup, extra), false) as Duplicati.Library.Interface.IListResults;

            info.OutputOK(r.Filesets);
        }

        private void FetchLogData(IBackup backup, RequestInfo info)
        {
            using(var con = (System.Data.IDbConnection)Activator.CreateInstance(Duplicati.Library.SQLiteHelper.SQLiteLoader.SQLiteConnectionType))
            {
                con.ConnectionString = "Data Source=" + backup.DBPath;
                con.Open();

                using(var cmd = con.CreateCommand())
                    info.OutputOK(LogData.DumpTable(cmd, "LogData", "ID", info.Request.QueryString["offset"].Value, info.Request.QueryString["pagesize"].Value));
            }
        }

        private void FetchRemoteLogData(IBackup backup, RequestInfo info)
        {
            using(var con = (System.Data.IDbConnection)Activator.CreateInstance(Duplicati.Library.SQLiteHelper.SQLiteLoader.SQLiteConnectionType))
            {
                con.ConnectionString = "Data Source=" + backup.DBPath;
                con.Open();

                using(var cmd = con.CreateCommand())
                {
                    var dt = LogData.DumpTable(cmd, "RemoteOperation", "ID", info.Request.QueryString["offset"].Value, info.Request.QueryString["pagesize"].Value);

                    // Unwrap raw data to a string
                    foreach(var n in dt)
                        try { n["Data"] = System.Text.Encoding.UTF8.GetString((byte[])n["Data"]); }
                    catch { }

                    info.OutputOK(dt);
                }
            }
        }

        private void Export(IBackup backup, RequestInfo info)
        {
            var cmdline = Library.Utility.Utility.ParseBool(info.Request.QueryString["cmdline"].Value, false);
            if (cmdline)
            {
                info.OutputOK(new { Command = Runner.GetCommandLine(Runner.CreateTask(DuplicatiOperation.Backup, backup)) });
            }
            else
            {
                var passphrase = info.Request.QueryString["passphrase"].Value;
                var ipx = Program.DataConnection.PrepareBackupForExport(backup);

                byte[] data;
                using(var ms = new System.IO.MemoryStream())
                using(var sw = new System.IO.StreamWriter(ms))
                {
                    Serializer.SerializeJson(sw, ipx, true);

                    if (!string.IsNullOrWhiteSpace(passphrase))
                    {
                        ms.Position = 0;
                        using(var ms2 = new System.IO.MemoryStream())
                        using(var m = new Duplicati.Library.Encryption.AESEncryption(passphrase, new Dictionary<string, string>()))
                        {
                            m.Encrypt(ms, ms2);
                            data = ms2.ToArray();
                        }
                    }
                    else
                        data = ms.ToArray();
                }

                var filename = Library.Utility.Uri.UrlEncode(backup.Name) + "-duplicati-config.json";
                if (!string.IsNullOrWhiteSpace(passphrase))
                    filename += ".aes";

                info.Response.ContentLength = data.Length;
                info.Response.AddHeader("Content-Disposition", string.Format("attachment; filename={0}", filename));
                info.Response.ContentType = "application/octet-stream";

                info.BodyWriter.SetOK();
                info.Response.SendHeaders();
                info.Response.SendBody(data);
            }
        }

        private void RestoreFiles(IBackup backup, RequestInfo info)
        {
            var input = info.Request.Form;

            var filters = input["paths"].Value.Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);
            var time = Duplicati.Library.Utility.Timeparser.ParseTimeInterval(input["time"].Value, DateTime.Now);
            var restoreTarget = input["restore-path"].Value;
            var overwrite = Duplicati.Library.Utility.Utility.ParseBool(input["overwrite"].Value, false);

            var permissions = Duplicati.Library.Utility.Utility.ParseBool(input["permissions"].Value, false);
            var skip_metadata = Duplicati.Library.Utility.Utility.ParseBool(input["skip-metadata"].Value, false);

            var task = Runner.CreateRestoreTask(backup, filters, time, restoreTarget, overwrite, permissions, skip_metadata);

            Program.WorkThread.AddTask(task);

            info.OutputOK(new { TaskID = task.TaskID });
        }

        private void CreateReport(IBackup backup, RequestInfo info)
        {
            var task = Runner.CreateTask(DuplicatiOperation.CreateReport, backup);
            Program.WorkThread.AddTask(task);
            Program.StatusEventNotifyer.SignalNewEvent();

            info.OutputOK(new { Status = "OK", ID = task.TaskID });
        }

        private void Repair(IBackup backup, RequestInfo info)
        {
            DoRepair(backup, info, false);
        }

        private void RepairUpdate(IBackup backup, RequestInfo info)
        {
            DoRepair(backup, info, true);
        }

        private void Verify(IBackup backup, RequestInfo info)
        {
            var task = Runner.CreateTask(DuplicatiOperation.Verify, backup);
            Program.WorkThread.AddTask(task);
            Program.StatusEventNotifyer.SignalNewEvent();

            info.OutputOK(new {Status = "OK", ID = task.TaskID});
        }

        private void DoRepair(IBackup backup, RequestInfo info, bool repairUpdate)
        {
            var input = info.Request.Form;
            string[] filters = null;
            var extra = new Dictionary<string, string>();
            if (input["only-paths"].Value != null)
                extra["repair-only-paths"] = (Library.Utility.Utility.ParseBool(input["only-paths"].Value, false)).ToString();
            if (input["time"].Value != null)
                extra["time"] = input["time"].Value;
            if (input["version"].Value != null)
                extra["version"] = input["version"].Value;
            if (input["paths"].Value != null)
                filters = input["paths"].Value.Split(new string[] { System.IO.Path.PathSeparator.ToString() }, StringSplitOptions.RemoveEmptyEntries);

            var task = Runner.CreateTask(repairUpdate ? DuplicatiOperation.RepairUpdate : DuplicatiOperation.Repair, backup, extra, filters);
            Program.WorkThread.AddTask(task);
            Program.StatusEventNotifyer.SignalNewEvent();

            info.OutputOK(new {Status = "OK", ID = task.TaskID});
        }

        private void RunBackup(IBackup backup, RequestInfo info)
        {
            var t = Program.WorkThread.CurrentTask;
            var bt = t == null ? null : t.Backup;
            if (bt != null && backup.ID == bt.ID)
            {
                // Already running
            }
            else if (Program.WorkThread.CurrentTasks.Where(x => { 
                var bn = x == null ? null : x.Backup;
                return bn == null || bn.ID == backup.ID;
            }).Any())
            {
                // Already in queue
            }
            else
            {
                Program.WorkThread.AddTask(Runner.CreateTask(DuplicatiOperation.Backup, backup));
                Program.StatusEventNotifyer.SignalNewEvent();
            }

            info.OutputOK();
        }

        private void IsActive(IBackup backup, RequestInfo info)
        {
            var t = Program.WorkThread.CurrentTask;
            var bt = t == null ? null : t.Backup;
            if (bt != null && backup.ID == bt.ID)
            {
                info.OutputOK(new { Status = "OK", Active = true });
                return;
            }
            else if (Program.WorkThread.CurrentTasks.Where(x =>
            { 
                var bn = x == null ? null : x.Backup;
                return bn == null || bn.ID == backup.ID;
            }).Any())
            {
                info.OutputOK(new { Status = "OK", Active = true });
                return;
            }
            else
            {
                info.OutputOK(new { Status = "OK", Active = false });
                return;
            }
        }
            
        public void GET(string key, RequestInfo info)
        {
            var parts = (key ?? "").Split(new char[] { '/' }, 2);
            var bk = Program.DataConnection.GetBackup(parts.First());
            if (bk == null)
                info.ReportClientError("Invalid or missing backup id");
            else
            {
                if (parts.Length > 1)
                {
                    var operation = parts.Last().Split(new char[] {'/'}).First().ToLowerInvariant();

                    switch (operation)
                    {
                        case "files":
                            SearchFiles(bk, parts.Last().Split(new char[] { '/' }, 2).LastOrDefault(), info);
                            return;
                        case "log":
                            FetchLogData(bk, info);
                            return;
                        case "remotelog":
                            FetchRemoteLogData(bk, info);
                            return;
                        case "filesets":
                            ListFileSets(bk, info);
                            return;
                        case "export":
                            Export(bk, info);
                            return;
                        case "isactive":
                            IsActive(bk, info);
                            return;
                        default:
                            info.ReportClientError(string.Format("Invalid component: {0}", operation));
                            return;
                    }

                }
                    
                var scheduleId = Program.DataConnection.GetScheduleIDsFromTags(new string[] { "ID=" + bk.ID });
                var schedule = scheduleId.Any() ? Program.DataConnection.GetSchedule(scheduleId.First()) : null;
                var sourcenames = SpecialFolders.GetSourceNames(bk);

                //TODO: Filter out the password in both settings and the target url

                info.OutputOK(new GetResponse()
                {
                    success = true,
                    data = new GetResponse.GetResponseData() {
                        Schedule = schedule,
                        Backup = bk,
                        DisplayNames = sourcenames
                    }
                });
            }
        }

        public void POST(string key, RequestInfo info)
        {
            var parts = (key ?? "").Split(new char[] { '/' }, 2);
            var bk = Program.DataConnection.GetBackup(parts.First());
            if (bk == null)
                info.ReportClientError("Invalid or missing backup id");
            else
            {
                if (parts.Length > 1)
                {
                    var operation = parts.Last().Split(new char[] { '/' }).First().ToLowerInvariant();

                    switch (operation)
                    {
                        case "deletedb":
                            System.IO.File.Delete(bk.DBPath);
                            info.OutputOK();
                            return;

                        case "restore":
                            RestoreFiles(bk, info);
                            return;

                        case "createreport":
                            CreateReport(bk, info);
                            return;

                        case "repair":
                            Repair(bk, info);
                            return;

                        case "repairupdate":
                            RepairUpdate(bk, info);
                            return;

                        case "verify":
                            Verify(bk, info);
                            return;

                        case "start":
                        case "run":
                            RunBackup(bk, info);
                            return;


                        case "copytotemp":
                            var ipx = Serializer.Deserialize<Database.Backup>(new StringReader(Newtonsoft.Json.JsonConvert.SerializeObject(bk)));

                            using(var tf = new Duplicati.Library.Utility.TempFile())
                                ipx.DBPath = tf;
                            ipx.ID = null;

                            info.OutputOK(new { status = "OK", ID = Program.DataConnection.RegisterTemporaryBackup(ipx) });
                            return;
                    }
                }

                info.ReportClientError("Invalid request");
            }
        }
            
        public void PUT(string key, RequestInfo info)
        {
            string str = info.Request.Form["data"].Value;
            if (string.IsNullOrWhiteSpace(str))
            {
                info.ReportClientError("Missing backup object");
                return;
            }

            Backups.AddOrUpdateBackupData data = null;
            try
            {
                data = Serializer.Deserialize<Backups.AddOrUpdateBackupData>(new StringReader(str));
                if (data.Backup == null)
                {
                    info.ReportClientError("Data object had no backup entry");
                    return;
                }

                if (!string.IsNullOrEmpty(key))
                    data.Backup.ID = key;

                if (string.IsNullOrEmpty(data.Backup.ID))
                {
                    info.ReportClientError("Invalid or missing backup id");
                    return;
                }          


                if (data.Backup.IsTemporary)
                {
                    var backup = Program.DataConnection.GetBackup(data.Backup.ID);
                    if (backup.IsTemporary)
                        throw new InvalidDataException("External is temporary but internal is not?");

                    Program.DataConnection.UpdateTemporaryBackup(backup);
                    info.OutputOK();
                }
                else
                {                    
                    lock(Program.DataConnection.m_lock)
                    {
                        var backup = Program.DataConnection.GetBackup(data.Backup.ID);
                        if (backup == null)
                        {
                            info.ReportClientError("Invalid or missing backup id");
                            return;
                        }

                        if (Program.DataConnection.Backups.Where(x => x.Name.Equals(data.Backup.Name, StringComparison.InvariantCultureIgnoreCase) && x.ID != data.Backup.ID).Any())
                        {
                            info.ReportClientError("There already exists a backup with the name: " + data.Backup.Name);
                            return;
                        }

                        //TODO: Merge in real passwords where the placeholder is found
                        Program.DataConnection.AddOrUpdateBackupAndSchedule(data.Backup, data.Schedule);

                    }

                    info.OutputOK();
                }
            }
            catch (Exception ex)
            {
                if (data == null)
                    info.ReportClientError(string.Format("Unable to parse backup or schedule object: {0}", ex.Message));
                else
                    info.ReportClientError(string.Format("Unable to save backup or schedule: {0}", ex.Message));

            }
        }

        public void DELETE(string key, RequestInfo info)
        {
            var backup = Program.DataConnection.GetBackup(key);
            if (backup == null)
            {
                info.ReportClientError("Invalid or missing backup id");
                return;
            }

            if (Program.WorkThread.Active)
            {
                try
                {
                    //TODO: It's not safe to access the values like this, 
                    //because the runner thread might interfere
                    var nt = Program.WorkThread.CurrentTask;
                    if (backup.Equals(nt == null ? null : nt.Backup))
                    {
                        bool force;
                        if (!bool.TryParse(info.Request.QueryString["force"].Value, out force))
                            force = false;

                        if (!force)
                        {
                            info.OutputError(new { status = "failed", reason = "backup-in-progress" });
                            return;
                        }

                        bool hasPaused = Program.LiveControl.State == LiveControls.LiveControlState.Paused;
                        Program.LiveControl.Pause();

                        try
                        {
                            for(int i = 0; i < 10; i++)
                                if (Program.WorkThread.Active)
                                {
                                    var t = Program.WorkThread.CurrentTask;
                                    if (backup.Equals(t == null ? null : t.Backup))
                                        System.Threading.Thread.Sleep(1000);
                                    else
                                        break;
                                }
                                else
                                    break;
                        }
                        finally
                        {
                        }

                        if (Program.WorkThread.Active)
                        {
                            var t = Program.WorkThread.CurrentTask;
                            if (backup.Equals(t == null ? null : t.Backup))
                            {
                                if (hasPaused)
                                    Program.LiveControl.Resume();
                                info.OutputError(new { status = "failed", reason = "backup-unstoppable" });
                                return;
                            }
                        }

                        if (hasPaused)
                            Program.LiveControl.Resume();
                    }
                }
                catch (Exception ex)
                {
                    info.OutputError(new { status = "error", message = ex.Message });
                    return;
                }
            }


            //var dbpath = backup.DBPath;
            Program.DataConnection.DeleteBackup(backup);

            // TODO: Before we activate this, 
            // we need some strategy to figure out
            // if the db is shared with something else
            // like the commandline or another backup
            /*try
            {
                if (System.IO.File.Exists(dbpath))
                    System.IO.File.Delete(dbpath);
            }
            catch (Exception ex)
            {
                Program.DataConnection.LogError(null, string.Format("Failed to delete database: {0}", dbpath), ex);
            }*/

            //We have fiddled with the schedules
            Program.Scheduler.Reschedule();

            info.OutputOK();
        }

+        public string Description { get { return "Retrieves, updates or deletes an existing backup and schedule"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(GetResponse)),
                    new KeyValuePair<string, Type>(HttpServer.Method.Put, typeof(Backups.AddOrUpdateBackupData)),
                    new KeyValuePair<string, Type>(HttpServer.Method.Delete, typeof(long))
                };
            }
        }
    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/BackupDefaults.cs b/Duplicati/Server/WebServer/RESTMethods/BackupDefaults.cs
new file mode 100644
index 000000000..a6841c568
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/BackupDefaults.cs
@@ -0,0 +1,27 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class BackupDefaults : IRESTMethodGET
+    {
+        public void GET(string key, RequestInfo info)
        {
            // Start with a scratch object
            var o = new Newtonsoft.Json.Linq.JObject();

            // Add application wide settings
            o.Add("ApplicationOptions", new Newtonsoft.Json.Linq.JArray(
                from n in Program.DataConnection.Settings
                select Newtonsoft.Json.Linq.JObject.FromObject(n)
            ));

            try
            {
                // Add built-in defaults
                Newtonsoft.Json.Linq.JObject n;
                using(var s = new System.IO.StreamReader(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name + ".newbackup.json")))
                    n = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(s.ReadToEnd());

                MergeJsonObjects(o, n);
            }
            catch
            {
            }

            try
            {
                // Add install defaults/overrides, if present
                var path = System.IO.Path.Combine(Duplicati.Library.AutoUpdater.UpdaterManager.InstalledBaseDir, "newbackup.json");
                if (System.IO.File.Exists(path))
                {
                    Newtonsoft.Json.Linq.JObject n;
                    n = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(System.IO.File.ReadAllText(path));

                    MergeJsonObjects(o, n);
                }
            }
            catch
            {
            }

            info.OutputOK(new
            {
                success = true,
                data = o
            });            
+        }

        private static void MergeJsonObjects(Newtonsoft.Json.Linq.JObject self, Newtonsoft.Json.Linq.JObject other)
        {
            foreach(var p in other.Properties())
            {
                var sp = self.Property(p.Name);
                if (sp == null)
                    self.Add(p);
                else
                {
                    switch (p.Type)
                    {
                        // Primitives override
                        case Newtonsoft.Json.Linq.JTokenType.Boolean:
                        case Newtonsoft.Json.Linq.JTokenType.Bytes:
                        case Newtonsoft.Json.Linq.JTokenType.Comment:
                        case Newtonsoft.Json.Linq.JTokenType.Constructor:
                        case Newtonsoft.Json.Linq.JTokenType.Date:
                        case Newtonsoft.Json.Linq.JTokenType.Float:
                        case Newtonsoft.Json.Linq.JTokenType.Guid:
                        case Newtonsoft.Json.Linq.JTokenType.Integer:
                        case Newtonsoft.Json.Linq.JTokenType.String:
                        case Newtonsoft.Json.Linq.JTokenType.TimeSpan:
                        case Newtonsoft.Json.Linq.JTokenType.Uri:
                        case Newtonsoft.Json.Linq.JTokenType.None:
                        case Newtonsoft.Json.Linq.JTokenType.Null:
                        case Newtonsoft.Json.Linq.JTokenType.Undefined:
                            self.Replace(p);
                            break;

                            // Arrays merge
                        case Newtonsoft.Json.Linq.JTokenType.Array:
                            if (sp.Type == Newtonsoft.Json.Linq.JTokenType.Array)
                                sp.Value = new Newtonsoft.Json.Linq.JArray(((Newtonsoft.Json.Linq.JArray)sp.Value).Union((Newtonsoft.Json.Linq.JArray)p.Value));
                            else
                            {
                                var a = new Newtonsoft.Json.Linq.JArray(sp.Value);
                                sp.Value = new Newtonsoft.Json.Linq.JArray(a.Union((Newtonsoft.Json.Linq.JArray)p.Value));
                            }

                            break;

                            // Objects merge
                        case Newtonsoft.Json.Linq.JTokenType.Object:
                            if (sp.Type == Newtonsoft.Json.Linq.JTokenType.Object)
                                MergeJsonObjects((Newtonsoft.Json.Linq.JObject)sp.Value, (Newtonsoft.Json.Linq.JObject)p.Value);
                            else
                                sp.Value = p.Value;
                            break;

                            // Ignore other stuff                                
                        default:
                            break;
                    }
                }
            }
        }

+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Backups.cs b/Duplicati/Server/WebServer/RESTMethods/Backups.cs
index 817fbec5d..354119c2a 100644
--- a/Duplicati/Server/WebServer/RESTMethods/Backups.cs
+++ b/Duplicati/Server/WebServer/RESTMethods/Backups.cs
@@ -14,12 +14,12 @@
 //  You should have received a copy of the GNU Lesser General Public
 //  License along with this library; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
using System.Linq;
using System.Collections.Generic;
+using System;
using System.Linq;
using System.Collections.Generic;
using Duplicati.Server.Serialization;
using System.IO;
 
 namespace Duplicati.Server.WebServer.RESTMethods
 {
-    public class Backups : IRESTMethodGET, IRESTMethodDocumented
-    {
        private class AddOrUpdateBackupData
        {
            public Database.Schedule Schedule { get; set;}
            public Database.Backup Backup { get; set;}
        }

        public void GET(string key, RequestInfo info)
        {
            var schedules = Program.DataConnection.Schedules;
            var backups = Program.DataConnection.Backups;

            var all = from n in backups
                select new AddOrUpdateBackupData() {
                Backup = (Database.Backup)n,
                Schedule = 
                    (from x in schedules
                        where x.Tags != null && x.Tags.Contains("ID=" + n.ID)
                        select (Database.Schedule)x).FirstOrDefault()
                };

            info.BodyWriter.OutputOK(all.ToArray());
        }

-        public string Description { get { return "Return a list of current backups and their schedules"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(AddOrUpdateBackupData[]))
                };
            }
        }
    }
+    public class Backups : IRESTMethodGET, IRESTMethodPOST, IRESTMethodDocumented
+    {
        public class AddOrUpdateBackupData
        {
            public Database.Schedule Schedule { get; set;}
            public Database.Backup Backup { get; set;}
        }

        public void GET(string key, RequestInfo info)
        {
            var schedules = Program.DataConnection.Schedules;
            var backups = Program.DataConnection.Backups;

            var all = from n in backups
                select new AddOrUpdateBackupData() {
                Backup = (Database.Backup)n,
                Schedule = 
                    (from x in schedules
                        where x.Tags != null && x.Tags.Contains("ID=" + n.ID)
                        select (Database.Schedule)x).FirstOrDefault()
                };

            info.BodyWriter.OutputOK(all.ToArray());
        }

        private void ImportBackup(RequestInfo info)
        {
            var output_template = "<html><body><script type=\"text/javascript\">var rp = null; try { rp = parent['CBM']; } catch (e) {}; rp = rp || alert; rp('MSG');</script></body></html>";
            //output_template = "<html><body><script type=\"text/javascript\">alert('MSG');</script></body></html>";
            try
            {
                var input = info.Request.Form;
                var cmdline = Library.Utility.Utility.ParseBool(input["cmdline"].Value, false);
                output_template = output_template.Replace("CBM", input["callback"].Value);
                if (cmdline)
                {
                    info.Response.ContentType = "text/html";
                    info.BodyWriter.Write(output_template.Replace("MSG", "Import from commandline not yet implemented"));
                }
                else
                {
                    Serializable.ImportExportStructure ipx;

                    var file = info.Request.Form.GetFile("config");
                    if (file == null)
                        throw new Exception("No file uploaded");

                    var buf = new byte[3];
                    using(var fs = System.IO.File.OpenRead(file.Filename))
                    {
                        fs.Read(buf, 0, buf.Length);

                        fs.Position = 0;
                        if (buf[0] == 'A' && buf[1] == 'E' && buf[2] == 'S')
                        {
                            var passphrase = input["passphrase"].Value;
                            using(var m = new Duplicati.Library.Encryption.AESEncryption(passphrase, new Dictionary<string, string>()))
                            using(var m2 = m.Decrypt(fs))
                            using(var sr = new System.IO.StreamReader(m2))
                                ipx = Serializer.Deserialize<Serializable.ImportExportStructure>(sr);
                        }
                        else
                        {
                            using(var sr = new System.IO.StreamReader(fs))
                                ipx = Serializer.Deserialize<Serializable.ImportExportStructure>(sr);
                        }
                    }

                    ipx.Backup.ID = null;
                    ((Database.Backup)ipx.Backup).DBPath = null;

                    if (ipx.Schedule != null)
                        ipx.Schedule.ID = -1;

                    lock(Program.DataConnection.m_lock)
                    {
                        var basename = ipx.Backup.Name;
                        var c = 0;
                        while (c++ < 100 && Program.DataConnection.Backups.Where(x => x.Name.Equals(ipx.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
                            ipx.Backup.Name = basename + " (" + c.ToString() + ")"; 

                        if (Program.DataConnection.Backups.Where(x => x.Name.Equals(ipx.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
                        {
                            info.BodyWriter.SetOK();
                            info.Response.ContentType = "text/html";
                            info.BodyWriter.Write(output_template.Replace("MSG", "There already exists a backup with the name: " + basename.Replace("\'", "\\'")));
                        }

                        Program.DataConnection.AddOrUpdateBackupAndSchedule(ipx.Backup, ipx.Schedule);
                    }

                    info.Response.ContentType = "text/html";
                    info.BodyWriter.Write(output_template.Replace("MSG", "OK"));

                    //bw.OutputOK(new { status = "OK", ID = ipx.Backup.ID });
                }
            }
            catch (Exception ex)
            {
                Program.DataConnection.LogError("", "Failed to import backup", ex);
                info.Response.ContentType = "text/html";
                info.BodyWriter.Write(output_template.Replace("MSG", ex.Message.Replace("\'", "\\'").Replace("\r", "\\r").Replace("\n", "\\n")));
            }            
        }

        public void POST(string key, RequestInfo info)
        {
            if ("import".Equals(key, StringComparison.InvariantCultureIgnoreCase))
            {
                ImportBackup(info);
                return;
            }

            AddOrUpdateBackupData data = null;
            try
            {
                data = Serializer.Deserialize<AddOrUpdateBackupData>(new StringReader(info.Request.Form["data"].Value));
                if (data.Backup == null)
                {
                    info.ReportClientError("Data object had no backup entry");
                    return;
                }

                data.Backup.ID = null;

                if (Duplicati.Library.Utility.Utility.ParseBool(info.Request.Form["temporary"].Value, false))
                {
                    using(var tf = new Duplicati.Library.Utility.TempFile())
                        data.Backup.DBPath = tf;

                    Program.DataConnection.RegisterTemporaryBackup(data.Backup);

                    info.OutputOK(new { status = "OK", ID = data.Backup.ID });
                }
                else
                {
                    if (Library.Utility.Utility.ParseBool(info.Request.Form["existing_db"].Value, false))
                    {
                        data.Backup.DBPath = Library.Main.DatabaseLocator.GetDatabasePath(data.Backup.TargetURL, null, false, false);
                        if (string.IsNullOrWhiteSpace(data.Backup.DBPath))
                            throw new Exception("Unable to find remote db path?");
                    }


                    lock(Program.DataConnection.m_lock)
                    {
                        if (Program.DataConnection.Backups.Where(x => x.Name.Equals(data.Backup.Name, StringComparison.InvariantCultureIgnoreCase)).Any())
                        {
                            info.ReportClientError("There already exists a backup with the name: " + data.Backup.Name);
                            return;
                        }

                        Program.DataConnection.AddOrUpdateBackupAndSchedule(data.Backup, data.Schedule);
                    }

                    info.OutputOK(new { status = "OK", ID = data.Backup.ID });
                }
            }
            catch (Exception ex)
            {
                if (data == null)
                    info.ReportClientError(string.Format("Unable to parse backup or schedule object: {0}", ex.Message));
                else
                    info.ReportClientError(string.Format("Unable to save schedule or backup object: {0}", ex.Message));
            }
        }


+        public string Description { get { return "Return a list of current backups and their schedules"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(AddOrUpdateBackupData[])),
                    new KeyValuePair<string, Type>(HttpServer.Method.Post, typeof(AddOrUpdateBackupData))
                };
            }
        }
    }
 }
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/BugReport.cs b/Duplicati/Server/WebServer/RESTMethods/BugReport.cs
new file mode 100644
index 000000000..49b248ce6
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/BugReport.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class BugReport : IRESTMethodGET
+    {
        public void GET(string key, RequestInfo info)
        {
            long id;
            long.TryParse(key, out id);

            var tf = Program.DataConnection.GetTempFiles().Where(x => x.ID == id).FirstOrDefault();
            if (tf == null)
            {
                info.ReportClientError("Invalid or missing backup id");
                return;
            }

            if (!System.IO.File.Exists(tf.Path))
            {
                info.ReportClientError("File is missing");
                return;
            }

            var filename = "bugreport.zip";
            using(var fs = System.IO.File.OpenRead(tf.Path))
            {
                info.Response.ContentLength = fs.Length;
                info.Response.AddHeader("Content-Disposition", string.Format("attachment; filename={0}", filename));
                info.Response.ContentType = "application/octet-stream";

                info.BodyWriter.SetOK();
                info.Response.SendHeaders();
                fs.CopyTo(info.Response.Body);
                info.Response.Send();
            }
        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Changelog.cs b/Duplicati/Server/WebServer/RESTMethods/Changelog.cs
new file mode 100644
index 000000000..81194afa0
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Changelog.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Changelog : IRESTMethodGET, IRESTMethodDocumented
+    {
        private class GetResponse
        {
            public string Status;
            public string Version;
            public string Changelog;
        }

        public void GET(string key, RequestInfo info)
        {
            var fromUpdate = info.Request.QueryString["from-update"].Value;
            if (!Library.Utility.Utility.ParseBool(fromUpdate, false))
            {
                var path = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "changelog.txt");
                info.OutputOK(new GetResponse() {
                    Status = "OK",
                    Version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(),
                    Changelog = System.IO.File.ReadAllText(path)
                });
            }
            else
            {
                var updateInfo = Program.DataConnection.ApplicationSettings.UpdatedVersion;
                if (updateInfo == null)
                {
                    info.ReportClientError("No update found");
                }
                else
                {
                    info.OutputOK(new GetResponse() {
                        Status = "OK",
                        Version = updateInfo.Version,
                        Changelog = updateInfo.ChangeInfo
                    });
                }
            }
        }

        public string Description { get { return "Gets the current changelog"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(GetResponse)),
                };
            }
        }

+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Filesystem.cs b/Duplicati/Server/WebServer/RESTMethods/Filesystem.cs
new file mode 100644
index 000000000..9274a0a2a
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Filesystem.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Filesystem : IRESTMethodGET, IRESTMethodDocumented
+    {
        public void GET(string key, RequestInfo info)
        {
            var parts = (key ?? "").Split(new char[] { '/' });
            var path =  Duplicati.Library.Utility.Uri.UrlDecode((parts.Length == 2 ? parts.FirstOrDefault() : key ?? ""));
            var command = parts.Length == 2 ? parts.Last() : null;

            if (string.IsNullOrEmpty(path))
            {
                info.ReportClientError("No path parameter was found");
                return;
            }

            bool skipFiles = Library.Utility.Utility.ParseBool(info.Request.QueryString["onlyfolders"].Value, false);

            string specialpath = null;
            string specialtoken = null;

            if (path.StartsWith("%"))
            {
                var ix = path.IndexOf("%", 1);
                if (ix > 0)
                {
                    var tk = path.Substring(0, ix + 1);
                    var node = SpecialFolders.Nodes.Where(x => x.id.Equals(tk, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
                    if (node != null)
                    {
                        specialpath = node.resolvedpath;
                        specialtoken = node.id;
                    }
                }
            }

            path = SpecialFolders.ExpandEnvironmentVariables(path);

            if (Duplicati.Library.Utility.Utility.IsClientLinux && !path.StartsWith("/"))
            {
                info.ReportClientError("The path parameter must start with a forward-slash");
                return;
            }

            if (!string.IsNullOrWhiteSpace(command))
            {
                if ("validate".Equals(command, StringComparison.InvariantCultureIgnoreCase))
                {
                    try
                    {
                        if (System.IO.Path.IsPathRooted(path) && System.IO.Directory.Exists(path))
                        {
                            info.OutputOK();
                            return;
                        }
                    }
                    catch
                    {
                    }

                    info.ReportServerError("File or folder not found");
                    return;
                }
                else
                {
                    info.ReportClientError(string.Format("No such operation found: {0}", command));
                    return;
                }
            }

            try
            {
                if (path != "" && path != "/")
                    path = Duplicati.Library.Utility.Utility.AppendDirSeparator(path);

                IEnumerable<Serializable.TreeNode> res;

                if (!Library.Utility.Utility.IsClientLinux && (path.Equals("/") || path.Equals("")))
                {
                    res = 
                        from di in System.IO.DriveInfo.GetDrives()
                            where di.DriveType == DriveType.Fixed || di.DriveType == DriveType.Network || di.DriveType == DriveType.Removable
                        select new Serializable.TreeNode()
                    {
                        id = di.RootDirectory.FullName,
                        text = di.RootDirectory.FullName.Replace('\\', ' ') + "(" + di.DriveType + ")",
                        iconCls = "x-tree-icon-drive"
                    };
                }
                else
                {
                    res = ListFolderAsNodes(path, skipFiles);                        
                }

                if ((path.Equals("/") || path.Equals("")) && specialtoken == null) 
                {
                    // Prepend special folders
                    res = SpecialFolders.Nodes.Union(res);
                }

                if (specialtoken != null)
                {
                    res = from n in res
                        select new Serializable.TreeNode() {
                        id = specialtoken + n.id.Substring(specialpath.Length),
                        text = n.text,
                        iconCls = n.iconCls,
                        leaf = n.leaf,
                        resolvedpath = n.id
                    };
                }

                info.OutputOK(res);
            }
            catch (Exception ex)
            {
                info.ReportClientError("Failed to process the path: " + ex.Message);
            }
        }

        private static IEnumerable<Serializable.TreeNode> ListFolderAsNodes(string entrypath, bool skipFiles)
        {
            //Helper function for finding out if a folder has sub elements
            Func<string, bool> hasSubElements = (p) => skipFiles ? Directory.EnumerateDirectories(p).Any() : Directory.EnumerateFileSystemEntries(p).Any();

            //Helper function for dealing with exceptions when accessing off-limits folders
            Func<string, bool> isEmptyFolder = (p) =>
            {
                try { return !hasSubElements(p); }
                catch { }
                return true;
            };

            //Helper function for dealing with exceptions when accessing off-limits folders
            Func<string, bool> canAccess = (p) =>
            {
                try { hasSubElements(p); return true; }
                catch { }
                return false;
            }; 

            var systemIO = Library.Utility.Utility.IsClientLinux
                ? (Duplicati.Library.Snapshots.ISystemIO)new Duplicati.Library.Snapshots.SystemIOLinux() 
                : (Duplicati.Library.Snapshots.ISystemIO)new Duplicati.Library.Snapshots.SystemIOWindows();

            foreach (var s in System.IO.Directory.EnumerateFileSystemEntries(entrypath))
            {
                Serializable.TreeNode tn = null;
                try
                {
                    var attr = systemIO.GetFileAttributes(s);
                    //var isSymlink = (attr & FileAttributes.ReparsePoint) != 0;
                    var isFolder = (attr & FileAttributes.Directory) != 0;
                    var isFile = !isFolder;
                    //var isHidden = (attr & FileAttributes.Hidden) != 0;

                    var accesible = isFile || canAccess(s);
                    var isLeaf = isFile || !accesible || isEmptyFolder(s);

                    var rawid = isFolder ? Library.Utility.Utility.AppendDirSeparator(s) : s;
                    if (!skipFiles || isFolder)
                        tn = new Serializable.TreeNode()
                    {
                        id = rawid,
                        text = systemIO.PathGetFileName(s),
                        iconCls = isFolder ? (accesible ? "x-tree-icon-parent" : "x-tree-icon-locked") : "x-tree-icon-leaf",
                        leaf = isLeaf
                    };
                }
                catch
                {
                }

                if (tn != null)
                    yield return tn;
            }
        }

        public string Description { get { return "Enumerates the server filesystem"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(string[])),
                };
            }
        }

+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/IRESTMethod.cs b/Duplicati/Server/WebServer/RESTMethods/IRESTMethod.cs
index fe13d1496..51a60fcf2 100644
--- a/Duplicati/Server/WebServer/RESTMethods/IRESTMethod.cs
+++ b/Duplicati/Server/WebServer/RESTMethods/IRESTMethod.cs
@@ -20,5 +20,5 @@ namespace Duplicati.Server.WebServer.RESTMethods
 {
     public interface IRESTMethod
     {
    }

    public interface IRESTMethodDocumented
    {
        string Description { get; }
        IEnumerable<KeyValuePair<string, Type>> Types { get; }
    }

    public interface IRESTMethodGET : IRESTMethod
    {
        void GET(string key, RequestInfo info);
    }

-    public interface IRESTMethodPUT : IRESTMethod
    {
        void PUT(string key, RequestInfo info);
    }

    public interface IRESTMethodPOST : IRESTMethod
    {
        void POST(string key, RequestInfo info);
    }

    public interface IRESTMethodDELETE : IRESTMethod
    {
        void DELETE(string key, RequestInfo info);
    }
}
+    public interface IRESTMethodPUT : IRESTMethod
    {
        void PUT(string key, RequestInfo info);
    }

    public interface IRESTMethodPOST : IRESTMethod
    {
        void POST(string key, RequestInfo info);
    }

    public interface IRESTMethodDELETE : IRESTMethod
    {
        void DELETE(string key, RequestInfo info);
    }

    public interface IRESTMethodPATCH : IRESTMethod
    {
        void PATCH(string key, RequestInfo info);
    }
}
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/Localizations.cs b/Duplicati/Server/WebServer/RESTMethods/Localizations.cs
new file mode 100644
index 000000000..fd7a69a69
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Localizations.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Localizations : IRESTMethodGET, IRESTMethodDocumented
+    {
+        public void GET(string key, RequestInfo info)
        {
            info.OutputOK(new Dictionary<string, string>());
        }

        public string Description { get { return "Returns a list of localizable strings."; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(Dictionary<string, string>))
                };
            }
        }    
    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/LogData.cs b/Duplicati/Server/WebServer/RESTMethods/LogData.cs
new file mode 100644
index 000000000..e5652e410
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/LogData.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class LogData : IRESTMethodGET, IRESTMethodDocumented
+    {
        public void GET(string key, RequestInfo info)
        {
            if ("poll".Equals(key, StringComparison.InvariantCultureIgnoreCase))
            {
                var input = info.Request.QueryString;
                var level_str = input["level"].Value ?? "";
                var id_str = input["id"].Value ?? "";

                Library.Logging.LogMessageType level;
                long id;

                long.TryParse(id_str, out id);
                Enum.TryParse(level_str, true, out level);

                info.OutputOK(Program.LogHandler.AfterID(id, level));
            }
            else
            {

                List<Dictionary<string, object>> res = null;
                Program.DataConnection.ExecuteWithCommand(x =>
                {
                    res = DumpTable(x, "ErrorLog", "Timestamp", info.Request.QueryString["offset"].Value, info.Request.QueryString["pagesize"].Value);
                });

                info.OutputOK(res);
            }
        }


        public static List<Dictionary<string, object>> DumpTable(System.Data.IDbCommand cmd, string tablename, string pagingfield, string offset_str, string pagesize_str)
        {
            var result = new List<Dictionary<string, object>>();

            long pagesize;
            if (!long.TryParse(pagesize_str, out pagesize))
                pagesize = 100;

            pagesize = Math.Max(10, Math.Min(500, pagesize));

            cmd.CommandText = "SELECT * FROM \"" + tablename + "\"";
            long offset = 0;
            if (!string.IsNullOrWhiteSpace(offset_str) && long.TryParse(offset_str, out offset) && !string.IsNullOrEmpty(pagingfield))
            {
                var p = cmd.CreateParameter();
                p.Value = offset;
                cmd.Parameters.Add(p);

                cmd.CommandText += " WHERE \"" + pagingfield + "\" < ?";
            }

            if (!string.IsNullOrEmpty(pagingfield))
                cmd.CommandText += " ORDER BY \"" + pagingfield + "\" DESC";
            cmd.CommandText += " LIMIT " + pagesize.ToString();

            using(var rd = cmd.ExecuteReader())
            {
                var names = new List<string>();
                for(var i = 0; i < rd.FieldCount; i++)
                    names.Add(rd.GetName(i));

                while (rd.Read())
                {
                    var dict = new Dictionary<string, object>();
                    for(int i = 0; i < names.Count; i++)
                        dict[names[i]] = rd.GetValue(i);

                    result.Add(dict);                                    
                }
            }

            return result;
        }

        public string Description { get { return "Retrieves system log data"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(Dictionary<string, string>[])),
                };
            }
        }

+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Notification.cs b/Duplicati/Server/WebServer/RESTMethods/Notification.cs
new file mode 100644
index 000000000..bd44c3878
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Notification.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Notification : IRESTMethodGET, IRESTMethodDELETE
+    {
+        public void GET(string key, RequestInfo info)
        {
            long id;
            if (!long.TryParse(key, out id))
            {
                info.ReportClientError("Invalid ID");
                return;
            }

            var el = Program.DataConnection.GetNotifications().Where(x => x.ID == id).FirstOrDefault();
            if (el == null)
                info.ReportClientError("No such notification", System.Net.HttpStatusCode.NotFound);
            else
                info.OutputOK(el);
        }

        public void DELETE(string key, RequestInfo info)
        {
            long id;
            if (!long.TryParse(key, out id))
            {
                info.ReportClientError("Invalid ID");
                return;
            }

            var el = Program.DataConnection.GetNotifications().Where(x => x.ID == id).FirstOrDefault();
            if (el == null)
                info.ReportClientError("No such notification", System.Net.HttpStatusCode.NotFound);
            else
            {
                Program.DataConnection.DismissNotification(id);
                info.OutputOK();
            }
        }
    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Notifications.cs b/Duplicati/Server/WebServer/RESTMethods/Notifications.cs
new file mode 100644
index 000000000..d35d9577b
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Notifications.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Notifications : IRESTMethodGET
+    {
        public void GET(string key, RequestInfo info)
        {
            info.OutputOK(Program.DataConnection.GetNotifications());
        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/ProgressState.cs b/Duplicati/Server/WebServer/RESTMethods/ProgressState.cs
index e88c65962..723cf811b 100644
--- a/Duplicati/Server/WebServer/RESTMethods/ProgressState.cs
+++ b/Duplicati/Server/WebServer/RESTMethods/ProgressState.cs
@@ -20,6 +20,6 @@ namespace Duplicati.Server.WebServer.RESTMethods
 {
     public class ProgressState : IRESTMethodGET, IRESTMethodDocumented
     {
-        public void GET(string key, RequestInfo info)
        {
            if (Program.GenerateProgressState == null)
                info.ReportError("No active backup");
            else
                info.OutputOK(Program.GenerateProgressState());
        }

        public string Description { get { return "Return the progress of the currently running operation."; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(Serialization.Interface.IProgressEventData))
                };
            }
        }    
    }
+        public void GET(string key, RequestInfo info)
        {
            if (Program.GenerateProgressState == null)
                info.ReportClientError("No active backup");
            else
                info.OutputOK(Program.GenerateProgressState());
        }

        public string Description { get { return "Return the progress of the currently running operation."; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(Serialization.Interface.IProgressEventData))
                };
            }
        }    
    }
 }
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/RemoteOperation.cs b/Duplicati/Server/WebServer/RESTMethods/RemoteOperation.cs
new file mode 100644
index 000000000..9148d1f0c
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/RemoteOperation.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class RemoteOperation : IRESTMethodGET
+    {
        private void LocateDbUri(string uri, RequestInfo info)
        {
            var path = Library.Main.DatabaseLocator.GetDatabasePath(uri, null, false, false);
            info.OutputOK(new {
                Exists = !string.IsNullOrWhiteSpace(path),
                Path = path
            });
        }

        private void CreateFolder(string uri, RequestInfo info)
        {
            using(var b = Duplicati.Library.DynamicLoader.BackendLoader.GetBackend(uri, new Dictionary<string, string>()))
                b.CreateFolder();

            info.OutputOK();
        }

        private void ListFolder(string uri, RequestInfo info)
        {
            using(var b = Duplicati.Library.DynamicLoader.BackendLoader.GetBackend(uri, new Dictionary<string, string>()))
                info.OutputOK(b.List());
        }

        private void TestConnection(string url, RequestInfo info)
        {
            
            var modules = (from n in Library.DynamicLoader.GenericLoader.Modules
                where n is Library.Interface.IConnectionModule
                select n).ToArray();

            try
            {
                var uri = new Library.Utility.Uri(url);
                var qp = uri.QueryParameters;

                var opts = new Dictionary<string, string>();
                foreach(var k in qp.Keys.Cast<string>())
                    opts[k] = qp[k];

                foreach(var n in modules)
                    n.Configure(opts);
                    
                using(var b = Duplicati.Library.DynamicLoader.BackendLoader.GetBackend(url, new Dictionary<string, string>()))
                    b.Test();
                
                info.OutputOK();
            }
            catch (Duplicati.Library.Interface.FolderMissingException)
            {
                info.ReportServerError("missing-folder");
            }
            catch (Duplicati.Library.Utility.SslCertificateValidator.InvalidCertificateException icex)
            {
                if (string.IsNullOrWhiteSpace(icex.Certificate))
                    info.ReportServerError(icex.Message);
                else
                    info.ReportServerError("incorrect-cert:" + icex.Certificate);
            }
            finally
            {
                foreach(var n in modules)
                    if (n is IDisposable)
                        ((IDisposable)n).Dispose();
            }
        }

        public void GET(string key, RequestInfo info)
        {
            var parts = (key ?? "").Split(new char[] { '/' }, 2);

            if (parts.Length <= 1)
            {
                info.ReportClientError("No url or operation supplied");
                return;
            }

            var url = Library.Utility.Uri.UrlDecode(parts.First());
            var operation = parts.Last().ToLowerInvariant();

            switch (operation)
            {
                case "dbpath":
                    LocateDbUri(url, info);
                    return;
                case "list":
                    ListFolder(url, info);
                    return;
                case "create":
                    CreateFolder(url, info);
                    return;
                case "test":
                    TestConnection(url, info);
                    return;
            }


        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/RequestInfo.cs b/Duplicati/Server/WebServer/RESTMethods/RequestInfo.cs
index 8e9c22444..1b7e42383 100644
--- a/Duplicati/Server/WebServer/RESTMethods/RequestInfo.cs
+++ b/Duplicati/Server/WebServer/RESTMethods/RequestInfo.cs
@@ -21,7 +21,7 @@ namespace Duplicati.Server.WebServer.RESTMethods
     public class RequestInfo : IDisposable
     {
        public HttpServer.IHttpRequest Request { get; private set; }
        public HttpServer.IHttpResponse Response { get; private set; }
        public HttpServer.Sessions.IHttpSession Session { get; private set; }
        public BodyWriter BodyWriter { get; private set; }

         public RequestInfo(HttpServer.IHttpRequest request, HttpServer.IHttpResponse response, HttpServer.Sessions.IHttpSession session)
-        {
            Request = request;
            Response = response;
            Session = session;
            BodyWriter = new BodyWriter(response);
-        }

        public void ReportError(string message)
        {
            Response.Status = System.Net.HttpStatusCode.InternalServerError;
            Response.Reason = message;

            BodyWriter.WriteJsonObject(new { Error = message });
        }

        public bool LongPollCheck(EventPollNotify poller, ref long id, out bool isError)
        {
            HttpServer.HttpInput input = Request.Method.ToUpper() == "POST" ? Request.Form : Request.QueryString;
            if (Library.Utility.Utility.ParseBool(input["longpoll"].Value, false))
            {
                long lastEventId;
                if (!long.TryParse(input["lasteventid"].Value, out lastEventId))
                {
                    ReportError("When activating long poll, the request must include the last event id");
                    isError = true;
                    return false;
                }

                TimeSpan ts;
                try { ts = Library.Utility.Timeparser.ParseTimeSpan(input["duration"].Value); }
                catch (Exception ex)
                {
                    ReportError("Invalid duration: " + ex.Message);
                    isError = true;
                    return false;
                }

                if (ts <= TimeSpan.FromSeconds(10) || ts.TotalMilliseconds > int.MaxValue)
                {
                    ReportError("Invalid duration, must be at least 10 seconds, and less than " + int.MaxValue + " milliseconds");
                    isError = true;
                    return false;
                }

                isError = false;
                id = poller.Wait(lastEventId, (int)ts.TotalMilliseconds);
                return true;
            }

            isError = false;
            return false;
        }

        public void OutputOK(object item = null)
        {
            BodyWriter.OutputOK(item);
        }

        public void Dispose()
        {
            if (BodyWriter != null)
            {
                var bw = BodyWriter;
                BodyWriter = null;
                bw.Dispose();
            }
        }
    }
+        {
            Request = request;
            Response = response;
            Session = session;
            BodyWriter = new BodyWriter(response, request);
+        }

        public void ReportServerError(string message, System.Net.HttpStatusCode code = System.Net.HttpStatusCode.InternalServerError)
        {
            Response.Status = System.Net.HttpStatusCode.InternalServerError;
            Response.Reason = message;

            BodyWriter.WriteJsonObject(new { Error = message });
        }

        public void ReportClientError(string message, System.Net.HttpStatusCode code = System.Net.HttpStatusCode.BadRequest)
        {
            ReportServerError(message, code);
        }

        public bool LongPollCheck(EventPollNotify poller, ref long id, out bool isError)
        {
            HttpServer.HttpInput input = Request.Method.ToUpper() == "POST" ? Request.Form : Request.QueryString;
            if (Library.Utility.Utility.ParseBool(input["longpoll"].Value, false))
            {
                long lastEventId;
                if (!long.TryParse(input["lasteventid"].Value, out lastEventId))
                {
                    ReportClientError("When activating long poll, the request must include the last event id");
                    isError = true;
                    return false;
                }

                TimeSpan ts;
                try { ts = Library.Utility.Timeparser.ParseTimeSpan(input["duration"].Value); }
                catch (Exception ex)
                {
                    ReportClientError("Invalid duration: " + ex.Message);
                    isError = true;
                    return false;
                }

                if (ts <= TimeSpan.FromSeconds(10) || ts.TotalMilliseconds > int.MaxValue)
                {
                    ReportClientError("Invalid duration, must be at least 10 seconds, and less than " + int.MaxValue + " milliseconds");
                    isError = true;
                    return false;
                }

                isError = false;
                id = poller.Wait(lastEventId, (int)ts.TotalMilliseconds);
                return true;
            }

            isError = false;
            return false;
        }

        public void OutputOK(object item = null)
        {
            BodyWriter.OutputOK(item);
        }

        public void OutputError(object item = null, System.Net.HttpStatusCode code = System.Net.HttpStatusCode.InternalServerError, string reason = null)
        {
            Response.Status = code;
            Response.Reason = reason ?? "Error";
            BodyWriter.WriteJsonObject(item);
        }

        public void Dispose()
        {
            if (BodyWriter != null)
            {
                var bw = BodyWriter;
                BodyWriter = null;
                bw.Dispose();
            }
        }
    }
 }
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/ServerSetting.cs b/Duplicati/Server/WebServer/RESTMethods/ServerSetting.cs
new file mode 100644
index 000000000..971d669ec
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/ServerSetting.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class ServerSetting : IRESTMethodGET, IRESTMethodPUT, IRESTMethodDocumented
+    {
        public void GET(string key, RequestInfo info)
        {
            var prop = typeof(Database.ApplicationSettings).GetProperty(key);
            if (prop == null)
                info.OutputError(null, System.Net.HttpStatusCode.NotFound, "Not found");
            else
                info.OutputOK(prop.GetValue(Program.DataConnection.ApplicationSettings));
        }

        public void PUT(string key, RequestInfo info)
        {
            var prop = typeof(Database.ApplicationSettings).GetProperty(key);
            if (prop == null)
                info.OutputError(null, System.Net.HttpStatusCode.NotFound, "Not found");
            else
            {
                var dict = new Dictionary<string, string>();
                dict[key] = info.Request.Form["data"].Value;
                Program.DataConnection.ApplicationSettings.UpdateSettings(dict);
                info.OutputOK();
            }
        }

        public string Description { get { return "Return a list of settings for the server"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(string)),
                    new KeyValuePair<string, Type>(HttpServer.Method.Put, typeof(string))
                };
            }
        }    
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/ServerSettings.cs b/Duplicati/Server/WebServer/RESTMethods/ServerSettings.cs
index 35aad8ec8..6f288d5a1 100644
--- a/Duplicati/Server/WebServer/RESTMethods/ServerSettings.cs
+++ b/Duplicati/Server/WebServer/RESTMethods/ServerSettings.cs
@@ -14,10 +14,10 @@
 //  You should have received a copy of the GNU Lesser General Public
 //  License along with this library; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-using System;
using System.Collections.Generic;
using Duplicati.Server.Database;
+using System;
using System.Linq;
using System.Collections.Generic;
using Duplicati.Server.Database;
using System.IO;
using Duplicati.Server.Serialization;
 
 namespace Duplicati.Server.WebServer.RESTMethods
 {
-    public class ServerSettings : IRESTMethodGET, IRESTMethodDocumented
    {
        public void GET(string key, RequestInfo info)
        {
            info.OutputOK(Program.DataConnection.ApplicationSettings);
        }

        public string Description { get { return "Return a list of settings for the server"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(ApplicationSettings))
                };
            }
        }    
    }
+    public class ServerSettings : IRESTMethodGET, IRESTMethodPATCH, IRESTMethodDocumented
    {
        public void GET(string key, RequestInfo info)
        {
            var adv_props = from n in Program.DataConnection.GetSettings(Database.Connection.APP_SETTINGS_ID)
                select new KeyValuePair<string, string>(n.Name, n.Value);

            info.OutputOK(adv_props.ToDictionary(x => x.Key, x => x.Value));
        }

        public void PATCH(string key, RequestInfo info)
        {
            string str = info.Request.Form["data"].Value;
            if (string.IsNullOrWhiteSpace(str))
            {
                info.ReportClientError("Missing data object");
                return;
            }

            Dictionary<string, string> data = null;
            try
            {
                data = Serializer.Deserialize<Dictionary<string, string>>(new StringReader(str));
                if (data == null)
                {
                    info.ReportClientError("Data object had no entry");
                    return;
                }

                Program.DataConnection.ApplicationSettings.UpdateSettings(data);

                info.OutputOK();
            }
            catch (Exception ex)
            {
                if (data == null)
                    info.ReportClientError(string.Format("Unable to parse data object: {0}", ex.Message));
                else
                    info.ReportClientError(string.Format("Unable to save settings: {0}", ex.Message));
            }            
        }

        public string Description { get { return "Return a list of settings for the server"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(ApplicationSettings))
                };
            }
        }    
    }
 }
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/ServerState.cs b/Duplicati/Server/WebServer/RESTMethods/ServerState.cs
index 83568d149..50c74e756 100644
--- a/Duplicati/Server/WebServer/RESTMethods/ServerState.cs
+++ b/Duplicati/Server/WebServer/RESTMethods/ServerState.cs
@@ -19,6 +19,6 @@ using System;
using System.Collections.Generic;
 namespace Duplicati.Server.WebServer.RESTMethods
 {
     public class ServerState : IRESTMethodGET, IRESTMethodPOST, IRESTMethodDocumented
-    {
        public void GET(string key, RequestInfo info)
        {
            bool isError;
            long id = 0;
            if (info.LongPollCheck(Program.StatusEventNotifyer, ref id, out isError))
            {
                //Make sure we do not report a higher number than the eventnotifyer says
                var st = new Serializable.ServerStatus();
                st.LastEventID = id;
                info.OutputOK(st);
            }
            else if (!isError)
            {
                info.OutputOK(new Serializable.ServerStatus());
            }
        }

        public void POST(string key, RequestInfo info)
        {
            GET(key, info);
        }

        public string Description { get { return "Return the state of the server. This method can be long-polled."; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(Serializable.ServerStatus)),
                    new KeyValuePair<string, Type>(HttpServer.Method.Post, typeof(Serializable.ServerStatus))
                };
            }
        }
    }
+    {
        public void GET(string key, RequestInfo info)
        {
            bool isError;
            long id = 0;
            long.TryParse(key, out id);

            if (info.LongPollCheck(Program.StatusEventNotifyer, ref id, out isError))
            {
                //Make sure we do not report a higher number than the eventnotifyer says
                var st = new Serializable.ServerStatus();
                st.LastEventID = id;
                info.OutputOK(st);
            }
            else if (!isError)
            {
                info.OutputOK(new Serializable.ServerStatus());
            }
        }

        public void POST(string key, RequestInfo info)
        {
            var input = info.Request.Form;
            switch ((key ?? "").ToLowerInvariant())
            {
                case "pause":
                    if (input.Contains("duration") && !string.IsNullOrWhiteSpace(input["duration"].Value))
                    {
                        TimeSpan ts;
                        try
                        {
                            ts = Library.Utility.Timeparser.ParseTimeSpan(input["duration"].Value);
                        }
                        catch (Exception ex)
                        {
                            info.ReportClientError(ex.Message);
                            return;
                        }
                        if (ts.TotalMilliseconds > 0)
                            Program.LiveControl.Pause(ts);
                        else
                            Program.LiveControl.Pause();
                    }
                    else
                    {
                        Program.LiveControl.Pause();
                    }

                    info.OutputOK();
                    return;

                case "resume":
                    Program.LiveControl.Resume();
                    info.OutputOK();
                    return;
                    
                default:
                    info.ReportClientError("No such action", System.Net.HttpStatusCode.NotFound);
                    return;
            }
        }

        public string Description { get { return "Return the state of the server. This method can be long-polled."; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(Serializable.ServerStatus)),
                    new KeyValuePair<string, Type>(HttpServer.Method.Post, typeof(Serializable.ServerStatus))
                };
            }
        }
    }
 }
 
diff --git a/Duplicati/Server/WebServer/RESTMethods/Tags.cs b/Duplicati/Server/WebServer/RESTMethods/Tags.cs
new file mode 100644
index 000000000..98e9a8ef3
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Tags.cs
@@ -0,0 +1,24 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Tags : IRESTMethodGET, IRESTMethodDocumented
+    {
        public void GET(string key, RequestInfo info)
        {
            var r = 
                from n in 
                Serializable.ServerSettings.CompressionModules
                    .Union(Serializable.ServerSettings.EncryptionModules)
                    .Union(Serializable.ServerSettings.BackendModules)
                    .Union(Serializable.ServerSettings.GenericModules)
                    select n.Key.ToLower();

            // Append all known tags
            r = r.Union(from n in Program.DataConnection.Backups select n.Tags into p from x in p select x.ToLower());
            info.OutputOK(r);       
        }

        public string Description { get { return "Gets the list of tags"; } }

        public IEnumerable<KeyValuePair<string, Type>> Types
        {
            get
            {
                return new KeyValuePair<string, Type>[] {
                    new KeyValuePair<string, Type>(HttpServer.Method.Get, typeof(string[])),
                };
            }
        }
    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Task.cs b/Duplicati/Server/WebServer/RESTMethods/Task.cs
new file mode 100644
index 000000000..3b13525e6
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Task.cs
@@ -0,0 +1,24 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Task : IRESTMethodPOST
    {
        public void POST(string key, RequestInfo info)
        {
            var parts = (key ?? "").Split(new char[] { '/' }, 2);
            long taskid;
            if (parts.Length == 2 && long.TryParse(parts.First(), out taskid))
            {
                var task = Program.WorkThread.CurrentTask;
                var tasks = Program.WorkThread.CurrentTasks;

                if (task != null)
                    tasks.Insert(0, task);

                task = tasks.Where(x => x.TaskID == taskid).FirstOrDefault();
                if (task == null)
                {
                    info.ReportClientError("No such task", System.Net.HttpStatusCode.NotFound);
                    return;
                }

                switch (parts.Last().ToLowerInvariant())
                {
                    case "abort":
                        task.Abort();
                        info.OutputOK();
                        return;

                    case "stop":
                        task.Stop();
                        info.OutputOK();
                        return;
                }
            }

            info.ReportClientError("Invalid or missing task id");
        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Tasks.cs b/Duplicati/Server/WebServer/RESTMethods/Tasks.cs
new file mode 100644
index 000000000..cdcd82e97
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Tasks.cs
@@ -0,0 +1,24 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Tasks : IRESTMethodGET
+    {
        public void GET(string key, RequestInfo info)
        {
            var cur = Program.WorkThread.CurrentTask;
            var n = Program.WorkThread.CurrentTasks;

            if (cur != null)
                n.Insert(0, cur);

            info.OutputOK(n);
        }
    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/UISettings.cs b/Duplicati/Server/WebServer/RESTMethods/UISettings.cs
new file mode 100644
index 000000000..13db3314b
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/UISettings.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Collections.Generic;
using Duplicati.Server.Serialization;
using System.IO;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class UISettings : IRESTMethodGET, IRESTMethodPOST
+    {
        public void GET(string key, RequestInfo info)
        {
            if (string.IsNullOrWhiteSpace(key))
            {
                info.OutputOK(Program.DataConnection.GetUISettingsSchemes());
            }
            else
            {
                info.OutputOK(Program.DataConnection.GetUISettings(key));
            }
        }

        public void POST(string key, RequestInfo info)
        {
            if (string.IsNullOrWhiteSpace(key))
            {
                info.ReportClientError("Scheme is missing");
                return;
            }

            IDictionary<string, string> data;
            try
            {
                data = Serializer.Deserialize<Dictionary<string, string>>(new StreamReader(info.Request.Body));
            }
            catch (Exception ex)
            {
                info.ReportClientError(string.Format("Unable to parse settings object: {0}", ex.Message));
                return;
            }

            if (data == null)
            {
                info.ReportClientError(string.Format("Unable to parse settings object"));
                return;
            }

            Program.DataConnection.SetUISettings(key, data);
            info.OutputOK();            
        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/Updates.cs b/Duplicati/Server/WebServer/RESTMethods/Updates.cs
new file mode 100644
index 000000000..ceeb6f7dc
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/Updates.cs
@@ -0,0 +1,25 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class Updates : IRESTMethodPOST
+    {
        public void POST(string key, RequestInfo info)
        {
            switch ((key ?? "").ToLowerInvariant())
            {
                case "check":
                    Program.UpdatePoller.CheckNow();
                    info.OutputOK();
                    return;

                case "install":
                    Program.UpdatePoller.InstallUpdate();
                    info.OutputOK();
                    return;

                case "activate":
                    if (Program.WorkThread.CurrentTask != null || Program.WorkThread.CurrentTasks.Count != 0)
                    {
                        info.ReportServerError("Cannot activate update while task is running or scheduled");
                    }
                    else
                    {
                        Program.UpdatePoller.ActivateUpdate();
                        info.OutputOK();
                    }
                    return;
                
                default:
                    info.ReportClientError("No such action", System.Net.HttpStatusCode.NotFound);
                    return;
            }
        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/WebModule.cs b/Duplicati/Server/WebServer/RESTMethods/WebModule.cs
new file mode 100644
index 000000000..1e7823d8a
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/WebModule.cs
@@ -0,0 +1,28 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class WebModule : IRESTMethodPOST
+    {
+        public void POST(string key, RequestInfo info)
+        {
            var m = Duplicati.Library.DynamicLoader.WebLoader.Modules.Where(x => x.Key.Equals(key, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
            if (m == null)
            {
                info.ReportClientError(string.Format("No such command {0}", key), System.Net.HttpStatusCode.NotFound);
                return;
            }

            info.OutputOK(new { 
                Status = "OK", 
                Result = m.Execute(info.Request.Form.Where(x => !x.Name.Equals("command", StringComparison.InvariantCultureIgnoreCase)
                ).ToDictionary(x => x.Name, x => x.Value))
            });            
+        }
+    }
+}
+
diff --git a/Duplicati/Server/WebServer/RESTMethods/WebModules.cs b/Duplicati/Server/WebServer/RESTMethods/WebModules.cs
new file mode 100644
index 000000000..e48fd337a
--- /dev/null
+++ b/Duplicati/Server/WebServer/RESTMethods/WebModules.cs
@@ -0,0 +1,28 @@
+//  Copyright (C) 2015, The Duplicati Team

+//  http://www.duplicati.com, info@duplicati.com
+//
+//  This library is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU Lesser General Public License as
+//  published by the Free Software Foundation; either version 2.1 of the
+//  License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+using System;
using System.Linq;
+
+namespace Duplicati.Server.WebServer.RESTMethods
+{
+    public class WebModules : IRESTMethodGET
+    {
+        public void GET(string key, RequestInfo info)
+        {
            info.OutputOK(Duplicati.Library.DynamicLoader.WebLoader.Modules);
+        }
+    }
+}
+