public MimeParserForm(ExchangeService oExchangeService, ItemId oItemId) { InitializeComponent(); //_ExchangeService = oExchangeService; //_ItemId = oItemId; string sMIME = string.Empty; DumpHelper.GetItemMime( oItemId, oExchangeService, ref sMIME); bool bRet = LoadMessage("string", sMIME); if (bRet == true) { StatusBar1.Text = "Loaded"; } else { StatusBar1.Text = "Not Loaded"; } DisableLoadSelection(); }
public UsbBlankGamepad(HidDevice device, string header, string dumpFileName) { VendorId = (short)device.VendorID; ProductId = (short)device.ProductID; _dumper = new DumpHelper(header, dumpFileName); }
public static UIObject ByNameAndClassName(UIObject root, string name, string className, bool shouldWait) { UICondition condition = UICondition.CreateFromName(name).AndWith(UICondition.CreateFromClassName(className)); UIObject uiObject = null; root.Descendants.TryFind(condition, out uiObject); if (shouldWait && !root.Descendants.TryFind(condition, out uiObject)) { Log.Comment("Object name = '{0}' className = '{1}' didn't exist, waiting...", name, className); try { TestEnvironment.WaitUntilElementLoadedByName(name); TestEnvironment.WaitUntilElementLoadedByClassName(className); } catch (WaiterTimedOutException) { Log.Error("Could not find object with condition '{0}'!", condition.ToString()); DumpHelper.DumpFullContext(); throw; } root.Descendants.TryFind(condition, out uiObject); Log.Comment("...Found"); } return(uiObject); }
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { string cur_time = DateTime.Now.ToString("yyyyMMddhhmmss"); string dump_name = "demo_dump_" + cur_time + ".dmp"; DumpHelper.TryDump(dump_name); }
public void WriteRequestAndReadResponse() { var channel = new TcpChannel(8080); ChannelServices.RegisterChannel(channel, false); RemotingServices.Marshal(new ServiceClass(), "Remote"); var uri = "tcp://localhost:8080/Remote"; using (var client = new TcpClient()) { client.Connect("localhost", 8080); using (var stream = client.GetStream()) { var messageRequest = new MethodCall(new Header[] { new Header(MessageHeader.Uri, uri), new Header(MessageHeader.MethodName, "Do"), new Header(MessageHeader.MethodSignature, new Type[] { typeof(string) }), new Header(MessageHeader.TypeName, typeof(ServiceClass).AssemblyQualifiedName), new Header(MessageHeader.Args, new object[] { "Hi" }) }); var messageRequestStream = BinaryFormatterHelper.SerializeObject(messageRequest); var handle = new TcpProtocolHandle(stream); //send remoting request handle.WritePreamble(); handle.WriteMajorVersion(); handle.WriteMinorVersion(); handle.WriteOperation(TcpOperations.Request); handle.WriteContentDelimiter(TcpContentDelimiter.ContentLength); handle.WriteContentLength(messageRequestStream.Length); handle.WriteTransportHeaders(new Dictionary <string, object>() { { TcpTransportHeader.RequestUri, uri } }); handle.WriteContent(messageRequestStream); //read remoting response Console.WriteLine("Preamble: {0}", handle.ReadPreamble()); Console.WriteLine("MajorVersion: {0}", handle.ReadMajorVersion()); Console.WriteLine("MinorVersion: {0}", handle.ReadMinorVersion()); var op = handle.ReadOperation(); Assert.AreEqual(TcpOperations.Reply, op); Console.WriteLine("Operation: {0}", op); Console.WriteLine("ContentDelimiter: {0}", handle.ReadContentDelimiter()); Console.WriteLine("ContentLength: {0}", handle.ReadContentLength()); handle.ReadTransportHeaders(); var messageResponse = BinaryFormatterHelper.DeserializeObject(handle.ReadContent()) as MethodResponse; Assert.IsNotNull(messageResponse); DumpHelper.DumpMessage(messageResponse); if (messageResponse.Exception != null) { throw messageResponse.Exception; } Assert.AreEqual("Hi", messageResponse.ReturnValue); } } }
public void InitializeFromDump(string path) { path = DumpHelper.NormalizeDumpPath(path); var schemaPath = Path.Combine(path, "schema.json"); var json = File.ReadAllText(schemaPath); var schema = SerializationHelper.DeserializeJson <Schema>(json); foreach (var typeDescription in schema.TypeDescriptions) { // register the type on the server var shard = 0; foreach (var client in CacheClients) { var request = new RegisterTypeRequest(typeDescription, shard, CacheClients.Count); var response = client.Channel.SendRequest(request); if (response is ExceptionResponse exResponse) { throw new CacheException("Error while registering a type on the server", exResponse.Message, exResponse.CallStack); } shard++; } FeedMany(DumpHelper.ObjectsInDump(path, typeDescription), true); } // reinitialize the sequences. As the shard count has probably changed reinitialize all the sequences in each shard // starting with the maximum value var maxValues = new Dictionary <string, int>(); var files = Directory.EnumerateFiles(path, "sequence_*.json"); foreach (var file in files) { var sequenceJson = File.ReadAllText(file); var seq = SerializationHelper.DeserializeJson <Dictionary <string, int> >(sequenceJson); foreach (var pair in seq) { var keyFound = maxValues.ContainsKey(pair.Key); if (keyFound && maxValues[pair.Key] < pair.Value || !keyFound) { maxValues[pair.Key] = pair.Value; } } } // resync sequences on the server ResyncUniqueIds(maxValues); }
public void ReadRequestAndWriteResponse() { IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList; var endpoint = new IPEndPoint(addressList[addressList.Length - 1], 9900); var listener = new TcpListener(endpoint); listener.Start(); var t = new Thread(new ThreadStart(() => { var c = listener.AcceptTcpClient(); var handle = new HttpProtocolHandle(c.GetStream()); //read remoting request Trace.WriteLine(handle.ReadFirstLine()); DumpHelper.DumpDictionary(handle.ReadHeaders()); var messageRequest = BinaryFormatterHelper.DeserializeObject(handle.ReadContent()) as MethodCall; //HACK:SoapFormatter not work well //http://labs.developerfusion.co.uk/SourceViewer/browse.aspx?assembly=SSCLI&namespace=System.Runtime.Remoting //var f = new System.Runtime.Serialization.Formatters.Soap.SoapFormatter(); //f.Context = new System.Runtime.Serialization.StreamingContext(System.Runtime.Serialization.StreamingContextStates.Other); //var mc = new MethodCall(this.Parse(headers)); //var messageRequest = f.Deserialize(new System.IO.MemoryStream(content), new HeaderHandler(mc.HeaderHandler)); Assert.IsNotNull(messageRequest); DumpHelper.DumpMessage(messageRequest); //write remoting response var responeMessage = new MethodResponse(new Header[] { new Header(MessageHeader.Return, messageRequest.Args[0]) }, messageRequest); var responseStream = BinaryFormatterHelper.SerializeObject(responeMessage); handle.WriteResponseFirstLine("200", "ok"); handle.WriteHeaders(new Dictionary <string, object>() { { HttpHeader.ContentLength, responseStream.Length } }); handle.WriteContent(responseStream); //end httprequest c.Close(); })); t.Start(); //use BinaryFormatter via HTTP var channel = new HttpChannel(new Hashtable(), new BinaryClientFormatterSinkProvider(), null); ChannelServices.RegisterChannel(channel, false); var url = string.Format("http://{0}/remote.rem", endpoint); var service = RemotingServices.Connect(typeof(ServiceClass), url) as ServiceClass; Assert.AreEqual("Hi", service.Do("Hi")); t.Abort(); ChannelServices.UnregisterChannel(channel); }
/// <summary> /// Dumps an object's contents to a string /// </summary> /// <param name="extended">object to dump</param> /// <param name="maxDepth">max depth to walk</param> /// <returns>object's contents</returns> public static string Dump(this object extended, ushort maxDepth) { Arguments.NotNull(extended, nameof(extended)); var context = new DumperContext(maxDepth); DumpHelper.Write(extended, context); return(context.ToString()); }
internal void LoadFromDump(string path, int shardIndex) { foreach (var cachedObject in DumpHelper.ObjectsInDump(path, CollectionSchema, shardIndex)) { InternalAddNew(cachedObject); // only in debug, only if this simulation was activated (for tests only) Dbg.SimulateException(100, shardIndex); } }
public static void Main(string[] args) { var p = new Person(); p.Name = "Duke"; WriteLine($"Hello {p.Name}"); ImportantInfo = p.Name; DumpHelper.CreateDump(Combine( ConfigurationManager.AppSettings[IntPtr.Size == 4 ? "DumpLocationX86" : "DumpLocationX64"], "helloworld.dmp")); }
public static void DumpMimeContents(ExchangeService service, Folder folder) { if (folder != null) { string outputPath = FormsUtil.GetFolderPathFromDialog("Pick a folder to save the MIME files in."); DumpHelper.DumpMIME( folder, ItemTraversal.Shallow, outputPath, service); } }
IEnumerable <User> ListUsers() { Console.WriteLine("---List Users---"); ApiResultHttpClientHelper <IEnumerable <User> > client = new ApiResultHttpClientHelper <IEnumerable <User> >(); client.Url = String.Format("{0}User", clo.apiUrl); client.AccessToken = accessToken; client.BaseAddress = clo.apiUrl; var users = client.GetApiResult(); DumpHelper.DumpUsers(users, 10); return(users); }
public static void DumpXmlContents(ExchangeService service, Folder folder) { if (folder != null) { string outputPath = FormsUtil.GetFolderPathFromDialog("Pick a folder to save the XML files in."); DumpHelper.DumpXML( folder, ItemTraversal.Shallow, new PropertySet(BasePropertySet.FirstClassProperties), outputPath, service); } }
public void InitializeFromDump(string path) { path = DumpHelper.NormalizeDumpPath(path); var schemaPath = Path.Combine(path, "schema.json"); var json = File.ReadAllText(schemaPath); var schema = SerializationHelper.DeserializeJson <Schema>(json); foreach (var collections in schema.CollectionsDescriptions) { // register the type on the server var shard = 0; foreach (var client in CacheClients) { client.DeclareCollection(collections.Key, collections.Value, shard); shard++; } FeedMany(collections.Key, DumpHelper.ObjectsInDump(path, collections.Value), true); } // reinitialize the sequences. As the shard count has probably changed reinitialize all the sequences in each shard // starting with the maximum value var maxValues = new Dictionary <string, int>(); var files = Directory.EnumerateFiles(path, "sequence_*.json"); foreach (var file in files) { var sequenceJson = File.ReadAllText(file); var seq = SerializationHelper.DeserializeJson <Dictionary <string, int> >(sequenceJson); foreach (var pair in seq) { var keyFound = maxValues.ContainsKey(pair.Key); if (keyFound && maxValues[pair.Key] < pair.Value || !keyFound) { maxValues[pair.Key] = pair.Value; } } } // resync sequences on the server ResyncUniqueIds(maxValues); }
public void ReadRequestAndWriteResponse() { IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList; var endpoint = new IPEndPoint(addressList[addressList.Length - 1], 9900); var listener = new TcpListener(endpoint); listener.Start(); var t = new Thread(new ThreadStart(() => { var c = listener.AcceptTcpClient(); var handle = new TcpProtocolHandle(c.GetStream()); //read remoting request Console.WriteLine("Preamble: {0}", handle.ReadPreamble()); Console.WriteLine("MajorVersion: {0}", handle.ReadMajorVersion()); Console.WriteLine("MinorVersion: {0}", handle.ReadMinorVersion()); var op = handle.ReadOperation(); Assert.AreEqual(TcpOperations.Request, op); Console.WriteLine("Operation: {0}", op); Console.WriteLine("ContentDelimiter: {0}", handle.ReadContentDelimiter()); Console.WriteLine("ContentLength: {0}", handle.ReadContentLength()); DumpHelper.DumpDictionary(handle.ReadTransportHeaders()); var messageRequest = BinaryFormatterHelper.DeserializeObject(handle.ReadContent()) as MethodCall; Assert.IsNotNull(messageRequest); DumpHelper.DumpMessage(messageRequest); //write remoting response var responeMessage = new MethodResponse(new Header[] { new Header(MessageHeader.Return, messageRequest.Args[0]) }, messageRequest); var responseStream = BinaryFormatterHelper.SerializeObject(responeMessage); handle.WritePreamble(); handle.WriteMajorVersion(); handle.WriteMinorVersion(); handle.WriteOperation(TcpOperations.Reply); handle.WriteContentDelimiter(TcpContentDelimiter.ContentLength); handle.WriteContentLength(responseStream.Length); handle.WriteTransportHeaders(null); handle.WriteContent(responseStream); })); t.Start(); var url = string.Format("tcp://{0}/remote.rem", endpoint); var service = RemotingServices.Connect(typeof(ServiceClass), url) as ServiceClass; Assert.AreEqual("Hi", service.Do("Hi")); t.Abort(); }
public MyForm() { InitializeComponent(); var button = new Button { Text = "Hello World" }; button.Click += (sender, args) => button.Text = "Clicked!"; Controls.Add(button); DumpHelper.CreateDump(Combine( ConfigurationManager.AppSettings[IntPtr.Size == 4 ? "DumpLocationX86" : "DumpLocationX64"], "winforms.dmp")); Environment.Exit(0); }
User AccessCurrentUser() { Console.WriteLine("---Current User---"); ApiResultHttpClientHelper <User> client = new ApiResultHttpClientHelper <User>(); client.Url = String.Format("{0}me", clo.apiUrl); client.AccessToken = accessToken; client.BaseAddress = clo.apiUrl; var user = client.GetApiResult(); DumpHelper.DumpUsers(new List <User> { user }); return(user); }
public void Import_export_data_to_json() { //add some data var item1 = new CacheableTypeOk(1, 1001, "aaa", new DateTime(2010, 10, 10), 1500); _client.Put(item1); var item2 = new CacheableTypeOk(2, 1002, "aaa", new DateTime(2010, 10, 10), 1600); _client.Put(item2); var item3 = new CacheableTypeOk(3, 1003, "bbb", new DateTime(2010, 10, 10), 1600); _client.Put(item3); var parser = new CommandLineParser(_client.GetClusterInformation()); var selectInto = parser.Parse("select CacheableTypeOk where IndexKeyFolder=aaa into export_test.json"); selectInto.TryExecute(_client); FileAssert.Exists("export_test.json"); var exported = DumpHelper.LoadObjects("export_test.json", _client).ToList(); Assert.AreEqual(2, exported.Count); var json = File.ReadAllText("export_test.json"); json = json.Replace("aaa", "abc"); File.WriteAllText("export_test.json", json); var import = parser.Parse("import export_test.json"); import.TryExecute(_client); _logger.Reset(); var cmd = _parser.Parse("count CacheableTypeOk where IndexKeyFolder=abc"); Assert.IsTrue(cmd.CanExecute); Assert.IsNotNull(cmd.TryExecute(_client)); var response = _logger.Buffer; var items = ExtractOne(@"\s*found\s*([0-9]*?)\s*items", response); Assert.AreEqual(items, "2"); }
public static void SetValueAndWait(this Edit edit, string s) { if (edit == null) { Log.Error("Attempted to set value on a null edit control! Dumping context..."); DumpHelper.DumpFullContext(); throw new ArgumentNullException("edit"); } using (var waiter = new ValueChangedEventWaiter(edit, s)) { edit.SetValue(s); waiter.Wait(); } Wait.ForIdle(); }
public static void InvokeAndWait(this Button button) { if (button == null) { Log.Error("Attempted to invoke a null button! Dumping context..."); DumpHelper.DumpFullContext(); throw new ArgumentNullException("button"); } using (var waiter = button.GetInvokedWaiter()) { button.Invoke(); waiter.Wait(); } Wait.ForIdle(); }
public static void ToggleAndWait(this ToggleButton toggleButton) { if (toggleButton == null) { Log.Error("Attempted to toggle a null toggle button! Dumping context..."); DumpHelper.DumpFullContext(); throw new ArgumentNullException("toggleButton"); } using (var waiter = toggleButton.GetToggledWaiter()) { toggleButton.Toggle(); waiter.Wait(); } Wait.ForIdle(); }
public static void CollapseAndWait(this SplitButton splitButton) { if (splitButton == null) { Log.Error("Attempted to collapse a null split button! Dumping context..."); DumpHelper.DumpFullContext(); throw new ArgumentNullException("splitButton"); } using (var waiter = splitButton.GetCollapsedWaiter()) { splitButton.Collapse(); waiter.Wait(); } Wait.ForIdle(); }
private static UIObject TryGetObject(string key, List <Dictionary <string, UIObject> > dictionaries, Action <string> waitAction = null) { UIObject obj = null; Func <bool> tryGetObjectFromDictionaries = () => { foreach (Dictionary <string, UIObject> dictionary in dictionaries) { if (dictionary.TryGetValue(key, out obj)) { return(true); } } return(false); }; if (!tryGetObjectFromDictionaries()) { Refresh(); if (!tryGetObjectFromDictionaries() && waitAction != null) { try { waitAction(key); } catch (WaiterTimedOutException) { Log.Error("Could not find '{0}'!", key); DumpHelper.DumpFullContext(); throw; } tryGetObjectFromDictionaries(); } } return(obj); }
public void WriteRequestAndReadResponse() { var properties = new Hashtable() { { "port", 8080 } }; var channel = new HttpChannel(properties, null, new BinaryServerFormatterSinkProvider()); ChannelServices.RegisterChannel(channel, false); RemotingServices.Marshal(new ServiceClass(), "Remote"); var uri = "http://localhost:8080/Remote"; var messageRequest = new MethodCall(new Header[] { new Header(MessageHeader.Uri, uri), new Header(MessageHeader.MethodName, "Do"), new Header(MessageHeader.MethodSignature, new Type[] { typeof(string) }), new Header(MessageHeader.TypeName, typeof(ServiceClass).AssemblyQualifiedName), new Header(MessageHeader.Args, new object[] { "Hi" }) }); var messageRequestStream = BinaryFormatterHelper.SerializeObject(messageRequest); var wc = new WebClient(); var messageResponse = BinaryFormatterHelper.DeserializeObject(wc.UploadData(uri, messageRequestStream)) as MethodResponse; Assert.IsNotNull(messageResponse); DumpHelper.DumpMessage(messageResponse); if (messageResponse.Exception != null) { throw messageResponse.Exception; } Assert.AreEqual("Hi", messageResponse.ReturnValue); //handle.WriteRequestFirstLine("POST", "/Remote"); //handle.WriteHeaders(new Dictionary<string, object>() { { HttpHeader.ContentLength, messageRequestStream.Length } }); //HACK:http will send 100 continue after read http header //handle.WriteContent(messageRequestStream); ChannelServices.UnregisterChannel(channel); }
public static void InvokeAndWait(this MenuItem menuItem, TimeSpan?timeout = null) { if (menuItem == null) { Log.Error("Attempted to invoke a null MenuItem! Dumping context..."); DumpHelper.DumpFullContext(); throw new ArgumentNullException("menuItem"); } using (var waiter = menuItem.GetInvokedWaiter()) { menuItem.Invoke(); if (timeout == null) { waiter.Wait(); } else { waiter.Wait(timeout.Value); } } Wait.ForIdle(); }
public static void ForIdle(bool findElementsIfNull = true) { TestEnvironment.LogVerbose("Wait.ForIdle: Begin"); try { // If any of these are null, then we haven't initialized our idle helpers yet. // We should just return - we'll do that soon after this. if (waitForIdleInvokerButton == null || idleStateEnteredCheckBox == null || errorReportingTextBox == null || logReportingTextBox == null) { return; } using (UIEventWaiter idleStateEnteredWaiter = idleStateEnteredCheckBox.GetToggledWaiter()) { TestEnvironment.LogSuperVerbose("Wait.ForIdle: After GetToggledWaiter"); using (var errorReportedWaiter = new ValueChangedEventWaiter(errorReportingTextBox)) { TestEnvironment.LogSuperVerbose("Wait.ForIdle: Before WaitForIdleInvoker.Invoke"); idleStateEnteredWaiter.AddFilter((WaiterEventArgs) => idleStateEnteredCheckBox.ToggleState == ToggleState.On); waitForIdleInvokerButton.Invoke(); TestEnvironment.LogSuperVerbose("Wait.ForIdle: After WaitForIdleInvoker.Invoke"); var waiter = CompositableWaiter.WaitAny(TimeSpan.FromSeconds(300), idleStateEnteredWaiter, errorReportedWaiter); if (waiter == errorReportedWaiter) { AutomationPropertyChangedEventArgs args = errorReportedWaiter.Arguments.EventArgs as AutomationPropertyChangedEventArgs; string errorMessage = args.NewValue as string; if (!IsRS2OrHigher() && errorMessage == "Animation complete wait took longer than idle timeout.") { Log.Warning("Timed out waiting for animation complete. Queueing application to close after this test."); TestEnvironment.ShouldRestartApplication = true; } else if (errorMessage.Length > 0) { Log.Error("Error while waiting for idle: {0}", errorMessage); DumpHelper.DumpFullContext(); throw new WaiterException(errorMessage); } } else { var value = logReportingTextBox.Value; if (!String.IsNullOrEmpty(value)) { TestEnvironment.LogSuperVerbose(value); logReportingTextBox.SetValue(""); } } } } } catch (ElementNotAvailableException) { if (!isRetrying && findElementsIfNull) { // If we got an element-not-available exception, we'll re-initialize our wait helper and try again. // If that doesn't work, then we'll just fail. ResetIdleHelper(); InitializeWaitHelper(); isRetrying = true; ForIdle(); } else { if (TestEnvironment.Application.Process == null) { Log.Error("Tried to wait for idle before starting the test app!"); } else if (TestEnvironment.Application.Process.HasExited) { Log.Error("Tried to wait for idle after the test app has closed!"); } throw; } } TestEnvironment.LogVerbose("Wait.ForIdle: End"); }
public void Import(string collectionName, string jsonFile) { var objects = DumpHelper.LoadObjects(this, jsonFile, collectionName); FeedMany(collectionName, objects, true); }
public void WriteRequestAndReadResponse() { //var properties = new Hashtable() { { "port", 8080 } }; //var channel = new TcpChannel(properties, null, new SoapServerFormatterSinkProvider()); //if using SOAP via TCP, messageRequestStream must be SOAP format var channel = new TcpChannel(8080); ChannelServices.RegisterChannel(channel, false); var service = new ServiceClass(); ObjRef obj = RemotingServices.Marshal(service, "Remote"); var uri = "tcp://localhost:8080/Remote"; using (var client = new TcpClient()) { client.Connect("localhost", 8080); using (var stream = client.GetStream()) { var messageRequest = new MethodCall(new Header[] { new Header("__Uri", uri), new Header("__MethodName", "Do"), new Header("__MethodSignature", new Type[] { typeof(string) }), new Header("__TypeName", typeof(ServiceClass).AssemblyQualifiedName), new Header("__Args", new object[] { "Hi" }) }); var messageRequestStream = BinaryFormatterHelper.SerializeObject(messageRequest); var writer = new ProtocolWriter(stream); writer.WritePreamble(); writer.WriteMajorVersion(); writer.WriteMinorVersion(); writer.WriteOperation(TcpOperations.Request); writer.WriteContentDelimiter(TcpContentDelimiter.ContentLength); writer.WriteContentLength(messageRequestStream.Length); writer.WriteTransportHeaders(uri); writer.WriteBytes(messageRequestStream); var reader = new ProtocolReader(stream); Console.WriteLine("Preamble: {0}", reader.ReadPreamble()); Console.WriteLine("MajorVersion: {0}", reader.ReadMajorVersion()); Console.WriteLine("MinorVersion: {0}", reader.ReadMinorVersion()); var op = reader.ReadOperation(); Assert.AreEqual(TcpOperations.Reply, op); Console.WriteLine("Operation: {0}", op); Console.WriteLine("ContentDelimiter: {0}", reader.ReadContentDelimiter()); var length = reader.ReadContentLength(); Console.WriteLine("ContentLength: {0}", length); reader.ReadTransportHeaders(); var messageResponse = BinaryFormatterHelper.DeserializeObject(reader.ReadBytes(length)) as MethodResponse; Assert.IsNotNull(messageResponse); DumpHelper.DumpMessage(messageResponse); if (messageResponse.Exception != null) { throw messageResponse.Exception; } Assert.AreEqual("Hi", messageResponse.ReturnValue); } } }
void ProcessReceive(SocketAsyncEventArgs e) { if (e.BytesTransferred > 0) { if (e.SocketError == SocketError.Success) { totalBuffer = Combine(totalBuffer, e.Buffer); if (e.AcceptSocket.Available == 0) { //.Net Remoting Protocol Parser #region Read Request Console.WriteLine("==== .Net Remoting Protocol Parser ===="); //1. Preamble, will be ".NET" Console.WriteLine("Preamble: {0}", Encoding.ASCII.GetString(new byte[] { totalBuffer[0], totalBuffer[1], totalBuffer[2], totalBuffer[3] })); //2. MajorVersion, will be 1 Console.WriteLine("MajorVersion: {0}", totalBuffer[4]); //3. MinorVersion, will be 0 Console.WriteLine("MinorVersion: {0}", totalBuffer[5]); //4. Operation, will be 5 (request,onewayrequest...) Console.WriteLine("Operation: {0}", (UInt16)(totalBuffer[6] & 0xFF | totalBuffer[7] << 8)); //5. TcpContentDelimiter and ContentLength var header = (UInt16)(totalBuffer[8] & 0xFF | totalBuffer[9] << 8); if (header == 1) { Console.WriteLine("Chunked: {0}", true); } else { Console.WriteLine("ContentLength: {0}" , (int)((totalBuffer[10] & 0xFF) | totalBuffer[11] << 8 | totalBuffer[12] << 16 | totalBuffer[13] << 24)); } #region 6. ReadHeaders ITransportHeaders Console.WriteLine("---- ITransportHeaders ----"); var index = header == 1 ? 9 : 13; var headerType = ReadUInt16(ref index); while (headerType != TcpHeaders.EndOfHeaders) { if (headerType == TcpHeaders.Custom) { Console.WriteLine("{0}: {1}", ReadCountedString(ref index), ReadCountedString(ref index)); } else if (headerType == TcpHeaders.RequestUri) { Console.WriteLine("RequestUri-Format: {0}", ReadByte(ref index)); Console.WriteLine("RequestUri: {0}", ReadCountedString(ref index)); } else if (headerType == TcpHeaders.StatusCode) { Console.WriteLine("StatusCode-Format: {0}", ReadByte(ref index)); var code = ReadUInt16(ref index); Console.WriteLine("StatusCode: {0}", code); //if (code != 0) error = true; } else if (headerType == TcpHeaders.StatusPhrase) { Console.WriteLine("StatusPhrase-Format: {0}", ReadByte(ref index)); Console.WriteLine("StatusPhrase: {0}", ReadCountedString(ref index)); } else if (headerType == TcpHeaders.ContentType) { Console.WriteLine("ContentType-Format: {0}", ReadByte(ref index)); Console.WriteLine("ContentType: {0}", ReadCountedString(ref index)); } else { var headerFormat = (byte)ReadByte(ref index); switch (headerFormat) { case TcpHeaderFormat.Void: break; case TcpHeaderFormat.CountedString: ReadCountedString(ref index); break; case TcpHeaderFormat.Byte: ReadByte(ref index); break; case TcpHeaderFormat.UInt16: ReadUInt16(ref index); break; case TcpHeaderFormat.Int32: ReadInt32(ref index); break; default: throw new RemotingException("Remoting_Tcp_UnknownHeaderType"); } } headerType = ReadUInt16(ref index); } #endregion //7. RequestStream/Message var requestStream = new byte[totalBuffer.Length - index - 1]; Buffer.BlockCopy(totalBuffer, index + 1, requestStream, 0, totalBuffer.Length - index - 1); //using BinaryFormatterSink default var requestMessage = BinaryFormatterHelper.DeserializeObject(requestStream) as MethodCall; DumpHelper.DumpMessage(requestMessage); #endregion buffers = new StringBuilder(); totalBuffer = new byte[0]; #region Write Response //http://labs.developerfusion.co.uk/SourceViewer/browse.aspx?assembly=SSCLI&namespace=System.Runtime.Remoting //else if (name.Equals("__Return")) var responeMessage = new MethodResponse( //just return args[0] new Header[] { new Header("__Return", requestMessage.Args[0]) } , requestMessage); //responeMessage.ReturnValue//can not set var responseStream = BinaryFormatterHelper.SerializeObject(responeMessage); //1.Preamble var preamble = Encoding.ASCII.GetBytes(".NET"); foreach (var b in preamble) { WriteByte(b); } //2.MajorVersion WriteByte((byte)1); //3.MinorVersion WriteByte((byte)0); //4.Operation WriteUInt16(TcpOperations.Reply); //5.TcpContentDelimiter and ContentLength WriteUInt16(0); WriteInt32(responseStream.Length); //6.Headers WriteUInt16(TcpHeaders.EndOfHeaders); //7.ResponseStream/Message foreach (var b in responseStream) { WriteByte(b); } #endregion e.SetBuffer(totalBuffer, 0, totalBuffer.Length); if (!e.AcceptSocket.SendAsync(e)) { this.ProcessSend(e); } } else if (!e.AcceptSocket.ReceiveAsync(e)) { this.ProcessReceive(e); } } else { //this.ProcessError(e); } } else { //this.CloseClientSocket(e); } }
public void Import(string jsonFile) { var objects = DumpHelper.LoadObjects(jsonFile, this); FeedMany(objects, true); }