OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reactivate BasicCircuitTests.TestAddClient() 

This checks that the initial UseCircuitCode packet is handled correctly for a normal client login.
0.7.2-post-fixes
Justin Clark-Casey (justincc) 2011-12-08 20:52:34 +00:00
parent 7e415e3f85
commit 638afca5aa
5 changed files with 200 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
OpenSim/Framework/Util.cs
View File

@ -58,10 +58,12 @@ namespace OpenSim.Framework
/// <remarks> /// <remarks>
/// None is used to execute the method in the same thread that made the call. It should only be used by regression /// None is used to execute the method in the same thread that made the call. It should only be used by regression
/// test code that relies on predictable event ordering. /// test code that relies on predictable event ordering.
/// RegressionTest is used by regression tests. It fires the call synchronously and does not catch any exceptions.
/// </remarks> /// </remarks>
public enum FireAndForgetMethod public enum FireAndForgetMethod
{ {
None, None,
RegressionTest,
UnsafeQueueUserWorkItem, UnsafeQueueUserWorkItem,
QueueUserWorkItem, QueueUserWorkItem,
BeginInvoke, BeginInvoke,
@ -1544,27 +1546,38 @@ namespace OpenSim.Framework
public static void FireAndForget(System.Threading.WaitCallback callback, object obj) public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
{ {
// When OpenSim interacts with a database or sends data over the wire, it must send this in en_US culture WaitCallback realCallback;
// so that we don't encounter problems where, for instance, data is saved with a culture that uses commas
// for decimals places but is read by a culture that treats commas as number seperators.
WaitCallback realCallback = delegate(object o)
{
Culture.SetCurrentCulture();
try if (FireAndForgetMethod == FireAndForgetMethod.RegressionTest)
{
// If we're running regression tests, then we want any exceptions to rise up to the test code.
realCallback = o => { Culture.SetCurrentCulture(); callback(o); };
}
else
{
// When OpenSim interacts with a database or sends data over the wire, it must send this in en_US culture
// so that we don't encounter problems where, for instance, data is saved with a culture that uses commas
// for decimals places but is read by a culture that treats commas as number seperators.
realCallback = o =>
{ {
callback(o); Culture.SetCurrentCulture();
}
catch (Exception e) try
{ {
// m_log.ErrorFormat( callback(o);
// "[UTIL]: Continuing after async_call_method thread terminated with exception {0}{1}", }
// e.Message, e.StackTrace); catch (Exception e)
} {
}; m_log.ErrorFormat(
"[UTIL]: Continuing after async_call_method thread terminated with exception {0}{1}",
e.Message, e.StackTrace);
}
};
}
switch (FireAndForgetMethod) switch (FireAndForgetMethod)
{ {
case FireAndForgetMethod.RegressionTest:
case FireAndForgetMethod.None: case FireAndForgetMethod.None:
realCallback.Invoke(obj); realCallback.Invoke(obj);
break; break;

20
OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
View File

@ -611,11 +611,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue; outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue;
} }
protected override void PacketReceived(UDPPacketBuffer buffer) public override void PacketReceived(UDPPacketBuffer buffer)
{ {
// Debugging/Profiling // Debugging/Profiling
//try { Thread.CurrentThread.Name = "PacketReceived (" + m_scene.RegionInfo.RegionName + ")"; } //try { Thread.CurrentThread.Name = "PacketReceived (" + m_scene.RegionInfo.RegionName + ")"; }
//catch (Exception) { } //catch (Exception) { }
// m_log.DebugFormat(
// "[LLUDPSERVER]: Packet received from {0} in {1}", buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
LLUDPClient udpClient = null; LLUDPClient udpClient = null;
Packet packet = null; Packet packet = null;
@ -625,7 +627,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
#region Decoding #region Decoding
if (buffer.DataLength < 7) if (buffer.DataLength < 7)
{
// m_log.WarnFormat(
// "[LLUDPSERVER]: Dropping undersized packet with {0} bytes received from {1} in {2}",
// buffer.DataLength, buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
return; // Drop undersizd packet return; // Drop undersizd packet
}
int headerLen = 7; int headerLen = 7;
if (buffer.Data[6] == 0xFF) if (buffer.Data[6] == 0xFF)
@ -637,7 +645,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
} }
if (buffer.DataLength < headerLen) if (buffer.DataLength < headerLen)
{
// m_log.WarnFormat(
// "[LLUDPSERVER]: Dropping packet with malformed header received from {0} in {1}",
// buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
return; // Malformed header return; // Malformed header
}
try try
{ {
@ -650,6 +664,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
} }
catch (IndexOutOfRangeException) catch (IndexOutOfRangeException)
{ {
// m_log.WarnFormat(
// "[LLUDPSERVER]: Dropping short packet received from {0} in {1}",
// buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
return; // Drop short packet return; // Drop short packet
} }
catch(Exception e) catch(Exception e)

2
OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
View File

@ -44,7 +44,7 @@ namespace OpenMetaverse
/// This method is called when an incoming packet is received /// This method is called when an incoming packet is received
/// </summary> /// </summary>
/// <param name="buffer">Incoming packet buffer</param> /// <param name="buffer">Incoming packet buffer</param>
protected abstract void PacketReceived(UDPPacketBuffer buffer); public abstract void PacketReceived(UDPPacketBuffer buffer);
/// <summary>UDP port to bind to in server mode</summary> /// <summary>UDP port to bind to in server mode</summary>
protected int m_udpPort; protected int m_udpPort;

223
OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
View File

@ -25,6 +25,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System;
using System.Net; using System.Net;
using log4net.Config; using log4net.Config;
using Nini.Config; using Nini.Config;
@ -32,10 +33,11 @@ using NUnit.Framework;
using OpenMetaverse; using OpenMetaverse;
using OpenMetaverse.Packets; using OpenMetaverse.Packets;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Region.Framework.Scenes;
using OpenSim.Tests.Common; using OpenSim.Tests.Common;
using OpenSim.Tests.Common.Mock; using OpenSim.Tests.Common.Mock;
namespace OpenSim.Region.ClientStack.LindenUDP.Tests namespace OpenSim.Region.ClientStack.LindenUDP
{ {
/// <summary> /// <summary>
/// This will contain basic tests for the LindenUDP client stack /// This will contain basic tests for the LindenUDP client stack
@ -43,17 +45,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
[TestFixture] [TestFixture]
public class BasicCircuitTests public class BasicCircuitTests
{ {
[SetUp] [TestFixtureSetUp]
public void Init() public void FixtureInit()
{ {
try // Don't allow tests to be bamboozled by asynchronous events. Execute everything on the same thread.
{ Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
XmlConfigurator.Configure(); }
}
catch [TestFixtureTearDown]
{ public void TearDown()
// I don't care, just leave log4net off {
} // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
// threads. Possibly, later tests should be rewritten so none of them require async stuff (which regression
// tests really shouldn't).
Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
} }
// /// <summary> // /// <summary>
@ -78,54 +83,54 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
// testLLUDPServer.LocalScene = scene; // testLLUDPServer.LocalScene = scene;
// } // }
/// <summary> // /// <summary>
/// Set up a client for tests which aren't concerned with this process itself and where only one client is being // /// Set up a client for tests which aren't concerned with this process itself and where only one client is being
/// tested // /// tested
/// </summary> // /// </summary>
/// <param name="circuitCode"></param> // /// <param name="circuitCode"></param>
/// <param name="epSender"></param> // /// <param name="epSender"></param>
/// <param name="testLLUDPServer"></param> // /// <param name="testLLUDPServer"></param>
/// <param name="acm"></param> // /// <param name="acm"></param>
protected void AddClient( // protected void AddClient(
uint circuitCode, EndPoint epSender, TestLLUDPServer testLLUDPServer, AgentCircuitManager acm) // uint circuitCode, EndPoint epSender, TestLLUDPServer testLLUDPServer, AgentCircuitManager acm)
{ // {
UUID myAgentUuid = UUID.Parse("00000000-0000-0000-0000-000000000001"); // UUID myAgentUuid = UUID.Parse("00000000-0000-0000-0000-000000000001");
UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002"); // UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002");
//
// AddClient(circuitCode, epSender, myAgentUuid, mySessionUuid, testLLUDPServer, acm);
// }
AddClient(circuitCode, epSender, myAgentUuid, mySessionUuid, testLLUDPServer, acm); // /// <summary>
} // /// Set up a client for tests which aren't concerned with this process itself
// /// </summary>
/// <summary> // /// <param name="circuitCode"></param>
/// Set up a client for tests which aren't concerned with this process itself // /// <param name="epSender"></param>
/// </summary> // /// <param name="agentId"></param>
/// <param name="circuitCode"></param> // /// <param name="sessionId"></param>
/// <param name="epSender"></param> // /// <param name="testLLUDPServer"></param>
/// <param name="agentId"></param> // /// <param name="acm"></param>
/// <param name="sessionId"></param> // protected void AddClient(
/// <param name="testLLUDPServer"></param> // uint circuitCode, EndPoint epSender, UUID agentId, UUID sessionId,
/// <param name="acm"></param> // TestLLUDPServer testLLUDPServer, AgentCircuitManager acm)
protected void AddClient( // {
uint circuitCode, EndPoint epSender, UUID agentId, UUID sessionId, // AgentCircuitData acd = new AgentCircuitData();
TestLLUDPServer testLLUDPServer, AgentCircuitManager acm) // acd.AgentID = agentId;
{ // acd.SessionID = sessionId;
AgentCircuitData acd = new AgentCircuitData(); //
acd.AgentID = agentId; // UseCircuitCodePacket uccp = new UseCircuitCodePacket();
acd.SessionID = sessionId; //
// UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
UseCircuitCodePacket uccp = new UseCircuitCodePacket(); // = new UseCircuitCodePacket.CircuitCodeBlock();
// uccpCcBlock.Code = circuitCode;
UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock // uccpCcBlock.ID = agentId;
= new UseCircuitCodePacket.CircuitCodeBlock(); // uccpCcBlock.SessionID = sessionId;
uccpCcBlock.Code = circuitCode; // uccp.CircuitCode = uccpCcBlock;
uccpCcBlock.ID = agentId; //
uccpCcBlock.SessionID = sessionId; // acm.AddNewCircuit(circuitCode, acd);
uccp.CircuitCode = uccpCcBlock; //
// testLLUDPServer.LoadReceive(uccp, epSender);
acm.AddNewCircuit(circuitCode, acd); // testLLUDPServer.ReceiveData(null);
// }
testLLUDPServer.LoadReceive(uccp, epSender);
testLLUDPServer.ReceiveData(null);
}
/// <summary> /// <summary>
/// Build an object name packet for test purposes /// Build an object name packet for test purposes
@ -144,54 +149,60 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
return onp; return onp;
} }
// /// <summary> /// <summary>
// /// Test adding a client to the stack /// Test adding a client to the stack
// /// </summary> /// </summary>
// [Test] [Test]
// public void TestAddClient() public void TestAddClient()
// { {
// TestHelper.InMethod(); TestHelpers.InMethod();
// XmlConfigurator.Configure();
// uint myCircuitCode = 123456;
// UUID myAgentUuid = UUID.Parse("00000000-0000-0000-0000-000000000001"); TestScene scene = SceneHelpers.SetupScene();
// UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002"); uint myCircuitCode = 123456;
// UUID myAgentUuid = TestHelpers.ParseTail(0x1);
// TestLLUDPServer testLLUDPServer; UUID mySessionUuid = TestHelpers.ParseTail(0x2);
// TestLLPacketServer testLLPacketServer; IPEndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
// AgentCircuitManager acm;
// SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm); uint port = 0;
// AgentCircuitManager acm = scene.AuthenticateHandler;
// AgentCircuitData acd = new AgentCircuitData();
// acd.AgentID = myAgentUuid; LLUDPServer llUdpServer
// acd.SessionID = mySessionUuid; = new LLUDPServer(IPAddress.Any, ref port, 0, false, new IniConfigSource(), acm);
// llUdpServer.AddScene(scene);
// UseCircuitCodePacket uccp = new UseCircuitCodePacket();
// UseCircuitCodePacket uccp = new UseCircuitCodePacket();
// UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
// = new UseCircuitCodePacket.CircuitCodeBlock(); UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
// uccpCcBlock.Code = myCircuitCode; = new UseCircuitCodePacket.CircuitCodeBlock();
// uccpCcBlock.ID = myAgentUuid; uccpCcBlock.Code = myCircuitCode;
// uccpCcBlock.SessionID = mySessionUuid; uccpCcBlock.ID = myAgentUuid;
// uccp.CircuitCode = uccpCcBlock; uccpCcBlock.SessionID = mySessionUuid;
// uccp.CircuitCode = uccpCcBlock;
// EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
// byte[] uccpBytes = uccp.ToBytes();
// testLLUDPServer.LoadReceive(uccp, testEp); UDPPacketBuffer upb = new UDPPacketBuffer(testEp, uccpBytes.Length);
// testLLUDPServer.ReceiveData(null); upb.DataLength = uccpBytes.Length; // God knows why this isn't set by the constructor.
// Buffer.BlockCopy(uccpBytes, 0, upb.Data, 0, uccpBytes.Length);
// // Circuit shouildn't exist since the circuit manager doesn't know about this circuit for authentication yet
// Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode)); llUdpServer.PacketReceived(upb);
//
// acm.AddNewCircuit(myCircuitCode, acd); // Presence shouldn't exist since the circuit manager doesn't know about this circuit for authentication yet
// Assert.That(scene.GetScenePresence(myAgentUuid), Is.Null);
// testLLUDPServer.LoadReceive(uccp, testEp);
// testLLUDPServer.ReceiveData(null); AgentCircuitData acd = new AgentCircuitData();
// acd.AgentID = myAgentUuid;
// // Should succeed now acd.SessionID = mySessionUuid;
// Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode));
// Assert.IsFalse(testLLUDPServer.HasCircuit(101)); acm.AddNewCircuit(myCircuitCode, acd);
// }
// llUdpServer.PacketReceived(upb);
// Should succeed now
ScenePresence sp = scene.GetScenePresence(myAgentUuid);
Assert.That(sp.UUID, Is.EqualTo(myAgentUuid));
}
// /// <summary> // /// <summary>
// /// Test removing a client from the stack // /// Test removing a client from the stack
// /// </summary> // /// </summary>

33
bin/OpenSim.Region.ClientStack.LindenUDP.Tests.dll.config Normal file
View File

@ -0,0 +1,33 @@
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
</configSections>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="nunit.framework" publicKeyToken="96d09a1eb7f44a77" culture="Neutral" />
<bindingRedirect oldVersion="2.0.6.0" newVersion="2.4.6.0" />
<bindingRedirect oldVersion="2.1.4.0" newVersion="2.4.6.0" />
<bindingRedirect oldVersion="2.2.8.0" newVersion="2.4.6.0" />
</dependentAssembly>
</assemblyBinding>
</runtime>
<log4net>
<!-- A1 is set to be a ConsoleAppender -->
<appender name="A1" type="log4net.Appender.ConsoleAppender">
<!-- A1 uses PatternLayout -->
<layout type="log4net.Layout.PatternLayout">
<!-- Print the date in ISO 8601 format -->
<conversionPattern value="%date [%thread] %-5level %logger %ndc - %message%newline" />
</layout>
</appender>
<!-- Set root logger level to DEBUG and its only appender to A1 -->
<root>
<level value="DEBUG" />
<appender-ref ref="A1" />
</root>
</log4net>
</configuration>