public SendSms()
{
InitializeComponent();
try
{
LOG_PATH = Globals.FileLogPath;
ERROR_LOG_PATH = Globals.FileLogPath;
_tokenSource = new CancellationTokenSource();
_token = _tokenSource.Token;
_timer = new System.Timers.Timer();
_timer.Interval = Convert.ToDouble(ConfigurationManager.AppSettings["serviceInterval"]);
_timer.AutoReset = true;
_timer.Enabled = true;
_timer.Elapsed += timer_Elapsed;
_sda = new SqlDataAccess();
_sda.openConnection(Globals.ConnectionString);
_service = MSCRM.GetOrgService(true);
_serviceProcess = new ServiceProcess(_sda, _service);
}
catch (Exception ex)
{
FileLogHelper.LogFunction(this.GetType().Name, "SendSms_SendSms_EXCEPTION:" + ex.Message, ERROR_LOG_PATH);
}
}
ICollection<IDataModel> PopulateChildrenInternal() {
lock (sync) {
cancelSrc = new CancellationTokenSource();
CancellationToken = cancelSrc.Token;
}
ICollection<IDataModel> children;
try {
children = new List<IDataModel>(PopulateChildren());
}
catch (Exception ex) {
children = new IDataModel[] {
new ErrorModel(
string.Format("Error while loading:{0}{1}{0}{0}",
Environment.NewLine, ex))
};
}
finally {
lock (sync) {
cancelSrc = null;
CancellationToken = null;
}
}
return children;
}
public PrimesFromFile(
string path,
Progress<ProgressEventArgs> progressIndicator = null,
CancellationToken? maybeCancellationToken = null)
{
myPrimes = null;
myProgressIndicator = progressIndicator;
myMaybeCancellationToken = maybeCancellationToken;
Utilities.ReadCompressedFile(path, this.InputFromBinaryReader);
}
protected override void OnStart(string[] args)
{
_tokenSource = new CancellationTokenSource();
_token = _tokenSource.Token;
foreach (KeyValuePair<string, IWindSerOperations> windSerOperationKeyValue in _innerDictionary)
{
Task startedTask = Task.Factory.StartNew(_ =>
{
windSerOperationKeyValue.Value.StartOperation();
}, _token);
}
}
public EdmondsKarpMaximumFlow(Transaction tx,
GraphStorage graphStorage,
Node sourceNode,
Node targetNode,
Func<Edge, long> capacity,
CancellationToken? cancelToken = null)
: base(capacity)
{
_sourceNode = sourceNode;
_targetNode = targetNode;
_storage = graphStorage;
_cancelToken = cancelToken;
_flow = new Dictionary<Tuple<long, long>, long>();
_tx = tx;
}
public OperationCanceledException2(CancellationToken token)
: base()
{
this.token = token;
}
public static string RenderContent(
this Uri uri,
List <QueryParams> queryParamsList = null,
Func <TemplateMultiDataRequest, IEnumerable <dynamic> > dataProviders = null,
CancellationToken?token = null,
string referrer = null,
string userAgent = null
)
{
// todo: needs heavy refactoring and optimizing
#region retrieve content
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (queryParamsList?.Any() == true)
{
//dataModelContainer.Data = dataModelContainer.Data.GetDataModelParameters();
// uri to use data model
uri = new Uri(uri.AbsoluteUri
.Fill(queryParamsList)
, UriKind.Absolute);
}
if (!Uri.IsWellFormedUriString(uri.AbsoluteUri, UriKind.Absolute))
{
throw new FormatException(
$"Invalid uri format : {uri.AbsoluteUri}");
}
string content;
if ((content = uri
.GetContentAsync(token,
referrer, userAgent)
.GetAwaiter().GetResult()) == null)
{
throw new TimeoutException(
$"Uri retrieval timed-out for {uri.AbsoluteUri}");
}
if (content == null)
{
return(null);
}
content = content.FillDates();
#endregion
#region check for data providers and data tag availability in content
IEnumerable <dynamic> dataResponse = null;
QueryParams newQueryParams = new();
//var nextOpenMarker = queryParamsList?.OpenMarker;
//var nextCloseMarker = queryParamsList?.CloseMarker;
//var nextNullValue = queryParamsList?.NullReplacement;
if (dataProviders != null)
{
var dataRequestMatch = Regex.Match(content,
DataTagContentRegex,
RegexOptions.Singleline);
// get data if data request tags available
if (dataRequestMatch.Success)
{
// no pre-filling data model before calling data providers
// (unless pre-fill = true)
// as data model is submitted to data providers
// to allow data providers implement their own sql injection
// protection if needed
//TemplateMultiDataRequest req = new TemplateMultiDataRequest();
//req.QueryParamsList = queryParamsList;
//req.Request = dataRequestMatch.Groups["content"]?.Value;
//req.ConnectionString = dataRequestMatch?.GetAttrib("connection-string");
//req.ContentType = dataRequestMatch.GetAttrib("content-type");
_ = bool.TryParse((dataRequestMatch
.GetAttrib("pre-render") ?? "false"), out bool preRender);
dataResponse = dataProviders(new()
{
QueryParamsList = queryParamsList,
Request = dataRequestMatch.Groups["content"]?.Value,
ConnectionString = dataRequestMatch?
.GetAttrib("connection-string"),
ContentType = dataRequestMatch
.GetAttrib("content-type"),
CancellationToken = token,
PreRender = preRender
});
//if (dataResponse !=null)
// newQueryParams.DataModel = dataResponse;
if (dataRequestMatch.GetAttrib("open-marker") != null)
{
newQueryParams.OpenMarker = dataRequestMatch.GetAttrib("open-marker");
}
if (dataRequestMatch.GetAttrib("close-marker") != null)
{
newQueryParams.CloseMarker = dataRequestMatch.GetAttrib("close-marker");
}
if (dataRequestMatch.GetAttrib("null-value") != null)
{
newQueryParams.NullReplacement = dataRequestMatch.GetAttrib("null-value");
}
}
}
#endregion
#region loop response data while rendering current recursive level content
// remove the data tag if it was available as it should
// already be processed by now and not needed anymore
content = Regex.Replace(content, DataTagContentRegex,
"", RegexOptions.Singleline);
string renderedContent = "";
if (dataResponse != null)
{
foreach (var item in dataResponse?.EnsureEnumerable())
{
// todo: replace with markers from regex, failover to
// subDataModelContainer markers
newQueryParams.DataModel = ((object)item)?.EnsureEnumerable();
queryParamsList?.Add(newQueryParams);
// content is the template with vars that gets filled with different
// data model and the fill result gets accumulated in filledContent
var filledContent = content.Fill(queryParamsList);
// retrieve sub-templates recursively from current recursive level
// rendered content
foreach (var templateTagMatch in Regex.Matches(
filledContent, TemplateTagRegex).Cast <Match>())
{
var subUri = templateTagMatch.Groups["content"]?.Value;
// todo: replace {uri{./}} placeholder with functioning uri traversal logic
if (subUri?.Contains("{uri{./}}") == true ||
subUri?.Contains("{uri{.}}") == true
)
{
subUri = subUri
.Replace("{uri{./}}", uri.GetParentUri().AbsoluteUri + "/")
.Replace("{uri{.}}", uri.GetParentUri().AbsoluteUri.RemoveLast(1));
}
if (!string.IsNullOrWhiteSpace(subUri)
||
Uri.IsWellFormedUriString(subUri, UriKind.Absolute)
)
{
var subTemplateContent = new Uri(subUri).RenderContent(
queryParamsList,
dataProviders,
token,
// todo: optional grab of referrer from regex sub-template tag
referrer,
userAgent
);
// replace sub-template tag with rendered sub-template content
filledContent = filledContent.Replace(templateTagMatch.Value, subTemplateContent);
}
// sub-template tag removal if no valid uri was available
else
{
filledContent = filledContent.Replace(templateTagMatch.Value, "");
}
}
renderedContent += filledContent;
}
}
else
{
if (queryParamsList != null)
{
content = content.Fill(queryParamsList);
}
foreach (var templateTagMatch in Regex.Matches(
content, TemplateTagRegex).Cast <Match>())
{
var subUri = templateTagMatch.Groups["content"]?.Value;
// fill placeholder for current uri
if (subUri?.Contains("{uri{./}}") == true ||
subUri?.Contains("{uri{.}}") == true
)
{
subUri = subUri
.Replace("{uri{./}}", uri.GetParentUri().AbsoluteUri)
.Replace("{uri{.}}", uri.GetParentUri().AbsoluteUri.RemoveLast(1));
}
if (!string.IsNullOrWhiteSpace(subUri)
||
Uri.IsWellFormedUriString(subUri, UriKind.Absolute)
)
{
var subTemplateContent = new Uri(subUri).RenderContent(
queryParamsList,
dataProviders,
token,
// todo: optional grab of referrer from regex sub-template tag
referrer,
userAgent
);
// replace sub-template tag with rendered sub-template content
content = content.Replace(templateTagMatch.Value, subTemplateContent);
}
// sub-template tag removal if no valid uri was available
else
{
content = content.Replace(templateTagMatch.Value, "");
}
}
renderedContent = content;
}
#endregion
return(renderedContent);
}
/// <summary>Return the balances for the account</summary>
public async Task <Dictionary <string, Balance> > GetBalances(CancellationToken?cancel = null)
{
var jtok = await PostData(Method.Account, "returnCompleteBalances", cancel);
return(ParseJsonReply <Dictionary <string, Balance> >(jtok));
}
public void Render(ICamera camera, int[] colors, int width, int height, bool parallel = true, CancellationToken?cancellationToken = null)
{
var rayFactory = camera.GetRayFactory(width, height);
if (parallel)
{
Parallel.For(0, height, y =>
{
for (var x = 0; x < width; ++x)
{
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return;
}
var index = y * width + x;
var ray = rayFactory.GetCameraRay(x, y);
colors[index] = Trace(ray, 0).ToArgb();
}
});
}
else
{
for (var x = 0; x < width; ++x)
{
for (var y = 0; y < height; ++y)
{
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return;
}
var index = y * width + x;
var ray = rayFactory.GetCameraRay(x, y);
colors[index] = Trace(ray, 0).ToArgb();
}
}
}
}
/// <summary>
/// Returns features within the specified bounding box.
/// </summary>
/// <param name="envelope"></param>
/// <returns></returns>
public override IEnumerable <Geometry> GetGeometriesInView(BoundingBox envelope, CancellationToken?ct = null)
{
// Identifies all the features within the given BoundingBox
var geoms = new Collection <Geometry>();
foreach (var feature in _features)
{
if (envelope.Intersects(feature.Geometry.EnvelopeInternal))
{
geoms.Add(feature.Geometry);
}
}
return(geoms);
}
public async Task <List <Trade> > GetTradeHistory(CurrencyPair pair, UnixSec start_time, UnixSec end_time, CancellationToken?cancel = null)
{
// https://poloniex.com/public?command=returnTradeHistory¤cyPair=BTC_NXT&start=1410158341&end=1410499372
var jtok = await GetData(Method.Public, "returnTradeHistory", cancel, new Params
{
{ "currencyPair", pair.Id },
{ "start", start_time },
{ "end", end_time },
});
return(ParseJsonReply <List <Trade> >(jtok));
}
void GetClassificationSpansCore(List <HexClassificationSpan> result, HexClassificationContext context, CancellationToken?cancellationToken)
{
if (context.IsDefault)
{
throw new ArgumentException();
}
var textSpan = context.LineSpan;
var list = new List <HexClassificationSpan>();
var taggerContext = new HexTaggerContext(context.Line, context.LineSpan);
var tags = !(cancellationToken is null) ? hexTagAggregator.GetAllTags(taggerContext, cancellationToken.Value) : hexTagAggregator.GetAllTags(taggerContext);
foreach (var tagSpan in tags)
{
var overlap = textSpan.Overlap(tagSpan.Span);
if (!(overlap is null))
{
list.Add(new HexClassificationSpan(overlap.Value, tagSpan.Tag.ClassificationType));
}
}
if (list.Count <= 1)
{
if (list.Count == 1)
{
result.Add(list[0]);
}
return;
}
list.Sort(HexClassificationSpanComparer.Instance);
// Common case
if (!HasOverlaps(list))
{
result.AddRange(Merge(list));
return;
}
int min = 0;
int minOffset = textSpan.Start;
var newList = new List <HexClassificationSpan>();
var ctList = new List <VSTC.IClassificationType>();
while (min < list.Count)
{
while (min < list.Count && minOffset >= list[min].Span.End)
{
min++;
}
if (min >= list.Count)
{
break;
}
var cspan = list[min];
minOffset = Math.Max(minOffset, cspan.Span.Start);
int end = cspan.Span.End;
ctList.Clear();
ctList.Add(cspan.ClassificationType);
for (int i = min + 1; i < list.Count; i++)
{
cspan = list[i];
int cspanStart = cspan.Span.Start;
if (cspanStart > minOffset)
{
if (cspanStart < end)
{
end = cspanStart;
}
break;
}
int cspanEnd = cspan.Span.End;
if (minOffset >= cspanEnd)
{
continue;
}
if (cspanEnd < end)
{
end = cspanEnd;
}
if (!ctList.Contains(cspan.ClassificationType))
{
ctList.Add(cspan.ClassificationType);
}
}
Debug.Assert(minOffset < end);
var ct = ctList.Count == 1 ? ctList[0] : classificationTypeRegistryService.CreateTransientClassificationType(ctList);
newList.Add(new HexClassificationSpan(VST.Span.FromBounds(minOffset, end), ct));
minOffset = end;
}
Debug.Assert(!HasOverlaps(newList));
result.AddRange(Merge(newList));
return;
}
public OperationCanceledException (string message, CancellationToken token)
: this (message)
{
this.token = token;
}
/// <summary>
/// Operation: Get User Presence Status List
/// HTTP Method: GET
/// Endpoint: /restapi/v1.0/account/{accountId}/presence
/// Rate Limit Group: Heavy
/// App Permission: ReadPresence
/// User Permission: ReadPresenceStatus
/// </summary>
public async Task <RingCentral.AccountPresenceInfo> Get(ReadAccountPresenceParameters queryParams = null,
CancellationToken?cancellationToken = null)
{
return(await rc.Get <RingCentral.AccountPresenceInfo>(this.Path(), queryParams, cancellationToken));
}
protected override Task <bool> DoIsFileExistsAsync(StorageItem item, CancellationToken?cancellationToken = null)
{
var fullPath = Path.Combine(Options.StoragePath, item.FilePath);
return(Task.FromResult(File.Exists(fullPath)));
}
private void ForwardAllResultsToCmdlet(Cmdlet cmdlet, CancellationToken?cancellationToken)
{
this.AssertNotDisposed();
ForwardingHelper.ForwardAllResultsToCmdlet(this, cmdlet, cancellationToken);
}
public static void ForwardAllResultsToCmdlet(ThrottlingJob throttlingJob, Cmdlet cmdlet, CancellationToken?cancellationToken)
{
using (var helper = new ForwardingHelper(throttlingJob))
{
try
{
throttlingJob.ChildJobAdded += helper.ThrottlingJob_ChildJobAdded;
try
{
throttlingJob.StateChanged += helper.ThrottlingJob_StateChanged;
IDisposable cancellationTokenRegistration = null;
if (cancellationToken.HasValue)
{
cancellationTokenRegistration = cancellationToken.Value.Register(helper.CancelForwarding);
}
try
{
Interlocked.MemoryBarrier();
ThreadPool.QueueUserWorkItem(
delegate
{
helper.StartMonitoringJob(throttlingJob);
foreach (Job childJob in throttlingJob.GetChildJobsSnapshot())
{
helper.StartMonitoringJob(childJob);
}
helper.CheckIfThrottlingJobIsComplete();
});
helper.ForwardResults(cmdlet);
}
finally
{
if (cancellationTokenRegistration != null)
{
cancellationTokenRegistration.Dispose();
}
}
}
finally
{
throttlingJob.StateChanged -= helper.ThrottlingJob_StateChanged;
}
}
finally
{
throttlingJob.ChildJobAdded -= helper.ThrottlingJob_ChildJobAdded;
}
}
}
public Task <IRedLock> CreateLockAsync(string resource, TimeSpan expiryTime, TimeSpan waitTime, TimeSpan retryTime, CancellationToken?cancellationToken = null)
{
throw new NotSupportedException();
}
public async Task<UploadResponse> UploadAsync(Dictionary<string, object> transferMetadata = null, CancellationToken? cancellationToken = null)
{
await PrepareAsync();
TransferMetadata = transferMetadata ?? new Dictionary<string, object>();
Progress.TransferMetadata = TransferMetadata;
CancellationToken = cancellationToken;
var response = await InternalUploadAsync();
try
{
var stream = await File.OpenReadAsync();
stream.Dispose();
}
catch (Exception)
{
// Eat the exception, we tried to clean up.
}
return response;
}
public OperationCanceledException(CancellationToken token)
: this()
{
this.token = token;
}
public FileWatch(CancellationToken?shutdown, ChangedHandler on_changed, params string[] files)
: this(shutdown, on_changed, 0, null, files)
{
}
public OperationCanceledException(string message, CancellationToken token)
: this(message)
{
this.token = token;
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="geom">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
protected override void OnExecuteIntersectionQuery(Geometry geom, IFeatureCollectionSet fcs, CancellationToken?ct = null)
{
using (var ogrGeometry = OgrGeometry.CreateFromWkb(GeometryToWKB.Write(geom)))
{
_ogrLayer.SetSpatialFilter(ogrGeometry);
var fds = new FeatureDataSet();
ExecuteIntersectionQuery(fds);
foreach (var fd in fds)
{
fcs.Add(fd);
}
}
}
public OperationCanceledException(string message, Exception innerException, CancellationToken token)
: base(message, innerException)
{
this.token = token;
}
/// <summary>
///
/// </summary>
/// <param name="envelope"></param>
/// <param name="ds"></param>
public override void ExecuteIntersectionQuery(BoundingBox envelope, IFeatureCollectionSet ds, CancellationToken?ct = null)
{
// Identifies all the features within the given BoundingBox
var dataTable = CreateFeatureDataTable();
dataTable.BeginLoadData();
foreach (Feature feature in _features)
{
if (envelope.Intersects(feature.Geometry.EnvelopeInternal))
{
CreateNewRow(dataTable, feature);
}
}
dataTable.EndLoadData();
ds.Add(dataTable);
}
/// <inheritdoc cref="IRepository{TEntity}"/>
public async Task InsertAsync(TEntity entity, CancellationToken?cancellationToken = null)
{
await Collection.InsertOneAsync(entity, new InsertOneOptions(), cancellationToken ?? CancellationToken.None);
}
/// <summary></summary>
public async Task <List <MarketChartData> > GetChartData(CurrencyPair pair, EMarketPeriod period, UnixSec time_beg, UnixSec time_end, CancellationToken?cancel = null)
{
try
{
var jtok = await GetData(Method.Public, "returnChartData", cancel, new Params
{
{ "currencyPair", pair.Id },
{ "start", time_beg.Value },
{ "end", time_end.Value },
{ "period", (int)period },
});
var data = ParseJsonReply <List <MarketChartData> >(jtok);
// Poloniex returns a single invalid candle if there is no data within the range
return
(data.Count == 0 ? new List <MarketChartData>() :
data.Count == 1 && data[0].Invalid ? new List <MarketChartData>() :
data);
}
catch (Exception ex)
{
if (ex.Message.Contains("too much data"))
{
throw new PoloniexException(EErrorCode.TooMuchDataRequested, "Too much chart data was requested");
}
throw;
}
}
public Task <bool> UpdateAsync <T>(T record, CancellationToken?cancellationToken = null)
{
throw new NotImplementedException();
}
/// <summary>Get the trade history</summary>
public async Task <Dictionary <string, List <TradeCompleted> > > GetTradeHistory(UnixSec?beg = null, UnixSec?end = null, CancellationToken?cancel = null)
{
var parms = new Params {
{ "currencyPair", "all" }
};
if (beg != null && end != null)
{
parms["start"] = beg.Value.Value;
parms["end"] = end.Value.Value;
}
var jtok = await PostData(Method.Account, "returnTradeHistory", cancel, parms);
var history = ParseJsonReply <Dictionary <string, List <TradeCompleted> > >(jtok);
foreach (var his in history)
{
foreach (var h in his.Value)
{
h.Pair = CurrencyPair.Parse(his.Key);
}
}
return(history);
}
//public event EventHandler<EventArgs<String>> OnServerCommandReceived;
public WifiServer(CancellationToken?stopToken = null) : base(stopToken)
{
}
/// <summary>
/// Establishes the websocket against the configured URL.
/// Try to get the QIX global interface when the connection has been established.
/// </summary>
/// <returns></returns>
public async Task <dynamic> OpenAsync(CancellationToken?ctn = null)
{
if (socket != null)
{
await CloseAsync(ctn);
}
LastOpenError = null;
CancellationToken ct = ctn ?? CancellationToken.None;
socket = await config.CreateSocketCall(ct).ConfigureAwait(false);
// Todo add here the global Cancelation Token that is
// triggered from the CloseAsync
bool?connected = null;
void RPCMethodCall(object sender, JsonRpcRequestMessage e)
{
logger.Trace($"RPCMethodCall - {e.Method}:{e.Parameters}");
if (e.Method == "OnAuthenticationInformation" && (bool?)e.Parameters["mustAuthenticate"] == true)
{
connected = false;
LastOpenError = "Connection established but authentication failed";
}
if (e.Method == "OnConnected")
{
LastOpenError = "";
connected = true;
}
if (!connected.HasValue)
{
string message = "";
try
{
message = (string)e.Parameters["message"];
}
catch (Exception ex)
{
logger.Error(ex);
}
string severity = "";
try
{
severity = (string)e.Parameters["severity"];
}
catch (Exception ex)
{
logger.Error(ex);
}
if (!string.IsNullOrEmpty(severity) && severity == "fatal")
{
try
{
LastOpenError = e.Method + "\n" + message;
}
catch (Exception ex)
{
logger.Error(ex);
LastOpenError = "Communication Error";
}
connected = false;
}
}
}
RPCMethodCalled += RPCMethodCall;
StartReceiveLoop(ct);
while (connected == null && !ct.IsCancellationRequested)
{
Thread.Sleep(10);
}
RPCMethodCalled -= RPCMethodCall;
if (connected == false)
{
socket?.CloseAsync(WebSocketCloseStatus.InternalServerError, "", ct);
throw new Exception("Connection Error");
}
// start SendLoop only if connection is opened
StartSendLoop(ct);
var global = new GeneratedAPI(new ObjectResult()
{
QHandle = -1, QType = "Global"
}, this);
GeneratedApiObjects.TryAdd(-1, new WeakReference <GeneratedAPI>(global));
return(global);
}
public string NullableCancellationTokenOnly(CancellationToken? token = null)
{
ReceivedToken = token;
return _returnValue;
}
public RequestState(HttpWebRequest request, CancellationToken? cancellationToken)
{
if (request == null) throw new ArgumentNullException("request");
this.request = request;
this.cancellationToken = cancellationToken;
}
public WorkItem(
TaskCompletionSource<object> taskSource,
Action action,
CancellationToken? cancelToken)
{
TaskSource = taskSource;
Action = action;
CancelToken = cancelToken;
}
public void Reset()
{
_onStarting = null;
_onCompleted = null;
_responseStarted = false;
_keepAlive = false;
_autoChunk = false;
_applicationException = null;
_requestHeaders.Reset();
ResetResponseHeaders();
ResetFeatureCollection();
Scheme = null;
Method = null;
RequestUri = null;
PathBase = null;
Path = null;
QueryString = null;
_httpVersion = HttpVersionType.Unknown;
RequestHeaders = _requestHeaders;
RequestBody = null;
StatusCode = 200;
ReasonPhrase = null;
ResponseHeaders = _responseHeaders;
ResponseBody = null;
DuplexStream = null;
var httpConnectionFeature = this as IHttpConnectionFeature;
httpConnectionFeature.RemoteIpAddress = _remoteEndPoint?.Address;
httpConnectionFeature.RemotePort = _remoteEndPoint?.Port ?? 0;
httpConnectionFeature.LocalIpAddress = _localEndPoint?.Address;
httpConnectionFeature.LocalPort = _localEndPoint?.Port ?? 0;
if (_remoteEndPoint != null && _localEndPoint != null)
{
httpConnectionFeature.IsLocal = _remoteEndPoint.Address.Equals(_localEndPoint.Address);
}
else
{
httpConnectionFeature.IsLocal = false;
}
_prepareRequest?.Invoke(this);
_manuallySetRequestAbortToken = null;
_abortedCts = null;
}
void MergeOptions (OptionsList list)
{
if (list.Item1 != null) {
if (options == null)
options = list.Item1;
else
Throw ("WithMergeOptions");
}
if (list.Item2 != null) {
if (mode == null)
mode = list.Item2;
else
Throw ("WithExecutionMode");
}
if (list.Item3 != null) {
if (token == null)
token = list.Item3;
else
Throw ("WithCancellationToken");
}
if (list.Item4 != -1) {
if (degreeOfParallelism == null)
degreeOfParallelism = list.Item4;
else
Throw ("WithDegreeOfParallelism");
}
// That one is treated specially
if (list.Item5 != null) {
implementerToken = implementerToken.Chain (list.Item5);
}
}
public WifiBaseClass(CancellationToken?stopToken = null)
{
_cts = CancellationTokenSource.CreateLinkedTokenSource(stopToken ?? CancellationToken.None);
}
public async Task <bool> SendPost(string url, TimeSpan?timeout = null, CancellationToken?ct = null)
{
return(await Send(true, url, timeout ?? Timeout30, ct ?? _cancellationTokenSource.Token));
}
public string CancellationTokenOnly(CancellationToken token)
{
ReceivedToken = token;
return _returnValue;
}
protected static async Task <ProcessExecutionResult> RunAsyncInternal(
Process process,
ILog log,
ILog stdout,
ILog stderr,
Action <int, int> kill,
Func <ILog, int, IList <int> > getChildProcessIds,
TimeSpan?timeout = null,
Dictionary <string, string>?environmentVariables = null,
CancellationToken?cancellationToken = null,
bool?diagnostics = null)
{
var stdoutCompletion = new TaskCompletionSource <bool>();
var stderrCompletion = new TaskCompletionSource <bool>();
var result = new ProcessExecutionResult();
process.StartInfo.RedirectStandardError = true;
process.StartInfo.RedirectStandardOutput = true;
// Make cute emojiis show up as cute emojiis in the output instead of ugly text symbols!
process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
process.StartInfo.UseShellExecute = false;
if (environmentVariables != null)
{
foreach (var kvp in environmentVariables)
{
if (kvp.Value == null)
{
process.StartInfo.EnvironmentVariables.Remove(kvp.Key);
}
else
{
process.StartInfo.EnvironmentVariables[kvp.Key] = kvp.Value;
}
}
}
process.OutputDataReceived += (sender, e) =>
{
if (e.Data != null)
{
lock (stdout)
{
stdout.WriteLine(e.Data);
stdout.Flush();
}
}
else
{
stdoutCompletion.TrySetResult(true);
}
};
process.ErrorDataReceived += (sender, e) =>
{
if (e.Data != null)
{
lock (stderr)
{
stderr.WriteLine(e.Data);
stderr.Flush();
}
}
else
{
stderrCompletion.TrySetResult(true);
}
};
var sb = new StringBuilder();
if (process.StartInfo.EnvironmentVariables != null)
{
var currentEnvironment = Environment.GetEnvironmentVariables().Cast <DictionaryEntry>().ToDictionary(v => v.Key.ToString(), v => v.Value?.ToString(), StringComparer.Ordinal);
var processEnvironment = process.StartInfo.EnvironmentVariables.Cast <DictionaryEntry>().ToDictionary(v => v.Key.ToString(), v => v.Value?.ToString(), StringComparer.Ordinal);
var allKeys = currentEnvironment.Keys.Union(processEnvironment.Keys).Distinct();
foreach (var key in allKeys)
{
if (key == null)
{
continue;
}
string?a = null, b = null;
currentEnvironment?.TryGetValue(key, out a);
processEnvironment?.TryGetValue(key, out b);
if (a != b)
{
sb.Append($"{key}={StringUtils.Quote(b)} ");
}
}
}
sb.Append($"{StringUtils.Quote(process.StartInfo.FileName)} {process.StartInfo.Arguments}");
log.WriteLine(sb.ToString());
process.Start();
var pid = process.Id;
process.BeginErrorReadLine();
process.BeginOutputReadLine();
cancellationToken?.Register(() =>
{
var hasExited = false;
try
{
hasExited = process.HasExited;
}
catch
{
// Process.HasExited can sometimes throw exceptions, so
// just ignore those and to be safe treat it as the
// process didn't exit (the safe option being to not leave
// processes behind).
}
if (!hasExited)
{
stderr.WriteLine($"Killing process {pid} as it was cancelled");
kill(pid, 9);
}
});
if (timeout.HasValue)
{
if (!await WaitForExitAsync(process, timeout.Value))
{
log.WriteLine($"Process {pid} didn't exit within {timeout} and will be killed");
await KillTreeAsync(pid, log, kill, getChildProcessIds, diagnostics ?? true);
result.TimedOut = true;
lock (stderr)
{
log.WriteLine($"{pid} Execution timed out after {timeout.Value.TotalSeconds} seconds and the process was killed.");
}
}
}
else
{
await WaitForExitAsync(process);
}
if (process.HasExited)
{
// make sure redirected output events are finished
process.WaitForExit();
}
Task.WaitAll(new Task[] { stderrCompletion.Task, stdoutCompletion.Task }, TimeSpan.FromSeconds(1));
try
{
result.ExitCode = process.ExitCode;
log.WriteLine($"Process {Path.GetFileName(process.StartInfo.FileName)} exited with {result.ExitCode}");
}
catch (Exception e)
{
result.ExitCode = 12345678;
log.WriteLine($"Failed to get ExitCode: {e}");
}
return(result);
}
public SendResponse Send(IFluentEmail email, CancellationToken?token = null)
{
return(SendAsync(email, token).GetAwaiter().GetResult());
}
public async Task <SendResponse> SendAsync(IFluentEmail email, CancellationToken?token = null)
{
var parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("from", $"{email.Data.FromAddress.Name} <{email.Data.FromAddress.EmailAddress}>"));
email.Data.ToAddresses.ForEach(x => {
parameters.Add(new KeyValuePair <string, string>("to", $"{x.Name} <{x.EmailAddress}>"));
});
email.Data.CcAddresses.ForEach(x => {
parameters.Add(new KeyValuePair <string, string>("cc", $"{x.Name} <{x.EmailAddress}>"));
});
email.Data.BccAddresses.ForEach(x => {
parameters.Add(new KeyValuePair <string, string>("bcc", $"{x.Name} <{x.EmailAddress}>"));
});
email.Data.ReplyToAddresses.ForEach(x => {
parameters.Add(new KeyValuePair <string, string>("h:Reply-To", $"{x.Name} <{x.EmailAddress}>"));
});
parameters.Add(new KeyValuePair <string, string>("subject", email.Data.Subject));
parameters.Add(new KeyValuePair <string, string>(email.Data.IsHtml ? "html" : "text", email.Data.Body));
if (!string.IsNullOrEmpty(email.Data.PlaintextAlternativeBody))
{
parameters.Add(new KeyValuePair <string, string>("text", email.Data.PlaintextAlternativeBody));
}
email.Data.Tags.ForEach(x =>
{
parameters.Add(new KeyValuePair <string, string>("o:tag", x));
});
foreach (var emailHeader in email.Data.Headers)
{
var key = emailHeader.Key;
if (!key.StartsWith("h:"))
{
key = "h:" + emailHeader.Key;
}
parameters.Add(new KeyValuePair <string, string>(key, emailHeader.Value));
}
var files = new List <HttpFile>();
email.Data.Attachments.ForEach(x =>
{
string param;
if (x.IsInline)
{
param = "inline";
}
else
{
param = "attachment";
}
files.Add(new HttpFile()
{
ParameterName = param,
Data = x.Data,
Filename = x.Filename,
ContentType = x.ContentType
});
});
var response = await _httpClient.PostMultipart <MailgunResponse>("messages", parameters, files).ConfigureAwait(false);
var result = new SendResponse {
MessageId = response.Data?.Id
};
if (!response.Success)
{
result.ErrorMessages.AddRange(response.Errors.Select(x => x.ErrorMessage));
return(result);
}
return(result);
}
public OperationCanceledException (CancellationToken token)
: this ()
{
this.token = token;
}
public OperationCanceledException2(CancellationToken token)
: base()
{
this.token = token;
}
public OperationCanceledException (string message, Exception innerException, CancellationToken token)
: base (message, innerException)
{
this.token = token;
}
/// <summary>
/// Returns the data associated with all the geometries that are intersected by 'geom'
/// </summary>
/// <param name="bbox">Geometry to intersect with</param>
/// <param name="ds">FeatureDataSet to fill data into</param>
public override void ExecuteIntersectionQuery(BoundingBox bbox, IFeatureCollectionSet fcs, CancellationToken?ct = null)
{
_ogrLayer.SetSpatialFilterRect(bbox.MinX, bbox.MinY, bbox.MaxX, bbox.MaxY);
var fds = new FeatureDataSet();
ExecuteIntersectionQuery(fds);
foreach (var fd in fds)
{
fcs.Add(fd);
}
}
