PowerShell

Firebase Receive Server-Sent Events (text/event-stream)

See more Firebase Examples

Demonstrates how to start receiving server-sent events and update your JSON database with each event. PowerShell

Add-Type -Path "C:\chilkat\ChilkatDotNet47-x64\ChilkatDotNet47.dll"

$success = $false

# Demonstrates how to begin receiving server-sent events, and to update
# your JSON database for each event.

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

# This example assumes a JWT authentication token, if required, has been previously obtained.
# See Get Firebase Access Token from JSON Service Account Private Key for sample code.

# Load the previously obtained Firebase access token into a string.
$fac = New-Object Chilkat.FileAccess
$accessToken = $fac.ReadEntireTextFile("qa_data/tokens/firebaseToken.txt","utf-8")
if ($fac.LastMethodSuccess -eq $false) {
    $($fac.LastErrorText)
    exit
}

$rest = New-Object Chilkat.Rest

# Make the initial connection (without sending a request yet).
# Once connected, any number of requests may be sent.  It is not necessary to explicitly
# call Connect before each request.  
$success = $rest.Connect("chilkat.firebaseio.com",443,$true,$true)
if ($success -eq $false) {
    $($rest.LastErrorText)
    exit
}

$authGoogle = New-Object Chilkat.AuthGoogle
$authGoogle.AccessToken = $accessToken
$rest.SetAuthGoogle($authGoogle)

$rest.AddHeader("Accept","text/event-stream")
$rest.AddHeader("Cache-Control","no-cache")

$responseBody = $rest.FullRequestNoBody("GET","/.json")

# A 307 redirect response is expected.
if ($rest.ResponseStatusCode -ne 307) {
    $("Unexpected response code: " + $rest.ResponseStatusCode)
    $($responseBody)
    $("Failed.")
    exit
}

# Get the redirect URL
$urlStr = $rest.LastRedirectUrl
$url = New-Object Chilkat.Url
$url.ParseUrl($urlStr)

$("redirect URL domain: " + $url.Host)
$("redirect URL path: " + $url.Path)
$("redirect URL query params: " + $url.Query)
$("redirect URL path with query params: " + $url.PathWithQueryParams)

# Our text/event-stream will be obtained from the redirect URL...
$rest2 = New-Object Chilkat.Rest

$success = $rest2.Connect($url.Host,443,$true,$true)
if ($success -ne $true) {
    $($rest2.LastErrorText)
    exit
}

$rest2.AddHeader("Accept","text/event-stream")
$rest2.AddHeader("Cache-Control","no-cache")

# Add the redirect query params to the request
$rest2.AddQueryParams($url.Query)

# In our case, we don't actually need the auth query param,
# so remove it.
$rest2.RemoveQueryParam("auth")

# Send the request.  (We are only sending the request here.
# We are not yet getting the response because the response
# will be a text/event-stream.)
$success = $rest2.SendReqNoBody("GET",$url.Path)
if ($success -ne $true) {
    $($rest2.LastErrorText)
    exit
}

# Read the response header.  
# We want to first get the response header to see if it's a successful
# response status code.  If not, then the response will not be a text/event-stream
# and we should read the response body normally.
$responseStatusCode = $rest2.ReadResponseHeader()
if ($responseStatusCode -lt 0) {
    $($rest2.LastErrorText)
    exit
}

# If successful, a 200 response code is expected.
# If the reponse code is not 200, then read the response body and fail..
if ($responseStatusCode -ne 200) {
    $("Response Code: " + $responseStatusCode)
    $("Response Status Text: " + $rest2.ResponseStatusText)
    $("Response Header: " + $rest2.ResponseHeader)
    $responseBody = $rest2.ReadRespBodyString()
    if ($rest2.LastMethodSuccess -eq $true) {
        $("Error Response Body: " + $responseBody)
    }

    $("Failed.")
    exit
}

# For this example, our JSON database will be empty at the beginning.
# The incoming events (put and patch) will be applied to this database.
$jsonDb = New-Object Chilkat.JsonObject

# Make sure to set the JSON path delimiter to "/".  The default is "." and this
# is not compatible with Firebase paths.
$jsonDb.DelimiterChar = "/"

# At this point, we've received the response header.  Now it's time to begin
# receiving the event stream.  We'll start a background thread to read the 
# stream.  (Our main application (foreground) thread can cancel it at any time.)  
# While receiving in the background thread, our foreground thread can read the stream
# as it desires..
$eventStream = New-Object Chilkat.Stream

# This sse object will be used as a helper to parse the server-sent event stream.
$sse = New-Object Chilkat.ServerSentEvent

$task = $rest2.ReadRespBodyStreamAsync($eventStream,$true)
$task.Run()

# For this example, we'll just read a few events, and then cancel the
# async task.
$count = 0
while (($count -lt 3) -and ($task.Finished -eq $false)) {

    # Get the next event, which is a series of text lines ending with
    # a blank line. 
    # Note: This method blocks the calling thread until a message arrives.
    # a program might instead periodically check the availability of
    # data via the stream's DataAvailable property, and then do the read.

    # An alternative to writing a while loop to read the event stream
    # would be to setup some sort of timer event in your program (using whatever timer functionality
    # is provided in a programming language/environment), to periodically check the eventStream's
    # DataAvailable property and consume the incoming event.
    $eventStr = $eventStream.ReadUntilMatch("`r`n`r`n")
    if ($eventStream.LastMethodSuccess -ne $true) {
        $($eventStream.LastErrorText)
        # Force the loop to exit by setting the count to a high number.
        $count = 99999
    }
    else {
        $("Event: [" + $eventStr + "]")

        # We have an event. Let's update our local copy of the JSON database.
        $success = $sse.LoadEvent($eventStr)
        if ($success -ne $true) {
            $("Failed to load sse event: " + $eventStr)
        }
        else {
            # Now we can easily access the event name and data, and apply it to our JSON database:
            $success = $jsonDb.FirebaseApplyEvent($sse.EventName,$sse.Data)
            if ($success -ne $true) {
                $("Failed to apply event: " + $sse.EventName + ": " + $sse.Data)
            }
            else {
                $("Successfully applied event: " + $sse.EventName + ": " + $sse.Data)
            }

        }

    }

    $count = $count + 1
}

# Make sure the background task is cancelled if still running.
$task.Cancel()

# Examine the JSON database after applying events..
$jsonDb.EmitCompact = $false
$("----")
$($jsonDb.Emit())