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

Update svn properties. Squash a couple of warnings.

0.6.0-stable
Jeff Ames 2008-07-22 15:01:04 +00:00
parent 492b25362c
commit 186f83692c
3 changed files with 267 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
OpenSim/Data/NHibernate/NHibernateAssetData.cs
View File

@ -107,7 +107,7 @@ namespace OpenSim.Data.NHibernate
{ {
return session.Load(typeof(AssetBase), uuid) as AssetBase; return session.Load(typeof(AssetBase), uuid) as AssetBase;
} }
catch (ObjectNotFoundException e) catch (ObjectNotFoundException)
{ {
m_log.ErrorFormat("[NHIBERNATE] no such asset {0}", uuid); m_log.ErrorFormat("[NHIBERNATE] no such asset {0}", uuid);
return null; return null;
@ -125,7 +125,7 @@ namespace OpenSim.Data.NHibernate
{ {
AssetBase a = session.Load(typeof(AssetBase), asset.FullID) as AssetBase; AssetBase a = session.Load(typeof(AssetBase), asset.FullID) as AssetBase;
} }
catch (ObjectNotFoundException e) catch (ObjectNotFoundException)
{ {
session.Save(asset); session.Save(asset);
session.Flush(); session.Flush();

4
OpenSim/Data/NHibernate/NHibernateRegionData.cs
View File

@ -125,7 +125,7 @@ namespace OpenSim.Data.NHibernate
session.Update(p); session.Update(p);
m_log.InfoFormat("[NHIBERNATE] updating object {0}", p.UUID); m_log.InfoFormat("[NHIBERNATE] updating object {0}", p.UUID);
} }
catch (ObjectNotFoundException e) catch (ObjectNotFoundException)
{ {
m_log.InfoFormat("[NHIBERNATE] saving object {0}", p.UUID); m_log.InfoFormat("[NHIBERNATE] saving object {0}", p.UUID);
session.Save(p); session.Save(p);
@ -145,7 +145,7 @@ namespace OpenSim.Data.NHibernate
session.Update(t); session.Update(t);
session.Flush(); session.Flush();
} }
catch (ObjectNotFoundException e) catch (ObjectNotFoundException)
{ {
session.Save(t); session.Save(t);
session.Flush(); session.Flush();

526
OpenSim/Region/ClientStack/LindenUDP/LLPacketTracker.cs
View File

@ -1,263 +1,263 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
using System.Threading; using System.Threading;
using libsecondlife; using libsecondlife;
using libsecondlife.Packets; using libsecondlife.Packets;
using OpenSim.Framework; using OpenSim.Framework;
namespace OpenSim.Region.ClientStack.LindenUDP namespace OpenSim.Region.ClientStack.LindenUDP
{ {
public class LLPacketTracker public class LLPacketTracker
{ {
public delegate void PacketAcked(uint sequenceNumber); public delegate void PacketAcked(uint sequenceNumber);
public event PacketAcked OnPacketAcked; public event PacketAcked OnPacketAcked;
protected List<uint> m_beenAcked = new List<uint>(); protected List<uint> m_beenAcked = new List<uint>();
protected TerrainPacketTracker[,] m_sentTerrainPackets = new TerrainPacketTracker[16, 16]; protected TerrainPacketTracker[,] m_sentTerrainPackets = new TerrainPacketTracker[16, 16];
protected Dictionary<LLUUID, PrimPacketTracker> m_sendPrimPackets = new Dictionary<LLUUID, PrimPacketTracker>(); protected Dictionary<LLUUID, PrimPacketTracker> m_sendPrimPackets = new Dictionary<LLUUID, PrimPacketTracker>();
protected LLClientView m_parentClient; protected LLClientView m_parentClient;
public LLPacketTracker(LLClientView parent) public LLPacketTracker(LLClientView parent)
{ {
m_parentClient = parent; m_parentClient = parent;
OnPacketAcked += TerrainPacketAcked; OnPacketAcked += TerrainPacketAcked;
//OnPacketAcked += PrimPacketAcked; //OnPacketAcked += PrimPacketAcked;
} }
public void PacketAck(uint sequenceNumber) public void PacketAck(uint sequenceNumber)
{ {
lock (m_beenAcked) lock (m_beenAcked)
{ {
m_beenAcked.Add(sequenceNumber); m_beenAcked.Add(sequenceNumber);
} }
} }
public void TrackTerrainPacket(uint sequenceNumber, int patchX, int patchY) public void TrackTerrainPacket(uint sequenceNumber, int patchX, int patchY)
{ {
TrackTerrainPacket(sequenceNumber, patchX, patchY, false, null); TrackTerrainPacket(sequenceNumber, patchX, patchY, false, null);
} }
public void TrackTerrainPacket(uint sequenceNumber, int patchX, int patchY, bool keepResending, LayerDataPacket packet) public void TrackTerrainPacket(uint sequenceNumber, int patchX, int patchY, bool keepResending, LayerDataPacket packet)
{ {
TerrainPacketTracker tracker = new TerrainPacketTracker(); TerrainPacketTracker tracker = new TerrainPacketTracker();
tracker.X = patchX; tracker.X = patchX;
tracker.Y = patchY; tracker.Y = patchY;
tracker.SeqNumber = sequenceNumber; tracker.SeqNumber = sequenceNumber;
tracker.TimeSent = DateTime.Now; tracker.TimeSent = DateTime.Now;
tracker.KeepResending = keepResending; tracker.KeepResending = keepResending;
tracker.Packet = packet; tracker.Packet = packet;
lock (m_sentTerrainPackets) lock (m_sentTerrainPackets)
{ {
m_sentTerrainPackets[patchX, patchY] = tracker; m_sentTerrainPackets[patchX, patchY] = tracker;
} }
} }
public void TrackPrimPacket(uint sequenceNumber, LLUUID primID) public void TrackPrimPacket(uint sequenceNumber, LLUUID primID)
{ {
PrimPacketTracker tracker = new PrimPacketTracker(); PrimPacketTracker tracker = new PrimPacketTracker();
tracker.PrimID = primID; tracker.PrimID = primID;
tracker.TimeSent = DateTime.Now; tracker.TimeSent = DateTime.Now;
tracker.SeqNumber = sequenceNumber; tracker.SeqNumber = sequenceNumber;
lock (m_sendPrimPackets) lock (m_sendPrimPackets)
{ {
m_sendPrimPackets[primID] = tracker; m_sendPrimPackets[primID] = tracker;
} }
} }
public void TerrainPacketCheck() public void TerrainPacketCheck()
{ {
DateTime now = DateTime.Now; DateTime now = DateTime.Now;
List<TerrainPacketTracker> resendList = new List<TerrainPacketTracker>(); List<TerrainPacketTracker> resendList = new List<TerrainPacketTracker>();
lock (m_sentTerrainPackets) lock (m_sentTerrainPackets)
{ {
for (int y = 0; y < 16; y++) for (int y = 0; y < 16; y++)
{ {
for (int x = 0; x < 16; x++) for (int x = 0; x < 16; x++)
{ {
if (m_sentTerrainPackets[x, y] != null) if (m_sentTerrainPackets[x, y] != null)
{ {
TerrainPacketTracker tracker = m_sentTerrainPackets[x, y]; TerrainPacketTracker tracker = m_sentTerrainPackets[x, y];
if ((now - tracker.TimeSent) > TimeSpan.FromMinutes(1)) if ((now - tracker.TimeSent) > TimeSpan.FromMinutes(1))
{ {
tracker.TimeSent = now; tracker.TimeSent = now;
m_sentTerrainPackets[x, y] = null; m_sentTerrainPackets[x, y] = null;
resendList.Add(tracker); resendList.Add(tracker);
} }
} }
} }
} }
} }
foreach (TerrainPacketTracker tracker in resendList) foreach (TerrainPacketTracker tracker in resendList)
{ {
if (!tracker.KeepResending) if (!tracker.KeepResending)
{ {
m_parentClient.TriggerTerrainUnackedEvent(tracker.X, tracker.Y); m_parentClient.TriggerTerrainUnackedEvent(tracker.X, tracker.Y);
} }
else else
{ {
if (tracker.Packet != null) if (tracker.Packet != null)
{ {
tracker.Packet.Header.Resent = true; tracker.Packet.Header.Resent = true;
m_parentClient.OutPacket(tracker.Packet, ThrottleOutPacketType.Resend); m_parentClient.OutPacket(tracker.Packet, ThrottleOutPacketType.Resend);
tracker.TimeSent = DateTime.Now; tracker.TimeSent = DateTime.Now;
lock (m_sentTerrainPackets) lock (m_sentTerrainPackets)
{ {
if (m_sentTerrainPackets[tracker.X, tracker.Y] == null) if (m_sentTerrainPackets[tracker.X, tracker.Y] == null)
{ {
m_sentTerrainPackets[tracker.X, tracker.Y] = tracker; m_sentTerrainPackets[tracker.X, tracker.Y] = tracker;
} }
} }
} }
} }
} }
} }
public void PrimPacketCheck() public void PrimPacketCheck()
{ {
DateTime now = DateTime.Now; DateTime now = DateTime.Now;
List<PrimPacketTracker> resendList = new List<PrimPacketTracker>(); List<PrimPacketTracker> resendList = new List<PrimPacketTracker>();
List<PrimPacketTracker> ackedList = new List<PrimPacketTracker>(); List<PrimPacketTracker> ackedList = new List<PrimPacketTracker>();
lock (m_sendPrimPackets) lock (m_sendPrimPackets)
{ {
foreach (PrimPacketTracker tracker in m_sendPrimPackets.Values) foreach (PrimPacketTracker tracker in m_sendPrimPackets.Values)
{ {
if (tracker.Acked) if (tracker.Acked)
{ {
ackedList.Add(tracker); ackedList.Add(tracker);
} }
else if (((now - tracker.TimeSent) > TimeSpan.FromMinutes(1)) && (!tracker.Acked)) else if (((now - tracker.TimeSent) > TimeSpan.FromMinutes(1)) && (!tracker.Acked))
{ {
resendList.Add(tracker); resendList.Add(tracker);
} }
} }
} }
foreach (PrimPacketTracker tracker in resendList) foreach (PrimPacketTracker tracker in resendList)
{ {
lock (m_sendPrimPackets) lock (m_sendPrimPackets)
{ {
m_sendPrimPackets.Remove(tracker.PrimID); m_sendPrimPackets.Remove(tracker.PrimID);
} }
//call event //call event
Console.WriteLine("Prim packet not acked, " + tracker.PrimID.ToString()); Console.WriteLine("Prim packet not acked, " + tracker.PrimID.ToString());
} }
RemovePrimTrackers(ackedList); RemovePrimTrackers(ackedList);
} }
public void PrimTrackerCleanup() public void PrimTrackerCleanup()
{ {
List<PrimPacketTracker> ackedList = new List<PrimPacketTracker>(); List<PrimPacketTracker> ackedList = new List<PrimPacketTracker>();
lock (m_sendPrimPackets) lock (m_sendPrimPackets)
{ {
foreach (PrimPacketTracker tracker in m_sendPrimPackets.Values) foreach (PrimPacketTracker tracker in m_sendPrimPackets.Values)
{ {
if (tracker.Acked) if (tracker.Acked)
{ {
ackedList.Add(tracker); ackedList.Add(tracker);
} }
} }
} }
Thread.Sleep(15); //give a little bit of time for other code to access list before we lock it again Thread.Sleep(15); //give a little bit of time for other code to access list before we lock it again
RemovePrimTrackers(ackedList); RemovePrimTrackers(ackedList);
} }
protected void RemovePrimTrackers(List<PrimPacketTracker> ackedList) protected void RemovePrimTrackers(List<PrimPacketTracker> ackedList)
{ {
lock (m_sendPrimPackets) lock (m_sendPrimPackets)
{ {
foreach (PrimPacketTracker tracker in ackedList) foreach (PrimPacketTracker tracker in ackedList)
{ {
m_sendPrimPackets.Remove(tracker.PrimID); m_sendPrimPackets.Remove(tracker.PrimID);
} }
} }
} }
protected void TerrainPacketAcked(uint sequence) protected void TerrainPacketAcked(uint sequence)
{ {
lock (m_sentTerrainPackets) lock (m_sentTerrainPackets)
{ {
for (int y = 0; y < 16; y++) for (int y = 0; y < 16; y++)
{ {
for (int x = 0; x < 16; x++) for (int x = 0; x < 16; x++)
{ {
if (m_sentTerrainPackets[x, y] != null) if (m_sentTerrainPackets[x, y] != null)
{ {
if (m_sentTerrainPackets[x, y].SeqNumber == sequence) if (m_sentTerrainPackets[x, y].SeqNumber == sequence)
{ {
m_sentTerrainPackets[x, y] = null; m_sentTerrainPackets[x, y] = null;
return; return;
} }
} }
} }
} }
} }
} }
protected void PrimPacketAcked(uint sequence) protected void PrimPacketAcked(uint sequence)
{ {
lock (m_sendPrimPackets) lock (m_sendPrimPackets)
{ {
foreach (PrimPacketTracker tracker in m_sendPrimPackets.Values) foreach (PrimPacketTracker tracker in m_sendPrimPackets.Values)
{ {
if (tracker.SeqNumber == sequence) if (tracker.SeqNumber == sequence)
{ {
tracker.Acked = true; tracker.Acked = true;
break; break;
} }
} }
} }
} }
public void Process() public void Process()
{ {
List<uint> ackedPackets = null; List<uint> ackedPackets = null;
lock (m_beenAcked) lock (m_beenAcked)
{ {
ackedPackets = new List<uint>(m_beenAcked); ackedPackets = new List<uint>(m_beenAcked);
m_beenAcked.Clear(); m_beenAcked.Clear();
} }
if (ackedPackets != null) if (ackedPackets != null)
{ {
foreach (uint packetId in ackedPackets) foreach (uint packetId in ackedPackets)
{ {
if (OnPacketAcked != null) if (OnPacketAcked != null)
{ {
OnPacketAcked(packetId); OnPacketAcked(packetId);
} }
} }
} }
// ackedPackets.Clear(); // ackedPackets.Clear();
ackedPackets = null; ackedPackets = null;
} }
public class TerrainPacketTracker public class TerrainPacketTracker
{ {
public uint SeqNumber = 0; public uint SeqNumber = 0;
public int X; public int X;
public int Y; public int Y;
public DateTime TimeSent; public DateTime TimeSent;
public LayerDataPacket Packet; public LayerDataPacket Packet;
public bool KeepResending; public bool KeepResending;
} }
public class PrimPacketTracker public class PrimPacketTracker
{ {
public uint SeqNumber = 0; public uint SeqNumber = 0;
public DateTime TimeSent; public DateTime TimeSent;
public LLUUID PrimID; public LLUUID PrimID;
public bool Acked = false; public bool Acked = false;
} }
} }
} }