Esempio n. 1
0
        protected override void OnExit(ExitEventArgs e)
        {
            CachingConfig.Save();

            base.OnExit(e);
        }
Esempio n. 2
0
        private static void CommonParameterValidate(ActionExecutingContext context)
        {
            var request = context.RequestContext.HttpContext.Request;

            var uid = request[Define.Uid];

            if (String.IsNullOrEmpty(uid))
            {
                throw new System.ArgumentNullException(Define.Uid);
            }

            //获取客户端操作系统
            //var os = nameValueCollection[Define.OS];

            //if (string.IsNullOrEmpty(os))
            //{
            //    throw new System.ArgumentNullException(Define.OS);
            //}

            //获取时间戳
            //var timeReq = nameValueCollection[Define.TimeReq];

            //if (string.IsNullOrEmpty(timeReq))
            //{
            //    throw new System.ArgumentNullException(Define.TimeReq);
            //}

            //获取签名串
            var sign = request[Define.Sign];

            if (String.IsNullOrEmpty(sign))
            {
                throw new System.ArgumentNullException(Define.Sign);
            }

            //客户端版本
            var clientVersion = request[Define.ClientVersion];

            if (String.IsNullOrEmpty(clientVersion))
            {
                throw new ArgumentNullException(Define.ClientVersion);
            }

            #region 进行签名验证

            const string os = "iphone";
            //根据os获取不同的appkey
            var appkey = CachingConfig.GetAppkey(os);
            var vList  = new Dictionary <string, string> {
                { Define.ClientVersion, HttpUtility.UrlDecode(clientVersion, Encoding.UTF8) }, { Define.Uid, HttpUtility.UrlDecode(uid, Encoding.UTF8) }
            };

            var builder = new StringBuilder();
            builder.Append(appkey);

            var kOrder = vList.Keys.OrderBy(v => v);
            foreach (var k in kOrder)
            {
                builder.AppendFormat("{0}{1}", k, vList[k]);
            }

            builder.Append(appkey);

            var str = GetMd5Hash(builder.ToString());

            var isOk = System.String.Compare(sign, str, StringComparison.OrdinalIgnoreCase) == 0;

            if (!isOk)
            {
                throw new System.Security.SecurityException("签名验证失败");
            }

            #endregion
        }
Esempio n. 3
0
        public void Create(string route, MethodInfo serverMethodInfo, MethodInfo clientMethodInfo, List <Type> serverInterceptors, List <Type> clientInterceptors)
        {
            if (ServiceInvokers.ContainsKey(route))
            {
                throw new DuplicateRouteException(route);
            }
            var enableClient = ServiceProvider.GetService <ILoadBalancing>() != null;
            ServiceCircuitBreakerOptions breaker = null;
            CachingConfig cachingConfig          = null;

            if (enableClient)
            {
                #region Circuit breaker
                var nonCircuitBreakerAttr = clientMethodInfo.GetCustomAttribute <NonCircuitBreakerAttribute>();
                if (nonCircuitBreakerAttr == null)
                {
                    var circuitBreakerAttr   = clientMethodInfo.GetCustomAttribute <CircuitBreakerAttribute>();
                    var globalCircuitBreaker = UraganoSettings.CircuitBreakerOptions;
                    if (globalCircuitBreaker != null || circuitBreakerAttr != null)
                    {
                        breaker = new ServiceCircuitBreakerOptions();
                        if (globalCircuitBreaker != null)
                        {
                            breaker.Timeout = globalCircuitBreaker.Timeout;
                            breaker.Retry   = globalCircuitBreaker.Retry;
                            breaker.ExceptionsAllowedBeforeBreaking =
                                globalCircuitBreaker.ExceptionsAllowedBeforeBreaking;
                            breaker.DurationOfBreak    = globalCircuitBreaker.DurationOfBreak;
                            breaker.MaxParallelization = globalCircuitBreaker.MaxParallelization;
                            breaker.MaxQueuingActions  = globalCircuitBreaker.MaxQueuingActions;
                        }

                        if (circuitBreakerAttr != null)
                        {
                            if (circuitBreakerAttr.TimeoutMilliseconds > -1)
                            {
                                breaker.Timeout = TimeSpan.FromMilliseconds(circuitBreakerAttr.TimeoutMilliseconds);
                            }
                            if (circuitBreakerAttr.Retry > -1)
                            {
                                breaker.Retry = circuitBreakerAttr.Retry;
                            }
                            if (circuitBreakerAttr.ExceptionsAllowedBeforeBreaking > -1)
                            {
                                breaker.ExceptionsAllowedBeforeBreaking =
                                    circuitBreakerAttr.ExceptionsAllowedBeforeBreaking;
                            }
                            if (circuitBreakerAttr.DurationOfBreakSeconds > -1)
                            {
                                breaker.DurationOfBreak = TimeSpan.FromSeconds(circuitBreakerAttr.DurationOfBreakSeconds);
                            }
                            if (!string.IsNullOrWhiteSpace(circuitBreakerAttr.FallbackExecuteScript))
                            {
                                breaker.HasInjection = true;
                                ScriptInjection.AddScript(route, circuitBreakerAttr.FallbackExecuteScript,
                                                          circuitBreakerAttr.ScriptUsingNameSpaces);
                            }

                            if (circuitBreakerAttr.MaxParallelization > -1)
                            {
                                breaker.MaxParallelization = circuitBreakerAttr.MaxParallelization;
                            }

                            if (circuitBreakerAttr.MaxQueuingActions > -1)
                            {
                                breaker.MaxQueuingActions = circuitBreakerAttr.MaxQueuingActions;
                            }
                        }
                    }
                }
                #endregion

                #region Caching
                //Must have a method of returning a value.
                if (UraganoSettings.CachingOptions != null && clientMethodInfo.ReturnType != typeof(Task) && clientMethodInfo.GetCustomAttribute <NonCachingAttribute>() == null && clientMethodInfo.DeclaringType?.GetCustomAttribute <NonCachingAttribute>() == null)
                {
                    var attr         = clientMethodInfo.GetCustomAttribute <CachingAttribute>();
                    var keyGenerator = ServiceProvider.GetRequiredService <ICachingKeyGenerator>();
                    var key          = keyGenerator.GenerateKeyPlaceholder(UraganoSettings.CachingOptions.KeyPrefix, UraganoSettings.CachingOptions.ExpireSeconds, route, clientMethodInfo, attr);

                    cachingConfig = new CachingConfig(key, attr != null && !string.IsNullOrWhiteSpace(attr.Key), attr != null && attr.ExpireSeconds != -1 ? attr.ExpireSeconds : UraganoSettings.CachingOptions.ExpireSeconds);
                }
                #endregion
            }
            var serviceDescriptor = new ServiceDescriptor(route, serverMethodInfo, clientMethodInfo, serverMethodInfo == null ? null : new MethodInvoker(serverMethodInfo), serverInterceptors, clientInterceptors, breaker, cachingConfig);
            ServiceInvokers.TryAdd(route, serviceDescriptor);
        }