/// <summary> /// Gets the host admin logs. /// </summary> /// <remarks> /// Host only. Required permissions: Audit.View. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='tenantId'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <MaintenanceSetting> GetAsync(this IMaintenance operations, int?tenantId = default(int?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { using (var _result = await operations.GetWithHttpMessagesAsync(tenantId, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public IHttpActionResult CreateMaintenance(CreateMaintenanceRequestDTO request) { IMaintenance maintenance = MaintenanceFactory.CreateMaintenance( request.Description, request.Cost, request.PlateNo, request.IsCompleted, request.DateTimeOfService); this._maintenanceRepository.Create(maintenance); return(Ok()); }
public ClientImpl(ClientBuilder clientBuilder) { // Copy the builder so external modifications won't affect this client impl. this.builder = clientBuilder.Copy(); this.kvClient = null; this.authClient = null; this.maintenanceClient = null; this.clusterClient = null; this.leaseClient = null; this.watchClient = null; this.lockClient = null; this.connectionManager = new ClientConnectionManager(this.builder); }
public void Create(IMaintenance maintenance) { Maintenance new_maintenance = new Maintenance { Description = maintenance.Description, Cost = maintenance.Cost, PlateNo = maintenance.PlateNo, IsCompleted = maintenance.IsCompleted, DateTimeOfService = maintenance.DateTimeOfService }; this.datacontext.Maintenances.InsertOnSubmit(new_maintenance); this.datacontext.SubmitChanges(); }
public Processor( IList <IFileParser> fileParsers, IProcessors processorsConfig, ITimers timersConfig, IMaintenance maintenanceConfig, IParser parser, IPersister persister, ILogger logger, IDirectory directory, IPerformance performance ) { // save the logger _logger = logger ?? throw new ArgumentNullException(nameof(logger)); const string directoryCounterName = "Processor: Average time processing Directories"; const string fileCounterName = "Processor: Average time processing Files"; const string parserCounterName = "Processor: Average time parsing files/folders"; // Create the various processors, they will not start doing anything just yet // or at least, they shouldn't var directoriesCounter = new ProcessorPerformanceCounter(performance, directoryCounterName, logger); var filesCounter = new ProcessorPerformanceCounter(performance, fileCounterName, logger); var parserCounter = new ProcessorPerformanceCounter(performance, parserCounterName, logger); _eventTimer = new ProcessorTimer( new List <IProcessor> { new Folders(directoriesCounter, processorsConfig.UpdatesFolderPerEvent, persister, logger, directory, timersConfig.EventsMaxWaitTransactionMs), new Files(filesCounter, processorsConfig.UpdatesFilesPerEvent, fileParsers, processorsConfig.IgnoreFiles, persister, logger, directory, timersConfig.EventsMaxWaitTransactionMs) }, _logger, processorsConfig.EventsProcessorMs); _maintenanceTimer = new ProcessorTimer( new List <IProcessor> { new Maintenance(maintenanceConfig.Active, parser, persister, logger) }, _logger, (int)TimeSpan.FromMinutes(processorsConfig.MaintenanceProcessorMinutes).TotalMilliseconds); _parserTimer = new ProcessorTimer( new List <IProcessor> { new Parser(parserCounter, parser, logger) }, _logger, (int)TimeSpan.FromMinutes(processorsConfig.ParserProcessorMinutes).TotalMilliseconds); }
public IEnumerable <IMaintenance> GetAllMaintenances() { var maintenances = new List <IMaintenance>(); foreach (var entity in datacontext.Maintenances.ToList()) { IMaintenance maintenance = MaintenanceFactory.CreateMaintenance( entity.Description, ((float)entity.Cost), entity.PlateNo, ((int)entity.IsCompleted), ((DateTime)entity.DateTimeOfService)); maintenances.Add(maintenance); } return(maintenances); }
public IMaintenance GetMaintenance(int maintenanceId) { foreach (var entity in datacontext.Maintenances.ToList()) { IMaintenance maintenance = MaintenanceFactory.CreateMaintenance( entity.Description, ((float)entity.Cost), entity.PlateNo, ((int)entity.IsCompleted), ((DateTime)entity.DateTimeOfService)); if (entity.MaintenanceID == maintenanceId) { return(maintenance); } } throw new NotImplementedException(); }
/// <summary> /// Creates a bag for the peers. This peer knows a lot about close peers. The further away the peers are, /// the less known they are. Distance is measured with XOR of the peer ID. /// E.g., the distance of peer with ID 0x12 and peer with ID 0x28 is 0x3a. /// </summary> /// <param name="peerMapConfiguration">The configuration values for this map.</param> public PeerMap(PeerMapConfiguration peerMapConfiguration) { Self = peerMapConfiguration.Self; if (Self == null || Self.IsZero) { throw new ArgumentException("Zero or null are not valid peer IDs."); } BagSizeVerified = peerMapConfiguration.BagSizeVerified; BagSizeOverflow = peerMapConfiguration.BagSizeOverflow; _offlineCount = peerMapConfiguration.OfflineCount; _peerFilters = peerMapConfiguration.PeerFilters; PeerMapVerified = InitFixedMap(BagSizeVerified, false); PeerMapOverflow = InitFixedMap(BagSizeOverflow, true); // _bagSizeVerified * Number160.Bits should be enough _offlineMap = new ConcurrentCacheMap <Number160, PeerAddress>(peerMapConfiguration.OfflineTimeout, BagSizeVerified * Number160.Bits); _shutdownMap = new ConcurrentCacheMap <Number160, PeerAddress>(peerMapConfiguration.ShutdownTimeout, BagSizeVerified * Number160.Bits); _exceptionMap = new ConcurrentCacheMap <Number160, PeerAddress>(peerMapConfiguration.ExceptionTimeout, BagSizeVerified * Number160.Bits); _maintenance = peerMapConfiguration.Maintenance.Init(PeerMapVerified, PeerMapOverflow, _offlineMap, _shutdownMap, _exceptionMap); _peerVerification = peerMapConfiguration.IsPeerVerification; }
/// <summary> /// Starts a maintenance window /// </summary> /// <remarks> /// Host only. Requires authentication. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='phase'> /// Phase - {UiPath.Orchestrator.Core.Enums.MaintenanceState.Draining} or /// {UiPath.Orchestrator.Core.Enums.MaintenanceState.Suspended}. Possible /// values include: 'None', 'Draining', 'Suspended' /// </param> /// <param name='force'> /// Whether to ignore errors during transition /// </param> /// <param name='killJobs'> /// Whether to force-kill running jobs when transitioning to /// {UiPath.Orchestrator.Core.Enums.MaintenanceState.Suspended} /// </param> /// <param name='tenantId'> /// </param> public static void Start(this IMaintenance operations, string phase, bool?force = default(bool?), bool?killJobs = default(bool?), int?tenantId = default(int?)) { operations.StartAsync(phase, force, killJobs, tenantId).GetAwaiter().GetResult(); }
/// <summary> /// Gets the host admin logs. /// </summary> /// <remarks> /// Host only. Required permissions: Audit.View. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='tenantId'> /// </param> public static MaintenanceSetting Get(this IMaintenance operations, int?tenantId = default(int?)) { return(operations.GetAsync(tenantId).GetAwaiter().GetResult()); }
/// <summary> /// Ends a maintenance window /// </summary> /// <remarks> /// Host only. Requires authentication. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='tenantId'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task EndAsync(this IMaintenance operations, int?tenantId = default(int?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { (await operations.EndWithHttpMessagesAsync(tenantId, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
/// <summary> /// Ends a maintenance window /// </summary> /// <remarks> /// Host only. Requires authentication. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='tenantId'> /// </param> public static void End(this IMaintenance operations, int?tenantId = default(int?)) { operations.EndAsync(tenantId).GetAwaiter().GetResult(); }
/// <summary> /// Starts a maintenance window /// </summary> /// <remarks> /// Host only. Requires authentication. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='phase'> /// Phase - {UiPath.Orchestrator.Core.Enums.MaintenanceState.Draining} or /// {UiPath.Orchestrator.Core.Enums.MaintenanceState.Suspended}. Possible /// values include: 'None', 'Draining', 'Suspended' /// </param> /// <param name='force'> /// Whether to ignore errors during transition /// </param> /// <param name='killJobs'> /// Whether to force-kill running jobs when transitioning to /// {UiPath.Orchestrator.Core.Enums.MaintenanceState.Suspended} /// </param> /// <param name='tenantId'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task StartAsync(this IMaintenance operations, string phase, bool?force = default(bool?), bool?killJobs = default(bool?), int?tenantId = default(int?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { (await operations.StartWithHttpMessagesAsync(phase, force, killJobs, tenantId, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
/// <summary> /// Starts a maintenance window /// </summary> /// <remarks> /// Client Credentials Flow required permissions: Administration or /// Administration.Write. /// /// Host only. Requires authentication. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='phase'> /// Phase - UiPath.Orchestrator.DataContracts.MaintenanceState.Draining or /// UiPath.Orchestrator.DataContracts.MaintenanceState.Suspended. Possible /// values include: 'None', 'Draining', 'Suspended' /// </param> /// <param name='force'> /// Whether to ignore errors during transition /// </param> /// <param name='killJobs'> /// Whether to force-kill running jobs when transitioning to /// UiPath.Orchestrator.DataContracts.MaintenanceState.Suspended /// </param> /// <param name='tenantId'> /// If tenant id is set, maintenance will start only for this tenant /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task StartAsync(this IMaintenance operations, MaintenanceState?phase = default(MaintenanceState?), bool?force = false, bool?killJobs = false, int?tenantId = default(int?), CancellationToken cancellationToken = default(CancellationToken)) { (await operations.StartWithHttpMessagesAsync(phase, force, killJobs, tenantId, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
public PeerMapConfiguration SetMaintenance(IMaintenance maintenance) { Maintenance = maintenance; return this; }
public IMaintenance Update(IMaintenance maintenance) { throw new NotImplementedException(); }
clsMainProgram(IMaintenance ObjClient) { this._ObjClient = ObjClient; }
public PeerMapConfiguration SetMaintenance(IMaintenance maintenance) { Maintenance = maintenance; return(this); }