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();
}
