exit_if_not_on_ec2_instance

# TAG
EC2_INSTANCE_TYPE=$(curl -s "http://169.254.169.254/latest/meta-data/instance-type")
echo "##teamcity[addBuildTag 'ec2-instance-type=$EC2_INSTANCE_TYPE']"

AWS_REGION=$(curl -s "http://169.254.169.254/latest/meta-data/placement/region")

if [[ "$AWS_REGION" == us-* ]]; then
  echo "For $AWS_REGION switching to user teamcityus access token"

object WebSocketProtocol {
  /** Magic value which must be appended to the key in a response header. */
  internal const val ACCEPT_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

  /*
  Each frame starts with two bytes of data.

   0 1 2 3 4 5 6 7    0 1 2 3 4 5 6 7
  +-+-+-+-+-------+  +-+-------------+
  |F|R|R|R| OP    |  |M| LENGTH      |
  |I|S|S|S| CODE  |  |A|             |
  |N|V|V|V|       |  |S|             |

lifecycle transition rules and becomes eligible for tiering. MinIO scanner (which runs at one minute intervals, each time scanning one sixteenth of the namespace), picks up the object for tiering. The data is moved to the remote tier in entirety, leaving only the object metadata on MinIO.

The data on the backend is stored under the `bucket/prefix` specified in the tier configuration with a custom name derived from a randomly generated uuid - e.g. `0b/c4/0bc4fab7-2daf-4d2f-8e39-5c6c6fb7e2d3`....

                                <c:if test="${editable}">
                                    <button type="button" class="btn btn-danger" name="delete"
                                            data-toggle="modal" data-target="#confirmToDelete"
                                            value="<la:message key="labels.joblog_button_delete" />">
                                        <i class="fa fa-trash" aria-hidden="true"></i>

We are not restricted to having only one dependency that can return that type of data.

///

## Other models { #other-models }

You can now get the current user directly in the *path operation functions* and deal with the security mechanisms at the **Dependency Injection** level, using `Depends`.

And you can use any model or data for the security requirements (in this case, a Pydantic model `User`).

}

// WriteJSON - encodes to JSON data.
func (r *Record) WriteJSON(writer io.Writer) error {
	var kvs jstream.KVS = make([]jstream.KV, 0, len(r.columnNames))
	for i, cn := range r.columnNames {
		if i < len(r.csvRecord) {
			kvs = append(kvs, jstream.KV{Key: cn, Value: r.csvRecord[i]})
		}
	}
	return json.NewEncoder(writer).Encode(kvs)
}

// Raw - returns the underlying data with format info.

    assert response.json() == {"msg": "Hello World"}


def test_websocket():
    client = TestClient(app)
    with client.websocket_connect("/ws") as websocket:
        data = websocket.receive_json()

    /**
     * Authenticates using the provided context
     *
     * @param context the CIFS context
     * @param challenge the server challenge (may be null for some auth types)
     * @return authentication response data
     * @throws CIFSException if authentication fails
     */
    byte[] authenticate(CIFSContext context, byte[] challenge) throws CIFSException;

    /**
     * Gets the session key after successful authentication

        int start = bufferIndex;

        if (len < 52) {
            throw new SMBProtocolDecodingException("Lease V2 context data too short: " + len);
        }

        // Read lease V2 data (52 bytes)
        byte[] keyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, keyBytes, 0, 16);
        this.leaseKey = new Smb2LeaseKey(keyBytes);

     */
    long getMid();

    /**
     * Verifies the signature of this response.
     *
     * @param buffer the buffer containing the signature data
     * @param i the starting index in the buffer
     * @param size the size of the signature data
     * @return whether signature verification is successful
     */
    boolean verifySignature(byte[] buffer, int i, int size);

    /**