🥮 mooncakes.io
    Sign in

    moonbitstack/moonzero/conf does not have a README file

    ConfigError

    source
    pub(all) suberror ConfigError {
      ConfigError(String)
    }

    A config-loading failure (← go-zero's conf.Load errors): malformed JSON or YAML, a non-mapping root, a field of the wrong type, a required field with no value, or a value outside its options=/range= constraint, with a human-readable reason.

    Conf

    source
    pub struct Conf {
      root : Map[String, Json]
    }

    A loaded config document (← go-zero's conf.Load): a parsed mapping read through canonical keys and dotted paths, with the ,env=NAME override and the default= / options= / range= constraints go-zero spells as struct tags.

    A field that is absent and has no default is an error, and so is a value that violates its options= or range= constraint — a bad value never degrades into the default.

    Conf::at

    source
    fn Conf::at(self : Conf, path : String) -> Json?

    The value at a dotted path, or None if any segment is missing or a non-mapping is walked into.

    Conf::bool

    source
    fn Conf::bool(self : Conf, path : String, default? : Bool, env? : String, also? : Array[String]) -> Bool raise ConfigError

    Read a Bool field, honouring env= and default=. true/false spelled as a string decode too, which is how an env override arrives.

    Conf::int

    source
    fn Conf::int(self : Conf, path : String, default? : Int, range? : String, env? : String, also? : Array[String]) -> Int raise ConfigError

    Read an Int field, honouring env=, default= and range=. A fractional value is truncated toward zero after the range check.

    Conf::int64

    source
    fn Conf::int64(self : Conf, path : String, default? : Int64, range? : String, env? : String, also? : Array[String]) -> Int64 raise ConfigError

    Read an Int64 field, honouring env=, default= and range=.

    Conf::list

    source
    fn Conf::list(self : Conf, path : String) -> Array[Conf] raise ConfigError

    The list of sub-documents at path — the shape a []Struct config field takes, each element read back through the same constraint-checked accessors. An absent path is an empty list; a non-list, or a list holding anything but mappings, is an error.

    Conf::of_json

    source
    fn Conf::of_json(src : String) -> Conf raise ConfigError

    Load a document from JSON. Raises ConfigError on malformed JSON or a non-object root.

    Conf::of_yaml

    source
    fn Conf::of_yaml(src : String) -> Conf raise ConfigError

    Load a document from the YAML go-zero ships as etc/*.yaml. Raises ConfigError on malformed YAML or a non-mapping root.

    Conf::string

    source
    fn Conf::string(self : Conf, path : String, default? : String, options? : Array[String], env? : String, also? : Array[String]) -> String raise ConfigError

    Read a string field, honouring env=, default= and options=.

    Conf::strings

    source
    fn Conf::strings(self : Conf, path : String, default? : Array[String], env? : String, also? : Array[String]) -> Array[String] raise ConfigError

    Read a string-list field, honouring env= and default=. An env override is comma-separated, since a shell variable carries one string.

    MiddlewaresConf

    source
    pub(all) struct MiddlewaresConf {
      trace : Bool
      log : Bool
      prometheus : Bool
      max_conns : Bool
      breaker : Bool
      shedding : Bool
      timeout : Bool
      recover : Bool
      metrics : Bool
      max_bytes : Bool
      gunzip : Bool
    } derive(Eq, 
    Debug    )

    Which of go-zero's built-in layers the engine installs (← MiddlewaresConf). Every flag defaults to true, so an etc/*.yaml that says nothing about middleware still gets the whole chain.

    MiddlewaresConf::equal

    source

    MiddlewaresConf::new

    source
    fn MiddlewaresConf::new(trace? : Bool, log? : Bool, prometheus? : Bool, max_conns? : Bool, breaker? : Bool, shedding? : Bool, timeout? : Bool, recover? : Bool, metrics? : Bool, max_bytes? : Bool, gunzip? : Bool) -> MiddlewaresConf

    The full chain, which is what go-zero defaults to.

    MiddlewaresConf::not_equal

    source
    fn MiddlewaresConf::not_equal(x : MiddlewaresConf, y : MiddlewaresConf) -> Bool

    MiddlewaresConf::to_repr

    source

    PrivateKeyConf

    source
    pub(all) struct PrivateKeyConf {
      fingerprint : String
      key_file : String
    } derive(Eq, 
    Debug    )

    One signing key the request-signature check would verify against (← rest.PrivateKeyConf).

    PrivateKeyConf::equal

    source

    PrivateKeyConf::not_equal

    source
    fn PrivateKeyConf::not_equal(x : PrivateKeyConf, y : PrivateKeyConf) -> Bool

    PrivateKeyConf::to_repr

    source

    RestConf

    source
    pub(all) struct RestConf {
      service : ServiceConf
      cert_file : String
      key_file : String
      verbose : Bool
      max_conns : Int
      max_bytes : Int
      cpu_threshold : Int64
      signature : SignatureConf
      middlewares : MiddlewaresConf
      trace_ignore_paths : Array[String]
    }

    A REST service's configuration (← go-zero's rest.RestConf), embedding ServiceConf the way go-zero's does. The name, bind address and request timeout live on that embedded config — host(), port() and timeout_ms() read them — and everything else here is RestConf's own.

    max_bytes is an Int where go-zero uses int64: it is compared against a request's Content-Length, and its own range= tag caps it at 32 MiB.

    RestConf::from_json

    source
    fn RestConf::from_json(src : String) -> RestConf raise ConfigError

    Load a RestConf from a JSON config string, with the same semantics as from_yaml.

    RestConf::from_yaml

    source
    fn RestConf::from_yaml(src : String) -> RestConf raise ConfigError

    Load a RestConf from the YAML go-zero ships as etc/*.yaml. Keys are matched canonically, MOONZERO_* env variables override the file, and a value outside its options=/range= constraint is an error.

    Name and Port carry no default, exactly as in go-zero: a rest service that does not say who it is or where to listen fails to load.

    RestConf::host

    source
    fn RestConf::host(self : RestConf) -> String

    The address the service binds.

    RestConf::new

    source
    fn RestConf::new(service? : ServiceConf, cert_file? : String, key_file? : String, verbose? : Bool, max_conns? : Int, max_bytes? : Int, cpu_threshold? : Int64, signature? : SignatureConf, middlewares? : MiddlewaresConf, trace_ignore_paths? : Array[String]) -> RestConf

    A REST config with go-zero's defaults: no TLS, not verbose, 10000 connections, a 1 MiB body cap, a 90% CPU shed threshold, and the full middleware chain.

    RestConf::port

    source
    fn RestConf::port(self : RestConf) -> Int

    The port the service binds.

    RestConf::timeout_ms

    source
    fn RestConf::timeout_ms(self : RestConf) -> Int

    The per-request timeout budget in milliseconds; 0 disables it.

    RestConf::tls

    source
    fn RestConf::tls(self : RestConf) -> Bool

    Whether TLS is configured — go-zero serves HTTPS once both files are named.

    RpcServerConf

    source
    pub(all) struct RpcServerConf {
      name : String
      host : String
      port : Int
      timeout_ms : Int
    } derive(Eq, 
    Debug    , 
    FromJson    )

    zRPC server configuration (← go-zero's zrpc.RpcServerConf): the service name, the address it listens on, and a per-call timeout in milliseconds (0 disables it). The registry/etcd fields of go-zero's conf are modelled by the separate discovery layer; this is the transport-facing core.

    RpcServerConf::equal

    source

    RpcServerConf::from_json

    source
    fn RpcServerConf::from_json(src : String) -> RpcServerConf raise ConfigError

    Load an RpcServerConf from a JSON config string, filling omitted fields from the new() defaults — the lenient loader matching go-zero's ,optional/,default= config tags. Keys are matched canonically, so go-zero's Name/Host/Port/Timeout load as readily as moonzero's own timeout_ms.

    RpcServerConf::from_yaml

    source
    fn RpcServerConf::from_yaml(src : String) -> RpcServerConf raise ConfigError

    Load an RpcServerConf from a YAML config string (self-built yaml_parse), with the same default-filling semantics as from_json.

    RpcServerConf::new

    source
    fn RpcServerConf::new(name? : String, host? : String, port? : Int, timeout_ms? : Int) -> RpcServerConf

    Build an RPC server config with go-zero-style defaults (0.0.0.0:8080, 2s timeout).

    RpcServerConf::not_equal

    source
    fn RpcServerConf::not_equal(x : RpcServerConf, y : RpcServerConf) -> Bool

    RpcServerConf::to_repr

    source

    ServiceConf

    source
    pub(all) struct ServiceConf {
      name : String
      host : String
      port : Int
      timeout_ms : Int
      log_level : 
    LogLevel
    } derive(Eq, 
    FromJson    )

    Service configuration (← go-zero's ServiceConf): the service name, its bind address, a request timeout, and the log level. timeout_ms is the per-request budget in milliseconds; 0 disables the deadline.

    ServiceConf::equal

    source
    fn ServiceConf::equal(ServiceConf, ServiceConf) -> Bool

    ServiceConf::from_json

    source
    fn ServiceConf::from_json(src : String) -> ServiceConf raise ConfigError

    Load a ServiceConf from a JSON config string, applying go-zero-style defaults for every omitted field (an empty {} yields exactly ServiceConf::new()). This is the lenient loader mirroring go-zero's conf.Load with ,optional/,default= struct tags: unlike the strict derived FromJson — reachable via @json.from_json and requiring every field present — a partial config is filled from the same defaults new() uses.

    Keys are matched canonically, so go-zero's Name/Host/Port/Timeout and moonzero's own timeout_ms/log_level spellings all load.

    Raises ConfigError on malformed JSON, a non-object root, a field of the wrong type, or a log level outside debug|info|error|severe.

    ServiceConf::from_yaml

    source
    fn ServiceConf::from_yaml(src : String) -> ServiceConf raise ConfigError

    Load a ServiceConf from a YAML config string — the format go-zero actually ships (etc/*.yaml) — with the same lenient, default-filling semantics as from_json: an empty document yields exactly ServiceConf::new(), and each omitted field falls back to its new() default. The YAML is parsed by the self-built yaml_parse (block mappings, nesting, sequences, scalars, comments) into a Json object, then decoded by the shared field reader — so JSON and YAML configs agree field-for-field.

    Raises ConfigError on malformed YAML, a non-mapping root, a field of the wrong type, or a log level outside debug|info|error|severe.

    ServiceConf::new

    source
    fn ServiceConf::new(name? : String, host? : String, port? : Int, timeout_ms? : Int, log_level? : 
    LogLevel    ) -> ServiceConf

    Build a config with sensible defaults (0.0.0.0:12000, 3s timeout, info).

    ServiceConf::not_equal

    source
    fn ServiceConf::not_equal(x : ServiceConf, y : ServiceConf) -> Bool

    SignatureConf

    source
    pub(all) struct SignatureConf {
      strict : Bool
      expiry_ms : Int64
      private_keys : Array[PrivateKeyConf]
    } derive(Eq, 
    Debug    )

    Request-signature settings (← rest.SignatureConf): whether an unsigned or badly-signed request is refused outright, how long a signature stays valid, and the keys it is checked against.

    moonzero loads and validates this config — a strict service with no keys is refused at assembly, as go-zero's ErrSignatureConfig does — but ships no content-signature layer to consume it.

    SignatureConf::equal

    source

    SignatureConf::new

    source
    fn SignatureConf::new(strict? : Bool, expiry_ms? : Int64, private_keys? : Array[PrivateKeyConf]) -> SignatureConf

    Signature settings that verify nothing: not strict, go-zero's one-hour expiry, no keys.

    SignatureConf::not_equal

    source
    fn SignatureConf::not_equal(x : SignatureConf, y : SignatureConf) -> Bool

    SignatureConf::to_repr

    source

    canonical_key

    source
    fn canonical_key(key : String) -> String

    go-zero's canonical form for a config key (← the WithCanonicalKeyFunc that conf.Load installs): lowercased, with _ and - dropped. Every lookup compares on this form, so MaxBytes, maxBytes, max_bytes and max-bytes all name one field — which is what lets a genuine go-zero etc/*.yaml, whose keys are all PascalCase, load into a config instead of silently yielding defaults.

    port

    source
    let port : Int

    The default port a moonzero service listens on.

    12000 is the family's number, not go-zero's 8888: every example, every document and every local run in this ecosystem points at the same place, and on a development machine 8888 is somebody else's already.

    rpc_port

    source
    let rpc_port : Int

    The default port the zRPC server listens on.

    gRPC shares 12000 with HTTP wherever one listener carries both, but a moonzero process binds RestEngine and RpcServer separately — two listeners cannot hold one port — so the second takes the next number.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io