wasDAVClient – Diff between revs 2 and 3

Subversion Repositories:

?pathlinks?

Rev 2 – Rev 4 – Go to most recent revision – Details – Blame – Last modification – View Log

 namespace wasDAVClient
+{
     public class Client : IClient
-    {
-        private static readonly HttpMethod PropFind = new HttpMethod("PROPFIND");
-        private static readonly HttpMethod MoveMethod = new HttpMethod("MOVE");
-        private static readonly HttpMethod MkCol = new HttpMethod(WebRequestMethods.Http.MkCol);
+    {
         private const int HttpStatusCode_MultiStatus = 207;
         // http://webdav.org/specs/rfc4918.html#METHOD_PROPFIND
             //"    <getetag/>" +
             //"    <resourcetype/>" +
             //"  </prop> " +
             "</propfind>";
+        private static readonly HttpMethod PropFind = new HttpMethod("PROPFIND");
+        private static readonly HttpMethod MoveMethod = new HttpMethod("MOVE");
+        private static readonly HttpMethod MkCol = new HttpMethod(WebRequestMethods.Http.MkCol);
         private static readonly string AssemblyVersion = typeof(IClient).Assembly.GetName().Version.ToString();
-        private readonly HttpClient _client;
-        private readonly HttpClient _uploadClient;
+        private readonly HttpClient _client;
-        private string _server;
+        private readonly HttpClient _uploadClient;
+        private string _basePath = "/";
+        private string _encodedBasePath;
+        private string _server;
+        public Client(NetworkCredential credential = null)
+        {
+            var handler = new HttpClientHandler();
+            if (handler.SupportsProxy)
+                handler.Proxy = WebRequest.DefaultWebProxy;
+            if (handler.SupportsAutomaticDecompression)
+                handler.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
+            if (credential != null)
+            {
+                handler.Credentials = credential;
+                handler.PreAuthenticate = true;
+            }
+            _client = new HttpClient(handler);
+            _client.Timeout = TimeSpan.FromSeconds(Timeout);
+            _client.DefaultRequestHeaders.ExpectContinue = false;
         private string _basePath = "/";
             _uploadClient = new HttpClient(handler);
-        private string _encodedBasePath;
+            _uploadClient.Timeout = TimeSpan.FromSeconds(Timeout);
             _uploadClient.DefaultRequestHeaders.ExpectContinue = false;
+        }
-        #region WebDAV connection parameters
-        /// <summary>
+        #region WebDAV connection parameters
-        /// Specify the WebDAV hostname (required).
         /// </summary>
-        public string Server
+        /// <summary>
         ///     Specify the WebDAV hostname (required).
-            get
+        /// </summary>
         public string Server
                 return _server;
             get { return _server; }
             set
+            {
                 value = value.TrimEnd('/');
                 _server = value;
-            }
-        }
+            }
-        /// <summary>
         /// Specify the path of a WebDAV directory to use as 'root' (default: /)
         /// </summary>
-        public string BasePath
+        /// <summary>
         ///     Specify the path of a WebDAV directory to use as 'root' (default: /)
-            get
+        /// </summary>
                     _basePath = "/" + value + "/";
+            }
+        }
         /// <summary>
-        /// Specify an port (default: null = auto-detect)
+        ///     Specify an port (default: null = auto-detect)
         /// </summary>
-        public int? Port
-        {
-            get; set;
         public int? Port { get; set; }
         /// <summary>
-        /// Specify the UserAgent (and UserAgent version) string to use in requests
+        ///     Specify the UserAgent (and UserAgent version) string to use in requests
-        /// </summary>
-        public string UserAgent
-        {
-            get; set;
+        /// </summary>
-        }
+        public string UserAgent { get; set; }
         /// <summary>
-        /// Specify the UserAgent (and UserAgent version) string to use in requests
-        /// </summary>
-        public string UserAgentVersion
-        {
-            get; set;
-        }
-        #endregion
-        public Client(NetworkCredential credential = null, TimeSpan? timeout = null, IWebProxy proxy = null)
-        {
-            var handler = new HttpClientHandler();
-            if (proxy != null && handler.SupportsProxy)
-                handler.Proxy = proxy;
+        ///     Specify the UserAgent (and UserAgent version) string to use in requests
-            if (handler.SupportsAutomaticDecompression)
+        /// </summary>
-                handler.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
-            if (credential != null)
-            {
-                handler.Credentials = credential;
-                handler.PreAuthenticate = true;
-            }
-            _client = new HttpClient(handler);
+        public string UserAgentVersion { get; set; }
-            _client.DefaultRequestHeaders.ExpectContinue = false;
-            if (timeout != null)
-            {
-                _uploadClient = new HttpClient(handler);
+        /// <summary>
-                _uploadClient.DefaultRequestHeaders.ExpectContinue = false;
+        ///     The HTTP request timeout in seconds.
-                _uploadClient.Timeout = timeout.Value;
+        /// </summary>
-            }
+        public int Timeout { get; set; } = 60;
         #endregion
         #region WebDAV operations
             if (depth != null)
+            {
                 headers.Add("Depth", depth.ToString());
+            }
             HttpResponseMessage response = null;
+            try
+            {
-            try
+                response =
+                    await
                         HttpRequest(listUri.Uri, PropFind, headers, Encoding.UTF8.GetBytes(PropFindRequestContent))
-                response = await HttpRequest(listUri.Uri, PropFind, headers, Encoding.UTF8.GetBytes(PropFindRequestContent)).ConfigureAwait(false);
+                            .ConfigureAwait(false);
                 if (response.StatusCode != HttpStatusCode.OK &&
-                    (int)response.StatusCode != HttpStatusCode_MultiStatus)
+                    (int) response.StatusCode != HttpStatusCode_MultiStatus)
+                {
-                    throw new wasDAVException((int)response.StatusCode, "Failed retrieving items in folder.");
+                    throw new wasDAVException((int) response.StatusCode, "Failed retrieving items in folder.");
+                }
+                            }
+                        }
+                    }
                     return result;
+                }
+            }
             finally
+            {
                 if (response != null)
                     response.Dispose();
+            }
+        }
         /// <summary>
-        /// List all files present on the server.
+        ///     List all files present on the server.
         /// </summary>
         /// <returns>A list of files (entries without a trailing slash) and directories (entries with a trailing slash)</returns>
         public async Task<Item> GetFolder(string path = "/")
+        {
             var listUri = await GetServerUrl(path, true).ConfigureAwait(false);
             return await Get(listUri.Uri, path).ConfigureAwait(false);
+        }
         /// <summary>
-        /// List all files present on the server.
+        ///     List all files present on the server.
         /// </summary>
         /// <returns>A list of files (entries without a trailing slash) and directories (entries with a trailing slash)</returns>
         public async Task<Item> GetFile(string path = "/")
+        {
             var listUri = await GetServerUrl(path, false).ConfigureAwait(false);
             return await Get(listUri.Uri, path).ConfigureAwait(false);
         }
         /// <summary>
-        /// List all files present on the server.
+        ///     List all files present on the server.
-        /// </summary>
-        /// <returns>A list of files (entries without a trailing slash) and directories (entries with a trailing slash)</returns>
+        /// </summary>
-        private async Task<Item> Get(Uri listUri, string path)
+        /// <returns>A list of files (entries without a trailing slash) and directories (entries with a trailing slash)</returns>
         private async Task<Item> Get(Uri listUri, string path)
+        {
             // Depth header: http://webdav.org/specs/rfc4918.html#rfc.section.9.1.4
             IDictionary<string, string> headers = new Dictionary<string, string>();
+            headers.Add("Depth", "0");
-            headers.Add("Depth", "0");
+            HttpResponseMessage response = null;
+            try
             HttpResponseMessage response = null;
+                response =
+                    await
-            try
+                        HttpRequest(listUri, PropFind, headers, Encoding.UTF8.GetBytes(PropFindRequestContent))
                             .ConfigureAwait(false);
                 response = await HttpRequest(listUri, PropFind, headers, Encoding.UTF8.GetBytes(PropFindRequestContent)).ConfigureAwait(false);
                 if (response.StatusCode != HttpStatusCode.OK &&
                     response.Dispose();
+            }
+        }
         /// <summary>
-        /// Download a file from the server
+        ///     Download a file from the server
         /// </summary>
         /// <param name="remoteFilePath">Source path and filename of the file on the server</param>
         public async Task<Stream> Download(string remoteFilePath)
+        {
             // Should not have a trailing slash.
             var downloadUri = await GetServerUrl(remoteFilePath, false).ConfigureAwait(false);
-            var dictionary = new Dictionary<string, string> { { "translate", "f" } };
+            var dictionary = new Dictionary<string, string> {{"translate", "f"}};
             var response = await HttpRequest(downloadUri.Uri, HttpMethod.Get, dictionary).ConfigureAwait(false);
             if (response.StatusCode != HttpStatusCode.OK)
+            {
-                throw new wasDAVException((int)response.StatusCode, "Failed retrieving file.");
+                throw new wasDAVException((int) response.StatusCode, "Failed retrieving file.");
+            }
             return await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
         }
         /// <summary>
-        /// Download a file from the server
+        ///     Download a file from the server
         /// </summary>
         /// <param name="remoteFilePath">Source path and filename of the file on the server</param>
         /// <param name="content"></param>
         /// <param name="name"></param>
+        public async Task<bool> Upload(string remoteFilePath, Stream content, string name)
-        public async Task<bool> Upload(string remoteFilePath, Stream content, string name)
+        {
             // Should not have a trailing slash.
-            // Should not have a trailing slash.
+            var uploadUri =
-            var uploadUri = await GetServerUrl(remoteFilePath.TrimEnd('/') + "/" + name.TrimStart('/'), false).ConfigureAwait(false);
+                await GetServerUrl(remoteFilePath.TrimEnd('/') + "/" + name.TrimStart('/'), false).ConfigureAwait(false);
                 if (response.StatusCode != HttpStatusCode.OK &&
                     response.StatusCode != HttpStatusCode.NoContent &&
                     response.StatusCode != HttpStatusCode.Created)
                 {
-                    throw new wasDAVException((int)response.StatusCode, "Failed uploading file.");
+                    throw new wasDAVException((int) response.StatusCode, "Failed uploading file.");
+                }
                 return response.IsSuccessStatusCode;
+            }
             finally
+            {
                 if (response != null)
-                    response.Dispose();
                     response.Dispose();
+            }
         }
         /// <summary>
-        /// Create a directory on the server
+        ///     Create a directory on the server
         /// </summary>
         /// <param name="remotePath">Destination path of the directory on the server</param>
+        /// <param name="name"></param>
-        /// <param name="name"></param>
+        public async Task<bool> CreateDir(string remotePath, string name)
         public async Task<bool> CreateDir(string remotePath, string name)
             // Should not have a trailing slash.
-            // Should not have a trailing slash.
+            var dirUri =
-            var dirUri = await GetServerUrl(remotePath.TrimEnd('/') + "/" + name.TrimStart('/'), false).ConfigureAwait(false);
+                await GetServerUrl(remotePath.TrimEnd('/') + "/" + name.TrimStart('/'), false).ConfigureAwait(false);
             HttpResponseMessage response = null;
             try
+            {
                 response = await HttpRequest(dirUri.Uri, MkCol).ConfigureAwait(false);
                 if (response.StatusCode == HttpStatusCode.Conflict)
-                    throw new wasDAVConflictException((int)response.StatusCode, "Failed creating folder.");
+                    throw new wasDAVConflictException((int) response.StatusCode, "Failed creating folder.");
                 if (response.StatusCode != HttpStatusCode.OK &&
             var response = await HttpRequest(listUri, HttpMethod.Delete).ConfigureAwait(false);
             if (response.StatusCode != HttpStatusCode.OK &&
                 response.StatusCode != HttpStatusCode.NoContent)
             {
-                throw new wasDAVException((int)response.StatusCode, "Failed deleting item.");
+                throw new wasDAVException((int) response.StatusCode, "Failed deleting item.");
+            }
+        }
         public async Task<bool> MoveFolder(string srcFolderPath, string dstFolderPath)
+        {
             // Should have a trailing slash.
             var srcUri = await GetServerUrl(srcFolderPath, true).ConfigureAwait(false);
-            var dstUri = await GetServerUrl(dstFolderPath, true).ConfigureAwait(false);
             var dstUri = await GetServerUrl(dstFolderPath, true).ConfigureAwait(false);
             return await Move(srcUri.Uri, dstUri.Uri).ConfigureAwait(false);
             return await Move(srcUri.Uri, dstUri.Uri).ConfigureAwait(false);
+        }
             const string requestContent = "MOVE";
             IDictionary<string, string> headers = new Dictionary<string, string>();
+            headers.Add("Destination", dstUri.ToString());
-            headers.Add("Destination", dstUri.ToString());
+            var response =
+                await
                     HttpRequest(srcUri, MoveMethod, headers, Encoding.UTF8.GetBytes(requestContent))
-            var response = await HttpRequest(srcUri, MoveMethod, headers, Encoding.UTF8.GetBytes(requestContent)).ConfigureAwait(false);
+                        .ConfigureAwait(false);
             if (response.StatusCode != HttpStatusCode.OK &&
                 response.StatusCode != HttpStatusCode.Created)
+            {
-                throw new wasDAVException((int)response.StatusCode, "Failed moving file.");
+                throw new wasDAVException((int) response.StatusCode, "Failed moving file.");
+            }
             return response.IsSuccessStatusCode;
         }
         #endregion
         #region Server communication
         /// <summary>
+        ///     Perform the WebDAV call and fire the callback when finished.
-        /// Perform the WebDAV call and fire the callback when finished.
+        /// </summary>
-        /// </summary>
+        /// <param name="uri"></param>
-        /// <param name="uri"></param>
+        /// <param name="method"></param>
-        /// <param name="method"></param>
+        /// <param name="headers"></param>
-        /// <param name="headers"></param>
+        /// <param name="content"></param>
                 else
                     request.Headers.UserAgent.Add(new ProductInfoHeaderValue("WebDAVClient", AssemblyVersion));
                 if (headers != null)
                 {
-                    foreach (string key in headers.Keys)
+                    foreach (var key in headers.Keys)
+                    {
                         request.Headers.Add(key, headers[key]);
+                    }
                 return await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
+            }
+        }
         /// <summary>
-        /// Perform the WebDAV call and fire the callback when finished.
+        ///     Perform the WebDAV call and fire the callback when finished.
         /// </summary>
         /// <param name="uri"></param>
         /// <param name="headers"></param>
         /// <param name="method"></param>
         /// <param name="content"></param>
+        private async Task<HttpResponseMessage> HttpUploadRequest(Uri uri, HttpMethod method, Stream content,
-        private async Task<HttpResponseMessage> HttpUploadRequest(Uri uri, HttpMethod method, Stream content, IDictionary<string, string> headers = null)
+            IDictionary<string, string> headers = null)
+        {
             using (var request = new HttpRequestMessage(method, uri))
+            {
                 request.Headers.Connection.Add("Keep-Alive");
                 else
                     request.Headers.UserAgent.Add(new ProductInfoHeaderValue("WebDAVClient", AssemblyVersion));
                 if (headers != null)
                 {
-                    foreach (string key in headers.Keys)
+                    foreach (var key in headers.Keys)
+                    {
                         request.Headers.Add(key, headers[key]);
+                    }
                 return await client.SendAsync(request).ConfigureAwait(false);
+            }
+        }
         /// <summary>
-        /// Try to create an Uri with kind UriKind.Absolute
+        ///     Try to create an Uri with kind UriKind.Absolute
-        /// This particular implementation also works on Mono/Linux
+        ///     This particular implementation also works on Mono/Linux
-        /// It seems that on Mono it is expected behaviour that uris
+        ///     It seems that on Mono it is expected behaviour that uris
-        /// of kind /a/b are indeed absolute uris since it referes to a file in /a/b.
+        ///     of kind /a/b are indeed absolute uris since it referes to a file in /a/b.
-        /// https://bugzilla.xamarin.com/show_bug.cgi?id=30854
+        ///     https://bugzilla.xamarin.com/show_bug.cgi?id=30854
         /// </summary>
         /// <param name="uriString"></param>
         /// <param name="uriResult"></param>
         /// <returns></returns>
         private async Task<UriBuilder> GetServerUrl(string path, bool appendTrailingSlash)
+        {
             // Resolve the base path on the server
             if (_encodedBasePath == null)
+            {
-                var baseUri = new UriBuilder(_server) { Path = _basePath };
+                var baseUri = new UriBuilder(_server) {Path = _basePath};
                 var root = await Get(baseUri.Uri, null).ConfigureAwait(false);
                 _encodedBasePath = root.Href;
+                {
                     return new UriBuilder(absoluteBaseUri);
+                }
                 // Otherwise, use the resolved base path relatively to the server
-                var baseUri = new UriBuilder(_server) { Path = _encodedBasePath };
+                var baseUri = new UriBuilder(_server) {Path = _encodedBasePath};
                 return baseUri;
+            }
+            }
+        }
         #endregion
     }
+}