def runTest(self):
auth = EdgeGridAuth(
client_token=self.testdata['client_token'],
client_secret=self.testdata['client_secret'],
access_token=self.testdata['access_token'],
headers_to_sign=self.testdata['headers_to_sign'],
max_body=self.testdata['max_body']
)
headers = { }
if 'headers' in self.testcase['request']:
for h in self.testcase['request']['headers']:
for k,v in h.iteritems():
headers[k] = v
request = requests.Request(
method=self.testcase['request']['method'],
url=urljoin(self.testdata['base_url'],self.testcase['request']['path']),
headers=headers,
data=self.testcase['request'].get('data') if self.testcase['request'].get('data') \
else None
)
try:
auth_header = auth.make_auth_header(
request.prepare(), self.testdata['timestamp'], self.testdata['nonce']
)
except Exception, e:
logger.debug('Got exception from make_auth_header', exc_info=True)
self.assertEquals(str(e), self.testcase['failsWithMessage'])
return
def runTest(self):
auth = EdgeGridAuth(
client_token=self.testdata['client_token'],
client_secret=self.testdata['client_secret'],
access_token=self.testdata['access_token'],
)
params = {
'extended': 'true',
}
data = {
'key':'value',
}
request = requests.Request(
method='POST',
url=urljoin(self.testdata['base_url'],'/testapi/v1/t3'),
params=params,
json=data,
)
auth_header = auth.make_auth_header(
request.prepare(), self.testdata['timestamp'], self.testdata['nonce']
)
self.assertEqual(auth_header, self.testdata['jsontest_hash'])
def __init__(self, edgedns_creds):
logger.debug("creating _EdgeDNSClient")
pathhost = ""
if EDGEGRID_CREDS["edgerc_path"]:
section = 'default'
if EDGEGRID_CREDS["edgerc_section"]:
section = EDGEGRID_CREDS["edgerc_section"]
pathhost = EdgeRc(EDGEGRID_CREDS["edgerc_path"]).get(section, 'host')
self.edgegrid_auth = EdgeGridAuth.from_edgerc(EDGEGRID_CREDS["edgerc_path"], section)
else:
pathhost = EDGEGRID_CREDS["host"]
self.edgegrid_auth = EdgeGridAuth(client_token = EDGEGRID_CREDS["client_token"],
client_secret = EDGEGRID_CREDS["client_secret"],
access_token = EDGEGRID_CREDS["access_token"])
# Error checking the .edgerc file
if pathhost.find('://') > 0:
raise errors.PluginError('{0}: You have specified an invalid host entry '
'Please remove the http(s):// at the beginning.'
)
root_path = self.BASEURL.format(pathhost)
self.EDGEDNSROOTURL = urljoin(root_path, "/config-dns/v2/")
self.EDGEDNSZONESURL = self.EDGEDNSROOTURL + "zones/"
self.EDGEDNSCHANGESURL = self.EDGEDNSROOTURL + "changelists"
self.recordset_semaphore = threading.Semaphore()
return
def runTest(self):
auth = EdgeGridAuth(client_token=self.testdata['client_token'],
client_secret=self.testdata['client_secret'],
access_token=self.testdata['access_token'],
headers_to_sign=self.testdata['headers_to_sign'],
max_body=self.testdata['max_body'])
headers = {}
if 'headers' in self.testcase['request']:
for h in self.testcase['request']['headers']:
for k, v in h.items():
headers[k] = v
request = requests.Request(
method=self.testcase['request']['method'],
url=urljoin(self.testdata['base_url'],self.testcase['request']['path']),
headers=headers,
data=self.testcase['request'].get('data') if self.testcase['request'].get('data') \
else None
)
try:
auth_header = auth.make_auth_header(request.prepare(),
self.testdata['timestamp'],
self.testdata['nonce'])
except Exception as e:
logger.debug('Got exception from make_auth_header', exc_info=True)
self.assertEquals(str(e), self.testcase['failsWithMessage'])
return
self.assertEqual(auth_header, self.testcase['expectedAuthorization'])
def runTest(self):
auth = EdgeGridAuth(
client_token=self.testdata['client_token'],
client_secret=self.testdata['client_secret'],
access_token=self.testdata['access_token'],
)
params = {
'extended': 'true',
}
data = {
'key': 'value',
}
request = requests.Request(
method='POST',
url=urljoin(self.testdata['base_url'], '/testapi/v1/t3'),
params=params,
json=data,
)
auth_header = auth.make_auth_header(request.prepare(),
self.testdata['timestamp'],
self.testdata['nonce'])
self.assertEqual(auth_header, self.testdata['jsontest_hash'])
def main():
params = demisto.params()
client = Client(base_url=urljoin(params.get('host'), '/siem/v1/configs'),
verify=not params.get('insecure', False),
proxy=params.get('proxy'),
auth=EdgeGridAuth(
client_token=params.get('clientToken'),
access_token=params.get('accessToken'),
client_secret=params.get('clientSecret')))
commands = {
f"test-module": test_module_command,
f"{INTEGRATION_COMMAND_NAME}-get-events": get_events_command
}
command = demisto.command()
demisto.debug(f'Command being called is {command}')
try:
if command == 'fetch-incidents':
incidents, new_last_run = fetch_incidents_command(
client,
fetch_time=params.get('fetchTime'),
fetch_limit=params.get('fetchLimit'),
config_ids=params.get('configIds'),
last_run=demisto.getLastRun().get('lastRun'))
demisto.incidents(incidents)
demisto.setLastRun(new_last_run)
else:
human_readable, entry_context, raw_response = commands[command](
client, **demisto.args())
return_outputs(human_readable, entry_context, raw_response)
except Exception as e:
err_msg = f'Error in {INTEGRATION_NAME} Integration [{e}]'
return_error(err_msg, error=e)
def get_property_hostnames(latestVersion, propertyId, contractId, groupId,
path, section, switchkey):
# setting up authentication as in https://github.com/akamai/AkamaiOPEN-edgegrid-python
property_hostnames_list = []
edgerc = EdgeRc(path)
baseurl = 'https://%s' % edgerc.get(section, "host")
http_request = requests.Session()
http_request.auth = EdgeGridAuth.from_edgerc(edgerc, section)
# setting up request headers
headers = {}
headers['PAPI-Use-Prefixes'] = "true"
http_request.headers = headers
# getting the list of groups and contracts associated to groups: https://developer.akamai.com/api/core_features/property_manager/v1.html#getgroups
http_response = http_request.get(
urljoin(
baseurl, '/papi/v1/properties/' + propertyId + '/versions/' +
str(latestVersion) + '/hostnames?contractId=' + contractId +
'&groupId=' + groupId +
'&validateHostnames=false&accountSwitchKey=' + switchkey))
http_status_code = http_response.status_code
http_content = json.loads(http_response.text)
try:
test = http_content['hostnames']['items']
except KeyError:
pass
else:
for item in http_content['hostnames']['items']:
property_hostnames_list = property_hostnames_list + [
item['cnameFrom']
]
return (property_hostnames_list)
def get_properties(contractId, groupId, path, section, switchkey):
# setting up authentication as in https://github.com/akamai/AkamaiOPEN-edgegrid-python
dict_list = []
edgerc = EdgeRc(path)
baseurl = 'https://%s' % edgerc.get(section, "host")
http_request = requests.Session()
http_request.auth = EdgeGridAuth.from_edgerc(edgerc, section)
# setting up request headers
headers = {}
headers['PAPI-Use-Prefixes'] = "true"
http_request.headers = headers
# getting the latest property version: https://developer.akamai.com/api/core_features/property_manager/v1.html#getproperties
http_response = http_request.get(
urljoin(
baseurl, '/papi/v1/properties?contractId=' + contractId +
'&groupId=' + groupId + '&accountSwitchKey=' + switchkey))
http_status_code = http_response.status_code
http_content = json.loads(http_response.text)
for item in http_content['properties']['items']:
dict_list = dict_list + [{
"latestVersion": item['latestVersion'],
"propertyId": item['propertyId'],
"contractId": contractId,
"groupId": groupId
}]
return (dict_list)
def init_config(edgerc_file, section):
global baseurl, session
# Check if the edgerc_file variable or the AKAMAI_EDGERC env var exist then use a default value if they don't exist.
if not edgerc_file:
if not os.getenv("AKAMAI_EDGERC"):
edgerc_file = os.path.join(os.path.expanduser("~"), '.edgerc')
else:
edgerc_file = os.getenv("AKAMAI_EDGERC")
if not os.access(edgerc_file, os.R_OK):
print("Unable to read edgerc file \"%s\"" % edgerc_file)
exit(1)
if not section:
if not os.getenv("AKAMAI_EDGERC_SECTION"):
section = "default"
else:
section = os.getenv("AKAMAI_EDGERC_SECTION")
try:
edgerc = EdgeRc(edgerc_file)
baseurl = 'https://%s' % edgerc.get(section, 'host')
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(edgerc, section)
return (baseurl, session)
except configparser.NoSectionError:
print("Edgerc section \"%s\" not found" % section)
exit(1)
except Exception:
print("Unknown error occurred trying to read edgerc file (%s)" %
edgerc_file)
exit(1)
def _get_dns_info(self, rrecord):
aka_cust_object = MISPObject('misc')
tagInfo=["source:AkamaiETP"]
_text = ""
dimensions = ['deviceId','site']
for dimension in dimensions:
#_result = self._run_custom_request(self, rrecord, dimension)
session = requests.Session()
session.auth = EdgeGridAuth(
client_token = self.ctoken,
client_secret = self.csecret,
access_token = self.atoken
)
confID = self.configID
epoch_time = int(time.time())
last_30_days = epoch_time - 3600 * 24 * 30 # last month by default for now
url = f'/etp-report/v2/configs/{str(confID)}' + \
f'/dns-activities/aggregate?cardinality=2500&dimension={dimension}&endTimeSec={epoch_time}&filters' + \
f'=%7B%22domain%22:%7B%22in%22:%5B%22{rrecord}%22%5D%7D%7D&startTimeSec={last_30_days}'
_result = session.get(urljoin(self.baseurl, url)).json()
if _result['dimension']['total'] != 0:
_text += dimension + ' involved\n\n'
if 'aggregations' in _result:
for el in _result['aggregations']:
name = el['name']
_text += f"{name} : {el['total']} connections \n"
aka_cust_object.add_attribute('Customer Attribution', type='text', value=str(_text), Tag=tagInfo, disable_correlation=True)
self.incident_flag = "true"
self.misp_event.add_object(**aka_cust_object)
def __init__(self, credfile='.edgerc', section='default'):
self.credfile = credfile
self.section = section
self.edgerc = EdgeRc(self.credfile)
self.baseurl = 'https://{}'.format(self.edgerc.get(section, 'host'))
self.s = requests.Session()
self.s.auth = EdgeGridAuth.from_edgerc(self.edgerc, self.section)
def __init__(self, baseurl, client_token, client_secret, access_token):
self.baseurl = baseurl
self.session = requests.Session()
self.session.auth = EdgeGridAuth(client_token=client_token,
client_secret=client_secret,
access_token=access_token,
max_body=128 * 1024)
def executeAPI(self,
api_command,
api_payload,
query,
verb='GET',
headers={}):
api_base_url = self.baseurl
action = api_command
url = urljoin(self.baseurl, action)
request_headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
request_headers.update(headers)
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(self.edgerc,
self.edgerc_section)
r = session.request(verb,
url,
headers=request_headers,
json=api_payload,
params=query)
self.http_status = r.status_code
self.http_content = r.content
content = r.content
return (content)
def papi_products(account_key, cid, verbose):
""" Getting a list of products """
if not cid:
print(
'Contract ID is required to get a list of Products. '
'To get a list of contracts, use "./' +
os.path.basename(__file__) + ' contracts"', '\n')
raise SystemExit
gssapi = ''
if account_key:
gssapi = '&accountSwitchKey=' + account_key
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(EDGERC, SECTION)
result = session.get(
urljoin(BASEURL, '/papi/v1/products?contractId=' + cid + gssapi))
# Get result of dictionaries and put them into a list
list_dict = result.json()
verbose_check(verbose, list_dict,
inspect.currentframe().f_code.co_name, [account_key, cid])
success_check(result.status_code, "200", list_dict, verbose)
print('accountId:', list_dict["accountId"])
print('contractId:', list_dict["contractId"])
print('Products:')
sorted_groups = sorted(list_dict["products"]["items"],
key=lambda x: x['productName'])
print('\t', 'productName;', 'productId;')
for items in sorted_groups:
print('\t', items['productName'] + ';', items['productId'] + ';')
print('\n')
def init_config(edgerc_file, section):
if not edgerc_file:
if not os.getenv("AKAMAI_EDGERC"):
edgerc_file = os.path.join(os.path.expanduser("~"), '.edgerc')
else:
edgerc_file = os.getenv("AKAMAI_EDGERC")
if not os.access(edgerc_file, os.R_OK):
root_logger.error("Unable to read edgerc file \"%s\"" % edgerc_file)
exit(1)
if not section:
if not os.getenv("AKAMAI_EDGERC_SECTION"):
section = "papi"
else:
section = os.getenv("AKAMAI_EDGERC_SECTION")
try:
edgerc = EdgeRc(edgerc_file)
base_url = edgerc.get(section, 'host')
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(edgerc, section)
return base_url, session
except configparser.NoSectionError:
root_logger.error("Edgerc section \"%s\" not found" % section)
exit(1)
except Exception:
root_logger.info(
"Unknown error occurred trying to read edgerc file (%s)" %
edgerc_file)
exit(1)
def main():
s = requests.Session()
# Akamai auth
s.auth = EdgeGridAuth.from_edgerc(edgerc, section)
url = 'https://{}/siem/v1/configs/{}?offset={}&from={}&to={}&limit={}'.format(
edgerc.get(section, 'host'), configIds, offset, firstTS, currentTS,
limit)
result = s.get(url)
content = result.content.decode("utf-8")
data = []
lines = content.splitlines()
lastLine = json.loads(lines[len(lines) - 1])
for l in lines[:-1]:
try:
j = json.loads(l)
tags = decoder(j['attackData']['ruleTags'])
# Filtering logs for only builtin Akamai web attacks and polices (ex. sqli, xss & rce)
if "WEB_ATTACK" in tags or "/POLICY/" in tags:
data.append(decodeData(j))
except Exception as e:
print(e)
with open(offsetPath, "w+") as f:
f.write(lastLine['offset'])
# Send data to syslog server
sendSyslog(data)
# Checking if every thing went will
healthCheck()
def __session(self):
session = getattr(self.__local, 'session', None)
if not session:
session = requests.Session()
session.auth = EdgeGridAuth(**self.__auth)
self.__local.session = session
return session
def test_edgerc_unparseable(self):
try:
auth = EdgeGridAuth.from_edgerc(
os.path.join(mydir, 'edgerc_test_doesnt_parse'))
self.fail("should have thrown an exception")
except:
pass
def api_record_create(zone: str, name: str, type: str, host: str,
client_secret: str, access_token: str, client_token: str,
switchkey: str, ip_list: list, ttl: int):
url = 'https://' + host + '/config-dns/v2/zones/' + zone + '/names/' + name + '/types/' + type + '?accountSwitchKey=' + switchkey
#print(url)
# creating a http request
http_request = requests.Session()
# post request headers
http_request.auth = EdgeGridAuth(client_token, client_secret, access_token)
headers = {}
headers['Content-type'] = "application/json"
http_request.headers = headers
# defining body of post request
body = {}
body['name'] = name
body['type'] = type
body['ttl'] = ttl
body['rdata'] = ip_list
#print(body)
json_body = json.dumps(body)
#print(json_body)
#http_request.data = json_body
http_response = http_request.post(url, data=json_body)
return (http_response)
def __init__(self, log=None, section_name="papi"):
self.log = log
self.session = requests.Session()
self.debug = False
self.verbose = False
self.section_name = section_name
self.account = None
# If all parameters are set already, use them. Otherwise
# use the config
self.config = EdgeGridConfig({}, self.section_name)
if hasattr(self.config, "debug") and self.config.debug:
self.debug = True
if hasattr(self.config, "verbose") and self.config.verbose:
self.verbose = True
# Set the config options
self.session.auth = EdgeGridAuth(
client_token=self.config.client_token,
client_secret=self.config.client_secret,
access_token=self.config.access_token)
if hasattr(self.config, 'headers'):
self.session.headers.update(self.config.headers)
self.baseurl = '%s://%s/' % ('https', self.config.host)
self.httpCaller = EdgeGridHttpCaller(self.session, self.debug,
self.verbose, self.baseurl,
self.log)
def purge(self, url):
auth = EdgeGridAuth(
client_token=self.client_token,
client_secret=self.client_secret,
access_token=self.access_token
)
headers = {'content-type': 'application/json'}
payload = {
'action': 'invalidate',
'objects': [url]
}
resp = requests.post(
self.fast_purge_url,
headers=headers,
data=json.dumps(payload),
auth=auth
)
logger.info(
u'Attempted to invalidate page {url}, '
'got back response {message}'.format(
url=url,
message=resp.text
)
)
resp.raise_for_status()
def papi_hostnames(account_key, cid, gid, pid, vid, verbose):
""" Not doing any checks because you should call this directly. There is no value. """
gssapi = ''
if account_key:
gssapi = '&accountSwitchKey=' + account_key
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(EDGERC, SECTION)
result = session.get(
urljoin(
BASEURL, '/papi/v1/properties/' + pid + '/versions/' + vid +
'/hostnames?contractId=' + cid + '&groupId=' + gid + gssapi))
# Get result of dictionaries and put them into a list
list_dict = result.json()
verbose_check(verbose, list_dict,
inspect.currentframe().f_code.co_name,
[account_key, cid, gid, pid, vid])
success_check(result.status_code, "200", list_dict, verbose)
# etag is needed for authentication
etag = list_dict['etag']
hosts = list_dict['hostnames']['items']
return (etag, hosts)
def papi_config(account_key, cid, gid, pid, vid, verbose):
""" Getting a config detail in JSON format """
if not cid or not gid or not pid or not vid:
print(
'Contract ID, Group ID, Property ID, and Version ID is required to get a the '
'property config details. This will be printed in JSON format.')
raise SystemExit
gssapi = ''
if account_key:
gssapi = '&accountSwitchKey=' + account_key
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(EDGERC, SECTION)
result = session.get(
urljoin(
BASEURL, '/papi/v1/properties/' + pid + '/versions/' + vid +
'/rules?contractId=' + cid + '&groupId=' + gid + gssapi))
# Get result of dictionaries and put them into a list
list_dict = result.json()
verbose_check(verbose, list_dict,
inspect.currentframe().f_code.co_name,
[account_key, cid, gid, pid, vid])
success_check(result.status_code, "200", list_dict, verbose)
print(json.dumps(list_dict))
def papi_latest(account_key, cid, gid, pid, version_source, verbose):
""" Not doing any checks because you should call this directly. There is no value. """
gssapi = ''
if account_key:
gssapi = '&accountSwitchKey=' + account_key
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(EDGERC, SECTION)
result = session.get(
urljoin(
BASEURL, '/papi/v1/properties/' + pid + '?contractId=' + cid +
'&groupId=' + gid + gssapi))
# Get result of dictionaries and put them into a list
list_dict = result.json()
verbose_check(verbose, list_dict,
inspect.currentframe().f_code.co_name,
[account_key, cid, gid, pid, version_source])
success_check(result.status_code, "200", list_dict, verbose)
if version_source == "PRODUCTION":
source_json = json.dumps(
list_dict["properties"]["items"][0]["productionVersion"])
elif version_source == "STAGING":
source_json = json.dumps(
list_dict["properties"]["items"][0]["stagingVersion"])
else:
source_json = json.dumps(
list_dict["properties"]["items"][0]["latestVersion"])
return source_json
def purgeCPCode(CP=None):
#Fetch Credentials from Env Variables from AWS
AO_ACCESS_TOKEN = os.environ['AO_ACCESS_TOKEN']
AO_CLIENT_SECRET = os.environ['AO_CLIENT_SECRET']
AO_API_HOST = os.environ['AO_API_HOST']
AO_CLIENT_TOKEN = os.environ['AO_CLIENT_TOKEN']
apiRequest = requests.Session()
apiRequest.auth = EdgeGridAuth(
client_token=AO_CLIENT_TOKEN,
client_secret=AO_CLIENT_SECRET,
access_token=AO_ACCESS_TOKEN
)
apiBaseUrl = "https://"+AO_API_HOST
apiEndpoint = apiBaseUrl+ "/ccu/v3/invalidate/cpcode/staging"
# Change Path for production network Purge
#apiEndpoint = apiBaseUrl+ "/ccu/v3/invalidate/cpcode/production"
postbody = '{"objects": ["' + str(CP) + '"]}'
response = apiRequest.post(apiEndpoint, postbody, headers={"Content-Type": "application/json"})
return {
'status':response.status_code,
'body': json.dumps(response.text)
}
def papi_groups(account_key, verbose):
""" Getting a list of groups """
gssapi = ''
if account_key:
gssapi = '?accountSwitchKey=' + account_key
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(EDGERC, SECTION)
result = session.get(urljoin(BASEURL, '/papi/v1/groups' + gssapi))
# Get result of dictionaries and put them into a list
list_dict = result.json()
verbose_check(verbose, list_dict,
inspect.currentframe().f_code.co_name, [account_key])
success_check(result.status_code, "200", list_dict, verbose)
print('accountId:', list_dict["accountId"])
print('accountName:', list_dict["accountName"])
print('Groups:')
sorted_groups = sorted(list_dict["groups"]["items"],
key=lambda x: x['groupName'])
print('\t', 'groupName;', 'groupId;', 'parentGroupId;')
for items in sorted_groups:
parent_id = items[
"parentGroupId"] if "parentGroupId" in items else "n/a"
print('\t', items['groupName'] + ';', items['groupId'] + ';',
parent_id + ';')
print('\n')
def load(self, edgerc_file, section, account_key):
if not edgerc_file:
if not os.getenv("AKAMAI_EDGERC"):
edgerc_file = os.path.join(os.path.expanduser("~"), '.edgerc')
else:
edgerc_file = os.getenv("AKAMAI_EDGERC")
if not os.access(edgerc_file, os.R_OK):
raise ValueError(
"Unable to read edgerc file {}".format(edgerc_file))
if not section:
if not os.getenv("AKAMAI_EDGERC_SECTION"):
section = "default"
else:
section = os.getenv("AKAMAI_EDGERC_SECTION")
try:
edgerc = EdgeRc(edgerc_file)
base_url = edgerc.get(section, 'host')
session = requests.Session()
session.auth = EdgeGridAuth.from_edgerc(edgerc, section)
context = self.buildContext(base_url, account_key, session)
return context
except configparser.NoSectionError:
raise ValueError("Edgerc section {} not found".format(section))
except Exception:
raise ValueError(
"Unknown error occurred trying to read edgerc file {}".format(
edgerc_file))
def api_session():
edgerc = EdgeRc(os.path.expanduser('~/.edgerc'))
section = 'default'
baseurl = 'https://%s' % edgerc.get(section, 'host')
s = requests.Session()
s.auth = EdgeGridAuth.from_edgerc(edgerc, section)
return [s, baseurl]
def test_edgerc_from_object(self):
auth = EdgeGridAuth.from_edgerc(EdgeRc(os.path.join(mydir, 'sample_edgerc')))
self.assertEqual(auth.client_token, 'xxxx-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx')
self.assertEqual(auth.client_secret, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=')
self.assertEqual(auth.access_token, 'xxxx-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx')
self.assertEqual(auth.max_body, 131072)
self.assertEqual(auth.headers_to_sign, [])
def test_get_header_versions(self):
auth = EdgeGridAuth.from_edgerc(os.path.join(mydir, 'sample_edgerc'), 'headers')
header = auth.get_header_versions()
self.assertFalse('user-agent' in header)
header = auth.get_header_versions({'User-Agent': 'testvalue'})
self.assertTrue('User-Agent' in header)
os.environ["AKAMAI_CLI"] = '1.0.0'
os.environ["AKAMAI_CLI_VERSION"] = '1.0.0'
header = auth.get_header_versions()
self.assertTrue('User-Agent' in header)
self.assertEqual(header['User-Agent'], ' AkamaiCLI/1.0.0')
os.environ["AKAMAI_CLI_COMMAND"] = '1.0.0'
os.environ["AKAMAI_CLI_COMMAND_VERSION"] = '1.0.0'
header = auth.get_header_versions()
self.assertTrue('User-Agent' in header)
self.assertEqual(header['User-Agent'], ' AkamaiCLI/1.0.0 AkamaiCLI-1.0.0/1.0.0')
header = auth.get_header_versions({'User-Agent': 'testvalue'})
self.assertTrue('User-Agent' in header)
self.assertEqual(header['User-Agent'], 'testvalue AkamaiCLI/1.0.0 AkamaiCLI-1.0.0/1.0.0')
del os.environ['AKAMAI_CLI']
del os.environ['AKAMAI_CLI_VERSION']
del os.environ['AKAMAI_CLI_COMMAND']
del os.environ['AKAMAI_CLI_COMMAND_VERSION']
self.assertFalse('AKAMAI_CLI' in os.environ)
self.assertFalse('AKAMAI_CLI_VERSION' in os.environ)
self.assertFalse('AKAMAI_CLI_COMMAND' in os.environ)
self.assertFalse('AKAMAI_CLI_COMMAND_VERSION' in os.environ)
def create_session():
session = requests.Session()
# Set the config options
session.auth = EdgeGridAuth(
client_token=os.environ['ETP_CLIENT_TOKEN'].strip(),
client_secret=os.environ['ETP_CLIENT_SECRET'].strip(),
access_token=os.environ['ETP_ACCESS_TOKEN'].strip())
return session
def get_session():
s = requests.Session()
s.auth = EdgeGridAuth(
client_token=os.environ['AK_CLIENT_TOKEN'],
client_secret=os.environ['AK_CLIENT_SECRET'],
access_token=os.environ['AK_ACCESS_TOKEN'],
)
return s
def Akamai_report(self):
s = requests.Session()
s.auth = EdgeGridAuth(client_token='xxxxxxxxxxxxxxxxxxx',
client_secret='xxxxxxxxxxxxxxxxxxx',
access_token='xxxxxxxxxxxxxxxxxxx')
baseurl = 'https://xxxxxxxxxxxxxxxxxxx.luna.akamaiapis.net/'
credentials_list = [s, baseurl]
return credentials_list
def papi_get(edgerc_path, path):
edgerc = EdgeRc(edgerc_path)
section = 'default'
s = requests.Session()
s.auth = EdgeGridAuth.from_edgerc(edgerc, section)
baseurl = 'https://%s' % edgerc.get(section, 'host')
return s.get(urlparse.urljoin(baseurl, path))
def edge_session(env, config):
s = requests.Session()
s.auth = EdgeGridAuth(
# This is akamai credential
client_token=config.get(env, 'client_token'),
client_secret=config.get(env, 'client_secret'),
access_token=config.get(env, 'access_token'))
return s
def papi_get(edgerc_path, path):
edgerc = EdgeRc(edgerc_path)
section = 'default'
s = requests.Session()
s.auth = EdgeGridAuth.from_edgerc(edgerc, section)
baseurl = 'https://%s' % edgerc.get(section, 'host')
body = s.get(urlparse.urljoin(baseurl, path))
if body.status_code > 200:
print "Error, got HTTP status code %s" % body.status_code
print body.content
exit(1)
if body.status_code == 200:
return s.get(urlparse.urljoin(baseurl, path))
def load_edgegrid_client_settings():
'''Load Akamai EdgeGrid configuration
returns a (hostname, EdgeGridAuth) tuple from the following locations:
1. Values specified directly in the Django settings::
AKAMAI_CCU_CLIENT_SECRET
AKAMAI_CCU_HOST
AKAMAI_CCU_ACCESS_TOKEN
AKAMAI_CCU_CLIENT_TOKEN
2. An edgerc file specified in the AKAMAI_EDGERC_FILENAME settings
3. The default ~/.edgerc file
Both edgerc file load options will return the values from the “CCU” section
by default. This may be customized using the AKAMAI_EDGERC_CCU_SECTION setting.
'''
if getattr(settings, 'AKAMAI_CCU_CLIENT_SECRET', None):
# If the settings module has the values directly and they are not empty
# we'll use them without checking for an edgerc file:
host = settings.AKAMAI_CCU_HOST
auth = EdgeGridAuth(access_token=settings.AKAMAI_CCU_ACCESS_TOKEN,
client_token=settings.AKAMAI_CCU_CLIENT_TOKEN,
client_secret=settings.AKAMAI_CCU_CLIENT_SECRET)
return host, auth
else:
edgerc_section = getattr(settings, 'AKAMAI_EDGERC_CCU_SECTION', 'CCU')
edgerc_path = getattr(settings, 'AKAMAI_EDGERC_FILENAME', '~/.edgerc')
edgerc_path = os.path.expanduser(edgerc_path)
if os.path.isfile(edgerc_path):
edgerc = EdgeRc(edgerc_path)
host = edgerc.get(edgerc_section, 'host')
auth = EdgeGridAuth.from_edgerc(edgerc, section=edgerc_section)
return host, auth
raise InvalidAkamaiConfiguration('Cannot find Akamai client configuration!')
def test_edgerc_headers(self):
auth = EdgeGridAuth.from_edgerc(os.path.join(mydir, 'sample_edgerc'), 'headers')
self.assertEqual(auth.headers_to_sign, ['x-mything1', 'x-mything2'])
def test_edgerc_broken(self):
auth = EdgeGridAuth.from_edgerc(os.path.join(mydir, 'sample_edgerc'), 'broken')
self.assertEqual(auth.client_secret, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=')
self.assertEqual(auth.access_token, 'xxxx-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx')
self.assertEqual(auth.max_body, 128*1024)
self.assertEqual(auth.headers_to_sign, [])
def test_edgerc_unparseable(self):
try:
auth = EdgeGridAuth.from_edgerc(os.path.join(mydir, 'edgerc_that_doesnt_parse'))
self.fail("should have thrown an exception")
except:
pass
def test_edgerc_dashes(self):
auth = EdgeGridAuth.from_edgerc(os.path.join(mydir, 'sample_edgerc'), 'dashes')
self.assertEqual(auth.max_body, 128*1024)
session = requests.Session()
logger = logging.getLogger(__name__)
parser = argparse.ArgumentParser(description='Process command line options.')
parser.add_argument('--verbose', '-v', default=False, action='count')
parser.add_argument('--debug', '-d', default=False, action='count')
args = parser.parse_args()
arguments = vars(args)
rc_path = os.path.expanduser("~/.edgerc")
edgerc = EdgeRc(rc_path)
baseurl = 'https://%s' % edgerc.get(section_name, 'host')
# Set the config options
session.auth = EdgeGridAuth.from_edgerc(edgerc, section_name)
if hasattr(edgerc, "debug") or arguments['debug']:
client.HTTPConnection.debuglevel = 1
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True
debug = True
if hasattr(edgerc, "verbose") or arguments['verbose']:
verbose = True
httpCaller = EdgeGridHttpCaller(session, debug,verbose, baseurl)
