Example #1
0
 protected bool Equals(RedisEndpoint other)
 {
     return(string.Equals(this.Host, other.Host) &&
            this.Port == other.Port &&
            this.Ssl.Equals(other.Ssl) &&
            this.ConnectTimeout == other.ConnectTimeout &&
            this.SendTimeout == other.SendTimeout &&
            this.ReceiveTimeout == other.ReceiveTimeout &&
            this.RetryTimeout == other.RetryTimeout &&
            this.IdleTimeoutSecs == other.IdleTimeoutSecs &&
            this.Db == other.Db &&
            string.Equals(this.Client, other.Client) &&
            string.Equals(this.Password, other.Password) &&
            string.Equals(this.NamespacePrefix, other.NamespacePrefix));
 }
Example #2
0
        // ReSharper disable once CyclomaticComplexity
        // ReSharper disable once MethodTooLong
        public static RedisEndpoint Create(string connectionString, int?defaultPort = null)
        {
            if (connectionString == null)
            {
                throw new ArgumentNullException(nameof(connectionString));
            }

            if (connectionString.StartsWith("redis://"))
            {
                connectionString = connectionString.Substring("redis://".Length);
            }

            var domainParts    = connectionString.SplitOnLast('@');
            var qsParts        = domainParts.Last().SplitOnFirst('?');
            var hostParts      = qsParts[0].SplitOnLast(':');
            var useDefaultPort = true;
            var port           = defaultPort.GetValueOrDefault(RedisConfig.DefaultPort);

            if (hostParts.Length > 1)
            {
                port           = int.Parse(hostParts[1]);
                useDefaultPort = false;
            }

            var endpoint = new RedisEndpoint(hostParts[0], port);

            if (domainParts.Length > 1)
            {
                var authParts = domainParts[0].SplitOnFirst(':');
                if (authParts.Length > 1)
                {
                    endpoint.Client = authParts[0];
                }

                endpoint.Password = authParts.Last();
            }

            if (qsParts.Length > 1)
            {
                var qsParams = qsParts[1].Split('&');
                foreach (var param in qsParams)
                {
                    var entry = param.Split('=');
                    var value = entry.Length > 1 ? WebUtility.UrlDecode(entry[1]) : null;
                    if (value == null)
                    {
                        continue;
                    }

                    var name = entry[0].ToLower();
                    switch (name)
                    {
                    case "db":
                        endpoint.Db = int.Parse(value);
                        break;

                    case "ssl":
                        endpoint.Ssl = bool.Parse(value);
                        if (useDefaultPort)
                        {
                            endpoint.Port = RedisConfig.DefaultPortSsl;
                        }

                        break;

                    case "client":
                        endpoint.Client = value;
                        break;

                    case "password":
                        endpoint.Password = value;
                        break;

                    case "namespaceprefix":
                        endpoint.NamespacePrefix = value;
                        break;

                    case "connecttimeout":
                        endpoint.ConnectTimeout = int.Parse(value);
                        break;

                    case "sendtimeout":
                        endpoint.SendTimeout = int.Parse(value);
                        break;

                    case "receivetimeout":
                        endpoint.ReceiveTimeout = int.Parse(value);
                        break;

                    case "retrytimeout":
                        endpoint.RetryTimeout = int.Parse(value);
                        break;

                    case "idletimeout":
                    case "idletimeoutsecs":
                        endpoint.IdleTimeoutSecs = int.Parse(value);
                        break;
                    }
                }
            }

            return(endpoint);
        }