Tuesday, June 25, 2024
HomeIOS DevelopmentNewbie's information to server-side Swift utilizing the Hummingbird framework

Newbie’s information to server-side Swift utilizing the Hummingbird framework


Swift on the Server in 2023

Three years in the past I began to give attention to Vapor, the most well-liked web-framework written in Swift, which served me very nicely through the years, however now it’s time to begin a brand new chapter in my life.

As I realized increasingly about how servers work I spotted that Vapor has it is personal execs and cons. The group modified lots throughout the previous 3 years, some core members left and new folks began to take care of the framework. I additionally had some struggles with the default template engine (Leaf) and not too long ago I began to show away from the summary database layer (Fluent) too. One other ache level for me is the rising variety of dependencies, I barely use websockets & multipart-kit, however Vapor has these dependencies by default and you’ll’t eliminate them. 😢

Vapor has some very nice issues to supply, and for the general public it is nonetheless going to be an incredible selection for constructing backends for frontends (BFFs). For me, Vapor reached its limits and I wished to make use of one thing that feels a bit lighter. Somethings that’s modular, one thing that may be simply prolonged and suits my precise wants with out further (unused) bundle dependencies.

This shiny new factor is known as Hummingbird and it seems to be very promising. It was created by Adam Fowler who’s a member of the SSWG and in addition the primary writer of the Soto library (AWS Swift).

Hummingbird has a complete documentation out there on-line and a pleasant instance repository containing varied demo apps written utilizing the Hummingbird Swift server framework. I consider that one of the best a part of the the framework is modularity & extensibility. By the best way, Hummingbird works with out Basis, however it has extensions for Basis objects, this can be a enormous plus for me, however perhaps that is simply my private desire these days. Hummingbird might be prolonged simply, you could find some very helpful extensions underneath the Hummingbird challenge web page, lengthy story brief it really works with Fluent and it is comparatively simple to get together with it when you’ve got some Vapor information… 🤔

Getting began with Hummingbird

To begin with, there isn’t a toolbox or command line utility to assist the kickoff course of, however you’ll be able to all the time obtain the examples repository and use one of many tasks as a place to begin. Alternatively you’ll be able to set every part up by hand, that is what we’ll do now. 🔨

In an effort to construct a brand new utility utilizing the Hummingbird framework you must create a brand new listing and initialize a brand new Swift bundle utilizing the next instructions:

mkdir server && cd $_
swift bundle init --type executable
open Package deal.swift

This can create a brand new Swift bundle and open the Package deal.swift file in Xcode. You should use your individual editor when you don’t love Xcode, however both means you will have so as to add Hummingbird to your bundle manifest file as a dependency. We’ll setup an App goal for the applying itself, and a Server goal for the primary executable, which is able to use the applying and configure it as wanted.


import PackageDescription

let bundle = Package deal(
    identify: "server",
    platforms: [
        .macOS(.v10_15),
    ],
    dependencies: [
        .package(
            url: "https://github.com/hummingbird-project/hummingbird",
            from: "1.0.0"
        ),
        .package(
            url: "https://github.com/apple/swift-argument-parser",
            from: "1.0.0"
        ),
    ],
    targets: [
        .executableTarget(
            name: "Server",
            dependencies: [
                .product(
                    name: "ArgumentParser",
                    package: "swift-argument-parser"
                ),
                .target(name: "App"),
            ]
        ),
        .goal(
            identify: "App",
            dependencies: [
                .product(
                    name: "Hummingbird",
                    package: "hummingbird"
                ),
                .product(
                    name: "HummingbirdFoundation",
                    package: "hummingbird"
                ),
            ],
            swiftSettings: [
                .unsafeFlags(
                    ["-cross-module-optimization"],
                    .when(configuration: .launch)
                ),
            ]
        ),
        .testTarget(
            identify: "AppTests",
            dependencies: [
                .product(
                    name: "HummingbirdXCT",
                    package: "hummingbird"
                ),
                .target(name: "App"),
            ]
        ),
    ]
)

Please create the mandatory file and listing construction, as listed under, earlier than you proceed to the subsequent steps. It is extremely essential to call issues as they seem, in any other case SPM will not work and the challenge will not compile. Anyway, the challenge construction is kind-of Vapor-like as you’ll be able to see. 💧

.
├── Package deal.resolved
├── Package deal.swift
├── README.md
├── Sources
│ ├── App
│ │ └── HBApplication+Configure.swift
│ └── Server
│     └── major.swift
└── Checks
    └── AppTests
        └── AppTests.swift

The subsequent step is to create the primary entry level for the applying. For this objective Hummingbird makes use of the Swift Argument Parser library. Place the next contents into the primary.swift file:

import ArgumentParser
import Hummingbird
import App

struct HummingbirdCommand: ParsableCommand {

    @Possibility(identify: .shortAndLong)
    var hostname: String = "127.0.0.1"

    @Possibility(identify: .shortAndLong)
    var port: Int = 8080

    func run() throws {
        let app = HBApplication(
            configuration: .init(
                deal with: .hostname(hostname, port: port),
                serverName: "Hummingbird"
            )
        )
        strive app.configure()
        strive app.begin()
        app.wait()
    }
}

HummingbirdCommand.major()

The HummingbirdCommand has two choices, you’ll be able to setup a customized hostname and port by offering these values as command line choices (I am going to present it in a while), the applying itself will setup the deal with utilizing the enter after which it’s going to begin listening on the required port.

The configure technique comes from the App goal, that is the place you’ll be able to customise your server occasion, register route handlers and stuff like that, similar to you’d do that in Vapor. The primary distinction is that Hummingbird makes use of the HB namespace, which is fairly useful, and the configure technique is written as an extension. Let’s write it and register a primary route handler. 🧩

import Hummingbird
import HummingbirdFoundation

public extension HBApplication {

    func configure() throws {

        router.get("/") { _ in
            "Whats up, world!"
        }
    }
}

That is it. Now you must be capable to run your server, you’ll be able to press the Play button in Xcode that’ll begin your utility or enter one of many following instructions into the Terminal utility:

# simply run the server
swift run Server

# customized hostname and port
swift run Server --port 3000
swift run Server --hostname 0.0.0.0 --port 3000

# brief model
swift run Server -p 3000
swift run Server -h 0.0.0.0 -p 3000

# set the log stage (https://github.com/apple/swift-log#log-levels)
LOG_LEVEL=discover swift run Server -p 3000

# make launch construct
swift construct -c launch

# copy launch construct to the native folder
cp .construct/launch/Server ./Server

# run the executable
LOG_LEVEL=discover ./Server -p 3000

You possibly can set these values in Xcode too, simply click on on the server scheme and choose the Edit Scheme… menu merchandise. Just remember to’re on the Run goal, displaying the Arguments tag. Merely provde the Arguments Handed On Launch choices to set a customized hostname or port and you’ll set the log stage by including a brand new merchandise into the Surroundings Variables part.

If you would like to unit check your utility, I’ve bought a excellent news for you. Hummingbird additionally comes with a pleasant utility device referred to as HummingbirdXCT, which you’ll be able to simply setup & use if you would like to run some exams towards your API. In our challenge, merely alter the AppTests.swift file.

import Hummingbird
import HummingbirdXCT
import XCTest
@testable import App

ultimate class AppTests: XCTestCase {
    
    func testHelloWorld() throws {
        let app = HBApplication(testing: .dwell)
        strive app.configure()

        strive app.XCTStart()
        defer { app.XCTStop() }

        strive app.XCTExecute(uri: "/", technique: .GET) { response in
            XCTAssertEqual(response.standing, .okay)

            let expectation = "Whats up, world!"
            let res = response.physique.map { String(buffer: $0) }
            XCTAssertEqual(res, expectation)
        }
    }
}

As an alternative of making the applying from the primary entry level, we will arrange a brand new HBApplication occasion, import the App framework and name the configure technique on it. the XCT framework comes with a customized XCTStart and XCTStop technique, and you’ll execute HTTP requests utilizing the XCTExecute perform. The response is accessible in a completion block and it is doable to look at the standing code and extract the physique utilizing a handy String initializer.

As you’ll be able to see Hummingbird is sort of much like Vapor, however it’s light-weight and you’ll nonetheless add these further issues to your server when it’s wanted. Hummingbird seems like the subsequent iteration of Vapor. I actually do not know if Vapor 5, goes to repair the problems I am presently having with the framework or not, however I do not actually care, as a result of that launch will not occur anytime quickly.

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments