CCT Latency Check Engine
npm install cct-lceCCT-LCE is specifically tailored for managing and monitoring data centers, with a primary focus on measuring and analyzing latency and bandwidth metrics. This documentation provides a comprehensive overview of the methods and properties available in the cct-lce.
- Properties
- allDatacenters
- datacenters
- runningLatency
- runningBandwidth
- compatibleDCsWithSockets
- Methods
- fetchDatacenterInformation
- fetchCompatibleDCsWithSockets
- setFilters
- stopMeasurements
- startLatencyChecks
- startBandwidthChecks
- getCurrentDatacentersSorted
- getAddress
- store
- getClosestDatacenters
- Events
- Types
- Datacenter
- LatencyChecksParams
- BandwidthChecksParams
- Location
- LatencyEventData
- IterationLatencyEventData
- BandwidthEventData
- IterationBandwidthEventData
- FilterKeys
---
An array initially empty, designated to store all known data centers. It is populated following the execution of the fetchDatacenterInformation request.
A dynamically managed subset of the allDatacenters array. Initially, it is filled following the successful execution of the fetchDatacenterInformation request. Subsequently, its contents can be modified in response to the setFilters request, which adjusts which data centers are included based on the specified filtering criteria.
A boolean flag indicating whether latency measurements are currently active. When set to true, it signifies that latency monitoring processes are ongoing.
A boolean flag indicating whether bandwidth measurements are currently active. When set to true, it signifies that bandwidth monitoring processes are ongoing.
An array containing data centers that have been identified as compatible with socket connections. It is populated following the execution of the fetchCompatibleDCsWithSockets request.
This method retrieves information about data centers from a specified URL and stores the data internally for further processing.
Parameters:
- dictionaryUrl (string, optional): The URL from which data center information is fetched.
- default: https://cct.demo-education.cloud.sap/datacenters?isActive=true
Example Usage:
``typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
console.log(cct.allDatacenters, cct.datacenters) // fetched datacenters is here.
`
Identifies data centers that are equipped to handle socket connections and updates the internal records with this information.
Returns:
- Promise<Datacenter[]>: Returns a promise that resolves to an array of data centers that support socket connections.
Example:
`typescript
const cct = new CCT();
const compatibleDCs = await cct.fetchCompatibleDCsWithSockets();
console.log(cct.compatibleDCsWithSockets) // fetched datacenters is here.
`
Applies filtering criteria to the list of data centers based on various attributes.
Parameters:
- filters(FilterKeys, optional): Criteria to filter the data centers. Possible keys include:name
- (string[], optional): Datacenter names.cloud
- (string[], optional): Associated cloud services.town
- (string[], optional): Towns.country
- (string[], optional): Countries.tags
- (string[], optional): Miscellaneous tags.
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
cct.setFilters({ country: ['USA', 'Canada'] });
console.log(cct.datacenters) // filtered datacenters
`
Stops all ongoing measurement processes and clears related resources.
Example:
`typescript `
// TODO
cct.stopMeasurements();
This method initiates the process of measuring latency for data centers according to specified criteria.
Parameters:
- params (LatencyChecksParams): Configuration options for latency tests.interval
- (number, optional): Time in milliseconds between each latency check.iterations
- default: 0
- (number, optional): Total number of latency checks to be performed.save
- default: 16
- (boolean, optional): Specifies whether to save the latency results.from
- default: true
- (string, optional): The ID of the data center from which latency is specifically measured.
- default: undefined
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
await cct.startLatencyChecks({ iterations: 10, interval: 1000 });
`
This method initiates the process of measuring bandwidth for data centers according to specified criteria.
Parameters:
- params (BandwidthChecksParams): Configuration options for bandwidths measurements.interval
- (number, optional): Time in milliseconds between each bandwidth check.iterations
- default: 0
- (number, optional): Total number of bandwidth checks to be performed.save
- default: 4
- (boolean, optional): Specifies whether to save the bandwidth results.from
- default: true
- (string, optional): The ID of the data center from which bandwidth is specifically measured.bandwidthMode
- default: undefined
- (BandwidthMode, optional): The mode of bandwidth measurement, either 'big' or 'small'.
- default: big
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
await cct.startBandwidthChecks({ from: 'datacenterId', iterations: 5, bandwidthMode: 'small' });
``
Returns a list of currently managed data centers, sorted by average latency.
Returns:
- [Datacenter[]](#datacenter): An array of sorted data centers.
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
const sortedDatacenters = cct.getCurrentDatacentersSorted();
`
Retrieves your current geographical address.
Returns:
- Promise<Location | null>: A promise that resolves to the current location, or null if the location cannot be determined.
Example:
`typescript`
const location = await cct.getAddress();
Saves measurement data to a designated endpoint. The minimum threshold to initiate saving is 16 latencies.
Parameters:
- location (Location): Location data to be included in the storage payload.url
- (string, optional): The endpoint URL where the data will be sent.https://cct.demo-education.cloud.sap/measurement
- default:
Returns:
Promise: True if the data was successfully stored, false otherwise.
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
await Promise.all([cct.startLatencyChecks(), cct.startBandwidthChecks()]);
const success = await cct.store({ latitude: 34.0522, longitude: -118.2437, address: "some adress" }, "urlToSave");
`
Calculates and retrieves the closest data centers to a specified geographical point.
Parameters:
- latitude (number): Latitude of the target location.longitude
- (number): Longitude of the target location.url
- (string, optional): URL to fetch data center information if not already loaded.top
- (number, optional): Number of top closest data centers to return.
Returns:
Promise<Datacenter[]>: An array of the top closest data centers.
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation('https://api.example.com/datacenters');
const closestDCs = await cct.getClosestDatacenters({
latitude: 34.0522,
longitude: -118.2437,
top: 5
});
`
The CCT class extends an event emitter, enabling full utilization of its capabilities.
- latency: This event is emitted for each latency measurement for each data center. Event data is passed to callback LatencyEventData
- latency:iteration: This event is triggered whenever a new round of latency measurements has been completed for all data centers. It occurs sequentially; for instance, it is emitted after each data center has logged its first set of latency data, again after each has logged its second set, and so forth. Event data is passed to callback LatencyEventData[]
- latency:end: This event is emitted when the latency measurement process has either concluded or been prematurely stopped.
- bandwidth: Emitted for each bandwidth measurement obtained from each data center. Event data is passed to callback BandwidthEventData
- bandwidth:iteration: Emitted each time a complete round of bandwidth measurements is calculated for all data centers. This event is triggered sequentially, such as after each data center has logged its first set of bandwidth data, its second set, and so on. Event data is passed to callback BandwidthEventData[]
- bandwidth:end: This event is emitted when the bandwidth measurement process has either concluded or been prematurely stopped.
Example:
`typescript
const cct = new CCT();
await cct.fetchDatacenterInformation();
cct.on('latency:iteration', (eventData) => {
// react to event
});
await cct.startLatencyChecks();
cct.removeAllListeners();
`
`typescript`
type Datacenter = {
id: string;
position: number;
cloud: string;
name: string;
town: string;
country: string;
latitude: string;
longitude: string;
ip: string;
tags: string;
lastUpdate: string;
averageLatency: number;
latencyJudgement?: Speed;
averageBandwidth: BandwidthPerSecond;
bandwidthJudgement?: Speed;
latencies: Latency[];
bandwidths: Bandwidth[];
storedLatencyCount: number;
storedBandwidthCount: number;
};
`typescript`
type LatencyChecksParams = {
interval?: number;
iterations?: number;
save?: boolean;
from?: string;
}
`typescript`
type BandwidthChecksParams = LatencyChecksParams & {bandwidthMode?: 'big' | 'small'}
`typescript`
type Location = {
address: string;
latitude: number;
longitude: number;
};
`typescript`
type LatencyEventData = {
id: string;
data: {
value: number;
timestamp: number;
};
}
`typescript`
type BandwidthEventData = {
id: string;
data: {
value: {
bitsPerSecond: number;
kiloBitsPerSecond: number;
megaBitsPerSecond: number;
}
};
timestamp: number;
}
[BandwidthEventData[]](#BandwidthEventData)
`typescript``
type FilterKeys = {
name?: string[];
cloud?: string[];
town?: string[];
country?: string[];
tags?: string[];
};