/// <summary> /// Uploads stream to remote path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="sourceStream">The source stream.</param> /// <param name="remotePath">The remote target file path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// FilePath remoteFilePath = "/site/wwwroot/hello.txt"; /// /// FilePath localFilePath = "./hello.txt"; /// /// using(Stream sourceStream = kuduClient.FileSystem.GetFile(localFilePath).OpenRead()) /// { /// kuduClient.VFSUploadStream(sourceStream, remoteFilePath); /// } /// </code> /// </example> // ReSharper disable once InconsistentNaming public static void VFSUploadStream( this IKuduClient client, Stream sourceStream, FilePath remotePath) { client.UploadStream(sourceStream, remotePath, EncodeVFSPath); }
internal static void DownloadFile <T>( this IKuduClient client, T remotePath, FilePath localPath, Func <T, string> encodeRemotePathFunc) where T : Path { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (remotePath == null) { throw new ArgumentNullException(nameof(remotePath)); } if (localPath == null) { throw new ArgumentNullException(nameof(localPath)); } if (encodeRemotePathFunc == null) { throw new ArgumentNullException(nameof(encodeRemotePathFunc)); } using (var localStream = client.FileSystem.GetFile(localPath).OpenWrite()) { client.HttpGetToStream( encodeRemotePathFunc(remotePath), localStream); } }
internal static void UploadStream <T>( this IKuduClient client, Stream sourceStream, T remotePath, Func <T, string> encodeRemotePathFunc, // ReSharper disable once UnusedParameter.Global bool allowNullStream = false) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (!allowNullStream && sourceStream == null) { throw new ArgumentNullException(nameof(sourceStream)); } if (remotePath == null) { throw new ArgumentNullException(nameof(remotePath)); } client.HttpPutStream( encodeRemotePathFunc(remotePath), sourceStream); }
/// <summary> /// Executes an arbitrary command line and return its output. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="command">The command to execute.</param> /// <param name="directory">The remote directory to execute command in.</param> /// <param name="arguments">The arguments.</param> /// <returns><see ref="KuduCommandResult"/></returns> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// IKuduCommandResult commandResult = kuduClient.ExecuteCommand( /// "echo", /// "D:/home/site/wwwroot", /// "hello"); /// /// Information( /// "Output:\r\n{0}\r\nError:\r\n{1}\r\nExitCode: {2}", /// commandResult.Output, /// commandResult.Error, /// commandResult.ExitCode); /// </code> /// </example> public static IKuduCommandResult ExecuteCommand( this IKuduClient client, string command, string directory, ProcessArgumentBuilder arguments = null) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (string.IsNullOrWhiteSpace(command)) { throw new ArgumentNullException(nameof(command)); } if (string.IsNullOrWhiteSpace(directory)) { throw new ArgumentNullException(nameof(directory)); } var commandArgs = new ProcessArgumentBuilder().AppendQuoted(command); arguments?.CopyTo(commandArgs); var param = new { command = commandArgs.Render(), dir = directory, }; return(client.HttpPostJsonObject <object, KuduCommandResult>( "/api/command", param)); }
/// <summary> /// Uploads file to remote path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="localPath">The local source file path.</param> /// <param name="remotePath">The remote target file path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// FilePath remoteFilePath = "/site/wwwroot/hello.txt"; /// /// FilePath localFilePath = "./hello.txt"; /// /// kuduClient.VFSUploadFile(localFilePath, remoteFilePath); /// </code> /// </example> // ReSharper disable once InconsistentNaming public static void VFSUploadFile( this IKuduClient client, FilePath localPath, FilePath remotePath) { client.UploadFile(localPath, remotePath, EncodeVFSPath); }
/// <summary> /// Downloads remote file locally. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="remotePath">The remote source path.</param> /// <param name="localPath">The local target path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// FilePath remoteFilePath = "/site/wwwroot/hello.txt"; /// /// FilePath localFilePath = "./hello.txt"; /// /// kuduClient.VFSDownloadFile(remoteFilePath, localFilePath); /// </code> /// </example> // ReSharper disable once InconsistentNaming public static void VFSDownloadFile( this IKuduClient client, FilePath remotePath, FilePath localPath) { client.DownloadFile(remotePath, localPath, EncodeVFSPath); }
/// <summary> /// Uploads zip file to expand into remote directory path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="localPath">The local source file path.</param> /// <param name="remotePath">The remote target directory path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// DirectoryPath remoteDirectoryPath = "/site/wwwroot/docs/"; /// FilePath zipFilePath = "./Documentation.zip"; /// /// Zip(sourceDirectoryPath, zipFilePath); /// /// kuduClient.ZipUploadFile( /// zipFilePath, /// remoteDirectoryPath); /// </code> /// </example> public static void ZipUploadFile( this IKuduClient client, FilePath localPath, DirectoryPath remotePath) { client.UploadFile(localPath, remotePath, EncodeZipPath); }
/// <summary> /// Downloads remote directory to local zip file. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="remotePath">The remote source path.</param> /// <param name="localPath">The local target path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath remoteDirectoryPath = "/site/wwwroot/"; /// FilePath localFilePath = "./wwwroot.zip"; /// /// kuduClient.ZipDownloadFile(remoteDirectoryPath, localFilePath); /// </code> /// </example> public static void ZipDownloadFile( this IKuduClient client, DirectoryPath remotePath, FilePath localPath) { client.DownloadFile(remotePath, localPath, EncodeZipPath); }
/// <summary> /// Uploads stream to remote path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="sourceString">The source string.</param> /// <param name="remotePath">The remote target file path.</param> /// <param name="encoding">The text encoding.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// string sourceString = "Hello"; /// FilePath remoteFilePath = "/site/wwwroot/hello.txt"; /// /// kuduClient.VFSUploadString(sourceString, remoteFilePath); /// </code> /// </example> // ReSharper disable once InconsistentNaming public static void VFSUploadString( this IKuduClient client, string sourceString, FilePath remotePath, Encoding encoding = null) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (sourceString == null) { throw new ArgumentNullException(nameof(sourceString)); } if (remotePath == null) { throw new ArgumentNullException(nameof(remotePath)); } client.HttpPutString( EncodeVFSPath(remotePath), sourceString, encoding); }
/// <summary> /// Deploy local directory to KuduWebsite as read only Zip file system /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="localPath">The local directory path.</param> /// <returns>The path of deployed Zip.</returns> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// /// FilePath deployFilePath = kuduClient.ZipRunFromDirectory(sourceDirectoryPath); /// /// Information("Deployed to {0}", deployFilePath); /// </code> /// </example> public static FilePath ZipRunFromDirectory( this IKuduClient client, DirectoryPath localPath) { return(client.ZipRunFromDirectory( skipPostDeploymentValidation: false, localPath: localPath)); }
/// <summary> /// Downloads remote file as string. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="remotePath">The remote source path.</param> /// <param name="encoding">The text encoding.</param> /// <returns>Content as string.</returns> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// FilePath remoteFilePath = "/site/wwwroot/hello.txt"; /// /// string resultString = kuduClient.VFSDownloadString(remoteFilePath); /// /// Information("Result: {0}", resultString); /// </code> /// </example> // ReSharper disable once InconsistentNaming public static string VFSDownloadString( this IKuduClient client, FilePath remotePath, Encoding encoding = null) { using (var reader = new StreamReader(client.VFSDownloadStream(remotePath), encoding ?? Encoding.UTF8)) { return(reader.ReadToEnd()); } }
/// <summary> /// Uploads zip stream and extracts to remote directory path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="sourceStream">The source stream.</param> /// <param name="remotePath">The remote directory path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// DirectoryPath remoteDirectoryPath = "/site/wwwroot/docs/"; /// FilePath zipFilePath = "./Documentation.zip"; /// /// Zip(sourceDirectoryPath, zipFilePath); /// /// using(Stream sourceStream = kuduClient.FileSystem.GetFile(zipFilePath).OpenRead()) /// { /// kuduClient.ZipUploadStream( /// sourceStream, /// remoteDirectoryPath); /// } /// </code> /// </example> public static void ZipUploadStream( this IKuduClient client, Stream sourceStream, DirectoryPath remotePath) { client.UploadStream( sourceStream, remotePath, EncodeZipPath); }
/// <summary> /// Get settings from appservice. /// </summary> /// <param name="client">The Kudu client.</param> /// <returns>The appservice settings.</returns> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// ReadOnlyDictionary<string, string> settings = kuduClient.SettingsGet(); /// /// foreach(var setting in settings) /// { /// Information( /// "{0}={1}", /// setting.Key, /// setting.Value); /// } /// </code> /// </example> public static IReadOnlyDictionary <string, string> SettingsGet( this IKuduClient client) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(client.HttpGetJsonObject <Dictionary <string, string> >( "/api/settings")); }
/// <summary> /// Deploy local directory to KuduWebsite /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="localPath">The local directory path.</param> /// <remarks>This will zip the folder in-memory.</remarks> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// /// kuduClient.ZipDeployDirectory( /// sourceDirectoryPath); /// </code> /// </example> public static void ZipDeployDirectory( this IKuduClient client, DirectoryPath localPath) { client.ZipDirectoryToMemoryStream( localPath, sourceStream => client.HttpPostStream( "/api/zipdeploy", sourceStream)); }
/// <summary> /// Uploads zip stream and extracts to remote directory path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="localPath">The local directory path.</param> /// <param name="remotePath">The remote directory path.</param> /// <remarks>This will zip the folder in-memory.</remarks> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// DirectoryPath remoteDirectoryPath = "/site/wwwroot/docs/"; /// /// kuduClient.ZipUploadDirectory( /// sourceDirectoryPath, /// remoteDirectoryPath); /// </code> /// </example> public static void ZipUploadDirectory( this IKuduClient client, DirectoryPath localPath, DirectoryPath remotePath) { client.ZipDirectoryToMemoryStream( localPath, sourceStream => client.UploadStream( sourceStream, remotePath, EncodeZipPath)); }
internal static void HttpDelete( this IKuduClient client, string relativeUri) { if (client == null) { throw new ArgumentNullException(nameof(client)); } ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.DeleteAsync(requestUri), response => true); }
internal static TOut HttpGetJsonObject <TOut>( this IKuduClient client, string relativeUri) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.GetAsync(requestUri), JsonResponseToObject <TOut>)); }
internal static void HttpPutStream( this IKuduClient client, string relativeUri, Stream value) { if (relativeUri == null) { throw new ArgumentNullException(nameof(relativeUri)); } ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.PutAsync(requestUri, value == null ? null : new StreamContent(value)), response => true); }
internal static void UploadFile <T>( this IKuduClient client, FilePath localPath, T remotePath, Func <T, string> encodeRemotePathFunc) { if (localPath == null) { throw new ArgumentNullException(nameof(localPath)); } using (var localStream = client.FileSystem.GetFile(localPath).OpenRead()) { client.UploadStream(localStream, remotePath, encodeRemotePathFunc); } }
// ReSharper disable once InconsistentNaming private static void VFSDelete( this IKuduClient client, Core.IO.Path remotePath) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (remotePath == null) { throw new ArgumentNullException(nameof(remotePath)); } client.HttpDelete(EncodeVFSPath(remotePath)); }
/// <summary> /// Delete setting from appservice. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="key">The key of settings to delete.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// kuduClient.SettingsDelete("FOO"); /// </code> /// </example> public static void SettingsDelete( this IKuduClient client, string key) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentNullException(nameof(key)); } client.HttpDelete( $"/api/settings/{Uri.EscapeDataString(key)}"); }
private static TOut ProcessHttpClientAction <TOut>( this IKuduClient client, string relativeUri, Func <HttpClient, string, Task <HttpResponseMessage> > preFunc, Func <HttpResponseMessage, TOut> postFunc) { if (string.IsNullOrWhiteSpace(relativeUri)) { throw new ArgumentNullException(nameof(relativeUri)); } var requestUri = $"{client.Settings.BaseUri.TrimEnd('/')}/{relativeUri.TrimStart('/')}"; var response = preFunc(client.HttpClient, requestUri).GetAwaiter().GetResult(); LogAndEnsureSuccessStatusCode(client.Log, response); return(postFunc(response)); }
/// <summary> /// Deploys zip stream Kudu website. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="sourceStream">The source stream.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// FilePath zipFilePath = "./Documentation.zip"; /// /// Zip(sourceDirectoryPath, zipFilePath); /// /// using(Stream sourceStream = kuduClient.FileSystem.GetFile(zipFilePath).OpenRead()) /// { /// kuduClient.ZipDeployStream( /// sourceStream); /// } /// </code> /// </example> public static void ZipDeployStream( this IKuduClient client, Stream sourceStream) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (sourceStream == null) { throw new ArgumentNullException(nameof(sourceStream)); } client.HttpPostStream( "/api/zipdeploy", sourceStream); }
/// <summary> /// Set settings to appservice. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="settings">The settings to set.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// var newSettings = new Dictionary<string, string> /// { /// { "FOO", "Bar" }, /// { "JOHN", "Doe" } /// }; /// /// kuduClient.SettingsSet( /// newSettings); /// </code> /// </example> public static void SettingsSet( this IKuduClient client, IReadOnlyDictionary <string, string> settings) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (settings == null) { throw new ArgumentNullException(nameof(settings)); } client.HttpPostJsonObject <object, IReadOnlyDictionary <string, string> >( "/api/settings", settings); }
/// <summary> /// Lists remote resources for a given path. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="remotePath">The remote directory path.</param> /// <returns><see cref="IKuduVFS"/> instance containing remote directory and file paths.</returns> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath remotePath = "/site/wwwroot"; /// /// IKuduVFS kuduVFS = kuduClient.VFSList(remotePath); /// /// Information("Directories and files"); /// foreach(IKuduPath path in kuduVFS.Entries) /// { /// Information( /// "Name: {0}, Size: {1}, Created: {2:yyyy-MM-dd HH:mm:ss}, Modified: {3:yyyy-MM-dd HH:mm:ss}, Mime: {4}", /// path.Name, /// path.Size, /// path.Created, /// path.Modified, /// path.Mime); /// } /// /// Information("Directories"); /// foreach(IKuduDirectoryPath directoryPath in kuduVFS.Directories) /// { /// Information( /// "Directory: {0}, Size: {1}, Created: {2:yyyy-MM-dd HH:mm:ss}, Modified: {3:yyyy-MM-dd HH:mm:ss}, Mime: {4}, Path: {5}", /// directoryPath.Name, /// directoryPath.Size, /// directoryPath.Created, /// directoryPath.Modified, /// directoryPath.Mime, /// directoryPath.Path); /// } /// /// Information("Files"); /// foreach(IKuduFilePath filePath in kuduVFS.Files) /// { /// Information( /// "File: {0}, Size: {1}, Created: {2:yyyy-MM-dd HH:mm:ss}, Modified: {3:yyyy-MM-dd HH:mm:ss}, Mime: {4}, Path: {5}", /// filePath.Name, /// filePath.Size, /// filePath.Created, /// filePath.Modified, /// filePath.Mime, /// filePath.Path); /// } /// </code> /// </example> // ReSharper disable once InconsistentNaming public static IKuduVFS VFSList( this IKuduClient client, DirectoryPath remotePath) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (remotePath == null) { throw new ArgumentNullException(nameof(remotePath)); } var paths = client.HttpGetJsonObject <KuduPath[]>( EncodeVFSPath(remotePath)); return(KuduVFS.ToKuduVfs(remotePath, paths)); }
internal static TOut HttpPostJsonObject <TIn, TOut>( this IKuduClient client, string relativeUri, TIn value, string mediaType = "application/json") { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.PostAsync( requestUri, new StringContent(LitJson.JsonMapper.ToJson(value), Encoding.UTF8, mediaType)), JsonResponseToObject <TOut>)); }
internal static void HttpGetToStream( this IKuduClient client, string relativeUri, Stream stream) { if (client == null) { throw new ArgumentNullException(nameof(client)); } ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.GetAsync(requestUri), response => { response.Content.CopyToAsync(stream).GetAwaiter().GetResult(); return(true); }); }
internal static Stream HttpGetStream( this IKuduClient client, string relativeUri) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.GetAsync(requestUri), response => { var ms = new MemoryStream(); response.Content.CopyToAsync(ms).GetAwaiter().GetResult(); ms.Position = 0; return ms; })); }
internal static void HttpPutString( this IKuduClient client, string relativeUri, string value, Encoding encoding = null) { if (relativeUri == null) { throw new ArgumentNullException(nameof(relativeUri)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } ProcessHttpClientAction( client, relativeUri, (httpClient, requestUri) => httpClient.PutAsync(requestUri, new StringContent(value, encoding ?? Encoding.UTF8)), response => true); }
/// <summary> /// Deploys zip file to Kudu wesite. /// </summary> /// <param name="client">The Kudu client.</param> /// <param name="localPath">The local source file path.</param> /// <example> /// <code> /// #addin nuget:?package=Cake.Kudu.Client /// /// string baseUri = EnvironmentVariable("KUDU_CLIENT_BASEURI"), /// userName = EnvironmentVariable("KUDU_CLIENT_USERNAME"), /// password = EnvironmentVariable("KUDU_CLIENT_PASSWORD"); /// /// IKuduClient kuduClient = KuduClient( /// baseUri, /// userName, /// password); /// /// DirectoryPath sourceDirectoryPath = "./Documentation/"; /// FilePath zipFilePath = "./Documentation.zip"; /// /// Zip(sourceDirectoryPath, zipFilePath); /// /// kuduClient.ZipDeployFile( /// zipFilePath); /// </code> /// </example> public static void ZipDeployFile( this IKuduClient client, FilePath localPath) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (localPath == null) { throw new ArgumentNullException(nameof(localPath)); } if (!client.FileSystem.Exist(localPath)) { throw new FileNotFoundException("Could not find local file to deploy", localPath.FullPath); } using (var localStream = client.FileSystem.GetFile(localPath).OpenRead()) { client.ZipDeployStream(localStream); } }