/// <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)); }