Ejemplo n.º 1
0
 public static void DeleteSetting(RegistryParam registryParam)
 {
     using (var regKey = GetRegistryKey(registryParam, true))
     {
         regKey?.DeleteValue(registryParam.Name, false);
     }
 }
Ejemplo n.º 2
0
        public static Result <T> GetSettings <T>(RegistryParam registryParam)
        {
            T regValue;

            using (var regKey = GetRegistryKey(registryParam))
            {
                if (regKey == null)
                {
                    return(Result <T> .Fail <T>("Registry Key is not found"));
                }

                if (registryParam.Name != null)
                {
                    var value = regKey.GetValue(registryParam.Name, registryParam.Value);

                    if (value == null)
                    {
                        return(Result <T> .Fail <T>("Registry Parameter is not found"));
                    }

                    regValue = (T)value;
                }
                else
                {
                    var type = typeof(T).Name.ToLowerInvariant() == "string";
                    regValue = (T)(object)registryParam.Section;
                }
            }
            return(Result <T> .Ok(regValue));
        }
Ejemplo n.º 3
0
 public RegistryChangedEventArgs(RegChangeNotifyFilter regChangeNotifyFilter, RegistryParam previous, RegistryParam current, string[] subKeys)
 {
     RegChangeNotifyFilter = regChangeNotifyFilter;
     Previous   = previous;
     Current    = current;
     NewSubKeys = subKeys;
 }
Ejemplo n.º 4
0
 public Task <ReturnT> RegistryRemove(RegistryParam registryParam)
 {
     return(InvokeRpcService("registryRemove", new List <object> {
         new JavaClass {
             Name = "com.xxl.job.core.biz.model.RegistryParam"
         }
     }, registryParam, true));
 }
Ejemplo n.º 5
0
        private static RegistryKey RegistryKeyLocalMachineX(RegistryParam registryParam, bool writable, bool create, RegistryView registryView)
        {
            var localMachineKey =
                RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, registryView);

            return(create
                ? localMachineKey.CreateSubKey(registryParam.RegistrySubKey, writable)
                : localMachineKey.OpenSubKey(registryParam.RegistrySubKey, writable));
        }
Ejemplo n.º 6
0
        private static void SaveRegistryEx(ResourceManager resourceManager, RegistryParam registryParam)
        {
            var executorRegistryService =
                new ExecutorRegistryService(
                    resourceManager,
                    registryParam,
                    RegistryAdminAction.set,
                    Guid.NewGuid());

            executorRegistryService.Execute();
        }
Ejemplo n.º 7
0
        private static RegistryKey GetRegistryKey(RegistryParam registryParam, bool writable = false, bool create = false)
        {
            RegistryKey regKey;

            switch (registryParam.RegistryHive)
            {
            case RegistryHive.ClassesRoot:
                regKey = create
                        ? Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(registryParam.RegistrySubKey, writable)
                        : Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(registryParam.RegistrySubKey, writable);
                break;

            case RegistryHive.CurrentUser:
                regKey = create
                        ? Microsoft.Win32.Registry.CurrentUser.CreateSubKey(registryParam.RegistrySubKey, writable)
                        : Microsoft.Win32.Registry.CurrentUser.OpenSubKey(registryParam.RegistrySubKey, writable);
                break;

            case RegistryHive.LocalMachine:
                regKey = RegistryKeyLocalMachine(registryParam, writable, create);
                break;

            case RegistryHive.Users:
                regKey = create
                        ? Microsoft.Win32.Registry.Users.CreateSubKey(registryParam.RegistrySubKey, writable)
                        : Microsoft.Win32.Registry.Users.OpenSubKey(registryParam.RegistrySubKey, writable);
                break;

            case RegistryHive.PerformanceData:
                regKey = create
                        ? Microsoft.Win32.Registry.PerformanceData.CreateSubKey(registryParam.RegistrySubKey, writable)
                        : Microsoft.Win32.Registry.PerformanceData.OpenSubKey(registryParam.RegistrySubKey, writable);
                break;

            case RegistryHive.CurrentConfig:
                regKey = create
                        ? Microsoft.Win32.Registry.CurrentConfig.CreateSubKey(registryParam.RegistrySubKey, writable)
                        : Microsoft.Win32.Registry.CurrentConfig.OpenSubKey(registryParam.RegistrySubKey, writable);
                break;

            case RegistryHive.DynData:
                regKey = create
#pragma warning disable CS0618
                        ? Microsoft.Win32.Registry.DynData.CreateSubKey(registryParam.RegistrySubKey, writable)
                        : Microsoft.Win32.Registry.DynData.OpenSubKey(registryParam.RegistrySubKey, writable);
#pragma warning restore CS0618
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(registryParam.RegistryHive), registryParam.RegistryHive, null);
            }

            return(regKey);
        }
Ejemplo n.º 8
0
        public static void SaveSetting(RegistryParam registryParam)
        {
            using (var regKey = GetRegistryKey(registryParam, true, true))
            {
                if (regKey == null)
                {
                    return;
                }

                regKey.SetValue(registryParam.Name, registryParam.Value, registryParam.RegistryValueKind);
            }
        }
Ejemplo n.º 9
0
 public static IEnumerable <string> GetSubKeys(RegistryParam registryParam)
 {
     string[] regValue = { };
     using (var regKey = GetRegistryKey(registryParam))
     {
         if (regKey != null)
         {
             regValue = regKey.GetSubKeyNames();
         }
     }
     return(regValue);
 }
Ejemplo n.º 10
0
        private static RegistryKey RegistryKeyLocalMachine(RegistryParam registryParam, bool writable, bool create)
        {
            var regKey = RegistryKeyLocalMachineX(registryParam, writable, create, RegistryView.Registry64);

            if (regKey != null)
            {
                return(regKey);
            }

            regKey = RegistryKeyLocalMachineX(registryParam, writable, create, RegistryView.Registry32);

            return(regKey);
        }
Ejemplo n.º 11
0
 public static bool ExistsSettings(RegistryParam registryParam)
 {
     using (var regKey = GetRegistryKey(registryParam))
     {
         if (regKey == null)
         {
             return(false);
         }
         if (registryParam.Name == null)
         {
             return(true);
         }
         var regValue = regKey.GetValue(registryParam.Name, registryParam.Value);
         return(regValue != null);
     }
 }
Ejemplo n.º 12
0
        public static string Registry(string adminaddresses, string executorappname, string executorip, int executorPort, string accessToken)
        {
            /*
             * {
             * "serverAddress": "http://127.0.0.1:8080/api",
             * "createMillisTime": 1525923077142,
             * "accessToken": "",
             * "className": "com.xxl.job.core.biz.AdminBiz",
             * "methodName": "registry",
             * "parameterTypes": [
             * "com.xxl.job.core.biz.model.RegistryParam"
             * ],
             * "parameters": [
             * {
             * "registGroup": "EXECUTOR",
             * "registryKey": "xxl-job-executor-sample1",
             * "registryValue": "172.30.128.33:62347"
             * }
             * ]
             * }
             */


            RegistryParam registryParam = new RegistryParam
            {
                registGroup   = "EXECUTOR",
                registryKey   = executorappname,
                registryValue = $"{executorip}:{executorPort}"
            };

            RpcRequest rpcRequest = new RpcRequest
            {
                accessToken      = accessToken,
                className        = "com.xxl.job.core.biz.AdminBiz",
                createMillisTime = TimeUtil.CurrentTimeMillis(),
                methodName       = "registry",
                parameters       = new object[] { registryParam },
                parameterTypes   = new[] { "com.xxl.job.core.biz.model.RegistryParam" },
                serverAddress    = adminaddresses + "/api",
            };

            var str = Newtonsoft.Json.JsonConvert.SerializeObject(rpcRequest);


            return(str);
        }
Ejemplo n.º 13
0
        public async Task RegistryAsync(CancellationToken cancellationToken)
        {
            var registryParam = new RegistryParam {
                RegistryGroup = "EXECUTOR",
                RegistryKey   = _options.AppName,
                RegistryValue = string.IsNullOrEmpty(_options.SpecialBindUrl)?
                                $"http://{_options.SpecialBindAddress}:{_options.Port}/" : _options.SpecialBindUrl
            };

            _logger.LogInformation(">>>>>>>> start registry to admin <<<<<<<<");

            var errorTimes = 0;

            while (!cancellationToken.IsCancellationRequested)
            {
                try
                {
                    var ret = await _adminClient.Registry(registryParam);

                    _logger.LogDebug("registry last result:{0}", ret?.Code);
                    errorTimes = 0;
                    await Task.Delay(Constants.RegistryInterval, cancellationToken);
                }
                catch (TaskCanceledException)
                {
                    _logger.LogInformation(">>>>> Application Stopping....<<<<<");
                }
                catch (Exception ex)
                {
                    errorTimes++;
                    await Task.Delay(Constants.RegistryInterval, cancellationToken);

                    _logger.LogError(ex, "registry error:{0},{1} Times", ex.Message, errorTimes);
                }
            }

            _logger.LogInformation(">>>>>>>> end registry to admin <<<<<<<<");

            _logger.LogInformation(">>>>>>>> start remove registry to admin <<<<<<<<");

            var removeRet = await this._adminClient.RegistryRemove(registryParam);

            _logger.LogInformation("remove registry last result:{0}", removeRet?.Code);
            _logger.LogInformation(">>>>>>>> end remove registry to admin <<<<<<<<");
        }
        public ExecutorRegistryService(ResourceManager resourceManager, RegistryParam registryParam, RegistryAdminAction registryAdminAction, object fileName)
        {
            RegistryAdminAction = registryAdminAction;
            if (fileName is Guid guidFileName)
            {
                RegistryFileName = guidFileName.ToString();
            }
            else
            {
                RegistryFileName = (string)fileName;
            }

            RegistrySaver = new RegistrySaver(registryAdminAction, RegistryFileName)
            {
                RegistryParam = registryParam
            };

            Name            = NAME;
            Arguments       = RegistrySaver.Arguments;
            ResourceManager = resourceManager;
        }
 public ReturnT <String> registryRemove(RegistryParam registryParam)
 {
     return(PostPackage("registryRemove", new[] { "com.xxl.job.core.biz.model.RegistryParam" }, new[] { registryParam }));
 }
Ejemplo n.º 16
0
 public Task <ReturnT> RegistryRemove(RegistryParam registryParam)
 {
     return(InvokeRpcService("registryRemove", registryParam));
 }
Ejemplo n.º 17
0
 private static void SetRegistryValue(ResourceManager resourceManager, RegistryParam registryParam, object value)
 {
     registryParam.Value = value;
     SaveRegistryEx(resourceManager, registryParam);
 }
Ejemplo n.º 18
0
        public void start(int port, String ip, String appName)
        {
            // valid
            if (appName == null || appName.Trim().Length == 0)
            {
                logger.Warn(">>>>>>>>>>>> xxl-job, executor registry config fail, appName is null.");
                return;
            }
            if (XxlJobExecutor.getAdminBizList() == null)
            {
                logger.Warn(">>>>>>>>>>>> xxl-job, executor registry config fail, adminAddresses is null.");
                return;
            }

            // executor address (generate addredd = ip:port)
            String executorAddress;

            if (ip != null && ip.Trim().Length > 0)
            {
                executorAddress = ip.Trim() + (":") + port;
            }
            else
            {
                executorAddress = IpUtil.getIpPort(port);
            }

            registryThread = new Thread(
                () =>
            {
                // registry
                while (!toStop1)
                {
                    try
                    {
                        RegistryParam registryParam = new RegistryParam(RegistryConfig.RegistType.EXECUTOR.ToString(), appName, executorAddress);
                        foreach (AdminBiz adminBiz in XxlJobExecutor.getAdminBizList())
                        {
                            try
                            {
                                Object registry = adminBiz.registry(registryParam);
                                ReturnT <String> registryResult = adminBiz.registry(registryParam);
                                if (registryResult != null && ReturnT <string> .SUCCESS_CODE == registryResult.code)
                                {
                                    registryResult = ReturnT <string> .SUCCESS;
                                    logger.Info(string.Format(">>>>>>>>>>> xxl-job registry success, registryParam:{0}, registryResult:{1}", registryParam, registryResult));
                                    break;
                                }
                                else
                                {
                                    logger.Info(string.Format(">>>>>>>>>>> xxl-job registry fail, registryParam:{0}, registryResult:{1}", registryParam, registryResult));
                                }
                            }
                            catch (Exception e)
                            {
                                logger.Info($">>>>>>>>>>> xxl-job registry error, registryParam:{registryParam}", e);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        logger.Error(e.Message, e);
                    }

                    Thread.Sleep(RegistryConfig.BEAT_TIMEOUT * 1000);
                }

                // registry remove
                try
                {
                    RegistryParam registryParam = new RegistryParam(RegistryConfig.RegistType.EXECUTOR.ToString(), appName, executorAddress);
                    foreach (AdminBiz adminBiz in XxlJobExecutor.getAdminBizList())
                    {
                        try
                        {
                            ReturnT <String> registryResult = adminBiz.registryRemove(registryParam);
                            if (registryResult != null && ReturnT <string> .SUCCESS_CODE == registryResult.code)
                            {
                                registryResult = ReturnT <string> .SUCCESS;
                                logger.Info(string.Format(">>>>>>>>>>> xxl-job registry-remove success, registryParam:{0}, registryResult:{1}", registryParam, registryResult));
                                break;
                            }
                            else
                            {
                                logger.Info(string.Format(">>>>>>>>>>> xxl-job registry-remove fail, registryParam:{0}, registryResult:{1}", registryParam, registryResult));
                            }
                        }
                        catch (Exception e)
                        {
                            logger.Info(string.Format(">>>>>>>>>>> xxl-job registry-remove error, registryParam:{0}", registryParam), e);
                        }
                    }
                }
                catch (Exception e)
                {
                    logger.Error(e.Message, e);
                }
                logger.Warn(">>>>>>>>>>>> xxl-job, executor registry thread destory.");
            }
                );
            registryThread.IsBackground = (true);
            registryThread.Start();
        }
Ejemplo n.º 19
0
 public RegistryChangedEventArgs(RegChangeNotifyFilter regChangeNotifyFilter, RegistryParam registryParam) :
     this(regChangeNotifyFilter, registryParam, registryParam, null)
 {
 }
Ejemplo n.º 20
0
 public RegistryChangedEventArgs(RegChangeNotifyFilter regChangeNotifyFilter, RegistryParam registryParam, string[] subKeys) :
     this(regChangeNotifyFilter, registryParam, registryParam, subKeys)
 {
 }
Ejemplo n.º 21
0
 public RegistryChangedEventArgs(RegChangeNotifyFilter regChangeNotifyFilter, RegistryParam previous, RegistryParam current) :
     this(regChangeNotifyFilter, previous, current, null)
 {
 }