public PSConnectionMonitorResult GetConnectionMonitor(string resourceGroupName, string name, string connectionMonitorName)
{
ConnectionMonitorResult connectionMonitor = this.ConnectionMonitors.Get(resourceGroupName, name, connectionMonitorName);
PSConnectionMonitorResult psConnectionMonitor = NetworkResourceManagerProfile.Mapper.Map <PSConnectionMonitorResult>(connectionMonitor);
return(psConnectionMonitor);
}
public async Task <Response <ConnectionMonitorResult> > GetAsync(string resourceGroupName, string networkWatcherName, string connectionMonitorName, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (networkWatcherName == null)
{
throw new ArgumentNullException(nameof(networkWatcherName));
}
if (connectionMonitorName == null)
{
throw new ArgumentNullException(nameof(connectionMonitorName));
}
using var message = CreateGetRequest(resourceGroupName, networkWatcherName, connectionMonitorName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
ConnectionMonitorResult value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
if (document.RootElement.ValueKind == JsonValueKind.Null)
{
value = null;
}
else
{
value = ConnectionMonitorResult.DeserializeConnectionMonitorResult(document.RootElement);
}
return(Response.FromValue(value, message.Response));
}
private PSConnectionMonitorResult UpdateConnectionMonitor(bool isConnectionMonitorV2)
{
MNM.ConnectionMonitor connectionMonitor;
if (isConnectionMonitorV2)
{
this.ValidateConnectionMonitorV2Request(this.TestGroup, this.Output);
connectionMonitor = this.PopulateConnectionMonitorParametersFromV2Request(this.TestGroup, this.Output, this.Note);
}
else
{
connectionMonitor = new ConnectionMonitor()
{
Source = new MNM.ConnectionMonitorSource
{
ResourceId = this.SourceResourceId,
Port = this.SourcePort
},
Destination = new MNM.ConnectionMonitorDestination
{
ResourceId = this.DestinationResourceId,
Address = this.DestinationAddress,
Port = this.DestinationPort
},
AutoStart = this.ConfigureOnly ? false : true,
MonitoringIntervalInSeconds = this.MonitoringIntervalInSeconds
};
}
connectionMonitor.Tags = TagsConversionHelper.CreateTagDictionary(this.Tag, validate: true);
if (!string.IsNullOrEmpty(this.Location))
{
connectionMonitor.Location = this.Location;
}
else if (this.NetworkWatcher != null)
{
connectionMonitor.Location = this.NetworkWatcher.Location;
}
else
{
MNM.NetworkWatcher networkWatcher = this.NetworkClient.NetworkManagementClient.NetworkWatchers.Get(this.ResourceGroupName, this.NetworkWatcherName);
connectionMonitor.Location = networkWatcher.Location;
}
PSConnectionMonitorResult psConnectionMonitorResult;
if (isConnectionMonitorV2)
{
this.ConnectionMonitors.CreateOrUpdate(this.ResourceGroupName, this.NetworkWatcherName, this.Name, connectionMonitor);
psConnectionMonitorResult = this.GetConnectionMonitor(this.ResourceGroupName, this.NetworkWatcherName, this.Name, isConnectionMonitorV2);
}
else
{
ConnectionMonitorResult connectionMonitorResult = this.ConnectionMonitors.CreateOrUpdateV1(this.ResourceGroupName, this.NetworkWatcherName, this.Name, connectionMonitor).Result;
psConnectionMonitorResult = MapConnectionMonitorResultToPSConnectionMonitorResultV1(connectionMonitorResult);
}
return(psConnectionMonitorResult);
}
public PSConnectionMonitorResult ConvertConnectionMonitorResultV2ToPSFormat(ConnectionMonitorResult connectionMonitor)
{
PSConnectionMonitorResult psConnectionMonitor = null;
if (String.Equals(connectionMonitor.ConnectionMonitorType, "SingleSourceDestination"))
{
psConnectionMonitor = ConvertConnectionMonitorResultToPSConnectionMonitorResultV1(connectionMonitor);
}
else
{
psConnectionMonitor = MapConnectionMonitorResultToPSConnectionMonitorResultV2(connectionMonitor);
}
return(psConnectionMonitor);
}
private PSConnectionMonitorResult CreateConnectionMonitor(string resourceGroupName, string networkWatcherName, bool isConnectionMonitorV2)
{
MNM.ConnectionMonitor connectionMonitor;
if (isConnectionMonitorV2)
{
if (ParameterSetName.Contains("SetByConnectionMonitorV2Object"))
{
this.TestGroup = this.ConnectionMonitor.TestGroups?.ToArray();
this.Output = this.ConnectionMonitor.Outputs?.ToArray();
this.Note = this.ConnectionMonitor.Notes;
}
this.ValidateConnectionMonitorV2Request(this.TestGroup, this.Output);
connectionMonitor = this.PopulateConnectionMonitorParametersFromV2Request(this.TestGroup, this.Output, this.Note);
}
else
{
connectionMonitor = new ConnectionMonitor()
{
Source = new MNM.ConnectionMonitorSource
{
ResourceId = this.SourceResourceId,
Port = this.SourcePort
},
Destination = new MNM.ConnectionMonitorDestination
{
ResourceId = this.DestinationResourceId,
Address = this.DestinationAddress,
Port = this.DestinationPort
},
AutoStart = this.ConfigureOnly.IsPresent,
MonitoringIntervalInSeconds = this.MonitoringIntervalInSeconds
};
}
connectionMonitor.Tags = TagsConversionHelper.CreateTagDictionary(this.Tag, validate: true);
if (ParameterSetName.Contains("SetByResource"))
{
connectionMonitor.Location = this.NetworkWatcher.Location;
}
else if (ParameterSetName.Contains("SetByName") || ParameterSetName.Contains("SetByConnectionMonitorV2Object"))
{
MNM.NetworkWatcher networkWatcher = this.NetworkClient.NetworkManagementClient.NetworkWatchers.Get(this.ResourceGroupName, this.NetworkWatcherName);
connectionMonitor.Location = networkWatcher.Location;
}
else
{
connectionMonitor.Location = this.Location;
}
PSConnectionMonitorResult psConnectionMonitorResult;
if (isConnectionMonitorV2)
{
// This is only used for testing. Do not remove
// string str = JsonConvert.SerializeObject(parameters, Formatting.Indented, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore });
// WriteObject(str);
this.ConnectionMonitors.CreateOrUpdate(resourceGroupName, networkWatcherName, this.Name, connectionMonitor);
psConnectionMonitorResult = this.GetConnectionMonitor(resourceGroupName, networkWatcherName, this.Name, isConnectionMonitorV2);
}
else
{
ConnectionMonitorResult connectionMonitorResult = this.ConnectionMonitors.CreateOrUpdateV1(resourceGroupName, networkWatcherName, this.Name, connectionMonitor).Result;
psConnectionMonitorResult = MapConnectionMonitorResultToPSConnectionMonitorResultV1(connectionMonitorResult);
}
return(psConnectionMonitorResult);
}
public PSConnectionMonitorResultV1 ConvertConnectionMonitorResultToPSConnectionMonitorResultV1(ConnectionMonitorResult ConnectionMonitorResult)
{
PSConnectionMonitorResultV2 PSConnectionMonitorResultV2 = MapConnectionMonitorResultToPSConnectionMonitorResultV2(ConnectionMonitorResult);
PSConnectionMonitorResultV1 ConnectionMonitorResultV1 = new PSConnectionMonitorResultV1()
{
Name = ConnectionMonitorResult.Name,
Id = ConnectionMonitorResult.Id,
Etag = ConnectionMonitorResult.Etag,
ProvisioningState = ConnectionMonitorResult.ProvisioningState,
Type = ConnectionMonitorResult.Type,
Location = ConnectionMonitorResult.Location,
AutoStart = ConnectionMonitorResult.AutoStart,
StartTime = ConnectionMonitorResult.StartTime,
MonitoringStatus = ConnectionMonitorResult.MonitoringStatus,
ConnectionMonitorType = ConnectionMonitorResult.ConnectionMonitorType,
MonitoringIntervalInSeconds = ConnectionMonitorResult.TestConfigurations?[0]?.TestFrequencySec,
Tags = new Dictionary <string, string>()
};
if (ConnectionMonitorResult.Tags != null)
{
foreach (KeyValuePair <string, string> KeyValue in ConnectionMonitorResult.Tags)
{
ConnectionMonitorResultV1.Tags.Add(KeyValue.Key, KeyValue.Value);
}
}
if (ConnectionMonitorResultV1.Source == null)
{
ConnectionMonitorResultV1.Source = new PSConnectionMonitorSource()
{
ResourceId = PSConnectionMonitorResultV2.TestGroups?[0]?.Sources?[0]?.ResourceId
};
}
if (ConnectionMonitorResultV1.Destination == null)
{
ConnectionMonitorResultV1.Destination = new PSConnectionMonitorDestination()
{
ResourceId = PSConnectionMonitorResultV2.TestGroups?[0]?.Destinations?[0]?.ResourceId,
Address = PSConnectionMonitorResultV2.TestGroups?[0]?.Destinations?[0]?.Address,
Port = GetDestinationPort(PSConnectionMonitorResultV2.TestGroups?[0]?.TestConfigurations[0])
};
}
return(ConnectionMonitorResultV1);
}
public PSConnectionMonitorResultV1 MapConnectionMonitorResultToPSConnectionMonitorResultV1(ConnectionMonitorResult ConnectionMonitor)
{
PSConnectionMonitorResultV1 psConnectionMonitor = new PSConnectionMonitorResultV1()
{
Name = ConnectionMonitor.Name,
Id = ConnectionMonitor.Id,
Etag = ConnectionMonitor.Etag,
ProvisioningState = ConnectionMonitor.ProvisioningState,
Type = ConnectionMonitor.Type,
Location = ConnectionMonitor.Location,
AutoStart = ConnectionMonitor.AutoStart,
MonitoringIntervalInSeconds = ConnectionMonitor.MonitoringIntervalInSeconds,
StartTime = ConnectionMonitor.StartTime,
MonitoringStatus = ConnectionMonitor.MonitoringStatus,
Tags = NetworkResourceManagerProfile.Mapper.Map <Dictionary <string, string> >(ConnectionMonitor.Tags),
ConnectionMonitorType = ConnectionMonitor.ConnectionMonitorType,
Source = NetworkResourceManagerProfile.Mapper.Map <PSConnectionMonitorSource>(ConnectionMonitor.Source),
Destination = NetworkResourceManagerProfile.Mapper.Map <PSConnectionMonitorDestination>(ConnectionMonitor.Destination),
};
return(psConnectionMonitor);
}
public PSConnectionMonitorResultV2 MapConnectionMonitorResultToPSConnectionMonitorResultV2(ConnectionMonitorResult connectionMonitor)
{
PSConnectionMonitorResultV2 psConnectionMonitor = new PSConnectionMonitorResultV2()
{
Name = connectionMonitor.Name,
Id = connectionMonitor.Id,
Etag = connectionMonitor.Etag,
ProvisioningState = connectionMonitor.ProvisioningState,
Type = connectionMonitor.Type,
Location = connectionMonitor.Location,
StartTime = connectionMonitor.StartTime,
Tags = new Dictionary <string, string>(),
ConnectionMonitorType = connectionMonitor.ConnectionMonitorType,
Notes = connectionMonitor.Notes,
TestGroups = new List <PSNetworkWatcherConnectionMonitorTestGroupObject>()
};
if (connectionMonitor.Tags != null)
{
foreach (KeyValuePair <string, string> KeyValue in connectionMonitor.Tags)
{
psConnectionMonitor.Tags.Add(KeyValue.Key, KeyValue.Value);
}
}
if (connectionMonitor.Outputs != null)
{
psConnectionMonitor.Outputs = new List <PSNetworkWatcherConnectionMonitorOutputObject>();
foreach (ConnectionMonitorOutput output in connectionMonitor.Outputs)
{
psConnectionMonitor.Outputs.Add(
new PSNetworkWatcherConnectionMonitorOutputObject()
{
Type = output.Type,
WorkspaceSettings = new PSConnectionMonitorWorkspaceSettings()
{
WorkspaceResourceId = output.WorkspaceSettings?.WorkspaceResourceId
}
});
}
}
if (connectionMonitor.TestGroups != null)
{
foreach (ConnectionMonitorTestGroup testGroup in connectionMonitor.TestGroups)
{
PSNetworkWatcherConnectionMonitorTestGroupObject testGroupObject = new PSNetworkWatcherConnectionMonitorTestGroupObject()
{
Name = testGroup.Name,
Disable = testGroup.Disable,
TestConfigurations = new List <PSNetworkWatcherConnectionMonitorTestConfigurationObject>(),
Sources = new List <PSNetworkWatcherConnectionMonitorEndpointObject>(),
Destinations = new List <PSNetworkWatcherConnectionMonitorEndpointObject>()
};
if (testGroup.Sources != null)
{
foreach (string sourceEndpointName in testGroup.Sources)
{
ConnectionMonitorEndpoint sourceEndpoint = GetEndpoinByName(connectionMonitor.Endpoints, sourceEndpointName);
PSNetworkWatcherConnectionMonitorEndpointObject EndpointObject =
NetworkResourceManagerProfile.Mapper.Map <PSNetworkWatcherConnectionMonitorEndpointObject>(sourceEndpoint);
testGroupObject.Sources.Add(EndpointObject);
}
}
if (testGroup.Destinations != null)
{
foreach (string destinationEndpointName in testGroup.Destinations)
{
ConnectionMonitorEndpoint destinationEndpoint = GetEndpoinByName(connectionMonitor.Endpoints, destinationEndpointName);
PSNetworkWatcherConnectionMonitorEndpointObject EndpointObject =
NetworkResourceManagerProfile.Mapper.Map <PSNetworkWatcherConnectionMonitorEndpointObject>(destinationEndpoint);
testGroupObject.Destinations.Add(EndpointObject);
}
}
// Test Configuration
if (testGroup.TestConfigurations != null)
{
foreach (string testConfigurationName in testGroup.TestConfigurations)
{
ConnectionMonitorTestConfiguration testConfiguration = GetTestConfigurationByName(connectionMonitor.TestConfigurations, testConfigurationName);
PSNetworkWatcherConnectionMonitorTestConfigurationObject testConfigurationObject = new PSNetworkWatcherConnectionMonitorTestConfigurationObject()
{
Name = testConfiguration.Name,
PreferredIPVersion = testConfiguration.PreferredIPVersion,
TestFrequencySec = testConfiguration.TestFrequencySec,
SuccessThreshold = testConfiguration.SuccessThreshold == null ? null :
new PSNetworkWatcherConnectionMonitorSuccessThreshold()
{
ChecksFailedPercent = testConfiguration.SuccessThreshold.ChecksFailedPercent,
RoundTripTimeMs = testConfiguration.SuccessThreshold.RoundTripTimeMs
},
ProtocolConfiguration = this.GetPSProtocolConfiguration(testConfiguration)
};
testGroupObject.TestConfigurations.Add(testConfigurationObject);
}
}
psConnectionMonitor.TestGroups.Add(testGroupObject);
}
}
return(psConnectionMonitor);
}
