Category Archives: General

VIP notifications on Android with Outlook Mobile

Posted on by
Reply

Summary

This post covers how to create a VIP notification for emails on Android with Outlook Mobile.

Overview over VIP messages

VIP notifications is available with Gmail (and iOS Mail) that allow notification customization when emails arrive from very important people (VIP). This is convenient when preferring silence, except for VIPs. Unfortunately, it is not available in Outlook on Android at this time. In Android, turning on the Notification feature, ‘Do not disturb’, will cause all notifications to be silent, but it has exceptions for certain types such as calls and text messages. The text message exception will be used for this solution by identifying emails from VIPs and then sending a text message that allows the notification to break through ‘Do not disturb’.

Prerequisites

Description

To begin the solution it helps to start with a baseline on how emails are send to the mobile device to identify integration points.

VIP email send to Android Device via a Mail Server

Outlook Mobile receives all emails from a mail server and although there may be other systems in use before the VIP email arrives to the mail server, we only have two (2) direct integration points; (1) Mail Server and (2) Android Device w/ Outlook Mobile.

For VIP notifications to break through ‘Do not disturb’ the following text message process will need to happen.

VIP text message send to Android Device via a Wireless Carrier

Android receives all text messages from a wireless carrier and similar to emails there may be other systems in use before the VIP message arrives to our Wireless Carrier, but we only have (2) direct integration points; (1) Wireless Carrier and (2) Android Device w/ Messages.

With the email and text message flows as a baseline, we can define a conceptual integration between the two (2) processes and their subsystems. As the process starts with an email, we need a solution that can check a condition if the email is received from a VIP sender and if true, send a text message to our device. This solution can be conceptualized by bringing the baseline flows together with a workflow.

Conceptual diagram of Mail Server and Wireless Carrier integration.

The conceptual design introduces a couple of new subsystems in the process, (a) Mail Event Receiver and (b) Workflow. The purpose of the Mail Event Receiver is to watch for incoming emails and initiate the Workflow subsystem. The workflow will then be responsible for the conditional check to see if the email sender is on the VIP list and if true send the email and/or message to the device via the Wireless Carrier.

The workflow subsystem is the integration hub between the mail server and the wireless carrier. We can use no-code / low-code workflow tools for these type of subsystem integrations. A great tool for this purpose is IFTTT (IF This Then That) which comes with connectors to various subsystems. For the purposes of this post, we will cover a similar tool called Power Automate with integration to Exchange Online acting as the mail server. For the mail event receiver between Exchange Online and Power Automate, we will indirectly be using a Graph subsystem that both Exchange Online and Power Automate is integrated with to complete the mail server to workflow integration.

That covers the input to the workflow, so lets turn to the workflow output and its integration to the Wireless Carrier. Most carriers support the ability to send emails as text messages through the use of the wireless phone number as the recipient on the carrier’s mail server (aka realm). This means we can send text messages to ourselves via emails by using the notation <my.phone.number>@<wireless.carrier.realm>. This is supported by multiple carriers including the following US carriers:

Wireless CarrierEmail Recipient
Verizon5551234567@vtext.com
AT&T5551234567@txt.att.com
T-Mobile5551234567@tmomail.com
Wireless Carrier email to text message

Plugging in the identified solutions for each subsystem creates a completed logical design that we can implement.

Logical design diagram of the email to text message integration.
Logical design of the Email to Text Message integration

Note; variations can be made to this design such as substituting Exchange Online with a different mail server and Power Automate with IFTTT.

Next we’ll cover the steps for creating the workflow condition using Power Automate.

Steps

1. In a browser, navigate to Power Automate and login with an Office 365 account.

2. On the navigation menu, select “My Flows”, “New”, “Automated – from blank”

Power Automate screen for creating a new automated flow from blank template.

3. Enter a Flow name, such as “VIP Notify”

4. Type “Email” in the flow trigger search box and select the trigger “When a new email arrives (V3)”

Searching and selecting the trigger event for the workflow to be based on arrival of an email.

5. Select “Create” and a workflow canvas should appear with a trigger step.

6. Click the trigger step titled “When a new email arrives (V3)” and it should expand to see all configuration options.

7. In the ‘From’ field, enter the sender email of the VIP person. Multiple sender emails can be entered by adding a semi-colon (;) between each sender.

Entering sender emails of VIPs in the Power Automate trigger task to filter emails to only VIPs

8. Select “+ New step” at the bottom of the workflow canvas to enter a new step.

9. Search and select the action titled “Send an email (V2)”

10. Click the step titled “Send an email (V2)” and it should expand to see all configuration options.

11. In the ‘To’ field, enter your wireless carrier email address using the <phone.number>@<wireless.carrier.realm> notation to send an email as a text message to yourself.

12. In the ‘Subject’ field, enter a description that identifies the text message, such as “VIP Email Received”

13. In the ‘Body’ field, enter a description for the text message, such as “Check email for details”.

Configuring your wireless carrier phone number to send an email that should be converted to a text message.

14. Select the ‘Save’ button on the workflow canvas to save the workflow.

15. The VIP Notify workflow is now configured and should be active if the Status field displays ‘On’

VIP Notify power automate flow summary with status set to 'on'.

16. If the VIP sender list needs to be updated, return to this ‘VIP Notify’ flow and select ‘Edit’ to return to the canvas and repeat step 7 for adding or removing VIP sender emails in the ‘From’ field.

Next Steps

  • In the configuration of “Send an Email (V2)” step 12 & step 13, additional information can be added to the Subject and/or Body fields for the text message. For example, the Subject could include a dynamic field that contains the ‘Sender’ or ‘Subject’ of the email that triggered the workflow. This would provide specific details in the text message of which VIP and subject was received without having to check emails.

Blazor App: An error has occurred. This application may no longer respond until reloaded. Reload

Posted on by
Reply

Summary

Running a Blazor Server application and refreshing the page sometimes creates the following error for the user:

An error has occurred. This application may no longer respond until reloaded. Reload
Blazor Server application in web browser display error message.
Example error message displayed to the user

Turning on browser debugging may show connection errors similar to the following:

blazor.server.js:1 WebSocket connection to 'ws://helloblazor.test/_blazor?id=gsHIh62GVm39WvDVxjpJMg' failed: Error during WebSocket handshake: Unexpected response code: 404
---
Error: Failed to start the transport 'WebSockets': Error: There was an error with the transport.
---
GET http://helloblazor.test/_blazor?id=oobUaSlKLPyrC5RPZVg3uw&_=1597287612026 404 (Not Found)
---
Error: Failed to start the transport 'LongPolling': Error: Not Found
---
Error: Failed to start the connection: Error: Unable to connect to the server with any of the available transports. WebSockets failed: Error: There was an error with the transport. ServerSentEvents failed: Error: 'ServerSentEvents' does not support Binary. LongPolling failed: Error: Not Found
---
Error: Error: Unable to connect to the server with any of the available transports. WebSockets failed: Error: There was an error with the transport. ServerSentEvents failed: Error: 'ServerSentEvents' does not support Binary. LongPolling failed: Error: Not Found
---
Uncaught (in promise) Error: Cannot send data if the connection is not in the 'Connected' State.
    at e.send (blazor.server.js:1)
    at e.sendMessage (blazor.server.js:1)
    at e.sendWithProtocol (blazor.server.js:1)
    at blazor.server.js:1
    at new Promise (<anonymous>)
    at e.invoke (blazor.server.js:1)
    at e.<anonymous> (blazor.server.js:15)
    at blazor.server.js:15
    at Object.next (blazor.server.js:15)
    at blazor.server.js:15

These errors show that two (2) types of connection transports were attempted, (1) WebSocket and (2) LongPolling (ServerSentEvents), and both failed to connect.

This connection error can occur when the host is running in a load-balanced server environment. In that type of environment, change the load balancer algorithm for the user to have server affinity (also referred to as sticky sessions). Enabling server affinity ensures the user connection is re-established to the same server on refreshes.

Description

Load balancing two (2) or more servers helps ensure application availability in case one of the servers experience an outage. A server outage could be caused by component failure (hardware/software) or by being overloaded relative to its physical capacity (CPU, Memory, Disk, Network). Adding a second server in a load balanced configuration allow users to be connected to any of the servers that are available to accept the request.

Load Balancer illustration for distributing load between two servers and to one server if the other becomes unavailable

For many web server type applications, the content the server provides to the user does not require the user to stay connected to the server for long durations. They work by a request-response pattern where the user’s browser requests content, such as ‘homepage.htm’, and the server responds by sending the content back. Once the request-response round-trip has completed the user has a local copy from the server and disconnects. Next, if the user refreshes the browser for the same homepage.htm, a 2nd request-response round trip is performed. As the user was disconnected from the server after the 1st request-response completed, a load balancer may forward the 2nd request to a different server to respond.

Illustration of 1st and 2nd request to a page being load balanced to 2 different web servers

When a load balancer operates in this mode where a request can receive a response from any server, it is referred to as having ‘no affinity’. When no affinity is used, the load balancer can have different ways (aka algorithms) for how it chooses to distribute the requests between the available servers. A common algorithm is round-robin where the load balancer gives each server a turn when a request is received. When all available servers have taken a turn, it starts over again from the first server in the round-robin list.

Image of round robin load balancing
Load Balancer with No Affinity and Round-Robin algorithm

As a load balancer can support ‘no affinity’, it can also support ‘affinity’. With affinity enabled the load balancer will stick all requests from a specific user to the same server. This is also referred to as ‘sticky sessions’. The session part stems from the stickiness often being temporal in nature either due to an expiration by the load balancer or the server becoming unavailable. If the server becomes unavailable, the load balancer will establish affinity to a new server for the user.

Image of load balancer with affinity
Load Balancer configured with Affinity

With the background of load balancing and affinity rules behind us, lets come back to the beginning of this article where the user is experiencing an error in the Blazor Server application. What we reviewed on the web server request-response pattern above is referred to as a one-way communication. The user calls the web server and responds, but the web server does not call the user. This one-way communication is foundational to the HTTP protocol used on the Internet.

A Blazor Server application works over a WebSocket protocol. This protocol allows two-way communication where both the user and web server can initiate requests to each other. For this two-way communication to work, the user is the initiating party that starts a request to the server over the HTTP protocol and then negotiates a protocol transition to WebSocket if supported. Once the WebSocket connection is established, both the user and the web server can initiate a call to each other, thus enabling two-way communication.

For the web server to call the user, it needs to know which of its connections is connected to what user to ensure it is sending the request to the right recipient. This logic is provided by the Blazor Server framework and is transparent to the application code but conceptually looks something similar to the following:

Image depicting User connections on Web Server for WebSocket protocol

As we experienced in the early days of cellular phones (thankfully less these days), dropped calls can happen. With cellular phones we call the party back and continue the conversation where we left off because with both have ‘memory’ of us talking to each other. Like cellular phone communication, a WebSocket connection may experience a ‘drop’ and will need to be re-established. In order to keep the communication going from the point where it dropped, both the user and web server needs ‘memory’ of each other like people with cellular phones. This memory is held on both the user and web server side so when communication is re-established both parties remember each other and continue from where they dropped. All the user and web server memory and communication reconnects are done for us by the Blazor Server framework.

This memory and reconnect works fine when the load balancer only sends us to one web server as above. But what happens to our memory on a reconnect if we are in a multi-web server environment that is load balanced with no affinity?

Image of reconnect to new web server thru load balancer with no affinity
Blazer Server application reconnect thru load balancer with no affinity

As depicted above, if the user was having a two-way communication with Server 1 that drops, then the ‘memory’ of the communication is between the user and Server 1. When the connection reconnects to Server 2, Server 2 will have no memory of the prior communication. It’s like calling your friend back on the cellular phone and continue the conversation only to realize you called the wrong number. The Blazor Server framework accounted for this situation so instead of having Server 2 play along in a conversation it ha no memory of, it responds with a ‘wrong number’ (404 Not Found) to inform the user that it will not establish the connection. This ultimately leads to a connection error on the user side which can be seen in the browser debugger with the following connection errors:

blazor.server.js:1 WebSocket connection to 'ws://helloblazor.test/_blazor?id=gsHIh62GVm39WvDVxjpJMg' failed: Error during WebSocket handshake: Unexpected response code: 404
---
Error: Failed to start the transport 'WebSockets': Error: There was an error with the transport.
---
GET http://helloblazor.test/_blazor?id=oobUaSlKLPyrC5RPZVg3uw&_=1597287612026 404 (Not Found)

That is very polite gesture instead of running a prank and attempt to play along in a conversation it knows nothing about 🙂

The Blazor Server framework comes with an additional backup transports if WebSockets fail, including ServerSentEvents (SSE) and long-polling. However, as the reconnect is happening to the wrong server, all three (3) connections fail as seen in the subsequent errors:

Error: Failed to start the transport 'LongPolling': Error: Not Found
---
Error: Failed to start the connection: Error: Unable to connect to the server with any of the available transports. WebSockets failed: Error: There was an error with the transport. ServerSentEvents failed: Error: 'ServerSentEvents' does not support Binary. LongPolling failed: Error: Not Found
---
Error: Error: Unable to connect to the server with any of the available transports. WebSockets failed: Error: There was an error with the transport. ServerSentEvents failed: Error: 'ServerSentEvents' does not support Binary. LongPolling failed: Error: Not Found

As indicated by the errors, ServerSentEvents never actually tried to connect because the transport errored out due to the binary message format not being supported over that transport. Both WebSocket and long-polling were attempted to reconnect.

This is analogous to first calling the friend back with the wrong number on the cellular phone (WebSocket) and then retrying the wrong number on a landline (long-polling). Both phones are connecting to the wrong number. The end result is a connection failure as both attempts failed:

Uncaught (in promise) Error: Cannot send data if the connection is not in the 'Connected' State.
    at e.send (blazor.server.js:1)
    at e.sendMessage (blazor.server.js:1)
    at e.sendWithProtocol (blazor.server.js:1)
    at blazor.server.js:1
    at new Promise (<anonymous>)
    at e.invoke (blazor.server.js:1)
    at e.<anonymous> (blazor.server.js:15)
    at blazor.server.js:15
    at Object.next (blazor.server.js:15)
    at blazor.server.js:15

With the understanding of load balancing affinity behavior we can then change the load balancer from ‘no affinity’ to ‘affinity’ to ensure that the load balancer always sends the user back to the same server upon reconnects.

Image of load balancer configured with affinity allowing Blazer Server reconnects
Load Balancer configured with affinity allowing Blazer Server reconnects

With the load balancer affinity enabled we should now be able to reconnect successful and verify the connection handshake succeeded in the browser debugger:

Information: WebSocket connected to ws://helloblazor.test/_blazor?id=NfBNcfX6EMrOjIxWpDUwsg.

This is not the only cause for an error has occurred, but it may be one to explore as well as reviewing the browser debugger information for additional information to help troubleshoot. As multiple replicas are common for server availability and easy to do with Docker containerization it can be an early cause to write off the troubleshooting list.

See Docker Blazor App on Linux ARM for additional information on containerizing Blazor Server applications.

Azure DevOps: ./config.sh: line 85: ./bin/Agent.Listener: cannot execute binary file: Exec format error

Posted on by
5

Summary

Registering a Deployment Group agent for Azure DevOps generates the following error using the Linux registration script on a Linux ARM 32-bit operating system (such as Raspberry Pi):

./config.sh: line 85: ./bin/Agent.Listener: cannot execute binary file: Exec format error

Change the link to the agent package in the default registration script from Linux-x64 to ARM. 

from 'vsts-agent-linux-x64-2.173.0.tar.gz' to 'vsts-agent-linux-arm-2.173.0.tar.gz'

The resulting registration script will look similar to the following:

mkdir azagent;cd azagent;curl -fkSL -o vstsagent.tar.gz https://vstsagentpackage.azureedge.net/agent/2.173.0/vsts-agent-linux-arm-2.173.0.tar.gz;tar -zxvf vstsagent.tar.gz; if [ -x "$(command -v systemctl)" ]; then ./config.sh --deploymentpool --deploymentpoolname "SandboxDeploy" --acceptteeeula --agent $HOSTNAME --url https://dev.azure.com/torben/ --work _work --runasservice; sudo ./svc.sh install; sudo ./svc.sh start; else ./config.sh --deploymentpool --deploymentpoolname "SandboxDeploy" --acceptteeeula --agent $HOSTNAME --url https://dev.azure.com/torben/ --work _work; ./run.sh; fi

Note: version numbers (2.173.0) are updated over time so the above referenced versions may have changed since this writing. The deployment pool name and Azure DevOps account will also be unique to the setup.

Re-run the registration script and the exec format error should be resolved with a processor / agent match.

Description

After executing the deployment group registration on a Linux ARM processor architecture, the agent may fail to start with the following error:

The ‘Exec format error’ indicates that the application was not compiled for the target processor architecture, ARM 32-bit. In reviewing the registration script, it becomes clearer that the script is pulling an agent for a Linux x64 target architecture:

Unfortunately, there is not a mechanism to select the processor type on the deployment pool registration screen as it only has the kernel (Windows or Linux) as an option, not processor architecture ARM or x64/x86. However, the deployment group targets are based on the same agent application used for Agent Pools so we can get the Url for the ARM version by going to Agent Pools, add an Agent, and select Linux : ARM.

vsts-agent-linux-arm-2.173.0.tar.gz
Azure DevOps image for Add Agent and selecting kernal and processor architecture for the agent binary

Next we change the original Deployment Group registration script by replacing

vsts-agent-linux-x64-2.173.0.tar.gz

with the arm version and rerun the updated deployment group registration script. 

mkdir azagent;cd azagent;curl -fkSL -o vstsagent.tar.gz https://vstsagentpackage.azureedge.net/agent/2.173.0/vsts-agent-linux-arm-2.173.0.tar.gz;tar -zxvf vstsagent.tar.gz; if [ -x "$(command -v systemctl)" ]; then ./config.sh --deploymentpool --deploymentpoolname "SandboxDeploy" --acceptteeeula --agent $HOSTNAME --url https://dev.azure.com/torben/ --work _work --runasservice; sudo ./svc.sh install; sudo ./svc.sh start; else ./config.sh --deploymentpool --deploymentpoolname "SandboxDeploy" --acceptteeeula --agent $HOSTNAME --url https://dev.azure.com/torben/ --work _work; ./run.sh; fi

As the processor architecture now matches ARM 32-bit, the registration should succeed with the agent running as a service.

Image of Linux console showing the deployment group agent as active and running as a service

The agent will now be available for handling Azure DevOps Pipeline Releases and perform deployments to the target resource(s).

Next Steps

  • Presumably this is a temporary solution until the Azure DevOps user interface for Deployment Groups gets updated to match the Agent Pool kernel and processor selection or equivalent.
  • For multi-processor agent pools, refer to ‘Targeting multi-processor architectures with Azure DevOps‘ for additional details.