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!"); } }
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); } }