protected virtual void Message(
            IEnumerable <IServerAddress> servers,
            ICacheRefresher refresher,
            MessageType messageType,
            IEnumerable <object> ids = null,
            Type idArrayType         = null,
            string jsonPayload       = null)
        {
            LogHelper.Debug <WebServiceServerMessenger>(
                "Performing distributed call for {0}/{1} on servers ({2}), ids: {3}, json: {4}",
                refresher.GetType,
                () => messageType,
                () => string.Join(";", servers.Select(x => x.ToString())),
                () => ids == null ? "" : string.Join(";", ids.Select(x => x.ToString())),
                () => jsonPayload ?? "");

            try
            {
                // NOTE: we are messaging ALL servers including the local server
                // at the moment, the web service,
                //  for bulk (batched) checks the origin and does NOT process the instructions again
                //  for anything else, processes the instructions again (but we don't use this anymore, batched is the default)
                // TODO: see WebServerHelper, could remove local server from the list of servers

                // the default server messenger uses http requests
                using (var client = new ServerSyncWebServiceClient())
                {
                    var asyncResults = new List <IAsyncResult>();

                    LogStartDispatch();

                    // go through each configured node submitting a request asynchronously
                    // NOTE: 'asynchronously' in this case does not mean that it will continue while we give the page back to the user!
                    foreach (var n in servers)
                    {
                        // set the server address
                        client.Url = n.ServerAddress;

                        // add the returned WaitHandle to the list for later checking
                        switch (messageType)
                        {
                        case MessageType.RefreshByJson:
                            asyncResults.Add(client.BeginRefreshByJson(refresher.UniqueIdentifier, jsonPayload, Login, Password, null, null));
                            break;

                        case MessageType.RefreshAll:
                            asyncResults.Add(client.BeginRefreshAll(refresher.UniqueIdentifier, Login, Password, null, null));
                            break;

                        case MessageType.RefreshById:
                            if (idArrayType == null)
                            {
                                throw new InvalidOperationException("Cannot refresh by id if the idArrayType is null.");
                            }

                            if (idArrayType == typeof(int))
                            {
                                // bulk of ints is supported
                                var json   = JsonConvert.SerializeObject(ids.Cast <int>().ToArray());
                                var result = client.BeginRefreshByIds(refresher.UniqueIdentifier, json, Login, Password, null, null);
                                asyncResults.Add(result);
                            }
                            else     // must be guids
                            {
                                // bulk of guids is not supported, iterate
                                asyncResults.AddRange(ids.Select(i =>
                                                                 client.BeginRefreshByGuid(refresher.UniqueIdentifier, (Guid)i, Login, Password, null, null)));
                            }

                            break;

                        case MessageType.RemoveById:
                            if (idArrayType == null)
                            {
                                throw new InvalidOperationException("Cannot remove by id if the idArrayType is null.");
                            }

                            // must be ints
                            asyncResults.AddRange(ids.Select(i =>
                                                             client.BeginRemoveById(refresher.UniqueIdentifier, (int)i, Login, Password, null, null)));
                            break;
                        }
                    }

                    // wait for all requests to complete
                    var waitHandles = asyncResults.Select(x => x.AsyncWaitHandle);
                    WaitHandle.WaitAll(waitHandles.ToArray());

                    // handle results
                    var errorCount = 0;
                    foreach (var asyncResult in asyncResults)
                    {
                        try
                        {
                            switch (messageType)
                            {
                            case MessageType.RefreshByJson:
                                client.EndRefreshByJson(asyncResult);
                                break;

                            case MessageType.RefreshAll:
                                client.EndRefreshAll(asyncResult);
                                break;

                            case MessageType.RefreshById:
                                if (idArrayType == typeof(int))
                                {
                                    client.EndRefreshById(asyncResult);
                                }
                                else
                                {
                                    client.EndRefreshByGuid(asyncResult);
                                }
                                break;

                            case MessageType.RemoveById:
                                client.EndRemoveById(asyncResult);
                                break;
                            }
                        }
                        catch (WebException ex)
                        {
                            LogDispatchNodeError(ex);
                            errorCount++;
                        }
                        catch (Exception ex)
                        {
                            LogDispatchNodeError(ex);
                            errorCount++;
                        }
                    }

                    LogDispatchBatchResult(errorCount);
                }
            }
            catch (Exception ee)
            {
                LogDispatchBatchError(ee);
            }
        }
        protected virtual void Message(IEnumerable <RefreshInstructionEnvelope> envelopes)
        {
            var envelopesA = envelopes.ToArray();
            var servers    = envelopesA.SelectMany(x => x.Servers).Distinct();

            try
            {
                // NOTE: we are messaging ALL servers including the local server
                // at the moment, the web service,
                //  for bulk (batched) checks the origin and does NOT process the instructions again
                //  for anything else, processes the instructions again (but we don't use this anymore, batched is the default)
                // TODO: see WebServerHelper, could remove local server from the list of servers

                using (var client = new ServerSyncWebServiceClient())
                {
                    var asyncResults = new List <IAsyncResult>();

                    LogStartDispatch();

                    // go through each configured node submitting a request asynchronously
                    // NOTE: 'asynchronously' in this case does not mean that it will continue while we give the page back to the user!
                    foreach (var server in servers)
                    {
                        // set the server address
                        client.Url = server.ServerAddress;

                        var serverInstructions = envelopesA
                                                 .Where(x => x.Servers.Contains(server))
                                                 .SelectMany(x => x.Instructions)
                                                 .Distinct() // only execute distinct instructions - no sense in running the same one.
                                                 .ToArray();

                        asyncResults.Add(
                            client.BeginBulkRefresh(
                                serverInstructions,
                                GetCurrentServerHash(),
                                Login, Password, null, null));
                    }

                    // wait for all requests to complete
                    var waitHandles = asyncResults.Select(x => x.AsyncWaitHandle).ToArray();
                    WaitHandle.WaitAll(waitHandles.ToArray());

                    // handle results
                    var errorCount = 0;
                    foreach (var asyncResult in asyncResults)
                    {
                        try
                        {
                            client.EndBulkRefresh(asyncResult);
                        }
                        catch (WebException ex)
                        {
                            LogDispatchNodeError(ex);
                            errorCount++;
                        }
                        catch (Exception ex)
                        {
                            LogDispatchNodeError(ex);
                            errorCount++;
                        }
                    }
                    LogDispatchBatchResult(errorCount);
                }
            }
            catch (Exception ee)
            {
                LogDispatchBatchError(ee);
            }
        }
Exemplo n.º 3
0
        protected virtual void PerformDistributedCall(
            IEnumerable <IServerAddress> servers,
            ICacheRefresher refresher,
            MessageType dispatchType,
            IEnumerable <object> ids = null,
            Type idArrayType         = null,
            string jsonPayload       = null)
        {
            //We are using distributed calls, so lets make them...
            try
            {
                //TODO: We should try to figure out the current server's address and if it matches any of the ones
                // in the ServerAddress list, then just refresh directly on this server and exclude that server address
                // from the list, this will save an internal request.

                using (var cacheRefresher = new ServerSyncWebServiceClient())
                {
                    var asyncResultsList = new List <IAsyncResult>();

                    LogStartDispatch();

                    // Go through each configured node submitting a request asynchronously
                    //NOTE: 'asynchronously' in this case does not mean that it will continue while we give the page back to the user!
                    foreach (var n in servers)
                    {
                        //set the server address
                        cacheRefresher.Url = n.ServerAddress;

                        // Add the returned WaitHandle to the list for later checking
                        switch (dispatchType)
                        {
                        case MessageType.RefreshByJson:
                            asyncResultsList.Add(
                                cacheRefresher.BeginRefreshByJson(
                                    refresher.UniqueIdentifier, jsonPayload, Login, Password, null, null));
                            break;

                        case MessageType.RefreshAll:
                            asyncResultsList.Add(
                                cacheRefresher.BeginRefreshAll(
                                    refresher.UniqueIdentifier, Login, Password, null, null));
                            break;

                        case MessageType.RefreshById:
                            if (idArrayType == null)
                            {
                                throw new InvalidOperationException("Cannot refresh by id if the idArrayType is null");
                            }

                            if (idArrayType == typeof(int))
                            {
                                var serializer = new JavaScriptSerializer();
                                var jsonIds    = serializer.Serialize(ids.Cast <int>().ToArray());
                                //we support bulk loading of Integers
                                var result = cacheRefresher.BeginRefreshByIds(refresher.UniqueIdentifier, jsonIds, Login, Password, null, null);
                                asyncResultsList.Add(result);
                            }
                            else
                            {
                                //we don't currently support bulk loading of GUIDs (not even sure if we have any Guid ICacheRefreshers)
                                //so we'll just iterate
                                asyncResultsList.AddRange(
                                    ids.Select(i => cacheRefresher.BeginRefreshByGuid(
                                                   refresher.UniqueIdentifier, (Guid)i, Login, Password, null, null)));
                            }

                            break;

                        case MessageType.RemoveById:
                            //we don't currently support bulk removing so we'll iterate
                            asyncResultsList.AddRange(
                                ids.Select(i => cacheRefresher.BeginRemoveById(
                                               refresher.UniqueIdentifier, (int)i, Login, Password, null, null)));
                            break;
                        }
                    }

                    List <WaitHandle> waitHandlesList;
                    var asyncResults = GetAsyncResults(asyncResultsList, out waitHandlesList);

                    var errorCount = 0;

                    // Once for each WaitHandle that we have, wait for a response and log it
                    // We're previously submitted all these requests effectively in parallel and will now retrieve responses on a FIFO basis
                    foreach (var t in asyncResults)
                    {
                        var handleIndex = WaitHandle.WaitAny(waitHandlesList.ToArray(), TimeSpan.FromSeconds(15));

                        try
                        {
                            // Find out if the call succeeded
                            switch (dispatchType)
                            {
                            case MessageType.RefreshByJson:
                                cacheRefresher.EndRefreshByJson(t);
                                break;

                            case MessageType.RefreshAll:
                                cacheRefresher.EndRefreshAll(t);
                                break;

                            case MessageType.RefreshById:
                                if (idArrayType == null)
                                {
                                    throw new InvalidOperationException("Cannot refresh by id if the idArrayType is null");
                                }

                                if (idArrayType == typeof(int))
                                {
                                    cacheRefresher.EndRefreshById(t);
                                }
                                else
                                {
                                    cacheRefresher.EndRefreshByGuid(t);
                                }
                                break;

                            case MessageType.RemoveById:
                                cacheRefresher.EndRemoveById(t);
                                break;
                            }
                        }
                        catch (WebException ex)
                        {
                            LogDispatchNodeError(ex);

                            errorCount++;
                        }
                        catch (Exception ex)
                        {
                            LogDispatchNodeError(ex);

                            errorCount++;
                        }
                    }

                    LogDispatchBatchResult(errorCount);
                }
            }
            catch (Exception ee)
            {
                LogDispatchBatchError(ee);
            }
        }