FaaS Execution

The FaaS Execution service collection provides operations for retrieving large request bodies from Function-as-a-Service gateway executions. Retrieve files or other large payloads that have spilled into object storage during function execution.

Language	Last Update
Python	v1.6.5
PowerShell
Go	v0.22.0
TypeScript	v0.6.0
Rust	v0.7.1
Ruby	v1.4.0

---

---

Table of Contents

Operation	Description
ReadRequestBody read_request_body	retrieve a large request body, such as a file, that has spilled into object storage

---

ReadRequestBody

retrieve a large request body, such as a file, that has spilled into object storage

Method GET

Route /faas-gateway/entities/execution-request-body/v2

Scope Apps: READ

PEP 8 read_request_body

Parameters

id query · string

Execution ID

fn query · string

function ref; form of $fn_id:$fn_version

filename query · string

filename to be retrieved

sha256 query · string

sha256 checksum for file to be retrieved

parameters query · dictionary

Full query string parameters payload in JSON format. Not required when using other keywords.

Code Examples

Python

PEP 8

from falconpy import FaaSExecution

falcon = FaaSExecution(client_id=CLIENT_ID,
                       client_secret=CLIENT_SECRET
                       )

with open("output_file", "wb") as save_file:
    response = falcon.read_request_body(id="string",
                                        fn="string",
                                        filename="string",
                                        sha256="string",
                                        stream=boolean)
    save_file.write(response)

Operation ID

from falconpy import FaaSExecution

falcon = FaaSExecution(client_id=CLIENT_ID,
                       client_secret=CLIENT_SECRET
                       )

with open("output_file", "wb") as save_file:
    response = falcon.ReadRequestBody(id="string",
                                      fn="string",
                                      filename="string",
                                      sha256="string",
                                      stream=boolean)
    save_file.write(response)

Uber

from falconpy import APIHarnessV2

falcon = APIHarnessV2(client_id=CLIENT_ID,
                      client_secret=CLIENT_SECRET
                      )

with open("output_file", "wb") as save_file:
    response = falcon.command("ReadRequestBody",
                              id="string",
                              fn="string",
                              filename="string",
                              sha256="string")
    save_file.write(response)

PowerShell

Examples coming soon.

Go

package main

import (
  "context"
  "fmt"
  "os"

  "github.com/crowdstrike/gofalcon/falcon"
  "github.com/crowdstrike/gofalcon/falcon/client/execution"
)

func main() {
  client, err := falcon.NewClient(&falcon.ApiConfig{
    ClientId:     os.Getenv("FALCON_CLIENT_ID"),
    ClientSecret: os.Getenv("FALCON_CLIENT_SECRET"),
    Context:      context.Background(),
  })
  if err != nil {
    panic(err)
  }

  response, err := client.Execution.ReadRequestBody(
    &execution.ReadRequestBodyParams{
      ID: "string",
      Fn: "string",
      Filename: "string",
      Sha256: "string",
      Context: context.Background(),
    },
  )
  if err != nil {
    panic(falcon.ErrorExplain(err))
  }

  fmt.Printf("%+v\n", response.Payload)
}

TypeScript

import { FalconClient } from "crowdstrike-falcon";

const client = new FalconClient({
  cloud: process.env.FALCON_CLOUD!,
  clientId: process.env.FALCON_CLIENT_ID!,
  clientSecret: process.env.FALCON_CLIENT_SECRET!,
});

const response = await client.execution.readRequestBody(
  "string",  // id
  "string",  // fn
  "string",  // filename
  "string"  // sha256
);

console.log(response);

Rust

use rusty_falcon::apis::execution_api::read_request_body;
use rusty_falcon::easy::client::FalconHandle;

#[tokio::main]
async fn main() {
    let falcon = FalconHandle::from_env().await.expect("Could not authenticate");

    let response = read_request_body(
        &falcon.cfg,  // configuration
        "string",  // id
        "string",  // filename
        "string",  // sha256
    ).await.expect("API call failed");

    println!("{:?}", response);
}

Ruby

require "crimson-falcon"

Falcon.configure do |config|
  config.client_id = ENV["FALCON_CLIENT_ID"]
  config.client_secret = ENV["FALCON_CLIENT_SECRET"]
  config.cloud = ENV["FALCON_CLOUD"]
end

api = Falcon::Execution.new

response = api.read_request_body('string', 'string', 'string', 'string')

puts response

Responses

400 Invalid arguments

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

403 Authorization failed

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

429 Too Many Requests

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}

500 Unexpected error during request body read

{
  "errors": [
    {
      "code": 0,
      "id": "string",
      "message": "string"
    }
  ],
  "meta": {
    "pagination": {
      "limit": 0,
      "offset": 0,
      "total": 0
    },
    "powered_by": "string",
    "query_time": 0.0,
    "trace_id": "string",
    "writes": {
      "resources_affected": 0
    }
  }
}