123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
#!/bin/shset -euo pipefail
SCRIPT_DIR=$(cd $(dirname $0); pwd)HANDLER_NAME=$(echo "$_HANDLER" | cut -d. -f2)HANDLER_FILE=$(echo "$_HANDLER" | cut -d. -f1)
# support deno in the /bin directory of the function (not only the layer)PATH=$SCRIPT_DIR/bin:$PATH
API_ROOT=http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/
# If this ENV variable is set then copy that directory as DENO_DIR (default = .deno_dir).# Note: For permissions reasons we need the actual DENO_DIR to be somewhere in /tmp.DENO_DIR=${DENO_DIR-.deno_dir}if [[ -z "$DENO_DIR" ]]; then  DENO_DIR=.deno_dirfi
# Potentially this could be overwritten HOWEVER several permissions are required for bootstrap.# Note: Do can plugins work?? (If so, it should be documented.)DENO_FLAGS="-A --no-check"DENO_CACHE_FLAGS=""
# For unstable flags we must pass --unstableDENO_UNSTABLE=${DENO_UNSTABLE-}if [[ ! -z "$DENO_UNSTABLE${DENO_IMPORTMAP-}" ]]; then  DENO_FLAGS="$DENO_FLAGS --unstable"  DENO_CACHE_FLAGS="$DENO_CACHE_FLAGS --unstable"fi
# Once there is a convention for lock filename we could look for its existence.# For now we require it to be passed as an env explicitly.DENO_LOCK=${DENO_LOCK-}if [[ ! -z "$DENO_LOCK" ]]; then  DENO_FLAGS="$DENO_FLAGS --lock=$DENO_LOCK"  DENO_CACHE_FLAGS="$DENO_CACHE_FLAGS --lock=$DENO_LOCK"fi
DENO_CONFIG=${DENO_CONFIG-}if [[ ! -z "$DENO_CONFIG" ]]; then  DENO_FLAGS="$DENO_FLAGS --config=$DENO_CONFIG"  DENO_CACHE_FLAGS="$DENO_CACHE_FLAGS --config=$DENO_CONFIG"fi
DENO_IMPORTMAP=${DENO_IMPORTMAP-}if [[ ! -z "$DENO_IMPORTMAP" ]]; then  DENO_FLAGS="$DENO_FLAGS --importmap=$DENO_IMPORTMAP"  DENO_CACHE_FLAGS="$DENO_CACHE_FLAGS --importmap=$DENO_IMPORTMAP"fi
DENO_LOCATION=${DENO_LOCATION-}if [[ ! -z "$DENO_LOCATION" ]]; then  DENO_FLAGS="$DENO_FLAGS --location=$DENO_LOCATION"  DENO_CACHE_FLAGS="$DENO_CACHE_FLAGS --location=$DENO_LOCATION"fi
DENO_PREFIX=${DENO_PREFIX-"\${level}\tRequestId: \${requestId}\r"}
# whether to use ts, js, bundle.js, etc.HANDLER_EXT=${HANDLER_EXT-'ts'}HANDLER_FILE=${HANDLER_FILE}.${HANDLER_EXT}
# If we fail prior to the handler loop we post an init error.function error {  echo "error:" $1  ERROR="{\"errorMessage\" : \"$1\", \"errorType\" : \"InitException\"}"  curl -s -X POST "${API_ROOT}init/error" \       -d "$ERROR" \       --header "Lambda-Runtime-Function-Error-Type: Unhandled" \       --output /tmp/init.out  # expect it to be {"status":"OK"}  grep -q OK /tmp/init.out \   || echo "Unexpected bootstrap error when calling AWS_LAMBDA_RUNTIME_API /init/error:" $(cat /tmp/init.out)  exit 1}
# If the script fails we try and determine why.function investigate {  [ -f $SCRIPT_DIR/bin/deno ] \   || error "missing deno executable"  type -P deno &> /dev/null \   || error "deno executable not found in PATH"  DENO_DIR=/tmp/deno_dir NO_COLOR=true deno eval 'Deno.version.deno' \   || error "bad deno executable"  [ -f $LAMBDA_TASK_ROOT/$HANDLER_FILE ] \   || error "missing expected handler file '$HANDLER_FILE'"  if [[ ! -z "$DENO_LOCK" ]]; then    [ -f $DENO_LOCK ] \     || error "missing lock file '$DENO_LOCK'"    # This second check might be unecessary (in that it would be caught by the 'unable to compile')    DENO_DIR=/tmp/deno_dir NO_COLOR=true deno cache $DENO_CACHE_FLAGS $LAMBDA_TASK_ROOT/$HANDLER_FILE &> /tmp/lock.out \     || error "lock file error: $(cat /tmp/lock.out)"  fi  DENO_DIR=/tmp/deno_dir NO_COLOR=true deno cache $DENO_CACHE_FLAGS $LAMBDA_TASK_ROOT/$HANDLER_FILE &> /dev/null \   || error "unable to compile $HANDLER_FILE"  # e.g. the HANDLER_FILE threw an error or did not import HANDLER_NAME  error "deno exited"}
# Note: This is a js file to avoid a runtime compilation step.# Hopefully $HANDLER_FILE's compilation is cached in DENO_DIR.echo "import { $HANDLER_NAME as handle } from '$LAMBDA_TASK_ROOT/$HANDLER_FILE';const INVOCATION = '${API_ROOT}invocation/';
function maybeJson(headers, headerName) {  const json = headers.get(headerName);  if (json) {    try {      return JSON.parse(json);    } catch (e) {      console.error(        'Unable to parse header', headerName, 'value as JSON:', json      );    }  }}
const prefix = Deno.env.get('DENO_PREFIX')let interpolate = prefix ? (params) => {  const names = Object.keys(params);  const vals = Object.values(params);  return new Function(...names, \`return \\\`\${prefix}\\\`;\`)(...vals);} : (x) => { return '' };
try {  interpolate({ requestId: 'a', level: 'TEST' });} catch (e) {  console.log('warn: DENO_PREFIX', e.message);  interpolate = x => { return ''; };}
const log = console.log;// In order to support multiline cloudwatch logs we replace \n with \r.// see https://github.com/hayd/deno-lambda/issues/40// we also prefix log events with DENO_PREFIX
let requestId;const logger = (level) => {  return (...args) => {    const prefix = interpolate({ requestId, level })    const text = Deno[Deno.internal].inspectArgs(args);    log((prefix + text).replace(/\n/g, '\r'));  }}console.log = logger('INFO');console.debug = logger('DEBUG');console.info = logger('INFO');console.warn = logger('WARN');console.error = logger('ERROR');
while (true) {  const next = await fetch(INVOCATION + 'next');  const headers = next.headers;  requestId = headers.get('lambda-runtime-aws-request-id');  Deno.env.set('_X_AMZN_TRACE_ID', headers.get('lambda-runtime-trace-id') || '');  const context = {    functionName: '$AWS_LAMBDA_FUNCTION_NAME',    functionVersion: '$AWS_LAMBDA_FUNCTION_VERSION',    invokedFunctionArn: headers.get('lambda-runtime-invoked-function-arn'),    memoryLimitInMB: '$AWS_LAMBDA_FUNCTION_MEMORY_SIZE',    awsRequestId: requestId,    logGroupName: '$AWS_LAMBDA_LOG_GROUP_NAME',    logStreamName: '$AWS_LAMBDA_LOG_STREAM_NAME',    identity: maybeJson(headers, 'lambda-runtime-cognito-identity'),    clientContext: maybeJson(headers, 'lambda-runtime-client-context'),    getRemainingTimeInMillis: function() {      return Number(headers.get('lambda-runtime-deadline-ms')) - Date.now();    },    // NOTE: we add these for type compatibility with Definitely Typed.    callbackWaitsForEmptyEventLoop: undefined,    done: undefined,    fail: undefined,    succeed: undefined  }  let res;  try {    const event = await next.json();    const body = await handle(event, context);    res = await fetch(INVOCATION + requestId + '/response', {      method: 'POST',      body: JSON.stringify(body)    });  } catch(e) {    console.error(e);    // If it's an Error we can pull these out cleanly...    // BUT it's javascript so it could be anything!    // If there's a better way, very happy to take suggestions.    let name, message;    try {      name = e.name || 'Error'    } catch (_) {      name = 'Error'    }    try {      message = e.message || e    } catch (_) {      message = e    }    if (typeof(name) !== 'string') {      name = JSON.stringify(name)    }    if (typeof(message) !== 'string') {      const s = JSON.stringify(message)      message = s === undefined ? '' + message : s    }    res = await fetch(INVOCATION + requestId + '/error', {      method: 'POST',      body: JSON.stringify({        errorMessage: message,        errorType: name      })    });  }  await res.blob();}" > /tmp/runtime.js
# We copy DENO_DIR into a writable directory (/tmp/deno_dir)# and expand DENO_DIR/LAMBDA_TASK_ROOT to match the new location ($LAMBDA_TASK_ROOT).
mkdir -p /tmp/deno_dir/gen/file$LAMBDA_TASK_ROOT# We cp first from the deno-lambda-layer.cp -R /opt/.deno_dir/gen/. /tmp/deno_dir/gen &> /dev/null \ && cp -R /opt/.deno_dir/deps/. /tmp/deno_dir/deps &> /dev/null \ || true# Then we overwrite with from the DENO_DIR in the function code.cp -R $LAMBDA_TASK_ROOT/$DENO_DIR/gen/. /tmp/deno_dir/gen &> /dev/null \ && cp -R $LAMBDA_TASK_ROOT/$DENO_DIR/deps/. /tmp/deno_dir/deps &> /dev/null \ && cp -R $LAMBDA_TASK_ROOT/$DENO_DIR/gen/. /tmp/deno_dir/gen &> /dev/null \ && cp -R $LAMBDA_TASK_ROOT/$DENO_DIR/LAMBDA_TASK_ROOT/. /tmp/deno_dir/gen/file$LAMBDA_TASK_ROOT &> /dev/null \ || expr match "$HANDLER_FILE" ".*bundle.js" &> /dev/null \ || echo "warn: unable to import '$DENO_DIR/' as DENO_DIR"# Note: We skip printing this warning if the filename endswith bundle.js.
# FIXME remove DENO_FLAGS=DENO_FLAGS environment variable setting (used in testing only).DENO_DIR=/tmp/deno_dir DENO_PREFIX=$DENO_PREFIX DENO_FLAGS=$DENO_FLAGS NO_COLOR=true deno run $DENO_FLAGS /tmp/runtime.js \ || investigate;# For debugging purposes of the bootstrap script itself it's useful to change the extension to /tmp/runtime.ts# and run this code instead to get more verbose and type errors during testing.# Note: on production you will see the verbose error message anyway in cloudwatch logs.# DENO_DIR=/tmp/deno_dir DENO_FLAGS=$DENO_FLAGS NO_COLOR=true deno run $DENO_FLAGS /tmp/runtime.ts &> /tmp/fail.out \#  || error "error: $(cat /tmp/fail.out)"