public DataRequest(RequestPriority prio, string method = HttpConst.HttpMethod_Get)
: base(prio)
{
httpMethod = method;
//Set uri in child class
RequestStream = null;
}
// ////////////////////////////////////////////////////////////
// Sync
// ////////////////////////////////////////////////////////////
public async Task SyncTimeline(long?forUserId, RequestPriority priority)
{
if (forUserId == null)
{
/* Pooling timeline requests is tricky and would require the pool to return the user
* who actually made the request[1], since some events are restricted per-user.
* Instead, find a random user who should have access, and hope their token is still valid.
*
* [1] Technically, it kind of does via the metadata, but that's grossssssss.
*/
var users = await GetUsersWithAccess();
if (!users.Any())
{
return;
}
forUserId = users[_rand.Next(users.Length)];
}
var ghc = _grainFactory.GetGrain <IGitHubActor>(forUserId.Value);
var updater = new DataUpdater(_contextFactory, _mapper);
try {
await SyncIssueTimeline(ghc, forUserId.Value, updater);
} catch (GitHubRateException) {
// nothing to do
}
await updater.Changes.Submit(_queueClient, urgent : true);
// Save metadata and other updates
await Save();
}
public override bool InternalOpen(string drvName, RequestPriority priority, IAttributes attributes, IParameters parameters)
{
try
{
lock (_openSync)
{
if (IsConnected(_client))
{
return(true);
}
_client = new TcpClient();
_client.ReceiveTimeout = readTimeout;
_client.SendTimeout = writeTimeout;
_client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
SetKeepAliveValues(_client.Client, true, _keepAliveTime, 5000);
_client.Connect(_host, _port);
_logger.Debug("InternalOpen", "InternalOpen({0}:{1}, keepAlive:{2})", _host, _port, _keepAliveTime);
}
return(true);
}
catch (Exception ex)
{
_logger.Error("InternalOpen", ex);
Thread.Sleep(_reconnectTimeout);
}
return(false);
}
public Task RegisterDriver(DriverCompanyDM driverCompany, RequestPriority priority)
{
var company = Mapper.Map <DriverCompanyEM>(driverCompany);
var api = GetApi(priority);
return(api.RegisterDriver(company));
}
public T GetApi(RequestPriority priority)
{
switch (priority)
{
case RequestPriority.UserInitiated:
{
return(UserInitiated);
}
case RequestPriority.Background:
{
return(Background);
}
case RequestPriority.Speculative:
{
return(Speculative);
}
default:
{
return(UserInitiated);
}
}
}
private bool UnregisterReceiver([NotNull] IReceiver receiver, out RequestPriority priority)
{
if (receiver == null)
{
throw new ArgumentNullException(nameof(receiver));
}
lock (_receivers)
{
// iterate P<DT, List<T<IR, RP>>>
foreach (var pair in _receivers)
{
// iterate T<IR, RP>
foreach (var tuple in pair.Value)
{
if (tuple.Item1 == receiver)
{
pair.Value.Remove(tuple);
if (pair.Value.Count == 0)
{
// remove empty list
_receivers.Remove(pair.Key);
}
priority = tuple.Item2;
return(true);
}
}
}
}
// dummy value
priority = RequestPriority.Low;
return(false);
}
private void RegisterReceiver(DateTime key, [NotNull] IReceiver receiver, RequestPriority priority)
{
if (receiver == null)
{
throw new ArgumentNullException(nameof(receiver));
}
if (_tokenSource.Token.IsCancellationRequested)
{
return;
}
bool firstChanged;
lock (_receivers)
{
if (!_receivers.ContainsKey(key))
{
_receivers[key] = new List <Tuple <IReceiver, RequestPriority> >();
}
_receivers[key].Add(Tuple.Create(receiver, priority));
firstChanged = _receivers.Values[0] == _receivers[key];
}
if (firstChanged)
{
// registered item is needed to call before than previous first item.
_re.Set();
}
}
private bool UnregisterReceiver([NotNull] IReceiver receiver, out RequestPriority priority)
{
if (receiver == null) throw new ArgumentNullException(nameof(receiver));
lock (_receivers)
{
// iterate P<DT, List<T<IR, RP>>>
foreach (var pair in _receivers)
{
// iterate T<IR, RP>
foreach (var tuple in pair.Value)
{
if (tuple.Item1 == receiver)
{
pair.Value.Remove(tuple);
if (pair.Value.Count == 0)
{
// remove empty list
_receivers.Remove(pair.Key);
}
priority = tuple.Item2;
return true;
}
}
}
}
// dummy value
priority = RequestPriority.Low;
return false;
}
private void Receive([NotNull] IReceiver receiver, RequestPriority priority)
{
if (receiver == null)
{
throw new ArgumentNullException(nameof(receiver));
}
_factories.Run(async() =>
{
var token = _tokenSource.Token;
var span = await receiver.ExecuteAsync(token).ConfigureAwait(false);
var now = DateTime.Now;
if (token.IsCancellationRequested)
{
return;
}
if (span.Ticks > (DateTime.MaxValue - now).Ticks)
{
// register as MaxValue
RegisterReceiver(DateTime.MaxValue, receiver, priority);
}
else
{
RegisterReceiver(now + span, receiver, priority);
}
}, (int)priority, _tokenSource.Token);
}
public int UpdateRow(DbTransaction pTran, RequestPriority RequestPriority, bool CreateTransaction)
{
int intRow = 0;
DbTransaction objTran = pTran;
Exception exception = null;
try
{
if (pTran == null && CreateTransaction == true)
{
objTran = RequestPriorityData.CreateTransaction();
}
intRow = RequestPriorityData.UpdateRow(objTran, RequestPriority);
if (pTran == null && objTran != null && CreateTransaction == true)
{
RequestPriorityData.CommitTransaction(objTran, true);
objTran = null;
}
}
catch (Exception EX)
{
exception = EX;
if (pTran == null && objTran != null && CreateTransaction == true)
{
RequestPriorityData.RollbackTransaction(objTran, true);
objTran = null;
}
}
finally
{
}
return(intRow);
}
public JobSortKey(RequestPriority priority, JobSortFlags flags, DateTime lastUpdate, Guid requestGuid)
{
this.priority = priority;
this.flags = flags;
this.lastUpdate = lastUpdate;
this.requestGuid = requestGuid;
}
public async Task Invoke_ShouldRestoreRequestPriority(RequestPriority requestPriority)
{
var req = Request.Get("/context?name=request-priority");
var priority = await Client.SendAsync(req, RequestParameters.Empty.WithPriority(requestPriority))
.GetResponseOrDie <RequestPriority>();
priority.Should().Be(requestPriority);
}
public async Task <CargoCatalogItemsDM> GetAvailableParams(RequestPriority priority)
{
var api = GetApi(priority);
var externalParams = await api.GetAvailableParams();
return(MappingService.Map <CargoCatalogItemsDM>(externalParams));
}
public async Task <ICollection <AddressDM> > GetAddresses(string request, RequestPriority priority)
{
var api = GetApi(priority);
var addresses = await api.GetAddress(request);
return(MappingService.Map <ICollection <AddressEM>, ICollection <AddressDM> >(addresses));
}
public async Task Create(BookingDM booking, RequestPriority priority)
{
var api = GetApi(priority);
var externalBooking = MappingService.Map <BookingEM>(booking);
await api.Create(externalBooking);
}
public RequestInfo(TimeSpan requestTimeout, RequestPriority requestPriority, string clientApplicationIdentity, IPAddress clientIpAddress)
{
Timeout = requestTimeout;
Budget = TimeBudget.StartNew(Timeout.Cut(100.Milliseconds(), 0.05));
Priority = requestPriority;
ClientApplicationIdentity = clientApplicationIdentity;
ClientIpAddress = clientIpAddress;
}
public async Task <BookingResponseDM> Calculate(BookingRequestDM request, RequestPriority priority)
{
var api = GetApi(priority);
var externalRequest = MappingService.Map <BookingRequestEM>(request);
var externalResponse = await api.Calculate(externalRequest);
return(MappingService.Map <BookingResponseDM>(externalResponse));
}
public void RegisterReceiver([NotNull] IReceiver receiver, RequestPriority priority = RequestPriority.Middle)
{
if (receiver == null)
{
throw new ArgumentNullException(nameof(receiver));
}
AssertNotDisposed();
RegisterReceiver(DateTime.Now, receiver, priority);
}
public void UpdatePriority(TItem resourcePackage, RequestPriority newPriority)
{
if (Priorities[resourcePackage] == newPriority)
{
return;
}
Packages.Remove(resourcePackage);
Enqueue(resourcePackage, newPriority);
}
public T Get <T>(RequestPriority priority)
{
var type = typeof(T);
var types = typeof(MockAPIManager).Assembly.GetTypes();
var creatingType = types.First(t => t.GetInterface((typeof(T).FullName)) != null);
var instance = (T)Activator.CreateInstance(creatingType);
return(instance);
}
public T Get <T>(RequestPriority priority)
{
var messageHandler = new RateLimitedHttpMessageHandler(BaseHandler, (Priority)priority);
var client = new HttpClient(messageHandler)
{
BaseAddress = new Uri(BaseAddress)
};
return(RestService.For <T>(client));
}
public int DeleteRow(DbTransaction pTran, RequestPriority RequestPriority)
{
int intRows = 0;
DbParameter[] Parameters = new DbParameter[1];
Parameters[0] = _getIdParameter(RequestPriority.Id, ParameterDirection.Input);
intRows = ExecuteNonQuery(pTran, "[Lookups].[DeleteRequestPriority]", Parameters);
return(intRows);
}
public async Task <VehicleParametersDM> GetVehiclesParams(RequestPriority priority)
{
var result = new VehicleParametersDM();
var api = GetApi(priority);
var vehicleParams = await api.GetVehicleParams();
Mapper.Map(vehicleParams, result);
return(result);
}
public RequestPriorityList SelectRows(DbTransaction pTran, System.Int32?Id, System.String name, System.String nameAr)
{
RequestPriorityList RequestPriorityList = new RequestPriorityList();
Exception exception = null;
DbParameter[] Parameters = new DbParameter[3];
Parameters[0] = _getIdParameter(Id, ParameterDirection.Input);
Parameters[1] = _getnameParameter(name, ParameterDirection.Input);
Parameters[2] = _getnameArParameter(nameAr, ParameterDirection.Input);
DbDataReader Dr = ExecuteReader(pTran, "[Lookups].[SelectRequestPriority]", Parameters);
try
{
if (Dr != null)
{
while (Dr.Read())
{
RequestPriority RequestPriority = new RequestPriority();
if (Dr["Id"] != DBNull.Value)
{
RequestPriority.Id = (System.Int32)Dr["Id"];
}
if (Dr["name"] != DBNull.Value)
{
RequestPriority.name = (System.String)Dr["name"];
}
if (Dr["nameAr"] != DBNull.Value)
{
RequestPriority.nameAr = (System.String)Dr["nameAr"];
}
RequestPriorityList.FillRow(RequestPriority);
RequestPriority = null;
}
}
}
catch (Exception Ex)
{
exception = Ex;
}
finally
{
if (Dr != null)
{
if (Dr.IsClosed == false)
{
Dr.Close();
}
Dr = null;
}
}
return(RequestPriorityList);
}
private GitHubRequest(HttpMethod method, string path, GitHubCacheDetails opts, RequestPriority priority)
{
if (path.IsNullOrWhiteSpace() || path.Contains('?'))
{
throw new ArgumentException($"path must be non null and cannot contain query parameters. provided: {path}", nameof(path));
}
Method = method;
Path = path;
Priority = priority;
CacheOptions = opts;
}
public void SetPriority(RequestPriority newPriority)
{
Priority = newPriority;
foreach (var resourcePackage in RequestedNetworkResourceList)
{
World.ResourceManager.UpdateRequestPriority(resourcePackage, Priority);
}
foreach (var resourcePackage in ProvidedResourceList)
{
World.ResourceManager.UpdateProvisionPriority(resourcePackage, Priority);
}
}
public void UpdateProvisionPriority(ResourcePackage resourcePackage, RequestPriority priority)
{
var provisions = Provisions.ToArray();
foreach (var provision in provisions)
{
if (provision == resourcePackage)
{
Provisions.UpdatePriority(provision, priority);
}
}
}
public void UpdateRequestPriority(ResourcePackage resourcePackage, RequestPriority priority)
{
var requests = Requests.ToArray();
foreach (var request in requests)
{
if (request == resourcePackage)
{
Requests.UpdatePriority(request, priority);
}
}
}
public void Should_set_request_priority(RequestPriority priority)
{
FlowingContext.Globals.Set <RequestPriority?>(priority);
module.ExecuteAsync(
context,
requestContext =>
{
requestContext.Parameters.Priority.Should().Be(priority);
Assert.Pass();
return(null);
})
.GetAwaiter()
.GetResult();
}
private static RequestPriorityDTO fillRequestPriorityDTObyRequestPriorityID(int?requestPriorityID)
{
RequestPriorityDTO _RequestPriorityDTO = default(RequestPriorityDTO);
RequestPriority _RequestPriority = _RequestPriorityList.FirstOrDefault(i => i.Id == requestPriorityID.Value);
if (_RequestPriority != default(RequestPriority))
{
_RequestPriorityDTO = new RequestPriorityDTO();
_RequestPriorityDTO.Id = _RequestPriority.Id;
_RequestPriorityDTO.name = _RequestPriority.name;
_RequestPriorityDTO.nameAr = _RequestPriority.nameAr;
}
return(_RequestPriorityDTO);
}
public int InsertRow(DbTransaction pTran, RequestPriority RequestPriority)
{
int intRows = 0;
DbParameter[] Parameters = new DbParameter[3];
Parameters[0] = _getIdParameter(RequestPriority.Id, ParameterDirection.Output);
Parameters[1] = _getnameParameter(RequestPriority.name, ParameterDirection.Input);
Parameters[2] = _getnameArParameter(RequestPriority.nameAr, ParameterDirection.Input);
intRows = ExecuteNonQuery(pTran, "[Lookups].[InsertRequestPriority]", Parameters);
if (Parameters[0].Value != DBNull.Value)
{
RequestPriority.Id = (System.Int32)Parameters[0].Value;
}
return(intRows);
}
private void RegisterReceiver(DateTime key, [NotNull] IReceiver receiver, RequestPriority priority)
{
if (receiver == null) throw new ArgumentNullException(nameof(receiver));
if (_tokenSource.Token.IsCancellationRequested) return;
bool firstChanged;
lock (_receivers)
{
if (!_receivers.ContainsKey(key))
{
_receivers[key] = new List<Tuple<IReceiver, RequestPriority>>();
}
_receivers[key].Add(Tuple.Create(receiver, priority));
firstChanged = _receivers.Values[0] == _receivers[key];
}
if (firstChanged)
{
// registered item is needed to call before than previous first item.
_re.Set();
}
}
private void Receive([NotNull] IReceiver receiver, RequestPriority priority)
{
if (receiver == null) throw new ArgumentNullException(nameof(receiver));
_factories.Run(async () =>
{
var token = _tokenSource.Token;
var span = await receiver.ExecuteAsync(token).ConfigureAwait(false);
var now = DateTime.Now;
if (token.IsCancellationRequested) return;
if (span.Ticks > (DateTime.MaxValue - now).Ticks)
{
// register as MaxValue
RegisterReceiver(DateTime.MaxValue, receiver, priority);
}
else
{
RegisterReceiver(now + span, receiver, priority);
}
}, (int)priority, _tokenSource.Token);
}
public void RegisterReceiver([NotNull] IReceiver receiver, RequestPriority priority = RequestPriority.Middle)
{
if (receiver == null) throw new ArgumentNullException(nameof(receiver));
AssertNotDisposed();
RegisterReceiver(DateTime.Now, receiver, priority);
}
