예제 #1
0
        /// <summary>
        /// Specify the Zulip server ie. zulip.example.org
        /// </summary>
        /// <param name="ServerBaseURL"></param>
        /// <param name="ApiVersion">Optional parameter in case there are v2 or higher in the future.</param>
        public ZulipServer(string ServerBaseURL, ServerApiVersion ApiVersion = ServerApiVersion.v1)
        {
            this.ServerBaseURL = TidyUpURL(ServerBaseURL);

            switch (ApiVersion)
            {
            case ServerApiVersion.v1:
                this.ApiURL = ApiPathV1;
                break;
            }

            this.ApiVersion = ApiVersion;
        }
예제 #2
0
        private (DisposableMongoClient Client, Dictionary <string, EventCapturer> ClientEventCapturers) CreateClient(BsonDocument entity)
        {
            string appName = null;
            var    clientEventCapturers       = new Dictionary <string, EventCapturer>();
            string clientId                   = null;
            var    commandNamesToSkipInEvents = new List <string>();
            List <(string Key, IEnumerable <string> Events, List <string> CommandNotToCapture)> eventTypesToCapture = new ();
            bool?    loadBalanced            = null;
            int?     maxPoolSize             = null;
            var      readConcern             = ReadConcern.Default;
            var      retryReads              = true;
            var      retryWrites             = true;
            var      useMultipleShardRouters = false;
            TimeSpan?waitQueueTimeout        = null;
            var      writeConcern            = WriteConcern.Acknowledged;
            var      serverApi = CoreTestConfiguration.ServerApi;

            foreach (var element in entity)
            {
                switch (element.Name)
                {
                case "id":
                    clientId = element.Value.AsString;
                    break;

                case "uriOptions":
                    foreach (var option in element.Value.AsBsonDocument)
                    {
                        switch (option.Name)
                        {
                        case "appname":
                            appName = option.Value.ToString();
                            break;

                        case "loadBalanced":
                            loadBalanced = option.Value.ToBoolean();
                            break;

                        case "maxPoolSize":
                            maxPoolSize = option.Value.ToInt32();
                            break;

                        case "retryWrites":
                            retryWrites = option.Value.AsBoolean;
                            break;

                        case "retryReads":
                            retryReads = option.Value.AsBoolean;
                            break;

                        case "readConcernLevel":
                            var levelValue = option.Value.AsString;
                            var level      = (ReadConcernLevel)Enum.Parse(typeof(ReadConcernLevel), levelValue, true);
                            readConcern = new ReadConcern(level);
                            break;

                        case "w":
                            writeConcern = new WriteConcern(option.Value.AsInt32);
                            break;

                        case "waitQueueTimeoutMS":
                            waitQueueTimeout = TimeSpan.FromMilliseconds(option.Value.ToInt32());
                            break;

                        default:
                            throw new FormatException($"Invalid client uriOption argument name: '{option.Name}'.");
                        }
                    }
                    break;

                case "useMultipleMongoses":
                    useMultipleShardRouters = element.Value.AsBoolean;
                    break;

                case "observeEvents":
                    var observeEvents = element.Value.AsBsonArray.Select(x => x.AsString);
                    eventTypesToCapture.Add(
                        (Key: Ensure.IsNotNull(clientId, nameof(clientId)),
                         Events: observeEvents,
                         CommandNotToCapture: commandNamesToSkipInEvents));
                    break;

                case "ignoreCommandMonitoringEvents":
                    commandNamesToSkipInEvents.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
                    break;

                case "serverApi":
                    ServerApiVersion serverApiVersion           = null;
                    bool?            serverApiStrict            = null;
                    bool?            serverApiDeprecationErrors = null;
                    foreach (var option in element.Value.AsBsonDocument)
                    {
                        switch (option.Name)
                        {
                        case "version":
                            var serverApiVersionString = option.Value.AsString;
                            switch (serverApiVersionString)
                            {
                            case "1":
                                serverApiVersion = ServerApiVersion.V1;
                                break;

                            default:
                                throw new FormatException($"Invalid serverApi version: '{serverApiVersionString}'.");
                            }
                            break;

                        case "strict":
                            serverApiStrict = option.Value.AsBoolean;
                            break;

                        case "deprecationErrors":
                            serverApiDeprecationErrors = option.Value.AsBoolean;
                            break;

                        default:
                            throw new FormatException($"Invalid client serverApi argument name: '{option.Name}'.");
                        }
                    }
                    if (serverApiVersion != null)
                    {
                        serverApi = new ServerApi(serverApiVersion, serverApiStrict, serverApiDeprecationErrors);
                    }
                    break;

                case "storeEventsAsEntities":
                    var eventsBatches = element.Value.AsBsonArray;
                    foreach (var batch in eventsBatches.Cast <BsonDocument>())
                    {
                        var id     = batch["id"].AsString;
                        var events = batch["events"].AsBsonArray.Select(e => e.AsString);
                        eventTypesToCapture.Add((id, events, CommandNotToCapture: null));
                    }
                    break;

                default:
                    throw new FormatException($"Invalid client argument name: '{element.Name}'.");
                }
            }

            if (eventTypesToCapture.Count > 0)
            {
                var defaultCommandNamesToSkip = new List <string>
                {
                    "authenticate",
                    "buildInfo",
                    "configureFailPoint",
                    "getLastError",
                    "getnonce",
                    "hello",
                    OppressiveLanguageConstants.LegacyHelloCommandName,
                    "saslContinue",
                    "saslStart"
                };

                foreach (var eventsDetails in eventTypesToCapture)
                {
                    var commandNamesNotToCapture = Enumerable.Concat(eventsDetails.CommandNotToCapture ?? Enumerable.Empty <string>(), defaultCommandNamesToSkip);
                    var formatter     = _eventFormatters.ContainsKey(eventsDetails.Key) ? _eventFormatters[eventsDetails.Key] : null;
                    var eventCapturer = CreateEventCapturer(eventsDetails.Events, commandNamesNotToCapture, formatter);
                    clientEventCapturers.Add(eventsDetails.Key, eventCapturer);
                }
            }

            var eventCapturers = clientEventCapturers.Select(c => c.Value).ToArray();
            var client         = DriverTestConfiguration.CreateDisposableClient(
                settings =>
            {
                settings.ApplicationName       = appName;
                settings.LoadBalanced          = loadBalanced.GetValueOrDefault(defaultValue: settings.LoadBalanced);
                settings.MaxConnectionPoolSize = maxPoolSize.GetValueOrDefault(defaultValue: settings.MaxConnectionPoolSize);
                settings.RetryReads            = retryReads;
                settings.RetryWrites           = retryWrites;
                settings.ReadConcern           = readConcern;
                settings.WaitQueueTimeout      = waitQueueTimeout.GetValueOrDefault(defaultValue: settings.WaitQueueTimeout);
                settings.WriteConcern          = writeConcern;
                settings.HeartbeatInterval     = TimeSpan.FromMilliseconds(5); // the default value for spec tests
                settings.ServerApi             = serverApi;
                if (eventCapturers.Length > 0)
                {
                    settings.ClusterConfigurator = c =>
                    {
                        foreach (var eventCapturer in eventCapturers)
                        {
                            c.Subscribe(eventCapturer);
                        }
                    };
                }
            },
                useMultipleShardRouters);

            return(client, clientEventCapturers);
        }
        private void CreateClient(BsonDocument entity, out DisposableMongoClient client, out EventCapturer eventCapturer)
        {
            var eventTypesToCapture = new List <string>();
            var commandNamesToSkip  = new List <string>
            {
                "authenticate",
                "buildInfo",
                "configureFailPoint",
                "getLastError",
                "getnonce",
                "isMaster",
                "saslContinue",
                "saslStart"
            };

            var       readConcern             = ReadConcern.Default;
            var       retryReads              = true;
            var       retryWrites             = true;
            var       useMultipleShardRouters = false;
            var       writeConcern            = WriteConcern.Acknowledged;
            ServerApi serverApi = null;

            foreach (var element in entity)
            {
                switch (element.Name)
                {
                case "id":
                    // handled on higher level
                    break;

                case "uriOptions":
                    foreach (var option in element.Value.AsBsonDocument)
                    {
                        switch (option.Name)
                        {
                        case "retryWrites":
                            retryWrites = option.Value.AsBoolean;
                            break;

                        case "retryReads":
                            retryReads = option.Value.AsBoolean;
                            break;

                        case "readConcernLevel":
                            var levelValue = option.Value.AsString;
                            var level      = (ReadConcernLevel)Enum.Parse(typeof(ReadConcernLevel), levelValue, true);
                            readConcern = new ReadConcern(level);
                            break;

                        case "w":
                            writeConcern = new WriteConcern(option.Value.AsInt32);
                            break;

                        default:
                            throw new FormatException($"Unrecognized client uriOption name: '{option.Name}'.");
                        }
                    }
                    break;

                case "useMultipleMongoses":
                    useMultipleShardRouters = element.Value.AsBoolean;
                    break;

                case "observeEvents":
                    eventTypesToCapture.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
                    break;

                case "ignoreCommandMonitoringEvents":
                    commandNamesToSkip.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
                    break;

                case "serverApi":
                    ServerApiVersion serverApiVersion           = null;
                    bool?            serverApiStrict            = null;
                    bool?            serverApiDeprecationErrors = null;
                    foreach (var option in element.Value.AsBsonDocument)
                    {
                        switch (option.Name)
                        {
                        case "version":
                            var serverApiVersionString = option.Value.AsString;
                            switch (serverApiVersionString)
                            {
                            case "1":
                                serverApiVersion = ServerApiVersion.V1;
                                break;

                            default:
                                throw new FormatException($"Unrecognized serverApi version: '{serverApiVersionString}'.");
                            }
                            break;

                        case "strict":
                            serverApiStrict = option.Value.AsBoolean;
                            break;

                        case "deprecationErrors":
                            serverApiDeprecationErrors = option.Value.AsBoolean;
                            break;

                        default:
                            throw new FormatException($"Unrecognized client serverApi option name: '{option.Name}'.");
                        }
                    }
                    if (serverApiVersion != null)
                    {
                        serverApi = new ServerApi(serverApiVersion, serverApiStrict, serverApiDeprecationErrors);
                    }
                    break;

                default:
                    throw new FormatException($"Unrecognized client entity field: '{element.Name}'.");
                }
            }

            eventCapturer = null;
            if (eventTypesToCapture.Count > 0)
            {
                eventCapturer = new EventCapturer();
                foreach (var eventTypeToCapture in eventTypesToCapture)
                {
                    switch (eventTypeToCapture)
                    {
                    case "commandStartedEvent":
                        eventCapturer = eventCapturer.Capture <CommandStartedEvent>(x => !commandNamesToSkip.Contains(x.CommandName));
                        break;

                    case "commandSucceededEvent":
                        eventCapturer = eventCapturer.Capture <CommandSucceededEvent>(x => !commandNamesToSkip.Contains(x.CommandName));
                        break;

                    case "commandFailedEvent":
                        eventCapturer = eventCapturer.Capture <CommandFailedEvent>(x => !commandNamesToSkip.Contains(x.CommandName));
                        break;

                    default:
                        throw new FormatException($"Invalid event name: {eventTypeToCapture}.");
                    }
                }
            }

            var localEventCapturer = eventCapturer; // copy value of eventCapturer ref variable to a local variable (to avoid error CS1628)

            client = DriverTestConfiguration.CreateDisposableClient(
                settings =>
            {
                settings.RetryReads        = retryReads;
                settings.RetryWrites       = retryWrites;
                settings.ReadConcern       = readConcern;
                settings.WriteConcern      = writeConcern;
                settings.HeartbeatInterval = TimeSpan.FromMilliseconds(5);     // the default value for spec tests
                if (localEventCapturer != null)
                {
                    settings.ClusterConfigurator = c => c.Subscribe(localEventCapturer);
                }
                settings.ServerApi = serverApi;
            },
                useMultipleShardRouters);
        }