/// <summary>
/// Executes the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var parentResourceIdentifier = default(ResourceIdentifier);
if (this.IsParameterBound(c => c.ParentResourceId))
{
parentResourceIdentifier = new ResourceIdentifier(ParentResourceId);
if (!string.Equals(StorageSyncConstants.StorageSyncServiceType, parentResourceIdentifier.ResourceType, System.StringComparison.OrdinalIgnoreCase))
{
throw new PSArgumentException(StorageSyncResources.MissingParentResourceIdErrorMessage);
}
}
var resourceGroupName = ResourceGroupName ?? ParentObject?.ResourceGroupName ?? parentResourceIdentifier?.ResourceGroupName;
var parentResourceName = StorageSyncServiceName ?? ParentObject?.StorageSyncServiceName ?? parentResourceIdentifier?.ResourceName;
Target = string.Join("/", resourceGroupName, parentResourceName);
if (ShouldProcess(Target, ActionMessage))
{
RegisteredServer resource = PerformServerRegistration(resourceGroupName, SubscriptionId, parentResourceName);
WriteObject(resource);
}
});
}
public void RegisteredServerCreateTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
IResourceManagementClient resourcesClient = StorageSyncManagementTestUtilities.GetResourceManagementClient(context, handler);
IStorageSyncManagementClient storageSyncManagementClient = StorageSyncManagementTestUtilities.GetStorageSyncManagementClient(context, handler);
// Create ResourceGroup
string resourceGroupName = StorageSyncManagementTestUtilities.CreateResourceGroup(resourcesClient);
// Create RegisteredServer Name
string storageSyncServiceName = TestUtilities.GenerateName("sss-rscreate");
Guid serverGuid = TestUtilities.GenerateGuid();
var storageSyncServiceParameters = StorageSyncManagementTestUtilities.GetDefaultStorageSyncServiceParameters();
var registeredServerParameters = StorageSyncManagementTestUtilities.GetDefaultRegisteredServerParameters(serverGuid);
StorageSyncService storageSyncServiceResource = storageSyncManagementClient.StorageSyncServices.Create(resourceGroupName, storageSyncServiceName, storageSyncServiceParameters);
Assert.NotNull(storageSyncServiceResource);
StorageSyncManagementTestUtilities.VerifyStorageSyncServiceProperties(storageSyncServiceResource, true);
RegisteredServer resource = storageSyncManagementClient.RegisteredServers.Create(resourceGroupName, storageSyncServiceResource.Name, serverGuid.ToString(), registeredServerParameters);
Assert.NotNull(resource);
StorageSyncManagementTestUtilities.VerifyRegisteredServerProperties(resource, true);
storageSyncManagementClient.RegisteredServers.Delete(resourceGroupName, storageSyncServiceResource.Name, serverGuid.ToString());
storageSyncManagementClient.StorageSyncServices.Delete(resourceGroupName, storageSyncServiceResource.Name);
StorageSyncManagementTestUtilities.RemoveResourceGroup(resourcesClient, resourceGroupName);
}
}
public static Server GetServerInfo(RegisteredServer registeredServer)
{
using var session = createSession(registeredServer);
var server = new Server();
if (!session.TestConnection())
{
server.ConnectionError = true;
return(server);
}
server.Id = registeredServer.Id;
server.Name = registeredServer.Domain;
var oprsys = session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_OperatingSystem").ElementAt(0);
foreach (var item in oprsys.CimInstanceProperties)
{
server.OperatingSystemProps.Add(item.Name, item.Value?.ToString() ?? "null");
}
var services = session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Service");
foreach (var item in services)
{
server.Services.Add(item);
}
return(server);
}
public override ResponseHeader RegisterServer(RequestHeader requestHeader, RegisteredServer server)
{
lock (_ServerLock)
{
//Validation
if (server == null || string.IsNullOrEmpty(server.ServerUri))
{
return(CreateResponse(requestHeader, StatusCodes.Bad));
}
if (server.IsOnline)
{
var newServer = new ApplicationDescription()
{
ApplicationName = server.ServerNames?.First(),
ApplicationUri = server.ServerUri,
ApplicationType = server.ServerType,
ProductUri = server.ProductUri,
DiscoveryUrls = server.DiscoveryUrls
};
var cacheItem = new CacheItem(server.ServerUri, newServer);
_Cache.Set(cacheItem, _CacheItemPolicy);
Console.WriteLine($"RegisteredServer: {server.ServerUri}");
}
else
{
_Cache.Remove(server.ServerUri);
}
}
return(CreateResponse(requestHeader, StatusCodes.Good));
}
public static void RebootServer(RegisteredServer registeredServer)
{
using var session = createSession(registeredServer);
var oprsys = session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_OperatingSystem").ElementAt(0);
var res = session.InvokeMethod(oprsys, "Reboot", null);
}
public static void InvokeOnService(RegisteredServer registeredServer, string serviceName, string methodName)
{
using var session = createSession(registeredServer);
var service = session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Service where Name = '" + serviceName + "'").ElementAt(0);
var res = session.InvokeMethod(service, methodName, null);
}
private static void UpdateCredentials(ImportItem itemToImport, Repository repository, string connectionName)
{
RegisteredServer.UpdateCredentials(repository.ConnectionString,
connectionName, itemToImport.UserName, itemToImport.Password,
(itemToImport.AuthType == SqlServerAuthenticationType.WindowsAuthentication || itemToImport.AuthType == SqlServerAuthenticationType.AzureADAuthentication) ? "W" : "S",
itemToImport.UseSameCredentials ? itemToImport.UserName : itemToImport.WindowsUserName,
itemToImport.UseSameCredentials
? itemToImport.Password
: itemToImport.WindowsUserPassword);
}
public static void VerifyRegisteredServerProperties(RegisteredServer resource, bool useDefaults)
{
Assert.NotNull(resource);
Assert.NotNull(resource.Id);
Assert.NotNull(resource.Name);
if (useDefaults)
{
}
}
/// <summary>
/// Invokes the RegisterServer service.
/// </summary>
public virtual ResponseHeader RegisterServer(
RequestHeader requestHeader,
RegisteredServer server)
{
ValidateRequest(requestHeader);
// Insert implementation.
return(CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported));
}
/// <summary>
/// Removes the double quotes.
/// </summary>
/// <param name="registeredServer">The registered server.</param>
/// <returns>RegisteredServer.</returns>
private RegisteredServer RemoveDoubleQuotes(RegisteredServer registeredServer)
{
registeredServer.ClusterId = registeredServer.ClusterId.Trim('\"');
registeredServer.StorageSyncServiceUid = registeredServer.StorageSyncServiceUid.Trim('\"');
registeredServer.ServerId = registeredServer.ServerId.Trim('\"');
registeredServer.DiscoveryEndpointUri = registeredServer.DiscoveryEndpointUri.Trim('\"');
registeredServer.ManagementEndpointUri = registeredServer.ManagementEndpointUri.Trim('\"');
registeredServer.LastHeartBeat = registeredServer.LastHeartBeat.Trim('\"');
return(registeredServer);
}
private static CimSession createSession(RegisteredServer registeredServer)
{
var options = new DComSessionOptions();
options.Impersonation = ImpersonationType.Impersonate;
options.AddDestinationCredentials(new CimCredential(PasswordAuthenticationMechanism.Default, registeredServer.Domain, registeredServer.Username, registeredServer.Password));
var s = CimSession.Create(registeredServer.Domain, options);
return(s);
}
/// <summary>
/// 注册服务(每个在本机启动的服务端都会主动调用此方法进行注册)
/// </summary>
/// <param name="requestHeader"></param>
/// <param name="server"></param>
/// <param name="discoveryConfiguration"></param>
/// <param name="configurationResults"></param>
/// <param name="diagnosticInfos"></param>
/// <returns></returns>
public virtual ResponseHeader RegisterServer2(
RequestHeader requestHeader,
RegisteredServer server,
ExtensionObjectCollection discoveryConfiguration,
out StatusCodeCollection configurationResults,
out DiagnosticInfoCollection diagnosticInfos)
{
configurationResults = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
try
{
Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ":服务注册:" + server.DiscoveryUrls.FirstOrDefault());
RegisteredServerTable model = _serverTable.Where(d => d.ServerUri == server.ServerUri).FirstOrDefault();
if (model != null)
{
model.LastRegistered = DateTime.Now;
}
else
{
model = new RegisteredServerTable()
{
DiscoveryUrls = server.DiscoveryUrls,
GatewayServerUri = server.GatewayServerUri,
IsOnline = server.IsOnline,
LastRegistered = DateTime.Now,
ProductUri = server.ProductUri,
SemaphoreFilePath = server.SemaphoreFilePath,
ServerNames = server.ServerNames,
ServerType = server.ServerType,
ServerUri = server.ServerUri
};
_serverTable.Add(model);
}
configurationResults = new StatusCodeCollection()
{
StatusCodes.Good
};
return(CreateResponse(requestHeader, StatusCodes.Good));
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("客户端调用RegisterServer2()注册服务时触发异常:" + ex.Message);
Console.ResetColor();
}
return(CreateResponse(requestHeader, StatusCodes.BadUnexpectedError));
}
public bool LoadServers(bool registeredOnly)
{
// Get the data source enumerator object.
bool isOk = true;
System.Data.Sql.SqlDataSourceEnumerator serversEnum = System.Data.Sql.SqlDataSourceEnumerator.Instance;
// Get the data sources and fill the list view.
try
{
if (!registeredOnly)
{
// Get data sources.
using (DataTable servers = serversEnum.GetDataSources())
{
// Process each row and populate the list view.
foreach (DataRow row in servers.Rows)
{
// Check that the server is not null.
if (!row.IsNull("ServerName"))
{
// Construct the instance name.
string serverInstance = (string)row["ServerName"];
if (!row.IsNull("InstanceName"))
{
serverInstance = serverInstance + @"\" + (string)row["InstanceName"];
}
// Update the list view.
_listView_Servers.Items.Add(serverInstance);
}
}
}
}
else
{
var servers = RegisteredServer.LoadRegisteredServers(Program.gController.Repository.ConnectionString);
foreach (RegisteredServer item in servers)
{
_listView_Servers.Items.Add(item.FullName);
}
}
}
catch (Exception ex)
{
logX.loggerX.Error("ERROR - exception raised when enumerating servers, ", ex);
isOk = false;
}
return(isOk);
}
/// <summary>
/// Invokes the RegisterServer2 service.
/// </summary>
public virtual ResponseHeader RegisterServer2(
RequestHeader requestHeader,
RegisteredServer server,
ExtensionObjectCollection discoveryConfiguration,
out StatusCodeCollection configurationResults,
out DiagnosticInfoCollection diagnosticInfos)
{
configurationResults = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return(CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported));
}
private void _wizard_Finish(object sender, EventArgs e)
{
try
{
if (!controlConfigurePolicyVulnerabilities1.OKToSave())
{
DialogResult = DialogResult.None;
return;
}
List <RegisteredServer> serversToAdd = null;
List <RegisteredServer> serversToRemove = null;
string dynamicSelection = null;
bool isDynamic;
controlPolicyAddServers1.GetServers(true, out serversToAdd, out serversToRemove, out dynamicSelection, out isDynamic);
int policyId = -1;
policyId = Policy.AddPolicy(PolicyName, PolicyDescription, isDynamic, dynamicSelection, _policyInterview.InterviewName, _policyInterview.GetInterviewText());
if (policyId != -1)
{
// Notify controller that a new server was added.
Program.gController.SignalRefreshPoliciesEvent(0);
// Now add the metrics to the policy
m_policy = Policy.GetPolicy(policyId);
controlConfigurePolicyVulnerabilities1.SaveMetricChanges(m_policy);
m_policy.SavePolicyToRepository(Program.gController.Repository.ConnectionString);
// Now add the selected servers to the policy
foreach (RegisteredServer rServer in serversToAdd)
{
RegisteredServer.AddRegisteredServerToPolicy(rServer.RegisteredServerId, m_policy.PolicyId, m_policy.AssessmentId);
}
}
}
catch (Exception ex)
{
string title = "Error Creating Policy";
string msg =
string.Format("Failed to Create policy {0} error message: {1}", textBox_PolicyName.Text,
ex.Message);
logX.loggerX.Error(msg);
MsgBox.ShowError(title, msg);
}
}
public static Entry For(RegisteredServer server)
{
if (server == null)
{
return(new NullEntry());
}
else
{
ObjectEntry serverEntry = new ObjectEntry();
serverEntry.Add("ServerURI", For(server.ServerUri));
serverEntry.Add("ProductURI", For(server.ProductUri));
serverEntry.Add("ServerType", For(server.ServerType));
serverEntry.Add("GatewayServerURI", For(server.GatewayServerUri));
serverEntry.Add("DiscoveryURLs", For(server.DiscoveryUrls));
serverEntry.Add("SemaphoreFilePath", For(server.SemaphoreFilePath));
serverEntry.Add("IsOnline", For(server.IsOnline));
return(serverEntry);
}
}
private void ultraListView_RegisterServer_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
UltraListViewSubItem item;
item = ultraListView_RegisterServer.SubItemFromPoint(e.Location);
if (item != null)
{
if (item.Key == "Manage")
{
RegisteredServer rServer = (RegisteredServer)item.Item.Tag;
if (rServer != null)
{
Forms.Form_SqlServerProperties.Process(rServer.ConnectionName, Forms.Form_SqlServerProperties.RequestedOperation.GeneralProperties, Program.gController.isAdmin);
LoadData();
}
}
}
}
}
/// <summary>
/// This function processes the registration and perform following steps
/// 1. EnsureSyncServerCertificate
/// 2. GetSyncServerCertificate
/// 3. GetSyncServerId
/// 4. Get ClusterInfo
/// 5. Populate RegistrationServerResource
/// </summary>
/// <param name="managementEndpointUri">Management endpoint Uri</param>
/// <param name="subscriptionId">Subscription Id</param>
/// <param name="storageSyncServiceName">Storage Sync Service Name</param>
/// <param name="resourceGroupName">Resource Group Name</param>
/// <param name="certificateProviderName">Certificate Provider Name</param>
/// <param name="certificateHashAlgorithm">Certificate Hash Algorithm</param>
/// <param name="certificateKeyLength">Certificate Key Length</param>
/// <param name="monitoringDataPath">Monitoring data path</param>
/// <param name="agentVersion">Agent Version</param>
/// <param name="registerOnlineCallback">Register Online Callback</param>
/// <returns>Registered Server Resource</returns>
/// <exception cref="Commands.StorageSync.Interop.Exceptions.ServerRegistrationException">
/// </exception>
/// <exception cref="ServerRegistrationException"></exception>
public RegisteredServer Register(
Uri managementEndpointUri,
Guid subscriptionId,
string storageSyncServiceName,
string resourceGroupName,
string certificateProviderName,
string certificateHashAlgorithm,
uint certificateKeyLength,
string monitoringDataPath,
string agentVersion,
Func <string, string, ServerRegistrationData, RegisteredServer> registerOnlineCallback)
{
if (!Validate(managementEndpointUri, subscriptionId, storageSyncServiceName, resourceGroupName, monitoringDataPath))
{
throw new ServerRegistrationException(ServerRegistrationErrorCode.ValidateSyncServerFailed);
}
var serverRegistrationData = Setup(managementEndpointUri, subscriptionId, storageSyncServiceName, resourceGroupName, certificateProviderName, certificateHashAlgorithm, certificateKeyLength, monitoringDataPath, agentVersion);
if (null == serverRegistrationData)
{
throw new ServerRegistrationException(ServerRegistrationErrorCode.ProcessSyncRegistrationFailed);
}
RegisteredServer resultantRegisteredServerResource = registerOnlineCallback(resourceGroupName, storageSyncServiceName, serverRegistrationData);
if (null == resultantRegisteredServerResource)
{
throw new ServerRegistrationException(ServerRegistrationErrorCode.RegisterOnlineSyncRegistrationFailed);
}
// Setting ServerCertificate from request resource to response resource so that it can be used by Monitoring pipeline
resultantRegisteredServerResource.ServerCertificate = Convert.ToBase64String(serverRegistrationData.ServerCertificate);
if (!Persist(resultantRegisteredServerResource, subscriptionId, storageSyncServiceName, resourceGroupName, monitoringDataPath))
{
throw new ServerRegistrationException(ServerRegistrationErrorCode.PersistSyncServerRegistrationFailed);
}
return(resultantRegisteredServerResource);
}
public async Task HandleAddRegisteredServerRequest(AddRegisteredServerParams cmsCreateParams, RequestContext <bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleAddRegisteredServerRequest");
try
{
CmsTask = Task.Run(async() =>
{
try
{
ServerConnection serverConn = ValidateAndCreateConnection(cmsCreateParams.ParentOwnerUri);
if (serverConn != null)
{
// Get Current Reg Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, cmsCreateParams.RelativePath);
RegisteredServerCollection servers = parentGroup.RegisteredServers;
// Add the new server (intentionally not cheching existence to reuse the exception message)
RegisteredServer registeredServer = new RegisteredServer(parentGroup, cmsCreateParams.RegisteredServerName);
registeredServer.Description = cmsCreateParams.RegisteredServerDescription;
registeredServer.ConnectionString = serverConn.ConnectionString;
registeredServer.ServerName = cmsCreateParams.RegisteredServerConnectionDetails.ServerName;
registeredServer.Create();
await requestContext.SendResult(true);
}
else
{
await requestContext.SendResult(false);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
public async Task HandleRemoveRegisteredServerRequest(RemoveRegisteredServerParams removeServerParams, RequestContext <bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleRemoveServerRequest");
try
{
CmsTask = Task.Run(async() =>
{
try
{
// Validate and Connect
ServerConnection serverConn = ValidateAndCreateConnection(removeServerParams.ParentOwnerUri);
if (serverConn != null)
{
// Get list of registered Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, removeServerParams.RelativePath, false);
if (parentGroup != null)
{
RegisteredServer regServ = parentGroup.RegisteredServers.OfType <RegisteredServer>().FirstOrDefault(r => r.Name == removeServerParams.RegisteredServerName); // since duplicates are not allowed
regServ?.Drop();
await requestContext.SendResult(true);
}
}
else
{
await requestContext.SendResult(false);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
private void ultraListView_CollectData_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
UltraListViewSubItem item;
item = ultraListView_CollectData.SubItemFromPoint(e.Location);
if (item != null)
{
if (item.Key == "Collect")
{
RegisteredServer rServer = (RegisteredServer)item.Item.Tag;
if (rServer != null)
{
try
{
Forms.Form_StartSnapshotJobAndShowProgress.Process(rServer.ConnectionName);
System.Threading.Thread.Sleep(1000);
LoadData();
}
catch (Exception ex)
{
Utility.MsgBox.ShowError(Utility.ErrorMsgs.SQLsecureDataCollection, Utility.ErrorMsgs.CantRunDataCollection, ex);
}
}
}
else if (item.Key == "Next")
{
RegisteredServer rServer = (RegisteredServer)item.Item.Tag;
if (rServer != null)
{
Forms.Form_SqlServerProperties.Process(rServer.ConnectionName, Forms.Form_SqlServerProperties.RequestedOperation.EditSchedule, Program.gController.isAdmin);
LoadData();
}
}
}
}
}
public void RefreshRegisteredServers()
{
m_RegisteredServers = RegisteredServer.RefreshRegisteredServers();
}
/// <summary>
/// Invokes the RegisterServer2 service.
/// </summary>
public virtual ResponseHeader RegisterServer2(
RequestHeader requestHeader,
RegisteredServer server,
ExtensionObjectCollection discoveryConfiguration,
out StatusCodeCollection configurationResults,
out DiagnosticInfoCollection diagnosticInfos)
{
RegisterServer2Request request = new RegisterServer2Request();
RegisterServer2Response response = null;
request.RequestHeader = requestHeader;
request.Server = server;
request.DiscoveryConfiguration = discoveryConfiguration;
UpdateRequestHeader(request, requestHeader == null, "RegisterServer2");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (RegisterServer2Response)genericResponse;
}
else
{
RegisterServer2ResponseMessage responseMessage = InnerChannel.RegisterServer2(new RegisterServer2Message(request));
if (responseMessage == null || responseMessage.RegisterServer2Response == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.RegisterServer2Response;
ValidateResponse(response.ResponseHeader);
}
configurationResults = response.ConfigurationResults;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "RegisterServer2");
}
return response.ResponseHeader;
}
/// <summary>
/// Invokes the RegisterServer service.
/// </summary>
public virtual ResponseHeader RegisterServer(
RequestHeader requestHeader,
RegisteredServer server)
{
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Invokes the RegisterServer2 service.
/// </summary>
public virtual ResponseHeader RegisterServer2(
RequestHeader requestHeader,
RegisteredServer server,
ExtensionObjectCollection discoveryConfiguration,
out StatusCodeCollection configurationResults,
out DiagnosticInfoCollection diagnosticInfos)
{
configurationResults = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
public static bool ImportItem(ImportItem itemToImport, Repository repository, ImportSettings settings)
{
using (logX.loggerX.InfoCall())
{
string sqlServerVersion, machine, instance, connectionName, edition;
var errorList = new List <string>();
if (itemToImport.HasErrors())
{
settings.ChangeStatus(ImportStatusIcon.Warning,
string.Format("Skipped due to errors: {0}", itemToImport.GetErrors()));
return(false);
}
settings.ChangeStatus(ImportStatusIcon.Importing, "Importing");
var serverNameParts = itemToImport.ServerName.Split(',');
var serverPort = serverNameParts.Length > 1 ? Convert.ToInt32(serverNameParts[1]) : (int?)null;
ScheduleJob.ScheduleData scheduleData = new ScheduleJob.ScheduleData();
//Validation of instance connection credentials
OperationResult <bool> operationResult =
ValidateCredentials(itemToImport, out sqlServerVersion, out machine, out instance,
out connectionName, out edition);
if (!operationResult.Value)
{
settings.ChangeStatus(ImportStatusIcon.Error, string.Format("Not imported. {0}", operationResult.GetEventAllMessagesString()));
return(false); //Skip importing of server
}
// SQLsecure 3.1 (Anshul) - Validate server edition based on server type.
// SQLsecure 3.1 (Anshul) - SQLSECU-1775 - Azure VM : Register a Server as Azure DB by selecting Server type as Azure VM.
if (!SqlHelper.ValidateServerEdition(itemToImport.ServerType, edition))
{
settings.ChangeStatus(ImportStatusIcon.Error, string.Format("Not imported. {0}",
itemToImport.ServerType == ServerType.AzureSQLDatabase ? ErrorMsgs.IncorrectServerTypeAzureSQLDBImportMsg :
ErrorMsgs.IncorrectServerTypeSQLServerImportMsg));
return(false); //Skip importing of server
}
//Validation of server acces credentials (using WindowsCredentials)
//Add operation error if not successful but continue import operation
operationResult = CheckServerAccess(itemToImport, machine);
if (!operationResult.Value)
{
errorList.AddRange(operationResult.GetEventMessagesStringList());
}
;
var parsedSqlServerVersion = SqlHelper.ParseVersion(sqlServerVersion);
ServerInfo serverInfo = new ServerInfo(parsedSqlServerVersion, (itemToImport.AuthType == SqlServerAuthenticationType.WindowsAuthentication || itemToImport.AuthType == SqlServerAuthenticationType.AzureADAuthentication),
itemToImport.UserName, itemToImport.Password, connectionName, SqlServer.GetValueByName(itemToImport.ServerType));
try
{
if (repository.RegisteredServers.Find(connectionName) != null)
{
UpdateCredentials(itemToImport, repository, connectionName);
if (errorList.Count > 0)
{
settings.ChangeStatus(ImportStatusIcon.Warning, string.Format("Updated with warnings: {0}", string.Join("\n", errorList.ToArray())));
}
else
{
settings.ChangeStatus(ImportStatusIcon.Imported, "Updated");
}
return(true);
}
string serverType = itemToImport.ServerType == ServerType.OnPremise ? "OP" : (itemToImport.ServerType == ServerType.SQLServerOnAzureVM ? "AVM" : "ADB");
RegisteredServer.AddServer(repository.ConnectionString,
connectionName, serverPort, machine, instance,
(itemToImport.AuthType == SqlServerAuthenticationType.WindowsAuthentication || itemToImport.AuthType == SqlServerAuthenticationType.AzureADAuthentication) ? "W" : "S",
itemToImport.UserName, itemToImport.Password,
itemToImport.UseSameCredentials ? itemToImport.UserName : itemToImport.WindowsUserName,
itemToImport.UseSameCredentials
? itemToImport.Password
: itemToImport.WindowsUserPassword,
sqlServerVersion, 0, new string[0], serverType);
repository.RefreshRegisteredServers();
}
catch (Exception ex)
{
errorList.Add(ex.Message);
logX.loggerX.Error(ex.Message);
return(false);
}
var server = repository.RegisteredServers.Find(connectionName);
//Add email notification
try
{
int providerId = Program.gController.Repository.NotificationProvider.ProviderId;
RegisteredServerNotification rSN =
new RegisteredServerNotification(SQLCommandTimeout.GetSQLCommandTimeoutFromRegistry());
rSN.RegisteredServerId = server.RegisteredServerId;
rSN.ProviderId = providerId;
rSN.Recipients = string.Empty;
rSN.SnapshotStatus = RegisteredServerNotification.SnapshotStatusNotification_Never;
rSN.PolicyMetricSeverity = (int)RegisteredServerNotification.MetricSeverityNotificaiton.Never;
rSN.AddNotificationProvider(repository.ConnectionString);
}
catch (Exception ex)
{
errorList.Add(ex.Message);
}
// Add rules to the repository.
try
{
AddRulesToRepository(repository, instance, serverInfo);
}
catch (Exception ex)
{
errorList.Add(ex.Message);
}
// Add job to repository
try
{
AddJobToRepository(repository, scheduleData, connectionName);
}
catch (Exception ex)
{
errorList.Add(ex.Message);
}
try
{
AddServerToTags(server.RegisteredServerId);
}
catch (Exception ex)
{
errorList.Add(ex.Message);
}
var errorMessage = string.Join("\n", errorList.ToArray());
if (string.IsNullOrEmpty(errorMessage))
{
settings.ChangeStatus(ImportStatusIcon.Imported, "Imported");
}
else
{
settings.ChangeStatus(ImportStatusIcon.Warning, string.Format("Imported with warnings: {0}", errorMessage));
}
return(true);
}
}
/// <summary>
/// Starts the server application.
/// </summary>
/// <param name="configuration">The configuration.</param>
protected override void StartApplication(ApplicationConfiguration configuration)
{
base.StartApplication(configuration);
lock (m_lock)
{
try
{
// create the datastore for the instance.
m_serverInternal = new ServerInternalData(
ServerProperties,
configuration,
MessageContext,
new CertificateValidator(),
InstanceCertificate);
// create the manager responsible for providing localized string resources.
ResourceManager resourceManager = CreateResourceManager(m_serverInternal, configuration);
// create the manager responsible for incoming requests.
RequestManager requestManager = CreateRequestManager(m_serverInternal, configuration);
// create the master node manager.
MasterNodeManager masterNodeManager = CreateMasterNodeManager(m_serverInternal, configuration);
// add the node manager to the datastore.
m_serverInternal.SetNodeManager(masterNodeManager);
// put the node manager into a state that allows it to be used by other objects.
masterNodeManager.Startup();
// create the manager responsible for handling events.
EventManager eventManager = CreateEventManager(m_serverInternal, configuration);
// creates the server object.
m_serverInternal.CreateServerObject(
eventManager,
resourceManager,
requestManager);
// do any additional processing now that the node manager is up and running.
OnNodeManagerStarted(m_serverInternal);
// create the manager responsible for aggregates.
m_serverInternal.AggregateManager = CreateAggregateManager(m_serverInternal, configuration);
// start the session manager.
SessionManager sessionManager = CreateSessionManager(m_serverInternal, configuration);
sessionManager.Startup();
// start the subscription manager.
SubscriptionManager subscriptionManager = CreateSubscriptionManager(m_serverInternal, configuration);
subscriptionManager.Startup();
// add the session manager to the datastore.
m_serverInternal.SetSessionManager(sessionManager, subscriptionManager);
ServerError = null;
// setup registration information.
lock (m_registrationLock)
{
m_bindingFactory = BindingFactory.Create(configuration, MessageContext);
m_maxRegistrationInterval = configuration.ServerConfiguration.MaxRegistrationInterval;
ApplicationDescription serverDescription = ServerDescription;
m_registrationInfo = new RegisteredServer();
m_registrationInfo.ServerUri = serverDescription.ApplicationUri;
m_registrationInfo.ServerNames.Add(serverDescription.ApplicationName);
m_registrationInfo.ProductUri = serverDescription.ProductUri;
m_registrationInfo.ServerType = serverDescription.ApplicationType;
m_registrationInfo.GatewayServerUri = null;
m_registrationInfo.IsOnline = true;
m_registrationInfo.SemaphoreFilePath = null;
// add all discovery urls.
string computerName = Utils.GetHostName();
for (int ii = 0; ii < BaseAddresses.Count; ii++)
{
UriBuilder uri = new UriBuilder(BaseAddresses[ii].DiscoveryUrl);
if (String.Compare(uri.Host, "localhost", StringComparison.OrdinalIgnoreCase) == 0)
{
uri.Host = computerName;
}
m_registrationInfo.DiscoveryUrls.Add(uri.ToString());
}
// build list of registration endpoints.
m_registrationEndpoints = new ConfiguredEndpointCollection(configuration);
EndpointDescription endpoint = configuration.ServerConfiguration.RegistrationEndpoint;
if (endpoint == null)
{
endpoint = new EndpointDescription();
endpoint.EndpointUrl = Utils.Format(Utils.DiscoveryUrls[0], "localhost");
endpoint.SecurityLevel = 0;
endpoint.SecurityMode = MessageSecurityMode.SignAndEncrypt;
endpoint.SecurityPolicyUri = SecurityPolicies.Basic128Rsa15;
endpoint.Server.ApplicationType = ApplicationType.DiscoveryServer;
}
m_registrationEndpoints.Add(endpoint);
m_minRegistrationInterval = 1000;
m_lastRegistrationInterval = m_minRegistrationInterval;
// start registration timer.
if (m_registrationTimer != null)
{
m_registrationTimer.Dispose();
m_registrationTimer = null;
}
if (m_maxRegistrationInterval > 0)
{
m_registrationTimer = new Timer(OnRegisterServer, this, m_minRegistrationInterval, Timeout.Infinite);
}
}
// set the server status as running.
SetServerState(ServerState.Running);
// all initialization is complete.
OnServerStarted(m_serverInternal);
// monitor the configuration file.
if (!String.IsNullOrEmpty(configuration.SourceFilePath))
{
m_configurationWatcher = new ConfigurationWatcher(configuration);
m_configurationWatcher.Changed += new EventHandler<ConfigurationWatcherEventArgs>(this.OnConfigurationChanged);
}
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error starting application");
m_serverInternal = null;
ServiceResult error = ServiceResult.Create(e, StatusCodes.BadInternalError, "Unexpected error starting application");
ServerError = error;
throw new ServiceResultException(error);
}
}
}
/// <summary> /// Persisting the register server resource from clooud to the local service. /// </summary> /// <param name="registeredServerResource">Registered Server Resource</param> /// <param name="subscriptionId">Subscription Id</param> /// <param name="storageSyncServiceName">Storage Sync Service Name</param> /// <param name="resourceGroupName">Resource Group Name</param> /// <param name="monitoringDataPath">Monitoring data path</param> /// <returns>success status</returns> public abstract bool Persist(RegisteredServer registeredServerResource, Guid subscriptionId, string storageSyncServiceName, string resourceGroupName, string monitoringDataPath);
private void button_OK_Click(object sender, EventArgs e)
{
try
{
if (string.IsNullOrEmpty(textBox_PolicyName.Text.Trim()))
{
ultraTabControl1.SelectedTab = ultraTabControl1.Tabs[(int)FormTabs.General];
textBox_PolicyName.Focus();
MsgBox.ShowError(ERRORTITLE_CREATE, ERRORMSGNAMEEMPTY);
DialogResult = DialogResult.None;
return;
}
if (m_policy.IsPolicy)
{
// Is Policy name already used
Policy p = Program.gController.Repository.GetPolicy(textBox_PolicyName.Text);
if (p != null && p.PolicyId != m_policy.PolicyId)
{
ultraTabControl1.SelectedTab = ultraTabControl1.Tabs[(int)FormTabs.General];
textBox_PolicyName.Focus();
MsgBox.ShowError(ERRORTITLE_CREATE,
string.Format(ERRORMSGDUP, textBox_PolicyName.Text));
DialogResult = DialogResult.None;
return;
}
}
else
{
if (string.IsNullOrEmpty(textBox_PolicyName.Text))
{
ultraTabControl1.SelectedTab = ultraTabControl1.Tabs[(int)FormTabs.General];
textBox_PolicyName.Focus();
MsgBox.ShowError(ERRORTITLE_CREATE, ERRORMSGNAMEEMPTY);
DialogResult = DialogResult.None;
return;
}
Policy p = Program.gController.Repository.GetPolicy(m_policy.PolicyId);
if (p.HasAssessment(textBox_PolicyName.Text))
{
Policy a = p.GetAssessment(textBox_PolicyName.Text);
if (a.AssessmentId != m_policy.AssessmentId)
{
MsgBox.ShowError(ERRORTITLE_UPDATE,
string.Format(ERRORMSGDUP, textBox_PolicyName.Text, p.PolicyName));
DialogResult = DialogResult.None;
Cursor = Cursors.Default;
return;
}
}
}
if (!controlConfigurePolicyVulnerabilities1.OKToSave())
{
ultraTabControl1.SelectedTab = ultraTabControl1.Tabs[(int)FormTabs.SecurityChecks];
DialogResult = DialogResult.None;
return;
}
if (controlConfigurePolicyVulnerabilities1.NumSecurityChecks == 0)
{
if (DialogResult.No == MsgBox.ShowWarningConfirm(WARNINGTITLE, ErrorMsgs.NoPolicyMetricsMsg))
{
ultraTabControl1.SelectedTab = ultraTabControl1.Tabs[(int)FormTabs.SecurityChecks];
DialogResult = DialogResult.None;
return;
}
}
if (controlPolicyAddServers1.NumServers == 0)
{
if (DialogResult.No == MsgBox.ShowWarningConfirm(WARNINGTITLE, ErrorMsgs.NoPolicyServersMsg))
{
ultraTabControl1.SelectedTab = ultraTabControl1.Tabs[(int)FormTabs.Servers];
DialogResult = DialogResult.None;
return;
}
}
List <RegisteredServer> serversToAdd = null;
List <RegisteredServer> serversToRemove = null;
string dynamicSelection = null;
bool isDynamic;
controlPolicyAddServers1.GetServers(m_isCreateNew, out serversToAdd, out serversToRemove,
out dynamicSelection, out isDynamic);
int policyId = -1;
if (m_isCreateNew)
{
policyId =
Policy.AddPolicy(textBox_PolicyName.Text, textBox_Description.Text, isDynamic, dynamicSelection, _policyInterview.InterviewName, _policyInterview.GetInterviewText());
if (policyId != -1)
{
m_policy = Policy.GetPolicy(policyId);
controlConfigurePolicyVulnerabilities1.SaveMetricChanges(m_policy);
m_policy.SavePolicyToRepository(Program.gController.Repository.ConnectionString);
}
}
else
{
policyId = m_policy.PolicyId;
controlConfigurePolicyVulnerabilities1.SaveMetricChanges(m_policy);
if (m_policy.IsAssessment)
{
m_policy.AssessmentName = textBox_PolicyName.Text;
m_policy.AssessmentDescription = textBox_Description.Text;
m_policy.AssessmentNotes = _textBox_Notes.Text;
}
else
{
m_policy.SetPolicyName(textBox_PolicyName.Text);
m_policy.PolicyDescription = textBox_Description.Text;
}
m_policy.IsDynamic = isDynamic;
m_policy.DynamicSelection = dynamicSelection;
m_policy.InterviewName = _policyInterview.InterviewName;
m_policy.InterviewText = _policyInterview.GetInterviewText();
m_policy.SavePolicyToRepository(Program.gController.Repository.ConnectionString);
}
//list should be empty if dynamic
if (!isDynamic)
{
foreach (RegisteredServer rServer in serversToRemove)
{
RegisteredServer.RemoveRegisteredServerFromPolicy(rServer.RegisteredServerId, m_policy.PolicyId, m_policy.AssessmentId);
}
foreach (RegisteredServer rServer in serversToAdd)
{
RegisteredServer.AddRegisteredServerToPolicy(rServer.RegisteredServerId, policyId, m_policy.AssessmentId);
}
}
Program.gController.SignalRefreshPoliciesEvent(0);
}
catch (Exception ex)
{
string title = ERRORTITLE_UPDATE;
string msg =
string.Format(ERRORMSGFMT, textBox_PolicyName.Text, ex.Message);
if (m_isCreateNew)
{
title = ERRORTITLE_CREATE;
msg =
string.Format(ERRORMSGFMT, textBox_PolicyName.Text, ex.Message);
}
logX.loggerX.Error(msg);
MsgBox.ShowError(title, msg);
}
}
/// <summary>
/// Begins an asynchronous invocation of the RegisterServer2 service.
/// </summary>
public IAsyncResult BeginRegisterServer2(
RequestHeader requestHeader,
RegisteredServer server,
ExtensionObjectCollection discoveryConfiguration,
AsyncCallback callback,
object asyncState)
{
RegisterServer2Request request = new RegisterServer2Request();
request.RequestHeader = requestHeader;
request.Server = server;
request.DiscoveryConfiguration = discoveryConfiguration;
UpdateRequestHeader(request, requestHeader == null, "RegisterServer2");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginRegisterServer2(new RegisterServer2Message(request), callback, asyncState);
}
internal void Received( IAsyncResult result )
{
int bytes;
//Socket socket = result.AsyncState as Socket;
try
{
bytes = socket.EndReceive( result );
if( bytes == 0 )
{
Dispose();
return;
}
}
catch( Exception e )
{
Log.log( "Socket Closed? {0}", e.Message );
Dispose();
return;
}
switch( readstate )
{
case ReadState.getLength:
toread = BitConverter.ToInt32( buffer.GetBuffer(), 0 );
readstate = ReadState.getData;
protocol_timeout = DateTime.Now;
Log.log( "Received length {0}", toread, 0 );
break;
case ReadState.getData:
readstate = ReadState.getLength;
toread = 4;
protocol_timeout = DateTime.MinValue;
byte[] msg_id = new byte[4];
buffer.Read( msg_id, 0, 4 ); // use 4 bytes before deserializing content.
last_receive = DateTime.Now;
idle_tick.Change( 30000, 30000 );
Protocol.Message message = (Protocol.Message)BitConverter.ToInt32( msg_id, 0 );
switch( message )
{
default:
Log.log( "Unhandled Message Received " + message );
break;
case Protocol.Message.PingReply:
// nothing to do; no content
//Log.log( "Received ping reply..." );
break;
case Protocol.Message.ServerHello:
Protocol.ServerHello msg = Serializer.Deserialize<Protocol.ServerHello>( buffer );
//Log.log( "Received ServerHello {0} {1}", msg.ServerID, msg.ServerName );
lock( servers ) {
registered_server = servers.AddServer( msg, host_address );
}
break;
case Protocol.Message.ListServers:
Protocol.ListServers listcmd = Serializer.Deserialize<Protocol.ListServers>( buffer );
int n;
int count = 0;
send_buffer.SetLength( 8 );
send_buffer.Seek( 8, SeekOrigin.Begin );
lock( servers ) {
Protocol.RegisteredGameServer[] this_segment;
for( n = listcmd.start_offset; count < 10 && n < servers.Count; n++ ) {
count++;
}
this_segment = new Voxelarium.Protocol.RegisteredGameServer[count];
count = 0;
for( n = listcmd.start_offset; count < 10 && n < servers.Count; n++ ) {
this_segment[count] = servers [n];
count++;
}
Serializer.Serialize<Protocol.RegisteredGameServer[]>( send_buffer, this_segment);
}
byte[] output = send_buffer.GetBuffer();
byte[] msg_len = BitConverter.GetBytes( (int)(send_buffer.Length - 4) );
msg_id = BitConverter.GetBytes( (int)Protocol.Message.Servers );
for( n = 0; n < 4; n++ )
output[n] = msg_len[n];
for( n = 0; n < 4; n++ )
output[4+n] = msg_id[n];
try{
socket.Send( output, (int)send_buffer.Length, SocketFlags.None );
}
catch( SocketException se ) {
Log.log( "Unexpected close: " + se.Message );
}
break;
}
break;
}
buffer.Position = 0;
buffer.SetLength( toread ); // make sure it's big enough
socket.BeginReceive( buffer.GetBuffer(), 0, toread, SocketFlags.None, Received, null );
}
/// <summary>
/// Begins an asynchronous invocation of the RegisterServer service.
/// </summary>
public IAsyncResult BeginRegisterServer(
RequestHeader requestHeader,
RegisteredServer server,
AsyncCallback callback,
object asyncState)
{
RegisterServerRequest request = new RegisterServerRequest();
request.RequestHeader = requestHeader;
request.Server = server;
UpdateRequestHeader(request, requestHeader == null, "RegisterServer");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginRegisterServer(new RegisterServerMessage(request), callback, asyncState);
}
/// <summary>
/// Invokes the RegisterServer service.
/// </summary>
public virtual ResponseHeader RegisterServer(
RequestHeader requestHeader,
RegisteredServer server)
{
RegisterServerRequest request = new RegisterServerRequest();
RegisterServerResponse response = null;
request.RequestHeader = requestHeader;
request.Server = server;
UpdateRequestHeader(request, requestHeader == null, "RegisterServer");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (RegisterServerResponse)genericResponse;
}
else
{
RegisterServerResponseMessage responseMessage = InnerChannel.RegisterServer(new RegisterServerMessage(request));
if (responseMessage == null || responseMessage.RegisterServerResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.RegisterServerResponse;
ValidateResponse(response.ResponseHeader);
}
}
finally
{
RequestCompleted(request, response, "RegisterServer");
}
return response.ResponseHeader;
}
private void button_OK_Click(object sender, EventArgs e)
{
try
{
// Is Policy name already used
Policy p = Program.gController.Repository.GetPolicy(textBox_PolicyName.Text);
if (p != null)
{
MsgBox.ShowError("Error Creating Policy",
string.Format("Cannot create policy {0}. A policy with the name you specified already exist. Specify a different policy name.", textBox_PolicyName.Text));
DialogResult = DialogResult.None;
return;
}
int policyId = -1;
List <RegisteredServer> serversToAdd = new List <RegisteredServer>();
List <RegisteredServer> serversToRemove = new List <RegisteredServer>();
foreach (ListViewItem server in listView_AddServers.CheckedItems)
{
serversToAdd.Add((RegisteredServer)server.Tag);
}
if (!m_isCreateNew && m_orginalServersInPolicy != null)
{
foreach (RegisteredServer r in m_orginalServersInPolicy)
{
bool isStillChecked = false;
foreach (ListViewItem server in listView_AddServers.CheckedItems)
{
if ((RegisteredServer)server.Tag == r)
{
isStillChecked = true;
break;
}
}
if (!isStillChecked)
{
serversToRemove.Add(r);
}
}
foreach (RegisteredServer rServer in serversToRemove)
{
RegisteredServer.RemoveRegisteredServerFromPolicy(rServer.RegisteredServerId, m_policy.PolicyId);
}
}
if (m_isCreateNew)
{
policyId = Policy.AddPolicy(textBox_PolicyName.Text, false, string.Empty);
if (policyId != -1)
{
m_policy = Policy.GetPolicy(policyId);
controlConfigurePolicyVulnerabilities1.SaveMetricChanges(m_policy);
m_policy.SavePolicyToRepository(Program.gController.Repository.ConnectionString);
}
}
else
{
controlConfigurePolicyVulnerabilities1.SaveMetricChanges(m_policy);
m_policy.SetPolicyName(textBox_PolicyName.Text);
m_policy.SavePolicyToRepository(Program.gController.Repository.ConnectionString);
}
foreach (RegisteredServer rServer in serversToAdd)
{
RegisteredServer.AddRegisteredServerToPolicy(rServer.RegisteredServerId, policyId);
}
}
catch (Exception ex)
{
string title = "Error Updating Policy";
string msg =
string.Format("Failed to Update policy {0} error message: {1}", textBox_PolicyName.Text, ex.Message);
if (m_isCreateNew)
{
title = "Error Creating Policy";
msg =
string.Format("Failed to Create policy {0} error message: {1}", textBox_PolicyName.Text,
ex.Message);
}
logX.loggerX.Error(msg);
MsgBox.ShowError(title, msg);
}
}
/// <summary>
/// Persisting the register server resource from clooud to the local service.
/// </summary>
/// <param name="registeredServerResource">Registered Server Resource</param>
/// <param name="subscriptionId">Subscription Id</param>
/// <param name="storageSyncServiceName">Storage Sync Service Name</param>
/// <param name="resourceGroupName">Resource Group Name</param>
/// <param name="monitoringDataPath">Monitoring data path</param>
/// <returns>success status</returns>
/// <exception cref="ArgumentException">StorageSyncServiceUid
/// or
/// ServerRole
/// or
/// ClusterId</exception>
/// <exception cref="Commands.StorageSync.Interop.Exceptions.ServerRegistrationException">
/// </exception>
/// <exception cref="ServerRegistrationException">StorageSyncServiceUid
/// or
/// ServerRole
/// or
/// ClusterId</exception>
public override bool Persist(RegisteredServer registeredServerResource, Guid subscriptionId, string storageSyncServiceName, string resourceGroupName, string monitoringDataPath)
{
var storageSyncServiceUid = Guid.Empty;
bool hasStorageSyncServiceUid = Guid.TryParse(registeredServerResource.StorageSyncServiceUid, out storageSyncServiceUid);
if (!hasStorageSyncServiceUid)
{
throw new ArgumentException(nameof(registeredServerResource.StorageSyncServiceUid));
}
bool hasServerRole = Enum.TryParse(registeredServerResource.ServerRole, out ServerRoleType serverRole);
if (!hasServerRole)
{
throw new ArgumentException(nameof(registeredServerResource.ServerRole));
}
Guid clusterId = Guid.Empty;
if (serverRole == ServerRoleType.ClusterNode)
{
if (!Guid.TryParse(registeredServerResource.ClusterId, out clusterId))
{
throw new ArgumentException(nameof(registeredServerResource.ClusterId));
}
}
int hr = EcsManagementInteropClient.PersistSyncServerRegistration(
registeredServerResource.ManagementEndpointUri,
subscriptionId.ToString(),
storageSyncServiceName,
resourceGroupName,
clusterId.Equals(Guid.Empty) ? string.Empty : clusterId.ToString(),
registeredServerResource.ClusterName ?? string.Empty,
storageSyncServiceUid.ToString(),
registeredServerResource.DiscoveryEndpointUri,
registeredServerResource.ServiceLocation,
registeredServerResource.ResourceLocation);
bool success = hr == 0;
if (!success)
{
throw new ServerRegistrationException(ServerRegistrationErrorCode.PersistSyncServerRegistrationFailed, hr, ErrorCategory.InvalidResult);
}
var monitoringConfiguration = default(HybridMonitoringConfigurationResource);
if (!string.IsNullOrEmpty(registeredServerResource.MonitoringConfiguration))
{
monitoringConfiguration = JsonConvert.DeserializeObject <HybridMonitoringConfigurationResource>(registeredServerResource.MonitoringConfiguration);
}
var registrationInfo = new ServerRegistrationInformation(
serviceEndpoint: registeredServerResource.ManagementEndpointUri,
subscriptionId: subscriptionId,
resourceGroupName: resourceGroupName,
storageSyncServiceName: storageSyncServiceName,
storageSyncServiceUid: storageSyncServiceUid,
clusterName: registeredServerResource.ClusterName ?? string.Empty,
clusterId: clusterId,
monitoringConfiguration: monitoringConfiguration,
serverCertificate: registeredServerResource.ServerCertificate.ToBase64Bytes(),
resourceLocation: registeredServerResource.ResourceLocation
);
// We try to register monitoring agent but do not gurantee it to succeed.
hr = EcsManagementInteropClient.RegisterMonitoringAgent(
JsonConvert.SerializeObject(registrationInfo),
monitoringDataPath);
success = hr == 0;
if (!success)
{
throw new ServerRegistrationException(ServerRegistrationErrorCode.RegisterMonitoringAgentFailed, hr, ErrorCategory.InvalidResult);
}
return(success);
}
// Registered Server handling
public void LoadRegisteredServers()
{
m_RegisteredServers = RegisteredServer.LoadRegisteredServers(m_ConnectionStringBuilder.ConnectionString);
}
public void ServerEndpointAllOperationsTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
IResourceManagementClient resourcesClient = StorageSyncManagementTestUtilities.GetResourceManagementClient(context, handler);
IStorageSyncManagementClient storageSyncManagementClient = StorageSyncManagementTestUtilities.GetStorageSyncManagementClient(context, handler);
// Create ResourceGroup
string resourceGroupName = StorageSyncManagementTestUtilities.CreateResourceGroup(resourcesClient);
// Create ServerEndpoint
string storageSyncServiceName = TestUtilities.GenerateName("sss-sepall");
string syncGroupName = TestUtilities.GenerateName("sg-sepall");
string resourceName = TestUtilities.GenerateName("sepall");
var storageSyncServiceParameters = StorageSyncManagementTestUtilities.GetDefaultStorageSyncServiceParameters();
var syncGroupParameters = StorageSyncManagementTestUtilities.GetDefaultSyncGroupParameters();
var cloudEndpointParameters = StorageSyncManagementTestUtilities.GetDefaultCloudEndpointParameters();
StorageSyncService storageSyncServiceResource = storageSyncManagementClient.StorageSyncServices.Create(resourceGroupName, storageSyncServiceName, storageSyncServiceParameters);
Assert.NotNull(storageSyncServiceResource);
StorageSyncManagementTestUtilities.VerifyStorageSyncServiceProperties(storageSyncServiceResource, true);
SyncGroup syncGroupResource = storageSyncManagementClient.SyncGroups.Create(resourceGroupName, storageSyncServiceResource.Name, syncGroupName, syncGroupParameters);
Assert.NotNull(syncGroupResource);
StorageSyncManagementTestUtilities.VerifySyncGroupProperties(syncGroupResource, true);
CloudEndpoint cloudEndpointResource = storageSyncManagementClient.CloudEndpoints.Create(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName, cloudEndpointParameters);
Assert.NotNull(cloudEndpointResource);
StorageSyncManagementTestUtilities.VerifyCloudEndpointProperties(cloudEndpointResource, true);
RegisteredServer registeredServerResource = EnsureRegisteredServerResource(storageSyncManagementClient, resourceGroupName, storageSyncServiceName, syncGroupName, storageSyncServiceResource);
Assert.NotNull(registeredServerResource);
StorageSyncManagementTestUtilities.VerifyRegisteredServerProperties(registeredServerResource, true);
var serverEndpointParameters = StorageSyncManagementTestUtilities.GetDefaultServerEndpointParameters(registeredServerResource.Id);
var serverEndpointUpdateParameters = StorageSyncManagementTestUtilities.GetDefaultServerEndpointUpdateParameters();
// Delete Test before it exists.
storageSyncManagementClient.ServerEndpoints.Delete(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName);
ServerEndpoint serverEndpointResource = storageSyncManagementClient.ServerEndpoints.Create(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName, serverEndpointParameters);
Assert.NotNull(serverEndpointResource);
StorageSyncManagementTestUtilities.VerifyServerEndpointProperties(serverEndpointResource, true);
// GET Test
serverEndpointResource = storageSyncManagementClient.ServerEndpoints.Get(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName);
Assert.NotNull(serverEndpointResource);
StorageSyncManagementTestUtilities.VerifyServerEndpointProperties(serverEndpointResource, true);
// List Test
IEnumerable <ServerEndpoint> serverEndpoints = storageSyncManagementClient.ServerEndpoints.ListBySyncGroup(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name);
Assert.Single(serverEndpoints);
Assert.NotNull(serverEndpoints.Single());
StorageSyncManagementTestUtilities.VerifyServerEndpointProperties(serverEndpoints.Single(), true);
// Recall Test
RecallActionParameters recallActionParameters = StorageSyncManagementTestUtilities.GetDefaultRecallActionParameters();
ServerEndpointsRecallActionHeaders serverEndpointsRecallActionHeaders = storageSyncManagementClient.ServerEndpoints.RecallAction(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName, recallActionParameters);
Assert.NotNull(serverEndpointsRecallActionHeaders);
Assert.NotEmpty(serverEndpointsRecallActionHeaders.XMsCorrelationRequestId);
Assert.NotEmpty(serverEndpointsRecallActionHeaders.XMsRequestId);
// Update Test
serverEndpointResource = storageSyncManagementClient.ServerEndpoints.Update(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName, serverEndpointUpdateParameters);
Assert.NotNull(serverEndpointResource);
StorageSyncManagementTestUtilities.VerifyServerEndpointUpdateProperties(serverEndpointResource, true);
// Delete Test
storageSyncManagementClient.ServerEndpoints.Delete(resourceGroupName, storageSyncServiceResource.Name, syncGroupResource.Name, resourceName);
storageSyncManagementClient.CloudEndpoints.Delete(resourceGroupName, storageSyncServiceResource.Name, syncGroupName, resourceName);
storageSyncManagementClient.SyncGroups.Delete(resourceGroupName, storageSyncServiceResource.Name, syncGroupName);
storageSyncManagementClient.RegisteredServers.Delete(resourceGroupName, storageSyncServiceResource.Name, registeredServerResource.ServerId.Trim('"'));
storageSyncManagementClient.StorageSyncServices.Delete(resourceGroupName, storageSyncServiceResource.Name);
StorageSyncManagementTestUtilities.RemoveResourceGroup(resourcesClient, resourceGroupName);
}
}
public override ResponseHeader RegisterServer2(RequestHeader requestHeader, RegisteredServer server, ExtensionObjectCollection discoveryConfiguration, out StatusCodeCollection configurationResults, out DiagnosticInfoCollection diagnosticInfos)
{
return(base.RegisterServer2(requestHeader, server, discoveryConfiguration, out configurationResults, out diagnosticInfos));
}
