mirror of https://github.com/waku-org/nwaku.git
104 lines
2.9 KiB
Nim
104 lines
2.9 KiB
Nim
when (NimMajor, NimMinor) < (1, 4):
|
|
{.push raises: [Defect].}
|
|
else:
|
|
{.push raises: [].}
|
|
|
|
|
|
import
|
|
std/[tables, typetraits, options, os],
|
|
serialization/object_serialization,
|
|
serialization/errors
|
|
import
|
|
./utils
|
|
|
|
|
|
type
|
|
EnvvarReader* = object
|
|
prefix: string
|
|
key: seq[string]
|
|
|
|
EnvvarError* = object of SerializationError
|
|
|
|
EnvvarReaderError* = object of EnvvarError
|
|
|
|
GenericEnvvarReaderError* = object of EnvvarReaderError
|
|
deserializedField*: string
|
|
innerException*: ref CatchableError
|
|
|
|
|
|
proc handleReadException*(r: EnvvarReader,
|
|
Record: type,
|
|
fieldName: string,
|
|
field: auto,
|
|
err: ref CatchableError) {.raises: [GenericEnvvarReaderError].} =
|
|
var ex = new GenericEnvvarReaderError
|
|
ex.deserializedField = fieldName
|
|
ex.innerException = err
|
|
raise ex
|
|
|
|
proc init*(T: type EnvvarReader, prefix: string): T =
|
|
result.prefix = prefix
|
|
|
|
proc readValue*[T](r: var EnvvarReader, value: var T) {.raises: [SerializationError].} =
|
|
mixin readValue
|
|
|
|
when T is string:
|
|
let key = constructKey(r.prefix, r.key)
|
|
value = os.getEnv(key)
|
|
|
|
elif T is (SomePrimitives or range):
|
|
let key = constructKey(r.prefix, r.key)
|
|
try:
|
|
getValue(key, value)
|
|
except ValueError:
|
|
raise newException(SerializationError,
|
|
"Couldn't getValue SomePrimitives: " & getCurrentExceptionMsg())
|
|
|
|
elif T is Option:
|
|
template getUnderlyingType[T](_: Option[T]): untyped = T
|
|
let key = constructKey(r.prefix, r.key)
|
|
if os.existsEnv(key):
|
|
type uType = getUnderlyingType(value)
|
|
when uType is string:
|
|
value = some(os.getEnv(key))
|
|
else:
|
|
try:
|
|
value = some(r.readValue(uType))
|
|
except ValueError, IOError:
|
|
raise newException(SerializationError,
|
|
"Couldn't read Option value: " & getCurrentExceptionMsg())
|
|
|
|
elif T is (seq or array):
|
|
when uTypeIsPrimitives(T):
|
|
let key = constructKey(r.prefix, r.key)
|
|
getValue(key, value)
|
|
|
|
else:
|
|
let key = r.key[^1]
|
|
for i in 0..<value.len:
|
|
r.key[^1] = key & $i
|
|
r.readValue(value[i])
|
|
|
|
elif T is (object or tuple):
|
|
type T = type(value)
|
|
when T.totalSerializedFields > 0:
|
|
let fields = T.fieldReadersTable(EnvvarReader)
|
|
var expectedFieldPos = 0
|
|
r.key.add ""
|
|
value.enumInstanceSerializedFields(fieldName, field):
|
|
when T is tuple:
|
|
r.key[^1] = $expectedFieldPos
|
|
var reader = fields[][expectedFieldPos].reader
|
|
expectedFieldPos += 1
|
|
else:
|
|
r.key[^1] = fieldName
|
|
var reader = findFieldReader(fields[], fieldName, expectedFieldPos)
|
|
|
|
if reader != nil:
|
|
reader(value, r)
|
|
discard r.key.pop()
|
|
|
|
else:
|
|
const typeName = typetraits.name(T)
|
|
{.fatal: "Failed to convert from Envvar an unsupported type: " & typeName.}
|