Ballerina: The ultimate toolset for seamless microservices development

configurable int port = 8080;

type Album readonly & record {|
    string id;
    string title;
    string artist;
    decimal price;
|};

service / on new http:Listener(port) {
    resource function get albums() returns Album[] {
        return albums.toArray();
    }

    resource function get albums/[string id]() returns Album|http:NotFound {
        Album? album = albums[id];
        if album is () {
            return http:NOT_FOUND;
        } else {
            return album;
        }
    }

    resource function post albums(@http:Payload Album album) returns Album {
        albums.add(album);
        return album;
    }
}

import ballerina/http;

type Person record {|
    string name;
    boolean employed;
|};

type Summary record {|
    int count;
    int average;
|};

int[] tasks = [1, 4, 5, 2, 7, 4];

service on new http:Listener(8080) {
    resource function post person\-tasks(Person[] members) returns Summary {
        return process(members, tasks);
    }
}

function process(Person[] members, int[] tasks) returns Summary {
    worker w1 {
        Person[] employedMembers = from Person p in members where p.employed select p;
        int count = employedMembers.length();
        count -> w2;
        count -> function;
    }

    worker w2 {
        int total = int:sum(...tasks);
        int employedCount = <- w1;
        int avg = employedCount == 0 ? 0 : total / employedCount;
        avg -> function;
    }

    int count = <- w1;
    int average = <- w2;
    return {count, average};
}

type Album readonly & record {
    string title;
    string artist;
};

public function main() returns error? {
    http:Client albumClient = check new ("localhost:9090",
        circuitBreaker = {
            // The failure calculation window measures how long the circuit breaker keeps the
            // statistics for the operations.
            rollingWindow: {
                // The period is in seconds for which the failure threshold is calculated.
                timeWindow: 10,
                // The granularity (in seconds) at which the time window slides.
                // The rolling window is divided into buckets and slides by these increments.
                bucketSize: 2,
                // The minimum number of requests in the rolling window that trips the circuit.
                requestVolumeThreshold: 0
            },
            // The threshold for request failures. When this threshold exceeds, the circuit trips.
            // This is the ratio between failures and total requests. The ratio is calculated using
            // the requests received within the given rolling window.
            failureThreshold: 0.2,
            // The period (in seconds) to wait before attempting to make another request to the upstream service.
            resetTime: 10,
            // HTTP response status codes that are considered as failures
            statusCodes: [400, 404, 500]

        }
    );
    Album[] payload = check albumClient->/albums;
    io:println(payload);
}