private object DeserializeJobData(QueuedItem payload)
{
string typeName = payload.@class;
var type = Type.GetType(typeName);
var jobData = JsonConvert.DeserializeObject(payload.args[0], type);
return jobData;
}
private void EnqueuePending()
{
lock (queue)
{
if (queue.Count > 0)
{
int nr = 0;
lock (activeDownloads) nr = activeDownloads.Count;
for (int i = nr; i < ParallelDownloads && queue.Count > 0; i++)
{
QueuedItem item = queue.Dequeue();
Logger.DebugLog("Requesting " + item.address.ToString());
HttpWebRequest req = SetupRequest(item.address, item.contentType);
CapsBase.DownloadDataAsync(
req,
item.millisecondsTimeout,
item.downloadProgressCallback,
(HttpWebRequest request, HttpWebResponse response, byte[] responseData, Exception error) =>
{
lock (activeDownloads) activeDownloads.Remove(request);
item.completedCallback(request, response, responseData, error);
EnqueuePending();
}
);
lock (activeDownloads) activeDownloads.Add(req);
}
}
}
}
public Task <T> QueueAsync(Func <Task <T> > workerFunction)
{
QueuedItem queuedItem = new QueuedItem()
{
TaskCompletionSource = new TaskCompletionSource <T>(),
WorkerFunction = workerFunction
};
bool shouldStart = false;
lock (this)
{
// Enqueue it
_queue.Enqueue(queuedItem);
// If this was the first, we have to start everything
shouldStart = _queue.Count == 1;
}
if (shouldStart)
{
Start();
}
return(queuedItem.TaskCompletionSource.Task);
}
protected virtual void DataInQueue(QueuedItem data)
{
// test behaviours such as accumulating data an processing in batch
// as it stands, we are processing every event as it comes in
_batchSenderThread.Process();
}
public RedisBackend(IRedis redisClient, QueuedItem payload, Exception exception, IWorker worker, string queue)
{
RedisClient = redisClient;
Payload = payload;
Exception = exception;
Worker = worker;
Queue = queue;
}
public QueuedItem Enqueue(QueuedItem item)
{
var hubContext = GlobalHost.ConnectionManager.GetHubContext <PublishQueueHub>();
var nitem = _queueRepo.Enqueue(item);
hubContext.Clients.All.Progress(GetStatus());
return(nitem);
}
public RedisBackend(IRedis redisClient, QueuedItem payload, Exception exception, IWorker worker, string queue)
{
RedisClient = redisClient;
Payload = payload;
Exception = exception;
Worker = worker;
Queue = queue;
}
public Job(JobFactory creator, IFailureService failureService, IWorker worker, QueuedItem item,
string queue)
{
Creator = creator;
FailureService = failureService;
Worker = worker;
Payload = item;
Queue = queue;
}
private void AddUserToServiceQueue(string userId, QueuedItem item, ITurnContext turnContext)
{
if (!IsServiceAvailableForUser(userId, item, turnContext))
{
return;
}
string requesterNames = item.RequestersToString();
item.PushRequester(userId);
NotifyRequester(item, turnContext, requesterNames);
}
public void CompleteAddingItems()
{
_addLock.EnterWriteLock();
{
_isFinishedAdding = true;
var queueCompletion = new QueuedItem <TInput, TResult>();
_concurrentQueue.Enqueue(queueCompletion);
Task.Factory.StartNew(() => { SignalResult(); });
}
_addLock.ExitWriteLock();
}
private void RemoveOwnerFromService(QueuedItem item, ITurnContext turnContext)
{
if (!item.IsAnyUserWaiting())
{
RemoveService(item.Id);
OperationFinished?.Invoke(turnContext, $"el recurso {item.Id} ha sido liberado y no hay nadie a la cola.");
}
else
{
PopRequester(item.Id, turnContext);
}
}
public async Task <string> GetValue(string propertyName)
{
_logger.LogInformation($"Getting value: " + propertyName);
var item = new QueuedItem
{
PropertyName = propertyName,
TaskSource = new TaskCompletionSource <string>()
};
await _queue.SendAsync(item);
return(await item.TaskSource.Task);
}
private void ShowServiceState(string itemId, ITurnContext turnContext)
{
QueuedItem item = GetQueuedService(itemId);
if (item != null)
{
OperationFinished?.Invoke(turnContext, item.GetCurrentState());
}
else
{
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.emptyServicePhrases));
}
}
private void NotifyRequester(QueuedItem item, ITurnContext turnContext, string requesterNames)
{
if (string.IsNullOrEmpty(requesterNames))
{
OperationFinished?.Invoke(turnContext, $"Actualmente {item.Id} está siendo utilizado por @{item.CurrentOwner}");
OperationFinished?.Invoke(turnContext, $"Eres la siguiente en la lista");
}
else
{
OperationFinished?.Invoke(turnContext, $"Actualmente {item.Id} está siendo utilizado por @{item.CurrentOwner}");
OperationFinished?.Invoke(turnContext, $"Estas personas están por delante tuyo: {requesterNames}");
}
}
public QueuedItem Enqueue(Guid key, string name, int userId = 0, QueueActions action = QueueActions.Publish)
{
var item = new QueuedItem()
{
Name = name,
NodeKey = key,
Submitted = DateTime.Now,
UserId = userId,
Action = (int)action
};
return(Enqueue(item));
}
private bool IsServiceAvailableForUser(string userId, QueuedItem item, ITurnContext turnContext)
{
if (item.IsCurrentOwner(userId))
{
OperationFinished?.Invoke(turnContext, $"El recurso ya está reservado por ti.");
return(false);
}
if (item.IsUserWaiting(userId))
{
OperationFinished?.Invoke(turnContext, $"Ya estás en la lista.");
return(false);
}
return(true);
}
private bool PublishItem(IContent node, QueuedItem queuedItem)
{
var attempt = _contentService.SaveAndPublishWithStatus(node, queuedItem.UserId);
if (attempt.Success)
{
_logger.Info <PublishQueueService>("Published: {0}", () => node.Name);
}
else
{
_logger.Warn <PublishQueueService>("Failed to publish: {0}", () => node.Name);
}
return(attempt.Success);
}
public QueuedItem Enqueue(QueuedItem item, bool insertIfExists = false)
{
lock (_lock)
{
using (var db = _dbContext.Database)
{
if (insertIfExists || !Contains(item.NodeKey))
{
item.Attempt++;
db.Insert(item);
}
return(item);
}
}
}
private void AskForServiceState(ActionOnItem actionOnItem, ITurnContext turnContext)
{
if (!IsValidServiceId(actionOnItem.itemName))
{
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.emptyServicePhrases));
return;
}
QueuedItem item = GetQueuedService(actionOnItem.itemName);
if (item != null)
{
ShowServiceState(item.Id, turnContext);
}
else
{
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.emptyServicePhrases));
}
}
private void RequestService(ActionOnItem actionOnItem, ITurnContext turnContext)
{
if (!IsValidServiceId(actionOnItem.itemName))
{
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.emptyServicePhrases));
return;
}
QueuedItem item = GetQueuedService(actionOnItem.itemName);
if (item != null)
{
AddUserToServiceQueue(turnContext.Activity.From.Name, item, turnContext);
}
else
{
CreateQueuedService(turnContext.Activity.From.Name, actionOnItem.itemName);
OperationFinished?.Invoke(turnContext, $"{actionOnItem.itemName} ha sido reservado por {turnContext.Activity.From.Name}");
}
}
public void Add(TInput input)
{
bool shouldThrow = false;
_addLock.EnterReadLock();
{
shouldThrow = _isFinishedAdding;
if (!shouldThrow)
{
var queuedItem = new QueuedItem <TInput, TResult>(input, _notFinished);
_concurrentQueue.Enqueue(queuedItem);
Task.Factory.StartNew(() => { _processor(queuedItem); SignalResult(); });
}
}
_addLock.ExitReadLock();
if (shouldThrow)
{
throw new InvalidOperationException("An attempt was made to add an item, but adding items was marked as completed");
}
}
public IPromise <T> Enqueue(Func <IPromise <T> > action, bool cull = false)
{
QueuedItem qi = new QueuedItem();
qi.Action = action;
qi.Promise = new Promise <T>();
if (Throttle.Count < Max)
{
Queue.Enqueue(qi);
Next();
}
else if (!cull)
{
Queue.Enqueue(qi);
}
else
{
return(Promise <T> .Rejected(new Exception("Throttle limit reached")));
}
return(qi.Promise);
}
private void SetServiceFree(ActionOnItem actionOnItem, ITurnContext turnContext)
{
if (!IsValidServiceId(actionOnItem.itemName))
{
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.emptyServicePhrases));
return;
}
QueuedItem item = GetQueuedService(actionOnItem.itemName);
if (item == null)
{
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.emptyServicePhrases));
return;
}
if (item.IsCurrentOwner(turnContext.Activity.From.Name))
{
RemoveOwnerFromService(item, turnContext);
return;
}
OperationFinished?.Invoke(turnContext, ConversationWords.GetRandomValueFromList(ConversationWords.authorizationErrors));
}
void Next()
{
if (Queue.Count == 0)
{
return;
}
QueuedItem qi = Queue.Dequeue();
if (qi == null)
{
return;
}
Throttle.Enqueue(DateTime.Now);
Promise <T> promise = qi.Promise;
Timer.Create(TimeSpan.FromSeconds(PerSeconds), () => {
Throttle.Dequeue();
Next();
});
qi.Action().Then(promise.Resolve, promise.Reject);
}
/// <summary>
/// Pushes a new <c>item</c> into the cargo.
/// </summary>
/// <param name="item">The item to work on.</param>
/// <returns>The completion task called when the item has completed work.</returns>
public Task <TItem> Push(TItem item)
{
lock (_syncLock)
{
// add our item to the queue
var queuedItem = new QueuedItem()
{
Item = item,
};
// assign the completed task
queuedItem.Completed = new Task <TItem>(() =>
{
if (queuedItem.ThrownException != null)
{
throw queuedItem.ThrownException;
}
return(item);
});
// enqueue
_cargo.Add(queuedItem);
// determine whether we've exceeded the payload
if (_activeWorkers == 0 ||
Payload < 1 ||
_cargo.Count >= Payload)
{
// IF no active workers
// OR payload is set to infinite (less than 1)
// OR we've exceed the payload
// THEN start another worker
StartWorker();
}
return(queuedItem.Completed);
}
}
private async Task ProcessPropertyValueItem(QueuedItem obj)
{
try
{
var url = "API/API/values/" + obj.PropertyName;
using (var client = _httpClientFactory.CreateClient("Systembrowser"))
{
var response = await client.GetAsync(url);
response.EnsureSuccessStatusCode();
var strResponse = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <List <PropertyValueResponse> >(strResponse);
obj.TaskSource.SetResult(data?.FirstOrDefault()?.Value?.Value);
}
}
catch (Exception e)
{
//_logger.LogError(e, "Error retrieving property value");
obj.TaskSource.SetResult("");
}
}
private async void Start()
{
bool shouldStartNext = false;
do
{
QueuedItem queuedItem = null;
lock (this)
{
queuedItem = _queue.Peek();
}
try
{
T answer = await queuedItem.WorkerFunction();
queuedItem.TaskCompletionSource.TrySetResult(answer);
}
catch (Exception ex)
{
try
{
queuedItem.TaskCompletionSource.TrySetException(ex);
}
catch { }
}
lock (this)
{
_queue.Dequeue();
shouldStartNext = _queue.Count > 0;
}
}while (shouldStartNext);
OnAllCompleted?.Invoke(this, new EventArgs());
}
private void CreateQueuedService(string userId, string itemId)
{
QueuedItem item = new QueuedItem(itemId, userId);
queuedItems.Add(itemId, item);
}
public RedisBackend Create(QueuedItem payload, Exception exception, IWorker worker, string queue)
{
return new RedisBackend(RedisClient, payload, exception, worker, queue);
}
private bool SaveItem(IContent node, QueuedItem queuedItem)
{
_logger.Info <PublishQueueService>("Saving: {0}", () => node.Name);
_contentService.Save(node, queuedItem.UserId);
return(true);
}
public IJob CreateJob(IFailureService failureService, Worker worker, QueuedItem deserializedObject, string queue)
{
return new Job(this, failureService, worker, deserializedObject, queue);
}
public static void Load()
{
Debug.Log("Loading...");
serializableDataSet.data.Clear();
CryptographyInfo.Decrypt(FilePath, fileFormat);
Debug.Log(FilePath);
JsonUtility.FromJsonOverwrite(File.ReadAllText(FilePath), serializableDataSet);
for (int i = 0; i < serializableDataSet.data.Count; i++)
{
for (int j = 0; j < gameObjectsDataSet.Count; j++)
{
QueuedItem queuedItem = gameObjectsDataSet[j];
string sID = (string)DataDeserialization.Deserialize(serializableDataSet.data[i].ID);
Debug.Log("Comparing ID: " + queuedItem.ID + " to sID: " + sID);
if (queuedItem.ID == sID)
{
Debug.Log("Loading on item: " + queuedItem.saveObject.name + " with an ID of: " + queuedItem.ID);
#region Deserialize Unity classes and types
#region Deserialize transform
((STransform)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sTransform)).Deserialize(ref queuedItem.saveObject);
#endregion
#region Deserialize Camera
if (serializableDataSet.data[i].unitySerializableData.sCamera.Length > 0)
{
((SCamera)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sCamera)).Deserialize(ref queuedItem.saveObject);
}
#endregion
#region Deserialize Audio
if (serializableDataSet.data[i].unitySerializableData.sAudioChorusFilter.Length > 0)
{
((SAudioChorusFilter)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioChorusFilter)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioDistortionFilter.Length > 0)
{
SAudioDistortionFilter sAudioDistortionFilter = (SAudioDistortionFilter)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioDistortionFilter);
sAudioDistortionFilter.Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioEchoFilter.Length > 0)
{
((SAudioEchoFilter)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioEchoFilter)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioHighPassFilter.Length > 0)
{
((SAudioHighPassFilter)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioHighPassFilter)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioListener.Length > 0)
{
((SAudioListener)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioListener)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioLowPassFilter.Length > 0)
{
((SAudioLowPassFilter)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioLowPassFilter)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioReverbFilter.Length > 0)
{
((SAudioReverbFilter)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioReverbFilter)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioReverbZone.Length > 0)
{
((SAudioReverbZone)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioReverbZone)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sAudioSource.Length > 0)
{
((SAudioSource)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sAudioSource)).Deserialize(ref queuedItem.saveObject);
}
#endregion
#region Deserialize Effects
if (serializableDataSet.data[i].unitySerializableData.sLensFlare.Length > 0)
{
((SLensFlare)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sLensFlare)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sLineRenderer.Length > 0)
{
((SLineRenderer)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sLineRenderer)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sParticleSystem.Length > 0)
{
((SParticleSystem)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sParticleSystem)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sProjector.Length > 0)
{
((SProjector)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sProjector)).Deserialize(ref queuedItem.saveObject);
}
if (serializableDataSet.data[i].unitySerializableData.sTrailRenderer.Length > 0)
{
((STrailRenderer)DataDeserialization.Deserialize(serializableDataSet.data[i].unitySerializableData.sTrailRenderer)).Deserialize(ref queuedItem.saveObject);
}
#endregion
#endregion
#region Deserialize User Defined Classes
MonoBehaviour[] saveableScripts = queuedItem.saveObject.GetComponents <MonoBehaviour>();
foreach (var monoItem in saveableScripts)
{
if (monoItem is IUniversalSerializedPersistenceSystem == false)
{
continue;
}
System.Type thisType = monoItem.GetType();
MethodInfo theMethod = thisType.GetMethod("Deserialize");
object[] param = new object[2] {
serializableDataSet.data[i].serializedScripts,
queuedItem.saveObject
};
theMethod.Invoke(monoItem, param);
break;
}
#endregion
#region Deserialize All Children
int childIndex = -1;
QueueData.DequeueAllChildren(queuedItem.saveObject.transform, queuedItem.saveObject.transform, serializableDataSet.data[i], ref childIndex);
#endregion
gameObjectsDataSet.RemoveAt(j);
break;
}
}
}
serializableDataSet.data.Clear();;
gameObjectsDataSet.Clear();
CryptographyInfo.Encrypt(FilePath, fileFormat);
Debug.Log("Load was successful!");
}
protected virtual void OnData(QueuedItem data)
{
// LORENZO: test behaviours such as accumulating data an processing in batch
_batchSenderThread.Process( );
}
/// <summary>
/// Sends a packet to the peer at the other side of the TCP connection. Transmission is done asynchronously and is
/// buffered if a sending operation is being performed.
/// </summary>
/// <param name="Packet">Packet to send.</param>
/// <param name="Callback">Optional method to call when packet has been sent.</param>
public async void SendTcp(byte[] Packet, EventHandler Callback)
{
if (this.disposed)
{
return;
}
try
{
byte[] EncodedPacket = this.EncodePacket(Packet, false);
lock (this.outgoingPackets)
{
if (this.writing)
{
this.outgoingPackets.AddLast(new QueuedItem(EncodedPacket, Callback));
return;
}
else
{
this.writing = true;
this.lastTcpPacket = DateTime.Now;
}
}
while (EncodedPacket != null)
{
await this.stream.WriteAsync(EncodedPacket, 0, EncodedPacket.Length);
if (this.disposed)
{
return;
}
BinaryEventHandler h = this.OnSent;
if (h != null)
{
try
{
h(this, EncodedPacket);
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
if (Callback != null)
{
try
{
Callback(this, new EventArgs());
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
lock (this.outgoingPackets)
{
if (this.outgoingPackets.First != null)
{
QueuedItem Item = this.outgoingPackets.First.Value;
EncodedPacket = Item.Packet;
Callback = Item.Callback;
this.outgoingPackets.RemoveFirst();
}
else
{
this.writing = false;
EncodedPacket = null;
Callback = null;
}
}
}
}
catch (Exception)
{
this.Closed();
}
}
public bool DeleteItem(IContent node, QueuedItem queuedItem)
{
_logger.Info <PublishQueueService>("Deleting: {0}", () => node.Name);
_contentService.Delete(node, queuedItem.UserId);
return(true);
}
