/// <summary>Snippet for CreateService</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void CreateService()
{
// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
ManagedService service = new ManagedService();
// Make the request
Operation <ManagedService, OperationMetadata> response = serviceManagerClient.CreateService(service);
// Poll until the returned long-running operation is complete
Operation <ManagedService, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
ManagedService result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <ManagedService, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceCreateService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
ManagedService retrievedResult = retrievedResponse.Result;
}
}
public async stt::Task GetServiceRequestObjectAsync()
{
moq::Mock <ServiceManager.ServiceManagerClient> mockGrpcClient = new moq::Mock <ServiceManager.ServiceManagerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetServiceRequest request = new GetServiceRequest
{
ServiceName = "service_named5df05d5",
};
ManagedService expectedResponse = new ManagedService
{
ServiceName = "service_named5df05d5",
ProducerProjectId = "producer_project_id18d0012a",
};
mockGrpcClient.Setup(x => x.GetServiceAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <ManagedService>(stt::Task.FromResult(expectedResponse), null, null, null, null));
ServiceManagerClient client = new ServiceManagerClientImpl(mockGrpcClient.Object, null);
ManagedService responseCallSettings = await client.GetServiceAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
ManagedService responseCancellationToken = await client.GetServiceAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for GetService</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void GetService()
{
// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
// Make the request
ManagedService response = serviceManagerClient.GetService(serviceName);
}
/// <summary>Snippet for GetServiceAsync</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task GetServiceAsync()
{
// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
ManagedService response = await serviceManagerClient.GetServiceAsync(serviceName);
}
/// <summary>Snippet for GetService</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void GetServiceRequestObject()
{
// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
GetServiceRequest request = new GetServiceRequest {
ServiceName = "",
};
// Make the request
ManagedService response = serviceManagerClient.GetService(request);
}
/// <summary>Snippet for GetServiceAsync</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task GetServiceRequestObjectAsync()
{
// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceRequest request = new GetServiceRequest {
ServiceName = "",
};
// Make the request
ManagedService response = await serviceManagerClient.GetServiceAsync(request);
}
internal void CleanUpSemaphore(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
MyLogger.Debug("Clean up Semaphore for {0}", svc.ConsulServiceName);
var qr = ConsulClient.KV.List(Config.KvPrefix + Config.SemaPrefix + svc.ConsulServiceName);
if (qr.Response != null)
{
KVPair[] sessions = qr.Response.Where(kv=>!kv.Key.EndsWith("/") && !kv.Key.EndsWith(".lock")).ToArray();
foreach (var kv in sessions)
{
var wr = ConsulClient.KV.Delete(kv.Key);
}
}
}
/// <summary>
/// Additional operations to be performed when cloning an instance of <see cref="ManagedService" /> to an instance of <see cref="PSManagedService" />.
/// </summary>
/// <param name="managedService">The managed service being cloned.</param>
private void CloneAdditionalOperations(ManagedService managedService)
{
ManagedServiceId = managedService.Id;
if (managedService.Links != null)
{
if (managedService.Links.AdminService != null)
{
Links.Add(nameof(managedService.Links.AdminService), managedService.Links.AdminService.Uri);
}
if (managedService.Links.ServiceHealth != null)
{
Links.Add(nameof(managedService.Links.ServiceHealth), managedService.Links.ServiceHealth.Uri);
}
if (managedService.Links.ServiceTicket != null)
{
Links.Add(nameof(managedService.Links.ServiceTicket), managedService.Links.ServiceTicket.Uri);
}
}
}
public void GetService()
{
moq::Mock <ServiceManager.ServiceManagerClient> mockGrpcClient = new moq::Mock <ServiceManager.ServiceManagerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetServiceRequest request = new GetServiceRequest
{
ServiceName = "service_named5df05d5",
};
ManagedService expectedResponse = new ManagedService
{
ServiceName = "service_named5df05d5",
ProducerProjectId = "producer_project_id18d0012a",
};
mockGrpcClient.Setup(x => x.GetService(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
ServiceManagerClient client = new ServiceManagerClientImpl(mockGrpcClient.Object, null);
ManagedService response = client.GetService(request.ServiceName);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Initializes a new instance of the <see cref="PSManagedService" /> class.
/// </summary>
/// <param name="managedService">The base managed service for this instance.</param>
public PSManagedService(ManagedService managedService)
{
Links = new Dictionary <string, Uri>();
this.CopyFrom(managedService, CloneAdditionalOperations);
}
void AllInOne(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
// Wait if service is ready to manage
if (!svc.CanRun) MyLogger.Info("Wait for service {0} to get in a ready state", svc.ConsulServiceName);
while (!_shouldStop && !svc.CanRun && svc.ShouldRun)
{
Thread.Sleep(1000);
}
MyLogger.Debug("Service {0} is ready, wait for lock", svc.ConsulServiceName);
while (!_shouldStop && svc.ShouldRun)
{
var semaphoreOptions = new SemaphoreOptions(Config.KvPrefix + Config.SemaPrefix + svc.ConsulServiceName,
svc.Limit) { SessionName = svc.ConsulServiceName + "_Session", SessionTTL = TimeSpan.FromSeconds(10) };
var semaphore = ConsulClient.Semaphore(semaphoreOptions);
// Try to get a lock until it is aqcuired or the program should stop
while (!_shouldStop && !semaphore.IsHeld && svc.ShouldRun)
{
MyLogger.Info("Acquiring lock on semaphore for {0}", svc.ConsulServiceName);
try
{
semaphore.Acquire();
}
catch
{
Thread.Sleep(1000);
}
}
// if the program should not stop and the semaphore is aqcuired, start the service
if (!_shouldStop && svc.ShouldRun && semaphore.IsHeld && (ServiceHelper.GetServiceStatus(svc.WindowsServiceName) != "Running"))
{
bool svcstarted = StartService(svc);
MyLogger.Info("Service {0} send start command with success: {1}", svc.WindowsServiceName, svcstarted);
}
// Make sure the service runs while the lock is held or the program should stop, otherwise stop the service and releade the lock
while (!_shouldStop && svc.ShouldRun && semaphore.IsHeld)
{
ServiceController sc = new ServiceController(svc.WindowsServiceName);
if (sc.Status != ServiceControllerStatus.Running)
{
MyLogger.Debug("Service not running, releasing lock");
if (semaphore.IsHeld) semaphore.Release();
}
sc.Close();
}
if (_shouldStop || !svc.ShouldRun)
{
if (ServiceHelper.GetServiceStatus(svc.WindowsServiceName) == "Running")
{
bool svcstopped = StopService(svc);
MyLogger.Info("Service {0} send stop command with success: {1}", svc.WindowsServiceName, svcstopped);
}
if (semaphore.IsHeld) semaphore.Release();
try
{
semaphore.Destroy();
}
catch (Exception ex)
{
MyLogger.Error("some error: {0}",ex.Message);
MyLogger.Debug(ex);
}
}
else
{
MyLogger.Info("Lock no longer held for {0}",svc.WindowsServiceName);
//Release lock because it could be the lock isheld was set to false due to consistency timeout
try
{
semaphore.Release();
}
catch (SemaphoreNotHeldException)
{
}
catch (Exception ex1) {
MyLogger.Error("Some error: {0}",ex1.Message);
MyLogger.Debug(ex1);
}
if (ServiceHelper.GetServiceStatus(svc.WindowsServiceName) == "Running")
{
bool svcstopped = StopService(svc);
MyLogger.Info("Service {0} send stop command with success: {1}", svc.WindowsServiceName, svcstopped);
}
}
}
}
private bool StopService(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
try
{
PermissionSet ps = GetServicePermission(svc);
ps.Assert();
}
catch (Exception ex)
{
MyLogger.Error("Cannot aquire service control permisison: {0}", ex.Message);
MyLogger.Debug(ex);
return false;
}
ServiceController sc = new ServiceController(svc.WindowsServiceName, Environment.MachineName);
if (sc.Status != ServiceControllerStatus.Stopped)
{
if (sc.Status == ServiceControllerStatus.StopPending)
{
MyLogger.Debug("Stop pending");
}
else
{
MyLogger.Info("Service {0} send stop command", svc.WindowsServiceName);
sc.Stop();
}
sc.WaitForStatus(ServiceControllerStatus.Stopped, TimeSpan.FromSeconds(10.0));
if (sc.Status != ServiceControllerStatus.Stopped)
{
MyLogger.Error("Service did not stop correctly, current status: {0}", sc.Status);
sc.Close();
CodeAccessPermission.RevertAssert();
return false;
}
}
sc.Close();
CodeAccessPermission.RevertAssert();
return true;
}
/// <summary>
/// Monitors the service running and ready state.
/// </summary>
/// <param name="svc">The SVC.</param>
void MonitorService(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
MyLogger.Info("Start monitoring service {0} for cluster{1}",svc.WindowsServiceName,svc.ConsulServiceName);
//Should we continue or is the Orek service stopping
Stopwatch sw = new Stopwatch();
while (!_shouldStop)
{
sw.Restart();
//Check if service is ready
svc.CanRun = CheckServiceReady(svc);
//Check if service is running
CheckServiceRunning(svc);
if (sw.ElapsedMilliseconds < (svc.HeartBeatTtl/2))
{
Thread.Sleep(Convert.ToInt32((svc.HeartBeatTtl/2) - sw.ElapsedMilliseconds));
}
else
{
MyLogger.Warn("Monitoring Service takes longer than 50% of the Heartbeat ttl, Consider increasing the ttl value");
}
}
MyLogger.Info("Stopped monitoring service {0} for cluster{1}", svc.WindowsServiceName, svc.ConsulServiceName);
}
/// <summary>
/// Gets the service control permission.
/// </summary>
/// <param name="svc">The SVC.</param>
/// <returns></returns>
/// <exception cref="System.Security.SecurityException">when the permission cannot be acquired</exception>
private PermissionSet GetServicePermission(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
// Creates a permission set that allows no access to the resource.
PermissionSet ps = new PermissionSet(System.Security.Permissions.PermissionState.None);
// Sets the security permission flag to use for this permission set.
ps.AddPermission(new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.Assertion));
// Initializes a new instance of the System.ServiceProcess.ServiceControllerPermission class.
ps.AddPermission(new ServiceControllerPermission(ServiceControllerPermissionAccess.Control, Environment.MachineName, svc.WindowsServiceName));
ps.Demand();
return ps;
}
/// <summary>
/// Checks if the service status is "Running" and puts either a Pass or a Fail to the TTL Check
/// </summary>
/// <param name="svc">The managed service.</param>
private void CheckServiceRunning(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
string stat = ServiceHelper.GetServiceStatus(svc.WindowsServiceName);
if (stat == "Running")
{
SendPassTTL(svc.ConsulServiceName + "_Running", stat);
}
else
{
SendFailTTL(svc.ConsulServiceName + "_Running", stat);
}
}
/// <summary>
/// Checks if the service is ready to run.
/// For now that means the service startup should be set to Manual.
/// </summary>
/// <param name="svc">The managed service.</param>
private bool CheckServiceReady(ManagedService svc)
{
MyLogger.Trace("Entering {0} for service: {1}", MethodBase.GetCurrentMethod().Name, svc.ConsulServiceName);
try
{
GetServicePermission(svc);
}
catch (Exception ex)
{
MyLogger.Error("Service Control permission for service {0} cannot be acquired: {1}", svc.WindowsServiceName, ex.Message);
MyLogger.Debug(ex);
SendFailTTL(svc.ConsulServiceName + "_Ready", "Service Control Permission not granted");
return false;
}
string stat = ServiceHelper.GetStartupType(svc.WindowsServiceName);
if (stat != "Manual")
{
SendFailTTL(svc.ConsulServiceName + "_Ready","Service Startup not set to Manual");
return false;
}
SendPassTTL(svc.ConsulServiceName + "_Ready", stat);
return true;
}
