private NtToken GetServiceToken(TokenAccessRights desired_access, ServiceAccountType service_type)
        {
            string user = string.Empty;

            switch (service_type)
            {
            case ServiceAccountType.System:
                user = "******";
                break;

            case ServiceAccountType.LocalService:
                user = "******";
                break;

            case ServiceAccountType.NetworkService:
                user = "******";
                break;

            case ServiceAccountType.IUsr:
                user = "******";
                break;
            }
            using (GetTcbPrivilege())
            {
                return(GetLogonToken(desired_access, user, "NT AUTHORITY", null, SecurityLogonType.Service));
            }
        }
Example #2
0
 public ResModel AddServiceAccountType(ServiceAccountTypeDto serviceAccountTypeDto, UserDto operationUser)
 {
     using (var db = new ModelContext())
     {
         var serviceAccountType = new ServiceAccountType()
         {
             Id          = Guid.NewGuid(),
             Name        = serviceAccountTypeDto.Name,
             Description = serviceAccountTypeDto.Description
         };
         try
         {
             db.ServiceAccountType.Add(serviceAccountType);
             db.SaveChanges();
         }
         catch (Exception e)
         {
             return(new ResModel()
             {
                 Msg = "添加结算方式失败", Success = false
             });
         }
         return(new ResModel()
         {
             Msg = "添加结算方式成功", Success = true
         });
     }
 }
        private static ServiceAccount GetAccountType(ServiceAccountType type)
        {
            switch (type)
            {
            case ServiceAccountType.LocalService:
                return(ServiceAccount.LocalService);

            case ServiceAccountType.NetworkService:
                return(ServiceAccount.NetworkService);

            case ServiceAccountType.LocalSystem:
                return(ServiceAccount.LocalSystem);

            case ServiceAccountType.User:
                return(ServiceAccount.User);

            default:
                throw new ArgumentOutOfRangeException(nameof(type), type, null);
            }
        }
 private static ServiceAccount GetAccountType(ServiceAccountType type)
 {
     switch (type)
     {
         case ServiceAccountType.LocalService:
             return ServiceAccount.LocalService;
         case ServiceAccountType.NetworkService:
             return ServiceAccount.NetworkService;
         case ServiceAccountType.LocalSystem:
             return ServiceAccount.LocalSystem;
         case ServiceAccountType.User:
             return ServiceAccount.User;
         default:
             throw new ArgumentOutOfRangeException(nameof(type), type, null);
     }
 }
        public static TrendyolAppBuilder UseDaemon <T>(this TrendyolAppBuilder appBuilder,
                                                       string serviceName,
                                                       int defaultStartStopTimeoutInMinutes  = 3,
                                                       ServiceAccountType serviceAccountType = ServiceAccountType.LocalSystem,
                                                       string serviceAccountUserName         = "",
                                                       string serviceAccountPassword         = "",
                                                       params string[] dependencies) where T : TrendyolWindowsService
        {
            appBuilder.AfterBuild(() =>
            {
                HostFactory.Run(x =>
                {
                    x.Service <T>(s =>
                    {
                        s.ConstructUsing(srv => Activator.CreateInstance <T>());
                        s.WhenStarted(srv => srv.Start());
                        s.WhenStopped(srv => srv.Stop());
                    });

                    x.OnException((ex) =>
                    {
                        Logger.Error($"There was a problem executing {serviceName}.", ex);
                    });

                    x.StartAutomatically();
                    x.SetStartTimeout(TimeSpan.FromMinutes(defaultStartStopTimeoutInMinutes));
                    x.SetStopTimeout(TimeSpan.FromMinutes(defaultStartStopTimeoutInMinutes));
                    x.SetDescription(serviceName);
                    x.SetDisplayName(serviceName);
                    x.SetServiceName(serviceName);

                    if (dependencies != null && dependencies.Any())
                    {
                        foreach (string dependency in dependencies)
                        {
                            x.AddDependency(dependency);
                        }
                    }

                    switch (serviceAccountType)
                    {
                    case ServiceAccountType.LocalSystem:
                        x.RunAsLocalSystem();
                        break;

                    case ServiceAccountType.Custom:
                        if (String.IsNullOrEmpty(serviceAccountUserName))
                        {
                            throw new ArgumentException("ServiceAccountUserName cannot be null when account type is set to custom.", nameof(serviceAccountUserName));
                        }

                        if (String.IsNullOrEmpty(serviceAccountPassword))
                        {
                            throw new ArgumentException("ServiceAccountPassword cannot be null when account type is set to custom.", nameof(serviceAccountPassword));
                        }

                        x.RunAs(serviceAccountUserName, serviceAccountPassword);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException(nameof(serviceAccountType), serviceAccountType, null);
                    }
                });
            });

            return(appBuilder);
        }