void RequestCompleted(QueueRequest request, string responseString)
{
if (request.Callback != null)
{
request.Callback(new WebRequestCompletedArgs(responseString));
}
}
void MakeRequest()
{
if (currentStatus == QueueStatus.Stopped)
return;
currentRequest = requests.First();
try
{
WebRequest = (HttpWebRequest)HttpWebRequest.Create(currentRequest.Url);
if (IsolatedStorageSettings.ApplicationSettings.Contains("RemoteServerUsername") &&
(string)IsolatedStorageSettings.ApplicationSettings["RemoteServerUsername"] != "" &&
IsolatedStorageSettings.ApplicationSettings.Contains("RemoteServerPassword") &&
(string)IsolatedStorageSettings.ApplicationSettings["RemoteServerPassword"] != "")
{
WebRequest.Credentials = new NetworkCredential((string)IsolatedStorageSettings.ApplicationSettings["RemoteServerUsername"], (string)IsolatedStorageSettings.ApplicationSettings["RemoteServerPassword"]);
}
WebRequest.BeginGetResponse(new AsyncCallback(FinishWebRequest), this);
}
catch (WebException e)
{
WebRequest = null;
if (currentRequest.Callback != null)
{
currentRequest.Callback(new WebRequestCompletedArgs(WebRequestStatus.WebException));
}
}
catch
{
WebRequest = null;
if (currentRequest.Callback != null)
{
currentRequest.Callback(new WebRequestCompletedArgs(WebRequestStatus.BeginWebRequestGeneralError));
}
}
//
if (WebRequest != null)
{
requests.RemoveAt(0);
}
}
//protected override IQueueAck Send(QueueItem message)
//{
// return _api.PublishItem(message);
//}
protected override void ReceiveAsync(IDynamicWait dw)
{
QueueRequest request = new QueueRequest()
{
Host = _api.QueueName,
QCommand = QueueCmd.Dequeue,
DuplexType = DuplexTypes.WaitOne
};
//void OnNack()
//{
// CalcDynamicWait(false);
//}
//void OnAck(bool ack)
//{
// aw.DynamicWaitAck(ack);
//}
//if (EnableResetEvent)
// _api.DequeueAsync(request, ConnectTimeout, OnCompleted, OnAck, resetEvent);
//else
_api.DequeueAsync(request, ConnectTimeout, OnCompleted, dw);
//_api.ReceiveAsync(
// OnFault,
// OnCompleted,
// DuplexTypes.WaitOne,
// resetEvent
// );
//_api.SendDuplexAsync(message,
// (err) => OnErrorOcurred(new GenericEventArgs<string>(err)),
// (qitem) => OnMessageReceived(qitem));
}
public static void DoQuery(QueueHost host)
{
QueueApi q = new QueueApi(host);
var req = new QueueRequest()
{
QCommand = QueueCmd.ReportQueueItems, DuplexType = DuplexTypes.NoWaite, Host = "NC_Quick"
};
var ts = q.SendDuplexStream(req, 1000000);
if (ts != null)
{
//var stream = ts.ReadStream(null);
//Nistec.Serialization.BinaryStreamer bs = new Nistec.Serialization.BinaryStreamer(stream);
//var olist= bs.Decode();
//var olist = ts.ReadValue();
var list = ts.ReadValue <IEnumerable <PersistItem> >();
Console.WriteLine(list);
}
else
{
Console.WriteLine("Get nothing!");
}
}
void RequestCompleted(QueueRequest request, string responseString)
{
if (request.Callback != null)
{
request.Callback(new WebRequestCompletedArgs(responseString));
}
}
public async Task Verify_can_override_arguments()
{
var services = GetContainerBuilder().BuildServiceProvider();
var result = await services.GetService <IBrokerObjectFactory>()
.Object <Queue>()
.Create("TestQueue31", "HareDu", "Node1", x =>
{
x.IsDurable();
x.AutoDeleteWhenNotInUse();
x.HasArguments(arg =>
{
arg.SetQueueExpiration(1000);
arg.Set <long>("x-expires", 980);
});
});
Assert.Multiple(() =>
{
Assert.IsFalse(result.HasFaulted);
Assert.IsNotNull(result.DebugInfo);
QueueRequest request = result.DebugInfo.Request.ToObject <QueueRequest>();
Assert.AreEqual("980", request.Arguments["x-expires"].ToString());
Assert.IsTrue(request.Durable);
Assert.IsTrue(request.AutoDelete);
Assert.AreEqual("Node1", request.Node);
});
}
public void run()
{
try
{
this.initClient();
Console.Out.WriteLine("big queue size before enqueue : " + client.getSize(TOPIC));
QueueRequest req = new QueueRequest();
req.Data = Encoding.Default.GetBytes("hello world");
client.enqueue(TOPIC, req);
Console.Out.WriteLine("big queue size after enqueue : " + client.getSize(TOPIC));
QueueResponse resp = client.peek(TOPIC);
Console.Out.WriteLine("big queue size after peek : " + client.getSize(TOPIC));
Console.Out.WriteLine("peeked message : " + Encoding.Default.GetString(resp.Data));
resp = client.dequeue(TOPIC);
Console.Out.WriteLine("big queue size after dequeue : " + client.getSize(TOPIC));
Console.Out.WriteLine("dequeued message : " + Encoding.Default.GetString(resp.Data));
}
finally
{
this.closeClient();
}
}
/// <summary>
/// Generates a task sequence for getting the properties of the queue service.
/// </summary>
/// <param name="setResult">A delegate to receive the service properties.</param>
/// <returns>A task sequence that gets the properties of the queue service.</returns>
private TaskSequence GetServicePropertiesImpl(Action <ServiceProperties> setResult)
{
HttpWebRequest request = QueueRequest.GetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
CommonUtils.ApplyRequestOptimizations(request, -1);
this.Credentials.SignRequest(request);
// Get the web response.
Task <WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return(responseTask);
using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
using (Stream responseStream = response.GetResponseStream())
using (MemoryStream memoryStream = new MemoryStream())
{
// Download the service properties.
Task <NullTaskReturn> downloadTask = new InvokeTaskSequenceTask(() => { return(responseStream.WriteTo(memoryStream)); });
yield return(downloadTask);
// Materialize any exceptions.
NullTaskReturn scratch = downloadTask.Result;
// Get the result from the memory stream.
memoryStream.Seek(0, SeekOrigin.Begin);
setResult(QueueResponse.ReadServiceProperties(memoryStream));
}
}
public override Task <QueueResponse> GetQueue(QueueRequest request, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, "Cannot get queue at this time"));
return(Task.FromResult(new QueueResponse
{
}));
}
private bool JoinQueue(bool isQuick = false)
{
var form = new Host(true);
form.Mode.Items.Clear();
form.HostBtn.Text = "Join Queue";
form.Mode.Items.AddRange(new object[] { "Single", "Match" });
form.Mode.SelectedItem = form.Mode.Items.Contains(Program.Config.Mode) ? Program.Config.Mode : "Match";
if (form.BanList.Items.Count > 0)
{
form.BanList.SelectedIndex = 0;
}
form.CardRules.SelectedIndexChanged += form.FormatChanged;
form.CardRules.Items.Clear();
form.CardRules.Items.AddRange(new object[] { "TCG", "OCG" });
form.CardRules.SelectedItem = form.CardRules.Items.Contains(Program.Config.CardRules) ? Program.Config.CardRules : "TCG";
if (isQuick || form.ShowDialog() == DialogResult.OK)
{
QueueRequest request = new QueueRequest(form.CardRules.SelectedItem.ToString(), form.Mode.SelectedItem.ToString());
Program.ChatServer.SendPacket(DevServerPackets.JoinQueue, JsonSerializer.SerializeToString(request));
QueueLabel.Text = "Queue Status: searching";
return(true);
}
return(false);
}
public async Task Verify_cannot_create_queue12()
{
var services = GetContainerBuilder().BuildServiceProvider();
var result = await services.GetService <IBrokerObjectFactory>()
.CreateQueue(string.Empty, string.Empty, "Node1", x =>
{
x.IsDurable();
x.AutoDeleteWhenNotInUse();
x.HasArguments(arg =>
{
arg.SetQueueExpiration(1000);
arg.SetPerQueuedMessageExpiration(2000);
});
});
Assert.Multiple(() =>
{
Assert.IsTrue(result.HasFaulted);
Assert.IsNotNull(result.DebugInfo);
Assert.AreEqual(2, result.DebugInfo.Errors.Count);
QueueRequest request = result.DebugInfo.Request.ToObject <QueueRequest>();
Assert.AreEqual("1000", request.Arguments["x-expires"].ToString());
Assert.AreEqual("2000", request.Arguments["x-message-ttl"].ToString());
Assert.IsTrue(request.Durable);
Assert.IsTrue(request.AutoDelete);
Assert.AreEqual("Node1", request.Node);
});
}
static void Main(string[] args)
{
var q = CloudStorageAccount.Parse("UseDevelopmentStorage=true").CreateCloudQueueClient().GetQueueReference("testqueue");
q.CreateIfNotExist();
var req = QueueRequest.PutMessage(new Uri(q.Uri, q.Name + "/messages"), 30, null);
var body = QueueRequest.GenerateMessageRequestBody("hello world");
req.ContentLength = body.Length;
q.ServiceClient.Credentials.SignRequest(req);
using (var stream = req.GetRequestStream())
{
stream.Write(body, 0, body.Length);
stream.Close();
}
req.GetResponse();
req = QueueRequest.GetMessages(new Uri(q.Uri, q.Name + "/messages"), 30, 32, null);
q.ServiceClient.Credentials.SignRequest(req);
using (var response = (HttpWebResponse)req.GetResponse())
{
using (var msgResponse = QueueResponse.GetMessages(response))
{
foreach (var msg in msgResponse.Messages)
{
Console.WriteLine("MESSAGE: " + msg.Text);
q.DeleteMessage(msg.Id, msg.PopReceipt);
}
}
}
q.Delete();
}
private async Task <QueueItemProcessResult> ProcessMessagesAsync(QueueRequest request, IServiceBusClient sbSender, CancellationToken token)
{
try
{
// update user
UserEntity dbUser = await adapterDocumentDbDependencyClient.GetUser(request.Id);
dbUser.Processed = true;
await adapterDocumentDbDependencyClient.UpdateUser(dbUser);
await sbSenderClient.SendAsync(request);
return(QueueItemProcessResult.Complete);
}
catch (Exception ex)
{
LoggingContext.CreateLogger <ServiceBusDependencyReceiver>()
.LogError(
ex,
"{queue} item processing unhandled exception for type={type}, id={messageId}",
sbReceiverClient.QueueName,
request.GetType().Name,
request.Id);
return(QueueItemProcessResult.Retry);
}
}
public IQueueItem Peek(QueueRequest message, int connectTimeout = 0)
{
message.QCommand = QueueCmd.Peek;
//message.Host = this._QueueName;
return(ConsumItem(message, connectTimeout));
}
public void DequeueAsync(QueueRequest message, int connectTimeout, Action <IQueueItem> onCompleted, IDynamicWait aw)
{
message.QCommand = QueueCmd.Dequeue;
//message.Host = this._QueueName;
//message.MessageState = MessageState.Sending;
ConsumItem(message, connectTimeout, onCompleted, aw);
}
public override Task <EmptyMessage> Queue(QueueRequest request, ServerCallContext context)
{
AIClient client = Clients[request.Id];
client.Queue(SabberStoneContract.Core.GameType.Normal, request.Deckstring);
return(Task.FromResult(new EmptyMessage()));
}
//public IQueueItem Dequeue(DuplexTypes DuplexType = DuplexTypes.WaitOne)
//{
// QueueRequest request = new QueueRequest()//_QueueName, QueueCmd.Dequeue, null);
// {
// Host = _QueueName,
// QCommand = QueueCmd.Dequeue,
// DuplexType = DuplexType
// };
// return Dequeue(request);
//}
#endregion
#region Peek
//public IQueueItem Peek(QueueRequest message)
//{
// return Peek(message, ConnectTimeout);
//}
public IQueueItem Peek(int connectTimeout = 0)
{
QueueRequest message = new QueueRequest()
{
QCommand = QueueCmd.Peek,
Host = _QueueName,
};
return(ConsumItem(message, connectTimeout));
}
public void PeekAsync(QueueRequest message, int connectTimeout, Action <IQueueItem> onCompleted)
{
message.QCommand = QueueCmd.Peek;
//message.Host = this._QueueName;
//message.MessageState = MessageState.Sending;
//void OnAck(bool ack) { }
ConsumItem(message, connectTimeout, onCompleted, DynamicWait.Empty);
}
protected override IQueueItem Receive()
{
QueueRequest request = new QueueRequest()//_QueueName, QueueCmd.Dequeue, null);
{
Host = _api.QueueName,
QCommand = QueueCmd.Dequeue,
DuplexType = DuplexTypes.WaitOne
};
return(_api.Dequeue(request));
}
//public IQueueItem Dequeue(QueueRequest message)
//{
// return Dequeue(message, ConnectTimeout);
//}
public IQueueItem Dequeue(int connectTimeout = 0)
{
QueueRequest message = new QueueRequest()
{
QCommand = QueueCmd.Dequeue,
Host = _QueueName,
DuplexType = DuplexTypes.WaitOne
};
return(ConsumItem(message, connectTimeout));
}
public TransStream Command(QueueCmd command)
{
QueueRequest request = new QueueRequest()
{
QCommand = (QueueCmd)(int)command,
Host = _QueueName
};
var result = ExecDuplexStream(request, ConnectTimeout);
return(result);
}
public QueueResponse Queue(QueueRequest request)
{
var whitePlayer = new UserBLL().CreateUser(request.white_player_name);
var blackPlayer = new UserBLL().CreateUser(request.black_player_name);
GameService.Value.QueueForGame(whitePlayer);
var game_id = GameService.Value.QueueForGame(blackPlayer);
return(new QueueResponse {
gameId = game_id,
});
}
public async Task <IActionResult> PostMessage([FromBody] QueueRequest message)
{
var request = new SendMessageRequest
{
MessageBody = message.Message,
QueueUrl = _queueUrl
};
await _sqsClient.SendMessageAsync(request);
return(Ok($"Message '{message.Message}' from user {message.User} queued."));
}
public TransStream Report(QueueCmdReport cmd)
{
QueueRequest request = new QueueRequest()
{
Host = _QueueName,
QCommand = (QueueCmd)(int)cmd
//Command = (QueueCmd)(int)cmd
};
var response = ExecDuplexStream(request, ConnectTimeout);
return(response);
}
//public void DequeueAsync(QueueRequest message, int connectTimeout, Action<IQueueItem> onCompleted, Action<bool> onAck, AutoResetEvent resetEvenet)
//{
// message.QCommand = QueueCmd.Dequeue;
// //message.Host = this._QueueName;
// //message.MessageState = MessageState.Sending;
// ConsumItem(message, connectTimeout, onCompleted, onAck, resetEvenet);
//}
public IQueueItem Dequeue(Priority priority)
{
QueueRequest request = new QueueRequest()//_QueueName, QueueCmd.DequeuePriority, null);
{
Host = _QueueName,
QCommand = QueueCmd.DequeuePriority
};
request.Priority = priority;
return(Dequeue(request));
}
public IQueueItem QueueExists()
{
QueueRequest message = new QueueRequest()
{
Host = _QueueName,
QCommand = QueueCmd.Exists,
};
var response = ConsumItem(message, ConnectTimeout);
return(response);// == null ? null : response.ToMessage();
//ReportApi client = new ReportApi(QueueDefaults.QueueManagerPipeName, true);
//return (Message)client.Exec(message, QueueCmd.RemoveQueue);
}
public IQueueItem AddQueue(QProperties qp)
{
var message = new QueueRequest()
{
Host = _QueueName,
QCommand = QueueCmd.AddQueue,
};
message.SetBody(qp.GetEntityStream(false), qp.GetType().FullName);
var response = ConsumItem(message, ConnectTimeout);
return(response);// == null ? null : response.ToMessage();
}
public IQueueItem OperateQueue(QueueCmdOperation cmd)
{
QueueRequest message = new QueueRequest()//queueName, (QueueCmd)(int)cmd)
{
Host = _QueueName,
QCommand = (QueueCmd)(int)cmd,
//Command = (QueueCmd)(int)cmd
};
var response = ConsumItem(message, ConnectTimeout);
return(response);//==null? null: response.ToMessage();
//ReportApi client = new ReportApi(QueueDefaults.QueueManagerPipeName, true);
//return (Message)client.Exec(message, (QueueCmd)(int)cmd);
}
/// <summary>
/// Lists the queues impl core.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="pagination">The pagination.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A <see cref="TaskSequence"/> for listing the queues.</returns>
private TaskSequence ListQueuesImplCore(
string prefix,
QueueListingDetails detailsIncluded,
ResultContinuation continuationToken,
ResultPagination pagination,
Action <ResultSegment <CloudQueue> > setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Queue);
ListingContext listingContext = new ListingContext(prefix, pagination.GetNextRequestPageSize())
{
Marker = continuationToken != null ? continuationToken.NextMarker : null
};
var queueList = new List <CloudQueue>();
var webRequest = QueueRequest.List(this.BaseUri, this.Timeout.RoundUpToSeconds(), listingContext, detailsIncluded);
this.Credentials.SignRequest(webRequest);
var listTask = webRequest.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return(listTask);
string nextMarker;
using (var response = listTask.Result as HttpWebResponse)
{
var parsedResponse = QueueResponse.List(response);
// Materialize the results so that we can close the response
queueList.AddRange(parsedResponse.Queues.Select((Func <QueueEntry, CloudQueue>) this.SelectResponse));
nextMarker = parsedResponse.NextMarker;
}
ResultContinuation newContinuationToken = new ResultContinuation()
{
NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Queue
};
ResultSegment.CreateResultSegment(
setResult,
queueList,
newContinuationToken,
pagination,
this.RetryPolicy,
(paginationArg, continuationArg, resultSegment) =>
this.ListQueuesImplCore(prefix, detailsIncluded, continuationArg, paginationArg, resultSegment));
}
public void AddToQueue(string id, string url, Action <WebRequestCompletedArgs> callback)
{
QueueRequest qr = null;
try
{
qr = requests.First(r => r.Id == id);
}
catch (Exception) { }
if (qr == null)
{
requests.Add(new QueueRequest(id, url, callback));
}
MakeNextRequest();
}
/// <summary>
/// Generates a task sequence for setting the properties of the queue service.
/// </summary>
/// <param name="properties">The queue service properties to set.</param>
/// <returns>A task sequence that sets the properties of the queue service.</returns>
private TaskSequence SetServicePropertiesImpl(ServiceProperties properties)
{
CommonUtils.AssertNotNull("properties", properties);
HttpWebRequest request = QueueRequest.SetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
using (MemoryStream memoryStream = new MemoryStream())
{
try
{
QueueRequest.WriteServiceProperties(properties, memoryStream);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
memoryStream.Seek(0, SeekOrigin.Begin);
CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
this.Credentials.SignRequest(request);
// Get the request stream
Task <Stream> getStreamTask = request.GetRequestStreamAsync();
yield return(getStreamTask);
using (Stream requestStream = getStreamTask.Result)
{
// Upload the service properties.
Task <NullTaskReturn> uploadTask = new InvokeTaskSequenceTask(() => { return((memoryStream as Stream).WriteTo(requestStream)); });
yield return(uploadTask);
// Materialize any exceptions.
NullTaskReturn scratch = uploadTask.Result;
Console.WriteLine(scratch);
}
}
// Get the web response.
Task <WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return(responseTask);
// Materialize any exceptions.
using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
{
}
}
public Response FunctionHandler(QueueRequest request)
{
var container = new CommandContainer();
container.RegisterRequirement <IDbConnection>(() => DbHelper.Connection)
.Register <QueueCommand>(Operation.Queue)
.Register <ReadCommand>(Operation.Read);
try
{
request.Validate();
return(container.ProcessWith(request, request.QueueOperation));
}
catch (Exception ex)
{
throw new LambdaException(HttpCode.BadRequest, ex.Message);
}
}
