/// <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);
}
