Pelican Wings

Wings is the server control plane for Pelican. It is designed for high performance and security in gaming environments. It provides two primary interfaces for interacting with server instances:

1. HTTP API: Allows direct interfacing with running server instances to manage the server lifecycle, fetch logs, and generate backups.
2. Built-in SFTP Server: Enables file access using the same credentials used for the Pelican Panel, removing the need for Pelican-specific dependencies for file management.

If you are developing or want to build Wings manually on macOS, you can use the standard Go build command or the provided Makefile targets.

Native build

go build -o wings wings.go

Using Makefile

make build-darwin

The Server struct is the central high-level definition for a server instance controlled by Wings. It acts as a coordinator between several subsystems:

• Configuration: Managed via Configuration, containing build settings, environment variables, and startup commands.
• Environment: Managed via environment.ProcessEnvironment, which handles the actual process lifecycle, state tracking, and log reading.
• Filesystem: Accessed via Filesystem(), providing access to the server's isolated data directory.
• Remote Client: A remote.Client used to push state changes (like PushServerStateChange) and fetch configurations from the Panel.
• Lifecycle State: Tracks whether the server is installing, transferring, or restoring using atomic booleans to prevent concurrent operations.

To provide the Panel with the necessary data to display resource utilization and current state, use ToAPIResponse(). This returns an APIResponse struct containing:

• State: The current process state.
• IsSuspended: Whether the server is suspended.
• Utilization: Current resource usage (CPU, RAM, etc.).
• Configuration: The server's configuration settings.

// response is used to send data back to the Panel
response := server.ToAPIResponse()

Starts the SFTP server by:

1. Checking for or generating an ED25519 private key at the path returned by PrivateKeyPath().
2. Configuring SSH server settings (Key exchanges, Ciphers, and MACs).
3. Setting up PasswordCallback and PublicKeyCallback to validate credentials via the Pelican API.
4. Opening a TCP listener on the configured Listen address.
5. Entering a loop to accept and handle inbound connections concurrently.

func (c *SFTPServer) Run() error

Processes a single net.Conn by performing the SSH handshake. It validates that the requested channel is a session and specifically the sftp subsystem. If the connection is authenticated, it identifies the target server instance using the uuid extension provided during authentication and spawns a goroutine to Handle the channel.

func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) error

Initializes an SFTPServer using the provided *server.Manager. It pulls default settings (Base path, Read-only status, and Listen address) from the global system configuration (config.Get().System).

func New(m *server.Manager) *SFTPServer

To create a new managed server instance, use the New function. This initializes the server with a background context, default configuration values, and necessary synchronization primitives (like power locks and sink pools). You must provide a remote.Client which is used for communicating with the Pelican Panel.

Note that New sets up the initial state as environment.ProcessOfflineState.

import "github.com/pelican/wings/server"

// client is an implementation of remote.Client
server, err := server.New(client)
if err != nil {
    // handle error
}

Use these methods to retrieve the unique identifiers for a server instance:

• ID(): Returns the UUID of the server instance.
• PID(): Returns the Panel Database ID (DBID) for the server instance.

uuid := server.ID()
dbID := server.PID()