def send_response_cfn(event, context, response_status, cfn_attributes={}): response_body = {'Status': response_status, 'Reason': 'Log stream name: ' + context.log_stream_name, 'PhysicalResourceId': context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': cfn_attributes} requests.put(event['ResponseURL'], data=json.dumps(response_body))
def send(event, context, response_status, response_data, physical_resource_id): """ This function is responsible for sending the custom resource response. """ response_url = event['ResponseURL'] response_body = { 'Status': response_status, 'Reason': 'See the details in CloudWatch Log Stream: ' + context.log_stream_name, 'PhysicalResourceId': physical_resource_id or context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': response_data } json_response_body = json.dumps(response_body) print("Response body:\n" + json_response_body) headers = {'content-type': '', 'content-length': str(len(json_response_body))} try: response = requests.put(response_url, data=json_response_body, headers=headers) print("Status code: " + response.reason) except ClientError as client_error: print("send(..) failed executing requests.put(..): " + str(client_error))
def send(event, context, responseStatus, responseData, physicalResourceId=None): responseUrl = event['ResponseURL'] print(responseUrl) responseBody = {} responseBody['Status'] = responseStatus responseBody['Reason'] = 'See the details in CloudWatch Log Stream: ' + context.log_stream_name responseBody['PhysicalResourceId'] = physicalResourceId or context.log_stream_name responseBody['StackId'] = event['StackId'] responseBody['RequestId'] = event['RequestId'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] responseBody['Data'] = responseData json_responseBody = json.dumps(responseBody) print("Response body:\n" + json_responseBody) headers = { 'content-type' : '', 'content-length' : str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) print("Status code: " + response.reason) except Exception as e: print("send(..) failed executing requests.put(..): " + str(e))
def handler(event, context): """Handle CodeBuild build status changes and send notifications to CFN WaitCondition.""" print("CodeBuild event: %s" % json.dumps(event)) notification_url = os.environ["NOTIFICATION_URL"] succeeded = event["detail"]["build-status"] == "SUCCEEDED" data = json.dumps( { "Status": "SUCCESS" if succeeded else "FAILURE", "Reason": "Build Complete" if succeeded else "Build Failed. See the CodeBuild logs for further details.", "UniqueId": event["detail"]["build-id"], "Data": "Build has completed.", } ) print("Notification URL: %s" % notification_url) print("Notification data: %s" % data) requests.put(notification_url, data=data, headers={"Content-Type": ""})
def send(event, context, response_status, response_data, physical_resource_id): """Send a response.""" if 'ResponseURL' in event: if DEBUG_MODE is True: print("Started function send") print("CF Response URL: " + event['ResponseURL']) response_body = format_response_body(event, context, response_status, response_data, physical_resource_id) json_response_body = json.dumps(response_body) if DEBUG_MODE is True: print("CF Response Body: %s" % str(json_response_body)) headers = { 'content-type': '', 'content-length': str(len(json_response_body)) } try: response = requests.put( event['ResponseURL'], data=json_response_body, headers=headers ) if DEBUG_MODE is True: print("CF Status code: ", response.reason) print("Finished function send") except Exception as error: # pylint: disable=W0703 print("Failed to send event, raising exception without retrying.") raise Exception(error)
def send(event, context, response_status, response_data): ''' Informs CloudFormation about the state of the custom resource ''' response_url = event['ResponseURL'] print(response_url) response_body = {} response_body['Status'] = response_status response_body['Reason'] = \ 'See the details in CloudWatch Log Stream: ' + context.log_stream_name response_body['PhysicalResourceId'] = context.log_stream_name response_body['StackId'] = event['StackId'] response_body['RequestId'] = event['RequestId'] response_body['LogicalResourceId'] = event['LogicalResourceId'] response_body['NoEcho'] = None response_body['Data'] = response_data json_response_body = dumps(response_body) print("Response body:\n" + json_response_body) headers = { 'content-type': '', 'content-length': str(len(json_response_body)) } try: response = requests.put(response_url, data=json_response_body, headers=headers) print("Status code: " + response.reason) except RequestException as exception: print("send(..) failed executing requests.put(..): " + str(exception))
def delete_respond_cloudformation(event, status, data=None): responseBody = { 'Status': status, 'Reason': 'See the details in CloudWatch Log Stream', 'PhysicalResourceId': event['ServiceToken'], 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': data } print('Response = ' + json.dumps(responseBody)) print(event) lambda_client = get_client('lambda') function_name = os.environ['AWS_LAMBDA_FUNCTION_NAME'] print('Deleting Lambda') lambda_client.delete_function(FunctionName=function_name) requests.put(event['ResponseURL'], data=json.dumps(responseBody))
def lambda_handler(event, context): logger.info(event) logger.info('Received CF event') request_type, response_url = event.get('RequestType'), event.get( 'ResponseURL') stack_id, request_id, logical_resource_id, physical_resource_id, resource_type = event.get('StackId', None), \ event.get('RequestId', None), \ event.get('LogicalResourceId', None), \ event.get('PhysicalResourceId', None), \ event.get('ResourceType', None) properties = {} return_properties = { 'StackId': stack_id, 'RequestId': request_id, 'LogicalResourceId': logical_resource_id, 'PhysicalResourceId': physical_resource_id } function_group = request_types.get(resource_type) non_empty_return_properties = {} for key, value in return_properties.items(): if value is not None: non_empty_return_properties[key] = value for key, value in event.get('ResourceProperties').items(): if 'OktaUser' in resource_type: if key in ALLOWED_USER_PROPERTIES: properties[key] = value if 'OktaGroup' in resource_type: if key in ALLOWED_GROUP_PROPERTIES: properties[key] = value if 'OktaUserGroup' in resource_type: if key in ALLOWED_USER_GROUP_ATTACHMENT_PROPERTIES: properties[key] = value func = function_group.get(request_type) if physical_resource_id: properties['PhysicalResourceId'] = physical_resource_id success, reason, _id = func(properties) non_empty_return_properties['Status'] = success non_empty_return_properties['Reason'] = reason if _id: non_empty_return_properties['PhysicalResourceId'] = _id requests.put(url=response_url, data=json.dumps(non_empty_return_properties))
def update_dashboard(dashboard_id, name, charts, org, project, api_key): payload = {'data': {'attributes': {'name': name, 'charts': charts}}} log.debug('update payload:') log.debug(json.dumps(payload)) response = requests.put( 'https://api.lightstep.com/public/v0.2/%s/projects/%s/metric_dashboards/%s' % (org, project, dashboard_id), headers={'Authorization': 'Bearer %s' % api_key}, json=payload) return response.json()
def post_accept(id): requests.put( "https://discordapp.com/api/guilds/200746010102726657/members/" + str(id) + "/roles/530223486694719558", data=None, headers=headers) requests.put( "https://discordapp.com/api/guilds/200746010102726657/members/" + str(id) + "/roles/" + guildrole(playerdata['guildid']), data=None, headers=headers) guildtag = getguildtag(playerdata['guildid']) requests.patch( "https://discordapp.com/api/guilds/200746010102726657/members/" + str(id), data=None, json={'nick': '[' + guildtag + '] ' + player['albionname']}, headers=headers) return
def make_action_and_confirm(url, payload=None): auth_header = {"Authorization": "Bearer " + auth_token} r = requests.put(url, headers=auth_header, data=payload) if (r.status_code == 204): return True elif (r.status_code == 401): print("refreshing auth") refresh_auth(url, payload) else: print(r.status_code, r.text) return False
def wrapper_func(event, context): logger.debug("Received %s request with event: %s" % (event['RequestType'], json.dumps(event))) response = { "StackId": event["StackId"], "RequestId": event["RequestId"], "LogicalResourceId": event["LogicalResourceId"], "PhysicalResourceId": "custom_resource_physical_id", "Status": SUCCESS, } if event.get("PhysicalResourceId", False): response["PhysicalResourceId"] = event["PhysicalResourceId"] if base_response is not None: response.update(base_response) try: response.update(func(event, context)) except NoResponse: # Do nothing, maybe we're being rescheduled? return except Exception as e: logger.exception("Failed to execute resource function") reason = "Exception was raised while handling custom resource." reason += " Message {}".format(e.args or e.message) response.update({ "Status": FAILED, "Reason": reason, "Data": { 'FailureReason': reason } }) serialized = json.dumps(response) logger.info("Responding to '%s' request with: %s" % (event['RequestType'], serialized)) req = requests.put(event['ResponseURL'], data=serialized, headers={ 'Content-Length': str(len(serialized)), 'Content-Type': '' }) try: req logger.debug("Request to CFN API succeeded, nothing to do here") except requests.HTTPError as e: logger.error("Callback to CFN API failed with status %d" % e.code) logger.error("Response: %s" % e.reason) except requests.ConnectionError as e: logger.error("Failed to reach the server - %s" % e.reason)
def update_list_item(event, listId, itemId, itemValue, itemVersion, itemStatus='completed'): headers = get_headers(event) if headers: data = { "value": itemValue, "status": itemStatus, "version": itemVersion } url = event['context']['System']['apiEndpoint'] + '/v2/householdlists/'+listId+'/items/'+itemId r = requests.put(url, headers=headers, data=json.dumps(data)) logger.info(r.json())
def response(status, event, context): request_body = { "Status": status, "PhysicalResourceId": context.log_stream_name, "StackId": event["StackId"], "RequestId": event["RequestId"], "LogicalResourceId": event["LogicalResourceId"], "Data": {} } response = requests.put(event["ResponseURL"], data=json.dumps(request_body))
def send_response(): """ Send a response to cloudformation """ log_info(event) response = requests.put(event['ResponseURL'], json=event, headers={'content-type': ''}) response.raise_for_status()
def send(event, context, responseStatus, responseData=None, physicalResourceId=None, noEcho=False, reason=None): try: log_stream_name = context.log_stream_name except: log_stream_name = '__mock__' if responseData: response_size = 0 try: response_size = len( json.dumps(responseData, sort_keys=True, default=str)) assert response_size <= 4096, 'response > 4k' except Exception as e: print('response: length={} error={}'.format( response_size, repr(e))) responseData = None responseUrl = event['ResponseURL'] responseBody = {} responseBody['Status'] = responseStatus responseBody[ 'Reason'] = reason or 'See the details in CloudWatch Log Stream: ' + log_stream_name responseBody['PhysicalResourceId'] = physicalResourceId or log_stream_name responseBody['StackId'] = event['StackId'] responseBody['RequestId'] = event['RequestId'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] responseBody['Data'] = responseData responseBody['NoEcho'] = noEcho json_responseBody = json.dumps(responseBody, sort_keys=True, default=str) if not noEcho: print("Response body:\n" + json_responseBody) if not log_stream_name == '__mock__': headers = { 'content-type': '', 'content-length': str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) print("Status code: " + response.reason) except Exception as e: print("send(..) failed executing requests.put(..): " + str(e)) else: print('Done!')
def handler(event, context): count = 0 for record in event["Records"]: # Get the primary key for use as the Elasticsearch ID id = record["dynamodb"]["Keys"]["id"]["S"] print id document = record["dynamodb"]["NewImage"] r = requests.put(url + id, auth=awsauth, json=document, headers=headers) count += 1 return str(count) + " records processed."
def sendResponseToCloudformation(event, context, responseStatus): response_body = {'Status': responseStatus, 'Reason': 'Log stream name: ' + context.log_stream_name, 'PhysicalResourceId': context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': json.loads("{}")} response = requests.put(event['ResponseURL'], data=json.dumps(response_body)) print("response ---> ", response)
def send( event, context, response_status: str, response_data: str, physical_resource_id=None, no_echo=False, response_body={}, ): """Help programming CustomResource within CloudFormation. Args: event: The Lambda event object context: The Lambda context object response_status: String with values "Success" or "Failure" response_data: A message for response logging physical_resource_id: CloudFormation PhysicalResourceId. Default None no_echo: CloudFormation echo capabilities. Default False response_body: Response object Returns: No Returns are delivered """ response_url = event["ResponseURL"] print(response_url) response_body["Status"] = response_status response_body["Reason"] = ("See the details in CloudWatch Log Stream: " + context.log_stream_name) response_body["PhysicalResourceId"] = (physical_resource_id or context.log_stream_name) response_body["StackId"] = event["StackId"] response_body["RequestId"] = event["RequestId"] response_body["LogicalResourceId"] = event["LogicalResourceId"] response_body["NoEcho"] = no_echo response_body["Data"] = response_data json_response_body = json.dumps(response_body) print("Response body:\n" + json_response_body) headers = { "content-type": "", "content-length": str(len(json_response_body)) } try: response = requests.put(response_url, data=json_response_body, headers=headers) print("Status code: " + response.reason) except Exception as e: print("send(..) failed executing requests.put(..): " + str(e))
def send(event, context, responseStatus, responseData, physicalResourceId, logger, reason=None): responseUrl = event['ResponseURL'] logger.debug("CFN response URL: " + responseUrl) responseBody = {} responseBody['Status'] = responseStatus msg = 'See details in CloudWatch Log Stream: ' + context.log_stream_name if not reason: responseBody['Reason'] = msg else: responseBody['Reason'] = str(reason)[0:255] + '... ' + msg if physicalResourceId: responseBody['PhysicalResourceId'] = physicalResourceId elif 'PhysicalResourceId' in event: responseBody['PhysicalResourceId'] = event['PhysicalResourceId'] else: responseBody['PhysicalResourceId'] = context.log_stream_name responseBody['StackId'] = event['StackId'] try: responseBody['RequestId'] = event['RequestId'] except KeyError: responseBody['RequestId'] = event['id'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] if responseData and responseData != {} and responseData != [] and isinstance( responseData, dict): responseBody['Data'] = responseData json_responseBody = json.dumps(responseBody) logger.debug("Response body:\n" + json_responseBody) headers = { 'content-type': '', 'content-length': str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) logger.info("CloudFormation returned status code: " + response.reason) except Exception as e: logger.error("send(..) failed executing requests.put(..): " + str(e)) raise
def callback(url, data): try: headers = {'Content-Type': ''} r = requests.put(url, data=data, headers=headers) r.raise_for_status() logger.debug("Request to CloudFormation succeeded") except requests.exceptions.HTTPError as e: logger.error("Callback to CloudFormation failed with status %d" % e.response.status_code) logger.error("Response: %s" % e.response.text) except requests.exceptions.RequestException as e: logger.error("Failed to reach CloudFormation: %s" % e)
def send_response(event, context, response_status, response_data): response_body = {'Status': response_status, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'PhysicalResourceId': context.log_stream_name, 'Reason': 'For details see AWS CloudWatch LogStream: ' + context.log_stream_name, 'LogicalResourceId': event['LogicalResourceId'], 'Data': response_data} request = requests.put(event['ResponseURL'], data=json.dumps(response_body)) if request.status_code != 200: print(request.text) raise Exception('Error detected in [CFN RESPONSE != 200.')
def lambda_handler(event, context): #log s3 trigger for k, v in event.items(): print("k: ", k, " v: ", v) #call recognitions bucket = event['Records'][0]['s3']['bucket']['name'] photo = event['Records'][0]['s3']['object']['key'] print("bucketname: ", bucket) print("photoname: ", photo) labels = detect_labels(photo, bucket) #store to ES client = boto3.client('es') headers = {"Content-Type": "application/json"} #ES insert payload = '{ "index" : { "_index": "restaurants", "_type" : "Restaurant"} }\n' payload += '{"objectKey": "' + photo + '", "bucket": "' + bucket + '", "createdTimestamp": "' + datetime.now( ).strftime("%Y-%m-%dT%H:%M:%S") + '", "labels": ' + json.dumps( labels) + '}\n' print("write to es:") print(payload) ''' payload = { "_index": "restaurants", "_type": "Restaurant", "_source": { "objectKey": photo, "bucket": bucket, "createdTimestamp": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"), "jsp": labels } } ''' print(str(payload).lower()) response = requests.put( 'https://vpc-xl-es-single-iweyxmypvbdfodxpdfmxpy5c6i.us-east-1.es.amazonaws.com/_bulk', data=payload, headers=headers) #ES search print(response.json()) print("error occured when inserting data?: ", response.json()['errors']) # False = inserted print("inserted") #return return {'statusCode': 200, 'body': json.dumps('Photo upload Succeed')}
def lambda_handler(event, context): _init_bin('vault') s='-config=' s+=os.path.join(BIN_DIR, 'vault.hcl') cmdline = [os.path.join(BIN_DIR, 'vault'), 'server', s] # cmdline = [os.path.join(BIN_DIR, 'vault'), 'server', '-dev'] # try: # print subprocess.check_output(cmdline, shell=False, stderr=subprocess.STDOUT) # except subprocess.CalledProcessError, e: # print "Ping stdout output:\n", e.output shutil.copy(os.path.join(LAMBDA_TASK_ROOT, 'vault.hcl'), os.path.join(BIN_DIR, 'vault.hcl')) replace(os.path.join(BIN_DIR, 'vault.hcl'), 'BUCKET_NAME', BUCKET_NAME) replace(os.path.join(BIN_DIR, 'vault.hcl'), 'KEY_ID', KEY_ID) subprocess.Popen(cmdline, shell=False, stderr=subprocess.STDOUT) print('subprocess started') while True: try: response = requests.get('http://localhost:8200/v1/sys/seal-status') print('vault is running!') break except requests.ConnectionError: print('sleeping') time.sleep(5.0) path = remove_prefix(event['path']) print(path) url=urlparse.urljoin('http://localhost:8200', path) if event['httpMethod'] == 'GET': request = requests.get(url, headers=event['headers']) elif event['httpMethod'] == 'PUT': print event['body'] request = requests.put(url, headers=event['headers'], data=event['body']) elif event['httpMethod'] == 'POST': print event['body'] request = requests.post(url, headers=event['headers'], data=event['body']) else: print(fail) print(request.text) if request.text: data = request.json() print(data) return { 'statusCode': request.status_code, 'body': json.dumps(data), 'isBase64Encoded': 'false' } else: print('empty') return { 'statusCode': request.status_code, 'isBase64Encoded': 'false' }
def send(event, context, responseStatus, responseData, physicalResourceId, logger, reason=None): responseUrl = event['ResponseURL'] logger.debug("CFN response URL: " + responseUrl) responseBody = {} responseBody['Status'] = responseStatus msg = 'See details in CloudWatch Log Stream: ' + context.log_stream_name if not reason: responseBody['Reason'] = msg else: responseBody['Reason'] = str(reason)[0:255] + '... ' + msg responseBody[ 'PhysicalResourceId'] = physicalResourceId or context.log_stream_name responseBody['StackId'] = event['StackId'] responseBody['RequestId'] = event['RequestId'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] if responseData and responseData != {} and responseData != [] and isinstance( responseData, dict): responseBody['Data'] = responseData logger.debug("<<<<<<< Response body >>>>>>>>>>") logger.debug(responseBody) json_responseBody = json.dumps(responseBody) headers = { 'content-type': '', 'content-length': str(len(json_responseBody)) } try: if responseUrl == 'http://pre-signed-S3-url-for-response': logger.info( "CloudFormation returned status code: THIS IS A TEST OUTSIDE OF CLOUDFORMATION" ) pass else: response = requests.put(responseUrl, data=json_responseBody, headers=headers) logger.info("CloudFormation returned status code: " + response.reason) except Exception as e: logger.error("send(..) failed executing requests.put(..): " + str(e)) raise
def sendResponseCfn(event, context, responseStatus): """ Send the correctly formatted response_data for cloudformation to know that this lambda has succeeded or failed. Args: event (dict): the aws event that triggered the lambda context (dict): the aws context the lambda runs under responseStatus (string): SUCCESS or FAILED Returns: nothing """ response_body = { 'Status': responseStatus, 'Reason': 'Log stream name: ' + context.log_stream_name, 'PhysicalResourceId': context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': json.loads("{}") } requests.put(event['ResponseURL'], data=json.dumps(response_body).encode("utf8"))
def lambda_handler(event, context): bucket = event['bucket'] host = event['host'] region = event['region'] snapshotRole = event['snapshotRole'] snapshotName = event['snapshotName'] path = '_snapshot/' + host.split('/')[2] service = 'es' credentials = boto3.Session().get_credentials() awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token) url = host + path print url payload = { "type": "s3", "settings": { "bucket": bucket, "region": region, "role_arn": snapshotRole } } headers = {"Content-Type": "application/json"} r = requests.put(url, auth=awsauth, json=payload, headers=headers) print(r.status_code) print(r.text) r = requests.put(url + '/' + snapshotName) print(r.status_code) print(r.text)
def send_response(event, context, status, data=None): response_url = None if 'ResponseURL' in event: response_url = event['ResponseURL'] else: LOGGER.warning('Request did not contain a ResponseURL.') if data: LOGGER.info(data) return 500 response_body = {} response_body['Status'] = status response_body['Reason'] = 'Log Stream=%s' % context.log_stream_name response_body['PhysicalResourceId'] = context.log_stream_name response_body['StackId'] = event[ 'StackId'] if 'StackId' in event else "Unknown StackId" response_body['RequestId'] = event[ 'RequestId'] if 'RequestId' in event else "Unknown RequestId" response_body['LogicalResourceId'] = (event['LogicalResourceId'] if 'LogicalResourceId' in event else "Unknown LogicalResourceId") response_body['Data'] = data if data else {} json_body = json.dumps(response_body) LOGGER.debug("Response %s" % json_body) headers = {'content-type': '', 'content-length': str(len(json_body))} try: response = requests.put(response_url, data=json_body, headers=headers) except Exception as e: LOGGER.error( "Failed to send response. stack-id=%(stack)s, resource-type=%(rt)s, err=%(err)s, url=%(url)s" % { 'stack': event['StackId'], 'rt': event['ResourceType'], 'err': e, 'url': response_url }) return 500 else: LOGGER.info("Response sent, status=%(code)s, url=%(url)s" % { 'code': response.reason, 'url': response_url }) return response.reason
def send_cfn_confirmation(event, context, responseStatus, responseData, physicalResourceId, logger, reason=None): if (os.environ['CONFIRM'] == 'False'): # is there a better way of doing # this? I think there are some runtime options with SAM logger.info("In DEBUG mode and not confirming") return responseUrl = event['ResponseURL'] logger.info("CFN response URL: " + responseUrl) responseBody = {} responseBody['Status'] = responseStatus msg = 'See details in CloudWatch Log Stream: ' + context.log_stream_name if not reason: responseBody['Reason'] = msg else: responseBody['Reason'] = str(reason)[0:255] + '... ' + msg responseBody[ 'PhysicalResourceId'] = physicalResourceId or context.log_stream_name responseBody['StackId'] = event['StackId'] responseBody['RequestId'] = event['RequestId'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] if responseData and responseData != {} and responseData != [] and isinstance( responseData, dict): responseBody['Data'] = responseData json_responseBody = json.dumps(responseBody) logger.info("Response body:\n" + json_responseBody) headers = { 'content-type': '', 'content-length': str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) logger.info("CloudFormation returned status code: " + response.reason) except Exception as e: logger.error("send(..) failed executing requests.put(..): " + str(e)) raise
def stop(event, context): logger.debug("Starting the stop_current() routine.") status = check_status() if "id" in status: url = f"https://www.toggl.com/api/v8/time_entries/{status['id']}/stop" token = os.environ["TOGGL_API_TOKEN"] auth_token = base64.b64encode(f"{token}:api_token".encode()).decode() r = requests.put(url, headers={"Authorization": "Basic " + auth_token}) status_code = r.status_code else: status_code = 200 return {"statusCode": status_code}
def handler(event, context): count = 0 for record in event["Records"]: # Get the primary key for use as the Elasticsearch ID id = record["dynamodb"]["Keys"]["id"]["S"] print "bookId " + id if record['eventName'] == 'REMOVE': r = requests.delete(url + id, auth=awsauth) else: document = record['dynamodb']['NewImage'] r = requests.put(url + id, auth=awsauth, json=document, headers=headers) count += 1 return str(count) + " records processed."
def lambda_handler(event, context): print(event) domain = '' try: if event['RequestType'] == "Create": domain_name = event['ResourceProperties']['DomainName'] user_pool_id = event['ResourceProperties']['UserPoolId'] client_id = event['ResourceProperties']['ClientId'] endpoint_url = event['ResourceProperties']['EndpointUrl'] domain = create_domain(domain_name,user_pool_id) update_client_settings(user_pool_id,client_id, endpoint_url) elif event['RequestType'] == "Update": old_domain_name = event['OldResourceProperties']['DomainName'] old_user_pool_id = event['OldResourceProperties']['UserPoolId'] domain_name = event['ResourceProperties']['DomainName'] user_pool_id = event['ResourceProperties']['UserPoolId'] client_id = event['ResourceProperties']['ClientId'] endpoint_url = event['ResourceProperties']['EndpointUrl'] delete_domain(old_domain_name,old_user_pool_id) domain = create_domain(domain_name, user_pool_id) update_client_settings(user_pool_id,client_id, endpoint_url) elif event['RequestType'] == "Delete": domain_name = event['ResourceProperties']['DomainName'] user_pool_id = event['ResourceProperties']['UserPoolId'] delete_domain(domain_name, user_pool_id) except Exception as e: print(e) finally: response_url = event['ResponseURL'] response_body = dict() response_body['Status'] = "SUCCESS" response_body['Reason'] = "" response_body['PhysicalResourceId'] = 'NONE' response_body['StackId'] = event['StackId'] response_body['RequestId'] = event['RequestId'] response_body['LogicalResourceId'] = event['LogicalResourceId'] json_response_body = json.dumps(response_body) print(json_response_body) headers = { 'content-type': '', 'content-length': str(len(json_response_body)) } response = requests.put(response_url, data=json_response_body, headers=headers)
def sendResponse(event, context, responseStatus, responseData): responseBody = {'Status': responseStatus, 'Reason': 'See the details in CloudWatch Log Stream: ' + context.log_stream_name, 'PhysicalResourceId': context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': responseData} print 'RESPONSE BODY:n' + json.dumps(responseBody) responseUrl = event['ResponseURL'] json_responseBody = json.dumps(responseBody) headers = { 'content-type' : '', 'content-length' : str(len(json_responseBody)) } response = requests.put(responseUrl,data=json_responseBody,headers=headers)
def send_response(event, context, responseStatus, responseData, resourceId, reason=None): logging.getLogger().debug("send_response - Start") responseUrl = event['ResponseURL'] logging.getLogger().debug(responseUrl) cw_logs_url = "https://console.aws.amazon.com/cloudwatch/home?region=%s#logEventViewer:group=%s;stream=%s" % ( context.invoked_function_arn.split(':')[3], context.log_group_name, context.log_stream_name) logging.getLogger().debug("Logs: cw_logs_url") responseBody = {} responseBody['Status'] = responseStatus responseBody['Reason'] = reason or ( 'See the details in CloudWatch Logs: ' + cw_logs_url) responseBody['PhysicalResourceId'] = resourceId responseBody['StackId'] = event['StackId'] responseBody['RequestId'] = event['RequestId'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] responseBody['NoEcho'] = False responseBody['Data'] = responseData json_responseBody = json.dumps(responseBody) logging.getLogger().debug("Response body:\n" + json_responseBody) headers = { 'content-type': '', 'content-length': str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) logging.getLogger().debug("Status code: " + response.reason) except Exception as error: logging.getLogger().error( "send(..) failed executing requests.put(..): " + str(error)) logging.getLogger().debug("send_response - End")
def send_response(event, context, response_status, response_data): response_body = json.dumps({ "Status": response_status, "Reason": "See the details in CloudWatch Log Stream: " + context.log_stream_name, "PhysicalResourceId": context.log_stream_name, "StackId": event['StackId'], "RequestId": event['RequestId'], "LogicalResourceId": event['LogicalResourceId'], "Data": response_data }) headers = { "Content-Type": "", "Content-Length": str(len(response_body)) } response = requests.put(event["ResponseURL"], headers = headers, data = response_body)
def send_response(cls, resource, url, response_content): if url == cls.DUMMY_RESPONSE_URL_SILENT: return elif url == cls.DUMMY_RESPONSE_URL_PRINT: six.print_(json.dumps(response_content, indent=2)) else: put_response = requests.put(url, data=json.dumps(response_content)) status_code = put_response.status_code response_text = put_response.text body_text = "" if status_code // 100 != 2: body_text = "\n" + response_text resource._base_logger.debug("Status code: {} {}{}".format(put_response.status_code, http_client.responses[put_response.status_code], body_text)) return put_response
def sendResponse(event, context, responseStatus, responseData): responseBody = {'Status': responseStatus, 'Reason': 'See the details in CloudWatch Log Stream: ' + context.log_stream_name, 'PhysicalResourceId': context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': responseData} print 'RESPONSE BODY:n' + json.dumps(responseBody) try: req = requests.put(event['ResponseURL'], data=json.dumps(responseBody)) if req.status_code != 200: print req.text raise Exception('Recieved non 200 response while sending response to CFN.') return except requests.exceptions.RequestException as e: print req.text print e raise
def sendResponse(event, context, responseStatus, responseData, reason=None, physical_resource_id=None): responseBody = {'Status': responseStatus, 'Reason': 'See the details in CloudWatch Log Stream: ' + context.log_stream_name, 'PhysicalResourceId': physical_resource_id or context.log_stream_name, 'StackId': event['StackId'], 'RequestId': event['RequestId'], 'LogicalResourceId': event['LogicalResourceId'], 'Data': responseData} print 'RESPONSE BODY:n' + json.dumps(responseBody) responseUrl = event['ResponseURL'] json_responseBody = json.dumps(responseBody) headers = { 'content-type' : '', 'content-length' : str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) print "Status code: " + response.reason except Exception as e: print "send(..) failed executing requests.put(..): " + str(e)
def send(event, context, responseStatus, responseData, physicalResourceId, logger, reason=None): responseUrl = event["ResponseURL"] logger.debug("CFN response URL: " + responseUrl) responseBody = {} responseBody["Status"] = responseStatus msg = "See details in CloudWatch Log Stream: " + context.log_stream_name if not reason: responseBody["Reason"] = msg else: responseBody["Reason"] = str(reason)[0:255] + "... " + msg if physicalResourceId: responseBody["PhysicalResourceId"] = physicalResourceId elif "PhysicalResourceId" in event: responseBody["PhysicalResourceId"] = event["PhysicalResourceId"] else: responseBody["PhysicalResourceId"] = context.log_stream_name responseBody["StackId"] = event["StackId"] responseBody["RequestId"] = event["RequestId"] responseBody["LogicalResourceId"] = event["LogicalResourceId"] if responseData and responseData != {} and responseData != [] and isinstance(responseData, dict): responseBody["Data"] = responseData json_responseBody = json.dumps(responseBody) logger.debug("Response body:\n" + json_responseBody) headers = {"content-type": "", "content-length": str(len(json_responseBody))} try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) logger.info("CloudFormation returned status code: " + response.reason) except Exception as e: logger.error("send(..) failed executing requests.put(..): " + str(e)) raise
def send(event, context, responseStatus, responseData, physicalResourceId, logger, reason=None): responseUrl = event['ResponseURL'] logger.debug("CFN response URL: " + responseUrl) responseBody = {} responseBody['Status'] = responseStatus msg = 'See details in CloudWatch Log Stream: ' + context.log_stream_name if not reason: responseBody['Reason'] = msg else: responseBody['Reason'] = str(reason)[0:255] + '... ' + msg responseBody['PhysicalResourceId'] = physicalResourceId or context.log_stream_name responseBody['StackId'] = event['StackId'] responseBody['RequestId'] = event['RequestId'] responseBody['LogicalResourceId'] = event['LogicalResourceId'] if responseData and responseData != {} and responseData != [] and isinstance(responseData, dict): responseBody['Data'] = responseData json_responseBody = json.dumps(responseBody) logger.debug("Response body:\n" + json_responseBody) headers = { 'content-type': '', 'content-length': str(len(json_responseBody)) } try: response = requests.put(responseUrl, data=json_responseBody, headers=headers) logger.info("CloudFormation returned status code: " + response.reason) except Exception as e: logger.error("send(..) failed executing requests.put(..): " + str(e)) raise
def send(event, context, response_status, response_data, physical_resource_id, logger, reason=None): response_url = event['ResponseURL'] logger.debug("CFN response URL: {}".format(response_url)) response_body = dict() response_body['Status'] = response_status msg = 'See CloudWatch Log Stream: {}'.format(context.log_stream_name) if not reason: response_body['Reason'] = msg else: response_body['Reason'] = str(reason)[0:255] + ' ({})'.format(msg) response_body['PhysicalResourceId'] = physical_resource_id or 'NONE' response_body['StackId'] = event['StackId'] response_body['RequestId'] = event['RequestId'] response_body['LogicalResourceId'] = event['LogicalResourceId'] if response_data and response_data != {} and response_data != [] and isinstance(response_data, dict): response_body['Data'] = response_data json_response_body = json.dumps(response_body) logger.debug("Response body:\n{}".format(json_response_body)) headers = { 'content-type': '', 'content-length': str(len(json_response_body)) } try: response = requests.put(response_url, data=json_response_body, headers=headers) logger.info("CloudFormation returned status code: {}".format(response.reason)) except Exception as e: logger.error("send(..) failed executing requests.put(..): {}".format(e)) raise
def cfn_response(event, context, response_status, response_data={}, physical_resource_id=None): """Format and send a CloudFormation custom resource object. Creates a JSON payload with a CloudFormation custom resource object[1], then HTTP PUTs this payload to an AWS signed URL. Replicates the functionality of the NodeJS cfn-response module in python.[2] Args: event: A dictionary containing CloudFormation custom resource provider request fields.[3] context: An AWS LambdaContext object containing lambda runtime information.[4] response_status: A status of SUCCESS or FAILED to send back to CloudFormation.[2] Use the Status.SUCCESS and Status.FAILED constants. response_data: A dictionary of key value pairs to pass back to CloudFormation which can be accessed with the Fn::GetAtt function on the CloudFormation custom resource.[5] physical_resource_id: An optional unique identifier of the custom resource that invoked the function. By default, the name of the CloudWatch Logs log stream is used. Returns: None Raises: No exceptions raised [1]: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-code.html#cfn-lambda-function-code-cfnresponsemodule [2]: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/crpg-ref-responses.html [3]: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/crpg-ref-requests.html#crpg-ref-request-fields [4]: http://docs.aws.amazon.com/lambda/latest/dg/python-context-object.html [5]: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/crpg-ref-responses.html#crpg-ref-responses-data """ if physical_resource_id is None: physical_resource_id = context.log_stream_name response_data = validate_response_data(response_data) reason = ("See the details in CloudWatch Log Stream: %s" % context.log_stream_name) if (response_status == Status.FAILED) and 'result' in response_data: reason = "%s %s" % (response_data['result'], reason) body = { "Status": response_status, "Reason": reason, "PhysicalResourceId": physical_resource_id, "StackId": event['StackId'], "RequestId": event['RequestId'], "LogicalResourceId": event['LogicalResourceId'], "Data": response_data } response_body = json.dumps(body) logger.debug("Response body: %s", response_body) try: response = requests.put(event['ResponseURL'], data=response_body) logger.debug("Status code: %s" % response.status_code) # logger.debug("Status message: %s" % response.status_message) # how do we get the status message? except Exception as e: logger.error("send(..) failed executing https.request(..): %s" % e.message)