async Task<OperationResult> Process(TestStatelessUnreliable msg, IOperationContext arg2)
        {
            if (msg.SleepDurationMs > 0)
                await Task.Delay(msg.SleepDurationMs);

            return OperationResult.Success;
        }

 /// <summary>
 /// Prepare the given OperationContext for use with this CMIS profile.
 /// </summary>
 /// <param name="operationContext"></param>
 public void ConfigureOperationContext(IOperationContext operationContext)
 {
     /*
     Disabled because repository may generate error if the type is not Orderable for cmis:contentStreamFileName
     Documentum generates such an error: https://github.com/aegif/CmisSync/issues/724
     Alfresco also is not Orderable even though it does not generate an error:
     http://stackoverflow.com/questions/39290294/check-whether-cmiscontentstreamfilename-is-orderable
     
     if (IgnoreIfSameLowercaseNames)
     {
         // Depending on the CMIS profile, order by stream name or document name.
         if (UseCmisStreamName && contentStreamFileNameOrderable)
         {
             operationContext.OrderBy = "cmis:contentStreamFileName";
         }
         else
         {
             operationContext.OrderBy = "cmis:name";
         }
     }
     else
     {
         // Do not specify an order criteria, as we don't need it,
         // and it might have a performance impact on the CMIS server.
     }
     */
 }

 public void Process(SayS2S msg, IOperationContext context)
 {
     foreach (var roomMember in _roomMembers)
     {
         roomMember.CallbackChannel.Send(new RoomEvent() { Text = msg.Text, UserName = msg.UserName });
     }
 }

        public Task<Message> Process(Func<IOperationContext, Task<Message>> next, IOperationContext operation)
        {
            var lockType = LockType.Write;
            if (_lockConfig != null)
                lockType = _lockConfig.GetLockType(operation.Message.GetType());

            return _fiber.Call(() => next(operation), lockType);
        }

        public OperationContextOrgUnitContextStorage(IOperationContext operationContext)
        {
            _operationContext = operationContext;

            // WCF operation context is null during app initialization.
            // We don't need to store OU context during that stage anyway.
            operationContextAvailable = _operationContext != null;
        }

 void OnSay(Say msg, IOperationContext context)
 {
     if (_room != null)
     {
         _room.SendOneWay(new SayS2S(){UserName = _userName, Text = msg.Text}, context);    
     }
     else throw new ProcessingException(SayErrors.NotConnectedToRoom);
 }

 async Task OnSay(Say msg, IOperationContext context)
 {
     if (_room != null)
     {
         await _room.Say(new SayS2S() { UserName = _userName, Text = msg.Text });
     }
     else throw new ProcessingException(SayErrors.NotConnectedToRoom);
 }

 async Task<OperationResult> Process(PingGateway msg, IOperationContext context)
 {
     using (BackendCallsTimer.NewContext())
     {
         await Task.Delay(msg.SleepDurationMs);
         return OperationResult.Success;
     }
 }

 private void UpdateClientIp(LocationContext location, IOperationContext operation)
 {
     if ( operation.HasIncomingMessageProperty(RemoteEndpointMessageProperty.Name) )
     {
         var property = (RemoteEndpointMessageProperty)
             operation.GetIncomingMessageProperty(RemoteEndpointMessageProperty.Name);
         location.Ip = property.Address;
         WcfEventSource.Log.LocationIdSet(location.Ip);
     }
 }

 public static IEnumerable<int> FindAssociatedOrgUnitIds(int? organizationalUnitId, DescendantOption descentantOption, LinkedOption linkedOption, IOperationContext operationContext, ObjectContext objectContext)
 {
     return
         AssociatedOrgUnitFinder.FindAssociatedOrgUnits(objectContext, new AssociatedOrgUnitsDto
         {
             OrganizationalUnitId = organizationalUnitId,
             DescendantOption = descentantOption,
             LinkedOption = linkedOption
         });
 }

 static void OnSay(Say msg, IOperationContext context)
 {
     RoomMember member;
     if (RoomMembers.TryGetValue(context.ReplyChannel, out member))
     {
         List<RoomMember> members;
         if (Rooms.TryGetValue(member.RoomName, out members))
         {
             members.ForEach((m) => m.UserChannel.Send(new RoomEvent() { UserName = member.UserName, Text = msg.Text }));
         }    
     }
 }

 /// <summary>
 /// Called when a telemetry item is available
 /// </summary>
 /// <param name="telemetry">The telemetry item to augment</param>
 /// <param name="operation">The operation context</param>
 protected override void OnInitialize(ITelemetry telemetry, IOperationContext operation)
 {
     var httpHeaders = operation.GetHttpRequestHeaders();
     if ( httpHeaders != null )
     {
         var userAgent = httpHeaders.Headers["User-Agent"];
         if ( !String.IsNullOrEmpty(userAgent) )
         {
             telemetry.Context.User.UserAgent = userAgent;
         }
     }
 }

 /// <summary>
 /// Initialize the telemetry event with the client IP if available
 /// </summary>
 /// <param name="telemetry">The telemetry event</param>
 /// <param name="operation">The WCF operation context</param>
 protected override void OnInitialize(ITelemetry telemetry, IOperationContext operation)
 {
     if ( String.IsNullOrEmpty(telemetry.Context.Location.Ip) )
     {
         var location = operation.Request.Context.Location;
         if ( String.IsNullOrEmpty(location.Ip) )
         {
             UpdateClientIp(location, operation);
         }
         telemetry.Context.Location.Ip = location.Ip;
     }
 }

 public static IEnumerable<int> FindAssociatedOrgUnitIds(int? organizationalUnitId, DescendantOption descentantOption, LinkedOption linkedOption, IOperationContext operationContext, ObjectContext objectContext)
 {
     var key = string.Concat("AssociatedOrgUnitIds_", organizationalUnitId, "_", descentantOption, "_", linkedOption);
     //return operationContext.FindOrCreate<IEnumerable<int>>(key, () =>
     //{
         return
             AssociatedOrgUnitFinder.FindAssociatedOrgUnits(objectContext, new AssociatedOrgUnitsDto
             {
                 OrganizationalUnitId = organizationalUnitId,
                 DescendantOption = descentantOption,
                 LinkedOption = linkedOption
             });
     //});
 }

        async Task<JoinRoomResponse> OnRoomJoin(JoinRoom msg, IOperationContext context)
        {
            var room = ActorProxy.Create<ISFRoomActor>(new ActorId(msg.RoomName));

            await room.SubscribeAsync(this);

            var joinRoomOnServer = new JoinRoomS2S()
            {
                RoomName = msg.RoomName,
                UserName = msg.UserName
            };
            var reply = await room.JoinRoom(joinRoomOnServer);
            if (reply.RetCode == JoinRoomRetCode.Ok)
            {
                _room = room;
                _userName = msg.UserName;
            }

            return reply;
        }

        async Task<JoinRoomResponse> OnRoomJoin(JoinRoom msg, IOperationContext context)
        {
            var room = await _rooms.GetActor(new ActorKey(msg.RoomName));

            var callbackRef = _callbacksNode.ExposeAsCallbackChannel(this);
            var joinRoomOnServer = new JoinRoomS2S()
            {
                CallbackChannelRef = callbackRef,
                RoomName = msg.RoomName,
                UserName = msg.UserName
            };
            var reply = await room.SendAsync<JoinRoomResponse>(joinRoomOnServer, context);
            if (reply.RetCode == JoinRoomRetCode.Ok)
            {
                _room = room;
                _userName = msg.UserName;
            }

            return reply;
        }

 public Task<Message> Process(Func<IOperationContext, Task<Message>> next, IOperationContext context)
 {
     Func<IOperationContext, Task<Message>> handler;
     if (_messageHandlingConfig.TryGetHandlerFor(context.Message.GetType(), out handler))
     {
         return handler(context);
     }
     else if (next != null)
     {
         return next(context);
     }
     else if (_throwIfUnhandled)
     {
         throw new ProcessingException(BasicErrorCode.DispatcherFuncNotFound);
     }
     else
     {
         return Task.FromResult<Message>(null);
     }
 }

        void IWcfTelemetryModule.OnError(IOperationContext operation, Exception error)
        {
            if ( operation == null )
                throw new ArgumentNullException("operation");
            if ( error == null )
                throw new ArgumentNullException("error");
            if ( telemetryClient == null )
                return;

            ExceptionTelemetry telemetry = new ExceptionTelemetry(error);
            if ( error is FaultException )
            {
                telemetry.SeverityLevel = SeverityLevel.Error;
                telemetry.HandledAt = ExceptionHandledAt.UserCode;
            } else
            {
                telemetry.SeverityLevel = SeverityLevel.Critical;
                telemetry.HandledAt = ExceptionHandledAt.Platform;
            }
            telemetryClient.TrackException(error);
        }

        public IDocument GetObjectOfLatestVersion(bool major, IOperationContext context)
        {
            string objectId;
            string versionSeriesId;

            Lock();
            try
            {
                objectId = ObjectId;
                versionSeriesId = VersionSeriesId;
            }
            finally
            {
                Unlock();
            }

            if (versionSeriesId == null)
            {
                throw new CmisRuntimeException("Version series id is unknown!");
            }

            IObjectData objectData = Binding.GetVersioningService().GetObjectOfLatestVersion(RepositoryId, objectId, versionSeriesId, major,
                context.FilterString, context.IncludeAllowableActions, context.IncludeRelationships, context.RenditionFilterString,
                context.IncludePolicies, context.IncludeAcls, null);

            IDocument result = Session.ObjectFactory.ConvertObject(objectData, context) as IDocument;
            if (result == null)
            {
                throw new CmisRuntimeException("Latest version is not a document!");
            }

            return result;
        }

        public IList<IDocument> GetAllVersions(IOperationContext context)
        {
            string objectId;
            string versionSeriesId;

            Lock();
            try
            {
                objectId = ObjectId;
                versionSeriesId = VersionSeriesId;
            }
            finally
            {
                Unlock();
            }

            IList<IObjectData> versions = Binding.GetVersioningService().GetAllVersions(RepositoryId, objectId, versionSeriesId,
                context.FilterString, context.IncludeAllowableActions, null);

            IObjectFactory of = Session.ObjectFactory;

            IList<IDocument> result = new List<IDocument>();
            if (versions != null)
            {
                foreach (IObjectData objectData in versions)
                {
                    IDocument doc = of.ConvertObject(objectData, context) as IDocument;
                    if (doc == null)
                    {
                        // should not happen...
                        continue;
                    }

                    result.Add(doc);
                }
            }

            return result;
        }