public void TestAddActionRuns() { bool ran = false; Instant due = TimeHelpers.Clock.Now + Duration.FromMilliseconds(100); Assert.IsTrue(due > TimeHelpers.Clock.Now); ScheduledAction action = Scheduler.Add(() => { ran = true; }, new OneOffSchedule(due)); Assert.IsTrue(due > TimeHelpers.Clock.Now); Assert.IsNotNull(action); Assert.IsTrue(action.Enabled); Assert.AreEqual(Scheduler.DefaultMaximumHistory, action.MaximumHistory); Assert.AreEqual(Scheduler.DefaultMaximumDuration, action.MaximumDuration); Thread.Sleep(200); Assert.IsTrue(ran); Assert.AreEqual(1, action.History.Count()); ScheduledActionResult history = action.History.FirstOrDefault(); Assert.IsNotNull(history); Assert.IsFalse(history.Cancelled); Assert.IsNull(history.Exception); Assert.AreEqual(due, history.Due); Assert.IsTrue(history.Due <= history.Started); }
public static void ConfigureForNodaTime(this SwaggerGenOptions config, IDateTimeZoneProvider dateTimeZoneProvider) { var dateTimeZone = dateTimeZoneProvider[America.NewYork]; var instant = SystemClock.Instance.GetCurrentInstant(); var interval = new Interval(instant, instant + Duration.FromMilliseconds(182713784L)); var dateTimeInterval = interval.InZoneStrictly(dateTimeZone); var zonedDateTime = dateTimeZone.AtLeniently(instant.InZone(dateTimeZone).LocalDateTime.With(TimeAdjusters.TruncateToMinute)); var localDateTime = zonedDateTime.LocalDateTime; var localDate = localDateTime.Date; var dateInterval = localDateTime.Date.GetContainingWeekInterval(IsoDayOfWeek.Monday); var localTime = localDateTime.TimeOfDay; var timeInterval = new TimeInterval(localTime, localTime + Period.FromHours(3) + Period.FromMinutes(45)); var offsetDateTime = zonedDateTime.ToOffsetDateTime(); var duration = Duration.FromDays(2) + Duration.FromHours(3) + Duration.FromMinutes(45); var offset = dateTimeZone.GetUtcOffset(instant); var period = Period.FromTicks(duration.BclCompatibleTicks); config.MapStruct(instant); config.MapStruct(localDate); config.MapStruct(localTime); config.MapStruct(localDateTime); config.MapStruct(offsetDateTime); config.MapStruct(zonedDateTime); config.MapStruct(interval); config.MapClass(dateInterval); config.MapClass(dateTimeInterval); config.MapClass(timeInterval); config.MapStruct(offset); config.MapClass(period); config.MapStruct(duration); config.MapClass(dateTimeZone); }
public void Test_ZonedDateTime() { CreateTable("timestamptz"); var subject = new PostgreSQLCopyHelper <AllNodaTypesEntity>("sample", "noda_time_test") .MapTimeStampTz("col_noda", x => x.ZonedDateTime); var timezone = DateTimeZoneProviders.Tzdb.GetZoneOrNull("Africa/Kigali"); var instant = Instant.FromUtc(2011, 1, 5, 22, 50, 0) + Duration.FromMilliseconds(193); var entity = new AllNodaTypesEntity { ZonedDateTime = new ZonedDateTime(instant, timezone) }; var entities = new[] { entity }; subject.SaveAll(connection, entities); // Check what's written to DB: var rows = GetAll(); // TODO: How does Postgres <-> NodaTime convert Timezones? There is a good test here, but // I couldn't see through it yet: // // https://github.com/npgsql/npgsql/blob/766658172f08abb0b87a6b7f01a7ea4b49952a29/test/Npgsql.PluginTests/NodaTimeTests.cs // var actual = (Instant)rows[0][0]; Assert.AreEqual(instant, actual); }
private void ValidateZoneEquality(Instant instant, DateTimeZone nodaZone, TimeZoneInfo windowsZone) { // The BCL is basically broken (up to and including .NET 4.5.1 at least) around its interpretation // of its own data around the new year. See http://codeblog.jonskeet.uk/2014/09/30/the-mysteries-of-bcl-time-zone-data/ // for details. We're not trying to emulate this behaviour. // It's a lot *better* for .NET 4.6, // FIXME: Finish this comment, try again. (We don't test against .NET 4.5 any more...) var utc = instant.InUtc(); if ((utc.Month == 12 && utc.Day == 31) || (utc.Month == 1 && utc.Day == 1)) { return; } var interval = nodaZone.GetZoneInterval(instant); // Check that the zone interval really represents a transition. It could be a change in // wall offset, name, or the split between standard time and daylight savings for the interval. if (interval.RawStart != Instant.BeforeMinValue) { var previousInterval = nodaZone.GetZoneInterval(interval.Start - Duration.Epsilon); Assert.AreNotEqual(new { interval.WallOffset, interval.Name, interval.StandardOffset }, new { previousInterval.WallOffset, previousInterval.Name, previousInterval.StandardOffset }, "Non-transition from {0} to {1}", previousInterval, interval); } var nodaOffset = interval.WallOffset; // Some midnight transitions in the Noda Time representation are actually corrections for the // BCL data indicating 23:59:59.999 on the previous day. If we're testing around midnight, // allow the Windows data to be correct for either of those instants. var acceptableInstants = new List <Instant> { instant }; var localTimeOfDay = instant.InZone(nodaZone).TimeOfDay; if ((localTimeOfDay == LocalTime.Midnight || localTimeOfDay == LocalTime.MaxValue) && instant > NodaConstants.BclEpoch) { acceptableInstants.Add(instant - Duration.FromMilliseconds(1)); } var expectedOffsetAsTimeSpan = nodaOffset.ToTimeSpan(); // Find an instant that at least has the right offset (so will pass the first assertion). var instantToTest = acceptableInstants.FirstOrDefault(candidate => windowsZone.GetUtcOffset(candidate.ToDateTimeUtc()) == expectedOffsetAsTimeSpan); // If the test is definitely going to fail, just use the original instant that was passed in. if (instantToTest == default) { instantToTest = instant; } var windowsOffset = windowsZone.GetUtcOffset(instantToTest.ToDateTimeUtc()); Assert.AreEqual(windowsOffset, expectedOffsetAsTimeSpan, "Incorrect offset at {0} in interval {1}", instantToTest, interval); var bclDaylight = windowsZone.IsDaylightSavingTime(instantToTest.ToDateTimeUtc()); Assert.AreEqual(bclDaylight, interval.Savings != Offset.Zero, "At {0}, BCL IsDaylightSavingTime={1}; Noda savings={2}", instant, bclDaylight, interval.Savings); }
private JobProgress CalculateProgressAfterRead() { // There's no need to consider _context.End here. We just calculate the prospective next iteration span // and it will be looked at and fixed before the next iteration, if needed. if (!string.IsNullOrWhiteSpace(_readResponse.NextToken)) { return(new JobProgress(Progress.NextIterationStart, Progress.NextIterationEnd, _readResponse.NextToken)); } // If the current timespan is completed, we start from one millisecond after the end of this timespan // because AWS APIs accept milliseconds as timespan, so the resolution is 1 ms. And the API is // inclusive for both start and end, so we don't want events with timestamp equal to previous end // be returned twice. var start = Progress.NextIterationEnd.Plus(Duration.FromMilliseconds(1)); var endCutoffInstant = InstantUtils.SecondsAgo(_context.ClockSkewProtectionSeconds); var minEndInstant = start.Plus(Duration.FromSeconds(_context.MinIntervalSeconds)); var maxEndInstant = start.Plus(Duration.FromSeconds(_context.MaxIntervalSeconds)); if (minEndInstant > endCutoffInstant) { return(new JobProgress(start, minEndInstant, null)); } var end = maxEndInstant; if (end > endCutoffInstant) { end = endCutoffInstant; } return(new JobProgress(start, end, null)); }
private static DomainParticipantQos ConfigureFlowController( uint tokenBucketPeriodMs) { // We'll get the QoS defined in the XML profile "cfc_Profile" // (the default profile in USER_QOS_PROFILES.xml) and tweak the // token bucket period DomainParticipantQos baseQos = QosProvider.Default.GetDomainParticipantQos(); if (tokenBucketPeriodMs == 0) { return(baseQos); } // This is the name we use in the XML file const string flowControllerName = "dds.flow_controller.token_bucket.custom_flowcontroller"; // baseQos.WithProperty(...) creates a new DomainParticipantQos // object with the changes we specify in the lambda function. return(baseQos.WithProperty(property => { // In WithProperty the input argument 'property' contains the // current values of baseQos.Property. We will just modify these // two properties. var period = Duration.FromMilliseconds(tokenBucketPeriodMs); property[$"{flowControllerName}.token_bucket.period.sec"] = period.Seconds.ToString(); property[$"{flowControllerName}.token_bucket.period.nanosec"] = period.Nanoseconds.ToString(); })); }
private Timestamp GetNextNormalizedTimestamp(Timestamp tCurrent, Duration cycle, Duration offset, CalcInstance adapter) { Timestamp tNext = Time.GetNextNormalizedTimestamp(cycle, offset); Duration minDuration = Duration.FromMilliseconds(1); Duration c = cycle < minDuration ? minDuration : cycle; while (tNext <= tCurrent) { tNext += c; } Trigger trigger = adapter.triggerDurationWarning.GetTrigger(isOK: tNext == tCurrent + cycle); if (trigger == Trigger.On) { Log_Warn("Cycle", $"Cycle length of {cycle} not long enough for calculation {adapter.Name}!", null, new ObjectRef[] { adapter.ID }); } else if (trigger == Trigger.Off) { Log_ReturnToNormal("Cycle", $"Cycle length of {cycle} is long enough for calculation {adapter.Name}.", new ObjectRef[] { adapter.ID }); } return(tNext); }
internal void CanThrottleMessagesPer100Milliseconds_Test1() { // Arrange var throttler = new Throttler <string>( this.container, this.receiver.Endpoint.Send, Duration.FromMilliseconds(100), 10, "1"); // Act for (var i = 0; i < 21; i++) { throttler.Endpoint.SendAsync($"Message-{i + 1}"); } Task.Delay(10).Wait(); // Should receives only the first 10 messages var count1 = this.receiver.Messages.Count; // Wait for the throttle duration interval // Should receive the next 10 messages Task.Delay(100).Wait(); throttler.Stop().Wait(); // Assert Assert.Equal(10, count1); Assert.Equal(20, this.receiver.Messages.Count); Assert.Equal(1, throttler.QueueCount); Assert.True(throttler.IsActive); }
public async Task Run(int delayMs, Instant?start) { await using var conn = await _db.Obtain(); HashSet <Guid> lastIds = null; while (true) { var url = GetFeedUrl(start, 1000); var feedItems = await GetFeedItems(url); if (feedItems.Count == 0) { break; } if (lastIds != null && lastIds.SetEquals(feedItems.Select(i => i.Id))) { break; } var saved = await _feedStore.SaveFeedItems(conn, feedItems); _logger.Information("Fetched {ItemCount} new feed items starting at {BeforeFilter} ({NewItems} new)", feedItems.Count, start, saved); start = feedItems.Max(i => i.Timestamp) - Duration.FromMilliseconds(1); lastIds = feedItems.Select(i => i.Id).ToHashSet(); await Task.Delay(TimeSpan.FromMilliseconds(delayMs)); } _logger.Information("Done fetching feed!"); }
public static SwaggerDocsConfig ConfigureForNodaTime(this SwaggerDocsConfig config, IDateTimeZoneProvider timeZoneProvider) { var timeZone = timeZoneProvider[America.NewYork]; var instant = SystemClock.Instance.GetCurrentInstant(); var zonedDateTime = instant.InZone(timeZone); var localDate = zonedDateTime.Date; var localTime = zonedDateTime.TimeOfDay; var localDateTime = zonedDateTime.LocalDateTime; var offsetDateTime = zonedDateTime.ToOffsetDateTime(); var duration = Duration.FromMilliseconds(182713784L); var interval = new Interval(instant, instant + duration); var offset = timeZone.GetUtcOffset(instant); var period = Period.Between(localDateTime, localDateTime.PlusTicks(duration.BclCompatibleTicks)); config.MapStruct(instant); config.MapStruct(localDate); config.MapStruct(localTime); config.MapStruct(localDateTime); config.MapStruct(offsetDateTime); config.MapStruct(zonedDateTime); config.MapStruct(interval); config.MapStruct(offset); config.MapClass(period); config.MapStruct(duration); config.MapClass(timeZone); return(config); }
private static Duration _offsetFromStart(LocalTime time, TimePeriod period) { var offset = Duration.Zero; offset += Duration.FromTicks(time.TickOfSecond); offset += Duration.FromMilliseconds(time.Second); switch (period) { case TimePeriod.Hour: offset += Duration.FromMinutes(time.Minute); break; case TimePeriod.Minute: break; case TimePeriod.TenMinutes: offset += Duration.FromMinutes(time.Minute % 10); break; case TimePeriod.QuarterHour: offset += Duration.FromMinutes(time.Minute % 15); break; case TimePeriod.HalfHour: offset += Duration.FromMinutes(time.Minute % 30); break; } return(offset); }
public static void WaitForFile(string path, string pattern, int duration, int interval) { path = GetPathForFile(path); var bFound = Directory.GetFiles(path, pattern).Length > 0; var start = System.DateTime.Now; while (!bFound && (System.DateTime.Now < start + TimeSpan.FromMilliseconds(duration))) { bFound = Directory.GetFiles(path, pattern).Length > 0; if (bFound) { break; } Delay.Duration(Duration.FromMilliseconds(interval), false); } if (bFound) { Report.Success("Validation", "File with pattern '" + pattern + "' was found in directory '" + path + "'."); } else { Report.Failure("Validation", "File with pattern '" + pattern + "' wasn't found in directory '" + path + "'."); } }
internal void Equals_VariousValues_ReturnsExpectedResult( decimal price1, decimal price2, int millisecondsOffset, bool expected) { // Arrange var tick1 = new TradeTick( this.symbol, Price.Create(price1), Quantity.Create(10000), Maker.Buyer, new MatchId("123456789"), StubZonedDateTime.UnixEpoch()); var tick2 = new TradeTick( this.symbol, Price.Create(price2), Quantity.Create(10000), Maker.Buyer, new MatchId("123456789"), StubZonedDateTime.UnixEpoch() + Duration.FromMilliseconds(millisecondsOffset)); // Act var result1 = tick1.Equals(tick2); var result2 = tick1 == tick2; // Assert Assert.Equal(expected, result1); Assert.Equal(expected, result2); }
public void FromMilliseconds_Double(double milliseconds, int expectedDays, long expectedNanoOfDay) { var actual = Duration.FromMilliseconds(milliseconds); var expected = new Duration(expectedDays, expectedNanoOfDay); Assert.AreEqual(expected, actual); }
/// <summary> /// Changes the specified due time and period. /// </summary> /// <param name="period">The optional minimum gap (in milliseconds) between the start of the task invocation and the start of the previous task invocation; use <see langword="null"/> to leave the value unchanged.</param> /// <param name="dueTime">The optional due time (in milliseconds) between the last time the timeouts were changed and the start of the task invocation; use <see langword="null"/> to leave the value unchanged.</param> /// <param name="minimumGap">The optional minimum gap (in milliseconds) between the start of the task invocation and the end of the previous task invocation; use <see langword="null"/> to leave the value unchanged.</param> public void Change(int?period = null, int?dueTime = null, int?minimumGap = null) { Change( period.HasValue ? Duration.FromMilliseconds(period.Value) : (Duration?)null, dueTime.HasValue ? Duration.FromMilliseconds(dueTime.Value) : (Duration?)null, minimumGap.HasValue ? Duration.FromMilliseconds(minimumGap.Value) : (Duration?)null); }
public override async Task TakeMeasurementAsync() { if (CurrentState != SensorStateEnum.Initialized) { throw new InvalidOperationException("Can't take measurement on uninitialized sensor!"); } _bme680.ConfigureHeatingProfile(Bme680HeaterProfile.Profile2, Temperature.FromDegreesCelsius(280), Duration.FromMilliseconds(80), Temperature.FromDegreesCelsius(_lastMeasurement.Temperature)); var measurementDuration = _bme680.GetMeasurementDuration(_bme680.HeaterProfile); /* Force the sensor to take a measurement. */ _bme680.SetPowerMode(Bme680PowerMode.Forced); await Task.Delay(measurementDuration.ToTimeSpan()); _bme680.TryReadTemperature(out var temp); _bme680.TryReadHumidity(out var humidity); _bme680.TryReadPressure(out var pressure); _bme680.TryReadGasResistance(out var gasResistance); _lastMeasurement.Temperature = Math.Round(temp.DegreesCelsius, 2); _lastMeasurement.Pressure = Math.Round(pressure.Hectopascals, 2); _lastMeasurement.Humidity = Math.Round(humidity.Percent, 2); _lastMeasurement.VolatileOrganicCompounds = Math.Round(gasResistance.Kiloohms, 2); Logger?.LogDebug($"{DateTimeOffset.Now}:BME680: reading"); Logger?.LogInformation( $"temperature:{_lastMeasurement.Temperature:N2} \u00B0C|" + $"pressure:{_lastMeasurement.Pressure:N2} hPa|" + $"humidity:{_lastMeasurement.Humidity:N2} %rH|" + $"voc:{_lastMeasurement.VolatileOrganicCompounds}"); }
public void Add_MethodEquivalents() { const int minutes = 23; const int hours = 3; const int milliseconds = 40000; const long seconds = 321; const long nanoseconds = 12345; const long ticks = 5432112345; ZonedDateTime before = SampleZone.AtStrictly(new LocalDateTime(2011, 6, 12, 15, 0)); Assert.AreEqual(before + Duration.OneDay, ZonedDateTime.Add(before, Duration.OneDay)); Assert.AreEqual(before + Duration.OneDay, before.Plus(Duration.OneDay)); Assert.AreEqual(before + Duration.FromHours(hours), before.PlusHours(hours)); Assert.AreEqual(before + Duration.FromHours(-hours), before.PlusHours(-hours)); Assert.AreEqual(before + Duration.FromMinutes(minutes), before.PlusMinutes(minutes)); Assert.AreEqual(before + Duration.FromMinutes(-minutes), before.PlusMinutes(-minutes)); Assert.AreEqual(before + Duration.FromSeconds(seconds), before.PlusSeconds(seconds)); Assert.AreEqual(before + Duration.FromSeconds(-seconds), before.PlusSeconds(-seconds)); Assert.AreEqual(before + Duration.FromMilliseconds(milliseconds), before.PlusMilliseconds(milliseconds)); Assert.AreEqual(before + Duration.FromMilliseconds(-milliseconds), before.PlusMilliseconds(-milliseconds)); Assert.AreEqual(before + Duration.FromTicks(ticks), before.PlusTicks(ticks)); Assert.AreEqual(before + Duration.FromTicks(-ticks), before.PlusTicks(-ticks)); Assert.AreEqual(before + Duration.FromNanoseconds(nanoseconds), before.PlusNanoseconds(nanoseconds)); Assert.AreEqual(before + Duration.FromNanoseconds(-nanoseconds), before.PlusNanoseconds(-nanoseconds)); }
internal void CleanUp() { // Skip non-transactional modification methods because they could cause database connections to be reinitialized. cleanUpDatabaseConnectionsAndExecuteNonTransactionalModificationMethods(skipNonTransactionalModificationMethods: true); if (errorPrefix.Any() || errorException != null) { TelemetryStatics.ReportError(errorPrefix, errorException); MiniProfiler.Stop(); } else { var duration = SystemClock.Instance.GetCurrentInstant() - beginInstant; MiniProfiler.Stop(); if (MiniProfiler.Current != null) { duration = Duration.FromMilliseconds((double)MiniProfiler.Current.DurationMilliseconds); } const int thresholdInSeconds = 30; if (duration > Duration.FromSeconds(thresholdInSeconds) && !ConfigurationStatics.IsDevelopmentInstallation) { TelemetryStatics.ReportError( "Request took " + duration.TotalSeconds + " seconds to process. The threshold is " + thresholdInSeconds + " seconds.", null); } } }
public void TestAddActionCancel() { bool ran = false; Instant due = TimeHelpers.Clock.Now + Duration.FromMilliseconds(100); Duration duration = Duration.FromMilliseconds(20); ScheduledAction action = Scheduler.Add( () => { ran = true; // This needs to sleep longer than the max duration to ensure it will be cancelled Thread.Sleep((int)duration.TotalMilliseconds() * 2); }, new OneOffSchedule(due), maximumDuration: duration); Assert.IsNotNull(action); Assert.IsTrue(action.Enabled); Assert.AreEqual(Scheduler.DefaultMaximumHistory, action.MaximumHistory); Assert.AreEqual(duration, action.MaximumDuration); Thread.Sleep(200); Assert.IsTrue(ran); Assert.AreEqual(1, action.History.Count()); ScheduledActionResult history = action.History.FirstOrDefault(); Assert.IsNotNull(history); Assert.IsTrue(history.Cancelled); Assert.IsNull(history.Exception); Assert.AreEqual(due, history.Due); Assert.IsTrue(history.Due <= history.Started); }
public void DoNotSaveIfAsked(RepoItemInfo buttonInfo) { if (buttonInfo.Exists(Duration.FromMilliseconds(1000))) { Report.Log(ReportLevel.Info, "Mouse", "(Optional Action)\r\nMouse Left Click item 'buttonInfo' at Center.", buttonInfo); buttonInfo.FindAdapter <Button>().Click(); } }
public void ConstructionFromMilliseconds() { Duration duration = Snippet.For(Duration.FromMilliseconds(600)); Assert.AreEqual(600, duration.Milliseconds); Assert.AreEqual(0.6, duration.TotalSeconds); Assert.AreEqual("0:00:00:00.6", duration.ToString()); }
public void RoundTrip() { var startInstant = Instant.FromUtc(2012, 1, 2, 3, 4, 5) + Duration.FromMilliseconds(670); var endInstant = Instant.FromUtc(2013, 6, 7, 8, 9, 10) + Duration.FromNanoseconds(123456789); var interval = new Interval(startInstant, endInstant); AssertConversions(interval, "{\"Start\":\"2012-01-02T03:04:05.67Z\",\"End\":\"2013-06-07T08:09:10.123456789Z\"}", settings); }
static void Main(string[] args) { _dpf = DomainParticipantFactory.Instance; ErrorHandler.checkHandle(_dpf, "Domain Participant Factory"); _dp = _dpf.CreateParticipant(Domain); //Initialize QOS pQos = new PublisherQos(); dwQos = new DataWriterQos(); fdmDataType = new FDMTypeSupport(); string FDMDATATypeName = fdmDataType.TypeName; ReturnCode status = fdmDataType.RegisterType(_dp, FDMDATATypeName); ErrorHandler.checkStatus(status, "FDMDATA: Cannot Register Type"); //Create FDMDATA Topic fdmDataTopic = _dp.FindTopic("FDMDATA", Duration.FromMilliseconds(1000)); if (fdmDataTopic == null) { fdmDataTopic = _dp.CreateTopic("FDMDATA", FDMDATATypeName); } ErrorHandler.checkHandle(fdmDataTopic, "Cannot Create Topic FDMDATA"); //Get Publisher QOS and Set Partition Name _dp.GetDefaultPublisherQos(ref pQos); pQos.Partition.Name = new String[1]; pQos.Partition.Name[0] = PartitionName; //Create Subscriber for FDMDATA Topic Publisher = _dp.CreatePublisher(pQos); ErrorHandler.checkHandle(Publisher, "Cannot Create FDMDATA Publisher"); //Get Data Writer QOS and Set History Depth Publisher.GetDefaultDataWriterQos(ref dwQos); ErrorHandler.checkHandle(dwQos, "Cannot get Data Writer Qos"); dwQos.History.Depth = 5; dwQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos; //Create DataReader for FDMDATA Topic parentWriter = Publisher.CreateDataWriter(fdmDataTopic, dwQos); ErrorHandler.checkHandle(parentWriter, "Cannot Create FDMDATA Data Writer"); //Narrow abstract parentWriter into its typed representative fdmDataWriter = parentWriter as FDMDataWriter; ErrorHandler.checkHandle(fdmDataWriter, "Cannot Narrow FDMDATA Data Writer"); fdmData = new FDM(); while (true) { StartPublish(); Console.WriteLine("Publishing data! "); Thread.Sleep(10); } }
static void Main(string[] args) { _dpf = DomainParticipantFactory.Instance; ErrorHandler.checkHandle(_dpf, "Domain Participant Factory"); _dp = _dpf.CreateParticipant(Domain); //Initialize QOS sQos = new SubscriberQos(); drQos = new DataReaderQos(); fdmDataType = new FDMTypeSupport(); string FDMDATATypeName = fdmDataType.TypeName; ReturnCode status = fdmDataType.RegisterType(_dp, FDMDATATypeName); ErrorHandler.checkStatus(status, "FDMDATA: Cannot Register Type"); //Create FDMDATA Topic fdmDataTopic = _dp.FindTopic("FDMDATA", Duration.FromMilliseconds(1000)); if (fdmDataTopic == null) { fdmDataTopic = _dp.CreateTopic("FDMDATA", FDMDATATypeName); } ErrorHandler.checkHandle(fdmDataTopic, "Cannot Create Topic FDMDATA"); //Get Subscriber QOS and Set Partition Name _dp.GetDefaultSubscriberQos(ref sQos); sQos.Partition.Name = new String[1]; sQos.Partition.Name[0] = PartitionName; //Create Subscriber for FDMDATA Topic Subscriber = _dp.CreateSubscriber(sQos); ErrorHandler.checkHandle(Subscriber, "Cannot Create FDMDATA Subscriber"); //Get Data Reader QOS and Set History Depth Subscriber.GetDefaultDataReaderQos(ref drQos); ErrorHandler.checkHandle(drQos, "Cannot get Data Reader Qos"); drQos.History.Depth = 5; drQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos; //Create DataReader for FDMDATA Topic parentReader = Subscriber.CreateDataReader(fdmDataTopic, drQos); ErrorHandler.checkHandle(parentReader, "Cannot Create FDMDATA Data Reader"); //Narrow abstract parentReader into its typed representative fdmDataReader = parentReader as FDMDataReader; ErrorHandler.checkHandle(fdmDataReader, "Cannot Narrow FDMDATA Data Reader"); // drQos.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos; fdmData = new FDM(); //Rececieve Loop while (true) { StartReceive(); Console.WriteLine("abc: " + fdmData.aa.ToString()); } }
private async Task HandleAsync(SchedulerBatch <T> document) { if (document.RetryCount > schedulerOptions.ExecutionRetries.Length) { await schedulerStore.CompleteAsync(document.Id); return; } var canRetry = document.RetryCount < schedulerOptions.ExecutionRetries.Length; try { var isConfirmed = true; if (Debugger.IsAttached) { isConfirmed = await onSuccess(document.Jobs, !canRetry, default); } else { using (var timeout = new CancellationTokenSource(schedulerOptions.Timeout)) { isConfirmed = await onSuccess(document.Jobs, !canRetry, timeout.Token); } } if (isConfirmed) { await schedulerStore.CompleteAsync(document.Id); } } catch (Exception ex) { log.LogError(ex, "Failed to handle job."); if (canRetry) { var wait = Duration.FromMilliseconds(schedulerOptions.ExecutionRetries[document.RetryCount]); var nextTime = document.DueTime.Plus(wait); await schedulerStore.RetryAsync(document.Id, nextTime); } else { try { await onError(document.Jobs, ex, default); } catch (Exception ex2) { log.LogError(ex2, "Failed to handle job."); } } } }
public void GenerateCodeLiteral_returns_duration_literal() { Assert.Equal("NodaTime.Duration.FromHours(5)", CodeLiteral(Duration.FromHours(5))); Assert.Equal("NodaTime.Duration.FromDays(4) + NodaTime.Duration.FromHours(5) + NodaTime.Duration.FromMinutes(6L) + " + "NodaTime.Duration.FromSeconds(7L) + NodaTime.Duration.FromMilliseconds(8L)", CodeLiteral(Duration.FromDays(4) + Duration.FromHours(5) + Duration.FromMinutes(6) + Duration.FromSeconds(7) + Duration.FromMilliseconds(8))); }
/// <summary> /// Returns the next time interval with a ceiling based on the given duration. /// </summary> /// <param name="time">The time.</param> /// <param name="duration">The duration ceiling.</param> /// <returns>The <see cref="ZonedDateTime"/> plus the rounded duration ceiling.</returns> public static ZonedDateTime Ceiling(this ZonedDateTime time, Duration duration) { Debug.NotDefault(time, nameof(time)); Debug.NotDefault(duration, nameof(duration)); var offset = CeilingOffsetMilliseconds(time, duration); return(time + Duration.FromMilliseconds(offset)); }
private static Duration CreateDuration(double days, double hours, double minutes, double seconds, double milliseconds = 0d, double ticks = 0d) { return(Duration.FromDays(days) + Duration.FromHours(hours) + Duration.FromMinutes(minutes) + Duration.FromSeconds(seconds) + Duration.FromMilliseconds(milliseconds) + Duration.FromTicks(ticks)); }
static void AppendSpecial(Timestamp t, List <VTTQ> list) { list.Add(VTTQ.Make(DataValue.FromString(""), t + Duration.FromSeconds(10), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString("A"), t + Duration.FromSeconds(11), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString("Ä"), t + Duration.FromSeconds(18), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString("AB"), t + Duration.FromSeconds(19), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString("ÖÜÄ"), t + Duration.FromSeconds(30), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString(new string('P', 255)), t + Duration.FromSeconds(34), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString(new string('a', 500)), t + Duration.FromSeconds(38), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.FromString(new string('ä', 9000)), t + Duration.FromMilliseconds(55005), t, Quality.Good)); list.Add(VTTQ.Make(DataValue.Empty, t + Duration.FromSeconds(30), t, Quality.Good)); }
public void Deserialize() { string json = "{\"Start\":\"2012-01-02T03:04:05.67Z\",\"End\":\"2013-06-07T08:09:10.1234567Z\"}"; var interval = JsonConvert.DeserializeObject <Interval>(json, settings); var startInstant = Instant.FromUtc(2012, 1, 2, 3, 4, 5) + Duration.FromMilliseconds(670); var endInstant = Instant.FromUtc(2013, 6, 7, 8, 9, 10) + Duration.FromTicks(1234567); var expectedInterval = new Interval(startInstant, endInstant); Assert.AreEqual(expectedInterval, interval); }