public IList<Message> GetMessagesAndJournal(QueueType qType)
{
IList<Message> messages = GetMessages(qType);
ReqMessageQueueJournal q = new ReqMessageQueueJournal(qConfiguration.GetQueueName(qType));
IList<Message> messagesj = q.GetAllMessages().ToList<Message>();
return messages.Union<Message>(messagesj).ToList();
}
public async Task <string> DequeueWork(QueueType queue)
{
CloudQueue cloudQueue = null;
switch (queue)
{
case QueueType.Workflow:
cloudQueue = _workflowQueue;
break;
case QueueType.Event:
cloudQueue = _eventQueue;
break;
}
if (cloudQueue == null)
{
return(null);
}
var msg = await cloudQueue.GetMessageAsync();
if (msg == null)
{
return(null);
}
await cloudQueue.DeleteMessageAsync(msg);
return(msg.AsString);
}
public static queue CreateDownloadQueue(Tranferclint client, int id, string typ, string saveName, long length)
{
try
{
//Same as above with some changes.
var queue = new queue();
queue._Type = typ;
queue.Client = client;
queue.Filename = saveName;
queue._Type = typ;
queue.Type = QueueType.Download;
//Create our file stream for writing.
queue.FS = new FileStream(saveName, FileMode.Create);
//Fill the stream will 0 bytes based on the real size. So we can index write.
queue.Length = length;
queue.FS.SetLength(length);
//Instead of generating an ID, we will set the ID that has been sent.
queue.ID = id;
return(queue);
}
catch
{
return(null);
}
}
private async Task <string> ConstructQueueName(ILogger logger, int herId, QueueType type)
{
var details = await Core.AddressRegistry.FindCommunicationPartyDetailsAsync(logger, herId).ConfigureAwait(false);
if (details == null)
{
throw new MessagingException("Could not find sender in address registry")
{
EventId = EventIds.SenderMissingInAddressRegistryEventId
};
}
switch (type)
{
case QueueType.Asynchronous:
return(ExtractQueueName(details.AsynchronousQueueName));
case QueueType.Synchronous:
return(ExtractQueueName(details.SynchronousQueueName));
case QueueType.Error:
return(ExtractQueueName(details.ErrorQueueName));
default:
throw new InvalidOperationException("QueueType not supported");
}
}
private void TestUpdate()
{
var now = DateTime.Now;
var queueType = new QueueType
{
Name = "My Queue Type 2",
Delay = 4,
Duration = 6,
Created = now
};
var created = _queueTypeRepository.Create(queueType).Result;
Assert.Equal(created.Id, _queueTypeRepository.FindById(created.Id).Id);
Assert.NotNull(created);
Assert.Equal(created.Id, queueType.Id);
created.Name = "I just changed my mind";
var updated = _queueTypeRepository.Update(created).Result;
Assert.NotNull(updated);
Assert.Equal("I just changed my mind", updated.Name);
}
public bool SendDataToQueue(QueueType queueType, object data)
{
var result = true;
try
{
if (_connection == null)
{
_connection = _connectionFactory.CreateConnection();
}
var channel = _connection.CreateModel();
channel.QueueDeclare(queueType.ToString(), false, false, false, null);
var messageJson = Newtonsoft.Json.JsonConvert.SerializeObject(data);
var message = Encoding.UTF8.GetBytes(messageJson);
channel.BasicPublish(exchange: String.Empty, routingKey: queueType.ToString(), basicProperties: null, body: message);
}
catch (Exception ex)
{
result = false;
}
return(result);
}
public MessageQueue[] InitializeQueue(Endpoint queueEndpoint, QueueType queueType)
{
var queue = MsmqUtil.GetQueuePath(queueEndpoint).Create();
switch (queueType)
{
case QueueType.Standard:
return(new[]
{
queue,
MsmqUtil.OpenOrCreateQueue(GetErrorsQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetSubscriptionQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetDiscardedQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetTimeoutQueuePath(), QueueAccessMode.SendAndReceive, queue),
});
case QueueType.LoadBalancer:
return(new[]
{
queue,
MsmqUtil.OpenOrCreateQueue(GetKnownWorkersQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetKnownEndpointsQueuePath(), QueueAccessMode.SendAndReceive, queue),
});
default:
throw new ArgumentOutOfRangeException("queueType", "Can't handle queue type: " + queueType);
}
}
/// <inheritdoc />
/// <summary>
/// Write a new id to the specified queue
/// </summary>
/// <param name="id"></param>
/// <param name="queue"></param>
/// <returns></returns>
public async Task QueueWork(string id, QueueType queue)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException(nameof(id), "Param id must not be null");
}
SqlConnection cn = new SqlConnection(_connectionString);
try
{
cn.Open();
var par = _config.GetByQueue(queue);
_sqlCommandExecutor.ExecuteCommand(cn, null, _queueWorkCommand,
new SqlParameter("@initiatorService", par.InitiatorService),
new SqlParameter("@targetService", par.TargetService),
new SqlParameter("@contractName", par.ContractName),
new SqlParameter("@msgType", par.MsgType),
new SqlParameter("@RequestMessage", id)
);
}
finally
{
cn.Close();
}
}
public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
{
var id = intent.GetIntExtra("id", 0);
var url = intent.GetStringExtra("url");
var filePath = intent.GetStringExtra("filePath");
var iQueueType = intent.GetIntExtra("queueType", 0);
QueueType queueType = ConvertIntToQueueType(iQueueType);
Task.Run(() => {
var imageHelper = new DownloadHelper();
imageHelper.DownloadFileAsync(url, filePath)
.ContinueWith(fp => {
var message = new DownloadFinishedMessage
{
Id = id,
Url = url,
FilePath = fp.Result,
QueueType = queueType
};
MessagingCenter.Send(message, "DownloadFinishedMessage");
});
});
return(StartCommandResult.Sticky);
}
/// <summary>
/// 佣兵招募冷却时间
/// </summary>
/// <param name="userID"></param>
/// <param name="recruitRule"></param>
/// <returns></returns>
public static void UpdateRecruitColdTime(string userID, RecruitRule recruitRule)
{
QueueType queueType = QueueType.ShiLiTiaoYi;
if (recruitRule.RecruitType == RecruitType.ShiLiTiaoYi.ToInt())
{
queueType = QueueType.ShiLiTiaoYi;
}
else if (recruitRule.RecruitType == RecruitType.BaiLiTiaoYi.ToInt())
{
queueType = QueueType.BaiLiTiaoYi;
}
else if (recruitRule.RecruitType == RecruitType.Golden.ToInt())
{
queueType = QueueType.Golden;
}
var cacheSet = new GameDataCacheSet <UserQueue>();
UserQueue userQueue = cacheSet.Find(userID, s => s.QueueType == queueType);
if (userQueue == null)
{
userQueue = new UserQueue();
userQueue.QueueID = Guid.NewGuid().ToString();
userQueue.UserID = userID;
userQueue.QueueType = queueType;
cacheSet.Add(userQueue, userID.ToInt());
}
userQueue.QueueName = queueType.ToString();
userQueue.Timing = DateTime.Now;
userQueue.TotalColdTime = recruitRule.CodeTime;
userQueue.ColdTime = recruitRule.CodeTime;
userQueue.StrengNum = 1;
userQueue.IsSuspend = false;
}
/// <summary>
/// Sends a prepared message
/// </summary>
/// <param name="logger"></param>
/// <param name="message">The prepared message</param>
/// <param name="queueType">The type of queue to use</param>
/// <param name="userId"></param>
/// <param name="xml">Optional xml content. This will be logged depending on the logging level.</param>
/// <returns></returns>
private async Task Send(ILogger logger, IMessagingMessage message, QueueType queueType, string userId = "99999999999", XDocument xml = null)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
IMessagingSender messageSender = null;
try
{
messageSender = SenderPool.CreateCachedMessageSender(logger, message.To);
await messageSender.SendAsync(message).ConfigureAwait(false);
}
catch (Exception ex)
{
logger.LogException("Cannot send message to service bus. Invalid endpoint.", ex);
throw new MessagingException(ex.Message)
{
EventId = EventIds.Send
};
}
finally
{
if (messageSender != null)
{
SenderPool.ReleaseCachedMessageSender(logger, message.To);
}
}
}
public override void SendCommandRemote(QueueType inQueue,
LibCommon.Network.Types.GameMessage inEvent)
{
byte[] msg = ThriftMessageSerialize.SerializeCompact(inEvent);
if (inQueue == QueueType.Client)
{
if (string.IsNullOrEmpty(inEvent.NetworkId))
{
//_internalNetwork.BroadcastAll(NetworkUtils.SerializeEvent(inEvent));
_internalNetwork.BroadcastAll(msg);
ClientQueue.Enqueue(inEvent);
}
else
{
Debug.Log(inEvent.NetworkId);
if (inEvent.NetworkId == "-1")
{
ClientQueue.Enqueue(inEvent);
}
else
{
_internalNetwork.SendPacketToClient(inEvent.NetworkId, msg);
}
}
}
else
{
_internalNetwork.SendToServer(msg);
}
}
public static List <CloudQueueMessage> GetQueueMessages(QueueType type, SourceType source, int messageCount)
{
messageCount = Math.Min(messageCount, 32); //32 is hard limit
CloudQueue queue = GetCloudQueue(type, source);
List <CloudQueueMessage> queueMessageList = new List <CloudQueueMessage>();
IEnumerable <CloudQueueMessage> queueMessages = queue.GetMessages(messageCount);
if ((queueMessages != null) && (queueMessages.Count <CloudQueueMessage>() > 0))
{
foreach (CloudQueueMessage message in queueMessages)
{
//Check Poisen Message
if (message.DequeueCount < 3)
{
queueMessageList.Add(message);
}
else
{
AddQueueMessage(QueueType.Failures, SourceType.Twitter, message.AsString);
queue.DeleteMessage(message);
}
}
}
return(queueMessageList);
}
public MessageQueue[] InitializeQueue(Endpoint queueEndpoint, QueueType queueType)
{
var queue = MsmqUtil.GetQueuePath(queueEndpoint).Create();
switch (queueType)
{
case QueueType.Standard:
return new[]
{
queue,
MsmqUtil.OpenOrCreateQueue(GetErrorsQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetSubscriptionQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetDiscardedQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetTimeoutQueuePath(), QueueAccessMode.SendAndReceive, queue),
};
case QueueType.LoadBalancer:
return new[]
{
queue,
MsmqUtil.OpenOrCreateQueue(GetKnownWorkersQueuePath(), QueueAccessMode.SendAndReceive, queue),
MsmqUtil.OpenOrCreateQueue(GetKnownEndpointsQueuePath(), QueueAccessMode.SendAndReceive, queue),
};
case QueueType.Raw:
return new[]
{
queue,
};
default:
throw new ArgumentOutOfRangeException("queueType", "Can't handle queue type: " + queueType);
}
}
public bool IsEmpty(QueueType type)
{
int count;
if (type == QueueType.Position)
{
lock (this)
{
count = positionQueue.Count;
}
}
else
{
lock (this)
{
count = velocityQueue.Count;
}
}
if (count == 0)
{
return(true);
}
else
{
return(false);
}
}
public void Replace(QueueType type, double[,] points)
{
if (points == null)
{
return;
}
List <double[]> tempQueue = new List <double[]>();
for (int i = 0; i < points.GetLength(1); i++)
{
tempQueue.Add(new double[2] {
points[0, i], points[1, i]
});
}
if (type == QueueType.Position)
{
lock (this)
{
positionQueue.Clear();
positionQueue.AddRange(tempQueue);
}
}
else
{
lock (this)
{
velocityQueue.Clear();
velocityQueue.AddRange(tempQueue);
}
}
}
public static queue CreateUploadQueue(Tranferclint client, string fileName)
{
try
{
//We will create a new upload queue
var queue = new queue();
//Set our filename
queue.Filename = fileName;
// queue.Filename = fileName;
queue._Type = Path.GetFileName(fileName).ToLower().Contains("jpg") || Path.GetFileName(fileName).ToLower().Contains("png") ? "Image" : "Video";
//Set our client
queue.Client = client;
//Set our queue type to upload.
queue.Type = QueueType.Upload;
//Create our file stream for reading.
queue.FS = new FileStream(fileName, FileMode.Open);
//Create our transfer thread
queue.Thread = new Thread(new ParameterizedThreadStart(transferProc));
// queue.Thread.IsBackground = true;
//Generate our ID
queue.ID = Application.Rand.Next();
//Set our length to the size of the file.
queue.Length = queue.FS.Length;
return(queue);
}
catch
{
//If something goes wrong, return null
return(null);
}
}
public void FixedUpdate()
{
if (ConstructingUnit != null)
{
ConstructionTimeLeft -= Time.deltaTime;
if (ConstructionTimeLeft <= 0f)
{
ConstructingUnit.gameObject.SetActive(true);
ConstructingUnit = null;
GetComponent <SpriteRenderer>().sprite = CompletedSprite;
}
}
if (QueueTimeLeft > 0)
{
QueueTimeLeft -= Time.fixedDeltaTime;
}
else if (CurrentQueuedItem != QueueType.None)
{
var coords = CordUtil.WorldToTile(transform.position);
var freespot = _map.FindNextFreeTile(coords.First, coords.Second);
_unitfactory.Create(QueuedUnit, PlayerOwner, freespot.First, freespot.Second - 2);
CurrentQueuedItem = QueueType.None;
}
if (HP <= 0)
{
//Building dies
Destroy(gameObject);
}
}
/// <summary>
/// Sets the current playlist.
/// Depending on the QueueType, we will either let the current song that is playing finish, or just immediately start playing our first song in the new playlist
/// </summary>
/// <param name="songs"></param>
/// <param name="queueType"></param>
public static void SetPlaylist(List <string> songs, QueueType queueType = QueueType.WaitForCurrent)
{
// If we are not adding any songs, don't bother doing the rest of this function
if (songs == null || songs.Count == 0)
{
return;
}
// If the song we are currently playing is being added again by the new playlist, move it to the back
// This means we will have to listen to all the others before we hear it again
if (CurrentPlaylist.Count > 0 && CurrentSong != null)
{
string currentSongName = CurrentSong.Name;
if (songs.Contains(currentSongName))
{
songs.Remove(currentSongName);
songs.Add(currentSongName);
}
}
// Resets the current song index so we play from the start of the new playlist
CurrentPlaylist = songs;
CurrentSongIndex = 0;
// If we have specified we wish to play immediately we skip the remainder of the current song and play the next one
if (queueType == QueueType.PlayImmediately)
{
PlayNextSong();
}
}
public virtual void AddMusic(QueueType queueType = QueueType.PlayImmediately)
{
if (BaseScreenData != null)
{
MusicManager.QueueSongs(BaseScreenData.BackgroundMusicNames, queueType);
}
}
public async Task <string> DequeueWork(QueueType queue, CancellationToken cancellationToken)
{
if (_connection == null)
{
throw new InvalidOperationException("ActiveMQ provider not running");
}
var destination = GetDestination(queue);
if (destination == null)
{
throw new InvalidOperationException("Invalid destination");
}
string result = null;
using (var consumer = _session.CreateConsumer(destination))
{
var message = consumer.ReceiveNoWait();
if (message != null)
{
var txtMsg = message as ITextMessage;
if (txtMsg != null)
{
result = txtMsg.Text;
}
message.Acknowledge();
}
}
return(result);
}
private double[] Drain(QueueType type)
{
double[] item = null;
switch (type)
{
case QueueType.ADC:
lock (gyroQueue)
{
if (gyroQueue.Count > 0)
{
item = gyroQueue.Dequeue();
}
}
break;
case QueueType.Gyro:
lock (adcQueue)
{
if (adcQueue.Count > 0)
{
item = adcQueue.Dequeue();
}
}
break;
}
return(item);
}
/// <summary>
/// Sends a prepared message
/// </summary>
/// <param name="logger"></param>
/// <param name="message">The prepared message</param>
/// <param name="queueType">The type of queue to use</param>
/// <param name="userId"></param>
/// <param name="xml">Optional xml content. This will be logged depending on the logging level.</param>
/// <returns></returns>
private async Task Send(ILogger logger, IMessagingMessage message, QueueType queueType, string userId = "99999999999", XDocument xml = null)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
logger.LogStartSend(queueType, message.MessageFunction, message.FromHerId, message.ToHerId, message.MessageId, userId, xml);
IMessagingSender messageSender = null;
try
{
messageSender = SenderPool.CreateCachedMessageSender(logger, message.To);
await messageSender.SendAsync(message).ConfigureAwait(false);
}
catch (Exception ex)
{
throw new MessagingException(ex.Message)
{
EventId = EventIds.Send
};
}
finally
{
if (messageSender != null)
{
SenderPool.ReleaseCachedMessageSender(logger, message.To);
}
}
logger.LogEndSend(queueType, message.MessageFunction, message.FromHerId, message.ToHerId, message.MessageId, userId);
}
public DirectRoutingTopology(bool durable, QueueType queueType, Func <Type, string> routingKeyConvention = null, Func <string> exchangeNameConvention = null)
{
this.durable = durable;
this.queueType = queueType;
this.routingKeyConvention = routingKeyConvention ?? DefaultRoutingKeyConvention.GenerateRoutingKey;
this.exchangeNameConvention = exchangeNameConvention ?? (() => amqpTopicExchange);
}
public User createUser(string[] s, QueueType type)
{
int id = -1;
string tableName = (type == QueueType.Banking) ? "[BankingQueue]" : "[NormalQueue]";
SqlCommand cmd = new SqlCommand();
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = QueueInsertString(s[0], s[1], s[2], s[3], s[4], tableName);//"INSERT INTO [User](Email, Firstname, LastName, Hash) OUTPUT INSERTED.ID VALUES('*****@*****.**' ,'fname','lname', 'hash')";
cmd.Connection = this.con.getSQLConnection();
try
{
con.getSQLConnection().Open();
id = (Int32)cmd.ExecuteScalar();
}
catch (Exception e)
{
Console.Write(e.ToString());
}
finally
{
con.getSQLConnection().Close();
}
return(getUser(id));
}
public PriorityQueue(QueueType type = QueueType.Min, IComparer <T> comparer = null)
{
comparer = comparer ?? Comparer <T> .Default;
set = new SortedSet <PQItem>(Comparer <PQItem> .Create((x, y) =>
comparer.Compare(x.Value, y.Value) == 0 ? x.Index - y.Index : comparer.Compare(x.Value, y.Value)));
this.type = type;
}
public async Task <string> DequeueWork(QueueType queue, CancellationToken cancellationToken)
{
if (_connection == null)
{
throw new InvalidOperationException("RabbitMQ provider not running");
}
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare(queue: GetQueueName(queue),
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var msg = channel.BasicGet(GetQueueName(queue), false);
if (msg != null)
{
var data = Encoding.UTF8.GetString(msg.Body);
channel.BasicAck(msg.DeliveryTag, false);
return(data);
}
return(null);
}
}
public void SendClientQueueSuccess(PlayerConnect _this, QueueType type, ulong characterId)
{
var data = new QueueSuccessData();
data.Type = (int)type;
switch (type)
{
case QueueType.Login:
{
LoginServerControlDefaultImpl.NotifyGateClientState(LoginServer.Instance.ServerControl,
_this.ClientId, 0, GateClientState.Login);
data.LastServerId = _this.Player.DbData.LastServerId;
_this.Player.DbData.LoginDay++;
_this.Player.DbData.LoginTotal++;
}
break;
case QueueType.EnterGame:
data.CharacterId = characterId;
break;
}
PlayerLog.WriteLog((int)LogType.SendClientQueueSuccess, "SendClientQueueSuccess type = {0}, name = {1}",
type, _this.Name);
LoginServer.Instance.ServerControl.NotifyQueueSuccess(_this.ClientId, data);
}
public ICollection <UserReference> GetReportCreators(QueueType queueType)
{
var reports = GetReportsByQueueType(queueType);
var ids = reports.Select(r => r.CreatedBy).Distinct().ToList();
var creators =
_administrationUnitOfWork.GetEntityQuery <User>(TrackingMode.Manual)
.Where(x => ids.Contains(x.Id)).ToList(); // user by the unique creator id
ICollection <UserReference> userReferences = new Collection <UserReference>();
foreach (var user in creators)
{
userReferences.Add(new UserReference
{
UserId = user.Id,
Username =
String.IsNullOrWhiteSpace(user.FirstName)
? user.LastName
: String.Concat(user.LastName, ", ", user.FirstName)
});
return(userReferences);
}
return(creators.Select(user => new UserReference
{
UserId = user.Id,
Username = String.IsNullOrWhiteSpace(user.FirstName) ? user.LastName : String.Concat(user.LastName, ", ", user.FirstName)
}).ToList());
}
public int GetSummaryQueueCount(QueueType queueType, QueueQuery queueQuery)
{
switch (queueType)
{
case QueueType.Incident:
return(IncidentSummaries(queueQuery).Count());
case QueueType.Arrest:
return(ArrestSummaries(queueQuery).Count());
case QueueType.FieldInterview:
return(FieldInterviewSummaries(queueQuery).Count());
case QueueType.Case:
return(CaseSummmaries(queueQuery).Count());
case QueueType.OtherEvent:
return(OtherEventSummaries(queueQuery).Count());
case QueueType.Citation:
return(CitationSummaries(queueQuery).Count());
case QueueType.CallForService:
return(CallForServiceSummaries(queueQuery).Count());
}
return(0);
}
public Queue(QueueType qType)
{
QueueType = ((char)qType).ToString();
Status = (int)QueueStatus.Waiting;
CreatedAt = DateTime.Now;
UpdatedAt = CreatedAt;
}
protected Guid ScheduleExportTableJob(string schemaName, string tableName, string path, QueueType queueType)
{
var queue = String.Format("Graywulf.Controller.Controller.{0}", queueType.ToString());
using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
var user = SignInTestUser(context);
var ef = new EntityFactory(context);
var f = ef.LoadEntity<Federation>(Federation.AppSettings.FederationName);
var format = new FileFormatFactory().GetFileFormatDescription("Jhu.Graywulf.Format.CsvFile");
var source = new Jhu.Graywulf.Schema.Table()
{
Dataset = user.GetUserDatabaseInstance(f.MyDBDatabaseVersion).GetDataset(), // TODO: fix this
SchemaName = schemaName,
TableName = tableName
};
var etf = new ExportTableFactory(context);
var ji = etf.ScheduleAsJob(
source,
path,
format,
queue,
"");
ji.Save();
return ji.Guid;
}
}
public ReaderQueue(QueueType pType, string pQueueName, bool pShared)
{
QueueName = pQueueName;
QueueType = pType;
Shared = pShared;
StartListening(QueueName);
}
public MessageQueue[] InitializeQueue(Endpoint queueEndpoint, QueueType queueType)
{
var path = MsmqUtil.GetQueuePath(queueEndpoint);
return new[]
{
path.Create()
};
}
public void insert(QueueType item)
{
items.Insert(0, item);
if (items.Count() > len)
{
items.RemoveAt(items.Count() - 1);
}
}
public static void QueueSong(string songName, QueueType queueType = QueueType.WaitForCurrent)
{
QueueSongNames.Enqueue(songName);
if (queueType == QueueType.PlayImmediately)
{
PlayNextSong();
}
}
public Message CreateMeesage(QueueType qType)
{
Message theMessage = new Message(messageBody);
theMessage.Formatter = new System.Messaging.XmlMessageFormatter(new string[] { "System.String" });
theMessage.Label = ((int)qType).ToString() + "|" + Guid.NewGuid();
return theMessage;
}
protected void CreateQueues(QueueType mainQueueType, Endpoint mainQueueEndpoint, string user)
{
// will create the queues if they are not already there
var queues = queueStrategy.InitializeQueue(mainQueueEndpoint, mainQueueType);
foreach (var queue in queues)
{
GrantPermissions(queue, user);
}
}
public static void Prepare(string queueName, QueueType queueType)
{
var queueUri = new Uri(queueName);
var queuePath = MsmqUtil.GetQueuePath(new Endpoint {
Uri = queueUri
});
CreateQueueIfNotExists(queuePath.QueuePath);
//PurgeQueue(queuePath.QueuePath);
//PurgeSubqueues(queuePath.QueuePath, queueType);
}
public Queue(int type, double size, double pages = 0)
{
_Type = (QueueType) type;
_MaxSize = size;
_PageSizes = new Collection<double>();
_PageSizes.Add(pages);
_ProcessList = new Collection<Process>();
_Log = new Collection<string>();
_MemoryList = new Collection<Memory>();
}
private void SetupMessageReadPropertyFilters(MessageQueue q, QueueType type)
{
q.MessageReadPropertyFilter.Id = true;
q.MessageReadPropertyFilter.ArrivedTime = true;
q.MessageReadPropertyFilter.Label = true;
q.MessageReadPropertyFilter.Body = false;
//if( type == QueueType.Error )
q.MessageReadPropertyFilter.Extension = true;
}
public Queue(string name, QueueType type, int color = 0)
{
Name = name;
Type = type;
DisplayName = name.CutBeginning(46);
Color = color;
ColorString = "#" + color.ToString("X");
SelectedColorString = "#" + GetSelectedColor(color).ToString("X");
}
public static string GetQueueName(QueueType qType)
{
switch (qType)
{
case QueueType.Booking:
return "Booking";
case QueueType.Scheduling:
return "Scheduling";
default:
return "default";
}
}
public Queue(string name, QueueType type, int color = 0, MessageContentFormat contentFormat = MessageContentFormat.Unknown) {
Name = name;
Type = type;
DisplayName = name.CutBeginning(46);
Color = color;
ContentFormat = contentFormat;
ColorString = "#" + color.ToString("X");
SelectedColorString = "#" + GetSelectedColor(color).ToString("X");
}
public TargetAction(int sequence, int frame, IPlayer player,
IMapPosition mapPosition, int objectId,
ObjectType objectType, OrderType orderType,
QueueType queueType)
: base(sequence, frame, player)
{
this.MapPosition = mapPosition;
this.ObjectIdentifier = objectId;
this.ObjectType = objectType;
this.OrderType = orderType;
this.QueueType = queueType;
ActionType = ActionType.Target;
}
public static void QueueSongs(List<string> songs, QueueType queueType = QueueType.WaitForCurrent)
{
// If we are not adding any songs, don't bother doing the rest of this function
if (songs.Count == 0)
return;
foreach (string song in songs)
{
QueueSongNames.Enqueue(song);
}
if (queueType == QueueType.PlayImmediately)
{
PlayNextSong();
}
}
public static void Prepare(string queueName, QueueType queueType)
{
_logger.InfoFormat("Prepairing queue {0}...", queueName);
var queueUri = new Uri(queueName);
var endpoint = new Endpoint {Uri = queueUri};
QueueInfo queuePath = MsmqUtil.GetQueuePath(endpoint);
EnsureQueueExists(queuePath.QueuePath);
/*NOTE:
If a queue is created this way by a windows service it wont yield the correct permissions
for other accounts i.e admin, developer to access this queue.*/
// CreateQueueIfNotExists(queuePath.QueuePath);
// PurgeQueue(queuePath.QueuePath);
// PurgeSubqueues(queuePath.QueuePath, queueType);
}
private static void PurgeSubqueues(string queuePath, QueueType queueType)
{
switch (queueType) {
case QueueType.Standard:
PurgeSubqueue(queuePath, "errors");
PurgeSubqueue(queuePath, "discarded");
PurgeSubqueue(queuePath, "timeout");
PurgeSubqueue(queuePath, "subscriptions");
break;
case QueueType.LoadBalancer:
PurgeSubqueue(queuePath, "endpoints");
PurgeSubqueue(queuePath, "workers");
break;
default:
throw new ArgumentOutOfRangeException("queueType", "Can't handle queue type: " + queueType);
}
}
protected Guid ScheduleQueryJob(string query, QueueType queueType)
{
var queue = String.Format("QueueInstance:Graywulf.Controller.Controller.{0}", queueType.ToString());
using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
SignInTestUser(context);
var f = new SqlQueryFactory(context);
var q = f.CreateQuery(query);
var ji = f.ScheduleAsJob(q, queue, "testjob");
ji.Save();
return ji.Guid;
}
}
protected Guid ScheduleMirroDatabaseJob(QueueType queueType)
{
var queue = String.Format("Graywulf.Controller.Controller.{0}", queueType.ToString());
using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
SignInTestUser(context);
var ef = new EntityFactory(context);
var jd = ef.LoadEntity<JobDefinition>(Cluster.AppSettings.ClusterName, typeof(MirrorDatabaseJob).Name);
var ji = jd.CreateJobInstance(queue, ScheduleType.Queued);
ji.Parameters["DatabaseVersionName"].SetValue("Graywulf.VOServices.SkyQuery.Galex.STAT");
ji.Save();
return ji.Guid;
}
}
protected Guid ScheduleExportTableJob(string schemaName, string tableName, string path, QueueType queueType)
{
var queue = String.Format("QueueInstance:Graywulf.Controller.Controller.{0}", queueType.ToString());
using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
var user = SignInTestUser(context);
var ef = new EntityFactory(context);
var federation = ef.LoadEntity<Federation>(Registry.AppSettings.FederationName);
var format = FileFormatFactory.Create(federation.FileFormatFactory).GetFileFormatDescription(typeof(Jhu.Graywulf.Format.DelimitedTextDataFile).FullName);
var mydbds = federation.MyDBDatabaseVersion.GetUserDatabaseInstance(user).GetDataset();
var source = new Jhu.Graywulf.Schema.Table()
{
Dataset = mydbds, // TODO: fix this
DatabaseName = mydbds.DatabaseName,
SchemaName = schemaName,
TableName = tableName
};
var etf = new ExportTablesFactory(context);
var ji = etf.ScheduleAsJob(
federation,
new TableOrView[] {source },
path,
format,
queue,
"");
ji.Save();
return ji.Guid;
}
}
private void MonitorStateChanged(QueueType type, bool value)
{
_monitorState.MonitorQueueType[(int)type] = value;
if( !value ) {
lock( _itemsLock ) {
foreach( var itm in _items.Where(i => i.Queue.Type == type).ToArray() )
_items.Remove(itm);
}
}
}
public uint GetUnprocessedItemsCount(QueueType qt)
{
return _unprocessedItemsCount[(int)qt];
}
private void ChangedMonitorFlag(QueueType type, bool newState)
{
switch( type ) {
case QueueType.Command: _sys.MonitorCommands = newState; break;
case QueueType.Event: _sys.MonitorEvents = newState; break;
case QueueType.Message: _sys.MonitorMessages = newState; break;
case QueueType.Error: _sys.MonitorErrors = newState; break;
}
}
public bool IsMonitoringQueueType(QueueType type)
{
return MonitorQueueType[(int)type];
}
/// <summary>
///
/// </summary>
/// <param name="queue"></param>
/// <param name="tag"></param>
/// <param name="query"></param>
public void RequestQueueFiles(QueueType queue, MetaTag tag, string query)
{
string filter = String.Empty;
List<string> trackList = new List<string>();
bool loop = true;
switch (tag)
{
case MetaTag.artist:
filter = XmlFilter(new[] {"ArtistPeople"}, query, true);
break;
case MetaTag.album:
filter = XmlFilter(new[] {"Album"}, query, true);
break;
case MetaTag.genre:
filter = XmlFilter(new[] {"Genre"}, query, true);
break;
case MetaTag.title:
trackList.Add(System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(query)));
loop = false;
break;
case MetaTag.none:
return;
default:
return;
}
if (trackList.Count == 0)
{
mbApiInterface.Library_QueryFiles(filter);
while (loop)
{
string current = mbApiInterface.Library_QueryGetNextFile();
if (String.IsNullOrEmpty(current)) break;
trackList.Add(current);
}
}
if (queue == QueueType.Next)
{
mbApiInterface.NowPlayingList_QueueFilesNext(trackList.ToArray());
}
else if (queue == QueueType.Last)
{
mbApiInterface.NowPlayingList_QueueFilesLast(trackList.ToArray());
}
else if (queue == QueueType.PlayNow)
{
mbApiInterface.NowPlayingList_Clear();
mbApiInterface.NowPlayingList_QueueFilesLast(trackList.ToArray());
mbApiInterface.NowPlayingList_PlayNow(trackList[0]);
}
}
private string GetQueueStatusString()
{
QueueType[] itemTypes = null;
if( _sys != null )
itemTypes = _sys.Items.Select(i => i.Queue.Type).ToArray();
else itemTypes = new QueueType[0];
return string.Format(" Commands: {0} \r\n Events: {1} \r\n Messages: {2} \r\n Errors: {3} ",
itemTypes.Count(i => i == QueueType.Command),
itemTypes.Count(i => i == QueueType.Event),
itemTypes.Count(i => i == QueueType.Message),
itemTypes.Count(i => i == QueueType.Error)
);
}
public QueueFetchResult GetProcessedMessages(QueueType type, DateTime since, IEnumerable<QueueItem> currentItems)
{
var result = new QueueFetchResult();
var queues = GetQueueListByType(type);
if (queues.Count() == 0)
{
result.Items = new List<QueueItem>();
return result;
}
List<QueueItem> r = new List<QueueItem>();
result.Items = r;
foreach (var q in queues)
{
string qName = q.GetDisplayName();
if (IsIgnoredQueue(qName) || !q.CanReadJournalQueue)
continue;
SetupMessageReadPropertyFilters(q.Journal, type);
try
{
List<Message> messages = new List<Message>();
// Enumete from the earliest item
MessageEnumerator msgs = q.Journal.GetMessageEnumerator2();
try
{
while (msgs.MoveNext())
{
Message msg = msgs.Current;
if (msg.ArrivedTime >= since)
messages.Add(msg);
}
}
finally
{
msgs.Close();
}
foreach (var msg in messages)
{
QueueItem itm = currentItems.FirstOrDefault(i => i.Id == msg.Id);
if (itm == null)
{
itm = CreateQueueItem(q.Queue, msg);
itm.Processed = true;
if (!PrepareQueueItemForAdd(itm))
itm = null;
}
if (itm != null)
r.Insert(0, itm);
}
}
catch (Exception e)
{
OnError("Error occured when getting processed messages from queue \"" + qName + "\", " + e.Message, e, false);
}
}
result.Count = (uint)r.Count;
return result;
}
protected IEnumerable<MsmqMessageQueue> GetQueueListByType(QueueType type)
{
return _monitorMsmqQueues.Where(q => q.Queue.Type == type);
}
public abstract IEnumerable<QueueItem> GetUnprocessedMessages(QueueType type, IEnumerable<QueueItem> currentItems);
