Authentication

req, _ := http.NewRequest("POST", base+"/ce/send/event", strings.NewReader(string(body)))
req.Header.Set("Content-Type", "application/cloudevents+json")
req.Header.Set("Authorization", "Bearer "+os.Getenv("JWT_TOKEN"))

resp, err := http.DefaultClient.Do(req)
if err != nil {
    log.Fatal("send event:", err)
}
defer resp.Body.Close()

headers, body = to_structured(event)
headers["Authorization"] = f"Bearer {os.environ['JWT_TOKEN']}"

resp = requests.post(
    f"{base}/ce/send/event",
    data=body,
    headers=dict(headers),
    timeout=10,
)

const message = HTTP.structured(event);
const resp = await fetch(`${base}/ce/send/event`, {
  method: 'POST',
  headers: {
    ...(message.headers as Record<string, string>),
    Authorization: `Bearer ${process.env.JWT_TOKEN}`,
  },
  body: message.body as string,
});

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(base + "/ce/send/event"))
        .POST(HttpRequest.BodyPublishers.ofByteArray(body))
        .header("Content-Type", "application/cloudevents+json")
        .header("Authorization", "Bearer " + System.getenv("JWT_TOKEN"))
        .build();

HttpResponse<String> response = httpClient.send(request,
        HttpResponse.BodyHandlers.ofString());

using var content = new ByteArrayContent(eventBytes.ToArray());
content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType.ToString());

using var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("JWT_TOKEN"));

var resp = await httpClient.PostAsync($"{base_}/ce/send/event", content);

headers, body = sdk.encode_event(event, structured_format: "json")
uri = URI("#{base}/ce/send/event")
Net::HTTP.start(uri.host, uri.port) do |http|
  req = Net::HTTP::Post.new(uri)
  req["Content-Type"] = headers["Content-Type"]
  req["Authorization"] = "Bearer #{ENV.fetch('JWT_TOKEN')}"
  req.body = body
  res = http.request(req)
end

let body = serde_json::to_string(&event)?;
let resp = client
    .post(format!("{}/ce/send/event", base))
    .header("Content-Type", "application/cloudevents+json")
    .header("Authorization", format!("Bearer {}", env::var("JWT_TOKEN")?))
    .body(body)
    .send()
    .await?;

req, _ := http.NewRequest("GET", sseURL, nil)
req.Header.Set("Accept", "text/event-stream")
req.Header.Set("Cache-Control", "no-cache")
req.Header.Set("Authorization", "Bearer "+os.Getenv("JWT_TOKEN"))

resp, err := http.DefaultClient.Do(req)

with requests.get(sse_url, stream=True, timeout=None,
                  headers={"Accept": "text/event-stream",
                           "Cache-Control": "no-cache",
                           "Authorization": f"Bearer {os.environ['JWT_TOKEN']}"}) as resp:
    for raw_line in resp.iter_lines(decode_unicode=True):
        ...

const es = new EventSource(sseUrl, {
  headers: { Authorization: `Bearer ${process.env.JWT_TOKEN}` },
});
es.addEventListener('cloudevent', (evt: MessageEvent) => {
  console.log(JSON.parse(evt.data));
});

HttpURLConnection conn = (HttpURLConnection) new URL(sseUrl).openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Accept", "text/event-stream");
conn.setRequestProperty("Cache-Control", "no-cache");
conn.setRequestProperty("Authorization", "Bearer " + System.getenv("JWT_TOKEN"));
conn.setDoInput(true);

using var request = new HttpRequestMessage(HttpMethod.Get, sseUrl);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream"));
request.Headers.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("JWT_TOKEN"));

using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

Net::HTTP.start(uri.host, uri.port) do |http|
  req = Net::HTTP::Get.new(uri)
  req["Accept"] = "text/event-stream"
  req["Cache-Control"] = "no-cache"
  req["Authorization"] = "Bearer #{ENV.fetch('JWT_TOKEN')}"
  http.request(req) do |resp|
    ...
  end
end

let stream = client
    .get(&sub_url)
    .header("Accept", "text/event-stream")
    .header("Cache-Control", "no-cache")
    .header("Authorization", format!("Bearer {}", env::var("JWT_TOKEN")?))
    .send()
    .await?
    .bytes_stream();