Example #1
0
        protected override void AnnotateCorpus(
            Corpus corpus, System.Threading.CancellationToken token)
        {
            token.ThrowIfCancellationRequested();

            Guid taskId = Guid.NewGuid();

            DirectoryInfo dir = new DirectoryInfo(
                AppDomain.CurrentDomain.BaseDirectory);

            dir = dir.CreateSubdirectory("Tasks");
            dir = dir.CreateSubdirectory(taskId.ToString());

            string dataFile = dir.FullName + "\\Corpus.crfppdata";
            string outputFile = dir.FullName + "\\Output.crfppdata";

            try
            {
                AnnotationProgressChangedEventArgs ePrepared =
                    new AnnotationProgressChangedEventArgs(
                        1, 3, MessagePreparing);
                OnAnnotationProgressChanged(ePrepared);

                CRFPPHelper.EncodeCorpusToCRFPPData(corpus, dataFile);
                token.ThrowIfCancellationRequested();

                AnnotationProgressChangedEventArgs eAnnotating =
                    new AnnotationProgressChangedEventArgs(
                        2, 3, MessageAnnotating);
                OnAnnotationProgressChanged(eAnnotating);

                CRFPPHelper.Annotate(
                    Model.RootPath, dataFile, outputFile, 1, 0);
                token.ThrowIfCancellationRequested();

                AnnotationProgressChangedEventArgs eFinishing =
                    new AnnotationProgressChangedEventArgs(
                        3, 3, MessageFinishing);
                OnAnnotationProgressChanged(eFinishing);

                CRFPPHelper.DecodeCorpusFromCRFPPData(corpus, outputFile);
                token.ThrowIfCancellationRequested();
            }
            catch
            {
                throw;
            }
            finally
            {
                File.Delete(dataFile);
                File.Delete(outputFile);

                try
                {
                    dir.Delete();
                }
                catch { }
            }
        }
Example #2
0
 protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
 {
     cancellationToken.ThrowIfCancellationRequested();
     var response = responseCreator(request);
     response.RequestMessage = request;
     return Task.FromResult(response);
 }
        private ICollection<CsprojFileData> FindCsprojFiles(System.Threading.CancellationToken cancellationToken, IProgress<DiscoveryProgress> progress)
        {
            var files = new List<CsprojFileData>();

            // find csproj files
            foreach (var fileName in System.IO.Directory.EnumerateFiles(FolderPath, "*.csproj", System.IO.SearchOption.AllDirectories))
            {
                cancellationToken.ThrowIfCancellationRequested();

                progress.Report(new DiscoveryProgress() { CurrentItem = fileName });

                CsprojFileData csprojData = null;
                try
                {
                    csprojData = csprojFileReader.ReadFromFile(fileName);
                }
                catch (Exception e)
                {
                    Debug.WriteLine("Error reading CSPROJ: " + e.Message);
                }

                if (csprojData != null)
                    files.Add(csprojData);
            }

            return files;
        }
        public Task<GraphData> Resolve(System.Threading.CancellationToken cancellationToken, IProgress<DiscoveryProgress> progress)
        {
            return Task.Factory.StartNew<GraphData>(() => {

                // read *.csproj projects
                var projects = FindCsprojFiles(cancellationToken, progress);
                cancellationToken.ThrowIfCancellationRequested();

                // read *.sln files
                var solutions = FindSlnFiles(cancellationToken, progress);
                cancellationToken.ThrowIfCancellationRequested();

                // build result
                var result = builder.Build(this, projects, solutions);
                return result;
            });
        }
        /// <summary>
        /// Calculates the sequence to a specified length.
        /// </summary>
        /// <param name="length">The length to calculate.</param>
        /// <param name="cancellationToken">The cancellation token used to cancel the work.</param>
        /// <param name="progress">The progress reporting object. Each report specifies the value of a single element.</param>
        /// <returns>
        /// Sequence results.
        /// </returns>
        public async Task CalculateAsync(int length, System.Threading.CancellationToken cancellationToken, IProgress<int> progress)
        {
            List<int> results = new List<int>();

            for (int loopVariable = 0; loopVariable < length; loopVariable++)
            {
                int index = loopVariable;

                // create a continuation to run asynchronously (probably the thread pool)
                await Task.Run(
                    () =>
                    {
                        // check the cancellation token to see if cancellation is required
                        cancellationToken.ThrowIfCancellationRequested();

                        // the first two elements are not calculated
                        if (index < 2)
                        {
                            results.Add(index);
                        }
                        else
                        {
                            // the new element is (i-1 + i-2)
                            results.Add(results[results.Count - 1] + results[results.Count - 2]);
                        }

                        if (results.Last() % 2 == 0)
                        {
                            //throw new InvalidOperationException("Test Exception");
                        }

                        System.Threading.Thread.Sleep(500);

                        // check the cancellation token to see if cancellation is required
                        cancellationToken.ThrowIfCancellationRequested();

                        progress.Report(results.Last());
                    });

                var handler = this.OnStepAdvance;
                if (handler != null)
                {
                    handler(this, new StepEventArgs(results.Last()));
                }
            }
        }
		public async Task<bool> VerifyPaymentAsync(string identifier, decimal? expectedAmount, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) {
			if(String.IsNullOrEmpty(Account)) {
				throw new InvalidOperationException("The Account property must be set before calling VerifyPaymentAsync");
			}
			if(String.IsNullOrEmpty(User)) {
				throw new InvalidOperationException("The User property must be set before calling VerifyPaymentAsync");
			}
			if(String.IsNullOrEmpty(Password)) {
				throw new InvalidOperationException("The Password property must be set before calling VerifyPaymentAsync");
			}

			var rangeEnd = DateTime.Now.AddDays(1);
			var rangeStart = rangeEnd.AddDays(-7);
			
			var data = new Dictionary<string, string> {
				{"ShopOrderNumber", identifier },// ReferenceCalculator.GenerateReferenceNumber(identifier)},
				{"Shop_Id", Account},
				{"Login", User},
				{"Password", Password},
				{"Format", "1"},
				{"English", "1"},
				{"StartYear", rangeStart.Year.ToString() },
				{"StartMonth", rangeStart.Month.ToString() },
				{"StartDay", rangeStart.Day.ToString() },
				{"StartHour", "0"},
				{"StartMin", "0"},
				{"EndYear", rangeEnd.Year.ToString() },
				{"EndMonth", rangeEnd.Month.ToString() },
				{"EndDay", rangeEnd.Day.ToString() },
				{"EndHour", "0"},
				{"EndMin", "0"}
			};

			// Make request
			var client = new HttpClient();
			var response = await client.PostAsync(EndpointUrl, new FormUrlEncodedContent(data), cancellationToken);
			response.EnsureSuccessStatusCode();
			cancellationToken.ThrowIfCancellationRequested();
			var responseContent = await response.Content.ReadAsStringAsync();

			// Match successful payment
			if(responseContent.Contains(identifier+";AS000;SUCCESSFUL")) {
				return true;
			}
			// Match payment outside date interval
			if(responseContent.Contains("ERROR:")) {
				return false;
			}
			// Match various error codes for unsuccessful payments
			if(Regex.IsMatch(responseContent, Regex.Escape(identifier)[email protected]";AS[1234]\d\d")) {
				return false;
			}
			throw new VerificationProviderException("Assist verification service returned unknown response.") {
				ResponseContent = responseContent
			};
		}
        /// <summary>
        /// Implement all the query logic in this method.
        /// </summary>
        /// <remarks>
        /// The cancellationToken must be checked when it is safe to cancel the
        /// operation. The blocking logic between two check points for cancellationToken
        /// should run as quick as possible. The logic will still be aborted if it takes too
        /// long after cancellationToken is canceled but no cancellation work is actually performed.
        /// The cancellation work can be simply return from the method or throw an OperationCanceledException.
        /// </remarks>
        /// <param name="cancellationToken">The cancellationToken to be checked.</param>
        /// <returns>Queried result</returns>
        protected override TaskQuickStatus QueryStatus(System.Threading.CancellationToken cancellationToken)
        {
            int count;
            for (count = 0; count < COUNT; count++)
            {
                // Check cancellationToken for the canceled state.
                cancellationToken.ThrowIfCancellationRequested();

                // TODO: do real work, keep it as quick as possible.
                // Here, simply uses a timed wait to make it look like working on something.
                cancellationToken.WaitHandle.WaitOne(WAIT_TIMEOUT);
            }

            // Check the cancellationToken again
            cancellationToken.ThrowIfCancellationRequested();

            return new TaskQuickStatus()
            {
                Mark = count.ToString(CultureInfo.CurrentCulture),
                StatusTips = String.Empty
            };
        }
Example #8
0
 public async Task Excute(Command[] commands,System.Threading.CancellationToken token)
 {
     try {
         foreach (var command in commands)
         {
             token.ThrowIfCancellationRequested();
             switch(command.Verb)
             {
                 case Verb.Back:
                     Back();
                     Straight();
                     break;
                 case Verb.BackLeft:
                     Back();
                     Left();
                     break;
                 case Verb.BackRight:
                     Back();
                     Right();
                     break;
                 case Verb.Fowerd:
                     Fowerd();
                     Straight();
                     break;
                 case Verb.FowerdLeft:
                     Fowerd();
                     Left();
                     break;
                 case Verb.FowerdRight:
                     Fowerd();
                     Right();
                     break;
                 case Verb.Stop:
                     Stop();
                     Straight();
                     break;
             }
             await Task.Delay(command.Time * 1000, token);
         }
     }catch(OperationCanceledException)
     {
         Console.WriteLine("Cancel");
     }
     finally
     {
         Stop();
         Straight();
     }
 }
        private void StartRegularDataCheck(System.Threading.CancellationToken cancellationToken)
        {
            Task.Run(async () =>
            {
                var sotonmet = new SouthamptonVTSDataSource(SouthamptonVTSStation.Dockhead);
                var bramble = new SouthamptonVTSDataSource(SouthamptonVTSStation.Bramble);

                while (!cancellationToken.IsCancellationRequested)
                {
                    var sotonRecord = sotonmet.GetLatestDataPoint();
                    var brambleRecord = bramble.GetLatestDataPoint();

                    await Task.Delay(60000).ConfigureAwait(false);
                }

                cancellationToken.ThrowIfCancellationRequested();
            }, cancellationToken);
        }
Example #10
0
 public static System.Collections.Generic.IEnumerable<TypeDefinition> FindDerivedTypes(TypeDefinition type, ModuleDefinition[] assemblies, System.Threading.CancellationToken cancellationToken)
 {
    foreach (ModuleDefinition module in assemblies)
    {
       foreach (TypeDefinition td in ICSharpCode.NRefactory.Utils.TreeTraversal.PreOrder(module.Types, t => t.NestedTypes))
       {
          cancellationToken.ThrowIfCancellationRequested();
          if (type.IsInterface && td.HasInterfaces)
          {
             foreach (TypeReference typeRef in td.Interfaces)
             {
                if (IsSameType(typeRef, type))
                   yield return td;
             }
          }
          else if (!type.IsInterface && td.BaseType != null && IsSameType(td.BaseType, type))
          {
             yield return td;
          }
       }
    }
 }
Example #11
0
 /// <summary>
 /// comingsoonでも止まるように変更した!
 /// </summary>
 /// <param name="live_id"></param>
 /// <param name="cc"></param>
 /// <param name="progress"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 private async Task<Response<getplayerstatus_new>> GetSeatLoopTest(string live_id, System.Net.CookieContainer cc, IProgress<StringReport> progress, System.Threading.CancellationToken token, bool logging)
 {
     var report = new StringReport();
     int loopCounter = 0;
     Response<getplayerstatus_new> response;
     do
     {
         //座席が取れた場合と座席を取るのが不可能な場合に結果を戻す。それ以外の場合には経過をReportして継続する。
         token.ThrowIfCancellationRequested();
         loopCounter++;
         response = await Api.GetPlayerStatus_new(live_id, cc, logging);
         if (response.status == status.ok)
         {
             return response.GetResponse();
         }
         else
         {
             var code = response.GetError().code;
             switch (code)
             {
                 case errorcode.closed:
                 case errorcode.notfound:
                 case errorcode.notlogin:
                 case errorcode.require_community_member:
                 case errorcode.deletedbyuser:
                 //注意!!
                 case errorcode.comingsoon:
                 case errorcode.noauth:
                     return response;
                 default:
                     break;
             }
             report.Message = string.Format("{0} {1, 4}回目", code, loopCounter);
             progress.Report(report);
         }
     } while (true);
 }
        /// <summary>
        /// Waits for a shout request message to arrive in the Pub/Sub
        /// subscription.  Converts the text to uppercase and posts the results
        /// back to the website.
        /// </summary>
        /// <returns>
        /// The number of messages pulled from the subscription,
        /// or -1 if an expected error occurred.
        /// </returns>
        public int ShoutOrThrow(System.Threading.CancellationToken cancellationToken)
        {
            // Pull a shout request message from the subscription.
            string subscriptionPath = MakeSubscriptionPath(_init.SubscriptionName);
            WriteLog("Pulling shout request messages from " + subscriptionPath + "...",
                TraceEventType.Verbose);
            var pullRequest = _init.PubsubService.Projects.Subscriptions.Pull(
                new PullRequest()
                {
                    MaxMessages = 1,
                    ReturnImmediately = false
                }, subscriptionPath).ExecuteAsync();
            Task.WaitAny(new Task[] { pullRequest }, cancellationToken);
            var pullResponse = pullRequest.Result;

            int messageCount = pullResponse.ReceivedMessages == null ? 0
                : pullResponse.ReceivedMessages.Count;
            WriteLog("Received " + messageCount + " messages.",
                     TraceEventType.Information);
            if (messageCount < 1)
                return 0;  // Nothing pulled.  Nothing to do.

            // Examine the received message.
            var shoutRequestMessage = pullResponse.ReceivedMessages[0];
            var attributes = shoutRequestMessage.Message.Attributes;
            string postStatusUrl;
            string postStatusToken;
            DateTime requestDeadline;
            try
            {
                postStatusUrl = attributes["postStatusUrl"];
                postStatusToken = attributes["postStatusToken"];
                long unixDeadline = Convert.ToInt64(attributes["deadline"]);
                requestDeadline = FromUnixTime(unixDeadline);
            }
            catch (Exception e)
            {
                WriteLog("Bad shout request message attributes.\n" + e.ToString(),
                    TraceEventType.Warning);
                Acknowledge(shoutRequestMessage.AckId);
                return -1;
            }

            // Tell the world we are shouting this request.
            PublishStatus(postStatusUrl, postStatusToken, "shouting");
            WriteLog("Shouting " + postStatusUrl, TraceEventType.Verbose);

            try
            {
                // Decode the payload, the string we want to shout.
                byte[] data = Convert.FromBase64String(shoutRequestMessage.Message.Data);
                string decodedString = Encoding.UTF8.GetString(data);

                // Watch the clock and cancellation token as we work.  We need to extend the
                // ack deadline if the request takes a while.
                var tenSeconds = TimeSpan.FromSeconds(10);
                DateTime ackDeadline = DateTime.UtcNow + tenSeconds;
                ThrowIfAborted throwIfAborted = () =>
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    var now = DateTime.UtcNow;
                    if (requestDeadline < now)
                        throw new FatalException("Request timed out.");
                    if (ackDeadline < now)
                    {
                        // Tell the subscription we need more time:
                        WriteLog("Need more time...", TraceEventType.Verbose);
                        _init.PubsubService.Projects.Subscriptions.ModifyAckDeadline(
                            new ModifyAckDeadlineRequest
                            {
                                AckIds = new string[] { shoutRequestMessage.AckId },
                                AckDeadlineSeconds = 15,
                            }, MakeSubscriptionPath(_init.SubscriptionName)).Execute();
                        ackDeadline = now + tenSeconds;
                    }
                };

                // Shout it.
                string upperText = ShoutString(decodedString, throwIfAborted);

                // Publish the result.
                PublishStatus(postStatusUrl, postStatusToken, "success", upperText);
                Acknowledge(shoutRequestMessage.AckId);
                return 1;
            }
            catch (OperationCanceledException)
            {
                return 1;  // Service stopped.  Nothing to report.
            }
            catch (FatalException e)
            {
                WriteLog("Fatal exception while shouting:\n" + e.Message, TraceEventType.Error);
                Acknowledge(shoutRequestMessage.AckId);
                PublishStatus(postStatusUrl, postStatusToken, "fatal", e.Message);
                return -1;
            }
            catch (Exception e)
            {
                // Something went wrong while shouting.  Report the error.
                WriteLog("Exception while shouting:\n" + e.Message, TraceEventType.Error);
                PublishStatus(postStatusUrl, postStatusToken, "error", e.Message);
                return -1;
            }
        }
Example #13
0
        public Task<Position> GetPositionAsync(int timeout, System.Threading.CancellationToken cancelToken, bool includeHeading)
        {
            var t = GetPositionAsync(timeout, includeHeading);

            while (t.Status == TaskStatus.Running)
            {
                cancelToken.ThrowIfCancellationRequested();
            }

            return t;
        }
Example #14
0
        public async Task<Position> GetPositionAsync(System.Threading.CancellationToken cancelToken)
        {
            var t = locator.GetGeopositionAsync().AsTask();

            while (t.Status == TaskStatus.Running)
            {
                cancelToken.ThrowIfCancellationRequested();
            }

            var position = await t;
            
            return position.Coordinate.GetPosition();
        }
Example #15
0
        /// <summary>
        /// Writes the content of the ResponseStream a file indicated by the filePath argument.
        /// </summary>
        /// <param name="filePath">The location where to write the ResponseStream</param>
        /// <param name="append">Whether or not to append to the file if it exists</param>
        /// <param name="cancellationToken">Cancellation token which can be used to cancel this operation.</param>
        public async System.Threading.Tasks.Task WriteResponseStreamToFileAsync(string filePath, bool append, System.Threading.CancellationToken cancellationToken)
        {
            // Make sure the directory exists to write too.
            FileInfo fi = new FileInfo(filePath);
            Directory.CreateDirectory(fi.DirectoryName);

            Stream downloadStream;
            if (append && File.Exists(filePath))
                downloadStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.Read, S3Constants.DefaultBufferSize);
            else
                downloadStream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read, S3Constants.DefaultBufferSize);

            try
            {
                long current = 0;
#if CORECLR
                Stream stream = this.ResponseStream;
#else
                Stream stream = new BufferedStream(this.ResponseStream);
#endif
                byte[] buffer = new byte[S3Constants.DefaultBufferSize];
                int bytesRead = 0;
                long totalIncrementTransferred = 0;
                while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)
                    .ConfigureAwait(continueOnCapturedContext: false)) > 0)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    await downloadStream.WriteAsync(buffer, 0, bytesRead)
                        .ConfigureAwait(continueOnCapturedContext: false);
                    current += bytesRead;
                    totalIncrementTransferred += bytesRead;

                    if (totalIncrementTransferred >= AWSSDKUtils.DefaultProgressUpdateInterval ||
                        current == this.ContentLength)
                    {
                        this.OnRaiseProgressEvent(filePath, totalIncrementTransferred, current, this.ContentLength);
                        totalIncrementTransferred = 0;
                    }
                }

                ValidateWrittenStreamSize(current);
            }
            finally
            {
                downloadStream.Dispose();
            }
        }