protected ManagedCluster CreateManagedCluster(
ResourceManagementClient resouceClient,
ServiceFabricManagementClient serviceFabricClient,
string rg,
string rgLocation,
string clusterName,
string sku)
{
var newCluster = new ManagedCluster(
location: rgLocation,
sku: new Sku()
{
Name = sku
},
dnsName: clusterName,
adminPassword: "******",
adminUserName: "******",
clientConnectionPort: 19000,
httpGatewayConnectionPort: 19080,
clients: new List <ClientCertificate>()
{
new ClientCertificate()
{
IsAdmin = true,
Thumbprint = "123BDACDCDFB2C7B250192C6078E47D1E1DB119B"
}
});
resouceClient.ResourceGroups.CreateOrUpdate(
rg,
new ResourceGroup(rgLocation));
var cluster = serviceFabricClient.ManagedClusters.CreateOrUpdate(rg, clusterName, newCluster);
Assert.NotNull(cluster);
return(cluster);
}
protected NodeType CreateNodeType(
ServiceFabricManagementClient serviceFabricClient,
string rg,
string clusterName,
string nodeTypeName,
bool isPrimary,
int vmInstanceCount)
{
var newNodeType = new NodeType(
isPrimary: isPrimary,
vmInstanceCount: vmInstanceCount,
dataDiskSizeGB: 100,
vmSize: "Standard_D2",
vmImagePublisher: "MicrosoftWindowsServer",
vmImageOffer: "WindowsServer",
vmImageSku: "2019-Datacenter",
vmImageVersion: "latest"
);
var nodeType = serviceFabricClient.NodeTypes.CreateOrUpdate(rg, clusterName, nodeTypeName, newNodeType);
Assert.NotNull(nodeType);
return(nodeType);
}
protected Cluster CreateCluster(
ResourceManagementClient resouceClient,
ServiceFabricManagementClient serviceFabricClient,
string rg,
string rgLocation,
string clusterName)
{
var clusterId = string.Format(
clusterIdFormat,
resouceClient.SubscriptionId,
rg,
clusterName);
var newCluster = new Cluster(
location: rgLocation,
reliabilityLevel: "Silver",
managementEndpoint: "http://testCluster.southcentralus.cloudapp.azure.com:19080",
nodeTypes: new List <NodeTypeDescription>()
{
new NodeTypeDescription()
{
ApplicationPorts = new EndpointRangeDescription()
{
StartPort = 1000,
EndPort = 3000
},
DurabilityLevel = "Bronze",
EphemeralPorts = new EndpointRangeDescription()
{
StartPort = 4000,
EndPort = 6000
},
IsPrimary = true,
Name = "n1",
ClientConnectionEndpointPort = 19000,
Capacities = null,
HttpGatewayEndpointPort = 19080,
PlacementProperties = null,
VmInstanceCount = 5,
ReverseProxyEndpointPort = null
}
},
clusterId: clusterId,
name: clusterName,
type: "Microsoft.ServiceFabric/clusters",
vmImage: "Windows"
)
{
};
resouceClient.ResourceGroups.CreateOrUpdate(
rg,
new ResourceGroup(rgLocation));
var cluster = serviceFabricClient.Clusters.Create(rg, clusterName, newCluster);
Assert.NotNull(cluster);
cluster = serviceFabricClient.Clusters.Get(rg, clusterName);
Assert.NotNull(cluster);
return(cluster);
}
public static async Task <AzureOperationResponse <Cluster> > BeginUpdateWithHttpMessagesAsync(this ServiceFabricManagementClient sfManagementClient, string resourceGroupName, string clusterName, dynamic parameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (resourceGroupName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
}
if (clusterName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "clusterName");
}
if (sfManagementClient.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "sfManagementClient.SubscriptionId");
}
if (parameters == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "parameters");
}
string apiVersion = "2020-03-01";
// Tracing
bool shouldTrace = ServiceClientTracing.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("resourceGroupName", resourceGroupName);
tracingParameters.Add("clusterName", clusterName);
tracingParameters.Add("apiVersion", apiVersion);
tracingParameters.Add("parameters", parameters);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(invocationId, sfManagementClient, "BeginUpdate", tracingParameters);
}
// Construct URL
var baseUrl = sfManagementClient.BaseUri.AbsoluteUri;
var url = new System.Uri(new System.Uri(baseUrl + (baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ServiceFabric/clusters/{clusterName}").ToString();
url = url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
url = url.Replace("{clusterName}", System.Uri.EscapeDataString(clusterName));
url = url.Replace("{subscriptionId}", System.Uri.EscapeDataString(sfManagementClient.SubscriptionId));
List <string> _queryParameters = new List <string>();
if (apiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(apiVersion)));
}
if (_queryParameters.Count > 0)
{
url += (url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var httpRequest = new HttpRequestMessage();
HttpResponseMessage httpResponse = null;
httpRequest.Method = new HttpMethod("PATCH");
httpRequest.RequestUri = new System.Uri(url);
// Set Headers
if (sfManagementClient.GenerateClientRequestId != null && sfManagementClient.GenerateClientRequestId.Value)
{
httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (sfManagementClient.AcceptLanguage != null)
{
if (httpRequest.Headers.Contains("accept-language"))
{
httpRequest.Headers.Remove("accept-language");
}
httpRequest.Headers.TryAddWithoutValidation("accept-language", sfManagementClient.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (httpRequest.Headers.Contains(_header.Key))
{
httpRequest.Headers.Remove(_header.Key);
}
httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string requestContent = null;
if (parameters != null)
{
var dynamicSerializationSettings = sfManagementClient.SerializationSettings.DeepCopy();
dynamicSerializationSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver();
requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, dynamicSerializationSettings);
httpRequest.Content = new StringContent(requestContent, System.Text.Encoding.UTF8);
httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (sfManagementClient.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await sfManagementClient.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (shouldTrace)
{
ServiceClientTracing.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await sfManagementClient.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
ServiceClientTracing.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string responseContent = null;
if ((int)statusCode != 200 && (int)statusCode != 202)
{
var ex = new ErrorModelException(string.Format("Operation returned an invalid status code '{0}'", statusCode));
try
{
responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorModel _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorModel>(responseContent, sfManagementClient.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(httpRequest, requestContent);
ex.Response = new HttpResponseMessageWrapper(httpResponse, responseContent);
if (shouldTrace)
{
ServiceClientTracing.Error(invocationId, ex);
}
httpRequest.Dispose();
if (httpResponse != null)
{
httpResponse.Dispose();
}
throw ex;
}
// Create Result
var result = new AzureOperationResponse <Cluster>();
result.Request = httpRequest;
result.Response = httpResponse;
if (httpResponse.Headers.Contains("x-ms-request-id"))
{
result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)statusCode == 200)
{
responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <Cluster>(responseContent, sfManagementClient.DeserializationSettings);
}
catch (JsonException ex)
{
httpRequest.Dispose();
if (httpResponse != null)
{
httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", responseContent, ex);
}
}
// Deserialize Response
if ((int)statusCode == 202)
{
responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <Cluster>(responseContent, sfManagementClient.DeserializationSettings);
}
catch (JsonException ex)
{
httpRequest.Dispose();
if (httpResponse != null)
{
httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", responseContent, ex);
}
}
if (shouldTrace)
{
ServiceClientTracing.Exit(invocationId, result);
}
return(result);
}
