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);
}
