Exemplo n.º 1
0
        private static void RegisterService()
        {
            var remainingArgs = Environment.GetCommandLineArgs()
                                .Where(arg => arg != RegisterServiceFlag)
                                .Select(EscapeArgs).ToList();

            remainingArgs.Add(RunAsServiceFlag);

            var host = Process.GetCurrentProcess().MainModule.FileName;

            if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
            {
                // For self-contained apps, skip the dll path
                remainingArgs = remainingArgs.Skip(1).ToList();
            }

            var fullServiceCommand = host + " " + string.Join(" ", remainingArgs);

            // Do not use LocalSystem in production, but this is good for demos as LocalSystem will have access to some random git-clone path
            // Note that when the service is already registered and running, it will be reconfigured but not restarted
            var serviceDefinition = new ServiceDefinitionBuilder(ServiceName)
                                    .WithDisplayName(ServiceDisplayName)
                                    .WithDescription(ServiceDescription)
                                    .WithBinaryPath(fullServiceCommand)
                                    .WithCredentials(Win32ServiceCredentials.LocalSystem)
                                    .WithAutoStart(true)
                                    .Build();

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition, startImmediately: true);

            Console.WriteLine($@"Successfully registered and started service ""{ServiceDisplayName}"" (""{ServiceDescription}"")");
        }
Exemplo n.º 2
0
        private static void RegisterService()
        {
            // Environment.GetCommandLineArgs() includes the current DLL from a "dotnet my.dll --register-service" call, which is not passed to Main()
            var remainingArgs = Environment.GetCommandLineArgs()
                                .Where(arg => arg != RegisterServiceFlag)
                                .Select(EscapeCommandLineArgument)
                                .Append(RunAsServiceFlag);

            var host = Process.GetCurrentProcess().MainModule.FileName;

            if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
            {
                remainingArgs = remainingArgs.Skip(1);
            }

            var fullServiceCommand = host + " " + string.Join(" ", remainingArgs);

            var serviceDefinition = new ServiceDefinitionBuilder(ServiceName)
                                    .WithDisplayName(ServiceDisplayName)
                                    .WithDescription(ServiceDescription)
                                    .WithBinaryPath(fullServiceCommand)
                                    .WithCredentials(Win32ServiceCredentials.LocalSystem)
                                    .WithAutoStart(true)
                                    .Build();

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition, true);

            Console.WriteLine(
                $@"Successfully registered and started service ""{ServiceDisplayName}"" (""{ServiceDescription}"")");
        }
Exemplo n.º 3
0
        private static string GetGeneratedCodeFromXmlDefinition(string xml)
        {
            ////var serializer = new XmlSerializer(typeof(ApisRoot));
            ////var reader = new StringReader(xml);
            ////var root = (ApisRoot)serializer.Deserialize(reader);

            MemoryStream stream    = new MemoryStream();
            StreamWriter writer    = new System.IO.StreamWriter(stream);
            var          generator = new CSharpGenerator(writer);
            var          xmlStream = new MemoryStream();
            var          xmlWriter = new StreamWriter(xmlStream);

            xmlWriter.Write(xml);
            xmlWriter.Flush();
            xmlStream.Seek(0L, SeekOrigin.Begin);

            var builder = new ServiceDefinitionBuilder();

            ////builder.AppendServiceDefinition(new ServiceDefinition(root));
            builder.AppendServiceDefinition(xmlStream);
            generator.Run(builder.Definition);
            stream.Seek(0L, SeekOrigin.Begin);
            var result = new StreamReader(stream).ReadToEnd();

            return(result);
        }
Exemplo n.º 4
0
        public void ImplicitSubReturnTypes2()
        {
            var xml        = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Root>
  <ApiGroup Name=""group"">
    <ReturnType Name=""person"" ClassName=""Person"">
      <Field Name=""location:(name)"" />
      <Field Name=""location:(country:(code))"" />
    </ReturnType>
  </ApiGroup>
</Root>";
            var serializer = new XmlSerializer(typeof(ApisRoot));
            var reader     = new StringReader(xml);
            var root       = (ApisRoot)serializer.Deserialize(reader);
            var stream     = new System.IO.MemoryStream();
            var writer     = new System.IO.StreamWriter(stream);
            var generator  = new CSharpGenerator(writer);
            var builder    = new ServiceDefinitionBuilder();

            builder.AppendServiceDefinition(new ServiceDefinition(root));
            generator.Run(builder.Definition);

            writer.Flush();
            stream.Seek(0L, System.IO.SeekOrigin.Begin);
            var result = new StreamReader(stream).ReadToEnd();

            Assert.IsFalse(string.IsNullOrEmpty(result));
        }
Exemplo n.º 5
0
        private static void RegisterService()
        {
            Logger.Log(LogLevel.Info, "Program registering as service");

            // Environment.GetCommandLineArgs() includes the current DLL from a "dotnet my.dll --register-service" call, which is not passed to Main()
            var remainingArgs = Environment.GetCommandLineArgs().Where(arg => arg != RegisterServiceFlag)
                                .Select(EscapeCommandLineArgument).Append(RunAsServiceFlag);

            var host = Process.GetCurrentProcess().MainModule.FileName;

            if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
            {
                remainingArgs = remainingArgs.Skip(1);
            }

            var fullServiceCommand = host + " " + string.Join(" ", remainingArgs);

            // Do not use LocalSystem in production.. but this is good for demos as LocalSystem will have access to some random git-clone path
            // Note that when the service is already registered and running, it will be reconfigured but not restarted
            var serviceDefinition = new ServiceDefinitionBuilder(ServiceName).WithDisplayName(ServiceDisplayName)
                                    .WithDescription(ServiceDescription).WithBinaryPath(fullServiceCommand)
                                    .WithCredentials(Win32ServiceCredentials.LocalSystem).WithAutoStart(true).Build();

            Console.WriteLine(ServiceName);
            Console.WriteLine(ServiceDisplayName);
            Console.WriteLine(ServiceDescription);
            Console.WriteLine(fullServiceCommand);

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition, true);

            Console.WriteLine(
                $@"Successfully registered and started service ""{ServiceDisplayName}"" (""{ServiceDescription}"")");
        }
Exemplo n.º 6
0
 public static ServiceDefinition BuildNonValidating(this ServiceDefinitionBuilder builder)
 {
     return(new ServiceDefinition(builder.ServiceName, builder.BinaryPath)
     {
         DisplayName = builder.DisplayName,
         Description = builder.Description,
         Credentials = builder.Credentials,
         FailureActions = builder.FailureActions,
         FailureActionsOnNonCrashFailures = builder.FailureActionsOnNonCrashFailures,
         AutoStart = builder.AutoStart,
         ErrorSeverity = builder.ErrorSeverity
     });
 }
Exemplo n.º 7
0
        public void ImplicitSubReturnTypes()
        {
            var stream    = new System.IO.MemoryStream();
            var writer    = new System.IO.StreamWriter(stream);
            var generator = new CSharpGenerator(writer);
            var root      = new ApisRoot
            {
                ApiGroups = new List <ApiGroup>()
                {
                    new ApiGroup
                    {
                        Name        = "g",
                        Methods     = new List <ApiMethod>(),
                        ReturnTypes = new List <ReturnType>()
                        {
                            new ReturnType
                            {
                                Name   = "r1",
                                Fields = new List <Field>()
                                {
                                    new Field
                                    {
                                        Name = "f1",
                                    },
                                    new Field
                                    {
                                        Name = "f2:(r2:(name))",
                                    },
                                },
                            },
                        },
                    },
                },
            };
            var builder = new ServiceDefinitionBuilder();

            builder.AppendServiceDefinition(new ServiceDefinition(root));
            generator.Run(builder.Definition);

            writer.Flush();
            stream.Seek(0L, System.IO.SeekOrigin.Begin);
            var result = new StreamReader(stream).ReadToEnd();

            Assert.IsFalse(string.IsNullOrEmpty(result));
            Assert.IsTrue(result.Contains("public class R1"));
            Assert.IsTrue(result.Contains("public class F2"));
            Assert.IsTrue(result.Contains("public string F1"));
            Assert.IsTrue(result.Contains("public F2 F2"));
            Assert.IsTrue(result.Contains("public string Name"));
        }
Exemplo n.º 8
0
 public void Register(Action <ServiceMessage> error)
 {
     try {
         var cmd = $"{Process.GetCurrentProcess().MainModule.FileName} {RunAsServiceHostFlag}";
         var serviceDefinition = new ServiceDefinitionBuilder(ServiceName)
                                 .WithDisplayName(ServiceName)
                                 .WithDescription(ServiceDescription)
                                 .WithBinaryPath(cmd)
                                 .WithCredentials(Win32ServiceCredentials.NetworkService)
                                 .WithAutoStart(true)
                                 .Build();
         this.Manager.CreateOrUpdateService(serviceDefinition, startImmediately: true);
     } catch (Exception e) {
         ServiceMessage.Send(error, $"Register: {e.Message}");
     }
 }
Exemplo n.º 9
0
        public void MyTestMethod()
        {
            var stream    = new System.IO.MemoryStream();
            var writer    = new System.IO.StreamWriter(stream);
            var generator = new CSharpGenerator(writer);
            var root      = new ApisRoot
            {
                ApiGroups = new List <ApiGroup>()
                {
                    new ApiGroup
                    {
                        Name    = "g",
                        Methods = new List <ApiMethod>()
                        {
                            new ApiMethod
                            {
                                Path       = "/v1/test1",
                                MethodName = "mtd1",
                            },
                            new ApiMethod
                            {
                                Path       = "/v1/test1/{UserId}",
                                MethodName = "mtd2",
                            },
                        },
                        ReturnTypes = new List <ReturnType>(),
                    },
                },
            };
            var builder = new ServiceDefinitionBuilder();

            builder.AppendServiceDefinition(new ServiceDefinition(root));
            generator.Run(builder.Definition);

            writer.Flush();
            stream.Seek(0L, System.IO.SeekOrigin.Begin);
            var result = new StreamReader(stream).ReadToEnd();

            Assert.IsFalse(string.IsNullOrEmpty(result));
            Assert.IsTrue(result.Contains("public void mtd1("));
            Assert.IsTrue(result.Contains("public void mtd2("));
            Assert.IsTrue(result.Contains("string userId"));
        }
Exemplo n.º 10
0
        private static void RegisterService()
        {
            // Environment.GetCommandLineArgs() includes the current DLL from a "dotnet my.dll --register-service" call, which is not passed to Main()
            var commandLineArgs = Environment.GetCommandLineArgs();

            var serviceArgs = commandLineArgs
                              .Where(arg => arg != RegisterServiceFlag && arg != PreserveWorkingDirectoryFlag)
                              .Select(EscapeCommandLineArgument)
                              .Append(RunAsServiceFlag);

            var host = Process.GetCurrentProcess().MainModule.FileName;

            if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
            {
                // For self-contained apps, skip the dll path
                serviceArgs = serviceArgs.Skip(1);
            }

            if (commandLineArgs.Contains(PreserveWorkingDirectoryFlag))
            {
                serviceArgs = serviceArgs
                              .Append(ServiceWorkingDirectoryFlag)
                              .Append(EscapeCommandLineArgument(Directory.GetCurrentDirectory()));
            }

            var fullServiceCommand = host + " " + string.Join(" ", serviceArgs);

            // Do not use LocalSystem in production.. but this is good for demos as LocalSystem will have access to some random git-clone path
            // When the service is already registered and running, it will be reconfigured but not restarted
            var serviceDefinition = new ServiceDefinitionBuilder(ServiceName)
                                    .WithDisplayName(ServiceDisplayName)
                                    .WithDescription(ServiceDescription)
                                    .WithBinaryPath(fullServiceCommand)
                                    .WithCredentials(Win32ServiceCredentials.LocalSystem)
                                    .WithAutoStart(true)
                                    .Build();

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition, startImmediately: true);

            WriteLine($@"Successfully registered and started service ""{ServiceDisplayName}"" (""{ServiceDescription}"")");
        }
Exemplo n.º 11
0
        private static void Install(IService service)
        {
            var failureAction = new ScAction
            {
                Type  = ScActionType.ScActionRestart,
                Delay = TimeSpan.FromMinutes(1)
            };

            var serviceDefinition = new ServiceDefinitionBuilder(service.ServiceName)
                                    .WithDisplayName(service.DisplayName)
                                    .WithDescription(service.Description)
                                    .WithBinaryPath(Process.GetCurrentProcess().MainModule.FileName + " run-as-service")
                                    .WithAutoStart(true)
                                    .WithFailureActions(new ServiceFailureActions(TimeSpan.FromMinutes(1), "", "", new[] { failureAction, failureAction, failureAction }))
                                    .WithCredentials(Win32ServiceCredentials.LocalSystem)
                                    .Build();

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition);

            Console.WriteLine($"service {service.ServiceName} installed successfully.");
        }
Exemplo n.º 12
0
        public void ImplicitAndExplicitReturnTypes()
        {
            var xml        = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Root>
  <ApiGroup Name=""group"">
    <ApiMethod MethodName=""ftw"" ReturnType=""Person"" Path=""/ftw"" />
    <ReturnType Name=""person"" ClassName=""Person"">
      <Field Name=""location"" Type=""PersonLocation"" />
    </ReturnType>
    <ReturnType Name=""location"" ClassName=""PersonLocation"">
      <Field Name=""name"" />
    </ReturnType>
  </ApiGroup>
</Root>";
            var serializer = new XmlSerializer(typeof(ApisRoot));
            var reader     = new StringReader(xml);
            var root       = (ApisRoot)serializer.Deserialize(reader);
            var stream     = new System.IO.MemoryStream();
            var writer     = new System.IO.StreamWriter(stream);
            var generator  = new CSharpGenerator(writer);
            var builder    = new ServiceDefinitionBuilder();

            builder.AppendServiceDefinition(new ServiceDefinition(root));
            generator.Run(builder.Definition);

            writer.Flush();
            stream.Seek(0L, System.IO.SeekOrigin.Begin);
            var result = new StreamReader(stream).ReadToEnd();

            Assert.IsFalse(string.IsNullOrEmpty(result));
            Assert.IsFalse(string.IsNullOrEmpty(result));
            Assert.IsTrue(result.Contains("public class Person"));
            Assert.IsTrue(result.Contains("public class PersonLocation"));
            Assert.IsTrue(result.Contains("public PersonLocation Location"));
            Assert.IsFalse(result.Contains("public class Location"));
            Assert.IsTrue(result.Contains("public string Name"));
        }
Exemplo n.º 13
0
        public static void RegisterService(string registerFlag, string runFlag)
        {
            var remainingArgs = Environment.GetCommandLineArgs()
                                .Where(arg => arg != registerFlag)
                                .Select(arg =>
            {
                arg = Regex.Replace(arg, @"(\\*)" + "\"", @"$1$1\" + "\"");
                arg = "\"" + Regex.Replace(arg, @"(\\+)$", @"$1$1") + "\"";
                return(arg);
            })
                                .Append(runFlag);

            var host = Process.GetCurrentProcess().MainModule.FileName;

            if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
            {
                // For self-contained apps, skip the dll path
                remainingArgs = remainingArgs.Skip(1);
            }

            var fullServiceCommand = host + " " + string.Join(" ", remainingArgs);

            // Do not use LocalSystem in production.. but this is good for demos as LocalSystem will have access to some random git-clone path
            // Note that when the service is already registered and running, it will be reconfigured but not restarted
            var serviceDefinition = new ServiceDefinitionBuilder("Simpbot.Cli.Service")
                                    .WithDisplayName("Simpbot.Cli.Service")
                                    .WithDescription("Simple bot built with Discrod.NET")
                                    .WithBinaryPath(fullServiceCommand)
                                    .WithCredentials(Win32ServiceCredentials.LocalSystem)
                                    .WithAutoStart(true)
                                    .Build();

            new Win32ServiceManager().CreateOrUpdateService(serviceDefinition, true);

            Console.WriteLine($@"Successfully registered and started service Simpbot.Cli");
        }
Exemplo n.º 14
0
        public void ValidateAndExecuteService()
        {
            var iSendFireService = GetServiceSingleton();

            try
            {
                //File.Create("C:\\GotThere.FactoryBaseValidateAndExecute.txt");
                iSendFireService.Init(ServiceProvider);

                var status = iSendFireService.ValidateConfiguration();

                DisplayStartup(iSendFireService, status);

                switch (status)
                {
                case BaseCommandArgumentSelected.DisplayHelp:
                    Environment.ExitCode = 1;
                    Thread.Sleep(500);     // Allow NLog Console Logging.
                    break;

                case BaseCommandArgumentSelected.ExecuteProgramAsConsole:
                    Console.Title = iSendFireService.ApplicationName;
                    iSendFireService.Start();

                    Console.WriteLine($"Running {iSendFireService.ServiceName} in Console Mode.");
                    Console.WriteLine("Hit any Key to Stop...");
                    Console.ReadKey();
                    Console.WriteLine("Key Registered, Stopping...");

                    iSendFireService.Stop();
                    Thread.Sleep(500);     // Allow NLog Console Logging.
                    break;

                case BaseCommandArgumentSelected.ExecuteProgramAsService:
                    //File.Create("C:\\GotThere.FactoryBaseValidateAndExecute.ExecuteProgramAsService.txt");

                    var serviceHost = new Win32ServiceHost(iSendFireService);
                    serviceHost.Run();
                    break;

                case BaseCommandArgumentSelected.RegisterService:
                    var rebuiltArguments = Environment.GetCommandLineArgs()
                                           .Where(arg =>
                                                  !arg.EndsWith(BaseCommandArguments.RegisterService, StringComparison.OrdinalIgnoreCase))
                                           .Select(EscapeCommandLineArgument);
                    var host = Process.GetCurrentProcess().MainModule.FileName;

                    if (!host.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
                    {
                        // For self-contained apps, skip the dll path
                        rebuiltArguments = rebuiltArguments.Skip(1);
                    }

                    var fullServiceCommand = host + " " + string.Join(" ", rebuiltArguments);

                    // Note that when the service is already registered and running, it will be reconfigured but not restarted
                    var serviceDefinition = new ServiceDefinitionBuilder(iSendFireService.ServiceName)
                                            .WithDisplayName(iSendFireService.GetServiceDisplayName())
                                            .WithDescription(iSendFireService.GetServiceDescription())
                                            .WithBinaryPath(fullServiceCommand)
                                            // TODO: Support more than LocalSystem in the future
                                            .WithCredentials(Win32ServiceCredentials.LocalSystem)
                                            // TODO: Support more than autostart in the future
                                            .WithAutoStart(true)
                                            .Build();

                    ServiceProvider.GetService <Win32ServiceManager>().CreateOrUpdateService(serviceDefinition, true);

                    Console.WriteLine($@"Successfully registered and started service ""{iSendFireService.ServiceName}"" (""{iSendFireService.GetHelpDescription()}"")");
                    break;

                case BaseCommandArgumentSelected.UninstallService:

                    ServiceProvider.GetService <Win32ServiceManager>().DeleteService(iSendFireService.ServiceName);

                    break;
                }
            }
            catch (Exception ex)
            {
                var errorTitle = $"{iSendFireService.ApplicationName} Startup Exception!";
                //File.WriteAllText(".\\SendFireServiceFactoryBase.err", ex.Message + Environment.NewLine + ex.StackTrace);
                // Catastrophic failure of DI and configuration building, display exception and shut down.
                if (Logger != null)
                {
                    DisplayStartup(iSendFireService, BaseCommandArgumentSelected.DisplayHelp);
                    // TODO: Need a better logger than the base logger.
                    Logger.LogCritical(errorTitle, ex);
                    Logger.LogCritical(ex.Message);
                    Thread.Sleep(500); // Allow Console / Other Logging if its on a background thread.
                }
                else
                {
                    Console.WriteLine(errorTitle);
                    Console.WriteLine(ex.Message);
                }
            }
        }