Airframe

https://github.com/wvlet/airframe
Admin
Airframe provides essential building blocks for Scala applications, including logging,...
Tokens:118,752
Snippets:408
Trust Score:7.8
License:Apache-2.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Task RPC Server Setup

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Sets up and starts an Airframe RPC server using Netty. It defines the application design, binds the TaskApiImpl, configures the Netty server with a router, and starts the server.

```scala
package taskapp.server

import taskapp.server.api.TaskApiImpl  
import wvlet.airframe.*
import wvlet.airframe.http.*
import wvlet.airframe.http.netty.Netty
import wvlet.log.{LogSupport, Logger}

object TaskRPCServer extends App with LogSupport {
  // Create RPC router from our API implementation
  val router = RxRouter.of[TaskApiImpl]
  
  val rpcDesign = AppDesign.design
    .bind[TaskApiImpl].toSingleton
    .add(Netty.server
      .withPort(8080)
      .withRouter(router)
      .design)
  
  rpcDesign.build[HttpServer] { server =>
    info(s"Task RPC server started at http://localhost:${server.port}")
    info("RPC interface available for type-safe client access")
    
    server.awaitTermination()
  }
}
```

--------------------------------

### Install Dependencies and Start Dev Server

Source: https://github.com/wvlet/airframe/blob/main/website/README.md

Installs project dependencies using Yarn and starts the development server for a Docusaurus website.

```sh
# Install dependencies
$ yarn

# Start the site
$ yarn start
```

--------------------------------

### Run RPC Server

Source: https://github.com/wvlet/airframe/blob/main/examples/rpc-examples/hello-rpc/README.md

Command to start the RPC server using the packaged application.

```Shell
$ ./target/pack/bin/greeter-main server
```

--------------------------------

### Start Airframe gRPC Server

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-rpc.md

Provides a complete example of setting up and starting an Airframe gRPC server with a custom router and port.

```scala
import wvlet.airframe.http.Router
import wvlet.airframe.http.grpc.gRPC

// API implementation
class GreeterApiImpl extends example.api.GreeterApi {
  def sayHello(message: String): String = s"Hello ${message}!"
}

// Create a Router definition in the same manner with Airframe RPC
val router = Router.add[GreeterApiImpl]

gRPC.server
  .withRouter(router)
  .withPort(8080)
  // [optional] You can add gRPC interceptors here
  //.withInterceptor(...)
  // [optional] you can customize gRPC server here
  //.withServerInitializer{ x: ServerBuilder => x.addMethod(...); x }
  // [optional] Disable the default logging to log/http_server.json file
  //.noRequestLogging
  .start { server =>
    // gRPC server (based on Netty) starts at localhost:8080
    server.awaitTermination
  }
```

--------------------------------

### Airframe Project Setup with sbt

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Defines the project structure and dependencies for a multi-module Scala application using Airframe. Includes cross-project setup for shared API modules.

```sbt
val AIRFRAME_VERSION = "(latest_version)"

ThisBuild / scalaVersion := "2.13.12"
ThisBuild / organization := "com.example"

// Shared API module (for both JVM and JS)
lazy val api = crossProject(JVMPlatform, JSPlatform)
  .crossType(CrossType.Pure)
  .in(file("api"))
  .settings(
    name := "task-api",
    libraryDependencies ++= Seq(
      "org.wvlet.airframe" %%% "airframe-http" % AIRFRAME_VERSION
    )
  )

// Server module (JVM only)
lazy val server = project
  .in(file("server"))
  .enablePlugins(AirframeHttpPlugin)
  .settings(
    name := "task-server",
    libraryDependencies ++= Seq(
      "org.wvlet.airframe" %% "airframe"             % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airframe-http-netty"  % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airframe-log"         % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airframe-codec"       % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airframe-launcher"    % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airspec"              % AIRFRAME_VERSION % Test
    ),
    airframeHttpClients := Seq("taskapp.api:rpc:TaskApiRPC")
  )
  .dependsOn(api.jvm)

// Scala.js client module
lazy val client = project
  .in(file("client"))
  .enablePlugins(ScalaJSPlugin, AirframeHttpPlugin)
  .settings(
    name := "task-client",
    libraryDependencies ++= Seq(
      "org.wvlet.airframe" %%% "airframe-http"  % AIRFRAME_VERSION,
      "org.wvlet.airframe" %%% "airframe-rx"    % AIRFRAME_VERSION,
      "org.wvlet.airframe" %%% "airframe-log"   % AIRFRAME_VERSION
    ),
    airframeHttpClients := Seq("taskapp.api:rpc:TaskApiRPC")
  )
  .dependsOn(api.js)

// CLI module
lazy val cli = project
  .in(file("cli"))
  .enablePlugins(AirframeHttpPlugin)
  .settings(
    name := "task-cli",
    libraryDependencies ++= Seq(
      "org.wvlet.airframe" %% "airframe-launcher" % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airframe-http"     % AIRFRAME_VERSION,
      "org.wvlet.airframe" %% "airframe-log"      % AIRFRAME_VERSION
    ),
    airframeHttpClients := Seq("taskapp.api:rpc:TaskApiRPC")
  )
  .dependsOn(api.jvm)
```

--------------------------------

### Start Airframe RPC Server

Source: https://github.com/wvlet/airframe/blob/main/examples/rpc-examples/rpc-scalajs/README.md

Starts the Airframe RPC server using sbt. After starting, the application can be accessed via a web browser.

```Shell
$ sbt
> server/run server
```

--------------------------------

### Setup Scala.js Widget Development Environment

Source: https://github.com/wvlet/airframe/blob/main/airframe-rx-widget/README.md

This snippet outlines the steps to set up the development environment for Scala.js widgets using airframe-rx-widget. It includes installing necessary npm packages and running sbt commands for compilation.

```Shell
$ npm install 12
$ npm install jsdom@16.0.0

$ ./sbt 
> ~widgetJS/fastOptJS
```

```Shell
$ npm install -g browser-sync

$ browser-sync start --server airframe-rx-widget/src/main/public --serveStatic airframe-rx-widget/.js/target/scala-2.12 --files airframe-rx-widget/.js/target/scala-2.12/airframe-rx-widget-fastopt.js
```

--------------------------------

### Build Configuration for Airframe RPC Project

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-rpc.md

Example build.sbt configuration for a multi-project setup including API, server, and client modules using Airframe RPC.

```Scala
val AIRFRAME_VERSION = "(version)"

// Common build settings
val buildSettings = Seq(
  organization := "(your organization)",
  scalaVersion := "3.3.1"
  // Add your own settings here
)

// RPC API definition. This project should contain only RPC interfaces
lazy val api =
  crossProject(JSPlatform, JVMPlatform)
    .crossType(CrossType.Pure)
    .in(file("myapp-api"))
    .settings(
       buildSettings,
       libraryDependencies ++= Seq(
         "org.wvlet.airframe" %%% "airframe-http" % AIRFRAME_VERSION
       )
    )

// RPC server project (JVM)
lazy val server =
  project
    .in(file("myapp-server"))
    .settings(
      buildSettings,
      libraryDependencies ++= Seq(
        // Add Netty backend
        "org.wvlet.airframe" %% "airframe-http-netty" % AIRFRAME_VERSION
      )
    )
    .dependsOn(api.jvm)

// RPC client project (JVM and Scala.js)
lazy val client =
  crossProject(JSPlatform, JVMPlatform)
    .in(file("myapp-client"))
    .enablePlugins(AirframeHttpPlugin)
    .settings(
      buildSettings,
      // Generate an RPC client for myapp.app.v1 package
      airframeHttpClients := Seq("myapp.app.v1:rpc")
   )
   .dependsOn(api)
```

--------------------------------

### Scala DI Example with AirSpec

Source: https://github.com/wvlet/airframe/blob/main/docs/airspec.md

Demonstrates sharing a singleton Service instance across multiple test methods using AirSpec's initDesign. It shows how to bind configurations, singletons, and define lifecycle hooks for starting and shutting down services.

```scala
import wvlet.airspec._

case class ServiceConfig(port:Int)
class Service(val config:ServiceConfig)

class ServiceSpec extends AirSpec {
  initDesign {
    design.bind[ServiceConfig].toInstance(ServiceConfig(port=8080))
      .bind[Service].toSingleton
      .onStart{x => info(s"Starting a server at ${x.config.port}")}
      .onShutdown{x => info(s"Stopping the server at ${x.config.port}")}
  }

  test("test1") { (service:Service) =>
     info(s"server id: ${service.hashCode}")
  }

  test("test2") { (service:Service) =>
     info(s"server id: ${service.hashCode}")
  }
}
```

--------------------------------

### Start Netty HTTP Server with airframe-http

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-http.md

Provides a Scala code example for starting a Netty HTTP server using airframe-http. It configures the server port, routes, and starts the server, keeping it running until terminated.

```Scala
import wvlet.airframe.http.*
import wvlet.airframe.http.netty.Netty

// Define API routes. This will read all @Endpoint annotations in MyApi
// You can add more routes by using ".add[X]" method.
val router = RxRouter.of[MyApi]

Netty.server
  .withPort(8080)
  .withRouter(router)
  .start { server =>
    // Netty http server will start here
    // Keep running the server 
    server.awaitTermination
  }
```

--------------------------------

### Build Benchmark Runner with sbt

Source: https://github.com/wvlet/airframe/blob/main/airframe-benchmark/README.md

Commands to build and install the Airframe benchmark runner using sbt. Includes commands to pack the benchmark runner and install it to a local directory.

```scala
$ ./sbt
> benchmark/pack

# To install this program to $HOME/local/bin, run:
> benchmark/packInstall
```

--------------------------------

### Start Airframe RPC Server

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-rpc.md

Demonstrates how to start a Netty-based RPC server using Airframe. It configures the server with a router and a specific port, then starts listening for requests.

```Scala
// Create a Router
val router = RxRouter.of[MyServiceImpl]

// Starting a new RPC server.
Netty
  .server
  .withRouter(router)
  .withPort(8080)
  .start { server =>
     server.awaitTermination()
  }
```

--------------------------------

### Build Project with sbt

Source: https://github.com/wvlet/airframe/blob/main/examples/rpc-examples/hello-rpc/README.md

Instructions to build the Scala 3 RPC project using the sbt build tool.

```Shell
$ sbt
> pack
```

--------------------------------

### Example of Programmable HTTP Recorder

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Provides an example demonstrating how to use the programmable HTTP recorder. This allows users to create custom mock HTTP servers for testing purposes.

```Scala
// Add example of programmable http-recorder ([#532](https://github.com/wvlet/airframe/issues/532)) [[cbab375](https://github.com/wvlet/airframe/commit/cbab375)]
```

--------------------------------

### Build and Install Airframe Benchmark Runner

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-benchmark.md

SBT commands to build the benchmark runner and install it to the local bin directory.

```scala
$ ./sbt
> benchmark/pack

# To install this program to $HOME/local/bin, run:
> benchmark/packInstall
```

--------------------------------

### Airframe DI and Examples

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Includes updates related to Airframe DI, such as support for DI tracing and coverage stats. Also highlights the addition of more Airframe DI code examples.

```Scala
// airframe: Support DI tracing and coverage stats ([#486](https://github.com/wvlet/airframe/issues/486))
// Add more airframe examples ([#502](https://github.com/wvlet/airframe/issues/502))
// Add more [Airframe DI code examples](https://github.com/wvlet/airframe/tree/main/examples/src/main/scala/wvlet/airframe/examples/di) ([#495](https://github.com/wvlet/airframe/issues/495))
// Add airframe code [examples ([#485](https://github.com/wvlet/airframe/issues/485))
```

--------------------------------

### Create Replay Server

Source: https://github.com/wvlet/airframe/blob/main/airframe-http-recorder/README.md

This example demonstrates creating an HTTP server that replays recorded responses for matching requests.

```Scala
import wvlet.airframe.http.recorder.{HttpRecorder,HttpRecorderConfig}

// Create a replay server that returns recorded responses for matching requests 
withResource(HttpRecorder.createServer(recorderConfig)) { server =>
  val addr = server.localAddress // "localhost:(port number)"
  // Requests to the local server will return the recorded responses
}
```

--------------------------------

### Airframe Config: Classpath Reading and Examples

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Enhances the airframe-config module to allow reading configuration files from the classpath. Includes additional examples to demonstrate usage and best practices.

```Scala
// airframe-config: Allow reading config files from classpath, and add more examples ([#544](https://github.com/wvlet/airframe/issues/544)) [[697b04e](https://github.com/wvlet/airframe/commit/697b04e)]
```

--------------------------------

### Compile Airframe UI

Source: https://github.com/wvlet/airframe/blob/main/examples/rpc-examples/rpc-scalajs/README.md

Compiles the ScalaJS frontend for the Airframe RPC project using sbt.

```Shell
$ sbt
> ui/fastLinkJS
```

--------------------------------

### Add demo code for airframe-rx-html

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Includes a new demo code example for the airframe-rx-html module, showcasing its capabilities and usage.

```Scala
airframe-rx-html: Add a demo code for airframe-rx-html ([#1283](https://github.com/wvlet/airframe/issues/1283)) [[70dda74](https://github.com/wvlet/airframe/commit/70dda74)]
```

--------------------------------

### Run RPC Client and View Output

Source: https://github.com/wvlet/airframe/blob/main/examples/rpc-examples/hello-rpc/README.md

Command to run the RPC client in a separate terminal and view the received messages from the server.

```Shell
$ ./target/pack/bin/greeter-main client
2023-04-27 10:34:09.510-0700  info [GreeterMain] Received: Hello RPC0!  - (GreeterMain.scala:62)
2023-04-27 10:34:09.527-0700  info [GreeterMain] Received: Hello RPC1!  - (GreeterMain.scala:62)
2023-04-27 10:34:09.531-0700  info [GreeterMain] Received: Hello RPC2!  - (GreeterMain.scala:62)
```

--------------------------------

### Execute Sub-Commands

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-launcher.md

Demonstrates how to execute specific sub-commands defined within the `MyApp` class, including passing arguments to commands like `world` and options to `start`.

```Scala
Launcher.execute[MyApp]("hello")
// hello

Launcher.execute[MyApp]("start --host localhost -p 10000")
// Straing server at localhost:10000
```

--------------------------------

### Launching JMX Registry Programmatically

Source: https://github.com/wvlet/airframe/blob/main/airframe-jmx/README.md

Shows how to start the JMX registry directly within your application using `JMXAgent.start`. This is useful for environments where manual JVM parameter configuration is not feasible.

```Scala
wvlet.airframe.jmx.JMXAgent.start(registryPort=7199)
```

--------------------------------

### Airframe RPC CLI Usage

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Demonstrates how to start the Airframe RPC server and interact with it using the command-line interface (CLI) for task management operations like creating, listing, completing, and deleting tasks.

```Bash
# Start the RPC server
$ sbt "server/run"

# In another terminal, use the CLI
$ sbt "cli/run create --title 'Learn RPC' --desc 'Understand Airframe RPC'"
$ sbt "cli/run list"
$ sbt "cli/run complete --id {task-id}"  
$ sbt "cli/run delete --id {task-id}"
```

--------------------------------

### Running the Airframe Application

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Instructions for compiling the Scala.js code and serving the HTML file to run the Airframe task management application. It details the necessary commands using sbt and Python's http.server.

```Bash
# Compile Scala.js
$ sbt "client/fastOptJS"

# Serve the HTML file (you can use any static server)
$ cd client/src/main/resources && python3 -m http.server 3000

# Open http://localhost:3000 in your browser
```

--------------------------------

### Scala Server Application with Logging

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

A simple Scala application that extends LogSupport to enable logging. It demonstrates how to log informational messages during application startup and provides a placeholder for configuring log levels programmatically.

```scala
package taskapp.server

import wvlet.log.{LogSupport, Logger}

object TaskApp extends App with LogSupport {
  info("Starting Task Management Application")
  debug("Debug logging is available but won't show unless debug level is enabled")
  
  // Configure log level programmatically
  // Logger.setDefaultLogLevel(LogLevel.DEBUG)
  
  info("Application initialized successfully")
}
```

--------------------------------

### Compile Airframe Rx Gallery

Source: https://github.com/wvlet/airframe/blob/main/examples/rx-demo/gallery/README.md

Instructions to compile the Airframe Rx Gallery project using sbt. This involves running the 'fastOptJS' command.

```Shell
$ sbt
> fastOptJS
```

--------------------------------

### Initialize Airframe Log

Source: https://github.com/wvlet/airframe/blob/main/airframe-log/README.md

Provides examples for initializing airframe-log with default settings, including options for enabling or disabling ANSI color output. This is useful for ensuring a consistent logging setup.

```Scala
import wvlet.airframe._

// Initialize with INFO level and SourceCodeLogFormatter
log.init

// For terminals not supporting ANSI colors
log.initNoColor
```

--------------------------------

### Running the Airframe Application

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Provides the command to run the server application using sbt. This command compiles and executes the main application object, generating log output.

```bash
$ sbt "server/run"
```

--------------------------------

### Example Airframe Application Log Output

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Illustrates the expected log output from the Airframe application, including timestamps, log levels, thread names, messages, and source code locations.

```text
2023-12-15 10:30:15.123-0800  info [TaskApp] Starting Task Management Application  - (TaskApp.scala:8)
2023-12-15 10:30:15.125-0800  info [TaskApp] Application initialized successfully  - (TaskApp.scala:14)
```

--------------------------------

### Define HTTP Endpoints with airframe-http

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-http.md

Demonstrates how to define RESTful HTTP endpoints in Scala using airframe-http annotations. Includes examples for GET and POST requests, path parameters, request bodies, headers, Future responses, custom responses, and streaming responses.

```Scala
import wvlet.airframe.http.*
import wvlet.airframe.http.HttpMessage.{Request, Response}
import scala.concurrent.Future

object MyApi {
  case class User(name: String)
  case class NewUserRequest(name:String)
  case class ServerInfo(version:String, ua:Option[String])
}

// [Optional] Specify a common prefix for all endpoints
@Endpoint(path="/v1")
class MyApi {
  import MyApi._

  // Binding http path parameters (e.g., :name) to method arguments
  @Endpoint(method = HttpMethod.GET, path = "/user/:name")
  def getUser(name: String): User = User(name)

  // Receive a JSON request body {"user":"leo"} to generate NewUserRequest instance
  @Endpoint(method = HttpMethod.POST, path = "/user")
  def createNewUser(request:NewUserRequest): User = User(request.name)

  // To read http request headers, get it from RPCContext
  @Endpoint(method = HttpMethod.GET, path = "/info")
  def getInfo(): ServerInfo = {
    val request = RPCContext.current.httpRequest
    ServerInfo("1.0", request.userAgent)
  }

  // Returning Future[X] is also possible.
  // This style is convenient when you need to call another service that returns Future response.
  @Endpoint(method = HttpMethod.GET, path = "/info_f")
  def getInfoFuture(): Future[ServerInfo] = {
    val request = RPCContext.current.httpRequest
    Future.apply(ServerInfo("1.0", request.userAgent))
  }

  // It is also possible to return custom HTTP responses
  @EndPoint(method = HttpMethod.GET, path = "/custom_response")
  def customResponse: Response = {
    val response = Http.response().withContent("hello airframe-http")
    response
  }

  import com.twitter.io.{Buf,Reader}
  // [finagle-backend only] If you return a Reader, the response will be streamed (i.e., it uses less memory)
  @EndPoint(method = HttpMethod.GET, path = "/stream_response")
  def streamingResponse: Reader[User] = {
     Reader.fromSeq(Seq(User("leo"), User("yui")))
  }
}
```

--------------------------------

### Developer Setup and Testing

Source: https://github.com/wvlet/airframe/blob/main/sbt-airframe/README.md

Instructions for developers to set up the Airframe project and run sbt scripted tests. This involves publishing local versions and executing specific test projects.

```bash
# Create a snapshto version of Aiframe for Scala 2.12
$ cd (AIRFRAME_SRC_ROOT)
$ ./sbt publishAllLocal


# Run sbt scripted test 
$ cd sbt-airframe
# Need to set the current AIRFRAME_VERSION. sbt-airframe plugin will read this environment variable
$ AIRFRAME_VERSION=$(../script/dynver.sh) ../sbt
# Run a target scripted test
> scripted sbt-airframe/(test project name)
```

--------------------------------

### Build and Run Airframe Program

Source: https://github.com/wvlet/airframe/blob/main/airframe-launcher/README.md

Instructions for building the Airframe project using sbt and then running the packaged application. It also shows how to access the command-line help.

```sh
$ sbt pack
...

$ ./target/pack/bin/myapp 
Type --help to display the list of commands
$ ./target/pack/bin/myapp --help
usage: [options] <command name>

[options]
 -h, --help                 display help messages
 -l, --loglevel=[LOGLEVEL]  log level 
[commands]
 hello      say hello
 world     	say world

$ ./target/pack/bin/myapp hello
hello
```

--------------------------------

### Main Application with DI

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

The main application object demonstrates how to build and run the application using the Airframe DI design. It injects the TaskService and performs basic operations like creating and listing tasks.

```scala
package taskapp.server

import taskapp.api.CreateTaskRequest
import taskapp.server.service.TaskService
import wvlet.log.{LogSupport, Logger}

object DIApp extends App with LogSupport {
  // Build and run the application using the design
  AppDesign.design.build[TaskService] { taskService =>
    info("Testing dependency injection")
    
    // Create some tasks
    val task1 = taskService.createTask(CreateTaskRequest("Learn Airframe", "Complete the walkthrough"))
    val task2 = taskService.createTask(CreateTaskRequest("Build app", "Create a task management app"))
    
    // List all tasks
    val response = taskService.listTasks()
    info(s"Total tasks: ${response.total}")
    response.tasks.foreach {
      task =>
        info(s"- ${task.title}: ${task.description}")
    }
  }
}
```

--------------------------------

### Airframe-Http-Client: GET with Query Strings

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Adds a `getResource` method to the airframe-http-client for making GET requests that include query string parameters.

```Scala
import wvlet.airframe.http.HttpClient

val client: HttpClient = ??? // Initialize HttpClient

val response = client.getResource("/search", Map("q" -> "airframe", "page" -> "1"))
```

--------------------------------

### Build and Run Airframe Program

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-launcher.md

Instructions for building the Airframe project using sbt and then running the packaged application. It also shows how to access the command-line help.

```sh
$ sbt pack
...

$ ./target/pack/bin/myapp 
Type --help to display the list of commands
$ ./target/pack/bin/myapp --help
usage: [options] <command name>

[options]
 -h, --help                 display help messages
 -l, --loglevel=[LOGLEVEL]  log level 
[commands]
 hello      say hello
 world     	say world

$ ./target/pack/bin/myapp hello
hello
```

--------------------------------

### Airframe Metrics: Exact Start Dates in TimeWindow

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Enhances the `TimeWindow` class in airframe-metrics to support exact start dates. This allows for more precise time-based window calculations.

```Scala
// metrics: Support exact start dates in TimeWindow ([#505](https://github.com/wvlet/airframe/issues/505)) [[23a91b9](https://github.com/wvlet/airframe/commit/23a91b9)]
```

--------------------------------

### Airframe-HTTP-Finagle Idempotent Start/Stop

Source: https://github.com/wvlet/airframe/blob/main/docs/release-notes.md

Makes the FinagleServer start and stop operations idempotent in the airframe-http-finagle module. This prevents issues if start or stop methods are called multiple times.

```Scala
// Make FinagleServer start/stop idempotent
```

--------------------------------

### Scala Task Management Example

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

A Scala code snippet illustrating task management within the Airframe RPC framework, including handling task not found scenarios.

```Scala
info(s"Task ${id} not found")
      }
    }
  }
}
```

--------------------------------

### Initialize Airframe Rx Gallery and Highlight.js

Source: https://github.com/wvlet/airframe/blob/main/examples/rx-demo/gallery/src/main/public/index.html

This snippet initializes the Airframe Rx Gallery by calling its main function and then initializes syntax highlighting using Highlight.js.

```JavaScript
Gallery.main();
hljs.initHighlightingOnLoad();
```

--------------------------------

### SBT Plugins for Airframe Project

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Configures the necessary sbt plugins for building Airframe-based Scala projects, including Scala.js and Airframe-specific plugins.

```sbt
addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.13.2")
addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.3.2")
addSbtPlugin("org.wvlet.airframe" % "sbt-airframe" % "(version)")
```

--------------------------------

### Running Airframe Tests with SBT

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Provides the command to execute tests for the 'server' module within an SBT project, commonly used in Airframe projects.

```bash
$ sbt "server/test"
```

--------------------------------

### Log Properties File Example

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-log.md

An example of a log.properties file format used by airframe-log for configuring log levels per package or logger. It follows the standard Java Properties file format.

```properties
# You can use all, trace, debug, info, warn, error, info, all as log level
wvlet.airframe=debug
org.eclipse.jetty=info
org.apache.http=info
com.amazonaws=info
```

--------------------------------

### Airframe DI Design Configuration

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Defines the Airframe DI design for the application, binding the TaskRepository interface to its in-memory implementation and configuring the TaskService as a singleton. It also shows how to bind configuration.

```scala
package taskapp.server

import taskapp.server.repository.{TaskRepository, InMemoryTaskRepository}
import taskapp.server.service.TaskService
import wvlet.airframe.*

object AppDesign {
  
  val design: Design = newDesign
    // Bind configuration as singleton
    .bind[AppConfig].toProvider { Config(env = "default").of[AppConfig] }
    
    // Bind repository interface to implementation
    .bind[TaskRepository].to[InMemoryTaskRepository]
    
    // TaskService will automatically receive TaskRepository through constructor injection
    .bind[TaskService].toSingleton
}
```

--------------------------------

### Log Level Properties File Example

Source: https://github.com/wvlet/airframe/blob/main/airframe-log/README.md

An example of a `log.properties` file used by airframe-log to configure logging levels for different packages or classes. It follows the standard Java Properties file format.

```Properties
# You can use all, trace, debug, info, warn, error, info, all as log level
wvlet.airframe=debug
org.eclipse.jetty=info
org.apache.http=info
com.amazonaws=info
```

--------------------------------

### AirSpec Assertion Examples

Source: https://github.com/wvlet/airframe/blob/main/docs/airspec.md

Provides practical examples of using AirSpec's `shouldBe` matchers for various testing scenarios in Scala. Demonstrates checking value equality, optional values, nulls, collections, and pattern matching.

```scala
import wvlet.airspec._

class MyTest extends AirSpec {
  test("assertion examples") {
    // checking the value equality with shouldBe, shouldNotBe:
    1 shouldBe 1
    1 shouldNotBe 2
    List().isEmpty shouldBe true

    // For optional values, shouldBe defined (or empty) can be used:
    Option("hello") shouldBe defined
    Option(null) shouldBe empty
    None shouldNotBe defined

    // null check
    val s:String = null
    s shouldBe null
    "s" shouldNotBe null

    // For Arrays, shouldBe checks the equality with deep equals
    Array(1, 2) shouldBe Array(1, 2)

    // Collection checker
    Seq(1) shouldBe defined
    Seq(1) shouldNotBe empty
    Seq(1, 2) shouldBe Seq(1, 2)
    (1, 'a') shouldBe (1, 'a')

    // Object equality checker
    val a = List(1, 2)
    val a1 = a
    val b = List(1, 2)
    a shouldBe a1
    a shouldBeTheSameInstanceAs a1
    a shouldBe b
    a shouldNotBeTheSameInstanceAs b
    
    // Patten matcher
    Seq(1, 2) shouldMatch {
      case Seq(1, _) => // ok 
    }
    
    // Containment check
    "hello world" shouldContain "world"
    Seq(1, 2, 3) shouldContain 1
    
    "hello world" shouldNotContain "!!"
    Seq(1, 2, 3) shouldNotContain 4
  }
}
```

--------------------------------

### Task CLI Client

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

A command-line interface client for interacting with the Task RPC server. It demonstrates type-safe client generation using Airframe's HTTP client and provides commands for listing, creating, completing, and deleting tasks.

```scala
package taskapp.cli

import taskapp.api.{TaskApi, CreateTaskRequest, UpdateTaskRequest}
import wvlet.airframe.http.Http
import wvlet.airframe.launcher.{Launcher, command, option}
import wvlet.log.{LogSupport, Logger}
import scala.util.Using

object TaskCLI extends App {
  Launcher.of[TaskCLI].execute(args)
}

class TaskCLI(
  @option(prefix = "-h,--help", description = "show help", isHelp = true)
  help: Boolean = false,
  @option(prefix = "--host", description = "server host")  
  host: String = "localhost",
  @option(prefix = "--port", description = "server port")
  port: Int = 8080
) extends LogSupport {
  // Create RPC client - this demonstrates type-safe client generation
  private def withClient[A](f: TaskApi => A): A = {
    Using.resource(Http.client.newSyncClient(s"${host}:${port}")) { httpClient =>
      // Generated RPC client provides type-safe access to remote services
      val rpcClient = taskapp.api.TaskApiRPC.newRPCSyncClient(httpClient)
      f(rpcClient.TaskApi)
    }
  }
  
  @command(description = "List all tasks")
  def list(): Unit = {
    withClient { client =>
      val response = client.listTasks()
      info(s"Found ${response.total} tasks:")
      response.tasks.foreach { task =>
        val status = if (task.completed) "✓" else "○"
        println(s"  ${status} [${task.id}] ${task.title}")
        println(s"    ${task.description}")
      }
    }
  }
  
  @command(description = "Create a new task")
  def create(
    @option(prefix = "--title", description = "task title") title: String,
    @option(prefix = "--desc", description = "task description") description: String = ""
  ): Unit = {
    withClient { client =>
      val task = client.createTask(CreateTaskRequest(title, description))
      info(s"Created task: ${task.id}")
    }
  }
  
  @command(description = "Complete a task")
  def complete(
    @option(prefix = "--id", description = "task ID") id: String
  ): Unit = {
    withClient { client =>
      client.updateTask(id, UpdateTaskRequest(completed = Some(true))) match {
        case Some(task) => info(s"Marked task '${task.title}' as completed")
        case None => info(s"Task ${id} not found")
      }
    }
  }
  
  @command(description = "Delete a task")  
  def delete(
    @option(prefix = "--id", description = "task ID") id: String
  ): Unit = {
    withClient { client =>
      if (client.deleteTask(id)) {
        info(s"Deleted task ${id}")
      } else {

```

--------------------------------

### Airframe RPC Example Interface

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-rpc.md

Defines an example RPC interface using Airframe RPC with a 'Greeter' trait and a 'GreeterResponse' case class. The trait uses the @RPC annotation to mark it as an RPC endpoint, and the 'hello' method serves as the RPC call.

```Scala
// An example RPC definition using Airframe RPC
@RPC
trait Greeter {
  // RPC endpoint definition
  def hello(name: String): GreeterResponse = GreeterResponse(s"Hello ${name}!")
}

// A model class defined with case class.
// This will be encoded into JSON {"message":"...."} or its MessagePack representation
case class GreeterResponse(message: String)

```

--------------------------------

### Airframe HTTP PUT Request Example

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-walkthrough.md

Demonstrates making an HTTP PUT request to a non-existent API endpoint with a JSON payload using Airframe's HTTP client. Includes a placeholder for handling potential errors gracefully.

```Scala
Http.PUT(s"/api/tasks/non-existent")
  .withJson(UpdateTaskRequest(title = Some("Updated")))
// Should handle gracefully
```

--------------------------------

### View Airframe Rx Gallery

Source: https://github.com/wvlet/airframe/blob/main/examples/rx-demo/gallery/README.md

Instructions to view the compiled Airframe Rx Gallery by opening the 'index.html' file in a web browser.

```HTML
src/main/public/index.html
```

--------------------------------

### Write tests with AirframeSpec

Source: https://github.com/wvlet/airframe/blob/main/docs/airframe-scalatest.md

Example of creating a test class that extends AirframeSpec for integration with airframe-scalatest.

```scala
package org.yourdomain
import wvlet.airframe.AirframeSpec

class MyTest extends AirframeSpec {
  "my test" in {
    // ... write your test here  
  }
}
```

--------------------------------

### Install sbt-airframe Plugin

Source: https://github.com/wvlet/airframe/blob/main/sbt-airframe/README.md

Adds the sbt-airframe plugin to your project by specifying the dependency in project/plugins.sbt.

```sbt
addSbtPlugin("org.wvlet.airframe" % "sbt-airframe" % "(version)")
```
Tokens:
Raw