/// <summary> /// Method checks is any BuildRoutes operation was started in other dates. /// </summary> /// <returns>True if no any BuildRoutes already started or application settings allows multiple BuildRoutes.</returns> /// <param name="info">Out param where method save AsyncOperationInfo with date where BuildRoutes is running.</param> private bool _CanBuildRoutesBeStarted(out AsyncOperationInfo outInfo) { bool canBuildRoutesBeStarted = true; // If "key" file allows multiple build routes - return "true". if (_isKeyToAllowMultipleBuildRoutesExist) { outInfo = null; return(true); } bool allowDisabledExecution = false; AsyncOperationInfo info = null; foreach (Guid id in OperationsIds) // Check all running operations. { App.Current.Solver.GetAsyncOperationInfo(id, out info); if (info.OperationType == SolveOperationType.BuildRoutes && info.Schedule.PlannedDate != App.Current.CurrentDate) { canBuildRoutesBeStarted = false; // "info" contains date where BuildRoutes is running. allowDisabledExecution = true; break; } info = null; // Set out parameter to null if BuildRoutes operation was not found. } outInfo = info; AllowDisabledExecution = allowDisabledExecution; return(canBuildRoutesBeStarted); }
public async Task FinishAsync(AsyncOperationInfo operationInfo) { await _partsProviderSupplier.ProvideLastPartAsync();// Provide last piece of data _parsingResult = await _parserFuture; _rawDumpStream.Dispose(); }
public async Task <byte[]> WaitAsync(int count, WaitMode mode, AsyncOperationInfo operationInfo) { throwIfDisposed(); _responseReadTimeout.ThrowIfTimeout(); operationInfo.CancellationToken.ThrowIfCancellationRequested(); byte[] waitResult = null; try { using (_waitTimeout.RestartMode) { switch (mode) { case WaitMode.EXACT: var buffer = new List <byte>(count); while (buffer.Count != count) { _responseReadTimeout.ThrowIfTimeout(); var result = await _pipe.ReadAsync(new PipeReadParameters(count - buffer.Count), _cancellation); if (result.Status.IsOneOf(IOBase.ReadStatus.DONE, IOBase.ReadStatus.PATIALLY_DONE)) { buffer.AddRange(result.Data); } else { throw new NotSupportedException(); } } waitResult = buffer.ToArray(); break; case WaitMode.NO_MORE_THAN: { var result = await _pipe.ReadAsync(new PipeReadParameters(count), _cancellation); if (result.Status.IsOneOf(IOBase.ReadStatus.DONE, IOBase.ReadStatus.PATIALLY_DONE)) { waitResult = result.Data.ToArray(); } else { throw new NotSupportedException(); } } break; default: throw new NotSupportedException(); } } return(waitResult); } finally { await Logger.LogResponseAsync(waitResult ?? new byte[0], count); } }
public override async Task DeactivateDeviceAsync(DeviceOperationScope scope, AsyncOperationInfo cancellation) { using (await _connectionInterface.LockAsync(cancellation)) { await _base.DeactivateDeviceAsync(scope, cancellation); } }
/// <summary> /// Method gets name of route which contains assigned orders. /// </summary> /// <param name="info">Operation information.</param> /// <returns>Route name.</returns> private static string _GetAssignedRouteName(AsyncOperationInfo info) { Debug.Assert(info != null); var inputParameters = (AssignOrdersParams)info.InputParams; ICollection <Route> targetRoutes = inputParameters.TargetRoutes; string routeName = null; if (targetRoutes.Count == 1) { // In most cases only one route is targeted. routeName = string.Format( (string)App.Current.FindResource(OPTION_WITH_QUOTES), targetRoutes.First().Name); } else { // Orders assigned to Best Route. routeName = (string)App.Current.FindResource(BEST_ROUTES_RESOURCE_NAME); } return(routeName); }
/// <summary> /// Method gets route name for assigned order. /// </summary> /// <param name="info">Operation info.</param> /// <param name="order">Assigned order.</param> /// <returns>Route name or empty string, in case order is unassigned.</returns> private static string _GetRouteNameForAssignedOrder( AsyncOperationInfo info, Order order) { Debug.Assert(info != null); Debug.Assert(order != null); var inputParameters = (AssignOrdersParams)info.InputParams; ICollection <Route> targetRoutes = inputParameters.TargetRoutes; // Search for stop associated with order, which was assigned to route. var assignedStops = from route in targetRoutes where route.Stops != null from stop in route.Stops where (stop.AssociatedObject == order) select stop; string routeName = string.Empty; if (assignedStops.Any()) { Stop stop = assignedStops.First(); routeName = stop.Route.Name; } return(routeName); }
/// <summary> /// Method gets status message: unassign operation completed. /// </summary> /// <param name="info">Operation information.</param> /// <returns>Message.</returns> public static string GetUnassignOperationCompletedMessage(AsyncOperationInfo info) { Debug.Assert(info != null); string result = string.Empty; var orders = ((UnassignOrdersParams)info.InputParams).OrdersToUnassign; int unassignedOrdersCount = orders.Count; string unassignedOrdersName = (string)App.Current.FindResource(UNASSIGNED_ORDERS_RESOURCE_NAME); if (unassignedOrdersCount == 1) { // Create message for only one unassigned order. Order order = orders.First(); if (order != null) { result = string.Format( (string)App.Current.FindResource(ORDER_MOVED), order.Name, unassignedOrdersName); } } else { // Create message for all unassigned orders. result = string.Format( (string)App.Current.FindResource(ALL_ORDERS_MOVED), unassignedOrdersCount, unassignedOrdersName); } return(result); }
/// <summary> /// Method gets status message: unassign operation completed, /// for multiple unassign operation. /// </summary> /// <param name="schedule">Schedule where operation proceeded.</param> /// <param name="info">Operation information.</param> /// <returns>Message.</returns> public static string GetMultipleUnassignOperationCompletedMessage( Schedule schedule, AsyncOperationInfo info) { Debug.Assert(schedule != null); Debug.Assert(info != null); string result = string.Empty; var orders = ((UnassignOrdersParams)info.InputParams).OrdersToUnassign; int unassignedOrdersCount = orders.Count; if (unassignedOrdersCount == 1) { // Create message for only one unassigned order. Order order = orders.First(); if (order != null) { result = string.Format( (string)App.Current.FindResource(ORDER_UNASSIGNED_FROM_SCHEDULES), order.Name, schedule.Name); } } else { // Create message for all unassigned orders. result = string.Format( (string)App.Current.FindResource(ORDERS_UNASSIGNED_FROM_SCHEDULES), unassignedOrdersCount, schedule.Name); } return(result); }
protected void Cmd_AsyncSolveCompleted(object sender, AsyncSolveCompletedEventArgs e) { // check is completed operation was started by this command if (OperationsIds.Contains(e.OperationId)) { _operationsIds.Remove(e.OperationId); AsyncOperationInfo info = null; Schedule schedule = null; if (App.Current.Solver.GetAsyncOperationInfo(e.OperationId, out info)) { schedule = info.Schedule; } IsEnabled = true; if (e.Cancelled) { App.Current.Messenger.AddInfo(_FormatCancelMsg(schedule)); } else if (e.Error != null) { _HandleSolveError(e.Error); } else { SolveResult res = e.Result; if (schedule != null) { _SaveSchedule(res, schedule, info); } } } }
/// <summary> /// /// </summary> /// <param name="from"></param> /// <param name="count"></param> /// <param name="operationInfo"></param> /// <returns></returns> public async Task <IPointsRow[]> GetDecimatedRangeAsync(int from, int count, AsyncOperationInfo operationInfo) { #warning what if underlying collection is not thread safe? Or it decreases its size?! await ThreadingUtils.ContinueAtThreadPull(operationInfo); IPointsRow[] result; if (count > _maxRowsCount) // Decimation required { var coefficient = (double)count / _maxRowsCount; var sourceRows = _maxRowsCount .Range() .AsParallel() .AsOrdered() .Select(i => (i * coefficient + from).Round()) .Where(i => i < Source.RowsCount) // To handle possible rounding error .ToArray(); return(await Source.ReadRowsAsync(from, sourceRows, operationInfo)); } else { result = await Source.ReadRowsAsync(from, count, operationInfo); } return(result); }
public async Task <byte[]> WaitAsync(int count, WaitMode waitMode, AsyncOperationInfo operationInfo) { var notYetReadBytes = _array.Count - _position; switch (waitMode) { case WaitMode.EXACT: if (notYetReadBytes < count) { throw new TimeoutException(); } else { _position += count; return(await _array.GetRangeAsync(_position - count, count, operationInfo)); } case WaitMode.NO_MORE_THAN: var dataToRead = (int)Math.Min(notYetReadBytes, count); _position += dataToRead; return(await _array.GetRangeAsync(_position - dataToRead, dataToRead, operationInfo)); default: throw new NotSupportedException(); } }
public async Task <byte[]> WaitAsync(int count, WaitMode waitMode, AsyncOperationInfo operationInfo) { var maxCount = _response.Count - _position; switch (waitMode) { case WaitMode.EXACT: if (maxCount < count) { throw new TimeoutException(); } else { var result = _response.GetRange(_position, count).ToArray(); _position += count; return(result); } case WaitMode.NO_MORE_THAN: var msxAvailableBytes = Math.Min(maxCount, _position + count) - _position; var bytesToRead = Math.Min(count, msxAvailableBytes); _position += bytesToRead; return(_response.GetRange(_position, bytesToRead).ToArray()); default: throw new NotSupportedException(); } }
async Task <Stream> openStream(Part part, StreamParameters parameters, AsyncOperationInfo operationInfo) { var baseStream = new FileStream(_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, parameters.ReadBufferSize); baseStream.Position = part.Position; return(new SectionedStreamProxy(baseStream, part.Length)); }
public override async Task <byte[]> WaitAsync(int count, WaitMode mode, AsyncOperationInfo operationInfo) { var data = await base.WaitAsync(count, mode, operationInfo); Storage.AddRange(data); return(data); }
/// <summary> /// Handle contains logic to save changes, start new operation or process errors when solve conpleted. /// </summary> /// <param name="sender">Solver.</param> /// <param name="e">Solve completed event args.</param> private void Solver_AsyncSolveCompleted(object sender, AsyncSolveCompletedEventArgs e) { // If event came from any else solve operation - exit. if (e.OperationId != _currentOperationId) { return; } AsyncOperationInfo info = null; App.Current.Solver.GetAsyncOperationInfo(e.OperationId, out info); // Get operation info. // If operation complete successful. if (e.Error == null && !e.Cancelled && !e.Result.IsFailed) { Schedule changedSchedule = info.Schedule; _ProcessSaveSchedule(changedSchedule, info); // Save edited schedule. _SetScheduleProcessed(changedSchedule); // Set schedule Processed to "true". App.Current.Messenger.AddInfo(_FormatSuccessSolveCompletedMsg(changedSchedule, info)); // Add info message. _NotifyScheduleChanged(changedSchedule); UnassignScheduleInfo nextInfo = null; if (_GetNextScheduleToUnassign(out nextInfo)) { _StartNextScheduleUnassigning(nextInfo); return; } _ProcessOrders(_args); // Call abstract method _ProcessOrders overrided in child command (to move orders to other date or delete them). } else if (e.Error != null) // If Error occured during operation. { Logger.Error(e.Error); CommonHelpers.AddRoutingErrorMessage(e.Error); if (e.Result != null) // Result is "null" when connection failed. { // Create violations collection. ICollection <MessageDetail> details = _GetErrorFailedDetails(info, e.Result); _ShowFailedMessage(e.Error, info.Schedule, details); // Show failed message. } } else if (e.Cancelled) // If operation was cancelled. { App.Current.Messenger.AddInfo(_FormatCancelMsg(info.Schedule)); } else if (e.Result.IsFailed) // If operation's failed. { // Create violations collection. ICollection <MessageDetail> details = _GetErrorFailedDetails(info, e.Result); _ShowFailedMessage(e.Error, info.Schedule, details); } _UpdateOptimizeAndEditPageSchedules(); // Update optimize and edit page content. _CleanUp(); _UnlockUI(); }
public Task SaveAsync(RUSDeviceId deviceId, IDictionary <RUSDeviceId, IEnumerable <IDataEntity> > dataPacketFormats, Stream rawDump, Stream uncompressedParsedData, Stream destination, AsyncOperationInfo operationInfo) { return(FlashDump.SaveAsync(deviceId, dataPacketFormats, rawDump, uncompressedParsedData, destination, operationInfo)); }
public async Task DeactivateDeviceAsync(DeviceOperationScope scope, AsyncOperationInfo cancellation) { Logger.LogInfo(null, $"Деактивация устройства \"{Name}\"..."); using (Logger.Indent) { await deactivateDeviceAsync(scope, cancellation); Logger.LogOK(null, $"Устройство \"{Name}\" деактивировано"); } }
public override async Task DeactivateDeviceAsync(DeviceOperationScope scope, AsyncOperationInfo cancellation) { try { await _base.DeactivateDeviceAsync(scope, cancellation); } catch (OperationCanceledException) { throw; } catch (Exception ex) { Logger.LogErrorEverywhere("Ошибка деактивации устройства", ex); } }
/// <summary> /// Method saves schedule /// </summary> private void _ProcessSaveSchedule(Schedule schedule, AsyncOperationInfo info) { // set unassigned orders if (null != schedule.UnassignedOrders) { schedule.UnassignedOrders.Dispose(); } schedule.UnassignedOrders = App.Current.Project.Orders.SearchUnassignedOrders(schedule, true); // save results App.Current.Project.Save(); }
public FlashDumpLoadVM(RUSDeviceId rusDevice, BusyObject isBusy) { IsBusy = isBusy; DataStorageVM = new FlashDataStorageVM(this); Load = new ActionCommand(loadAsync, IsBusy); Cancel = new ActionCommand(cancelAsync, () => _currentOperation != null, IsBusy); async Task loadAsync() { using (IsBusy.BusyMode) { var path = IOUtils.RequestFileOpenPath("BIN (*.bin)|*.bin"); if (path == null) { return; } try { _currentOperation = new AsyncOperationInfo().UseInternalCancellationSource(); _currentOperationTask = LoadAsync(path, _currentOperation); Cancel.Update(); await _currentOperationTask; Logger.LogOKEverywhere("Дамп Flash успешно загружен"); } catch (OperationCanceledException) { Logger.LogInfoEverywhere("Чтение дампа Flash отменено"); PointsSource = null; } catch (Exception ex) { Logger.LogError("Ошибка загрузки дампа", $"-MSG", ex); PointsSource = null; } finally { _currentOperationTask = null; _currentOperation = null; } } } async Task cancelAsync() { _currentOperation?.Cancel(); } }
/// <summary> /// Method gets details messages about successfully assigned orders during /// routing operation. Details message are expanded by route names. /// </summary> /// <param name="schedule">Schedule.</param> /// <param name="info">Operation info.</param> /// <returns>Collection of message details.</returns> private ICollection <MessageDetail> _GetSuccessfullyAssignedOrdersDetails( Schedule schedule, AsyncOperationInfo info) { var routedOrdersDetails = new Collection <MessageDetail>(); ICollection <Order> ordersToAssign = _GetOrdersToAssign(info); if (ordersToAssign == null) { return(routedOrdersDetails); } // Find all pairs Route & Order. var detailsPairs = new List <KeyValuePair <Route, Order> >(); foreach (Order order in ordersToAssign) { foreach (Route route in schedule.Routes) { foreach (Stop stop in route.Stops) { if (stop.AssociatedObject is Order && ((Order)stop.AssociatedObject).Equals(order)) { var pair = new KeyValuePair <Route, Order>( route, order); detailsPairs.Add(pair); } } } } string formatString = (string)App.Current.FindResource(ORDERS_SUCCESSFULLY_ASSIGNED); // Add messages expanded by Routes. foreach (Route route in schedule.Routes) { foreach (KeyValuePair <Route, Order> pair in detailsPairs) { if (pair.Key.Name == route.Name) { DataObject[] parameters = new DataObject[] { pair.Value, pair.Key }; MessageDetail detail = new MessageDetail(MessageType.Information, formatString, parameters); routedOrdersDetails.Add(detail); } } } return(routedOrdersDetails); }
public override async Task <byte[]> WaitAsync(int count, WaitMode waitMode, AsyncOperationInfo operationInfo) { var result = await base.WaitAsync(count, waitMode, operationInfo); ReadCount += result.Length; var bytesToStore = Math.Min(Capacity - (ReadCount - result.Length), result.Length).NegativeToZero().ToInt32(); if (bytesToStore != 0) { _storage.Add(result.Take(bytesToStore)); StorageCount += bytesToStore; } return(result); }
/// <summary> /// Occurs when solve operation completed /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnAsyncSolveCompleted(object sender, AsyncSolveCompletedEventArgs e) { AsyncOperationInfo info = null; Schedule schedule = null; if (App.Current.Solver.GetAsyncOperationInfo(e.OperationId, out info)) { schedule = info.Schedule; } if (schedule != null && !_pendingDatesToUpdate.Contains((DateTime)schedule.PlannedDate)) { _pendingDatesToUpdate.Add((DateTime)schedule.PlannedDate); _optimizeAndEditPage.Dispatcher.BeginInvoke(new DayStatusDelegate(_UpdateDayStatus), System.Windows.Threading.DispatcherPriority.Send); } }
private void _AsyncSolveCompleted(object sender, AsyncSolveCompletedEventArgs e) { Schedule schedule = null; AsyncOperationInfo info = null; if (App.Current.Solver.GetAsyncOperationInfo(e.OperationId, out info)) { schedule = info.Schedule; } if (!IsEnabled) { IsEnabled = ((null == _schedulePage.CurrentSchedule) || (schedule.PlannedDate == _schedulePage.CurrentSchedule.PlannedDate)); } }
public static ICollection <Route> GetRoutingCommandRoutes(Schedule schedule, AsyncOperationInfo info) { ICollection <Route> routes = null; switch (info.OperationType) { case SolveOperationType.BuildRoutes: routes = GetBuildRoutes(schedule); break; case SolveOperationType.SequenceRoutes: { Debug.Assert(null != info.InputParams); SequenceRoutesParams param = info.InputParams as SequenceRoutesParams; routes = param.RoutesToSequence; break; } case SolveOperationType.UnassignOrders: { UnassignOrdersParams param = info.InputParams as UnassignOrdersParams; routes = ViolationsHelper.GetRouteForUnassignOrders(schedule, param.OrdersToUnassign); break; } case SolveOperationType.AssignOrders: { AssignOrdersParams param = info.InputParams as AssignOrdersParams; routes = param.TargetRoutes; break; } case SolveOperationType.GenerateDirections: { GenDirectionsParams param = info.InputParams as GenDirectionsParams; routes = param.Routes; break; } default: Debug.Assert(false); // NOTE: not supported break; } return(routes); }
/// <summary> /// Method check is command enabled. /// </summary> private void _CheckEnabled() { Schedule schedule = _optimizeAndEditPage.CurrentSchedule; bool hasOrders = ((schedule != null) && (schedule.UnassignedOrders != null) && ((schedule.UnassignedOrders.Count > 0) || ScheduleHelper.DoesScheduleHaveBuiltRoutes(schedule))); AsyncOperationInfo info = null; bool canBuildRoutesBeStarted = _CanBuildRoutesBeStarted(out info); bool isPageStateAllowRouting = (hasOrders && (schedule.Routes.Count > 0) && !_optimizeAndEditPage.IsEditingInProgress && !_optimizeAndEditPage.IsLocked && !_DoesAllRoutesLocked()); // AllowDisabledExecution should be "false" if editing in progress. AllowDisabledExecution = isPageStateAllowRouting; IsEnabled = (isPageStateAllowRouting && canBuildRoutesBeStarted); }
/// <summary> /// Method returns collection of violation message details. /// </summary> /// <param name="schedule">Schedule to be checked.</param> /// <param name="info">Solver's asyncrone operation info.</param> /// <param name="violations">Founded violations.</param> /// <returns>Message detail with description for violations.</returns> public static ICollection <MessageDetail> GetViolationDetails(Schedule schedule, AsyncOperationInfo info, ICollection <Violation> violations) { Debug.Assert(null != schedule); Debug.Assert(0 < violations.Count); // special case bool isSpecialCase = false; Order orderToAssign = null; if (SolveOperationType.AssignOrders == info.OperationType) { AssignOrdersParams param = (AssignOrdersParams)info.InputParams; if (null != param.TargetSequence) { isSpecialCase = param.TargetSequence.HasValue; } if (isSpecialCase) { Debug.Assert(1 == param.OrdersToAssign.Count); orderToAssign = param.OrdersToAssign.First(); } } ICollection <MessageDetail> details = null; if (!isSpecialCase && _IsRouteRelatedViolationPresent(violations)) { details = _GetRouteViolationDetails(violations); } else { ICollection <Route> routes = ViolationsHelper.GetRoutingCommandRoutes(schedule, info); Debug.Assert((null != routes) && (0 < routes.Count)); details = _GetViolationDetails(routes, isSpecialCase, orderToAssign, violations); } return(details); }
public async Task LoadAsync(string dumpPath, AsyncOperationInfo operationInfo) { if (dumpPath != null) { await NetFrameworkUtils.ContinueAtUIThread(); var dump = await FlashDump.OpenAsync(dumpPath, operationInfo); var dataParser = new SectionedDataPacketParser( dump.DataRowDescriptors.Select(ds => new SectionedDataPacketParser.Section( ds.Key, new DataPacketParser(ds.Value))).ToArray()); var dumpReader = await FlashDumpDataParser.CreateParserAsync(dump, dataParser, operationInfo); var rowsReader = await dumpReader.InstantiateReaderAsync(operationInfo); var rowsCollection = new FileMappedPointsRowsReadOnlyCollection(rowsReader); PointsSource = new DataPointsSource(new EnhancedObservableCollection <ICurveInfo>(dataParser.Curves, new CollectionOptions(true)), rowsCollection); } }
/// <summary> /// Method shows that Order was assigned to that Route /// in message window. /// </summary> /// <param name="schedule">Schedule.</param> /// <param name="info">Operation info.</param> protected void _ShowSuccessfullyAssignedOrders(Schedule schedule, AsyncOperationInfo info) { var assignOrdersDetails = _GetSuccessfullyAssignedOrdersDetails(schedule, info); // Add success details only in case of more than 1 orders assigned, // otherwise head message is good enough. if (assignOrdersDetails.Count > 1) { App.Current.Messenger.AddInfo( _FormatSuccessSolveCompletedMsg(schedule, info), assignOrdersDetails); } else { assignOrdersDetails.Clear(); App.Current.Messenger.AddInfo( _FormatSuccessSolveCompletedMsg(schedule, info), assignOrdersDetails); } }
public async static Task <FlashStreamReader> CreateAsync(RUSDeviceId device, IDictionary <RUSDeviceId, IEnumerable <IDataEntity> > formats, IFlashDumpDataParserFactory parserFactory, AsyncOperationInfo operationInfo) { var flashDumpPath = Storaging.GetTempFilePath(); var baseStream = new FileStream(flashDumpPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read); var flashDumpWriteStream = new FillNotifiableWriteOnlyStreamDecorator(CHUNK_SIZE, baseStream); var partsProvider = new DumpParserPartsProvider(flashDumpPath); var partsProviderSupplier = new StreamPartsProviderSupplier(flashDumpWriteStream, partsProvider); var scope = new DeviceOperationScope(new FlashDumpStreamParameter(flashDumpWriteStream)); var sections = formats.Select(f => new SectionedDataPacketParser.Section( f.Key, new DataPacketParser(EntitiesDeserializer.ExtractDataPacketDescriptors(f.Value)))) .ToArray(); var dataParser = new SectionedDataPacketParser(sections); var parserFuture = parserFactory.CreateFromRawPartsAsync(partsProvider.RawDumpParts(), dataParser, operationInfo); return(new FlashStreamReader(scope, device, formats, parserFuture, partsProviderSupplier, flashDumpWriteStream, flashDumpPath)); }