1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
"""
SoftLayer.cdn
~~~~~~~~~~~~~
CDN Manager/helpers
:license: MIT, see LICENSE for more details.
"""
from SoftLayer import utils
class CDNManager(utils.IdentifierMixin, object):
"""Manage Content Delivery Networks in the account.
See product information here:
https://www.ibm.com/cloud/cdn
https://cloud.ibm.com/docs/infrastructure/CDN?topic=CDN-about-content-delivery-networks-cdn-
:param SoftLayer.API.BaseClient client: the client instance
"""
def __init__(self, client):
self.client = client
self._start_date = None
self._end_date = None
self.cdn_configuration = self.client['Network_CdnMarketplace_Configuration_Mapping']
self.cdn_path = self.client['SoftLayer_Network_CdnMarketplace_Configuration_Mapping_Path']
self.cdn_metrics = self.client['Network_CdnMarketplace_Metrics']
self.cdn_purge = self.client['SoftLayer_Network_CdnMarketplace_Configuration_Cache_Purge']
def list_cdn(self, **kwargs):
"""Lists Content Delivery Networks for the active user.
:param dict \\*\\*kwargs: header-level options (mask, limit, etc.)
:returns: The list of CDN objects in the account
"""
return self.cdn_configuration.listDomainMappings(**kwargs)
def get_cdn(self, unique_id, **kwargs):
"""Retrieves the information about the CDN account object.
:param str unique_id: The unique ID associated with the CDN.
:param dict \\*\\*kwargs: header-level option (mask)
:returns: The CDN object
"""
cdn_list = self.cdn_configuration.listDomainMappingByUniqueId(unique_id, **kwargs)
# The method listDomainMappingByUniqueId() returns an array but there is only 1 object
return cdn_list[0]
def get_origins(self, unique_id, **kwargs):
"""Retrieves list of origin pull mappings for a specified CDN account.
:param str unique_id: The unique ID associated with the CDN.
:param dict \\*\\*kwargs: header-level options (mask, limit, etc.)
:returns: The list of origin paths in the CDN object.
"""
return self.cdn_path.listOriginPath(unique_id, **kwargs)
def add_origin(self, unique_id, origin, path, origin_type="server", header=None,
port=80, protocol='http', bucket_name=None, file_extensions=None,
optimize_for="web", cache_query="include all"):
"""Creates an origin path for an existing CDN.
:param str unique_id: The unique ID associated with the CDN.
:param str path: relative path to the domain provided, e.g. "/articles/video"
:param str origin: ip address or hostname if origin_type=server, API endpoint for
your S3 object storage if origin_type=storage
:param str origin_type: it can be 'server' or 'storage' types.
:param str header: the edge server uses the host header to communicate with the origin.
It defaults to hostname. (optional)
:param int port: the http port number (default: 80)
:param str protocol: the protocol of the origin (default: HTTP)
:param str bucket_name: name of the available resource
:param str file_extensions: file extensions that can be stored in the CDN, e.g. "jpg,png"
:param str optimize_for: performance configuration, available options: web, video, and file where:
- 'web' = 'General web delivery'
- 'video' = 'Video on demand optimization'
- 'file' = 'Large file optimization'
:param str cache_query: rules with the following formats: 'include-all', 'ignore-all',
'include: space separated query-names',
'ignore: space separated query-names'.'
:return: a CDN origin path object
"""
types = {'server': 'HOST_SERVER', 'storage': 'OBJECT_STORAGE'}
performance_config = {
'web': 'General web delivery',
'video': 'Video on demand optimization',
'file': 'Large file optimization'
}
new_origin = {
'uniqueId': unique_id,
'path': path,
'origin': origin,
'originType': types.get(origin_type),
'httpPort': port,
'protocol': protocol.upper(),
'performanceConfiguration': performance_config.get(optimize_for, 'General web delivery'),
'cacheKeyQueryRule': cache_query
}
if header:
new_origin['header'] = header
if types.get(origin_type) == 'OBJECT_STORAGE':
if bucket_name:
new_origin['bucketName'] = bucket_name
if file_extensions:
new_origin['fileExtension'] = file_extensions
origin = self.cdn_path.createOriginPath(new_origin)
# The method createOriginPath() returns an array but there is only 1 object
return origin[0]
def remove_origin(self, unique_id, path):
"""Removes an origin pull mapping with the given origin pull ID.
:param str unique_id: The unique ID associated with the CDN.
:param str path: The origin path to delete.
:returns: A string value
"""
return self.cdn_path.deleteOriginPath(unique_id, path)
def purge_content(self, unique_id, path):
"""Purges a URL or path from the CDN.
:param str unique_id: The unique ID associated with the CDN.
:param str path: A string of url or path that should be purged.
:returns: A Container_Network_CdnMarketplace_Configuration_Cache_Purge array object
"""
return self.cdn_purge.createPurge(unique_id, path)
def get_usage_metrics(self, unique_id, history=30, frequency="aggregate"):
"""Retrieves the cdn usage metrics.
It uses the 'days' argument if start_date and end_date are None.
:param int unique_id: The CDN uniqueId from which the usage metrics will be obtained.
:param int history: Last N days, default days is 30.
:param str frequency: It can be day, week, month and aggregate. The default is "aggregate".
:returns: A Container_Network_CdnMarketplace_Metrics object
"""
_start = utils.days_to_datetime(history)
_end = utils.days_to_datetime(0)
self._start_date = utils.timestamp(_start)
self._end_date = utils.timestamp(_end)
usage = self.cdn_metrics.getMappingUsageMetrics(unique_id, self._start_date, self._end_date, frequency)
# The method getMappingUsageMetrics() returns an array but there is only 1 object
return usage[0]
@property
def start_data(self):
"""Retrieve the cdn usage metric start date."""
return self._start_date
@property
def end_date(self):
"""Retrieve the cdn usage metric end date."""
return self._end_date
|
