public void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination, Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq)
{
if (reg == null || finalDestination == null)
{
sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
return;
}
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Request Teleport to {0} ({1}) {2}/{3}",
reg.ServerURI, finalDestination.ServerURI, finalDestination.RegionName, position);
uint newRegionX = (uint)(reg.RegionHandle >> 40);
uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
uint oldRegionX = (uint)(sp.Scene.RegionInfo.RegionHandle >> 40);
uint oldRegionY = (((uint)(sp.Scene.RegionInfo.RegionHandle)) >> 8);
ulong destinationHandle = finalDestination.RegionHandle;
// Let's do DNS resolution only once in this process, please!
// This may be a costly operation. The reg.ExternalEndPoint field is not a passive field,
// it's actually doing a lot of work.
IPEndPoint endPoint = finalDestination.ExternalEndPoint;
if (endPoint.Address != null)
{
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (sp.ParentID != (uint)0)
sp.StandUp();
if (!sp.ValidateAttachments())
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Failed validation of all attachments for teleport of {0} from {1} to {2}. Continuing.",
sp.Name, sp.Scene.RegionInfo.RegionName, finalDestination.RegionName);
// if (!sp.ValidateAttachments())
// {
// sp.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
// return;
// }
string reason;
string version;
if (!m_aScene.SimulationService.QueryAccess(finalDestination, sp.ControllingClient.AgentId, Vector3.Zero, out version, out reason))
{
sp.ControllingClient.SendTeleportFailed("Teleport failed: " + reason);
return;
}
m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Destination is running version {0}", version);
sp.ControllingClient.SendTeleportStart(teleportFlags);
// the avatar.Close below will clear the child region list. We need this below for (possibly)
// closing the child agents, so save it here (we need a copy as it is Clear()-ed).
//List<ulong> childRegions = avatar.KnownRegionHandles;
// Compared to ScenePresence.CrossToNewRegion(), there's no obvious code to handle a teleport
// failure at this point (unlike a border crossing failure). So perhaps this can never fail
// once we reach here...
//avatar.Scene.RemoveCapsHandler(avatar.UUID);
string capsPath = String.Empty;
AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
AgentCircuitData agentCircuit = sp.ControllingClient.RequestClientInfo();
agentCircuit.startpos = position;
agentCircuit.child = true;
agentCircuit.Appearance = sp.Appearance;
if (currentAgentCircuit != null)
{
agentCircuit.ServiceURLs = currentAgentCircuit.ServiceURLs;
agentCircuit.IPAddress = currentAgentCircuit.IPAddress;
agentCircuit.Viewer = currentAgentCircuit.Viewer;
agentCircuit.Channel = currentAgentCircuit.Channel;
agentCircuit.Mac = currentAgentCircuit.Mac;
agentCircuit.Id0 = currentAgentCircuit.Id0;
}
if (NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY))
{
// brand new agent, let's create a new caps seed
agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
}
// Let's create an agent there if one doesn't exist yet.
bool logout = false;
if (!CreateAgent(sp, reg, finalDestination, agentCircuit, teleportFlags, out reason, out logout))
{
sp.ControllingClient.SendTeleportFailed(String.Format("Destination refused: {0}",
reason));
return;
}
// OK, it got this agent. Let's close some child agents
sp.CloseChildAgents(newRegionX, newRegionY);
IClientIPEndpoint ipepClient;
if (NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY))
{
//sp.ControllingClient.SendTeleportProgress(teleportFlags, "Creating agent...");
#region IP Translation for NAT
// Uses ipepClient above
if (sp.ClientView.TryGet(out ipepClient))
{
endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
}
#endregion
capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
if (eq != null)
{
eq.EnableSimulator(destinationHandle, endPoint, sp.UUID);
// ES makes the client send a UseCircuitCode message to the destination,
// which triggers a bunch of things there.
// So let's wait
Thread.Sleep(200);
eq.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
}
else
{
sp.ControllingClient.InformClientOfNeighbour(destinationHandle, endPoint);
}
}
else
{
agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
}
SetInTransit(sp.UUID);
// Let's send a full update of the agent. This is a synchronous call.
AgentData agent = new AgentData();
sp.CopyTo(agent);
agent.Position = position;
SetCallbackURL(agent, sp.Scene.RegionInfo);
//sp.ControllingClient.SendTeleportProgress(teleportFlags, "Updating agent...");
if (!UpdateAgent(reg, finalDestination, agent))
{
// Region doesn't take it
m_log.WarnFormat(
"[ENTITY TRANSFER MODULE]: UpdateAgent failed on teleport of {0} to {1}. Returning avatar to source region.",
sp.Name, finalDestination.RegionName);
Fail(sp, finalDestination);
return;
}
sp.ControllingClient.SendTeleportProgress(teleportFlags | (uint)TeleportFlags.DisableCancel, "sending_dest");
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, sp.UUID);
if (eq != null)
{
eq.TeleportFinishEvent(destinationHandle, 13, endPoint,
0, teleportFlags, capsPath, sp.UUID);
}
else
{
sp.ControllingClient.SendRegionTeleport(destinationHandle, 13, endPoint, 4,
teleportFlags, capsPath);
}
// Let's set this to true tentatively. This does not trigger OnChildAgent
sp.IsChildAgent = true;
// TeleportFinish makes the client send CompleteMovementIntoRegion (at the destination), which
// trigers a whole shebang of things there, including MakeRoot. So let's wait for confirmation
// that the client contacted the destination before we close things here.
if (!WaitForCallback(sp.UUID))
{
m_log.WarnFormat(
"[ENTITY TRANSFER MODULE]: Teleport of {0} to {1} failed due to no callback from destination region. Returning avatar to source region.",
sp.Name, finalDestination.RegionName);
Fail(sp, finalDestination);
return;
}
// For backwards compatibility
if (version == "Unknown" || version == string.Empty)
{
// CrossAttachmentsIntoNewRegion is a synchronous call. We shouldn't need to wait after it
m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Old simulator, sending attachments one by one...");
CrossAttachmentsIntoNewRegion(finalDestination, sp, true);
}
// May need to logout or other cleanup
AgentHasMovedAway(sp, logout);
// Well, this is it. The agent is over there.
KillEntity(sp.Scene, sp.LocalId);
// Now let's make it officially a child agent
sp.MakeChildAgent();
// sp.Scene.CleanDroppedAttachments();
// Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
if (NeedsClosing(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
{
Thread.Sleep(5000);
sp.Close();
sp.Scene.IncomingCloseAgent(sp.UUID);
}
else
{
// now we have a child agent in this region.
sp.IsInTransit = false; // not sure :(
sp.Reset();
}
// REFACTORING PROBLEM. Well, not a problem, but this method is HORRIBLE!
if (sp.Scene.NeedSceneCacheClear(sp.UUID))
{
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: User {0} is going to another region, profile cache removed",
sp.UUID);
}
}
else
{
sp.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
}
}
public void Add(IEventQueue queue)
{
if (queue.IsSynched)
this.tree.Add(queue);
else
this.list.Add(queue);
}
public void Remove(IEventQueue queue)
{
if (queue.IsSynched)
this.tree.Remove(queue);
else
this.list.Remove(queue);
}
internal DataSeriesObject(DataSeries series, DateTime dateTime1, DateTime dateTime2, IEventQueue queue)
{
this.series = series;
this.queue = queue;
if (dateTime1 == DateTime.MinValue || dateTime1 < series.DateTime1)
{
this.index1 = 0L;
}
else
{
this.index1 = series.GetIndex(dateTime1, SearchOption.Next);
}
if (dateTime2 == DateTime.MaxValue || dateTime2 > series.DateTime2)
{
this.index2 = series.count - 1L;
}
else
{
this.index2 = series.GetIndex(dateTime2, SearchOption.Prev);
}
this.current = this.index1;
this.obj = series[this.current];
this.progressDelta = (int)Math.Ceiling((double)this.Count / 100.0);
this.progressCount = this.progressDelta;
this.progressPercent = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="Replication"/> class.
/// </summary>
/// <param name="replicationLength">Length of the replication.</param>
/// <param name="dataGatherer">The data gatherer.</param>
/// <param name="queueFactory">The queue factory.</param>
/// <param name="startup">The startup time.</param>
public Replication(
uint replicationLength, IDataGatherer dataGatherer, IEventQueueFactory queueFactory, uint startup )
{
_replicationLength = replicationLength;
_startup = startup;
CurrentState = ReplicationState.NotStarted;
ReplicationData = dataGatherer;
_queue = queueFactory.Create( dataGatherer );
}
/// <summary>
/// Creates a new Parser Context
/// </summary>
/// <param name="g">Graph</param>
/// <param name="document">XML Document</param>
/// <param name="traceParsing">Whether to Trace Parsing</param>
public RdfXmlParserContext(IGraph g, XmlDocument document, bool traceParsing)
: base(g)
{
this._queue = new EventQueue(new DomBasedEventGenerator(document));
if (this._queue.EventGenerator is IPreProcessingEventGenerator)
{
((IPreProcessingEventGenerator)this._queue.EventGenerator).GetAllEvents(this);
}
}
private ExportComponent(bool supportInProcessStores, IEventQueue eventQueue)
{
this.SpanExporter = Export.SpanExporter.Create(ExporterBufferSize, ExporterScheduleDelay);
this.RunningSpanStore =
supportInProcessStores
? new InProcessRunningSpanStore()
: Export.RunningSpanStoreBase.NoopRunningSpanStore;
this.SampledSpanStore =
supportInProcessStores
? new InProcessSampledSpanStore(eventQueue)
: Export.SampledSpanStoreBase.NoopSampledSpanStore;
}
public XEventDataReader(
string connectionString,
string sessionName,
IEventQueue events,
ExtendedEventsWorkloadListener.ServerType serverType
)
{
ConnectionString = connectionString;
SessionName = sessionName;
Events = events;
ServerType = serverType;
}
//init
public DatabaseEventProvider(IEventQueue <TKey> eventQueue, IMonitor <TKey> eventSink
, SenderSettings senderSettings, ISignalEventQueries <TKey> eventQueries, ILogger logger)
{
_eventQueue = eventQueue;
_monitor = eventSink;
_eventQueries = eventQueries;
_logger = logger;
QueryPeriod = senderSettings.DatabaseSignalProviderQueryPeriod;
ItemsQueryCount = senderSettings.DatabaseSignalProviderItemsQueryCount;
MaxFailedAttempts = senderSettings.DatabaseSignalProviderItemsMaxFailedAttempts;
}
private ExportComponent(bool supportInProcessStores, IEventQueue eventQueue)
{
SpanExporter = Export.SpanExporter.Create(EXPORTER_BUFFER_SIZE, EXPORTER_SCHEDULE_DELAY);
this.RunningSpanStore =
supportInProcessStores
? new InProcessRunningSpanStore()
: Export.RunningSpanStoreBase.NoopRunningSpanStore;
this.SampledSpanStore =
supportInProcessStores
? new InProcessSampledSpanStore(eventQueue)
: Export.SampledSpanStoreBase.NoopSampledSpanStore;
}
private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
{
if (m_debugEnabled)
{
m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
DebugGridInstantMessage(im);
}
// Start group IM session
if ((im.dialog == (byte)InstantMessageDialog.SessionGroupStart))
{
UUID groupID = new UUID(im.toAgentID);
GroupRecord groupInfo = m_groupsModule.GetGroupRecord(groupID);
if (groupInfo != null)
{
if (m_debugEnabled)
{
m_log.DebugFormat("[GROUPS-MESSAGING]: Start Group Session for {0}", groupInfo.GroupName);
}
AddAgentToGroupSession(im.fromAgentID, im.imSessionID);
ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, groupID);
IEventQueue queue = remoteClient.Scene.RequestModuleInterface <IEventQueue>();
queue.ChatterBoxSessionAgentListUpdates(
new UUID(groupID)
, new UUID(im.fromAgentID)
, new UUID(im.fromAgentID)
, false //canVoiceChat
, false //isModerator
, false //text mute
, im.dialog
);
}
}
// Send a message from locally connected client to a group
if ((im.dialog == (byte)InstantMessageDialog.SessionSend))
{
UUID groupID = new UUID(im.toAgentID);
if (m_debugEnabled)
{
m_log.DebugFormat("[GROUPS-MESSAGING]: Send message to session for group {0} with session ID {1}", groupID, im.imSessionID.ToString());
}
SendMessageToGroup(remoteClient, im, groupID);
}
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="settings">The settings to use, or pass null to use the default settings.</param>
/// <param name="templateManager">The <see cref="BaseTemplateManager"/> used to access templates.</param>
/// <param name="blogSettingsResolver">The resolver used to resolve settings for specific blogs.</param>
/// <param name="eventQueue">The event queue to submit new comments to.</param>
public CommentManager(
IWeBlogSettings settings = null,
IWeBlogCommentSettings commentSettings = null,
BaseTemplateManager templateManager = null,
IBlogSettingsResolver blogSettingsResolver = null,
BaseEventQueueProvider eventQueue = null)
{
Settings = settings ?? WeBlogSettings.Instance;
CommentSettings = commentSettings ?? ServiceLocator.ServiceProvider.GetRequiredService <IWeBlogCommentSettings>();
TemplateManager = templateManager ?? ServiceLocator.ServiceProvider.GetRequiredService <BaseTemplateManager>();
BlogSettingsResolver = blogSettingsResolver ?? ServiceLocator.ServiceProvider.GetRequiredService <IBlogSettingsResolver>();
EventQueue = eventQueue ?? ServiceLocator.ServiceProvider.GetRequiredService <BaseEventQueueProvider>();
}
private void AddAgentToSession(UUID AgentID, UUID GroupID, GridInstantMessage msg)
{
// Agent not in session and hasn't dropped from session
// Add them to the session for now, and Invite them
AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
IClientAPI activeClient = GetActiveClient(AgentID);
if (activeClient != null)
{
GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), GroupID, null);
if (groupInfo != null)
{
if (m_debugEnabled)
{
m_log.DebugFormat("[Groups.Messaging]: Sending chatterbox invite instant message");
}
UUID fromAgent = new UUID(msg.fromAgentID);
// Force? open the group session dialog???
// and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
IEventQueue eq = activeClient.Scene.RequestModuleInterface <IEventQueue>();
if (eq != null)
{
eq.ChatterboxInvitation(
GroupID
, groupInfo.GroupName
, fromAgent
, msg.message
, AgentID
, msg.fromAgentName
, msg.dialog
, msg.timestamp
, msg.offline == 1
, (int)msg.ParentEstateID
, msg.Position
, 1
, new UUID(msg.imSessionID)
, msg.fromGroup
, OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
);
var update = new GroupChatListAgentUpdateData(AgentID);
var updates = new List <GroupChatListAgentUpdateData> {
update
};
eq.ChatterBoxSessionAgentListUpdates(GroupID, new UUID(msg.toAgentID), updates);
}
}
}
}
public BattleEventProcessor(IGUIService guiService, IBattleGraphicController graphicService, IEventQueue queue, IEventCreator events)
{
this.guiService = guiService;
this.graphicService = graphicService;
this.queue = queue;
events.CriticalDamage += CriticalDamageHandler;
events.HPChanged += HPChangedHandler;
events.MoveEffective += MoveEffectiveHandler;
events.MoveUsed += MoveUsedHandler;
events.NewTurn += NewTurnHandler;
events.PokemonChanged += PokemonChangedHandler;
events.StatusChanged += StatusChangedHandler;
}
public EventPushBackgroundService(IEventQueue eventQueue,
IHubContext <EventHub, IEventClient> hubContext,
IdentityGenerator identityGenerator,
IOptions <ApplicationSettings> options,
IEventStoreQueue storeQueue,
IMemoryCache memoryCache)
{
_eventQueue = eventQueue;
_hubContext = hubContext;
_identityGenerator = identityGenerator;
_options = options;
_storeQueue = storeQueue;
_memoryCache = memoryCache;
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing) return;
if (this.eventQueue != null)
{
this.eventQueue.Dispose();
this.eventQueue = null;
}
ExtensionPackage.Instance = null;
}
public static void CofigureWebRtcLib(CoreDispatcher uiDispatcher)
{
IEventQueue queue = EventQueueMaker.Bind(uiDispatcher);
var configuration = new WebRtcLibConfiguration();
configuration.Queue = queue;
configuration.AudioCaptureFrameProcessingQueue = EventQueue.GetOrCreateThreadQueueByName("AudioCaptureProcessingQueue");
configuration.AudioRenderFrameProcessingQueue = EventQueue.GetOrCreateThreadQueueByName("AudioRenderProcessingQueue");
configuration.VideoFrameProcessingQueue = EventQueue.GetOrCreateThreadQueueByName("VideoFrameProcessingQueue");
WebRtcLib.Setup(configuration);
Initialized?.Invoke(true);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="subscriptionsManager"></param>
/// <param name="eventStore"></param>
/// <param name="serviceProvider"></param>
public SimulationEventBus(
ILogger <SimulationEventBus> logger,
ISubscriptionsManager subscriptionsManager,
IEventQueue eventStore,
IServiceProvider serviceProvider)
{
this.logger = logger;
this.subscriptionsManager = subscriptionsManager ?? new InMemorySubscriptionsManager();
this.eventStore = eventStore;
this.serviceProvider = serviceProvider;
this.subscriptionsManager.OnEventRemoved += SubscriptionsManager_OnEventRemoved;
DoConsume();
}
public IList <Object> GetObjects(IList <IObjRef> orisToGet, ICacheIntern targetCache, CacheDirective cacheDirective)
{
CheckNotDisposed();
if (orisToGet == null || orisToGet.Count == 0)
{
return(new List <Object>(0));
}
IEventQueue eventQueue = EventQueue;
if (eventQueue != null)
{
eventQueue.Pause(this);
}
try
{
bool oldCacheModificationValue = CacheModification.Active;
bool acquireSuccess = AcquireHardRefTLIfNotAlready(orisToGet.Count);
CacheModification.Active = true;
try
{
if (cacheDirective.HasFlag(CacheDirective.LoadContainerResult) || cacheDirective.HasFlag(CacheDirective.CacheValueResult))
{
return(Parent.GetObjects(orisToGet, this, cacheDirective));
}
bool doAnotherRetry;
while (true)
{
doAnotherRetry = false;
IList <Object> result = GetObjectsRetry(orisToGet, cacheDirective, out doAnotherRetry);
if (!doAnotherRetry)
{
return(result);
}
}
}
finally
{
CacheModification.Active = oldCacheModificationValue;
ClearHardRefs(acquireSuccess);
}
}
finally
{
if (eventQueue != null)
{
eventQueue.Resume(this);
}
}
}
public FakeLoggerProvider(IOptionsMonitor <FakeLoggerOptions> options, IEventQueue eventQueue)
{
var loggerOptions = options.CurrentValue;
_interval = loggerOptions.FlushPeriod;
_batchSize = loggerOptions.BatchSize;
_queueSize = loggerOptions.BackgroundQueueSize;
_eventQueue = eventQueue ?? throw new ArgumentNullException(nameof(eventQueue));
_processId = Process.GetCurrentProcess().Id;
_optionsChangeToken = options.OnChange(UpdateOptions);
UpdateOptions(options.CurrentValue);
}
void EventManager_OnGetScriptRunning(OpenSim.Framework.IClientAPI controllingClient,
OpenMetaverse.UUID objectID, OpenMetaverse.UUID itemID)
{
_exeScheduler.PostScriptInfoRequest(new ScriptInfoRequest(itemID, ScriptInfoRequest.Type.ScriptRunningRequest,
delegate(ScriptInfoRequest req)
{
IEventQueue eq = World.RequestModuleInterface <IEventQueue>();
if (eq != null)
{
eq.Enqueue(EventQueueHelper.ScriptRunningReplyEvent(objectID, itemID, req.IsRunning, false),
controllingClient.AgentId);
}
}
));
}
//init
public EventProcessor(SenderState <TKey> hubState, IMonitor <TKey> eventSink
, ILogger logger, SenderSettings senderSettings
, IEventQueue <TKey> eventQueue, IDispatchQueue <TKey> dispatchQueue
, IEventHandlerRegistry <TKey> handlerRegistry, IEventSettingsQueries <TKey> eventSettingsQueries)
: base(logger)
{
_hubState = hubState;
_monitor = eventSink;
_eventQueue = eventQueue;
_dispatchQueue = dispatchQueue;
_handlerRegistry = handlerRegistry;
_eventSettingsQueries = eventSettingsQueries;
MaxParallelItems = senderSettings.MaxParallelEventsProcessed;
}
public override void Initialize(IGameEngine engine)
{
base.Initialize(engine);
// Create event queues.
var events = Engine.Systems.First <IEventQueueSystem>();
deletedEvents = events.CreateShared <int, EntityEventHandler>(EventQueueUsageHint.Lazy);
unpairedFromChildEvents = events.CreateShared <int, EntityPairEventHandler>(EventQueueUsageHint.Lazy);
unpairedFromParentEvents = events.CreateShared <int, EntityPairEventHandler>(EventQueueUsageHint.Lazy);
madeParentOfEvents = events.CreateShared <int, EntityPairEventHandler>(EventQueueUsageHint.Lazy);
madeChildOfEvents = events.CreateShared <int, EntityPairEventHandler>(EventQueueUsageHint.Lazy);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing)
{
return;
}
if (this.eventQueue != null)
{
this.eventQueue.Dispose();
this.eventQueue = null;
}
}
public void Add(IEventQueue queue)
{
if (queue.IsEmpty())
{
throw new Exception($"EventTree::Add Can not add queue, the queue is empty : {queue.Name}");
}
var item = new EventTreeItem(queue);
if (this.eventTreeItem_0 == null)
{
this.eventTreeItem_0 = item;
return;
}
this.method_0(item);
}
/// <summary>
/// Removes a collection of items from an event queue
/// </summary>
/// <param name="queue">The event queue</param>
/// <param name="itemsToRemove">The items to remove the event queue</param>
/// <returns>The new event queue, less the items to remove</returns>
public static IEventQueue Remove(this IEventQueue queue, IEnumerable <EventQueueItem> itemsToRemove)
{
var newQueue = new EventQueue();
var queueItems = queue.ToList();
foreach (var item in queueItems)
{
var matchFound = itemsToRemove.Any(_ => _.GetHashCode() == item.GetHashCode());
if (false == matchFound)
{
newQueue.Add(item.AggregateKey, item.AggregateType, item.Event);
}
}
return(newQueue);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing)
{
return;
}
if (this.eventQueue != null)
{
this.eventQueue.Dispose();
this.eventQueue = null;
}
ExtensionPackage.Instance = null;
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing)
{
return;
}
if (_eventQueue != null)
{
_eventQueue.Dispose();
_eventQueue = null;
}
Instance = null;
}
//init
public Sender(SenderState <TKey> hubState, IEventQueue <TKey> eventQueue,
IDispatchQueue <TKey> dispatchQueue, IEnumerable <IRegularJob> regularJobs,
IEnumerable <ISignalProviderControl> signalEndpoints)
{
_hubState = hubState;
_regularJobs = regularJobs.ToList();
_eventQueue = eventQueue;
_dispatchQueue = dispatchQueue;
_signalEndpoints = signalEndpoints.ToList();
_regularJobTimers = _regularJobs.Select(x => new NonReentrantTimer(x.Tick
, NotificationsConstants.REGULAR_JOB_TICK_INTERVAL, intervalFromCallbackStarted: false))
.ToList();
_stopMonitorTimer = new NonReentrantTimer(StopTimers
, NotificationsConstants.REGULAR_JOB_TICK_INTERVAL, intervalFromCallbackStarted: false);
_stopEventHandle = new ManualResetEventSlim(false);
}
private void Queue_EventReceived(IEventQueue sender, JToken arg)
{
lock (lockObj)
{
if (subscriptions.TryGetValue(sender.Name, out List <EvHandler> handlers))
{
foreach (var h in handlers)
{
h(arg);//TODO: handle errors?
}
}
else
{
throw new Exception("no handler exist for queue " + sender.Name + " but an event was received. this shouldnt happen. check yo code");
}
}
}
/// <summary>
/// Initializes all <see cref="IEventQueue" />s.
/// </summary>
private static void InitializeEventQueues()
{
try
{
Config config = Config.ReadConfig();
foreach (Pipeline pipeline in config.Pipelines)
{
IEventQueue eventQueue = EventQueue.GetQueue(pipeline.Name);
InitializeWorkerThreads(eventQueue, pipeline.WorkerThreads
.GetValueOrDefault(config.ProcessModel.WorkerThreads));
}
Log.Info("Event queues and worker threads have been initialized.");
}
catch (Exception ex)
{
Log.Error(ex);
}
}
void SendGroupMembershipInfoViaCaps(IClientAPI remoteClient, GroupMembershipData[] data)
{
m_log.InfoFormat("[Groups] {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
OSDArray AgentData = new OSDArray(1);
OSDMap AgentDataMap = new OSDMap(1);
AgentDataMap.Add("AgentID", OSD.FromUUID(remoteClient.AgentId));
AgentData.Add(AgentDataMap);
OSDArray GroupData = new OSDArray(data.Length);
OSDArray NewGroupData = new OSDArray(data.Length);
foreach (GroupMembershipData membership in data)
{
OSDMap GroupDataMap = new OSDMap(6);
OSDMap NewGroupDataMap = new OSDMap(1);
GroupDataMap.Add("GroupID", OSD.FromUUID(membership.GroupID));
GroupDataMap.Add("GroupPowers", OSD.FromBinary(membership.GroupPowers));
GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(membership.AcceptNotices));
GroupDataMap.Add("GroupInsigniaID", OSD.FromUUID(membership.GroupPicture));
GroupDataMap.Add("Contribution", OSD.FromInteger(membership.Contribution));
GroupDataMap.Add("GroupName", OSD.FromString(membership.GroupName));
NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(membership.ListInProfile));
GroupData.Add(GroupDataMap);
NewGroupData.Add(NewGroupDataMap);
}
OSDMap llDataStruct = new OSDMap(3);
llDataStruct.Add("AgentData", AgentData);
llDataStruct.Add("GroupData", GroupData);
llDataStruct.Add("NewGroupData", NewGroupData);
IEventQueue queue = remoteClient.Scene.RequestModuleInterface <IEventQueue>();
if (queue != null)
{
queue.Enqueue(EventQueueHelper.buildEvent("AgentGroupDataUpdate", llDataStruct), remoteClient.AgentId);
}
}
public IList <IObjRelationResult> GetObjRelations(IList <IObjRelation> objRels, ICacheIntern targetCache, CacheDirective cacheDirective)
{
CheckNotDisposed();
IEventQueue eventQueue = EventQueue;
if (eventQueue != null)
{
eventQueue.Pause(this);
}
try
{
bool oldCacheModificationValue = CacheModification.Active;
bool acquireSuccess = AcquireHardRefTLIfNotAlready(objRels.Count);
CacheModification.Active = true;
try
{
if (SecurityActive && ((targetCache == null && Privileged) || (targetCache != null && targetCache.Privileged) && //
SecurityActivation != null && SecurityActivation.FilterActivated))
{
return(SecurityActivation.ExecuteWithoutFiltering(delegate()
{
return Parent.GetObjRelations(objRels, targetCache, cacheDirective);
}));
}
else
{
return(Parent.GetObjRelations(objRels, targetCache, cacheDirective));
}
}
finally
{
CacheModification.Active = oldCacheModificationValue;
ClearHardRefs(acquireSuccess);
}
}
finally
{
if (eventQueue != null)
{
eventQueue.Resume(this);
}
}
}
/// <summary>
/// Tries to teleport agent to landmark.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="regionHandle"></param>
/// <param name="position"></param>
public override void RequestTeleportLandmark(IClientAPI remoteClient, AssetLandmark lm)
{
m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Teleporting agent via landmark to {0} region {1} position {2}",
(lm.Gatekeeper == string.Empty) ? "local" : lm.Gatekeeper, lm.RegionID, lm.Position);
if (lm.Gatekeeper == string.Empty)
{
base.RequestTeleportLandmark(remoteClient, lm);
return;
}
GridRegion info = m_aScene.GridService.GetRegionByUUID(UUID.Zero, lm.RegionID);
// Local region?
if (info != null)
{
((Scene)(remoteClient.Scene)).RequestTeleportLocation(remoteClient, info.RegionHandle, lm.Position,
Vector3.Zero, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark));
return;
}
else
{
// Foreign region
Scene scene = (Scene)(remoteClient.Scene);
GatekeeperServiceConnector gConn = new GatekeeperServiceConnector();
GridRegion gatekeeper = new GridRegion();
gatekeeper.ServerURI = lm.Gatekeeper;
GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(lm.RegionID));
if (finalDestination != null)
{
ScenePresence sp = scene.GetScenePresence(remoteClient.AgentId);
IEntityTransferModule transferMod = scene.RequestModuleInterface <IEntityTransferModule>();
IEventQueue eq = sp.Scene.RequestModuleInterface <IEventQueue>();
if (transferMod != null && sp != null && eq != null)
{
transferMod.DoTeleport(sp, gatekeeper, finalDestination, lm.Position,
Vector3.UnitX, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark), eq);
}
}
}
// can't find the region: Tell viewer and abort
remoteClient.SendTeleportFailed("The teleport destination could not be found.");
}
internal StatsManager(IEventQueue queue, IClock clock, CurrentStatsState state)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
if (clock == null)
{
throw new ArgumentNullException(nameof(clock));
}
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
this.queue = queue;
this.clock = clock;
this.state = state;
}
public WorkloadListener()
{
switch (QueueType)
{
case EventQueueType.MMF:
Events = new MMFEventQueue();
break;
case EventQueueType.LiteDB:
throw new NotImplementedException();
case EventQueueType.Sqlite:
throw new NotImplementedException();
case EventQueueType.BinarySerialized:
Events = new BinarySerializedBufferedEventQueue();
Events.BufferSize = 10000;
break;
}
}
/// <summary>
/// Enqueues a <see cref="ShutdownRequestEvent"/>.
/// </summary>
/// <param name="eventQueue">The <see cref="IEventQueue"/> to use.</param>
/// <param name="onRequestHandled">An optional delegate invoked sometime after the event finished being handled. It may not get called, if the event queue is suspended or being shut down. Check the return value to know whether you can reasonably expect it.</param>
/// <param name="file">The source file of the caller.</param>
/// <param name="member">The method or property name of the caller to this method.</param>
/// <param name="line">The line number in <paramref name="file"/>.</param>
/// <returns><c>true</c> if the event was enqueued successfully and you can expect a callback once it's done being handled; otherwise, <c>false</c>.</returns>
public static bool RequestShutdown(
this IEventQueue eventQueue,
Action <ShutdownRequestEvent> onRequestHandled = null,
[CallerFilePath] string file = "",
[CallerMemberName] string member = "",
[CallerLineNumber] int line = 0)
{
Action <EventBase> action = null;
if (onRequestHandled.NotNullReference())
{
action = e => onRequestHandled((ShutdownRequestEvent)e);
}
return(eventQueue.Enqueue(
new ShutdownRequestEvent(),
action,
file,
member,
line));
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
base.Initialize();
GetDte();
GetStatusbar();
GetCodeModelProvider();
RegisterLanguageService();
RegisterIcons();
ClearTempDirectory();
this.solutionMonitor = new SolutionMonitor();
this.templateController = new TemplateController(dte);
this.eventQueue = new EventQueue(statusBar);
this.generationController = new GenerationController(dte, metadataProvider, templateController, eventQueue);
RenderTemplate.Initialize(this);
WireupEvents();
ErrorList.Initialize(this);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
base.Initialize();
GetDte();
GetStatusbar();
GetCodeModelProvider();
RegisterLanguageService();
RegisterIcons();
ClearTempDirectory();
this.solutionMonitor = new SolutionMonitor();
this.templateController = new TemplateController(dte);
this.eventQueue = new EventQueue(statusBar);
this.generationController = new GenerationController(dte, metadataProvider, templateController, eventQueue);
RenderTemplate.Initialize(this);
WireupEvents();
ErrorList.Initialize(this);
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'parseTypeResourcePropertyElt'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Resource Parse Type Property Element and its Children</param>
/// <param name="parent">Parent Event (ie. Node) of the Property Element</param>
private void GrammarProductionParseTypeResourcePropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Parse Type Resource Property Element");
}
//Get the first Event, should be an ElementEvent
//Type checking is done by the Parent Production
IRdfXmlEvent first = eventlist.Dequeue();
ElementEvent element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
//Apply Namespaces
this.ApplyNamespaces(context, element);
//Validate Attributes
String ID = String.Empty;
if (element.Attributes.Count > 2)
{
//Can't be more than 2 Attributes, only allowed an optional rdf:ID and a required rdf:parseType
throw ParserHelper.Error("An Property Element with Parse Type 'Resource' was encountered with too many Attributes. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Resource'", "Parse Type Resource Property Element", element);
}
else
{
//Check the attributes that do exist
foreach (AttributeEvent a in element.Attributes)
{
if (RdfXmlSpecsHelper.IsIDAttribute(a))
{
ID = "#" + a.Value;
}
else if (a.QName.Equals("rdf:parseType"))
{
//OK
}
else
{
//Invalid Attribute
throw ParserHelper.Error("Unexpected Attribute '" + a.QName + "' was encountered on a Property Element with Parse Type 'Resource'. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Resource'", "Parse Type Resource Property Element", element);
}
}
}
//Add a Triple about this
INode subj, pred, obj;
//Get the Subject from the Parent
ElementEvent parentEvent = (ElementEvent)parent;
subj = parentEvent.SubjectNode;
//Validate the ID (if any)
if (!ID.Equals(String.Empty))
{
this.ValidateID(context, ID.Substring(1), subj);
}
//Create the Predicate from the Element
pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName);
//Generate a Blank Node ID for the Object
obj = context.Handler.CreateBlankNode();
//Assert
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
//Reify if applicable
if (!ID.Equals(String.Empty))
{
//Resolve the Uri
UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty);
IUriNode uri = this.Resolve(context, uriref,element.BaseUri);
this.Reify(context, uri, subj, pred, obj);
}
//Get the next event in the Queue which should be either an Element Event or a End Element Event
//Validate this
IRdfXmlEvent next = eventlist.Dequeue();
if (next is EndElementEvent)
{
//Content is Empty so nothing else to do
}
else if (next is ElementEvent)
{
//Non-Empty Content so need to build a sequence of new events
IEventQueue<IRdfXmlEvent> subEvents = new EventQueue<IRdfXmlEvent>();
//Create an rdf:Description event as the container
ElementEvent descrip = new ElementEvent("rdf:Description", element.BaseUri, String.Empty);
descrip.Subject = new BlankNodeIDEvent(String.Empty);
descrip.SubjectNode = obj;
subEvents.Enqueue(descrip);
//Add the current element we were looking at
subEvents.Enqueue(next);
//Add rest of events in list (exceot the last)
while (eventlist.Count > 1)
{
subEvents.Enqueue(eventlist.Dequeue());
}
//Terminate with an EndElement Event
subEvents.Enqueue(new EndElementEvent());
//Process with Node Element Production
this.GrammarProductionNodeElement(context, subEvents);
//Get the last thing in the List
next = eventlist.Dequeue();
}
else
{
throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an ElementEvent or EndElementEvent after a Parse Type Resource Property Element!", "Parse Type Resource Property Element", next);
}
//Check for the last thing being an EndElement Event
if (!(next is EndElementEvent))
{
throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an EndElementEvent to terminate a Parse Type Resource Property Element!", "Parse Type Resource Property Element", next);
}
}
/// <summary>
/// Creates a new Parser Context which uses Streaming parsing
/// </summary>
/// <param name="g">Graph</param>
/// <param name="stream">Stream</param>
public RdfXmlParserContext(IGraph g, Stream stream)
: base(g)
{
this._queue = new StreamingEventQueue(new StreamingEventGenerator(stream, g.BaseUri.ToSafeString()));
}
public void RegionLoaded(Scene scene)
{
m_eventQueue = scene.RequestModuleInterface<IEventQueue>();
m_profileConnector = Aurora.DataManager.DataManager.RequestPlugin<IProfileConnector>();
}
protected void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination, Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq)
{
if (reg == null || finalDestination == null)
{
sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
return;
}
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Request Teleport to {0}:{1}:{2}/{3}",
reg.ExternalHostName, reg.HttpPort, finalDestination.RegionName, position);
uint newRegionX = (uint)(reg.RegionHandle >> 40);
uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
uint oldRegionX = (uint)(sp.Scene.RegionInfo.RegionHandle >> 40);
uint oldRegionY = (((uint)(sp.Scene.RegionInfo.RegionHandle)) >> 8);
ulong destinationHandle = finalDestination.RegionHandle;
if (eq == null)
sp.ControllingClient.SendTeleportLocationStart();
// Let's do DNS resolution only once in this process, please!
// This may be a costly operation. The reg.ExternalEndPoint field is not a passive field,
// it's actually doing a lot of work.
IPEndPoint endPoint = finalDestination.ExternalEndPoint;
if (endPoint.Address != null)
{
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (sp.ParentID != (uint)0)
sp.StandUp();
if (!sp.ValidateAttachments())
{
sp.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
return;
}
// the avatar.Close below will clear the child region list. We need this below for (possibly)
// closing the child agents, so save it here (we need a copy as it is Clear()-ed).
//List<ulong> childRegions = new List<ulong>(avatar.GetKnownRegionList());
// Compared to ScenePresence.CrossToNewRegion(), there's no obvious code to handle a teleport
// failure at this point (unlike a border crossing failure). So perhaps this can never fail
// once we reach here...
//avatar.Scene.RemoveCapsHandler(avatar.UUID);
string capsPath = String.Empty;
AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
AgentCircuitData agentCircuit = sp.ControllingClient.RequestClientInfo();
agentCircuit.startpos = position;
agentCircuit.child = true;
agentCircuit.Appearance = sp.Appearance;
if (currentAgentCircuit != null)
{
agentCircuit.ServiceURLs = currentAgentCircuit.ServiceURLs;
agentCircuit.Viewer = currentAgentCircuit.Viewer;
}
if (NeedsNewAgent(oldRegionX, newRegionX, oldRegionY, newRegionY))
{
// brand new agent, let's create a new caps seed
agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
}
string reason = String.Empty;
// Let's create an agent there if one doesn't exist yet.
if (!CreateAgent(sp, reg, finalDestination, agentCircuit, teleportFlags, out reason))
{
sp.ControllingClient.SendTeleportFailed(String.Format("Destination refused: {0}",
reason));
return;
}
// OK, it got this agent. Let's close some child agents
sp.CloseChildAgents(newRegionX, newRegionY);
if (NeedsNewAgent(oldRegionX, newRegionX, oldRegionY, newRegionY))
{
#region IP Translation for NAT
IClientIPEndpoint ipepClient;
if (sp.ClientView.TryGet(out ipepClient))
{
capsPath
= "http://"
+ NetworkUtil.GetHostFor(ipepClient.EndPoint, finalDestination.ExternalHostName)
+ ":"
+ finalDestination.HttpPort
+ CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
}
else
{
capsPath
= "http://"
+ finalDestination.ExternalHostName
+ ":"
+ finalDestination.HttpPort
+ CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
}
#endregion
if (eq != null)
{
#region IP Translation for NAT
// Uses ipepClient above
if (sp.ClientView.TryGet(out ipepClient))
{
endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
}
#endregion
eq.EnableSimulator(destinationHandle, endPoint, sp.UUID);
// ES makes the client send a UseCircuitCode message to the destination,
// which triggers a bunch of things there.
// So let's wait
Thread.Sleep(200);
eq.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
}
else
{
sp.ControllingClient.InformClientOfNeighbour(destinationHandle, endPoint);
}
}
else
{
agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
capsPath = "http://" + finalDestination.ExternalHostName + ":" + finalDestination.HttpPort
+ "/CAPS/" + agentCircuit.CapsPath + "0000/";
}
// Expect avatar crossing is a heavy-duty function at the destination.
// That is where MakeRoot is called, which fetches appearance and inventory.
// Plus triggers OnMakeRoot, which spawns a series of asynchronous updates.
//m_commsProvider.InterRegion.ExpectAvatarCrossing(reg.RegionHandle, avatar.ControllingClient.AgentId,
// position, false);
//{
// avatar.ControllingClient.SendTeleportFailed("Problem with destination.");
// // We should close that agent we just created over at destination...
// List<ulong> lst = new List<ulong>();
// lst.Add(reg.RegionHandle);
// SendCloseChildAgentAsync(avatar.UUID, lst);
// return;
//}
SetInTransit(sp.UUID);
// Let's send a full update of the agent. This is a synchronous call.
AgentData agent = new AgentData();
sp.CopyTo(agent);
agent.Position = position;
SetCallbackURL(agent, sp.Scene.RegionInfo);
UpdateAgent(reg, finalDestination, agent);
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, sp.UUID);
if (eq != null)
{
eq.TeleportFinishEvent(destinationHandle, 13, endPoint,
0, teleportFlags, capsPath, sp.UUID);
}
else
{
sp.ControllingClient.SendRegionTeleport(destinationHandle, 13, endPoint, 4,
teleportFlags, capsPath);
}
// TeleportFinish makes the client send CompleteMovementIntoRegion (at the destination), which
// trigers a whole shebang of things there, including MakeRoot. So let's wait for confirmation
// that the client contacted the destination before we send the attachments and close things here.
if (!WaitForCallback(sp.UUID))
{
// Client never contacted destination. Let's restore everything back
sp.ControllingClient.SendTeleportFailed("Problems connecting to destination.");
ResetFromTransit(sp.UUID);
// Yikes! We should just have a ref to scene here.
//sp.Scene.InformClientOfNeighbours(sp);
EnableChildAgents(sp);
// Finally, kill the agent we just created at the destination.
m_aScene.SimulationService.CloseAgent(finalDestination, sp.UUID);
return;
}
// CrossAttachmentsIntoNewRegion is a synchronous call. We shouldn't need to wait after it
CrossAttachmentsIntoNewRegion(finalDestination, sp, true);
KillEntity(sp.Scene, sp.LocalId);
sp.MakeChildAgent();
// Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
if (NeedsClosing(oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
{
Thread.Sleep(5000);
sp.Close();
sp.Scene.IncomingCloseAgent(sp.UUID);
}
else
// now we have a child agent in this region.
sp.Reset();
// REFACTORING PROBLEM. Well, not a problem, but this method is HORRIBLE!
if (sp.Scene.NeedSceneCacheClear(sp.UUID))
{
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: User {0} is going to another region, profile cache removed",
sp.UUID);
}
}
else
{
sp.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
}
}
/// <summary>
/// Creates a new Parser Context which uses Streaming parsing
/// </summary>
/// <param name="g">Graph</param>
/// <param name="input">Input</param>
public RdfXmlParserContext(IGraph g, TextReader input)
: base(g)
{
this._queue = new StreamingEventQueue(new StreamingEventGenerator(input, g.BaseUri.ToSafeString()));
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposing) return;
if (this.eventQueue != null)
{
this.eventQueue.Dispose();
this.eventQueue = null;
}
}
/// <summary>
/// Creates a new Parser Context which uses Streaming parsing
/// </summary>
/// <param name="handler">RDF Handler</param>
/// <param name="input">Input</param>
public RdfXmlParserContext(IRdfHandler handler, TextReader input)
: base(handler)
{
this._queue = new StreamingEventQueue(new StreamingEventGenerator(input, String.Empty));
}
public void Add(IEventQueue queue)
{
this.queues.Add(queue);
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'parseTypeCollectionPropertyElt'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Collection Parse Type Property Element and its Children</param>
/// <param name="parent">Parent Event (ie. Node) of the Property Element</param>
private void GrammarProductionParseTypeCollectionPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Parse Type Collection Property Element");
}
//Get the first Event, should be an ElementEvent
//Type checking is done by the Parent Production
IRdfXmlEvent first = eventlist.Dequeue();
ElementEvent element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
//Apply Namespaces
this.ApplyNamespaces(context, element);
//Validate Attributes
String ID = String.Empty;
if (element.Attributes.Count > 2)
{
//Can't be more than 2 Attributes, only allowed an optional rdf:ID and a required rdf:parseType
throw ParserHelper.Error("An Property Element with Parse Type 'Collection' was encountered with too many Attributes. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Collection'", "Parse Type Collection Property Element", element);
}
else
{
//Check the attributes that do exist
foreach (AttributeEvent a in element.Attributes)
{
if (RdfXmlSpecsHelper.IsIDAttribute(a))
{
ID = "#" + a.Value;
}
else if (a.QName.Equals("rdf:parseType"))
{
//OK
}
else
{
//Invalid Attribute
throw ParserHelper.Error("Unexpected Attribute '" + a.QName + "' was encountered on a Property Element with Parse Type 'Collection'. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Collection'", "Parse Type Collection Property Element", element);
}
}
}
//Build sequence of Blank Nodes
IRdfXmlEvent next;
IRdfXmlEvent nodeElement;
Queue<ElementEvent> seqNodes = new Queue<ElementEvent>();
while (eventlist.Count > 1)
{
#region Node Element Processing
//Need to process the Node Element first
//Create a new Sublist
IEventQueue<IRdfXmlEvent> subevents = new EventQueue<IRdfXmlEvent>();
int nesting = 0;
nodeElement = eventlist.Peek();
//Add Node Element to sequence
seqNodes.Enqueue((ElementEvent)nodeElement);
//Gather the Sublist taking account of nesting
do
{
next = eventlist.Dequeue();
subevents.Enqueue(next);
if (next is ElementEvent)
{
nesting++;
}
else if (next is EndElementEvent)
{
nesting--;
}
} while (nesting > 0);
//Call the next Grammar Production
this.GrammarProductionNodeElement(context, subevents);
#endregion
}
//Build a triple expressing the start of the list (which may be an empty list)
INode subj, pred, obj;
INode firstPred, restPred;
INode b1, b2;
//Subject comes from Parent
ElementEvent parentElement = (ElementEvent)parent;
subj = parentElement.SubjectNode;
//Validate the ID (if any)
if (!ID.Equals(String.Empty))
{
this.ValidateID(context, ID.Substring(1), subj);
}
//Predicate from the Element
pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName);
if (seqNodes.Count > 0)
{
//Non-empty list
ElementEvent node;
//Get first Element from the Queue
node = seqNodes.Dequeue();
//Object is first thing in the Sequence which we create a Blank Node for
b1 = context.Handler.CreateBlankNode();
//Assert
if (!context.Handler.HandleTriple(new Triple(subj, pred, b1))) ParserHelper.Stop();
//Reify if applicable
if (!ID.Equals(String.Empty))
{
//Resolve the Uri
UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty);
IUriNode uri = this.Resolve(context, uriref, element.BaseUri);
this.Reify(context, uri, subj, pred, b1);
}
//Set the first element in the list
subj = b1;
firstPred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListFirst));
if (!context.Handler.HandleTriple(new Triple(subj, firstPred, node.SubjectNode))) ParserHelper.Stop();
//Middle elements of the list
restPred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListRest));
while (seqNodes.Count >= 1)
{
node = seqNodes.Dequeue();
//Set Node 2 to be the rest of the previous items list
b2 = context.Handler.CreateBlankNode();
if (!context.Handler.HandleTriple(new Triple(b1, restPred, b2))) ParserHelper.Stop();
//Set Node 2 to be the start of it's own list
if (!context.Handler.HandleTriple(new Triple(b2, firstPred, node.SubjectNode))) ParserHelper.Stop();
b1 = b2;
}
//Set last element of the list to have its rest as nil
if (!context.Handler.HandleTriple(new Triple(b1, restPred, context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListNil))))) ParserHelper.Stop();
}
else
{
//Empty list
//Object is therefore rdf:nil
obj = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListNil));
//Assert
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
//Reify if applicable
if (!ID.Equals(String.Empty))
{
//Resolve the Uri
UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty);
IUriNode uri = this.Resolve(context, uriref, element.BaseUri);
this.Reify(context, uri, subj, pred, obj);
}
}
//Check last event is an EndElementEvent
next = eventlist.Dequeue();
if (!(next is EndElementEvent))
{
throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an EndElementEvent to terminate a Parse Type Collection Property Element!", "Parse Type Collection Property Element", next);
}
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'nodeElementList'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events to apply the Production to</param>
private void GrammarProductionNodeElementList(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTrace("Node Element List");
}
IRdfXmlEvent next;
//Want to break up into a number of sublists
while (eventlist.Count > 0)
{
//Create a new Sublist
IEventQueue<IRdfXmlEvent> subevents = new EventQueue<IRdfXmlEvent>();
int nesting = 0;
//Gather the Sublist taking account of nesting
do
{
next = eventlist.Dequeue();
subevents.Enqueue(next);
if (next is ElementEvent)
{
nesting++;
}
else if (next is EndElementEvent)
{
nesting--;
}
} while (nesting > 0);
//Call the next Grammar Production
this.GrammarProductionNodeElement(context, subevents);
}
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'nodeElement'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Node Element and its Children to apply the Production to</param>
private void GrammarProductionNodeElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Node Element");
}
//Get First Event in the Queue
IRdfXmlEvent first = eventlist.Dequeue();
//Check it's an ElementEvent
if (!(first is ElementEvent))
{
//Unexpected Event
throw ParserHelper.Error("Expected an ElementEvent but encountered a '" + first.GetType().ToString() + "'", "Node Element", first);
}
//Check it has a valid Uri
ElementEvent element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
this.ApplyNamespaces(context, element);
if (!RdfXmlSpecsHelper.IsNodeElementUri(element.QName))
{
throw ParserHelper.Error("A Node Element was encountered with an invalid URI '" + element.QName + "' \nCore Syntax Terms, Old Syntax Terms and rdf:li cannot be used as Node Element URIs", "Node Element", element);
}
//Check the set of Attributes is Valid
int limitedAttributesFound = 0;
String ID = String.Empty;
foreach (AttributeEvent attr in element.Attributes)
{
if (RdfXmlSpecsHelper.IsIDAttribute(attr))
{
ID = attr.Value;
limitedAttributesFound++;
//Set the Subject
element.Subject = new UriReferenceEvent("#" + attr.Value, attr.SourceXml);
}
else if (RdfXmlSpecsHelper.IsNodeIDAttribute(attr))
{
limitedAttributesFound++;
//Validate the Node ID
if (!XmlSpecsHelper.IsName(attr.Value))
{
throw ParserHelper.Error("The value '" + attr.Value + "' for rdf:nodeID is not valid, RDF Node IDs can only be valid Names as defined by the W3C XML Specification", "Node Element", attr);
}
//Set the Subject
element.Subject = new BlankNodeIDEvent(attr.Value, attr.SourceXml);
}
else if (RdfXmlSpecsHelper.IsAboutAttribute(attr))
{
limitedAttributesFound++;
//Set the Subject
element.Subject = new UriReferenceEvent(attr.Value, attr.SourceXml);
}
else if (RdfXmlSpecsHelper.IsPropertyAttribute(attr))
{
//Don't need to do anything here yet
}
else
{
//Unknown and Unexpected Attribute Type
throw ParserHelper.Error("Unexpected Attribute '" + attr.QName + "' was encountered!", "Node Element", element);
}
//Can't have more than 1 of ID, Node ID or About Attributes
if (limitedAttributesFound > 1)
{
throw ParserHelper.Error("A Node Element can only have 1 of the following attributes: rdf:id, rdf:nodeID, rdf:about", "Node Element", element);
}
}
//Generate a Blank Node ID if our Subject is empty
if (element.Subject == null)
{
element.Subject = new BlankNodeIDEvent(element.SourceXml);
}
//Add statements as necessary
INode subj, pred, obj;
if (element.SubjectNode == null)
{
//Don't always want to drop in here since the SubjectNode may already be set elsewhere
if (element.Subject is UriReferenceEvent)
{
UriReferenceEvent uri = (UriReferenceEvent)element.Subject;
subj = this.Resolve(context, uri, element.BaseUri);
}
else if (element.Subject is BlankNodeIDEvent)
{
BlankNodeIDEvent blank = (BlankNodeIDEvent)element.Subject;
//Select whether we need to generate an ID or if there's one given for the Blank Node
//Note that we let the Graph class handle generation of IDs
if (blank.Identifier.Equals(String.Empty))
{
subj = context.Handler.CreateBlankNode();
}
else
{
subj = context.Handler.CreateBlankNode(blank.Identifier);
}
}
else
{
throw ParserHelper.Error("Unexpected Subject generated for a Triple", "Node Element", element.Subject);
}
} else {
subj = element.SubjectNode;
}
//Set the Subject Node property of the Event for later reuse
element.SubjectNode = subj;
//Validate the ID (if any)
if (!ID.Equals(String.Empty))
{
this.ValidateID(context, ID, subj);
}
if (!element.QName.Equals("rdf:Description") && !element.QName.Equals(":Description"))
{
//Assert a Triple regarding Type
pred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
obj = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName);
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
}
//Go back over Attributes looking for property attributes
foreach (AttributeEvent attr in element.Attributes)
{
if (RdfXmlSpecsHelper.IsPropertyAttribute(attr))
{
if (attr.QName.Equals("rdf:type"))
{
//Generate a Type Triple
pred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
//Resolve URIRef into a Uri Node
UriReferenceEvent uriref = new UriReferenceEvent(attr.Value, attr.SourceXml);
obj = this.Resolve(context, uriref, element.BaseUri);
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
}
else
{
//Generate a Property Triple
pred = context.Handler.CreateUriNode(UriFactory.Create(Tools.ResolveQName(attr.QName, context.Namespaces, context.BaseUri)));
//Add Language to Literal if necessary
if (element.Language.Equals(String.Empty))
{
obj = context.Handler.CreateLiteralNode(attr.Value);
}
else
{
obj = context.Handler.CreateLiteralNode(attr.Value, element.Language);
}
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
}
}
}
//Handle Child Elements
IEventQueue<IRdfXmlEvent> children = new EventQueue<IRdfXmlEvent>();
while (eventlist.Count > 1)
{
children.Enqueue(eventlist.Dequeue());
}
if (children.Count > 0) this.GrammarProductionPropertyElementList(context, children, element);
//Check Last Event in queue is an EndElement event
IRdfXmlEvent last = eventlist.Dequeue();
if (!(last is EndElementEvent))
{
throw ParserHelper.Error("Unexpected Event '" + last.GetType().ToString() + "', expected an EndElement Event", "NodeElement", last);
}
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'parseTypeLiteralPropertyElt'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Literal Parse Type Property Element and its Children</param>
/// <param name="parent">Parent Event (ie. Node) of the Property Element</param>
private void GrammarProductionParseTypeLiteralPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Parse Type Literal Property Element");
}
//Get the first Event, should be an ElementEvent
//Type checking is done by the Parent Production
IRdfXmlEvent first = eventlist.Dequeue();
ElementEvent element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
//Apply Namespaces
this.ApplyNamespaces(context, element);
//Validate Attributes
String ID = String.Empty;
if (element.Attributes.Count > 2)
{
//Can't be more than 2 Attributes, only allowed an optional rdf:ID and a required rdf:parseType
throw ParserHelper.Error("An Property Element with Parse Type 'Literal' was encountered with too many Attributes. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Literal'", "Parse Type Literal Property Element", element);
}
else
{
//Check the attributes that do exist
foreach (AttributeEvent a in element.Attributes)
{
if (RdfXmlSpecsHelper.IsIDAttribute(a))
{
ID = "#" + a.Value;
}
else if (a.QName.Equals("rdf:parseType"))
{
//OK
}
else
{
//Invalid Attribute
throw ParserHelper.Error("Unexpected Attribute '" + a.QName + "' was encountered on a Property Element with Parse Type 'Literal'. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Literal'", "Parse Type Literal Property Element", element);
}
}
}
//Get the next event in the Queue which should be a TypedLiteralEvent
//Validate this
IRdfXmlEvent lit = eventlist.Dequeue();
if (!(lit is TypedLiteralEvent))
{
throw ParserHelper.Error("Unexpected Event '" + lit.GetType().ToString() + "', expected a TypedLiteralEvent after a Property Element with Parse Type 'Literal'", "Parse Type Literal Property Element", lit);
}
//Get the Subject from the Parent
INode subj, pred, obj;
ElementEvent parentEl = (ElementEvent) parent;
subj = parentEl.SubjectNode;
//Validate the ID (if any)
if (!ID.Equals(String.Empty))
{
this.ValidateID(context, ID.Substring(1), subj);
}
//Create the Predicate from the Element
pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName);
//Create the Object from the Typed Literal
TypedLiteralEvent tlit = (TypedLiteralEvent)lit;
//At the moment we're just going to ensure that we normalize it to Unicode Normal Form C
String xmllit = tlit.Value;
#if !NO_NORM
xmllit = xmllit.Normalize();
#endif
obj = context.Handler.CreateLiteralNode(xmllit, UriFactory.Create(tlit.DataType));
//Assert the Triple
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
//Reify if applicable
if (!ID.Equals(String.Empty))
{
//Resolve the Uri
UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty);
IUriNode uri = this.Resolve(context, uriref,element.BaseUri);
this.Reify(context, uri, subj, pred, obj);
}
//Check for the last thing being an EndElement Event
IRdfXmlEvent next = eventlist.Dequeue();
if (!(next is EndElementEvent))
{
throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an EndElementEvent to terminate a Parse Type Literal Property Element!", "Parse Type Literal Property Element", next);
}
}
public virtual void RegionLoaded(Scene scene)
{
if (!m_Enabled)
return;
m_eqModule = Scene.RequestModuleInterface<IEventQueue>();
m_regionCombinerModule = Scene.RequestModuleInterface<IRegionCombinerModule>();
}
public void RegionLoaded(Scene s)
{
m_scene.EventManager.OnRegisterCaps += RegisterCaps;
m_eventQueue = m_scene.RequestModuleInterface<IEventQueue>();
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'propertyElt'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Property Element and its Children</param>
/// <param name="parent">Parent Event (ie. Node) of the Property Element</param>
private void GrammarProductionPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Property Element");
}
//Get first thing from the Queue
IRdfXmlEvent first = eventlist.Dequeue();
ElementEvent element;
//Must be an ElementEvent
if (!(first is ElementEvent))
{
//Unexpected Event
throw ParserHelper.Error("Expected an ElementEvent but encountered a '" + first.GetType().ToString() + "'", "PropertyElement", first);
}
//Validate the Uri
element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
this.ApplyNamespaces(context, element);
if (!RdfXmlSpecsHelper.IsPropertyElementURI(element.QName))
{
//Invalid Uri
throw ParserHelper.Error("A Property Element was encountered with an invalid URI '" + element.QName + "'\nCore Syntax Terms, Old Syntax Terms and rdf:Description cannot be used as Property Element URIs", "PropertyElement", element);
}
//List Expansion
if (element.QName.Equals("rdf:li"))
{
UriReferenceEvent u = this.ListExpand(parent);
element.SetUri(u);
}
//Need to select what to do based on the Type of Property Element
IRdfXmlEvent next = eventlist.Peek();
//This call inserts the first element back at the head of the queue
//Most of the sub-productions here need this
//Would ideally use Stacks instead of Queues but Queues make more sense for most of the Parsing
this.QueueJump(eventlist, first);
if (element.ParseType == RdfXmlParseType.None)
{
//A Resource/Literal Property Element
if (next is ElementEvent)
{
//Resource
this.GrammarProductionResourcePropertyElement(context, eventlist, parent);
}
else if (next is TextEvent)
{
//Literal
this.GrammarProductionLiteralPropertyElement(context, eventlist, parent);
}
else if (next is EndElementEvent)
{
//An Empty Property Element
this.GrammarProductionEmptyPropertyElement(context, element, parent);
}
else
{
//Error
throw ParserHelper.Error("An Element which should be Parsed with the Default Parsing Rules was encountered without a valid subsequent Event - Parser cannot proceed!", "Property Element", element);
}
}
else if (element.ParseType == RdfXmlParseType.Literal)
{
//A rdf:parseType="Literal" Property Element
this.GrammarProductionParseTypeLiteralPropertyElement(context, eventlist, parent);
}
else if (element.ParseType == RdfXmlParseType.Collection)
{
//A rdf:parseType="Collection" Property Element
this.GrammarProductionParseTypeCollectionPropertyElement(context, eventlist, parent);
}
else if (element.ParseType == RdfXmlParseType.Resource)
{
//A rdf:parseType="Resource" Property Element
this.GrammarProductionParseTypeResourcePropertyElement(context, eventlist, parent);
}
else if (next is EndElementEvent)
{
//An Empty Property Element
this.GrammarProductionEmptyPropertyElement(context, element, parent);
}
else
{
//Error
throw ParserHelper.Error("An Element without a known Parse Type was encountered Or the Parser was unable to determine what to do based on the subsequent event - Parser cannot proceed!", "Node Element", element);
}
}
public EventHandler(IEventQueue eventQueue, IEventStore eventStore)
{
// TODO: Validate if input is null
EventQueue = eventQueue;
EventStore = eventStore;
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'resourcePropertyElt'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Resource Property Element and its Children</param>
/// <param name="parent">Parent Event (ie. Node) of the Property Element</param>
private void GrammarProductionResourcePropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Resource Property Element");
}
//Cast to an ElementEvent
//We don't validate type here since we know this will be an ElementEvent because the calling function
//will have done this validation previously
IRdfXmlEvent first = eventlist.Dequeue();
IRdfXmlEvent next = eventlist.Peek();
ElementEvent element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
//Apply Namespaces
this.ApplyNamespaces(context, element);
//Only allowed one attribute max which must be an ID attribute
String ID = String.Empty;
if (element.Attributes.Count > 1)
{
throw ParserHelper.Error("A Resource Property Element contains too many Attributes, only rdf:ID is permitted", element);
}
else if (element.Attributes.Count == 1)
{
if (!RdfXmlSpecsHelper.IsIDAttribute(element.Attributes.First()))
{
throw ParserHelper.Error("A Resource Property Element was encountered with a single attribute which was not rdf:ID, only rdf:ID is permitted", element);
}
else
{
ID = element.Attributes.First().Value;
}
}
//Next must be an ElementEvent
if (!(next is ElementEvent))
{
throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an ElementEvent as the first Event in a Resource Property Elements Event list", next);
}
//Get list of Sub Events
IEventQueue<IRdfXmlEvent> subevents = new EventQueue<IRdfXmlEvent>();
while (eventlist.Count > 1)
{
subevents.Enqueue(eventlist.Dequeue());
}
this.GrammarProductionNodeElement(context, subevents);
//Check Last is an EndElementEvent
IRdfXmlEvent last = eventlist.Dequeue();
if (!(last is EndElementEvent))
{
throw ParserHelper.Error("Unexpected Event '" + last.GetType().ToString() + "', expected an EndElement Event", last);
}
//Now we can generate the relevant RDF
INode subj, pred, obj;
//Validate the Type of the Parent
if (!(parent is ElementEvent))
{
throw ParserHelper.Error("Unexpected Parent Event '" + parent.GetType().ToString() + "', expected an ElementEvent", parent);
}
ElementEvent parentEl = (ElementEvent)parent;
//Get the Subject Node from the Parent
subj = parentEl.SubjectNode;
//Validate the ID (if any)
if (!ID.Equals(String.Empty))
{
this.ValidateID(context, ID, subj);
}
//Create a Predicate from this Element
pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName);
//Get the Object Node from the Child Node
ElementEvent child = (ElementEvent)next;
obj = child.SubjectNode;
//Assert the Triple
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
//Add Reification where appropriate
if (element.Attributes.Count == 1)
{
//Must be an rdf:ID attribute as we've validated this earlier
//Get the Attribute Event and generate a Uri from it
AttributeEvent attr = element.Attributes.First();
UriReferenceEvent uriref = new UriReferenceEvent("#" + attr.Value, attr.SourceXml);
IUriNode uri = this.Resolve(context, uriref, element.BaseUri);
this.Reify(context, uri, subj, pred, obj);
}
}
public virtual void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination, Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq)
{
sp.ControllingClient.SendTeleportProgress(teleportFlags, "sending_dest");
if (reg == null || finalDestination == null)
{
sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
return;
}
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Request Teleport to {0}:{1}:{2}/{3}",
reg.ExternalHostName, reg.HttpPort, finalDestination.RegionName, position);
uint newRegionX = (uint)(reg.RegionHandle >> 40);
uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
uint oldRegionX = (uint)(sp.Scene.RegionInfo.RegionHandle >> 40);
uint oldRegionY = (((uint)(sp.Scene.RegionInfo.RegionHandle)) >> 8);
ulong destinationHandle = finalDestination.RegionHandle;
// Let's do DNS resolution only once in this process, please!
// This may be a costly operation. The reg.ExternalEndPoint field is not a passive field,
// it's actually doing a lot of work.
IPEndPoint endPoint = finalDestination.ExternalEndPoint;
if (endPoint.Address != null)
{
sp.ControllingClient.SendTeleportProgress(teleportFlags, "arriving");
if (m_cancelingAgents.Contains(sp.UUID))
{
Cancel(sp);
return;
}
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (sp.ParentID != UUID.Zero)
sp.StandUp();
if (!sp.ValidateAttachments())
{
sp.ControllingClient.SendTeleportProgress(teleportFlags, "missing_attach_tport");
sp.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
return;
}
string capsPath = String.Empty;
AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
AgentCircuitData agentCircuit = sp.ControllingClient.RequestClientInfo();
agentCircuit.startpos = position;
agentCircuit.child = true;
agentCircuit.Appearance = sp.Appearance;
if (currentAgentCircuit != null)
{
agentCircuit.ServiceURLs = currentAgentCircuit.ServiceURLs;
agentCircuit.IPAddress = currentAgentCircuit.IPAddress;
agentCircuit.Viewer = currentAgentCircuit.Viewer;
agentCircuit.Channel = currentAgentCircuit.Channel;
agentCircuit.Mac = currentAgentCircuit.Mac;
agentCircuit.Id0 = currentAgentCircuit.Id0;
}
if (NeedsNewAgent(oldRegionX, newRegionX, oldRegionY, newRegionY))
{
// brand new agent, let's create a new caps seed
agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
}
string reason = String.Empty;
// Let's create an agent there if one doesn't exist yet.
bool logout = false;
if (!CreateAgent(sp, reg, finalDestination, agentCircuit, teleportFlags, out reason, out logout))
{
sp.ControllingClient.SendTeleportFailed(String.Format("Destination refused: {0}",
reason));
return;
}
// OK, it got this agent. Let's close some child agents
sp.CloseChildAgents(newRegionX, newRegionY);
if (NeedsNewAgent(oldRegionX, newRegionX, oldRegionY, newRegionY))
{
//sp.ControllingClient.SendTeleportProgress(teleportFlags, "Creating agent...");
#region IP Translation for NAT
IClientIPEndpoint ipepClient;
if (sp.ClientView.TryGet(out ipepClient))
{
capsPath
= "http://"
+ NetworkUtil.GetHostFor(ipepClient.EndPoint, finalDestination.ExternalHostName)
+ ":"
+ finalDestination.HttpPort
+ CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
}
else
{
capsPath
= "http://"
+ finalDestination.ExternalHostName
+ ":"
+ finalDestination.HttpPort
+ CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
}
#endregion
if (eq != null)
{
#region IP Translation for NAT
// Uses ipepClient above
if (sp.ClientView.TryGet(out ipepClient))
{
endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
}
#endregion
eq.EnableSimulator(destinationHandle, endPoint, sp.UUID);
// ES makes the client send a UseCircuitCode message to the destination,
// which triggers a bunch of things there.
// So let's wait
Thread.Sleep(200);
eq.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
}
else
{
sp.ControllingClient.InformClientOfNeighbour(destinationHandle, endPoint);
}
}
else
{
agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
capsPath = "http://" + finalDestination.ExternalHostName + ":" + finalDestination.HttpPort
+ "/CAPS/" + agentCircuit.CapsPath + "0000/";
}
if (m_cancelingAgents.Contains(sp.UUID))
{
Cancel(sp);
return;
}
SetInTransit(sp.UUID);
// Let's send a full update of the agent. This is a synchronous call.
AgentData agent = new AgentData();
sp.CopyTo(agent);
agent.Position = position;
SetCallbackURL(agent, sp.Scene.RegionInfo);
//sp.ControllingClient.SendTeleportProgress(teleportFlags, "Updating agent...");
if (!UpdateAgent(reg, finalDestination, agent))
{
// Region doesn't take it
Fail(sp, finalDestination);
return;
}
m_log.DebugFormat(
"[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, sp.UUID);
if (eq != null)
{
eq.TeleportFinishEvent(destinationHandle, 13, endPoint,
0, teleportFlags, capsPath, sp.UUID, teleportFlags);
}
else
{
sp.ControllingClient.SendRegionTeleport(destinationHandle, 13, endPoint, 4,
teleportFlags, capsPath);
}
// Let's set this to true tentatively. This does not trigger OnChildAgent
sp.IsChildAgent = true;
// TeleportFinish makes the client send CompleteMovementIntoRegion (at the destination), which
// trigers a whole shebang of things there, including MakeRoot. So let's wait for confirmation
// that the client contacted the destination before we send the attachments and close things here.
//OpenSim sucks at callbacks, disable it for now
if (!WaitForCallback(sp.UUID))
{
/*//Make sure the client hasn't TPed back in this time.
ScenePresence SP = m_aScene.GetScenePresence(sp.UUID);
if (SP != null && SP.IsChildAgent)
{
//Disabling until this actually helps and doesn't kill clients
//Fail(sp, finalDestination);
return;
}
else if (SP == null)
{
//Err.. this happens somehow.
return;
}*/
}
/*//Make sure the client hasn't TPed back in this time.
ScenePresence newSP = m_aScene.GetScenePresence(sp.UUID);
if (newSP != null && !newSP.IsChildAgent)
{
//They are root again, don't cross them!
return;
}
else if (newSP == null)
{
//Err.. this happens somehow.
return;
}*/
// CrossAttachmentsIntoNewRegion is a synchronous call. We shouldn't need to wait after it
CrossAttachmentsIntoNewRegion(finalDestination, sp, true);
// Well, this is it. The agent is over there.
KillEntity(sp.Scene, sp.LocalId);
// May need to logout or other cleanup
AgentHasMovedAway(sp.ControllingClient.SessionId, logout);
// Now let's make it officially a child agent
sp.MakeChildAgent();
// Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
if (NeedsClosing(oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
{
Thread.Sleep(5000);
sp.Close();
sp.Scene.IncomingCloseAgent(sp.UUID);
}
else
// now we have a child agent in this region.
sp.Reset();
//If they canceled too late, remove them so the next tp does not fail.
if (m_cancelingAgents.Contains(sp.UUID))
m_cancelingAgents.Remove(sp.UUID);
}
else
{
sp.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
}
}
/// <summary>
/// Helper function which inserts an Element back on the front of a Queue
/// </summary>
/// <param name="eventlist">Queue to insert onto the Front of</param>
/// <param name="evt">Event to put on the front of the Queue</param>
private void QueueJump(IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent evt)
{
Stack<IRdfXmlEvent> temp = new Stack<IRdfXmlEvent>();
temp.Push(evt);
while (eventlist.Count > 0)
{
temp.Push(eventlist.Dequeue());
}
foreach (IRdfXmlEvent e in temp.Reverse())
{
eventlist.Enqueue(e);
}
}
/// <summary>
/// Creates a new Parser Context which uses Streaming parsing
/// </summary>
/// <param name="handler">RDF Handler</param>
/// <param name="stream">Stream</param>
public RdfXmlParserContext(IRdfHandler handler, Stream stream)
: base(handler)
{
this._queue = new StreamingEventQueue(new StreamingEventGenerator(stream, String.Empty));
}
/// <summary>
/// Implementation of the RDF/XML Grammar Production 'literalPropertyElt'
/// </summary>
/// <param name="context">Parser Context</param>
/// <param name="eventlist">Queue of Events that make up the Literal Property Element and its Children</param>
/// <param name="parent">Parent Event (ie. Node) of the Property Element</param>
private void GrammarProductionLiteralPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent)
{
//Tracing
if (this._traceparsing)
{
this.ProductionTracePartial("Literal Property Element");
}
//Get the 3 Events (should only be three)
IRdfXmlEvent first, middle, last;
first = eventlist.Dequeue();
middle = eventlist.Dequeue();
last = eventlist.Dequeue();
//If Queue is non-empty then Error
if (eventlist.Count > 0)
{
throw ParserHelper.Error("Too many events encountered while trying to parse a Literal Property Element", first);
}
ElementEvent element = (ElementEvent)first;
if (this._traceparsing) this.ProductionTracePartial(element);
//Apply Namespaces
this.ApplyNamespaces(context, element);
//Validate that the middle event is a TextEvent
if (!(middle is TextEvent))
{
throw ParserHelper.Error("Unexpected event '" + middle.GetType().ToString() + "', expected a TextEvent in a Literal Property Element", middle);
}
TextEvent text = (TextEvent)middle;
//Validate the Attributes
String ID = String.Empty;
String datatype = String.Empty;
if (element.Attributes.Count > 2)
{
throw ParserHelper.Error("A Literal Property Element contains too many attributes, only rdf:ID and rdf:datatype are permitted", element);
}
else
{
//Only rdf:ID and rdf:datatype allowed
foreach (AttributeEvent a in element.Attributes)
{
if (RdfXmlSpecsHelper.IsIDAttribute(a)) {
ID = "#" + a.Value;
}
else if (RdfXmlSpecsHelper.IsDataTypeAttribute(a))
{
datatype = a.Value;
}
else
{
throw ParserHelper.Error("A Literal Property Element contains an unexpected attribute, only rdf:ID and rdf:datatype are permitted", element);
}
}
}
//Create the Nodes for the Graph
INode subj, pred, obj;
//Get the Subject from the Parent
ElementEvent parentEl = (ElementEvent)parent;
subj = parentEl.SubjectNode;
//Validate the ID (if any)
if (!ID.Equals(String.Empty))
{
this.ValidateID(context, ID.Substring(1), subj);
}
//Create a Predicate from this Element
pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName);
//Create an Object from the Text Event
if (datatype.Equals(String.Empty))
{
//No Type with possible Language
if (element.Language.Equals(String.Empty))
{
obj = context.Handler.CreateLiteralNode(text.Value);
}
else
{
obj = context.Handler.CreateLiteralNode(text.Value, element.Language);
}
}
else
{
//Typed
//Resolve the Datatype Uri
UriReferenceEvent dtref = new UriReferenceEvent(datatype, String.Empty);
IUriNode dturi = this.Resolve(context, dtref, element.BaseUri);
obj = context.Handler.CreateLiteralNode(text.Value, dturi.Uri);
}
//Assert the Triple
if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop();
//Reify if applicable
if (!ID.Equals(String.Empty))
{
//Resolve the Uri
UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty);
IUriNode uri = this.Resolve(context, uriref,element.BaseUri);
this.Reify(context, uri, subj, pred, obj);
}
}
