| /** |
| * @license Apache-2.0 |
| * |
| * Copyright 2022 ocket8888 |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * Represents the `geoLimit` field of a Delivery Service |
| */ |
| export const enum GeoLimit { |
| /** |
| * No geographic limiting is to be done. |
| */ |
| NONE = 0, |
| /** |
| * Only clients found in a Coverage Zone File may be permitted access. |
| */ |
| CZF_ONLY = 1, |
| /** |
| * Only clients found in a Coverage Zone File OR can be geo-located within a |
| * set of country codes may be permitted access. |
| */ |
| CZF_AND_COUNTRY_CODES = 2 |
| } |
| |
| /** |
| * Defines the supported Geograhic IP mapping database providers and their |
| * respective magic number identifiers. |
| */ |
| export const enum GeoProvider { |
| /** The standard database used for geo-location. */ |
| MAX_MIND = 0, |
| /** An alternative database with dubious support. */ |
| NEUSTAR = 1 |
| } |
| |
| /** |
| * Represents a single entry in a Delivery Service's `matchList` field. |
| */ |
| export interface DeliveryServiceMatch { |
| /** A regular expression matching on something depending on the 'type'. */ |
| pattern: string; |
| /** |
| * The number in the set of the expression, which has vague but incredibly |
| * important meaning. |
| */ |
| setNumber: number; |
| /** |
| * The type of match which determines how it's used. |
| */ |
| type: string; |
| } |
| |
| /** |
| * Represents the allowed routing protocols and their respective magic number |
| * identifiers. |
| */ |
| export const enum Protocol { |
| /** Serve HTTP traffic only. */ |
| HTTP = 0, |
| /** Serve HTTPS traffic only. */ |
| HTTPS = 1, |
| /** Serve both HTTPS and HTTP traffic. */ |
| HTTP_AND_HTTPS = 2, |
| /** Redirect HTTP requests to HTTPS URLs and serve HTTPS traffic normally. */ |
| HTTP_TO_HTTPS = 3 |
| } |
| |
| /** |
| * Converts Protocols to a textual representation. |
| * |
| * @param p The Protocol to convert. |
| * @returns A string representation of 'p', or a blank string if 'p' was null. |
| */ |
| export function protocolToString(p: Protocol | null): string { |
| switch (p) { |
| case Protocol.HTTP: |
| return "Serve only unsecured HTTP requests"; |
| case Protocol.HTTPS: |
| return "Serve only secured HTTPS requests"; |
| case Protocol.HTTP_AND_HTTPS: |
| return "Serve both unsecured HTTP requests and secured HTTPS requests"; |
| case Protocol.HTTP_TO_HTTPS: |
| return "Serve secured HTTPS requests normally, but redirect unsecured HTTP requests to use HTTPS"; |
| } |
| return ""; |
| } |
| |
| /** |
| * Represents the allowed values of the `qstringIgnore` field of a |
| * `DeliveryService`. |
| */ |
| export const enum QStringHandling { |
| /** Use the query string in the cache key and pass in upstream requests. */ |
| USE = 0, |
| /** |
| * Don't use the query string in the cache key but do pass it in upstream |
| * requests. |
| */ |
| IGNORE = 1, |
| /** |
| * Neither use the query string in the cache key nor pass it in upstream |
| * requests. |
| */ |
| DROP = 2 |
| } |
| |
| /** |
| * Converts a QStringHandling to a textual representation. |
| * |
| * @param q The QStringHandling to convert. |
| * @returns A string representation of 'q'. |
| */ |
| export function qStringHandlingToString(q: QStringHandling): string { |
| switch (q) { |
| case QStringHandling.USE: |
| return "Use the query parameter string when deciding if a URL is cached, and pass it in upstream requests to the" + |
| " Mid-tier/origin"; |
| case QStringHandling.IGNORE: |
| return "Do not use the query parameter string when deciding if a URL is cached, but do pass it in upstream requests to the" + |
| " Mid-tier/origin"; |
| case QStringHandling.DROP: |
| return "Immediately strip URLs of their query parameter strings before checking cached objects or making upstream requests"; |
| } |
| } |
| |
| /** |
| * Represents the allowed values of the `rangeRequestHandling` field of a |
| * `Delivery Service`. |
| */ |
| export const enum RangeRequestHandling { |
| /** Range requests will not be cached. */ |
| NONE = 0, |
| /** |
| * The entire object will be fetched in the background to be cached, with |
| * the requested range served when it becomes available. |
| */ |
| BACKGROUND_FETCH = 1, |
| /** |
| * Cache range requests like any other request. |
| */ |
| CACHE_RANGE_REQUESTS = 2 |
| } |
| |
| /** |
| * Converts a RangeRequestHandling to a textual representation. |
| * |
| * @param r The RangeRequestHandling to convert. |
| * @returns A string representation of 'r'. |
| */ |
| export function rangeRequestHandlingToString(r: RangeRequestHandling): string { |
| switch (r) { |
| case RangeRequestHandling.NONE: |
| return "Do not cache Range requests"; |
| case RangeRequestHandling.BACKGROUND_FETCH: |
| return "Use the background_fetch plugin to serve Range requests while quietly caching the entire object"; |
| case RangeRequestHandling.CACHE_RANGE_REQUESTS: |
| return "Use the cache_range_requests plugin to directly cache object ranges"; |
| } |
| } |
| |
| /** |
| * The basic set of Delivery Service properties without being more specific as |
| * to the routing type, as they are given in requests. |
| */ |
| interface RequestDeliveryServiceBase { |
| /** Whether or not the Delivery Service is actively routed. */ |
| active: boolean; |
| /** Whether or not anonymization services are blocked. */ |
| anonymousBlockingEnabled?: boolean | null; |
| /** |
| * @deprecated This field no longer works and is subject to removal in the |
| * future. |
| */ |
| cacheurl: string | null; |
| /** The TTL of DNS responses from the Traffic Router, in seconds. */ |
| ccrDnsTtl?: number | null; |
| /** The ID of the CDN to which the Delivery Service belongs. */ |
| cdnId: number; |
| /** A sample path which may be requested to ensure the origin is working. */ |
| checkPath?: string | null; |
| /** |
| * A set of the query parameters that are important for Traffic Router to |
| * consider when performing "consistent hashing". |
| */ |
| consistentHashQueryParams?: Array<string> | null; |
| /** |
| * A regular expression used to extract request path fragments for use as |
| * keys in "consistent hashing" for routing purposes. |
| */ |
| consistentHashRegex?: string | null; |
| /** Whether or not to use "deep caching". */ |
| deepCachingType?: "ALWAYS" | "NEVER" | null; |
| /** A human-friendly name for the Delivery Service. */ |
| displayName: string; |
| /** An FQDN to use for DNS-routed bypass scenarios. */ |
| dnsBypassCname?: string | null; |
| /** An IPv4 address to use for DNS-routed bypass scenarios. */ |
| dnsBypassIp?: string | null; |
| /** An IPv6 address to use for DNS-routed bypass scenarios. */ |
| dnsBypassIp6?: string | null; |
| /** The TTL of DNS responses served in bypass scenarios. */ |
| dnsBypassTtl?: number | null; |
| /** The Delivery Service's DSCP. */ |
| dscp: number; |
| ecsEnabled?: boolean | null; |
| /** Extra header rewrite text used at the Edge tier. */ |
| edgeHeaderRewrite?: string | null; |
| firstHeaderRewrite?: string | null; |
| fqPacingRate?: number | null; |
| /** |
| * Describes limitation of content availability based on geographic |
| * location. |
| */ |
| geoLimit: GeoLimit; |
| /** |
| * The countries from which content access is allowed in the event that |
| * geographic limiting is taking place with a setting that allows for |
| * specific country codes to access content. |
| */ |
| geoLimitCountries?: string | null; |
| /** |
| * A URL to which to re-direct users who are blocked because of |
| * geographic-based access limiting |
| */ |
| geoLimitRedirectUrl?: string | null; |
| /** |
| * The provider of the IP-address-to-geographic-location database. |
| */ |
| geoProvider: GeoProvider; |
| /** |
| * The globally allowed maximum megabits per second to be served for the |
| * Delivery Service. |
| */ |
| globalMaxMbps?: number | null; |
| /** |
| * The globally allowed maximum transactions per second to be served for the |
| * Delivery Service. |
| */ |
| globalMaxTps?: number | null; |
| /** A URL to be used in HTTP-routed bypass scenarios. */ |
| httpBypassFqdn: string | null; |
| /** |
| * A URL from which information about a Delivery Service may be obtained. |
| * Historically, this has been used to link to the support ticket that |
| * requested the Delivery Service's creation. |
| */ |
| infoUrl: string | null; |
| /** The number of caches across which to spread content. */ |
| initialDispersion?: number | null; |
| innerHeaderRewrite?: string | null; |
| /** Whether or not routing of IPv6 clients should be supported. */ |
| ipv6RoutingEnabled?: boolean | null; |
| lastHeaderRewrite?: string | null; |
| /** Whether or not logging should be enabled for the Delivery Service. */ |
| logsEnabled: boolean; |
| /** A textual description of arbitrary length. */ |
| longDesc?: string | null; |
| /** |
| * A textual description of arbitrary length. |
| * |
| * @deprecated This has been removed in the latest API version. |
| */ |
| longDesc1?: string | null; |
| /** |
| * A textual description of arbitrary length. |
| * |
| * @deprecated This has been removed in the latest API version. |
| */ |
| longDesc2?: string | null; |
| /** |
| * Sets the maximum number of answers Traffic Router may provide in a single |
| * DNS response for this Delivery Service. |
| */ |
| maxDnsAnswers?: number | null; |
| /** |
| * The maximum number of connections that cache servers are allowed to open |
| * to the Origin(s). |
| * |
| * @default 0 |
| */ |
| maxOriginConnections?: number | null; |
| /** |
| * The maximum size (in bytes) of the request header that is allowed for |
| * this Delivery Service. |
| * |
| * @since 3.1 |
| * @default 0 |
| */ |
| maxRequestHeaderBytes?: number | null; |
| /** Extra header rewrite text to be used at the Mid-tier. */ |
| midHeaderRewrite?: string | null; |
| /** The latitude that should be used when geo-location of a client fails. */ |
| missLat?: number | null; |
| /** The longitude that should be used when geo-location of a client fails.*/ |
| missLong?: number | null; |
| /** Whether or not Multi-Site Origin is in use. */ |
| multiSiteOrigin?: boolean | null; |
| /** The URL of the Origin server, which I think means nothing for MSO. */ |
| orgServerFqdn?: string | null; |
| /** A string used to shield the Origin, somehow. */ |
| originShield?: string | null; |
| /** |
| * An integral, unique identifer for the Profile used by the Delivery |
| * Service. |
| */ |
| profileId?: number | null; |
| /** The protocols served by the Delivery Service. */ |
| protocol?: Protocol | null; |
| /** |
| * How query strings ought to be handled by cache servers serving content |
| * for this Delivery Service. |
| */ |
| qstringIgnore?: QStringHandling | null; |
| /** |
| * How HTTP Range requests ought to be handled by cache servers serving |
| * content for this Delivery Service. |
| */ |
| rangeRequestHandling?: RangeRequestHandling | null; |
| rangeSliceBlockSize?: null | number; |
| /** Some raw text to be inserted into regex_remap.config. */ |
| regexRemap?: string | null; |
| /** Whether or not regional geo-blocking should be used. */ |
| regionalGeoBlocking: boolean; |
| /** Some raw text to be inserted into remap.config. */ |
| remapText: string | null; |
| /** |
| * The lowest-level DNS label used in URLs for the Delivery Service. |
| * |
| * @default "cdn" |
| */ |
| routingName?: string | null; |
| serviceCategory?: string | null; |
| /** |
| * Whether or not responses from the cache servers for this Delivery |
| * Service's content will be signed. |
| */ |
| signed?: boolean | null; |
| /** |
| * The algorithm used to sign responses from the cache servers for this |
| * Delivery Service's content. |
| */ |
| signingAlgorithm?: "url_sig" | "uri_signing" | null; |
| /** The generation of SSL key used by this Delivery Service. */ |
| sslKeyVersion?: number | null; |
| /** |
| * An integral, unique identifier for the Tenant to whom this Delivery |
| * Service belongs. |
| */ |
| tenantId: number; |
| /** A list of explicitly supported TLS versions. */ |
| tlsVersions?: undefined | null | [string, ...string[]]; |
| topology?: string | null; |
| /** |
| * HTTP headers that should be logged from client requests by Traffic |
| * Router. |
| */ |
| trRequestHeaders?: string | null; |
| /** Extra HTTP headers that Traffic Router should provide in responses. */ |
| trResponseHeaders?: string | null; |
| /** The integral, unique identifier of the type of the Delivery Service. */ |
| typeId: number; |
| /** The second-lowest-level DNS label used in the Delivery Service's URLs.*/ |
| xmlId: string; |
| } |
| |
| /** |
| * Represents an HTTP-type Delivery Service in the context of a request. |
| * |
| * Note that since Type is utterly determined by `typeId`, it's not possible to |
| * know without communicating with the server in some way whether or not any |
| * given object is actually HTTP-typed. |
| */ |
| export interface RequestHTTPDeliveryService extends RequestDeliveryServiceBase { |
| /** The number of caches across which to spread content. */ |
| initialDispersion: number; |
| /** Whether or not routing of IPv6 clients should be supported. */ |
| ipv6RoutingEnabled: boolean; |
| /** The latitude that should be used when geo-location of a client fails. */ |
| missLat: number; |
| /** The longitude that should be used when geo-location of a client fails.*/ |
| missLong: number; |
| /** Whether or not Multi-Site Origin is in use. */ |
| multiSiteOrigin: boolean; |
| /** The URL of the Origin server, which I think means nothing for MSO. */ |
| orgServerFqdn: string; |
| /** The protocols served by the Delivery Service. */ |
| protocol: Protocol; |
| /** |
| * How query strings ought to be handled by cache servers serving content |
| * for this Delivery Service. |
| */ |
| qstringIgnore: QStringHandling; |
| /** |
| * How HTTP Range requests ought to be handled by cache servers serving |
| * content for this Delivery Service. |
| */ |
| rangeRequestHandling: RangeRequestHandling; |
| } |
| |
| /** |
| * Represents a DNS-type Delivery Service in the context of a request. |
| * |
| * Note that since Type is utterly determined by `typeId`, it's not possible to |
| * know without communicating with the server in some way whether or not any |
| * given object is actually DNS-typed. |
| */ |
| export interface RequestDNSDeliveryService extends RequestDeliveryServiceBase { |
| /** Whether or not routing of IPv6 clients should be supported. */ |
| ipv6RoutingEnabled: boolean; |
| /** The latitude that should be used when geo-location of a client fails. */ |
| missLat: number; |
| /** The longitude that should be used when geo-location of a client fails.*/ |
| missLong: number; |
| /** Whether or not Multi-Site Origin is in use. */ |
| multiSiteOrigin: boolean; |
| /** The URL of the Origin server, which I think means nothing for MSO. */ |
| orgServerFqdn: string; |
| /** The protocols served by the Delivery Service. */ |
| protocol: Protocol; |
| /** |
| * How query strings ought to be handled by cache servers serving content |
| * for this Delivery Service. |
| */ |
| qstringIgnore: QStringHandling; |
| /** |
| * How HTTP Range requests ought to be handled by cache servers serving |
| * content for this Delivery Service. |
| */ |
| rangeRequestHandling: RangeRequestHandling; |
| } |
| |
| /** |
| * Represents a STEERING-type Delivery Service in the context of a request. |
| * |
| * Note that since Type is utterly determined by `typeId`, it's not possible to |
| * know without communicating with the server in some way whether or not any |
| * given object is actually STEERING-typed. |
| */ |
| export type RequestSteeringDeliveryService = RequestDeliveryServiceBase; |
| |
| /** |
| * Represents an ANY_MAP-type Delivery Service in the context of a request. |
| * |
| * Note that since Type is utterly determined by `typeId`, it's not possible to |
| * know without communicating with the server in some way whether or not any |
| * given object is actually ANY_MAP-typed. |
| */ |
| export type RequestAnyMapDeliveryService = RequestDeliveryServiceBase; |
| |
| /** |
| * Represents a Delivery Service as required by the Traffic Ops API in requests. |
| */ |
| export type RequestDeliveryService = RequestHTTPDeliveryService | RequestDNSDeliveryService | RequestSteeringDeliveryService | RequestAnyMapDeliveryService; |
| |
| /** |
| * The basic set of Delivery Service properties without being more specific as |
| * to the routing type, as they are found in responses. |
| */ |
| interface ResponseDeliveryServiceBase { |
| /** Whether or not the Delivery Service is actively routed. */ |
| active: boolean; |
| /** Whether or not anonymization services are blocked. */ |
| anonymousBlockingEnabled: boolean; |
| /** |
| * @deprecated This field no longer works and is subject to removal in the |
| * future. |
| */ |
| cacheurl: string | null; |
| /** The TTL of DNS responses from the Traffic Router, in seconds. */ |
| ccrDnsTtl: number | null; |
| /** The ID of the CDN to which the Delivery Service belongs. */ |
| cdnId: number; |
| /** |
| * The Name of the CDN to which the Delivery Service belongs. |
| * |
| * This is null in response to PUT or POST requests where it was null or |
| * unspecified in the response. |
| */ |
| cdnName: string | null; |
| /** A sample path which may be requested to ensure the origin is working. */ |
| checkPath: string | null; |
| /** |
| * A set of the query parameters that are important for Traffic Router to |
| * consider when performing "consistent hashing". |
| */ |
| consistentHashQueryParams: null | [string, ...Array<string>]; |
| /** |
| * A regular expression used to extract request path fragments for use as |
| * keys in "consistent hashing" for routing purposes. |
| */ |
| consistentHashRegex: string | null; |
| /** Whether or not to use "deep caching". */ |
| deepCachingType: "ALWAYS" | "NEVER"; |
| /** A human-friendly name for the Delivery Service. */ |
| displayName: string; |
| /** An FQDN to use for DNS-routed bypass scenarios. */ |
| dnsBypassCname: string | null; |
| /** An IPv4 address to use for DNS-routed bypass scenarios. */ |
| dnsBypassIp: string | null; |
| /** An IPv6 address to use for DNS-routed bypass scenarios. */ |
| dnsBypassIp6: string | null; |
| /** The TTL of DNS responses served in bypass scenarios. */ |
| dnsBypassTtl: number | null; |
| /** The Delivery Service's DSCP. */ |
| dscp: number; |
| ecsEnabled: boolean; |
| /** Extra header rewrite text used at the Edge tier. */ |
| edgeHeaderRewrite: string | null; |
| /** |
| * A list of the URLs which may be used to request Delivery Service content. |
| * |
| * These are generated on-the-fly by Traffic Ops based on the structure of |
| * the given Delivery Service - as such, they cannot be directly modified. |
| */ |
| readonly exampleURLs: readonly string[]; |
| firstHeaderRewrite: string | null; |
| fqPacingRate: number; |
| /** |
| * Describes limitation of content availability based on geographic |
| * location. |
| */ |
| geoLimit: GeoLimit; |
| /** |
| * The countries from which content access is allowed in the event that |
| * geographic limiting is taking place with a setting that allows for |
| * specific country codes to access content. |
| */ |
| geoLimitCountries: string | null; |
| /** |
| * A URL to which to re-direct users who are blocked because of |
| * geographic-based access limiting |
| */ |
| geoLimitRedirectURL: string | null; |
| /** |
| * The provider of the IP-address-to-geographic-location database. |
| */ |
| geoProvider: GeoProvider; |
| /** |
| * The globally allowed maximum megabits per second to be served for the |
| * Delivery Service. |
| */ |
| globalMaxMbps: number | null; |
| /** |
| * The globally allowed maximum transactions per second to be served for the |
| * Delivery Service. |
| */ |
| globalMaxTps: number | null; |
| /** A URL to be used in HTTP-routed bypass scenarios. */ |
| httpBypassFqdn: string | null; |
| /** An integral, unique identifier for the Delivery Service. */ |
| readonly id: number; |
| /** |
| * A URL from which information about a Delivery Service may be obtained. |
| * Historically, this has been used to link to the support ticket that |
| * requested the Delivery Service's creation. |
| */ |
| infoUrl: string | null; |
| /** The number of caches across which to spread content. */ |
| initialDispersion: number; |
| innerHeaderRewrite: string | null; |
| /** Whether or not routing of IPv6 clients should be supported. */ |
| ipv6RoutingEnabled: boolean; |
| lastHeaderRewrite: string | null; |
| /** When the Delivery Service was last updated via the API. */ |
| readonly lastUpdated: Date; |
| /** Whether or not logging should be enabled for the Delivery Service. */ |
| logsEnabled: boolean; |
| /** A textual description of arbitrary length. */ |
| longDesc: string | null; |
| /** |
| * A textual description of arbitrary length. |
| * |
| * @deprecated This has been removed in the latest API version. |
| */ |
| longDesc1?: string; |
| /** |
| * A textual description of arbitrary length. |
| * |
| * @deprecated This has been removed in the latest API version. |
| */ |
| longDesc2?: string; |
| /** |
| * A list of regular expressions for routing purposes which should not ever |
| * be modified by hand. |
| */ |
| matchList: Array<DeliveryServiceMatch>; |
| /** |
| * Sets the maximum number of answers Traffic Router may provide in a single |
| * DNS response for this Delivery Service. |
| */ |
| maxDnsAnswers: number | null; |
| /** |
| * The maximum number of connections that cache servers are allowed to open |
| * to the Origin(s). |
| */ |
| maxOriginConnections: number; |
| /** |
| * The maximum size (in bytes) of the request header that is allowed for |
| * this Delivery Service. |
| * |
| * @since 3.1 |
| */ |
| maxRequestHeaderBytes: number; |
| /** Extra header rewrite text to be used at the Mid-tier. */ |
| midHeaderRewrite: string | null; |
| /** The latitude that should be used when geo-location of a client fails. */ |
| missLat: number; |
| /** The longitude that should be used when geo-location of a client fails.*/ |
| missLong: number; |
| /** Whether or not Multi-Site Origin is in use. */ |
| multiSiteOrigin: boolean; |
| /** A string used to shield the Origin, somehow. */ |
| originShield: string | null; |
| /** The URL of the Origin server, which I think means nothing for MSO. */ |
| orgServerFqdn: string | null; |
| /** The protocols served by the Delivery Service. */ |
| protocol: Protocol | null; |
| /** |
| * How query strings ought to be handled by cache servers serving content |
| * for this Delivery Service. |
| */ |
| qstringIgnore: QStringHandling | null; |
| /** |
| * How HTTP Range requests ought to be handled by cache servers serving |
| * content for this Delivery Service. |
| */ |
| rangeRequestHandling: RangeRequestHandling | null; |
| rangeSliceBlockSize: null | number; |
| /** Some raw text to be inserted into regex_remap.config. */ |
| regexRemap: string | null; |
| /** Whether or not regional geo-blocking should be used. */ |
| regionalGeoBlocking: boolean; |
| /** Some raw text to be inserted into remap.config. */ |
| remapText: string | null; |
| /** The lowest-level DNS label used in URLs for the Delivery Service. */ |
| routingName: string; |
| serviceCategory: string | null; |
| /** |
| * Whether or not responses from the cache servers for this Delivery |
| * Service's content will be signed. |
| */ |
| signed: boolean; |
| /** |
| * The algorithm used to sign responses from the cache servers for this |
| * Delivery Service's content. |
| */ |
| signingAlgorithm: "url_sig" | "uri_signing" | null; |
| /** The generation of SSL key used by this Delivery Service. */ |
| sslKeyVersion: number | null; |
| /** The name of the Tenant to whom this Delivery Service belongs. */ |
| tenant: string; |
| /** |
| * An integral, unique identifier for the Tenant to whom this Delivery |
| * Service belongs. |
| */ |
| tenantId: number; |
| /** A list of explicitly supported TLS versions. */ |
| tlsVersions: null | [string, ...string[]]; |
| topology: string | null; |
| /** Extra HTTP headers that Traffic Router should provide in responses. */ |
| trResponseHeaders: string | null; |
| /** |
| * HTTP headers that should be logged from client requests by Traffic |
| * Router. |
| */ |
| trRequestHeaders: string | null; |
| /** The type of the Delivery Service. */ |
| type: string; |
| /** The integral, unique identifier of the type of the Delivery Service. */ |
| typeId: number; |
| /** The second-lowest-level DNS label used in the Delivery Service's URLs.*/ |
| xmlId: string; |
| } |
| |
| /** |
| * A Delivery Service with a Profile. If a Delivery Service has a Profile, all |
| * of the related properties are guaranteed to be non-null in responses. |
| */ |
| interface ResponseDeliveryServiceWithProfile extends ResponseDeliveryServiceBase { |
| /** A description of the Profile used by the Delivery Service (read-only) */ |
| profileDescription: string; |
| /** |
| * An integral, unique identifer for the Profile used by the Delivery |
| * Service. |
| */ |
| profileId: number; |
| /** The name of the Profile used by the Delivery Service. */ |
| profileName: string; |
| } |
| |
| /** |
| * A Delivery Service with a Profile. If a Delivery Service does not has a |
| * Profile, all of the related properties are guaranteed to be null in |
| * responses. |
| */ |
| interface ResponseDeliveryServiceWithoutProfile extends ResponseDeliveryServiceBase { |
| /** A description of the Profile used by the Delivery Service (read-only) */ |
| profileDescription: null; |
| /** |
| * An integral, unique identifer for the Profile used by the Delivery |
| * Service. |
| */ |
| profileId: null; |
| /** The name of the Profile used by the Delivery Service. */ |
| profileName: null; |
| } |
| |
| /** |
| * Represents a Delivery Service as returned by the Traffic Ops API in |
| * responses. |
| */ |
| export type ResponseDeliveryService = ResponseDeliveryServiceWithProfile | ResponseDeliveryServiceWithoutProfile; |
| |
| /** |
| * Represents a Delivery Service. |
| */ |
| export type DeliveryService = RequestDeliveryService | ResponseDeliveryService; |
| |
| /** |
| * Determines if the Delivery Service is a candidate for bypassing. |
| * |
| * @param ds The Delivery Service to check. |
| * @returns `true` if it can have bypass settings, `false` otherwise. |
| */ |
| export function bypassable(ds: DeliveryService): boolean { |
| if (!Object.prototype.hasOwnProperty.call(ds, "type")) { |
| return false; |
| } |
| |
| switch ((ds as ResponseDeliveryService).type) { |
| case "HTTP": |
| case "HTTP_LIVE": |
| case "HTTP_LIVE_NATNL": |
| case "DNS": |
| case "DNS_LIVE": |
| case "DNS_LIVE_NATNL": |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Represents a Delivery Service "Regular Expression" as Traffic Ops requires it |
| * in requests. |
| */ |
| export interface RequestDeliveryServiceRegexp { |
| pattern: string; |
| setNumber: number; |
| type: number; |
| } |
| |
| /** |
| * Represents a Delivery Service "Regular Expression" as Traffic Ops presents it |
| * in responses. |
| */ |
| export interface ResponseDeliveryServiceRegexp { |
| readonly id: number; |
| pattern: string; |
| setNumber: number; |
| type: number; |
| typeName: string; |
| } |
| |
| /** Represents a Delivery Service "Regular Expression" in an arbitrary context. */ |
| export type DeliveryServiceRegexp = RequestDeliveryServiceRegexp | ResponseDeliveryServiceRegexp; |
| |
| /** |
| * Represents the Delivery Service "Regular Expressions" of a Delivery Service |
| * as they appear in responses from the Traffic Ops API's |
| * `/deliveryservices_regexes` endpoint. |
| */ |
| export interface DeliveryServicesRegexps { |
| /** The Delivery Service's XMLID. */ |
| dsName: string; |
| regexes: Array<{ |
| pattern: string; |
| setNumber: number; |
| type: string; |
| }>; |
| } |
| |
| /** |
| * Represents a request to update the "safe" fields of a Delivery Service - i.e. |
| * the ones that are modifiable through the `/deliveryservices/{{ID}}/safe` |
| * endpoint of the Traffic Ops API. |
| */ |
| export interface DSSafeUpdateRequest { |
| displayName: string; |
| infoUrl?: string | null; |
| longDesc?: string | null; |
| /** @deprecated This has been removed in the latest API version. */ |
| longDesc1?: string | null; |
| } |
| |
| /** |
| * Represents a request to associate zero or more servers with a Delivery |
| * Service. |
| * |
| * This is redundant with {@link RequestDeliveryServiceServer}, so |
| * applications are recommended to pick one API endpoint to use for such |
| * assignments, which will determine the representation used. Generally it boils |
| * down to whether you'd rather use hostnames (which can't be guaranteed to be |
| * unique to a server so they may be a bad choice!) and XMLIDs or numeric IDs to |
| * identify servers and Delivery Services. |
| */ |
| export interface RequestDeliveryServicesServers { |
| serverNames: Array<string>; |
| } |
| |
| /** |
| * Represents a response from Traffic Ops to a request to associate zero or more |
| * servers with a Delivery Service. |
| * |
| * This is redundant with {@link ResponseDeliveryServiceServer}, so |
| * applications are recommended to pick one API endpoint to use for such |
| * assignments, which will determine the representation used. Generally it boils |
| * down to whether you'd rather use hostnames (which can't be guaranteed to be |
| * unique to a server so they may be a bad choice!) and XMLIDs or numeric IDs to |
| * identify servers and Delivery Services. |
| */ |
| export interface ResponseDeliveryServicesServers { |
| serverNames: Array<string>; |
| xmlId: string; |
| } |
| |
| /** |
| * Represents a request to associate a Delivery Service with zero or more |
| * servers as Traffic Ops requires it in requests to its |
| * `/deliveryserviceserver` API endpoint. |
| * |
| * This is redundant with {@link RequestDeliveryServicesServers}, so |
| * applications are recommended to pick one API endpoint to use for such |
| * assignments, which will determine the representation used. Generally it boils |
| * down to whether you'd rather use hostnames (which can't be guaranteed to be |
| * unique to a server so they may be a bad choice!) and XMLIDs or numeric IDs to |
| * identify servers and Delivery Services. |
| */ |
| export interface RequestDeliveryServiceServer { |
| dsId: number; |
| /** @default false */ |
| replace?: boolean | null; |
| /** @default [] */ |
| servers?: Array<number> | null; |
| } |
| |
| /** |
| * Represents a single association shown in responses to GET requests made to |
| * `/deliveryserviceserver` endpoint of the Traffic Ops API. |
| * |
| * This is redundant with {@link ResponseDeliveryServicesServers}, so |
| * applications are recommended to pick one API endpoint to use for such |
| * assignments, which will determine the representation used. Generally it boils |
| * down to whether you'd rather use hostnames (which can't be guaranteed to be |
| * unique to a server so they may be a bad choice!) and XMLIDs or numeric IDs to |
| * identify servers and Delivery Services. |
| */ |
| export interface ResponseDeliveryServiceServer { |
| deliveryService: number; |
| readonly lastUpdated: Date; |
| server: number; |
| } |
| |
| /** |
| * Represents a Service Category as Traffic Ops requires it in requests. |
| */ |
| export interface RequestServiceCategory { |
| name: string; |
| } |
| |
| /** |
| * Represents a Service Category as Traffic Ops presents it in responses. |
| */ |
| export interface ResponseServiceCategory { |
| readonly lastUpdated: Date; |
| name: string; |
| } |
| |
| /** |
| * Service Categories are used to group Delivery Services for the purposes of |
| * metrics and analytics. Cache servers will add the value of a Delivery |
| * Service's Service Category as the `X-CDN-SVC` HTTP Header in their downstream |
| * responses. |
| */ |
| export type ServiceCategory = RequestServiceCategory | ResponseServiceCategory; |
| |
| /** |
| * Represents a Static DNS Entry as Traffic Ops requires it in requests. |
| */ |
| export interface RequestStaticDNSEntry { |
| address: string; |
| /** @default null */ |
| cachegroupId?: number | null; |
| deliveryserviceId: number; |
| host: string; |
| /** In seconds */ |
| ttl: number; |
| typeId: number; |
| } |
| |
| /** |
| * A response to a {@link RequestStaticDNSEntry}. |
| */ |
| export interface RequestStaticDNSEntryResponse { |
| address: string; |
| cachegroupId: number | null; |
| cachegroup: string | null; |
| deliveryserviceId: number; |
| deliveryservice: string | null; |
| host: string; |
| readonly id: number; |
| readonly lastUpdated: Date; |
| /** In seconds */ |
| ttl: number; |
| type: string; |
| typeId: number; |
| } |
| |
| /** |
| * All of the properties common to Static DNS Entries as presented in responses. |
| */ |
| interface ResponseStaticDNSEntryBase { |
| address: string; |
| deliveryserviceId: number; |
| deliveryservice: string; |
| host: string; |
| readonly id: number; |
| readonly lastUpdated: Date; |
| /** In seconds */ |
| ttl: number; |
| type: string; |
| typeId: number; |
| } |
| |
| /** |
| * Represents a Static DNS Entry with an associated Cache Group as Traffic Ops |
| * presents it in responses. |
| */ |
| interface ResponseStaticDNSEntryWithCacheGroup extends ResponseStaticDNSEntryBase { |
| cachegroupId: number; |
| cachegroup: string; |
| } |
| |
| /** |
| * Represents a Static DNS Entry without an associated Cache Group as Traffic |
| * Ops presents it in responses. |
| */ |
| interface ResponseStaticDNSEntryWithoutCacheGroup extends ResponseStaticDNSEntryBase { |
| cachegroupId: null; |
| cachegroup: null; |
| } |
| |
| /** |
| * Represents a Static DNS Entry as Traffic Ops presents it in responses. |
| */ |
| export type ResponseStaticDNSEntry = ResponseStaticDNSEntryWithCacheGroup | ResponseStaticDNSEntryWithoutCacheGroup; |
| |
| /** |
| * A Static DNS Entry represents a custom DNS record for a Delivery Service. |
| */ |
| export type StaticDNSEntry = RequestStaticDNSEntry | RequestStaticDNSEntryResponse | ResponseStaticDNSEntry; |