# Copyright 2019 Google LLC # # 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. import sys # [START functions_helloworld_http] # [START functions_http_content] from flask import escape # [END functions_helloworld_http] # [END functions_http_content] # [START functions_helloworld_get] def hello_get(request): """HTTP Cloud Function. Args: request (flask.Request): The request object. Returns: The response text, or any set of values that can be turned into a Response object using `make_response` . Note: For more information on how Flask integrates with Cloud Functions, see the `Writing HTTP functions` page. """ return 'Hello World!' # [END functions_helloworld_get] # [START functions_helloworld_http] def hello_http(request): """HTTP Cloud Function. Args: request (flask.Request): The request object. Returns: The response text, or any set of values that can be turned into a Response object using `make_response` . """ request_json = request.get_json(silent=True) request_args = request.args if request_json and 'name' in request_json: name = request_json['name'] elif request_args and 'name' in request_args: name = request_args['name'] else: name = 'World' return 'Hello {}!'.format(escape(name)) # [END functions_helloworld_http] # [START functions_helloworld_pubsub] def hello_pubsub(event, context): """Background Cloud Function to be triggered by Pub/Sub. Args: event (dict): The dictionary with data specific to this type of event. The `@type` field maps to `type.googleapis.com/google.pubsub.v1.PubsubMessage`. The `data` field maps to the PubsubMessage data in a base64-encoded string. The `attributes` field maps to the PubsubMessage attributes if any is present. context (google.cloud.functions.Context): Metadata of triggering event including `event_id` which maps to the PubsubMessage messageId, `timestamp` which maps to the PubsubMessage publishTime, `event_type` which maps to `google.pubsub.topic.publish`, and `resource` which is a dictionary that describes the service API endpoint pubsub.googleapis.com, the triggering topic's name, and the triggering event type `type.googleapis.com/google.pubsub.v1.PubsubMessage`. Returns: None. The output is written to Cloud Logging. """ import base64 print("""This Function was triggered by messageId {} published at {} to {} """.format(context.event_id, context.timestamp, context.resource["name"])) if 'data' in event: name = base64.b64decode(event['data']).decode('utf-8') else: name = 'World' print('Hello {}!'.format(name)) # [END functions_helloworld_pubsub] # [START functions_helloworld_storage] def hello_gcs(event, context): """Background Cloud Function to be triggered by Cloud Storage. This generic function logs relevant data when a file is changed. Args: event (dict): The dictionary with data specific to this type of event. The `data` field contains a description of the event in the Cloud Storage `object` format described here: https://cloud.google.com/storage/docs/json_api/v1/objects#resource context (google.cloud.functions.Context): Metadata of triggering event. Returns: None; the output is written to Stackdriver Logging """ print('Event ID: {}'.format(context.event_id)) print('Event type: {}'.format(context.event_type)) print('Bucket: {}'.format(event['bucket'])) print('File: {}'.format(event['name'])) print('Metageneration: {}'.format(event['metageneration'])) print('Created: {}'.format(event['timeCreated'])) print('Updated: {}'.format(event['updated'])) # [END functions_helloworld_storage] # [START functions_http_content] def hello_content(request): """ Responds to an HTTP request using data from the request body parsed according to the "content-type" header. Args: request (flask.Request): The request object. Returns: The response text, or any set of values that can be turned into a Response object using `make_response` . """ content_type = request.headers['content-type'] if content_type == 'application/json': request_json = request.get_json(silent=True) if request_json and 'name' in request_json: name = request_json['name'] else: raise ValueError("JSON is invalid, or missing a 'name' property") elif content_type == 'application/octet-stream': name = request.data elif content_type == 'text/plain': name = request.data elif content_type == 'application/x-www-form-urlencoded': name = request.form.get('name') else: raise ValueError("Unknown content type: {}".format(content_type)) return 'Hello {}!'.format(escape(name)) # [END functions_http_content] # [START functions_http_method] def hello_method(request): """ Responds to a GET request with "Hello world!". Forbids a PUT request. Args: request (flask.Request): The request object. Returns: The response text, or any set of values that can be turned into a Response object using `make_response` . """ from flask import abort if request.method == 'GET': return 'Hello World!' elif request.method == 'PUT': return abort(403) else: return abort(405) # [END functions_http_method] def hello_error_1(request): # [START functions_helloworld_error] # This WILL be reported to Stackdriver Error # Reporting, and WILL NOT show up in logs or # terminate the function. from google.cloud import error_reporting client = error_reporting.Client() try: raise RuntimeError('I failed you') except RuntimeError: client.report_exception() # This WILL be reported to Stackdriver Error Reporting, # and WILL terminate the function raise RuntimeError('I failed you') # [END functions_helloworld_error] def hello_error_2(request): # [START functions_helloworld_error] # These errors WILL NOT be reported to Stackdriver # Error Reporting, but will show up in logs. import logging print(RuntimeError('I failed you (print to stdout)')) logging.warn(RuntimeError('I failed you (logging.warn)')) logging.error(RuntimeError('I failed you (logging.error)')) sys.stderr.write('I failed you (sys.stderr.write)\n') # This is considered a successful execution and WILL NOT be reported to # Stackdriver Error Reporting, but the status code (500) WILL be logged. from flask import abort return abort(500) # [END functions_helloworld_error]