Fountain

https://fountain.soludian.com/docs
Admin
Fountain is a comprehensive Go framework for building production-grade distributed systems and...
Tokens:245,389
Snippets:2,672
Trust Score:7.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install QUIC Server Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Installs a QUIC server instance with specified options.

```go
func InstallFountainInstance(opts ...Option) *Server

```

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

### gRPC Server Example

Source: https://fountain.soludian.com/docs/guide/servers

A basic gRPC server implementation in Go. This snippet demonstrates how to set up a listener, register a service, and start serving requests.

```go
/* !!
 * File: server.go
 * File Created: Monday, 6th June 2022 10:07:23 am
 * Author: Kim Ericko (fountain@soludian.com)
 * ----- 
 * Last Modified: Monday, 6th June 2022 10:07:23 am
 * Modified By: Kim Ericko (fountain@soludian.com)
 * ----- 
 * Copyright 2022 Soludian, soludian.com
 * All rights reserved.
 * 
 * Licensed under the SOLUDIAN TECHNOLOGY SOLUTION CO., LTD Software License Agreement.
 * Unauthorized use, reproduction, or distribution is prohibited (the "License");
 * 
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 * 
 * legal@soludian.com / https://www.soludian.com/license
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ----- 
 * 
 * HISTORY:
 * 
 * Date      	By	Comments
 * ----------	---	---------------------------------------------------------
 */

package main

import (
	"context"
	"fmt"
	"log"
	"net"

	"gitlab.soludian.com/soludian/fountain/examples/grpc/chat"
	"google.golang.org/grpc"
)

func main() {
	fmt.Println("Go gRPC Beginners Tutorial!")

	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", 9000))
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}

	s := &ChatService{}

	grpcServer := grpc.NewServer()

	chat.RegisterChatServiceServer(grpcServer, s)

	if err := grpcServer.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %s", err)
	}
}

type ChatService struct {
	chat.UnimplementedChatServiceServer
}

func (s *ChatService) SayHello(ctx context.Context, req *chat.Message) (*chat.Message, error) {
	log.Printf("Receive message body from client: %s", req.Body)
	return &chat.Message{Body: "Hello From the Server!"}, nil
}

```

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

### FJob Start Method

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fjob

Starts the execution of the FJob.

```go
func (c FJob) Start() error
```

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

### ftkit init Example

Source: https://fountain.soludian.com/docs/ftkit/init

An example of how to use the ftkit init command with specific service name and module path values.

```bash
ftkit init my-service gitlab.soludian.com/soludian/my-service
```

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

### Start Serving

Source: https://fountain.soludian.com/docs/reference/clients/ftcp_client

Starts the FTCP client to serve incoming connections. Returns an error if serving fails.

```go
func (c *Client) Serving() error
```

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

### InstallFountainInstance

Source: https://fountain.soludian.com/docs/reference/libs/brokers/fmqtt

Installs a single MQTT broker instance using a key:value configuration format. If the configuration is in key:array format, only the first element will be installed.

```APIDOC
## InstallFountainInstance

### Description
Installs a single MQTT broker instance using a key:value configuration format. If the configuration is in key:array format, only the first element will be installed.

### Usage
```yaml
config.yaml:
	fmqtt:
	  name: default_name
	  ...
```

```go
fmqtt.InstallFountainInstance()

fmqtt.WithConfigKey("fmqtt").InstallFountainInstance()
```

### Signature
```go
var InstallFountainInstance = Lib.InstallFountainInstance
```
```

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

### Setup Configuration Environment

Source: https://fountain.soludian.com/docs/reference/libs/env

Initializes the environment for configuration loading.

```go
func SetupConfigEnv()
```

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

### Sentinel Flow Control Setup

Source: https://fountain.soludian.com/docs/guide/resilience

This Go code demonstrates how to set up a basic API server with Sentinel-based flow control. It includes routes for testing panic, successful responses, and error responses. Use this as a starting point for implementing rate limiting and other flow control mechanisms.

```go
/* !!
 * File: main.go
 * File Created: Tuesday, 28th June 2022 4:24:43 pm
 * Author: Kim Ericko (fountain@soludian.com)
 * ----- 
 * Last Modified: Thursday, 30th June 2022 4:25:20 pm
 * Modified By: Kim Ericko (fountain@soludian.com)
 * ----- 
 * Copyright 2022 Soludian, soludian.com
 * All rights reserved.
 *
 * Licensed under the SOLUDIAN TECHNOLOGY SOLUTION CO., LTD Software License Agreement.
 * Unauthorized use, reproduction, or distribution is prohibited (the "License");
 *
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * legal@soludian.com / https://www.soludian.com/license
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ----- 
 *
 * HISTORY:
 *
 * Date      	By	Comments
 * ----------	---	---------------------------------------------------------
 */

package main

import (
	"fmt"

	"github.com/gofiber/fiber/v3"
	"gitlab.soludian.com/soludian/fountain"
	"gitlab.soludian.com/soludian/fountain/libs/flog"
	"gitlab.soludian.com/soludian/fountain/libs/fnet/fhttp"
)

var logger = flog.NewFountainLoggerOnce()

type APIServer struct {
	*fhttp.Server
}

func (s *APIServer) Initialize() error {
	s.Server = fhttp.InstallFountainInstance()
	s.Server.Get("/panic", func(ctx fiber.Ctx) error {
		err := fmt.Errorf("Route panic")
		logger.WErr(err).Panicf(err.Error())
		return err
	})

	s.Server.Get("/200", func(ctx fiber.Ctx) error {
		return ctx.SendString("hello")
	})

	s.Server.Get("/hello", func(ctx fiber.Ctx) error {
		return ctx.JSON("Hello client: " + ctx.Get("app"))
	})

	s.Server.Get("/500", func(ctx fiber.Ctx) error {
		return ctx.Status(500).JSON("Hello client: " + ctx.Get("app"))
	})

	return nil
}

// export FOUNTAIN_DEBUG_MODE=true && go run main.go
// ab -n 10 -c 10 http://127.0.0.1:9007/hello, you can see 429, indicating current limit
func main() {
	server := &APIServer{}
	fountain.WithAppInstances(server).Serving()
}

```

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

### Bootstrap Fountain Application

Source: https://fountain.soludian.com/docs/guide/core-concepts

Use `New()` to get the singleton Fountain instance, register components with fluent builder methods, and start the lifecycle with `Serving()`. The builder methods return `*Fountain` for chaining.

```go
fountain.New().
    WithAppInstances(httpServer, grpcServer).
    WithInvokers(initDB).
    WithCrons(dailyReport).
    Serving()
```

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

### Registering and Installing Core Controllers

Source: https://fountain.soludian.com/docs/guide/core-concepts

Shows how to register new controllers and install them after dependencies are available. This process triggers InstallController and RegisterCallback methods.

```go
core.RegisterCoreController(&UserController{})
core.RegisterCoreController(&OrderController{})

// after databases, caches, etc. are installed:
core.InstallCoreControllers()
```

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

### Install Core Controllers

Source: https://fountain.soludian.com/docs/reference/core

Installs core controllers after essential dependencies like SQL and Redis have been set up. Returns a slice of any controllers that failed to install.

```go
func InstallCoreControllers(ctrl ...CoreController) []CoreController

```

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

### Serve

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fhttp

Starts the server. This function should be run in a goroutine.

```APIDOC
## Serve

### Description
Starts the server. This function should be run in a goroutine.

### Method
POST

### Endpoint
/serve

### Parameters

### Request Body

### Request Example

### Response
#### Success Response (200)
- **error** (error) - Error if the server failed to start.
```

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

### Installing Infrastructure with Config-Key Pattern

Source: https://fountain.soludian.com/docs/guide/core-concepts

Illustrates using the config-key pattern to bind an infrastructure component, like Redis, to a configuration key and install it into the Fountain instance.

```go
client := fedis.WithConfigKey("redis").InstallFountainInstance()
```

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

### InstallCoreControllers

Source: https://fountain.soludian.com/docs/reference/core

Installs a list of CoreControllers. This function should be called after all necessary dependencies (like SQL/Redis) are installed.

```APIDOC
## InstallCoreControllers

### Description
Installs a variadic list of CoreController instances. This function is intended to be called after core dependencies are set up.

### Function Signature
```go
func InstallCoreControllers(ctrl ...CoreController) []CoreController
```

### Parameters
* **ctrl** (...CoreController) - A variadic list of CoreController instances to install.

### Returns
* **[]CoreController**: A slice of CoreController instances that were successfully installed.
```

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

### Install Fountain Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates and configures a new QUIC server instance with the provided options.

```go
func InstallFountainInstance(opts ...Option) *Server
```

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

### ServerInstance.Initialize

Source: https://fountain.soludian.com/docs/reference/runnable

Initialize performs setup tasks required for the ServerInstance to operate correctly.

```APIDOC
## ServerInstance.Initialize

### Description
Initializes the ServerInstance, performing necessary setup operations.

### Method Signature
```go
func (si ServerInstance) Initialize() error
```

### Returns
* `error` - An error if initialization fails, otherwise nil.
```

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

### Get Authentication URL

Source: https://fountain.soludian.com/docs/reference/libs/social_auth

Starts the authentication process and returns a URL for users to be redirected to. It expects the provider name from query parameters.

```go
func GetAuthURL(ctx fiber.Ctx) (string, error)
```

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

### Install Fountain Instance Once (Key-Value Config)

Source: https://fountain.soludian.com/docs/reference/libs/sd/fetcd

Installs a Fountain instance using a key-value configuration format, ensuring it's initialized only once. If the config is key:array, it will only install the first element.

```go
var InstallFountainInstanceOnce = Lib.InstallFountainInstanceOnce

```

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

### Installation and Management

Source: https://fountain.soludian.com/docs/reference/clients/ftcp_client

Functions for installing and managing FTCP client instances, including options for configuration.

```APIDOC
## func InstallFountainInstance

### Description
Installs a FTCP client instance with default configuration.

### Usage
```go
// config.yaml:
// ftcp_client:
//   name: default_name
//   ...
// code.go
// ftcp_client.InstallFountainInstance()
// ftcp_client.WithConfigKey("ftcp_client").InstallFountainInstance()
```

### Signature
```go
var InstallFountainInstance = Lib.InstallFountainInstance
```
```

```APIDOC
## func InstallFountainInstances

### Description
Installs FTCP client instances, supporting configuration in key:array format.

### Usage
```go
// config.yaml:
// ftcp_client:
//   - name: default_name
//     ...
// code.go
// ftcp_client.InstallFountainInstances()
// ftcp_client.WithConfigKey("ftcp_client").InstallFountainInstances()
```

### Signature
```go
var InstallFountainInstances = Lib.InstallFountainInstances
```
```

```APIDOC
## func WithConfigKey

### Description
Specifies a configuration key for installing FTCP client instances.

### Signature
```go
var WithConfigKey = Lib.WithConfigKey
```
```

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

### Basic Fountain Application with APIServer

Source: https://fountain.soludian.com/docs/guide/getting-started

This snippet shows a complete Fountain application. It defines an APIServer that embeds an fhttp.Server, installs it using a configuration key, wires up core controllers and crypto instances, and registers several HTTP routes. The main function initializes the server and starts the Fountain lifecycle.

```go
/* !!
 * File: main.go
 * File Created: Friday, 28th October 2022 5:19:38 pm
 * Author: Kim Ericko (fountain@soludian.com)
 * ----- 
 * Last Modified: Wednesday, 8th March 2023 4:40:18 pm
 * Modified By: Kim Ericko (fountain@soludian.com)
 * ----- 
 * Copyright 2022 Soludian, soludian.com
 * All rights reserved.
 * 
 * Licensed under the SOLUDIAN TECHNOLOGY SOLUTION CO., LTD Software License Agreement.
 * Unauthorized use, reproduction, or distribution is prohibited (the "License");
 * 
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 * 
 * legal@soludian.com / https://www.soludian.com/license
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ----- 
 * 
 * HISTORY:
 * 
 * Date      	By	Comments
 * ----------	---	---------------------------------------------------------
 */

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/gofiber/fiber/v3"
	"gitlab.soludian.com/soludian/fountain"
	"gitlab.soludian.com/soludian/fountain/biz/core"
	"gitlab.soludian.com/soludian/fountain/libs/base/lib_3rd"
	"gitlab.soludian.com/soludian/fountain/libs/crypto"
	"gitlab.soludian.com/soludian/fountain/libs/flog"
	"gitlab.soludian.com/soludian/fountain/libs/fnet/fhttp"
)

var logger = flog.NewFountainLoggerOnce()

type NoModule struct {
}

func (NoModule) Liveness() bool {
	return true
}

func (NoModule) Readiness() bool {
	return false
}

type APIServer struct {
	*fhttp.Server
}

func (s *APIServer) Initialize() error {
	s.Server = fhttp.WithConfigKey("server.fhttp").InstallFountainInstance()

	core.InstallCoreControllers()

	cr := crypto.InstallFountainInstances()
	log.Printf("Initializing: %+v", cr.GetFountainInstanceNames())

	s.Server.Get("/panic", func(ctx fiber.Ctx) error {
		err := fmt.Errorf("route panic")
		logger.WErr(err).Panicf(err.Error())
		return err
	})

	s.Server.Get("/200", func(ctx fiber.Ctx) error {
		return ctx.SendString("hello")
	})

	s.Server.Get("/hello", func(ctx fiber.Ctx) error {
		logger.Infof(ctx.Route().Path)
		return ctx.JSON("Hello client: " + ctx.Get("app"))
	})

	s.Server.Get("/encrypt", func(ctx fiber.Ctx) error {
		logger.Infof(ctx.Route().Path)
		return fhttp.WithContext(ctx).WithEncryption().WithStatus(200).WriteSuccess("Hello client: " + ctx.Get("app"))
	})

	s.Server.Get("/encrypt-cbc", func(ctx fiber.Ctx) error {
		data := make(map[string]any)
		data["server"] = "encrypt-cbc"
		data["time"] = time.Now().String()

		logger.Infof(ctx.Route().Path)
		return fhttp.WithContext(ctx).WithEncryptionFunc(crypto.GetFountainInstance("AES-CBC")).WithStatus(200).WriteSuccess(data)
	})

	s.Server.Get("/encrypt-ctr", func(ctx fiber.Ctx) error {
		data := make(map[string]any)
		data["server"] = "encrypt-ctr"
		data["time"] = time.Now().String()

		logger.Infof(ctx.Route().Path)
		return fhttp.WithContext(ctx).WithEncryptionFunc(crypto.GetFountainInstance("AES-CTR")).WithStatus(200).WriteSuccess(data)
	})

	s.Server.Get("/500", func(ctx fiber.Ctx) error {
		return ctx.Status(500).JSON("Hello client: " + ctx.Get("app"))
	})

	lib_3rd.RegisterHealthCheck("NoModule", &NoModule{})
	s.Server.InitHealthCheckPath("/")

	return nil
}

func main() {
	server := &APIServer{}
	fountain.WithAppInstances(server).Serving()
}

```

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

### FJob StartHTTP Method

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fjob

Starts the FJob in an HTTP context.

```go
func (c FJob) StartHTTP(w http.ResponseWriter, r *http.Request)
```

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

### Start Cache and Garbage Collection

Source: https://fountain.soludian.com/docs/reference/libs/cache/redis_cache

Starts the Redis cache adapter and initiates garbage collection. Accepts optional configuration strings.

```go
func (rc *Cache) StartAndGC(configs ...string) error
```

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

### Install Single Fountain Instance

Source: https://fountain.soludian.com/docs/reference/clients/fgrpc_client

Installs a single Fountain instance with configuration. Use when config instance is in key:value format. If config is key:array, only the first element is installed.

```go
var InstallFountainInstance = Lib.InstallFountainInstance
```

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

### Server InstallFountainInstance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Installs a new QUIC server instance with the given options. This is typically used to set up the server in a specific environment.

```APIDOC
## Server.InstallFountainInstance

### Description
Installs a new QUIC server instance with the given options.

### Signature
```go
func InstallFountainInstance(opts ...Option) *Server
```
```

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

### FJob.Start

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fjob

Starts the FJob execution.

```APIDOC
## Start

### Description
Starts the FJob execution.

### Method
```go
func (c FJob) Start() error
```
```

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

### Start

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fcron

Starts the cron scheduler in a separate goroutine. If already started, this is a no-op.

```APIDOC
## Start

### Description
Start the cron scheduler in its own goroutine, or no-op if already started.

### Signature
```go
func (c *Cron) Start()
```
```

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

### Client.Serving

Source: https://fountain.soludian.com/docs/reference/clients/fudp_client

Starts the serving process for the FUDP client.

```APIDOC
## func (c *Client) Serving

### Description
Starts the serving process for the FUDP client.

### Signature
```go
func (c *Client) Serving() error
```
```

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

### GetStartTime Function

Source: https://fountain.soludian.com/docs/reference/libs/env

Retrieves the start time of the application.

```go
func GetStartTime() string
```

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

### Start Tracing Span

Source: https://fountain.soludian.com/docs/reference/libs/ftracer

The Start method on a Tracer begins a tracing span. It returns the updated context and the created trace.Span.

```go
func (t *Tracer) Start(ctx context.Context, spanName string, carrier propagation.TextMapCarrier, opts ...trace.SpanStartOption) (context.Context, trace.Span)
```

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

### Install ftkit CLI

Source: https://fountain.soludian.com/docs/ftkit/overview

Installs the ftkit CLI using Go modules. Ensure your GOPRIVATE and .netrc are configured for private GitLab hosts.

```bash
go install gitlab.soludian.com/soludian/ftkit@latest
```

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

### Install Fountain instance with key:value config

Source: https://fountain.soludian.com/docs/reference/libs/brokers/fmqtt

Use this function when the instance configuration is in a key:value format. It installs the first element if the config is key:array.

```go
var InstallFountainInstance = Lib.InstallFountainInstance

```

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

### Run Fountain Application

Source: https://fountain.soludian.com/docs/guide/getting-started

Execute this command from your project directory to start the Fountain application. The application will initialize registered instances and start the HTTP server.

```bash
go run .

```

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

### Start Cache and Garbage Collection

Source: https://fountain.soludian.com/docs/reference/libs/cache/lfu_cache

Starts the LFU cache and its garbage collection process. Accepts optional configuration strings.

```go
func (lc *Cache) StartAndGC(configs ...string) error
```

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

### StartAndGC

Source: https://fountain.soludian.com/docs/reference/libs/cache/memcache

Starts the memcache adapter with optional configuration. It can also perform garbage collection.

```APIDOC
## StartAndGC

### Description
Starts the memcache adapter with optional configuration. It can also perform garbage collection.

### Method
`StartAndGC`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **configs** (string...) - Optional - Configuration strings, expected in the format `{"conn":"connection info"}`. Defaults to `{"conn":"127.0.0.1:11211"}` if not provided.
```

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

### Install gomarkdoc and regenerate API docs

Source: https://fountain.soludian.com/docs/reference

To regenerate the API documentation, you need to install gomarkdoc and then run the npm script. Ensure the fountain and ftkit repositories are checked out alongside the documentation repository.

```bash
go install github.com/princjef/gomarkdoc/cmd/gomarkdoc@latest
npm run gen:api
```

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

### Server.Serve

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fhttp

Starts the server and begins listening for incoming requests. This is the main function to run the server.

```APIDOC
## Server.Serve

### Description
Starts the HTTP server and begins serving requests.

### Signature
func (s *Server) Serve() (err error)
```

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

### InstallFountainInstance

Source: https://fountain.soludian.com/docs/reference/libs/stored/fcql

Installs a Fountain instance with configuration provided in a key:value format. This is used when the configuration is a single value associated with a key. It attempts to install the instance using the provided configuration key.

```APIDOC
## InstallFountainInstance

### Description
Installs a Fountain instance with configuration provided in a key:value format. This is used when the configuration is a single value associated with a key. It attempts to install the instance using the provided configuration key.

### Usage

```yaml
config.yaml:

fcql:
  name: default_name
  ...
```

```go
fcql.InstallFountainInstance()

fcql.WithConfigKey("fcql").InstallFountainInstance()
```
```

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

### InstallFountainInstances

Source: https://fountain.soludian.com/docs/reference/libs/stored/fcql

Installs multiple Fountain instances when the configuration is provided as a key:array format. This function will always attempt to initialize instances, even if the configuration is in a key:value format (installing only the first element).

```APIDOC
## InstallFountainInstances

### Description
Installs multiple Fountain instances when the configuration is provided as a key:array format. This function will always attempt to initialize instances, even if the configuration is in a key:value format (installing only the first element).

### Usage

```yaml
config.yaml:

fcql:
  - name: default_name
    ...
```

```go
fcql.InstallFountainInstances()

fcql.WithConfigKey("fcql").InstallFountainInstances()
```
```

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

### Install Fountain Instance with Key-Value Config

Source: https://fountain.soludian.com/docs/reference/libs/sd/fconsul

Use this function when configuring the instance in a key:value format. If the config is key:array, only the first element will be installed.

```yaml
config.yaml:

fconsul:
  name: default_name
  ...

```

```go
fconsul.InstallFountainInstance()

fconsul.WithConfigKey("fconsul").InstallFountainInstance()
```

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

### Server.Serving

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Serving starts the FQUIC server to accept incoming connections.

```APIDOC
## Server.Serving

### Description
Serving starts the FQUIC server to accept incoming connections.

### Signature
func (s *Server) Serving()
```

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

### Serving

Source: https://fountain.soludian.com/docs/reference/libs/fnet/ftcp

Starts the server to listen for incoming connections. This function should be run in a goroutine.

```APIDOC
## Serving

### Description
Starts the server to listen for incoming connections. This function should be run in a goroutine.

### Method
*Server.Serving

### Parameters
None

### Request Example
```go
// Example usage (assuming 's' is a *Server instance)
go s.Serving()
```

### Response
This method does not return a value.
```

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

### StartAndGC

Source: https://fountain.soludian.com/docs/reference/libs/cache/lru_cache

Starts the garbage collection routine for the cache with optional configuration.

```APIDOC
## StartAndGC

### Description

Starts the garbage collection routine for the cache with optional configuration.

### Method

* (rc *Cache) StartAndGC(configs ...string) error

### Parameters

#### Path Parameters

* **configs** (...string) - Optional - Configuration strings for the GC routine. Expected format: `{"capacity": 1024}`.

### Response

#### Success Response

Returns nil error if the GC routine was started successfully, otherwise an error.

#### Response Example

```go
null
```
```

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

### Start ARC Cache with Garbage Collection

Source: https://fountain.soludian.com/docs/reference/libs/cache/arc_cache

Starts the ARC cache and enables garbage collection with optional configuration strings.

```go
func (ac *Cache) StartAndGC(configs ...string) error
```

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

### Serve with FUDP Server

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fudp

Serving starts the FUDP server's main loop and should be run in a goroutine.

```go
func (s *Server) Serving()
```

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

### Install Multiple Fountain Instances

Source: https://fountain.soludian.com/docs/reference/clients/fgrpc_client

Installs multiple Fountain instances, especially when config is in key:array format. It will always attempt to initialize, even if the config is key:value.

```go
var InstallFountainInstances = Lib.InstallFountainInstances
```

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

### Cache.StartAndGC

Source: https://fountain.soludian.com/docs/reference/libs/cache/lru_cache

Starts the cache and its garbage collection process with optional configurations.

```APIDOC
## Cache.StartAndGC

### Description
Starts the cache and its garbage collection process with optional configurations.

### Method
```go
func (rc *Cache) StartAndGC(configs ...string) error
```

### Parameters
#### Path Parameters
- **configs** (...string) - Optional - Configuration strings for the cache and GC process.
```

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

### DefaultConfig

Source: https://fountain.soludian.com/docs/reference/clients/ftcp_client

Provides a default configuration object for the FTCP client. This is useful for quick setup or as a starting point for custom configurations.

```APIDOC
## DefaultConfig

### Description
Provides a default configuration object for the FTCP client. This is useful for quick setup or as a starting point for custom configurations.

### Method
Go Function

### Signature
func DefaultConfig() *Config

### Parameters
No parameters.
```

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

### FJob.StartHTTP

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fjob

Starts the FJob execution in an HTTP context.

```APIDOC
## StartHTTP

### Description
Starts the FJob execution in an HTTP context.

### Method
```go
func (c FJob) StartHTTP(w http.ResponseWriter, r *http.Request)
```
```

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

### Serving2

Source: https://fountain.soludian.com/docs/reference/libs/fnet/ftcp

Starts the server using connect.NewBufferedConn. This is a potentially tricky implementation and not directly comparable with the codec interface.

```APIDOC
## Serving2

### Description
Starts the server using connect.NewBufferedConn. This is a potentially tricky implementation and not directly comparable with the codec interface. TODO(@Kim Ericko): A tricky way.

### Method
*Server.Serving2

### Parameters
None

### Request Example
```go
// Example usage (assuming 's' is a *Server instance)
go s.Serving2()
```

### Response
This method does not return a value.
```

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

### GetStartTime

Source: https://fountain.soludian.com/docs/reference/libs/env

Retrieves the start time of the application.

```APIDOC
## func GetStartTime()

Get the start time in which the application runs
```

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

### InstallFountainInstance Function

Source: https://fountain.soludian.com/docs/reference/clients/fquic_client

Creates and configures a QUIC client instance with provided options.

```go
func InstallFountainInstance(opts ...Option) *Client

```

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

### Connect Method

Source: https://fountain.soludian.com/docs/reference/clients/fquic_client

Establishes a connection to the QUIC server. This is the initial step to begin communication.

```go
func (c *Client) Connect(ctx context.Context) error
```

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

### Initialize QUIC Server

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Initializes the QUIC server, preparing it for operation.

```go
func (s *Server) Initialize() error

```

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

### Get Server Package Name

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Returns the package name of the server.

```go
func (s *Server) PackageName() string

```

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

### Get QUIC Server Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Retrieves the QUIC server instance with specified options.

```go
func GetFountainInstance(opts ...Option) *Server

```

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

### StartAndGC

Source: https://fountain.soludian.com/docs/reference/libs/cache/redis_cache

Starts the Redis cache adapter and performs garbage collection. Configuration options can be provided as strings.

```APIDOC
## StartAndGC

### Description
Starts the Redis cache adapter and performs garbage collection. Configuration options can be provided as strings. The cache items in Redis are stored forever, so no explicit GC operation is performed on them.

### Method
Not applicable (SDK method)

### Signature
func (rc *Cache) StartAndGC(configs ...string) error

### Parameters
- **configs** (...string) - Optional configuration strings for starting the cache. Example format: `{"name": "cache", "key":"collection key","addr":"127.0.0.1:6379","db_num":"0"}`.

### Returns
- **error** - An error if the operation fails, otherwise nil.
```

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

### Server Initialize

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Initializes the QUIC server instance. This method must be called before the server can start accepting connections.

```APIDOC
## Server.Initialize

### Description
Initializes the QUIC server instance.

### Signature
```go
func (s *Server) Initialize() error
```
```

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

### InstallFountainInstances

Source: https://fountain.soludian.com/docs/reference/libs/brokers/fmqtt

Installs multiple MQTT broker instances using a key:array<value> configuration format. It will always attempt to initialize, even if the configuration is in key:value format.

```APIDOC
## InstallFountainInstances

### Description
Installs multiple MQTT broker instances using a key:array<value> configuration format. It will always attempt to initialize, even if the configuration is in key:value format.

### Usage
```yaml
config.yaml:
	fmqtt:
	  - name: default_name
	    ...
```

```go
fmqtt.InstallFountainInstances()

fmqtt.WithConfigKey("fmqtt").InstallFountainInstances()
```

### Signature
```go
var InstallFountainInstances = Lib.InstallFountainInstances
```
```

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

### Initialize the 3rd party library

Source: https://fountain.soludian.com/docs/reference/libs/brokers/fmqtt

Initializes the 3rd party library with a new client and default configuration function.

```go
var Lib = lib_3rd.NewLib(newClient, lib_3rd.WithDefaultConfigFunc[typ.Config, client](typ.DefaultConfig))

```

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

### Tracer.Start

Source: https://fountain.soludian.com/docs/reference/libs/ftracer

Starts a tracing span with the given context, name, carrier, and start options.

```APIDOC
## func (*Tracer) Start

### Description
Starts a tracing span. This method takes a context, a span name, a text map carrier for propagation, and optional span start options.

### Signature
```go
func (t *Tracer) Start(ctx context.Context, spanName string, carrier propagation.TextMapCarrier, opts ...trace.SpanStartOption) (context.Context, trace.Span)
```
```

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

### Get Fountain Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Provides an alias for InstallFountainInstance, used to retrieve an existing QUIC server instance.

```go
func GetFountainInstance(opts ...Option) *Server
```

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

### SetupConfigEnv

Source: https://fountain.soludian.com/docs/reference/libs/env

Sets up the environment for configuration loading.

```APIDOC
## func SetupConfigEnv

### Description
Sets up the environment for configuration loading.

### Signature
```go
func SetupConfigEnv()
```
```

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

### StartAndGC

Source: https://fountain.soludian.com/docs/reference/libs/cache/lfu_cache

Starts the garbage collection routine for the cache, configured by a string containing settings like capacity.

```APIDOC
## func (*Cache) StartAndGC

### Description
Starts gc routine based on config string settings. config: must be in the format {"capacity": 1024}

### Method Signature
```go
func (lc *Cache) StartAndGC(configs ...string) error
```
```

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

### Initialize Progress Bar with Multiple Options

Source: https://fountain.soludian.com/docs/reference/ftkit/progress_bar

Demonstrates initializing a progress bar with multiple options, including width, rendering blank state, and visibility. The example resets the bar, prints a message, waits, and then adds progress.

```go
bar := NewOptions(100, OptionSetWidth(10), OptionSetRenderBlankState(true), OptionSetVisibility(false))
bar.Reset()
fmt.Println("hello, world")
time.Sleep(1 * time.Second)
bar.Add(10)
```

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

### Server.Serving

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fudp

Serving starts the UDP server's main loop, intended to be run in a goroutine.

```APIDOC
## func (s *Server) Serving

### Description
Starts the UDP server's main loop. This function needs to be run in a goroutine.

### Signature
```go
func (s *Server) Serving()
```
```

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

### Start the cron scheduler in a goroutine

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fcron

Starts the cron scheduler in a separate goroutine. If the scheduler is already running, this function has no effect.

```go
func (c *Cron) Start()
```

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

### New QUIC Server Instance with Config Key

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance using a configuration key.

```go
func WithConfigKey(configKey string) runnable.AppInstance

```

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

### Create QUIC Server with Configuration

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance using a provided configuration object.

```go
func WithConfig(c *config) runnable.AppInstance
```

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

### Cache.StartAndGC

Source: https://fountain.soludian.com/docs/reference/libs/cache/memcache

Starts the memcache service and garbage collection process. It can accept configuration strings to customize its behavior.

```APIDOC
## Cache.StartAndGC

### Description
Starts the memcache service and garbage collection.

### Signature
```go
func (rc *Cache) StartAndGC(configs ...string) error
```
```

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

### Create QUIC Server with Config Key

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance by specifying a configuration key.

```go
func WithConfigKey(configKey string) runnable.AppInstance
```

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

### Create New QUIC Server Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance with default configuration.

```go
func New() runnable.AppInstance

```

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

### Get Auxiliary Server Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fhttp

Retrieves the auxiliary server instance. Panics if the server is not available.

```go
func GetAuxiliaryServer() *Server
```

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

### Server.Initialize

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Initialize prepares the FQUIC server for serving connections.

```APIDOC
## Server.Initialize

### Description
Initialize prepares the FQUIC server for serving connections.

### Signature
func (s *Server) Initialize() error
```

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

### New QUIC Server Instance with Config

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance with a specific configuration.

```go
func WithConfig(c *config) runnable.AppInstance

```

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

### ServerInstance Initialize Method Signature

Source: https://fountain.soludian.com/docs/reference/runnable

Method signature for initializing a ServerInstance.

```go
func (si ServerInstance) Initialize() error
```

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

### Installing Infrastructure with Functional-Options Pattern

Source: https://fountain.soludian.com/docs/guide/core-concepts

Shows how to configure an infrastructure component, such as an gRPC server, inline using functional options. This pattern allows for flexible, code-based configuration.

```go
server := fgrpc.WithConfigKey("fgrpc").
    InstallFountainInstance(fgrpc.WithServerOptions(serverOptions...))
```

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

### New QUIC Server Instance

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance with default configuration. This is the entry point for setting up a QUIC server.

```APIDOC
## New

### Description
Creates a new QUIC server instance with default configuration.

### Signature
```go
func New() runnable.AppInstance
```
```

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

### New Client Function

Source: https://fountain.soludian.com/docs/reference/clients/fquic_client

Creates a new QUIC client with default configuration.

```go
func New() *Client

```

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

### Example: Render Blank State for Progress Bar

Source: https://fountain.soludian.com/docs/reference/ftkit/progress_bar

Shows how to configure a progress bar to render a 0% state upon initialization using OptionSetRenderBlankState.

```go
NewOptions(10, OptionSetWidth(10), OptionSetRenderBlankState(true))
// Output:
// 0% |          |  [0s:0s]
```

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

### Server.GetName

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fhttp

Gets the name of the server instance.

```APIDOC
## Server.GetName

### Description
Retrieves the name of the server.

### Signature
func (s *Server) GetName() string
```

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

### Main Server Initialization

Source: https://fountain.soludian.com/docs/guide/servers

Initializes and serves the API server. This is the entry point for the application.

```go
func main() {
	server := &APIServer{}
	fountain.WithAppInstances(server).Serving()
}
```

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

### Initialize FQUIC Server

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Initializes the server, preparing it for serving QUIC connections. This method must be called before the server can accept connections.

```go
func (s *Server) Initialize() error
```

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

### InstallFountainInstance

Source: https://fountain.soludian.com/docs/reference/libs/sd/fconsul

Installs a Consul client instance using configuration defined in a key:value format. If the configuration is in key:array format, only the first element will be used.

```APIDOC
## InstallFountainInstance

### Description

Installs a Consul client instance using configuration defined in a key:value format. If the configuration is in key:array format, only the first element will be used.

### Usage

```yaml
config.yaml:

fconsul:
  name: default_name
  ...
```

```go
fconsul.InstallFountainInstance()

fconsul.WithConfigKey("fconsul").InstallFountainInstance()
```
```

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

### Server.GetPackageName

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fhttp

Gets the package name associated with the server.

```APIDOC
## Server.GetPackageName

### Description
Retrieves the package name of the server.

### Signature
func (s *Server) GetPackageName() string
```

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

### Client.WatchPrefix

Source: https://fountain.soludian.com/docs/reference/libs/sd/fetcd

Starts watching for changes under a given prefix in etcd.

```APIDOC
## Client.WatchPrefix

### Description
Starts watching for changes under a given prefix in etcd.

### Signature
```go
func (e *Client) WatchPrefix(ctx context.Context, prefix string) (*Watch, error)
```

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Response
#### Success Response
- **Watch** (*Watch) - A pointer to the Watch object that can be used to receive events.
- **err** (error) - An error if the watch setup failed.

#### Error Response
- **err** (error) - An error if the watch setup failed.
```

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

### With Client Certificate Option

Source: https://fountain.soludian.com/docs/reference/libs/sd/fetcd

Option to configure client certificate and key for TLS connections.

```go
func WithCert(certFile, keyFile string) lib_3rd.Option[config]

```

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

### CoreControllerAfterInstalled Interface

Source: https://fountain.soludian.com/docs/reference/core

Interface for controllers that need to perform actions after installation is complete. Primarily used for testing or auto-running tasks.

```go
type CoreControllerAfterInstalled interface {
    // For test or auto run
    AfterInstalledDone()
}

```

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

### Get Validator Instance

Source: https://fountain.soludian.com/docs/reference/libs/validator

Retrieve a singleton instance of the Validator.

```go
func GetValidator() *Validator
```

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

### Get Server Name

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fgrpc

Retrieves the configured name of the server.

```go
func (s *Server) GetName() string
```

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

### WithConnectionReceiveWindow Option

Source: https://fountain.soludian.com/docs/reference/clients/fquic_client

Sets the initial and maximum connection receive window sizes. Adjust these to control flow control behavior.

```go
func WithConnectionReceiveWindow(initial, max uint64) Option
```

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

### Get Server Address

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fgrpc

Retrieves the network address of the server.

```go
func (s *Server) GetAddress() string
```

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

### Get Connection Manager

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Retrieves the connection manager for the server.

```go
func (s *Server) GetConnectionManager() *connect.ConnectionManager

```

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

### Initialize Progress Bar with Default Settings

Source: https://fountain.soludian.com/docs/reference/ftkit/progress_bar

Create a progress bar using the Default function, which provides recommended settings. This example iterates and adds progress over a short period.

```go
bar := Default(100)
for i := 0; i < 50; i++ {
	bar.Add(1)
	time.Sleep(10 * time.Millisecond)
}
```

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

### Get Remote Name

Source: https://fountain.soludian.com/docs/reference/clients/ftcp_client

Retrieves the name of the remote peer.

```go
func (c *Client) GetRemoteName() string
```

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

### WithConfig

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Creates a new QUIC server instance with a provided configuration object.

```APIDOC
## func WithConfig

### Description
Creates a new QUIC server instance with provided configuration.

### Signature
```go
func WithConfig(c *config) runnable.AppInstance
```
```

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

### FJob.Job

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fjob

Creates a new FJob with a given name and a start function.

```APIDOC
## Job

### Description
Creates a new FJob with a given name and a start function.

### Function Signature
```go
func Job(name string, startFunc func(Context) error) FJob
```
```

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

### Controller Registration with sync.Once

Source: https://fountain.soludian.com/docs/service/controllers

Demonstrates the standard pattern for registering a controller as a singleton using sync.Once to ensure safe, repeatable initialization. The init() function calls RegisterCoreController.

```go
var (
    once     sync.Once
    instance *OrdersController
)

func GetOrdersControllerInstance() *OrdersController {
    once.Do(func() { instance = &OrdersController{} })
    return instance
}

func init() {
    f_core.RegisterCoreController(GetOrdersControllerInstance())
}
```

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

### InstallFountainInstances

Source: https://fountain.soludian.com/docs/reference/libs/sd/fconsul

Installs Consul client instances using configuration defined in a key:array format. This function will attempt to initialize instances even if the configuration is in key:value format.

```APIDOC
## InstallFountainInstances

### Description

Installs Consul client instances using configuration defined in a key:array format. This function will attempt to initialize instances even if the configuration is in key:value format.

### Usage

```yaml
config.yaml:

fconsul:
  - name: default_name
    ...
```

```go
fconsul.InstallFountainInstances()

fconsul.WithConfigKey("fconsul").InstallFountainInstances()
```
```

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

### Client.PingLoop

Source: https://fountain.soludian.com/docs/reference/clients/fudp_client

Starts the ping loop for the FUDP client to maintain connection.

```APIDOC
## func (c *Client) PingLoop

### Description
Starts the ping loop for the FUDP client to maintain connection.

### Signature
```go
func (c *Client) PingLoop()
```
```

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

### DAO Managers Registration Example

Source: https://fountain.soludian.com/docs/service/dao

Defines constants for backend identifiers and demonstrates the `init()` function where DAO factories are registered with the central manager.

```go
// biz/dal/dao/managers.go
package dao

const (
    SERVICE_CACHE = "service.cache"
    SERVICE_DB    = "service.db"
    SERVICE_STO   = "service.sto"
)

func init() {
    RegisterDAO(SERVICE_DB, func() any { return mongo_dao.NewOrdersDAO() })
    RegisterDAO(SERVICE_CACHE, func() any { return redis_dao.NewOrdersCache() })
}
```

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

### Get Server Listener

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fgrpc

Retrieves the network listener information for the server.

```go
func (s *Server) GetListener() net.Listener
```

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

### Get Server Config

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fgrpc

Retrieves the configuration object associated with the server.

```go
func (s *Server) GetConfig() *config
```

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

### Configure Client Callback Instance

Source: https://fountain.soludian.com/docs/reference/clients/ftcp_client

Use this option to provide a specific instance for client callbacks.

```go
func WithClientCallbackInstance(instance ClientCallBack) lib_3rd.Option[Config]
```

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

### Get Server Histogram Metrics

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Retrieves the metrics histogram for the server.

```go
func (s *Server) Histogram() metrics.Histogram

```

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

### Get Message Controller

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Retrieves the message controller used by the server.

```go
func (s *Server) GetMessageCodec() *codec.MessageController

```

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

### Client Constructors

Source: https://fountain.soludian.com/docs/reference/clients/fquic_client

Provides functions to create and configure a QUIC client instance. These include creating a new client with default settings, installing a client with specific options, or initializing a client using a configuration key or object.

```APIDOC
## Client Constructors

### GetFountainInstance

```go
func GetFountainInstance(opts ...Option) *Client
```

GetFountainInstance is an alias for InstallFountainInstance for compatibility.

### InstallFountainInstance

```go
func InstallFountainInstance(opts ...Option) *Client
```

InstallFountainInstance creates and configures a QUIC client.

### New

```go
func New() *Client
```

New creates a new QUIC client with default configuration.

### NewClient

```go
func NewClient(c *config) *Client
```

NewClient creates a new QUIC client with the given configuration.

### WithConfig

```go
func WithConfig(c *config) *Client
```

WithConfig creates a new QUIC client with provided configuration.

### WithConfigKey

```go
func WithConfigKey(configKey string) *Client
```

WithConfigKey creates a new QUIC client with configuration from config key.
```

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

### Get Server Counter Metrics

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Retrieves the metrics counter for the server.

```go
func (s *Server) Counter() metrics.Counter

```

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

### Get Current Connection

Source: https://fountain.soludian.com/docs/reference/clients/ftcp_client

Retrieves the current active connection object.

```go
func (c *Client) GetConnection() *connect.Connection
```

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

### Get Fountain manager variable

Source: https://fountain.soludian.com/docs/reference/libs/brokers/fmqtt

Provides access to the Fountain manager.

```go
var GetFountainManager = Lib.GetFountainManager

```

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

### Get Fountain Manager Variable

Source: https://fountain.soludian.com/docs/reference/clients/fgrpc_client

Provides access to the Fountain manager.

```go
var GetFountainManager = Lib.GetFountainManager
```

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

### WithConfig Option Function

Source: https://fountain.soludian.com/docs/reference/clients/fquic_client

Creates a new QUIC client using a provided configuration object.

```go
func WithConfig(c *config) *Client

```

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

### Job Function

Source: https://fountain.soludian.com/docs/reference/libs/ftasker/fjob

Creates a new FJob with a given name and a start function.

```go
func Job(name string, startFunc func(Context) error) FJob
```

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

### Example Configuration File

Source: https://fountain.soludian.com/docs/guide/getting-started

This YAML file demonstrates the structure for configuring various Fountain components, including environment settings, HTTP server parameters, tracing, and crypto algorithms. Settings can be overridden by environment variables with the FOUNTAIN_ prefix.

```yaml
env:
  log_print_level: 5
  log_file_level: 5
  
server.fhttp:
  addr: ":9007"
  enable_csrf: true
  enable_access_interceptor: true
  enable_access_interceptor_req: true
  enable_access_interceptor_res: true
  access_interceptor_req_res_filter: 'hahaha'
  server_read_timeout: 1m
  server_read_header_timeout: 1h
  server_write_timeout: "30m"
  server_http_timeout: "5s"
  metrics_enable: true

trace:
  service_name: "server"

crypto:
  - algorithm: AES-CTR
    key: "1234567890123456"
  - algorithm: AES-CBC
    key: "1234567890123456"

```

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

### StartTimer

Source: https://fountain.soludian.com/docs/reference/clients/fudp_client

Starts the timer for the FUDP client. This function is part of the Client struct.

```APIDOC
## func (*Client) StartTimer

### Description
Starts the timer for the FUDP client.

### Signature
```go
func (c *Client) StartTimer()
```
```

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

### CoreControllerAfterInstalled Interface

Source: https://fountain.soludian.com/docs/reference/core

An optional interface for controllers that need to perform actions after they have been installed.

```APIDOC
## CoreControllerAfterInstalled Interface

### Description
An interface for controllers that need to execute specific logic after their installation is complete. Useful for testing or auto-running setup tasks.

### Interface Definition
```go
type CoreControllerAfterInstalled interface {
    AfterInstalledDone()
}
```

### Methods
* **AfterInstalledDone()**: Method to be called after the controller has been fully installed.
```

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

### ServerInstance Label Method Signature

Source: https://fountain.soludian.com/docs/reference/runnable

Method signature for getting the label of a ServerInstance.

```go
func (si ServerInstance) Label() string
```

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

### Get Local Address

Source: https://fountain.soludian.com/docs/reference/libs/fnet/fquic

Retrieves the network address on which the QUIC server is listening.

```go
func (s *Server) GetLocalAddr() net.Addr
```
Tokens:
Raw