private void DispatchAction(RelationKind work, Action succeeded, Action <Exception> failed) { this.IsCommunicating = true; RequestQueue.EnqueueObservable(_source, new UpdateRelationRequest(_target, work)) .Finally(() => this.IsCommunicating = false) .Subscribe(_ => { }, failed, succeeded); }
private void DispatchMute(bool mute, Action succeeded, Action <Exception> failed) { this.IsCommunicating = true; RequestQueue.EnqueueObservable(_source, new UpdateMuteRequest(_target, mute)) .Finally(() => this.IsCommunicating = false) .Subscribe(_ => { }, failed, succeeded); }
/// <summary> /// Creates a new <see cref="RequestThrottlingMiddleware"/>. /// </summary> /// <param name="next">The <see cref="RequestDelegate"/> representing the next middleware in the pipeline.</param> /// <param name="loggerFactory">The <see cref="ILoggerFactory"/> used for logging.</param> /// <param name="options">The <see cref="RequestThrottlingOptions"/> containing the initialization parameters.</param> public RequestThrottlingMiddleware(RequestDelegate next, ILoggerFactory loggerFactory, IOptions <RequestThrottlingOptions> options) { _requestThrottlingOptions = options.Value; if (_requestThrottlingOptions.MaxConcurrentRequests == null) { throw new ArgumentException("The value of 'options.MaxConcurrentRequests' must be specified.", nameof(options)); } if (_requestThrottlingOptions.MaxConcurrentRequests < 0) { throw new ArgumentException("The value of 'options.MaxConcurrentRequests' must be a positive integer.", nameof(options)); } if (_requestThrottlingOptions.RequestQueueLimit < 0) { throw new ArgumentException("The value of 'options.RequestQueueLimit' must be a positive integer.", nameof(options)); } if (_requestThrottlingOptions.OnRejected == null) { throw new ArgumentException("The value of 'options.OnRejected' must not be null.", nameof(options)); } _next = next; _logger = loggerFactory.CreateLogger <RequestThrottlingMiddleware>(); _requestQueue = new RequestQueue( _requestThrottlingOptions.MaxConcurrentRequests.Value, _requestThrottlingOptions.RequestQueueLimit); }
/// <summary> /// The one entry point, this is where requests should be sent /// </summary> public void AddJob(IJobRequest jobRequestObj) { // queue the object and notify the threadProc that there's work to do RequestQueue.Enqueue(jobRequestObj); QueueProcessHandle.Set( ); }
protected sealed override Task <HttpResponseMessage> SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { RequestQueue.Enqueue(request); return(Task.FromResult(ResponseQueue.Dequeue())); }
public static async void Init() { var queue = new RequestQueue(); var google = new Uri("http://www.google.com/"); var songkick = new Uri("http://api.songkick.com/api/3.0/events.json?location=clientip&apikey=G2KCF6q91g23Q6Zh"); Parallel.For(1, 16, async x => { var uri = x % 2 == 0 ? google : songkick; var request = new StringRequest { Uri = uri, }; queue.Add(request); try { var result = await request.GetResultAsync(); Console.WriteLine("received response: {0}", result.Substring(0, 40)); } catch (Exception ex) { Console.WriteLine("handled exception: {0}", ex); } }); }
protected RemoteTunnel(int maxConnections) { if (maxConnections < 1 || maxConnections > 8192) throw new ArgumentException("maxConnections"); MaxConnections = maxConnections; _queue = new RequestQueue(); }
private async Task <TResponse> SendRpcAsyncInternal <TResponse>(string cmd, object payload, Optional <string> evt, RequestOptions options) where TResponse : class { byte[] bytes = null; var guid = Guid.NewGuid(); payload = new API.Rpc.RpcFrame { Cmd = cmd, Event = evt, Args = payload, Nonce = guid }; if (payload != null) { var json = SerializeJson(payload); bytes = Encoding.UTF8.GetBytes(json); } var requestTracker = new RpcRequest <TResponse>(options); _requests[guid] = requestTracker; await RequestQueue.SendAsync(new WebSocketRequest(_webSocketClient, null, bytes, true, options)).ConfigureAwait(false); await _sentRpcMessageEvent.InvokeAsync(cmd).ConfigureAwait(false); return(await requestTracker.Promise.Task.ConfigureAwait(false)); }
private async Task SendGatewayInternalAsync(GatewayOpCode opCode, object payload, RequestOptions options) { CheckState(); //TODO: Add ETF byte[] bytes = null; payload = new SocketFrame { Operation = (int)opCode, Payload = payload }; if (payload != null) { bytes = Encoding.UTF8.GetBytes(SerializeJson(payload)); } options.IsGatewayBucket = true; if (options.BucketId == null) { options.BucketId = GatewayBucket.Get(GatewayBucketType.Unbucketed).Id; } await RequestQueue.SendAsync(new WebSocketRequest(WebSocketClient, bytes, true, opCode == GatewayOpCode.Heartbeat, options)).ConfigureAwait(false); await _sentGatewayMessageEvent.InvokeAsync(opCode).ConfigureAwait(false); #if DEBUG_PACKETS Console.WriteLine($"-> {opCode}:\n{SerializeJson(payload)}"); #endif }
protected virtual void TriggerRelease(Event @event = null) { while (ReleaseQueue.Count > 0) { var release = ReleaseQueue.Peek(); if (release.Request.IsAlive) { if (!RequestQueue.Remove(release.Request)) { throw new InvalidOperationException("Failed to cancel a request."); } BreakOffTime?.Add(Environment.ToDouble(Environment.Now - release.Request.Time)); release.Succeed(); ReleaseQueue.Dequeue(); } else { DoRelease(release); if (release.IsTriggered) { ReleaseQueue.Dequeue(); TriggerWhenAny(); TriggerWhenFull(); TriggerWhenChange(); } else { break; } } } Utilization?.UpdateTo(InUse / (double)Capacity); WIP?.UpdateTo(InUse + RequestQueue.Count); QueueLength?.UpdateTo(RequestQueue.Count); }
private void LazyWriterTimerCallback(object state) { lock (_inLazyWriterMonitor) { try { do { // Console.WriteLine("q: {0}", RequestQueue.RequestCount); List <LogEventInfo> pendingRequests = RequestQueue.DequeueBatch(BatchSize); try { if (pendingRequests.Count == 0) { break; } LogEventInfo[] events = pendingRequests.ToArray(); WrappedTarget.Write(events); } finally { RequestQueue.BatchProcessed(pendingRequests); } } while (_flushAll); } catch (Exception ex) { InternalLogger.Error("Error in lazy writer timer procedure: {0}", ex); } } }
/// <summary> /// 添加到队列 /// </summary> /// <param name="command"></param> public bool Enqueue(ServiceData command) { m_Logger.Debug(string.Format("服务入队。\r\nGuid:{0}。\r\n服务名称:{1}" , command.Command.Guid, command.Command.ServiceFullName)); try { RequestQueue <ServiceData> queue = null; if (m_PriorityQueue.TryGetValue(command.Command.Priority, out queue)) { queue.Enqueue(command); m_Logger.Debug("服务入队结束。"); return(true); } } catch (Exception ex) { m_Logger.Debug("服务入队异常。"); m_Logger.Fatal(string.Concat("服务入队 异常: ", ex.Message)); m_Logger.Fatal(string.Concat("服务入队 异常: ", ex.StackTrace)); } m_Logger.Debug("服务入队失败。"); return(false); }
public void QueueItem(RequestedModel request, string id, RequestType type, FaultType faultType) { //Ensure there is not a duplicate queued item var existingItem = RequestQueue.Custom( connection => { connection.Open(); var result = connection.Query <RequestQueue>("select * from RequestQueue where PrimaryIdentifier = @ProviderId", new { ProviderId = id }); return(result); }).FirstOrDefault(); if (existingItem != null) { // It's already in the queue return; } var queue = new RequestQueue { Type = type, Content = ByteConverterHelper.ReturnBytes(request), PrimaryIdentifier = id, FaultType = faultType }; RequestQueue.Insert(queue); }
void ThreadProc( ) { while (true) { Rock.Mobile.Util.Debug.WriteLine("ThreadProc: Sleeping..."); QueueProcessHandle.WaitOne( ); Rock.Mobile.Util.Debug.WriteLine("ThreadProc: Waking for work"); // while there are requests pending, process them while (RequestQueue.IsEmpty == false) { Rock.Mobile.Util.Debug.WriteLine("ThreadProc: Processing Request"); // get the web request out of the queue RequestUpdateHandle.WaitOne( ); //Wait to make sure no other thread is using the Queue IWebRequestObject requestObj = null; RequestQueue.TryDequeue(out requestObj); //yank it out RequestUpdateHandle.Set( ); // all clear if (requestObj != null) { // execute it requestObj.ProcessRequest( ); } } } }
public async Task QueueItemAsync(RequestedModel request, string id, RequestType type, FaultType faultType, string description = null) { //Ensure there is not a duplicate queued item var existingItem = await RequestQueue.CustomAsync(async connection => { connection.Open(); var result = await connection.QueryAsync <RequestQueue>("select * from RequestFaultQueue where PrimaryIdentifier = @ProviderId", new { ProviderId = id }); return(result); }); if (existingItem.FirstOrDefault() != null) { // It's already in the queue return; } var queue = new RequestQueue { Type = type, Content = ByteConverterHelper.ReturnBytes(request), PrimaryIdentifier = id, FaultType = faultType, Message = description ?? string.Empty }; await RequestQueue.InsertAsync(queue); }
protected virtual void TriggerRequest(Event @event = null) { var current = RequestQueue.First; while (current != null) { var request = current.Value; DoRequest(request); if (request.IsTriggered) { var next = current.Next; RequestQueue.Remove(current); current = next; TriggerWhenEmpty(); TriggerWhenChange(); } else { current = current.Next; } if (Resources.Count == 0) { break; } } Utilization?.UpdateTo(InUse / (double)Capacity); WIP?.UpdateTo(InUse + RequestQueue.Count); QueueLength?.UpdateTo(RequestQueue.Count); }
protected virtual void TriggerRelease(Event @event = null) { while (ReleaseQueue.Count > 0) { var release = ReleaseQueue.Peek(); if (release.Request.IsAlive) { if (!RequestQueue.TryRemove((PreemptiveRequest)release.Request)) { throw new InvalidOperationException("Failed to cancel a request."); } release.Succeed(); ReleaseQueue.Dequeue(); } else { DoRelease(release); if (release.IsTriggered) { ReleaseQueue.Dequeue(); TriggerWhenAny(); TriggerWhenFull(); TriggerWhenChange(); } else { break; } } } }
private void PlaySystemQueueCallback(object obj) { // trace callback TraceHelper.AddMessage(String.Format("Play System Queue Callback: {0}", obj == null ? "null" : "success")); // if the operation was successful, continue the refresh cycle if (obj != null) { // dequeue the current record (which removes it from the queue) RequestQueue.RequestRecord record = RequestQueue.DequeueRequestRecord(RequestQueue.SystemQueue); // parse out request record info and trace the details string typename; string reqtype; string id; string name; RequestQueue.RetrieveRequestInfo(record, out typename, out reqtype, out id, out name); TraceHelper.AddMessage(String.Format("Request details: {0} {1} {2} (id {3})", reqtype, typename, name, id)); // don't need to process the object since the folder will be refreshed at the end // of the cycle anyway // since the operation was successful, continue to drain the queue PlayQueue(RequestQueue.SystemQueue); } else { // refresh cycle interrupted - still need to signal the SyncComplete event if it was set if (SyncComplete != null) SyncComplete(this, new SyncCompleteEventArgs(SyncCompleteArg)); } }
public override RequestQueue Execute(SensorRepository repSensors, RequestQueue LastWinner) { bool iWon = LastWinner != null && LastWinner.BehaviorName == m_Name; RequestQueue requests = new RequestQueue(m_Name); // Ignore if powered off or during a spin if (!repSensors.SensorValueBool("IsPower") || repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_SpinCW || repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_SpinCCW) return requests; if (repSensors.SensorValueInt("DistFwd") <= 8) { if (iWon || repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Halt) { // Halt already sent so create a NOP request to retain control requests.Enqueue(new Request() { Name = "NOP", Channel = "NA", Command = "NP" }); } else { // Halt requests.Enqueue(new Request() { Name = "Halt", Channel = "Drive", Command = "HL" }); } } return requests; }
public WebApiApplication() { base.BeginRequest += delegate { RequestQueue.Instance().Enqueue(HttpContext.Current.Request); }; }
public override RequestQueue Execute(SensorRepository repSensors, RequestQueue LastWinner) { bool iWon = LastWinner != null && LastWinner.BehaviorName == m_Name; RequestQueue requests = new RequestQueue(m_Name); if (repSensors.SensorValueBool("IsPower") && repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Fwd) { if(repSensors.SensorValueInt("DistL30") < repSensors.SensorValueInt("DistR30")) { if(repSensors.SensorValueInt("DistL30") < 20 || (iWon && repSensors.SensorValueInt("DistL30") < 24)) { requests.Enqueue(new Request() { Name = "Turn Right", Channel = "Drive", Command = "RT" }); } } else { if(repSensors.SensorValueInt("DistR30") < 20 || (iWon && repSensors.SensorValueInt("DistR30") < 24)) { requests.Enqueue(new Request() { Name = "Turn Left", Channel = "Drive", Command = "LF" }); } } } return requests; }
public static async void Init() { var logger = new DebugLogger(); var queue = new RequestQueue( logger, new Cache(), new Network(logger, new WebRequestClient()), new ResponseDelivery()); var google = new Uri("http://www.google.com/"); var songkick = new Uri("http://api.songkick.com/api/3.0/events.json?location=clientip&apikey=G2KCF6q91g23Q6Zh"); var jsontest = new Uri("http://date.jsontest.com"); Parallel.For(0, 32, async x => { var uri = x % 2 == 0 ? google : songkick; var request = new StringRequest { Uri = uri, }; queue.Add(request); try { var result = await request.GetResponseAsync(); } catch (Exception ex) { Console.WriteLine("handled exception: {0}", ex); } }); }
public OutputHandler(RequestQueue queue, ServerConnection connection) { base.Queue = queue; base.SetMethod(_ProcessingMethod); this.Connection = connection; }
public override IPAction ExecuteRest(SensorRepository repSensors, RequestQueue requests, bool iWon) { if (repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Halt) return IPAction.Increment; else return IPAction.DoRest; }
public override IPAction ExecuteRest(SensorRepository repSensors, RequestQueue requests, bool iWon) { int currentDistance = repSensors.SensorValueInt("Encoder1"); if (currentDistance == m_RequestedDistance) { // All done, move to next operator m_RequestedDistance = m_DesiredDistance; return IPAction.Increment; } else if (repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Halt && currentDistance > 0) { // Something stopped us so start over and request the remaining distance m_RequestedDistance = m_DesiredDistance - currentDistance; return IPAction.DoFirst; } else if (repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Fwd && m_DesiredHeading != -1) { // Heading hold int herr = HeadingError(repSensors.SensorValueInt("Heading")); int corr = m_HhPID.Calculate(herr); if (corr > 0) requests.Enqueue(new Request() { Name = "Right Turn" + corr.ToString(), Channel = "Drive", Command = "RX" + corr.ToString() }); else if (corr < 0) requests.Enqueue(new Request() { Name = "Left Turn" + Math.Abs(corr).ToString(), Channel = "Drive", Command = "LX" + Math.Abs(corr).ToString() }); } return IPAction.DoRest; }
void DisconnectUserButton_Click(object sender, EventArgs e) { // if we're connected, this is a disconnect request if (IsConnected) { // if the request queue isn't empty, warn the user if (RequestQueue.GetRequestRecord(RequestQueue.UserQueue) != null) { MessageBoxResult result = MessageBox.Show( "some of the changes you made on the phone haven't made it to your Zaplify account yet. " + "click ok to disconnect now and potentially lose these changes, or cancel the operation", "disconnect now?", MessageBoxButton.OKCancel); if (result == MessageBoxResult.Cancel) { return; } } // process the disconnect App.ViewModel.User = null; App.ViewModel.EraseAllData(); WebServiceHelper.Disconnect(); // reset the settings page accountOperationSuccessful = false; dvc.NavigationController.PopViewControllerAnimated(true); ResignFirstResponder(); CreateRoot(); dvc.ReloadData(); } }
public static void Main(string[] args) { var log = new ConsoleLog(); using (var requestQueue = new RequestQueue()) { var server = new PluginServer(log, requestQueue); server.Start(); while (true) { while (requestQueue.Requests.TryDequeue(out Request request)) { log.WriteLine("dequeued: " + request.Message); requestQueue.Replys.Add( new Request(request.ClientStream, $"Got {request.Message.Length} bytes, thanks!")); } Thread.Sleep(50); } // server.Start(waitForFinish: true); } }
protected virtual void TriggerRequest(Event @event = null) { var current = RequestQueue.First; while (current != null) { var request = current.Value; DoRequest(request); if (request.IsTriggered) { var next = current.Next; RequestQueue.Remove(current); current = next; TriggerWhenEmpty(); TriggerWhenChange(); } else { current = current.Next; } if (Resources.Count == 0) { break; } } }
IEnumerator PostQueue(RequestQueue requsetInfo) { UnityWebRequest request = UnityWebRequest.Post(requsetInfo.url, requsetInfo.postDict); yield return(request.SendWebRequest()); RequestInfo info = new RequestInfo(); if (request.isDone) { if (request.isHttpError || request.isNetworkError) { info.error = true; } else { info.requsetStr = request.downloadHandler.text; } } if (requsetInfo.callback != null) { requsetInfo.callback.Invoke(info); } }
private void DispatchRetweetSuppression(bool suppress, Action succeeded, Action <Exception> failed) { this.IsCommunicating = true; RequestQueue.EnqueueObservable(_source, new UpdateFriendshipsRequest(_target, null, suppress)) .Finally(() => this.IsCommunicating = false) .Subscribe(_ => { }, failed, succeeded); }
public static RequestQueue NewRequestQueue(Context context, IHttpStack stack, int maxDiskCacheBytes) { //组织缓存根目录 var cacheDir = Directory.CreateDirectory(context.CacheDir.Path + "/" + DEFAULT_CACHE_DIR); String userAgent = "volley/0"; try { String packageName = context.PackageName; var info = context.PackageManager.GetPackageInfo(packageName, 0); userAgent = packageName + "/" + info.VersionCode; } catch (Android.Content.PM.PackageManager.NameNotFoundException) { } if (stack == null) { stack = new HttpClientStack(); } INetwork network = new BasicNetwork(stack); RequestQueue queue; if (maxDiskCacheBytes <= -1) { queue = new RequestQueue(new DiskBasedCache(cacheDir), network); } else { queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network); } return(queue); }
public override void CommitEditingStyle(UITableView tableView, UITableViewCellEditingStyle editingStyle, NSIndexPath indexPath) { if (editingStyle == UITableViewCellEditingStyle.Delete) { // get the folder from the local collection, and refresh it from the viewmodel in case // it changed underneath us Folder folder = controller.Folders[indexPath.Row]; if (App.ViewModel.Folders.Any(f => f.ID == folder.ID)) { folder = App.ViewModel.Folders.Single(f => f.ID == folder.ID); } // enqueue the Web Request Record RequestQueue.EnqueueRequestRecord(RequestQueue.UserQueue, new RequestQueue.RequestRecord() { ReqType = RequestQueue.RequestRecord.RequestType.Delete, Body = folder }); // save the changes to local storage App.ViewModel.FolderDictionary.Remove(folder.ID); App.ViewModel.Folders.Remove(folder); StorageHelper.WriteFolders(App.ViewModel.Folders); StorageHelper.DeleteFolder(folder); // refresh the table UI controller.SortFolders(); tableView.DeleteRows(new [] { indexPath }, UITableViewRowAnimation.Fade); } }
private void ImportListPopup_ImportButton_Click(object sender, RoutedEventArgs e) { Item target = ImportListPopupListPicker.SelectedItem as Item; if (target == null) { return; } // create a copy of the item and attach all the non-list children to its Items collection Item targetList = new Item(target, false); targetList.Items = App.ViewModel.Items.Where(i => i.ParentID == target.ID && i.IsList != true).ToObservableCollection(); // add the items in the template to the existing folder foreach (Item i in targetList.Items) { DateTime now = DateTime.UtcNow; // create the new item Item item = new Item(i) { ID = Guid.NewGuid(), FolderID = folder.ID, ParentID = list.ID, Created = now, LastModified = now }; // recreate the itemtags (they must be unique) if (item.ItemTags != null && item.ItemTags.Count > 0) { foreach (var tt in item.ItemTags) { tt.ID = Guid.NewGuid(); } } // enqueue the Web Request Record RequestQueue.EnqueueRequestRecord(RequestQueue.UserQueue, new RequestQueue.RequestRecord() { ReqType = RequestQueue.RequestRecord.RequestType.Insert, Body = item }); // add the item to the folder and list folder.Items.Add(item); list.Items.Add(item); } // render the list ListHelper.RenderList(list); // save the changes to local storage StorageHelper.WriteFolder(folder); // trigger a sync with the Service App.ViewModel.SyncWithService(); // close the popup importPopupOpen = false; ImportListPopup.IsOpen = false; }
public virtual PreemptiveRequest Request(double priority = 1, bool preempt = false) { var request = new PreemptiveRequest(Environment, TriggerRelease, DisposeCallback, priority, preempt); RequestQueue.Enqueue(request); TriggerRequest(); return(request); }
public virtual ResourcePoolRequest Request(Func <object, bool> filter = null) { var request = new ResourcePoolRequest(Environment, TriggerRelease, DisposeCallback, filter ?? TrueFunc); RequestQueue.AddLast(request); TriggerRequest(); return(request); }
/// <summary> /// Initializes object with default values. /// </summary> public ServerBase() { m_messageContext = new ServiceMessageContext(); m_serverError = new ServiceResult(StatusCodes.BadServerHalted); m_hosts = new List<ServiceHost>(); m_listeners = new List<ITransportListener>(); m_endpoints = null; m_requestQueue = new RequestQueue(this, 10, 100, 1000); }
public override void Send(RequestQueue requests) { lock (m_lockObj) { foreach (Request request in requests) { m_Port.WriteLine(">" + m_RobotID + request.Command); } } }
public override NavOperator.IPAction ExecuteFirst(SensorRepository repSensors, RequestQueue requests, bool iWon) { if (!iWon) { requests.Enqueue(new Request() { Name = "Set Speed" + m_Speed.ToString(), Channel = "Drive", Command = "S" + m_Speed.ToString() }); return IPAction.DoFirst; } else return IPAction.Increment; }
public override IPAction ExecuteFirst(SensorRepository repSensors, RequestQueue requests, bool iWon) { if (!iWon) { requests.Enqueue(new Request() { Name = "Halt/Reset", Channel = "Drive", Command = "EH" }); requests.Enqueue(new Request() { Name = "Fwd " + m_RequestedDistance, Channel = "Drive", Command = "FX" + m_RequestedDistance }); return IPAction.DoFirst; } else return IPAction.DoRest; }
public override NavOperator.IPAction ExecuteFirst(SensorRepository repSensors, RequestQueue requests, bool iWon) { if (!iWon) { // Halt requests.Enqueue(new Request() { Name = "Halt", Channel = "Drive", Command = "HL" }); return IPAction.DoFirst; } else return IPAction.Increment; }
public override RequestQueue Execute(SensorRepository repSensors, RequestQueue LastWinner) { bool iWon = LastWinner != null && LastWinner.BehaviorName == m_Name; RequestQueue requests = new RequestQueue(m_Name); if (!iWon && repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Halt) { requests.Enqueue(new Request() { Name = "Halt/Reset", Channel = "Drive", Command = "EH" }); requests.Enqueue(new Request() { Name = "Fwd " + m_CruiseDistance, Channel = "Drive", Command = "FX" + m_CruiseDistance }); } return requests; }
public override RequestQueue Execute(SensorRepository repSensors, RequestQueue LastWinner) { bool iWon = LastWinner != null && LastWinner.BehaviorName == m_Name; RequestQueue requests = new RequestQueue(m_Name); if (repSensors.SensorValueBool("IsPower") && repSensors.SensorValueInt("Direction") == (int)Cruise.MoveDir.Mov_Fwd && m_DesiredHeading != -1) { int herr = HeadingError(repSensors.SensorValueInt("Heading")); int corr = m_HhPID.Calculate(herr); if(corr > 0) requests.Enqueue(new Request() { Name = "Right Turn" + corr.ToString(), Channel = "Drive", Command = "RX" + corr.ToString() }); else if (corr < 0) requests.Enqueue(new Request() { Name = "Left Turn" + Math.Abs(corr).ToString(), Channel = "Drive", Command = "LX" + Math.Abs(corr).ToString() }); } return requests; }
private static void RetrieveRequestInfo(RequestQueue.RequestRecord req, out string typename, out string reqtype, out string id, out string name) { typename = req.BodyTypeName; reqtype = ""; id = ""; name = ""; switch (req.ReqType) { case RequestQueue.RequestRecord.RequestType.Delete: reqtype = "Delete"; id = ((ClientEntity)req.Body).ID.ToString(); name = ((ClientEntity)req.Body).Name; break; case RequestQueue.RequestRecord.RequestType.Insert: reqtype = "Insert"; id = ((ClientEntity)req.Body).ID.ToString(); name = ((ClientEntity)req.Body).Name; break; case RequestQueue.RequestRecord.RequestType.Update: reqtype = "Update"; switch (req.BodyTypeName) { case "Tag": name = ((List<Tag>)req.Body)[0].Name; id = ((List<Tag>)req.Body)[0].ID.ToString(); break; case "Item": name = ((List<Item>)req.Body)[0].Name; id = ((List<Item>)req.Body)[0].ID.ToString(); break; case "Folder": name = ((List<Folder>)req.Body)[0].Name; id = ((List<Folder>)req.Body)[0].ID.ToString(); break; default: name = "(unrecognized entity)"; break; } break; default: reqtype = "Unrecognized"; break; } }
public override IPAction ExecuteFirst(SensorRepository repSensors, RequestQueue requests, bool iWon) { if (!iWon) { requests.Enqueue(new Request() { Name = "Halt/Reset", Channel = "Drive", Command = "EH" }); // Calculate how many degrees to spin to get to desired heading int herr = HeadingError(repSensors.SensorValueInt("Heading")); m_RequestedCorrection = Math.Abs(herr); if (herr > 0) requests.Enqueue(new Request() { Name = "SpinCCW " + m_RequestedCorrection.ToString(), Channel = "Drive", Command = "LX" + m_RequestedCorrection.ToString() }); else if (herr < 0) requests.Enqueue(new Request() { Name = "SpinCW " + m_RequestedCorrection.ToString(), Channel = "Drive", Command = "RX" + m_RequestedCorrection.ToString() }); else return IPAction.Increment; return IPAction.DoFirst; } else return IPAction.DoRest; }
public override RequestQueue Execute(SensorRepository repSensors, RequestQueue LastWinner) { bool iWon = LastWinner != null && LastWinner.BehaviorName == m_Name; RequestQueue requests = new RequestQueue(m_Name); if (m_InstPtr < m_Route.Count) { NavOperator.IPAction action; if (m_IsFirst) action = m_Route[m_InstPtr].ExecuteFirst(repSensors, requests, iWon); else action = m_Route[m_InstPtr].ExecuteRest(repSensors, requests, iWon); switch (action) { case NavOperator.IPAction.Increment: m_InstPtr++; m_IsFirst = true; break; case NavOperator.IPAction.Reset: m_InstPtr = 0; m_IsFirst = true; break; case NavOperator.IPAction.DoFirst: m_IsFirst = true; break; case NavOperator.IPAction.DoRest: m_IsFirst = false; break; } } return requests; }
public abstract void Send(RequestQueue requests);
public abstract RequestQueue Execute(SensorRepository repSensors, RequestQueue LastWinner);
public abstract IPAction ExecuteRest(SensorRepository repSensors, RequestQueue requests, bool iWon);
private void SendRequests(RequestQueue requests) { // Send requests out each channel Dictionary<string, CommLink>.ValueCollection valueColl = m_Channels.Values; foreach (CommLink comm in valueColl) { RequestQueue requestsChannel = new RequestQueue(requests.BehaviorName); foreach (Request req in requests) { if (req.Channel == comm.Name) { requestsChannel.Enqueue(req); m_LogEntries.AddEntry(new ActivityLogEntry(requestsChannel.BehaviorName + " sent " + req.Name + " (" + req.Command + ") via the " + req.Channel + " channel")); } } if(requestsChannel.Count > 0) comm.Send(requestsChannel); } }
internal IpcServerHandler(IpcPort port, RequestQueue requestQueue, Stream stream) : base (null, requestQueue, stream) { _requestQueue = requestQueue; _port = port; _stream = stream; }
} // TcpSocketHandler public TcpSocketHandler(Socket socket, RequestQueue requestQueue, Stream stream) : base(socket, requestQueue, stream) { } // TcpSocketHandler
internal Request(RequestQueue _enclosing) { this._enclosing = _enclosing; }
private void ProcessBehaviorsTask(RobotSpecification specRobot) { while (true) { if (m_tsCancel.IsCancellationRequested) { m_LogEntries.AddEntry(new ActivityLogEntry("Behavior Task stopped")); break; } else { try { SensorRepository sr; if (m_SensorReadings.TryTake(out sr, -1, m_tsCancel.Token)) { m_LogEntries.AddEntry(new ActivityLogEntry(ActivityLogEntry.LogEntryType.SensorData, "Get sensor data", sr)); // Run each Behavior in order of priority if (m_RunBehaviors) { foreach (Behavior behavior in m_Behaviors) { // Execute the behavior and enqueue any requests it may have generated RequestQueue requests = behavior.Execute(sr, m_WinningRequests); if (requests != null && requests.Count > 0) m_RequestQueueQueue.Enqueue(requests); } } // Arbitrate and send winning behavior's requests if (m_RequestQueueQueue.Count > 0) { // Since behaviors are executed in priority order the highest will always be the first in the request queue queue m_WinningRequests = m_RequestQueueQueue.Dequeue(); m_LastWinnerName = m_WinningRequests.BehaviorName; // Send each request out the selected comm link SendRequests(m_WinningRequests); // Clear out the queue for the next time m_RequestQueueQueue.Clear(); } else m_WinningRequests = null; } } catch (Exception ex) { m_LogEntries.AddEntry(new ActivityLogEntry("Exception in Behavior Task: " + ex.Message)); } } } }
TcpReadingStream _requestStream; // the request stream internal TcpServerSocketHandler(Socket socket, RequestQueue requestQueue) : base(socket, requestQueue) { _connectionId = Interlocked.Increment(ref _connectionIdCounter); } // TcpServerSocketHandler
public ImageLoader(RequestQueue queue, IImageCache imageCache) { this.mRequestQueue = queue; this.mCache = imageCache; }
} // TcpSocketHandler public TcpSocketHandler(Socket socket, RequestQueue requestQueue) : base(socket, requestQueue) { } // TcpSocketHandler
/// <summary> /// Initializes the request queue. /// </summary> /// <param name="configuration">The configuration.</param> protected void InitializeRequestQueue(ApplicationConfiguration configuration) { // set suitable defaults. int minRequestThreadCount = 10; int maxRequestThreadCount = 1000; int maxQueuedRequestCount = 2000; if (configuration.ServerConfiguration != null) { minRequestThreadCount = configuration.ServerConfiguration.MinRequestThreadCount; maxRequestThreadCount = configuration.ServerConfiguration.MaxRequestThreadCount; maxQueuedRequestCount = configuration.ServerConfiguration.MaxQueuedRequestCount; } else if (configuration.DiscoveryServerConfiguration != null) { minRequestThreadCount = configuration.DiscoveryServerConfiguration.MinRequestThreadCount; maxRequestThreadCount = configuration.DiscoveryServerConfiguration.MaxRequestThreadCount; maxQueuedRequestCount = configuration.DiscoveryServerConfiguration.MaxQueuedRequestCount; } // ensure configuration errors don't render the server inoperable. if (minRequestThreadCount < 1) { minRequestThreadCount = 1; } if (maxRequestThreadCount < minRequestThreadCount) { maxRequestThreadCount = minRequestThreadCount; } if (maxQueuedRequestCount < 100) { maxQueuedRequestCount = 100; } if (m_requestQueue != null) { m_requestQueue.Dispose(); } m_requestQueue = new RequestQueue(this, minRequestThreadCount, maxRequestThreadCount, maxQueuedRequestCount); }
public override IPAction ExecuteFirst(SensorRepository repSensors, RequestQueue requests, bool iWon) { return IPAction.Reset; }
public override IPAction ExecuteRest(SensorRepository repSensors, RequestQueue requests, bool iWon) { throw new NotImplementedException(); }
public override void Send(RequestQueue requests) { throw new NotImplementedException(); }