public HttpResponseMessage ExportPortalTemplate(ExportTemplateRequest request)
{
try
{
bool success;
var message = _controller.ExportPortalTemplate(request, UserInfo, out success);
if (!success)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, message));
}
var template = _controller.GetPortalTemplates().First(x => x.Name == request.FileName);
var templateItem = _controller.CreateListItem(template);
return(Request.CreateResponse(HttpStatusCode.OK, new
{
Message = message,
Template = new
{
Name = templateItem.Text,
templateItem.Value
}
}));
}
catch (Exception exc)
{
Logger.Error(exc);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
/// <summary> Captures the specified resource group as a template. </summary>
/// <param name="parameters"> Parameters for exporting the template. </param>
/// <param name="waitForCompletion"> Waits for the completion of the long running operations. </param>
/// <param name="cancellationToken"> The cancellation token to use. </param>
public virtual ResourceGroupExportTemplateOperation ExportTemplate(ExportTemplateRequest parameters, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("ResourceGroup.ExportTemplate");
scope.Start();
try
{
var originalResponse = _restClient.ExportTemplate(Id.Name, parameters, cancellationToken);
var operation = new ResourceGroupExportTemplateOperation(_clientDiagnostics, Pipeline, _restClient.CreateExportTemplateRequest(Id.Name, parameters).Request, originalResponse);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <IResourceGroupExportResult> ExportTemplateAsync(ResourceGroupExportTemplateOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
ExportTemplateRequest exportTemplateRequest = new ExportTemplateRequest();
exportTemplateRequest.Resources = new List <string>()
{
"*"
};
exportTemplateRequest.Options = EnumNameAttribute.GetName(options);
var result = await client.ExportTemplateWithHttpMessagesAsync(Name, exportTemplateRequest, cancellationToken : cancellationToken);
return(new ResourceGroupExportResultImpl(result.Body));
}
public async Task StartExportTemplate()
{
Subscription subscription = await Client.GetDefaultSubscriptionAsync().ConfigureAwait(false);
var rgOp = await subscription.GetResourceGroups().CreateOrUpdateAsync(true, Recording.GenerateAssetName("testrg"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroup rg = rgOp.Value;
var parameters = new ExportTemplateRequest();
parameters.Resources.Add("*");
var expOp = await rg.ExportTemplateAsync(false, parameters);
await expOp.WaitForCompletionAsync();
Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
var expOp = await rg.ExportTemplateAsync(false, null);
_ = await expOp.WaitForCompletionAsync();
});
}
/// <summary> Captures the specified resource group as a template. </summary>
/// <param name="parameters"> Parameters for exporting the template. </param>
/// <param name="cancellationToken"> The cancellation token to use. </param>
public virtual ResourceGroupsExportTemplateOperation StartExportTemplate(ExportTemplateRequest parameters, CancellationToken cancellationToken = default)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = Diagnostics.CreateScope("ResourceGroupOperations.StartExportTemplate");
scope.Start();
try
{
var originalResponse = RestClient.ExportTemplate(Id.Name, parameters, cancellationToken);
return(new ResourceGroupsExportTemplateOperation(Diagnostics, Pipeline, RestClient.CreateExportTemplateRequest(Id.Name, parameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task StartExportTemplate()
{
ResourceGroup rg = await Client.DefaultSubscription.GetResourceGroups().Construct(Location.WestUS2).CreateOrUpdateAsync(Recording.GenerateAssetName("testrg"));
var parameters = new ExportTemplateRequest();
parameters.Resources.Add("*");
var expOp = await rg.StartExportTemplateAsync(parameters);
await expOp.WaitForCompletionAsync();
Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
var expOp = await rg.StartExportTemplateAsync(null);
_ = await expOp.WaitForCompletionAsync();
});
rg.Id.Name = null;
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await rg.StartExportTemplateAsync(parameters));
}
public virtual Response <ResourceGroupExportResult> ExportTemplate(string resourceGroupName, ExportTemplateRequest parameters, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ResourceGroupsOperations.ExportTemplate");
scope.Start();
try
{
return(RestClient.ExportTemplate(resourceGroupName, parameters, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <ResourceGroupExportResult> > ExportTemplateAsync(string resourceGroupName, ExportTemplateRequest parameters, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ResourceGroupsClient.ExportTemplate");
scope.Start();
try
{
return(await RestClient.ExportTemplateAsync(resourceGroupName, parameters, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Executes the cmdlet.
/// </summary>
protected override void OnProcessRecord()
{
base.OnProcessRecord();
string contents;
if (ShouldProcess(ResourceGroupName, VerbsData.Export))
{
var resourceGroupId = this.GetResourceGroupId();
if (!this.IsParameterBound(c => c.ApiVersion))
{
var parameters = new ExportTemplateRequest
{
Resources = this.GetResourcesFilter(resourceGroupId: resourceGroupId),
Options = this.GetExportOptions(),
};
var exportedTemplate = ResourceManagerSdkClient.ExportResourceGroup(ResourceGroupName, parameters);
var template = exportedTemplate.Template;
contents = template.ToString();
var error = exportedTemplate.Error;
if (error != null)
{
WriteWarning(string.Format("{0} : {1}", error.Code, error.Message));
foreach (var detail in error.Details)
{
WriteWarning(string.Format("{0} : {1}", detail.Code, detail.Message));
}
}
}
else
{
var parameters = new ExportTemplateParameters
{
Resources = this.GetResourcesFilter(resourceGroupId: resourceGroupId),
Options = this.GetExportOptions(),
};
var apiVersion = this.ApiVersion;
var operationResult = this.GetResourcesClient()
.InvokeActionOnResource <JObject>(
resourceId: resourceGroupId,
action: Constants.ExportTemplate,
parameters: parameters.ToJToken(),
apiVersion: apiVersion,
cancellationToken: this.CancellationToken.Value)
.Result;
var managementUri = this.GetResourcesClient()
.GetResourceManagementRequestUri(
resourceId: resourceGroupId,
apiVersion: apiVersion,
action: Constants.ExportTemplate);
var activity = string.Format("POST {0}", managementUri.PathAndQuery);
var resultString = this.GetLongRunningOperationTracker(activityName: activity,
isResourceCreateOrUpdate: false)
.WaitOnOperation(operationResult: operationResult);
var template = JToken.FromObject(JObject.Parse(resultString)["template"]);
contents = template.ToString();
if (JObject.Parse(resultString)["error"] != null)
{
if (JObject.Parse(resultString)["error"].TryConvertTo(out ExtendedErrorInfo error))
{
WriteWarning(string.Format("{0} : {1}", error.Code, error.Message));
foreach (var detail in error.Details)
{
WriteWarning(string.Format("{0} : {1}", detail.Code, detail.Message));
}
}
}
}
string path = FileUtility.SaveTemplateFile(
templateName: this.ResourceGroupName,
contents: contents,
outputPath:
string.IsNullOrEmpty(this.Path)
? System.IO.Path.Combine(CurrentPath(), this.ResourceGroupName)
: this.TryResolvePath(this.Path),
overwrite: Force.IsPresent,
shouldContinue: ShouldContinue);
WriteObject(PowerShellUtilities.ConstructPSObject(null, "Path", path));
}
}
public virtual async Task <ResourceGroupsExportTemplateOperation> StartExportTemplateAsync(string resourceGroupName, ExportTemplateRequest parameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("ResourceGroupsOperations.StartExportTemplate");
scope.Start();
try
{
var originalResponse = await RestClient.ExportTemplateAsync(resourceGroupName, parameters, cancellationToken).ConfigureAwait(false);
return(new ResourceGroupsExportTemplateOperation(_clientDiagnostics, _pipeline, RestClient.CreateExportTemplateRequest(resourceGroupName, parameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Captures the specified resource group as a template.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group to export as a template.
/// </param>
/// <param name='parameters'>
/// Parameters for exporting the template.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ResourceGroupExportResult> ExportTemplateAsync(this IResourceGroupsOperations operations, string resourceGroupName, ExportTemplateRequest parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ExportTemplateWithHttpMessagesAsync(resourceGroupName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Captures the specified resource group as a template.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group to export as a template.
/// </param>
/// <param name='parameters'>
/// Parameters for exporting the template.
/// </param>
public static ResourceGroupExportResult ExportTemplate(this IResourceGroupsOperations operations, string resourceGroupName, ExportTemplateRequest parameters)
{
return(operations.ExportTemplateAsync(resourceGroupName, parameters).GetAwaiter().GetResult());
}
public async virtual Task <ResourceGroupExportTemplateOperation> ExportTemplateAsync(bool waitForCompletion, ExportTemplateRequest parameters, CancellationToken cancellationToken = default)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _resourceGroupClientDiagnostics.CreateScope("ResourceGroup.ExportTemplate");
scope.Start();
try
{
var response = await _resourceGroupRestClient.ExportTemplateAsync(Id.SubscriptionId, Id.ResourceGroupName, parameters, cancellationToken).ConfigureAwait(false);
var operation = new ResourceGroupExportTemplateOperation(_resourceGroupClientDiagnostics, Pipeline, _resourceGroupRestClient.CreateExportTemplateRequest(Id.SubscriptionId, Id.ResourceGroupName, parameters).Request, response);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Captures the specified resource group as a template.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group to be created or updated.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the export template resource group operation.
/// </param>
public static ResourceGroupExportResult ExportTemplate(this IResourceGroupsOperations operations, string resourceGroupName, ExportTemplateRequest parameters)
{
return(Task.Factory.StartNew(s => ((IResourceGroupsOperations)s).ExportTemplateAsync(resourceGroupName, parameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public virtual ArmOperation <ResourceGroupExportResult> ExportTemplate(bool waitForCompletion, ExportTemplateRequest parameters, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(parameters, nameof(parameters));
using var scope = _resourceGroupClientDiagnostics.CreateScope("ResourceGroup.ExportTemplate");
scope.Start();
try
{
var response = _resourceGroupRestClient.ExportTemplate(Id.SubscriptionId, Id.ResourceGroupName, parameters, cancellationToken);
var operation = new ResourcesArmOperation <ResourceGroupExportResult>(new ResourceGroupExportResultOperationSource(), _resourceGroupClientDiagnostics, Pipeline, _resourceGroupRestClient.CreateExportTemplateRequest(Id.SubscriptionId, Id.ResourceGroupName, parameters).Request, response, OperationFinalStateVia.Location);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
