Create App Engine task handlers

publicclassStartup
{
publicStartup(IConfigurationconfiguration)
{
Configuration=configuration;
}
publicIConfigurationConfiguration{get;}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
publicvoidConfigureServices(IServiceCollectionservices)
{
services.AddLogging(builder=>builder.AddDebug());
services.AddRouting();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
publicvoidConfigure(IApplicationBuilderapp,IHostingEnvironmentenv,ILoggerFactoryloggerFactory)
{
varlogger=loggerFactory.CreateLogger("testStackdriverLogging");
if(env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// Configure error reporting service.
app.UseExceptionHandler("/Home/Error");
}
varrouteBuilder=newRouteBuilder(app);
routeBuilder.MapPost("log_payload",context=>
{
// Log the request payload
varreader=newStreamReader(context.Request.Body);
vartask=reader.ReadToEnd();
logger.LogInformation($"Received task with payload: {task}");
returncontext.Response.WriteAsync($"Printed task payload: {task}");
});
routeBuilder.MapGet("hello",context=>
{
// Basic index to verify app is serving
returncontext.Response.WriteAsync("Hello, world!");
});
routeBuilder.MapGet("_ah/health",context=>
{
// Respond to GAE health-checks
returncontext.Response.WriteAsync("OK");
});
routeBuilder.MapGet("/",context=>
{
returncontext.Response.WriteAsync("Hello, world!");
});
varroutes=routeBuilder.Build();
app.UseRouter(routes);
}
}

// Sample task_handler is an App Engine app demonstrating Cloud Tasks handling.
packagemain
import(
"fmt"
"io"
"log"
"net/http"
"os"
)
funcmain(){
// Allow confirmation the task handling service is running.
http.HandleFunc("/",indexHandler)
// Handle all tasks.
http.HandleFunc("/task_handler",taskHandler)
port:=os.Getenv("PORT")
ifport==""{
port="8080"
log.Printf("Defaulting to port %s",port)
}
log.Printf("Listening on port %s",port)
iferr:=http.ListenAndServe(":"+port,nil);err!=nil{
log.Fatal(err)
}
}
// indexHandler responds to requests with our greeting.
funcindexHandler(whttp.ResponseWriter,r*http.Request){
ifr.URL.Path!="/"{
http.NotFound(w,r)
return
}
fmt.Fprint(w,"Hello, World!")
}
// taskHandler processes task requests.
functaskHandler(whttp.ResponseWriter,r*http.Request){
taskName:=r.Header.Get("X-Appengine-Taskname")
iftaskName==""{
// You may use the presence of the X-Appengine-Taskname header to validate
// the request comes from Cloud Tasks.
log.Println("Invalid Task: No X-Appengine-Taskname request header found")
http.Error(w,"Bad Request - Invalid Task",http.StatusBadRequest)
return
}
// Pull useful headers from Task request.
queueName:=r.Header.Get("X-Appengine-Queuename")
// Extract the request body for further task details.
body,err:=io.ReadAll(r.Body)
iferr!=nil{
log.Printf("ReadAll: %v",err)
http.Error(w,"Internal Error",http.StatusInternalServerError)
return
}
// Log & output details of the task.
output:=fmt.Sprintf("Completed task: task queue(%s), task name(%s), payload(%s)",
queueName,
taskName,
string(body),
)
log.Println(output)
// Set a non-2xx status code to indicate a failure in task processing that should be retried.
// For example, http.Error(w, "Internal Server Error: Task Processing", http.StatusInternalServerError)
fmt.Fprintln(w,output)
}

@WebServlet(
name="Tasks",
description="Create Cloud Task",
urlPatterns="/tasks/create"
)
publicclass TaskServletextendsHttpServlet{
privatestaticLoggerlog=Logger.getLogger(TaskServlet.class.getName());
@Override
publicvoiddoPost(HttpServletRequestreq,HttpServletResponseresp)throwsIOException{
log.info("Received task request: "+req.getServletPath());
Stringbody=req.getReader()
.lines()
.reduce("",(accumulator,actual)->accumulator+actual);
if(!body.isEmpty()){
log.info("Request payload: "+body);
Stringoutput=String.format("Received task with payload %s",body);
resp.getOutputStream().write(output.getBytes());
log.info("Sending response: "+output);
resp.setStatus(HttpServletResponse.SC_OK);
}else{
log.warning("Null payload received in request to "+req.getServletPath());
}
}
}

constexpress=require('express');
constapp=express();
app.enable('trust proxy');
// Set the Content-Type of the Cloud Task to ensure compatibility
// By default, the Content-Type header of the Task request is set to "application/octet-stream"
// see https://cloud.google.com/tasks/docs/reference/rest/v2beta3/projects.locations.queues.tasks#AppEngineHttpRequest
app.use(express.text());
app.get('/',(req,res)=>{
// Basic index to verify app is serving
res.send('Hello, World!').end();
});
app.post('/log_payload',(req,res)=>{
// Log the request payload
console.log(`Received task with payload: ${req.body}`);
res.send(`Printed task payload: ${req.body}`).end();
});
app.get('*',(req,res)=>{
res.send('OK').end();
});
constPORT=process.env.PORT||8080;
app.listen(PORT,()=>{
console.log(`App listening on port ${PORT}`);
console.log('Press Ctrl+C to quit.');
});

require __DIR__ . '/vendor/autoload.php';
use Google\Cloud\Logging\LoggingClient;
// Create the logging client.
$logging = new LoggingClient();
// Create a PSR-3-compatible logger.
$logger = $logging->psrLogger('app', ['batchEnabled' => true]);
// Front-controller to route requests.
switch (@parse_url($_SERVER['REQUEST_URI'])['path']) {
 case '/':
 print "Hello, World!\n";
 break;
 case '/task_handler':
 // Taskname and Queuename are two of several useful Cloud Tasks headers available on the request.
 $taskName = $_SERVER['HTTP_X_APPENGINE_TASKNAME'] ?? '';
 $queueName = $_SERVER['HTTP_X_APPENGINE_QUEUENAME'] ?? '';
 try {
 handle_task(
 $queueName,
 $taskName,
 file_get_contents('php://input')
 );
 } catch (Exception $e) {
 http_response_code(400);
 exit($e->getMessage());
 }
 break;
 default:
 http_response_code(404);
 exit('Not Found');
}
/**
 * Process a Cloud Tasks HTTP Request.
 *
 * @param string $queueName provides the name of the queue which dispatched the task.
 * @param string $taskName provides the identifier of the task.
 * @param string $body The task details from the HTTP request.
 */
function handle_task($queueName, $taskName, $body = '')
{
 global $logger;
 if (empty($taskName)) {
 // You may use the presence of the X-Appengine-Taskname header to validate
 // the request comes from Cloud Tasks.
 $logger->warning('Invalid Task: No X-Appengine-Taskname request header found');
 throw new Exception('Bad Request - Invalid Task');
 }
 $output = sprintf('Completed task: task queue(%s), task name(%s), payload(%s)', $queueName, $taskName, $body);
 $logger->info($output);
 // Set a non-2xx status code to indicate a failure in task processing that should be retried.
 // For example, http_response_code(500) to indicate a server error.
 print $output;
}

fromflaskimport Flask, render_template, request
app = Flask(__name__)
@app.route("/example_task_handler", methods=["POST"])
defexample_task_handler():
"""Log the request payload."""
 payload = request.get_data(as_text=True) or "(empty payload)"
 print(f"Received task with payload: {payload}")
 return render_template("index.html", payload=payload)

require"sinatra"
require"json"
get"/"do
# Basic index to verify app is serving
"Hello World!"
end
post"/log_payload"do
data=request.body.read
# Log the request payload
puts"Received task with payload: #{data}"
"Printed task payload: #{data}"
end