void IDataImport.SendMessage(IDataMessage message) { if (!this.useBuffering) { base.WrappedObject.SendMessage(message); return; } DataMessageOpcode value; byte[] array; message.Serialize(this.useCompression, out value, out array); this.writer.Write((int)value); if (array != null) { this.writer.Write(array.Length); this.writer.Write(array); this.uncompressedSize += 8 + array.Length; } else { this.writer.Write(0); this.uncompressedSize += 8; } this.bufferCount++; if (this.gzipStream != null) { this.gzipStream.Flush(); } if (this.dataBuffer.Length >= (long)this.minBatchSize) { this.FlushBuffers(false); } }
MessageRec IMailbox.SaveSyncState(byte[] key, string syncState) { MrsTracer.ProxyClient.Function("RemoteMailbox.SaveSyncState", new object[0]); if (!(this is RemoteDestinationMailbox)) { throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "IMailbox_SaveSyncState"); } this.VerifyMailboxConnection(); IDataExport dataExport = new PagedTransmitter(syncState, base.MrsProxyClient.UseCompression); DataExportBatch dataExportBatch = dataExport.ExportData(); long handle = base.MrsProxy.IDestinationMailbox_SaveSyncState2(base.Handle, key, dataExportBatch); if (!dataExportBatch.IsLastBatch) { using (IDataImport dataImport = new RemoteDataImport(base.MrsProxy, handle, null)) { do { dataExportBatch = dataExport.ExportData(); IDataMessage message = DataMessageSerializer.Deserialize(dataExportBatch.Opcode, dataExportBatch.Data, base.MrsProxyClient.UseCompression); dataImport.SendMessage(message); }while (!dataExportBatch.IsLastBatch); } } return(null); }
private void FlushBufferedOperations() { while (this.pendingOperations.Count > 0) { IDataMessage message = this.pendingOperations.Dequeue(); base.WrappedObject.SendMessage(message); } }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage request) { this.UpdateTracker(request); IDataMessage dataMessage = this.destination.SendMessageAndWaitForReply(request); this.UpdateTracker(dataMessage); return(dataMessage); }
void IDataImport.SendMessage(IDataMessage message) { this.SpinUpTransmitterThread(); this.WaitUntilDataIsProcessed(); this.currentMessage = message; this.eventBufferIsAvailableToAccept.Reset(); this.eventWakeUpTransmitter.Set(); }
void IDataImport.SendMessage(IDataMessage message) { DataMessageOpcode opcode; byte[] data; message.Serialize(base.MrsProxyClient.UseCompression, out opcode, out data); base.MrsProxy.IDataImport_ImportBuffer(base.Handle, (int)opcode, data); }
public static void ExportRoutine(IMailboxReplicationProxyService mrsProxy, long dataExportHandle, IDataImport destProxy, DataExportBatch firstBatch, bool useCompression) { try { DataExportBatch dataExportBatch; do { if (firstBatch != null) { dataExportBatch = firstBatch; firstBatch = null; } else { if (TestIntegration.Instance.AbortConnectionDuringFX) { MailboxReplicationProxyClient mailboxReplicationProxyClient = (MailboxReplicationProxyClient)mrsProxy; mailboxReplicationProxyClient.Abort(); } dataExportBatch = mrsProxy.DataExport_ExportData2(dataExportHandle); if (dataExportBatch.IsLastBatch) { dataExportHandle = 0L; } } bool flag = false; try { if (dataExportBatch.Opcode != 0) { IDataMessage message = DataMessageSerializer.Deserialize(dataExportBatch.Opcode, dataExportBatch.Data, useCompression); destProxy.SendMessage(message); } if (dataExportBatch.FlushAfterImport) { destProxy.SendMessageAndWaitForReply(FlushMessage.Instance); } flag = true; } finally { if (!flag && dataExportHandle != 0L) { MrsTracer.ProxyClient.Error("Exception was thrown during import/flush, canceling export.", new object[0]); mrsProxy.DataExport_CancelExport(dataExportHandle); dataExportHandle = 0L; } } }while (!dataExportBatch.IsLastBatch); } finally { if (dataExportHandle != 0L) { mrsProxy.CloseHandle(dataExportHandle); } } }
void IDataImport.SendMessage(IDataMessage message) { MrsTracer.ProxyService.Function("DataExport.SendMessage", new object[0]); this.CheckForCancel(); message.Serialize(this.service.UseCompression, out this.nextOpcode, out this.nextBuffer); this.result = DataExport.DataExportResult.MoreData; this.eventDataAvailable.Set(); this.WaitForTheNextCall(); }
private void UpdateTracker(IDataMessage message) { if (this.job.ProgressTracker != null && message != null) { uint size = (uint)message.GetSize(); this.job.ProgressTracker.AddBytes(size); MRSResource.Cache.GetInstance(MRSResource.Id.ObjectGuid, this.job.WorkloadTypeFromJob).Charge(size); } }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message) { ((IDataImport)this).SendMessage(new AsynchronousTransmitter.AsyncTransmitterWaitForReplyMessage(message)); this.WaitUntilDataIsProcessed(); IDataMessage result = this.replyMessage; this.replyMessage = null; return(result); }
private void BufferOrSendMessage(IDataMessage msg) { if (msg is FxProxyPoolCloseEntryMessage || msg is FxProxyPoolOpenFolderMessage || msg is FxProxyPoolCreateItemMessage || msg is FxProxyPoolOpenItemMessage) { this.pendingOperations.Enqueue(msg); return; } this.FlushBufferedOperations(); base.WrappedObject.SendMessage(msg); }
void IDataImport.SendMessage(IDataMessage message) { FxProxyImportBufferMessage fxProxyImportBufferMessage = message as FxProxyImportBufferMessage; if (fxProxyImportBufferMessage != null) { base.WrappedObject.ProcessRequest(fxProxyImportBufferMessage.Opcode, fxProxyImportBufferMessage.Buffer); return; } throw new UnexpectedErrorPermanentException(-2147024809); }
byte[] IMapiFxProxy.GetObjectData() { IDataMessage dataMessage = base.WrappedObject.SendMessageAndWaitForReply(FxProxyGetObjectDataRequestMessage.Instance); FxProxyGetObjectDataResponseMessage fxProxyGetObjectDataResponseMessage = dataMessage as FxProxyGetObjectDataResponseMessage; if (fxProxyGetObjectDataResponseMessage == null) { throw new UnexpectedErrorPermanentException(-2147024809); } return(fxProxyGetObjectDataResponseMessage.Buffer); }
IFxProxy IDestinationMailbox.GetFxProxy() { MrsTracer.ProxyClient.Function("RemoteDestinationMailbox.GetFxProxy", new object[0]); base.VerifyMailboxConnection(); byte[] data; long handle = base.MrsProxy.IDestinationMailbox_GetFxProxy(base.Handle, out data); IDataMessage getDataResponseMsg = FxProxyGetObjectDataResponseMessage.Deserialize(DataMessageOpcode.FxProxyGetObjectDataResponse, data, base.MrsProxyClient.UseCompression); BufferedTransmitter destination = new BufferedTransmitter(new RemoteDataImport(base.MrsProxy, handle, getDataResponseMsg), base.ExportBufferSizeKB, true, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression); AsynchronousTransmitter destination2 = new AsynchronousTransmitter(destination, true); return(new FxProxyTransmitter(destination2, true)); }
List <byte[]> IFxProxyPool.GetUploadedMessageIDs() { this.EnsureFolderDataCached(); this.FlushBufferedOperations(); IDataMessage dataMessage = base.WrappedObject.SendMessageAndWaitForReply(FxProxyPoolGetUploadedIDsRequestMessage.Instance); FxProxyPoolGetUploadedIDsResponseMessage fxProxyPoolGetUploadedIDsResponseMessage = dataMessage as FxProxyPoolGetUploadedIDsResponseMessage; if (fxProxyPoolGetUploadedIDsResponseMessage == null) { throw new UnexpectedErrorPermanentException(-2147024809); } return(fxProxyPoolGetUploadedIDsResponseMessage.EntryIDs); }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message) { if (!this.useBuffering) { return(base.WrappedObject.SendMessageAndWaitForReply(message)); } if (message is FlushMessage) { this.FlushBuffers(true); return(null); } return(base.WrappedObject.SendMessageAndWaitForReply(message)); }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message) { if (message is FxProxyGetObjectDataRequestMessage) { return(new FxProxyGetObjectDataResponseMessage(base.WrappedObject.GetObjectData())); } if (message is FlushMessage) { base.WrappedObject.Flush(); return(null); } throw new UnexpectedErrorPermanentException(-2147024809); }
IFxProxyPool IDestinationMailbox.GetFxProxyPool(ICollection <byte[]> folderIds) { MrsTracer.ProxyClient.Function("RemoteDestinationMailbox.GetFxProxyPool", new object[0]); base.VerifyMailboxConnection(); List <byte[]> list = new List <byte[]>(folderIds); byte[] data; long handle = base.MrsProxy.IDestinationMailbox_GetFxProxyPool(base.Handle, list.ToArray(), out data); IDataMessage getDataResponseMsg = FxProxyPoolGetFolderDataResponseMessage.Deserialize(DataMessageOpcode.FxProxyPoolGetFolderDataResponse, data, base.MrsProxyClient.UseCompression); BufferedTransmitter destination = new BufferedTransmitter(new RemoteDataImport(base.MrsProxy, handle, getDataResponseMsg), base.ExportBufferSizeKB, true, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression); AsynchronousTransmitter destination2 = new AsynchronousTransmitter(destination, true); return(new FxProxyPoolTransmitter(destination2, true, base.ServerVersion)); }
private void EnsureFolderDataCached() { if (this.folderDataMap != null) { return; } IDataMessage dataMessage = base.WrappedObject.SendMessageAndWaitForReply(FxProxyPoolGetFolderDataRequestMessage.Instance); FxProxyPoolGetFolderDataResponseMessage fxProxyPoolGetFolderDataResponseMessage = dataMessage as FxProxyPoolGetFolderDataResponseMessage; if (fxProxyPoolGetFolderDataResponseMessage == null) { throw new UnexpectedErrorPermanentException(-2147024809); } this.folderDataMap = fxProxyPoolGetFolderDataResponseMessage.FolderData; }
public DataExport(IDataMessage getDataResponseMsg, MailboxReplicationProxyService service) { this.getDataResponseMsg = getDataResponseMsg; this.nextOpcode = DataMessageOpcode.None; this.nextBuffer = null; this.result = DataExport.DataExportResult.Done; this.exportFailure = null; this.exportThread = null; this.eventDataAvailable = new AutoResetEvent(false); this.eventDataProcessed = new AutoResetEvent(false); this.cancelExport = false; this.service = service; this.lastReturnWasTimeout = false; this.storedOpcode = 0; this.storedData = null; }
void IDataImport.SendMessage(IDataMessage message) { MessageExportResultsMessage messageExportResultsMessage = message as MessageExportResultsMessage; if (messageExportResultsMessage == null) { base.WrappedObject.SendMessage(message); return; } this.MissingMessages = messageExportResultsMessage.MissingMessages; this.BadMessages = messageExportResultsMessage.BadMessages; foreach (BadMessageRec badMessageRec in this.BadMessages) { badMessageRec.Failure = FailureRec.Create(new RemotePermanentException(new LocalizedString(badMessageRec.XmlData), null)); } }
void IDataImport.SendMessage(IDataMessage message) { PagedDataMessage pagedDataMessage = message as PagedDataMessage; if (pagedDataMessage == null) { throw new InputDataIsInvalidPermanentException(); } if (pagedDataMessage.Buffer != null) { this.chunks.Add(pagedDataMessage.Buffer); this.totalDataSize += pagedDataMessage.Buffer.Length; } if (pagedDataMessage.IsLastChunk) { byte[] array; if (this.chunks.Count == 0) { array = null; } else if (this.chunks.Count == 1) { array = this.chunks[0]; } else { array = new byte[this.totalDataSize]; int num = 0; foreach (byte[] array2 in this.chunks) { array2.CopyTo(array, num); num += array2.Length; } } if (this.blobDoneDelegate != null) { if (this.useCompression) { array = CommonUtils.DecompressData(array); } this.blobDoneDelegate(array); return; } string data = CommonUtils.UnpackString(array, this.useCompression); this.stringDoneDelegate(data); } }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message) { if (message is FlushMessage) { base.MrsProxy.IDataImport_Flush(base.Handle); return(null); } if (message is FxProxyGetObjectDataRequestMessage && this.getDataResponseMsg is FxProxyGetObjectDataResponseMessage) { return(this.getDataResponseMsg); } if (message is FxProxyPoolGetFolderDataRequestMessage && this.getDataResponseMsg is FxProxyPoolGetFolderDataResponseMessage) { return(this.getDataResponseMsg); } throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "IDataImport_GetObjectData"); }
void IDataImport.SendMessage(IDataMessage message) { if (!this.useBuffering) { base.WrappedObject.SendMessage(message); return; } BufferBatchMessage bufferBatchMessage = message as BufferBatchMessage; if (bufferBatchMessage == null) { base.WrappedObject.SendMessage(message); return; } if (bufferBatchMessage.Buffer != null) { byte[] buffer; if (this.useCompression) { buffer = CommonUtils.DecompressData(bufferBatchMessage.Buffer); } else { buffer = bufferBatchMessage.Buffer; } using (MemoryStream memoryStream = new MemoryStream(buffer)) { using (BinaryReader binaryReader = new BinaryReader(memoryStream)) { while (memoryStream.Position < memoryStream.Length) { int opcode = CommonUtils.ReadInt(binaryReader); byte[] data = CommonUtils.ReadBlob(binaryReader); IDataMessage message2 = DataMessageSerializer.Deserialize(opcode, data, this.useCompression); base.WrappedObject.SendMessage(message2); } } } } if (bufferBatchMessage.FlushAfterImport) { base.WrappedObject.SendMessageAndWaitForReply(FlushMessage.Instance); } }
IFxProxy IDestinationFolder.GetFxProxy(FastTransferFlags flags) { byte[] data; long handle; if (base.ServerVersion[30]) { handle = base.MrsProxy.IDestinationFolder_GetFxProxy2(base.Handle, (int)flags, out data); } else { handle = base.MrsProxy.IDestinationFolder_GetFxProxy(base.Handle, out data); } IDataMessage getDataResponseMsg = FxProxyGetObjectDataResponseMessage.Deserialize(DataMessageOpcode.FxProxyGetObjectDataResponse, data, base.MrsProxyClient.UseCompression); BufferedTransmitter destination = new BufferedTransmitter(new RemoteDataImport(base.MrsProxy, handle, getDataResponseMsg), this.exportBufferSizeKB, true, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression); AsynchronousTransmitter destination2 = new AsynchronousTransmitter(destination, true); return(new FxProxyTransmitter(destination2, true)); }
public void Process(IDataMessage data) { //simply dispatch the data to the correct method switch (data.DataType) { case DataType.Accelerometer: Process(data as AccelerometerData); break; case DataType.Touch: Process(data as TouchData); break; case DataType.Text: Process(data as TextData); break; case DataType.Tap: Process(data as TapData); break; } }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message) { MrsTracer.ProxyService.Function("DataExport.SendMessageAndWaitForReply", new object[0]); if (message is FlushMessage) { this.CheckForCancel(); this.result = DataExport.DataExportResult.Flush; this.eventDataAvailable.Set(); this.WaitForTheNextCall(); return(null); } if (message is FxProxyGetObjectDataRequestMessage && this.getDataResponseMsg is FxProxyGetObjectDataResponseMessage) { return(this.getDataResponseMsg); } if (message is FxProxyPoolGetFolderDataRequestMessage && this.getDataResponseMsg is FxProxyPoolGetFolderDataResponseMessage) { return(this.getDataResponseMsg); } throw new UnexpectedErrorPermanentException(-2147024809); }
void ISourceMailbox.SetMailboxSyncState(string syncState) { MrsTracer.ProxyClient.Function("RemoteSourceMailbox.SetMailboxSyncState", new object[0]); base.VerifyMailboxConnection(); IDataExport dataExport = new PagedTransmitter(syncState, base.MrsProxyClient.UseCompression); DataExportBatch dataExportBatch = dataExport.ExportData(); long handle = base.MrsProxy.ISourceMailbox_SetMailboxSyncState(base.Handle, dataExportBatch); if (!dataExportBatch.IsLastBatch) { using (IDataImport dataImport = new RemoteDataImport(base.MrsProxy, handle, null)) { do { dataExportBatch = dataExport.ExportData(); IDataMessage message = DataMessageSerializer.Deserialize(dataExportBatch.Opcode, dataExportBatch.Data, base.MrsProxyClient.UseCompression); dataImport.SendMessage(message); }while (!dataExportBatch.IsLastBatch); } } }
/// <summary> /// Sends the specified data message to the server. /// </summary> /// <param name="data">The data message to send.</param> public void Send(IDataMessage data) { Guard(); _logger.Trace("Send request for data {0}", data.DataType); lock (_messageQueue) { if (_isSending) { _messageQueue.Enqueue(data); } else { SendDataMessage(data); } } }
private void RaiseDataMessageReceivedEvent(IDataMessage dataMessage) { _logger.Trace("Raising event DataMessageReceived"); _synchronizationContext.Post(o => { var handlers = DataMessageReceived; if (handlers != null) { handlers(this, new DataMessageEventArgs(dataMessage)); } }, null); }
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message) { return(base.WrappedObject.SendMessageAndWaitForReply(message)); }
public RemoteDataImport(IMailboxReplicationProxyService mrsProxy, long handle, IDataMessage getDataResponseMsg) : base(mrsProxy, handle) { this.getDataResponseMsg = getDataResponseMsg; }
void IDataImport.SendMessage(IDataMessage message) { FxProxyPoolOpenFolderMessage fxProxyPoolOpenFolderMessage = message as FxProxyPoolOpenFolderMessage; if (fxProxyPoolOpenFolderMessage != null) { this.ClearCurrentObjectsReferences(); this.currentFolder = base.WrappedObject.GetFolderProxy(fxProxyPoolOpenFolderMessage.Buffer); return; } FxProxyPoolCreateFolderMessage fxProxyPoolCreateFolderMessage = message as FxProxyPoolCreateFolderMessage; if (fxProxyPoolCreateFolderMessage != null) { this.ClearCurrentObjectsReferences(); this.currentFolder = base.WrappedObject.CreateFolder(fxProxyPoolCreateFolderMessage.Data); return; } FxProxyPoolSetItemPropertiesMessage fxProxyPoolSetItemPropertiesMessage = message as FxProxyPoolSetItemPropertiesMessage; if (fxProxyPoolSetItemPropertiesMessage != null) { if (fxProxyPoolSetItemPropertiesMessage.Props != null) { if (this.currentMessage != null) { this.currentMessage.SetItemProperties(fxProxyPoolSetItemPropertiesMessage.Props); return; } if (this.currentFolder != null) { this.currentFolder.SetItemProperties(fxProxyPoolSetItemPropertiesMessage.Props); return; } base.WrappedObject.SetItemProperties(fxProxyPoolSetItemPropertiesMessage.Props); } return; } if (this.currentFolder == null) { throw new FolderIsMissingTransientException(); } FxProxyPoolOpenItemMessage fxProxyPoolOpenItemMessage = message as FxProxyPoolOpenItemMessage; if (fxProxyPoolOpenItemMessage != null) { this.currentMessage = this.CurrentFolder.OpenMessage(fxProxyPoolOpenItemMessage.Buffer); return; } FxProxyPoolCreateItemMessage fxProxyPoolCreateItemMessage = message as FxProxyPoolCreateItemMessage; if (fxProxyPoolCreateItemMessage != null) { this.currentMessage = this.CurrentFolder.CreateMessage(fxProxyPoolCreateItemMessage.CreateFAI); return; } FxProxyPoolDeleteItemMessage fxProxyPoolDeleteItemMessage = message as FxProxyPoolDeleteItemMessage; if (fxProxyPoolDeleteItemMessage != null) { this.CurrentFolder.DeleteMessage(fxProxyPoolDeleteItemMessage.Buffer); return; } FxProxyPoolCloseEntryMessage fxProxyPoolCloseEntryMessage = message as FxProxyPoolCloseEntryMessage; if (fxProxyPoolCloseEntryMessage != null) { if (this.currentMessage != null) { this.currentMessage.Dispose(); this.currentMessage = null; return; } if (this.currentFolder != null) { this.currentFolder.Dispose(); this.currentFolder = null; } return; } else { FxProxyPoolSetPropsMessage fxProxyPoolSetPropsMessage = message as FxProxyPoolSetPropsMessage; if (fxProxyPoolSetPropsMessage != null) { this.CurrentEntry.SetProps(fxProxyPoolSetPropsMessage.PropValues); return; } FxProxyPoolSetExtendedAclMessage fxProxyPoolSetExtendedAclMessage = message as FxProxyPoolSetExtendedAclMessage; if (fxProxyPoolSetExtendedAclMessage != null) { this.CurrentFolder.SetItemProperties(new FolderAcl(fxProxyPoolSetExtendedAclMessage.AclFlags, fxProxyPoolSetExtendedAclMessage.AclData)); return; } FxProxyPoolSaveChangesMessage fxProxyPoolSaveChangesMessage = message as FxProxyPoolSaveChangesMessage; if (fxProxyPoolSaveChangesMessage != null) { this.CurrentMessage.SaveChanges(); return; } FxProxyPoolWriteToMimeMessage fxProxyPoolWriteToMimeMessage = message as FxProxyPoolWriteToMimeMessage; if (fxProxyPoolWriteToMimeMessage != null) { this.CurrentMessage.WriteToMime(fxProxyPoolWriteToMimeMessage.Buffer); return; } FxProxyImportBufferMessage fxProxyImportBufferMessage = message as FxProxyImportBufferMessage; if (fxProxyImportBufferMessage != null) { this.CurrentEntry.ProcessRequest(fxProxyImportBufferMessage.Opcode, fxProxyImportBufferMessage.Buffer); return; } throw new UnexpectedErrorPermanentException(-2147024809); } }
/// <summary> /// Initializes a new instance of the <see cref="DataMessageEventArgs"/> class. /// </summary> /// <param name="dataMessage">The data message.</param> public DataMessageEventArgs(IDataMessage dataMessage) { DataMessage = dataMessage; }
private void SendDataMessage(IDataMessage data) { _logger.Trace("Sending data message {0}", data.DataType); _isSending = true; var rawData = data.ToByteArray(); // take a look whether we need to throttle sending if (MinMillisecondsBetweenMessages > 0) { var now = DateTime.Now; var elapsed = now - _lastMessageSent; var diff = MinMillisecondsBetweenMessages - (int)Math.Floor(elapsed.TotalMilliseconds); if (diff > 0) { Thread.Sleep(diff); } } if (data.MustBeDelivered) { Socket.SendAsync(rawData); } else { _udpSender.SendToAsync(rawData); } // store reference time _lastMessageSent = DateTime.Now; }