services

package module
v0.8.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 21, 2022 License: AGPL-3.0 Imports: 8 Imported by: 0

README

Kiebitz Services

This repository contains Kiebitz's backend services:

  • A storage service that stores encrypted user & operator settings and temporary data.
  • An appointments service that stores encrypted appointment data.

tl;dr

We are showing a quick version here, full details below make sure you installed Golang in a current version >=1.16.

we need a Redis server:
docker run -d -p 6379:6379 redis

simply run

  1. make to install
  2. source .test-setup so tests create/setup necessary data
  3. kiebitz admin keys setup to generate necessary keys will overwrite existing key files
  4. kiebitz run all to run the development services

Then have a look and jump to the APIs

Dependencies

The Kiebitz backend services are written in Golang. Please install a recent version, preferably >=1.16.

If you're running MacOS and run into the readlink: illegal option -- f error, you can resolve it by installing coreutils: brew install coreutils and linking it to your bin: ln -s /usr/local/bin/greadlink /usr/local/bin/readlink. Restart your terminal afterwards.

By default, Kiebitz uses a Redis database to store data. Please make sure a Redis server is available. You can change the connection details in the settings/dev/001_default.yml settings file. The metering services (for statistics) also uses a Redis database by default and can be configured just like the main database. In addition, to generate TLS certificates (which is not always necessary) Kiebitz relies on the openssl CLI.

Installation

To build and install all services into your GOPATH, simply run

make

Basic Setup

Kiebitz needs cryptographic keys and some helper data to function correctly. All of these can be generated using the kiebitz command.

First things first: Kiebitz looks for settings in the path given by the KIEBITZ_SETTINGS environment variable. For development, settings are in the settings/dev subdirectory of the repository. To set up our development environment, we simply run

source .dev-setup

For the commands below we'll assume that KIEBITZ_SETTINGS points to the settings/dev directory.

Cryptographic Keys

Now, we need to generate various cryptographic keys for signing and encryption. To do this, we simply run

kiebitz admin keys setup

Warning: Running this command will overwrite existing key files, potentially rendering all your development data useless, so be careful.

This will generate two files in the Kiebitz settings directory, 002_admin.json and 003_appt.json. The former is only for administration purposes and should remain locked away. The latter is for use with the appointments server.

Optionally, you can encrypt the 002_admin.json file with a passphrase. The passphrase must be present in the KIEBITZ_PASSPHRASE environment variable, and has to be pretsent for the generation of the keys as well as every time the server starts. You can generate an encrypted key file with the -e switch like this:

kiebitz admin keys setup -e

Now we can generate mediator keys. To do this, we simply run

kiebitz admin keys mediator > data/secret-mediator-keys.json

This will create a JSON data structure with all necessary keys for the mediator. Please be aware that the provider keys are just copied from the 002_admin.json file generated before. These keys enable mediators to decrypt provider data.

For the next steps of the setup process we'll need a running backend, so let's start it via

kiebitz --level debug run all

That should start the appointments and storage services. Now we can tell the backend about the newly created mediator keys, which we do via

kiebitz admin mediators upload data/secret-mediator-keys.json

This will sign the public signing and encryption keys of the mediator with the root key and put the signed key material on the backend for publication. That's it! Now we should be able to go to the /mediator URL in the frontend, load our mediator key file and verify providers. Providers should be able to sign up, upload their data for verification and get tokens. Users should also be able to sign up and receive invitations.

ZIP Code Data

ZIP code data helps Kiebitz to estimate distances between zip code areas. There are two files data/distances.json and data/distances-areas.json that need to be uploaded. We can do this via

# upload distances for full ZIP codes (used when matching tokens to providers)
kiebitz admin distances upload data/distances.json
# upload distances for ZIP codes areas (used when filtering appointments for users)
kiebitz admin distances upload data/distances-areas.json

To generate the distances, we can use the make_distances.py and make_area_distances.py scripts from the .scripts folder (normally this is not necessary though):

python3 .scripts/make_distances.py
python3 .scripts/make_area_distances.py

Note: We can test the system without the ZIP code data, but tokens will then only be distributed to matching zip codes.

Signup Codes

We can also upload user & provider codes if we want to restrict who can register on the platform (this requires setting appointments.user_codes_enabled: true and appointments.provider_codes.enabled: true, respectively):

# upload user codes from a file
kiebitz admin codes upload data/secret-user-codes.json
# upload provider codes from a file
kiebitz admin codes upload data/secret-provider-codes.json

To generate codes, we simply run

# generate 10.000 user codes
kiebitz admin codes generate --actor user -n 10000 > data/secret-user-codes.json
# generate 10.000 provider codes
kiebitz admin codes generate --actor provider -n 10000 > data/secret-user-codes.json

Codes are just random 16 byte values, and the actor parameter just tells the backend for which actor the codes should be used.

TLS Certificates

Finally, if we want to run Kiebitz using a self-signed TLS certificate, we simply run

make certs

to generate these certificates, and then enable them by commenting out the tls section in the settings.

Running

Start redis:

docker run -d -p 6379:6379 redis

To run the development services we can then

# run the appointments service
kiebitz run appointments
# ...or run the storage service
kiebitz run storage
# ...or run all services
kiebitz run all
Logging

The logrus module is used for logging. The default log level is info. More verbose log levels are available, namely debug and trace. To run kiebitz at another log leve, simply pass the --level argument. E.g.

kiebitz --level trace run all

APIs

The Kiebitz services can be exposed as a JSON-RPC or REST service (or both). Simply set or remove the jsonrpc or rest section in the storage or appointments section of the settings to enable or disable the api for those servers.

For example, if both API types are enabled, the getAppointmentsByZipCode endpoint with parameters zipCode=10707 and radius=20 can be reached via both of the following queries:

# REST endpoint
curl http://localhost:8888/appointments/zipCode/10707/20
# JSON-RPC endpoint
curl -X POST --header "Content-Type: application/json" http://localhost:8888/jsonrpc --data '{"jsonrpc": "2.0", "method": "getAppointmentsByZipCode", "params": {"zipCode": "10707", "radius": "20"}}'

In general, the REST API is better for caching as it exposes cacheable endpoints via GET requests, while the JSON-RPC API provides a simpler and more natural interface.

Testing

Here's how you can send a request to the storage server via curl (this assumes you have jq installed for parsing of the JSON result):

curl --cacert settings/dev/certs/root.crt --resolve storage-1:9999:127.0.0.1 https://storage-1:9999/jsonrpc --header "Content-Type: application/json; charset=utf-8" --data '{"method": "getSettings", "id": "2", "params": {"key": "az4df7vjunsd6ad"}, "jsonrpc": "2.0"}' 2>/dev/null | jq

To run all Go tests and benchmarks, simply

# run normal tests
make test
# run race-condition tests
make test-races
# run benchmarks
make bench
Load Testing

Careful, the following commands will create massive amounts of fake data via the API client, never run this against the production system, except for initial load testing!

You can simulate providers, appointments and bookings in the backend using the testing benchmark command. The following command will create 1.000 providers with 1.000 appointments with 20 slots each, hence a total of 20.000.000 appointments:

kiebitz testing benchmark --providers 1000 --appointments 1000 --slots 20

This command will use the given settings and connect to a running API server, hence to run it you need to also run the Kiebitz API. Probably you want to use the test settings for this

Development

To auto-generate copyright headers for Golang files, simply run

make copyright

Security

Did you find a security issue you'd like to report? Please contact us at impftermin@inoeg.de. We appreciate if you follow responsible disclosure practices. Please do not create a public Github issue for exploitable vulnerabilities that you've identified. We do not have a formal bug bounty program in place but will try to reward researchers for significant security findings. We also pledge to never take any kind of legal action or retaliate against researchers that disclose security issues in good faith. You may of course disclose issues anonymously as well.

Documentation

Index

Constants

View Source 
const (
	PanicLogLevel = Level(log.PanicLevel)
	FatalLogLevel = Level(log.FatalLevel)
	ErrorLogLevel = Level(log.ErrorLevel)
	WarnLogLevel  = Level(log.WarnLevel)
	InfoLogLevel  = Level(log.InfoLevel)
	DebugLogLevel = Level(log.DebugLevel)
	TraceLogLevel = Level(log.TraceLevel)
)

Variables

View Source 
var Log = Logger{}

Functions

func APIHandlerStruct 

func APIHandlerStruct(handler interface{}) (interface{}, error)

returns a new struct that we can coerce the valid form parameters into

func Key 

func Key(keys []*crypto.Key, name string) *crypto.Key

Types

type ActorKey 

type ActorKey struct {
	ID        []byte `json:"id"`
	Data      string `json:"data"`
	Signature []byte `json:"signature"`
	PublicKey []byte `json:"publicKey"`
	// contains filtered or unexported fields
}

func (*ActorKey) KeyData 

func (a *ActorKey) KeyData() (*ActorKeyData, error)

func (*ActorKey) ProviderKeyData 

func (a *ActorKey) ProviderKeyData() (*ProviderKeyData, error)

type ActorKeyData 

type ActorKeyData struct {
	Encryption []byte `json:"encryption"`
	Signing    []byte `json:"signing"`
}

type AddCodesParams 

type AddCodesParams struct {
	JSON      string     `json:"data" coerce:"name:json"`
	Data      *CodesData `json:"-" coerce:"name:data"`
	Signature []byte     `json:"signature"`
	PublicKey []byte     `json:"publicKey"`
}

type AddMediatorPublicKeysParams 

type AddMediatorPublicKeysParams struct {
	Timestamp     time.Time              `json:"timestamp"`
	SignedKeyData *SignedMediatorKeyData `json:"signedKeyData"`
}

type AddMediatorPublicKeysSignedParams 

type AddMediatorPublicKeysSignedParams struct {
	JSON      string                       `json:"data" coerce:"name:json"`
	Data      *AddMediatorPublicKeysParams `json:"-" coerce:"name:data"`
	Signature []byte                       `json:"signature"`
	PublicKey []byte                       `json:"publicKey"`
}

type AdminSettings 

type AdminSettings struct {
	Signing *SigningSettings `json:"signing,omitempty"`
	Client  *ClientSettings  `json:"client,omitempty"`
}

type AggregatedProviderAppointments 

type AggregatedProviderAppointments struct {
	Provider     *ProviderData            `json:"provider"`
	Appointments []*AppointmentAggregated `json:"appointments"`
}

type Appointment 

type Appointment struct {
	ID         []byte            `json:"id"`
	Duration   int64             `json:"duration"`
	Properties map[string]string `json:"properties"`
	SlotData   []*Slot           `json:"slotData"`
	Timestamp  time.Time         `json:"timestamp"`
	Vaccine    string            `json:"vaccine"`
	PublicKey  []byte            `json:"publicKey"`
}

func MakeAppointment 

func MakeAppointment(timestamp time.Time, slots, duration int64) (*Appointment, error)

func (*Appointment) Sign 

func (k *Appointment) Sign(key *crypto.Key) (*SignedAppointment, error)

type AppointmentAggregated 

type AppointmentAggregated struct {
	ID         []byte            `json:"id"`
	Duration   int64             `json:"duration"`
	Properties map[string]string `json:"properties"`
	SlotN      int               `json:"slotN"`
	Timestamp  time.Time         `json:"timestamp"`
	Vaccine    string            `json:"vaccine"`
}

type AppointmentsSettings 

type AppointmentsSettings struct {
	DataTTLDays               int64                  `json:"data_ttl_days,omitempty"`
	HTTP                      *HTTPServerSettings    `json:"http,omitempty"`
	REST                      *RESTServerSettings    `json:"rest,omitempty"`
	JSONRPC                   *JSONRPCServerSettings `json:"jsonrpc,omitempty"`
	Keys                      []*crypto.Key          `json:"keys,omitempty"`
	Secret                    []byte                 `json:"secret,omitempty"`
	ProviderCodesEnabled      bool                   `json:"provider_codes_enabled,omitempty"`
	UserCodesEnabled          bool                   `json:"user_codes_enabled,omitempty"`
	UserCodesReuseLimit       int64                  `json:"user_codes_reuse_limit"`
	ProviderCodesReuseLimit   int64                  `json:"provider_codes_reuse_limit"`
	ResponseMaxProvider       int64                  `json:"response_max_provider"`
	ResponseMaxAppointment    int64                  `json:"response_max_appointment"`
	ResponseMinNAggregated    int64                  `json:"response_min_n_aggregated"`
	ResponseMaxDaysAggregated int64                  `json:"response_max_days_aggregated"`
	MaxTokensPerUser          int64                  `json:"max_tokens_per_user"`
	Validate                  *ValidateSettings      `json:"validate"`
}

func (*AppointmentsSettings) Key 

func (a *AppointmentsSettings) Key(name string) *crypto.Key

type BaseDatabase 

type BaseDatabase struct {
}

type BookAppointmentParams 

type BookAppointmentParams struct {
	ProviderID      []byte                    `json:"providerID"`
	ID              []byte                    `json:"id"`
	EncryptedData   *crypto.ECDHEncryptedData `json:"encryptedData"`
	SignedTokenData *SignedTokenData          `json:"signedTokenData"`
	Timestamp       time.Time                 `json:"timestamp"`
}

type BookAppointmentSignedParams 

type BookAppointmentSignedParams struct {
	JSON      string                 `json:"data" coerce:"name:json"`
	Data      *BookAppointmentParams `json:"-" coerce:"name:data"`
	Signature []byte                 `json:"signature"`
	PublicKey []byte                 `json:"publicKey"`
}

type Booking 

type Booking struct {
	ID            []byte                    `json:"id"`
	PublicKey     []byte                    `json:"publicKey"`
	Token         []byte                    `json:"token"`
	EncryptedData *crypto.ECDHEncryptedData `json:"encryptedData"`
}

type CancelAppointmentParams 

type CancelAppointmentParams struct {
	Timestamp       time.Time        `json:"timestamp"`
	ProviderID      []byte           `json:"providerID"`
	SignedTokenData *SignedTokenData `json:"signedTokenData"`
	ID              []byte           `json:"id"`
}

type CancelAppointmentSignedParams 

type CancelAppointmentSignedParams struct {
	JSON      string                   `json:"data" coerce:"name:json"`
	Data      *CancelAppointmentParams `json:"-" coerce:"name:data"`
	Signature []byte                   `json:"signature"`
	PublicKey []byte                   `json:"publicKey"`
}

type CheckProviderDataParams 

type CheckProviderDataParams struct {
	Timestamp time.Time `json:"timestamp"`
}

type CheckProviderDataSignedParams 

type CheckProviderDataSignedParams struct {
	JSON      string                   `json:"data" coerce:"name:json"`
	Data      *CheckProviderDataParams `json:"-" coerce:"name:data"`
	Signature []byte                   `json:"signature"`
	PublicKey []byte                   `json:"publicKey"`
}

type ClientSettings 

type ClientSettings struct {
	StorageEndpoint      string `json:"storage_endpoint"`
	AppointmentsEndpoint string `json:"appointments_endpoint"`
}

type CodesData 

type CodesData struct {
	Actor     string    `json:"actor"`
	Timestamp time.Time `json:"timestamp"`
	Codes     [][]byte  `json:"codes"`
}

type CommandsDefinition 

type CommandsDefinition struct {
	Name        string        `json:"name"`
	Description string        `json:"description"`
	Maker       CommandsMaker `json:"-"`
}

type CommandsDefinitions 

type CommandsDefinitions []CommandsDefinition

type CommandsMaker 

type CommandsMaker func(settings *Settings) ([]cli.Command, error)

type ConfirmProviderParams 

type ConfirmProviderParams struct {
	Timestamp             time.Time              `json:"timestamp"`
	PublicProviderData    *SignedProviderData    `json:"publicProviderData"`
	ConfirmedProviderData *ConfirmedProviderData `json:"confirmedProviderData"`
	SignedKeyData         *SignedProviderKeyData `json:"signedKeyData"`
}

this data is accessible to the provider, nothing "secret" should be stored here...

type ConfirmProviderSignedParams 

type ConfirmProviderSignedParams struct {
	JSON      string                 `json:"data" coerce:"name:json"`
	Data      *ConfirmProviderParams `json:"-" coerce:"name:data"`
	Signature []byte                 `json:"signature"`
	PublicKey []byte                 `json:"publicKey"`
}

type ConfirmedProviderData 

type ConfirmedProviderData struct {
	JSON      string                    `json:"data" coerce:"name:json"`
	Data      *crypto.ECDHEncryptedData `json:"-" coerce:"name:data"`
	Signature []byte                    `json:"signature"`
	PublicKey []byte                    `json:"publicKey"`
}

type Context 

type Context interface {
	Params() map[string]interface{}
	Result(data interface{}) Response
	Error(code int, message string, data interface{}) Response
	InternalError() Response
	InvalidParams(err error) Response
	IsInternalError(err Response) bool
	MethodNotFound() Response
	NotFound() Response
	Acknowledge() Response
	Nil() Response
}

type CorsSettings 

type CorsSettings struct {
	AllowedHeaders []string `json:"allowed_headers"`
	AllowedHosts   []string `json:"allowed_hosts"`
	AllowedMethods []string `json:"allowed_methods"`
}

type Database 

type Database interface {
	Close() error
	Open() error
	Reset() error
	Lock(key string, lockWait, ttl time.Duration) (Lock, error)
	LockDefault(key string) (Lock, error)

	DatabaseOps
}

A database can deliver and accept message

type DatabaseDefinition 

type DatabaseDefinition struct {
	Name              string            `json:"name"`
	Description       string            `json:"description"`
	Maker             DatabaseMaker     `json:"-"`
	SettingsValidator SettingsValidator `json:"-"`
}

type DatabaseDefinitions 

type DatabaseDefinitions map[string]DatabaseDefinition

type DatabaseMaker 

type DatabaseMaker func(settings interface{}) (Database, error)

type DatabaseOps 

type DatabaseOps interface {
	Expire(table string, key []byte, ttl time.Duration) error
	ExpireAt(table string, key []byte, tm time.Time) error
	Integer(table string, key []byte) Integer
	List(table string, key []byte) List
	Map(table string, key []byte) Map
	Set(table string, key []byte) Set
	SortedSet(table string, key []byte) SortedSet
	Value(table string, key []byte) Value
}

type DatabaseSettings 

type DatabaseSettings struct {
	Type     string `json:"type"`
	Settings interface{}
}

type Definitions 

type Definitions struct {
	CommandsDefinitions
	DatabaseDefinitions
	MeterDefinitions
}

func MergeDefinitions 

func MergeDefinitions(a, b Definitions) Definitions

func (Definitions) Marshal 

func (d Definitions) Marshal() map[string]interface{}

func (Definitions) MarshalJSON 

func (d Definitions) MarshalJSON() ([]byte, error)

We perform JSON marshalling manually to gain more flexibility...

type DeleteSettingsParams 

type DeleteSettingsParams struct {
	ID []byte `json:"id"`
}

type Distance 

type Distance struct {
	From     string  `json:"from"`
	To       string  `json:"to"`
	Distance float64 `json:"distance"`
}

type GetAppointmentParams 

type GetAppointmentParams struct {
	ProviderID []byte `json:"providerID"`
	ID         []byte `json:"id"`
}

type GetAppointmentsAggregatedParams 

type GetAppointmentsAggregatedParams struct {
	Date    time.Time `json:"date"`
	ZipFrom string    `json:"zipFrom"`
	ZipTo   string    `json:"zipTo"`
}

type GetAppointmentsByZipCodeParams 

type GetAppointmentsByZipCodeParams struct {
	Radius  int64     `json:"radius"`
	ZipCode string    `json:"zipCode"`
	From    time.Time `json:"from"`
	To      time.Time `json:"to"`
}

type GetConfigurablesParams 

type GetConfigurablesParams struct {
}

getConfigurables

type GetKeysParams 

type GetKeysParams struct {
}

getKeys

type GetProviderAppointmentsByPropertyParams 

type GetProviderAppointmentsByPropertyParams struct {
	Key       string    `json:"key"`
	Value     string    `json:"value"`
	Timestamp time.Time `json:"timestamp"`
}

type GetProviderAppointmentsByPropertySignedParams 

type GetProviderAppointmentsByPropertySignedParams struct {
	JSON      string                                   `json:"data" coerce:"name:json"`
	Data      *GetProviderAppointmentsByPropertyParams `json:"-" coerce:"name:data"`
	Signature []byte                                   `json:"signature"`
	PublicKey []byte                                   `json:"publicKey"`
}

type GetProviderAppointmentsParams 

type GetProviderAppointmentsParams struct {
	Timestamp    time.Time  `json:"timestamp"`
	From         time.Time  `json:"from"`
	To           time.Time  `json:"to"`
	UpdatedSince *time.Time `json:"updatedSince"`
}

type GetProviderAppointmentsSignedParams 

type GetProviderAppointmentsSignedParams struct {
	JSON      string                         `json:"data" coerce:"name:json"`
	Data      *GetProviderAppointmentsParams `json:"-" coerce:"name:data"`
	Signature []byte                         `json:"signature"`
	PublicKey []byte                         `json:"publicKey"`
}

type GetProviderDataParams 

type GetProviderDataParams struct {
	Timestamp  time.Time `json:"timestamp"`
	ProviderID []byte    `json:"providerID"`
}

type GetProviderDataSignedParams 

type GetProviderDataSignedParams struct {
	JSON      string                 `json:"data" coerce:"name:json"`
	Data      *GetProviderDataParams `json:"-" coerce:"name:data"`
	Signature []byte                 `json:"signature"`
	PublicKey []byte                 `json:"publicKey"`
}

type GetProviderResult 

type GetProviderResult struct {
	UnverifiedData *RawProviderData `json:"unverifiedData"`
	VerifiedData   *RawProviderData `json:"verifiedData"`
}

type GetProvidersByZipCodeParams 

type GetProvidersByZipCodeParams struct {
	ZipFrom string `json:"zipFrom"`
	ZipTo   string `json:"zipTo"`
}

type GetProvidersDataParams added in v0.8.1 

type GetProvidersDataParams struct {
	Timestamp time.Time `json:"timestamp"`
	Limit     int64     `json:"limit"`
}

type GetProvidersDataSignedParams added in v0.8.1 

type GetProvidersDataSignedParams struct {
	JSON      string                  `json:"data" coerce:"name:json"`
	Data      *GetProvidersDataParams `json:"-" coerce:"name:data"`
	Signature []byte                  `json:"signature"`
	PublicKey []byte                  `json:"publicKey"`
}

type GetSettingsParams 

type GetSettingsParams struct {
	ID []byte `json:"id"`
}

type GetStatsParams 

type GetStatsParams struct {
	ID     string                 `json:"id"`
	Type   string                 `json:"type"`
	Filter map[string]interface{} `json:"filter"`
	Metric string                 `json:"metric"`
	Name   string                 `json:"name"`
	From   *time.Time             `json:"from"` // optional
	To     *time.Time             `json:"to"`   // optional
	N      *int64                 `json:"n"`    // optional
}

type GetTokenParams 

type GetTokenParams struct {
	Hash      []byte `json:"hash"`
	Code      []byte `json:"code"`
	PublicKey []byte `json:"publicKey"`
}

type HTTPServerSettings 

type HTTPServerSettings struct {
	TLS           *TLSSettings `json:"tls,omitempty"`
	BindAddress   string       `json:"bind_address"`
	TCPRateLimits []*RateLimit `json:"tcp_rate_limits"`
}

type Integer 

type Integer interface {
	Object
	Set(value int64, ttl time.Duration) error
	IncrBy(int64) (int64, error)
	DecrBy(int64) (int64, error)
	Get() (int64, error)
	Del() error
}

type JSONRPCServerSettings 

type JSONRPCServerSettings struct {
	Cors *CorsSettings       `json:"cors,omitempty"`
	HTTP *HTTPServerSettings `json:"http,omitempty"`
}

Settings for the JSON-RPC server

type KeyChain 

type KeyChain struct {
	Provider *ActorKey `json:"provider"`
	Mediator *ActorKey `json:"mediator"`
}

type KeyLists 

type KeyLists struct {
	Providers []*ActorKey `json:"providers"`
	Mediators []*ActorKey `json:"mediators"`
}

type Keys 

type Keys struct {
	ProviderData []byte `json:"providerData"`
	RootKey      []byte `json:"rootKey"`
	TokenKey     []byte `json:"tokenKey"`
}

type Level 

type Level log.Level

func ParseLevel 

func ParseLevel(level string) (Level, error)

type List 

type List interface {
	Object
}

type Lock 

type Lock interface {
	Release() error
}

type Logger 

type Logger struct {
}

func (*Logger) Debug 

func (l *Logger) Debug(args ...interface{})

func (*Logger) Debugf 

func (l *Logger) Debugf(format string, args ...interface{})

func (*Logger) Error 

func (l *Logger) Error(args ...interface{})

func (*Logger) Errorf 

func (l *Logger) Errorf(format string, args ...interface{})

func (*Logger) Fatal 

func (l *Logger) Fatal(args ...interface{})

func (*Logger) Info 

func (l *Logger) Info(args ...interface{})

func (*Logger) Infof 

func (l *Logger) Infof(format string, args ...interface{})

func (*Logger) SetLevel 

func (l *Logger) SetLevel(level Level)

func (*Logger) Trace 

func (l *Logger) Trace(args ...interface{})

func (*Logger) Tracef 

func (l *Logger) Tracef(format string, args ...interface{})

func (*Logger) Warning 

func (l *Logger) Warning(args ...interface{})

func (*Logger) Warningf 

func (l *Logger) Warningf(format string, args ...interface{})

type MailSettings 

type MailSettings struct {
	SmtpHost     string `json:"smtp_host"`
	SmtpPort     int64  `json:"smtp_port"`
	SmtpUser     string `json:"smtp_user"`
	SmtpPassword string `json:"smtp_password"`
	Sender       string `json:"sender"`
	MailSubject  string `json:"mail_subject"`
	MailTemplate string `json:"mail_template"`
	MailDelay    int64  `json:"mail_delay"`
}

type Map 

type Map interface {
	GetAll() (map[string][]byte, error)
	Get(key []byte) ([]byte, error)
	Del(key []byte) error
	Set(key []byte, value []byte) error
	Object
}

type MediatorKeyData 

type MediatorKeyData struct {
	Signing    []byte `json:"signing"`
	Encryption []byte `json:"encryption"`
}

func (*MediatorKeyData) Sign 

func (k *MediatorKeyData) Sign(key *crypto.Key) (*SignedMediatorKeyData, error)

type Meter 

type Meter interface {
	// Add the given value to the metric
	Add(id string, name string, data map[string]string, tw TimeWindow, value int64) error
	// Add the given value to the metric, but only if the given uid hasn't been counted yet
	AddOnce(id string, name string, uid string, data map[string]string, tw TimeWindow, value int64) error
	// Add the maximum value to the metric
	AddMax(id string, name string, uid string, data map[string]string, tw TimeWindow, value int64) error
	// Return the metric and its assigned quota
	Get(id string, name string, data map[string]string, tw TimeWindow) (*Metric, error)
	// Return metrics for a given ID and time interval
	Range(id string, from, to int64, name, twType string) ([]*Metric, error)
	N(id string, to int64, n int64, name, twType string) ([]*Metric, error)
}

type MeterDefinition 

type MeterDefinition struct {
	Name              string            `json:"name"`
	Description       string            `json:"description"`
	Maker             MeterMaker        `json:"-"`
	SettingsValidator SettingsValidator `json:"-"`
}

type MeterDefinitions 

type MeterDefinitions map[string]MeterDefinition

type MeterMaker 

type MeterMaker func(settings interface{}) (Meter, error)

type MeterSettings 

type MeterSettings struct {
	Type     string `json:"type"`
	Settings interface{}
}

type Metric 

type Metric struct {
	Name       string
	TimeWindow TimeWindow
	Value      int64
	Data       map[string]string
}

type MetricSettings 

type MetricSettings struct {
	BindAddress string `json:"bind_address"`
}

type MetricsServer 

type MetricsServer interface {
	Start() error
	Stop() error
}

type Object 

type Object interface {
}

type PriorityToken 

type PriorityToken struct {
	N int64 `json:"n"`
}

func (*PriorityToken) Marshal 

func (p *PriorityToken) Marshal() ([]byte, error)

type ProviderAppointments 

type ProviderAppointments struct {
	Provider     *SignedProviderData  `json:"provider"`
	Appointments []*SignedAppointment `json:"appointments"`
	KeyChain     *KeyChain            `json:"keyChain"`
}

type ProviderData 

type ProviderData struct {
	ID          []byte `json:"id,omitempty"`
	Name        string `json:"name"`
	Street      string `json:"street"`
	City        string `json:"city"`
	ZipCode     string `json:"zipCode"`
	Description string `json:"description"`
	Accessible  bool   `json:"accessible"`
}

func (*ProviderData) Sign 

func (k *ProviderData) Sign(key *crypto.Key) (*SignedProviderData, error)

type ProviderKeyData 

type ProviderKeyData struct {
	Signing    []byte             `json:"signing"`
	Encryption []byte             `json:"encryption"`
	QueueData  *ProviderQueueData `json:"queueData"`
}

func (*ProviderKeyData) Sign 

func (k *ProviderKeyData) Sign(key *crypto.Key) (*SignedProviderKeyData, error)

type ProviderQueueData 

type ProviderQueueData struct {
	ZipCode    string `json:"zipCode"`
	Accessible bool   `json:"accessible"`
}

type PublishAppointmentsParams 

type PublishAppointmentsParams struct {
	Timestamp    time.Time            `json:"timestamp"`
	Appointments []*SignedAppointment `json:"appointments"`
}

type PublishAppointmentsSignedParams 

type PublishAppointmentsSignedParams struct {
	JSON      string                     `json:"data" coerce:"name:json"`
	Data      *PublishAppointmentsParams `json:"-" coerce:"name:data"`
	Signature []byte                     `json:"signature"`
	PublicKey []byte                     `json:"publicKey"`
}

type RESTServerSettings 

type RESTServerSettings struct {
	Cors *CorsSettings       `json:"cors,omitempty"`
	HTTP *HTTPServerSettings `json:"http,omitempty"`
}

Settings for the REST server

type RPCSettings 

type RPCSettings struct {
	BindAddress string `json:"bind_address"`
}

type RateLimit 

type RateLimit struct {
	TimeWindow *TimeWindow `json:"timeWindow"`
	Type       string      `json:"type"`
	Limit      int64       `json:"limit"`
}

type RawProviderData 

type RawProviderData struct {
	ID            []byte                    `json:"id,omitempty"`
	Verified      bool                      `json:"verified,omitempty"`
	Status        string                    `json:"status,omitempty"`
	EncryptedData *crypto.ECDHEncryptedData `json:"encryptedData"`
}

type Request 

type Request interface {
}

type ResetDBParams 

type ResetDBParams struct {
	Timestamp time.Time `json:"timestamp"`
}

type ResetDBSignedParams 

type ResetDBSignedParams struct {
	JSON      string         `json:"data" coerce:"name:json"`
	Data      *ResetDBParams `json:"-" coerce:"name:data"`
	Signature []byte         `json:"signature"`
	PublicKey []byte         `json:"publicKey"`
}

type Response 

type Response interface {
}

func HandleAPICall 

func HandleAPICall(
	handler interface{},
	form *forms.Form,
	validateSettings *ValidateSettings,
	context Context) Response

type Set 

type Set interface {
	Add([]byte) error
	Has([]byte) (bool, error)
	Del(key []byte) error
	Members() ([]*SetEntry, error)
	Object
}

type SetEntry 

type SetEntry struct {
	Data []byte
}

type Settings 

type Settings struct {
	Test         bool                  `json:"test,omitempty"`
	Admin        *AdminSettings        `json:"admin,omitempty"`
	Definitions  *Definitions          `json:"definitions,omitempty"`
	Storage      *StorageSettings      `json:"storage,omitempty"`
	Appointments *AppointmentsSettings `json:"appointments,omitempty"`
	Database     *DatabaseSettings     `json:"database,omitempty"`
	Meter        *MeterSettings        `json:"meter,omitempty"`
	Metrics      *MetricSettings       `json:"metrics,omitempty"`
	DatabaseObj  Database              `json:"-"`
	MeterObj     Meter                 `json:"-"`
	MetricsObj   MetricsServer         `json:"-"`
}

type SettingsValidator 

type SettingsValidator func(settings map[string]interface{}) (interface{}, error)

type SignedAppointment 

type SignedAppointment struct {
	UpdatedAt   time.Time    `json:"updatedAt"`
	Bookings    []*Booking   `json:"bookings"`    // only for providers
	BookedSlots []*Slot      `json:"bookedSlots"` // for users
	JSON        string       `json:"data" coerce:"name:json"`
	Data        *Appointment `json:"-" coerce:"name:data"`
	Signature   []byte       `json:"signature"`
	PublicKey   []byte       `json:"publicKey"`
}

type SignedMediatorKeyData 

type SignedMediatorKeyData struct {
	JSON      string           `json:"data" coerce:"name:json"`
	Data      *MediatorKeyData `json:"-" coerce:"name:data"`
	Signature []byte           `json:"signature"`
	PublicKey []byte           `json:"publicKey"`
}

type SignedParams 

type SignedParams struct {
	JSON      string
	Signature []byte
	PublicKey []byte
	Timestamp time.Time
	ExtraData interface{}
}

type SignedProviderData 

type SignedProviderData struct {
	JSON      string        `json:"data" coerce:"name:json"`
	Data      *ProviderData `json:"-" coerce:"name:data"`
	Signature []byte        `json:"signature"`
	PublicKey []byte        `json:"publicKey"`
	ID        []byte        `json:"id"`
}

type SignedProviderKeyData 

type SignedProviderKeyData struct {
	JSON      string           `json:"data" coerce:"name:json"`
	Data      *ProviderKeyData `json:"-" coerce:"name:data"`
	Signature []byte           `json:"signature"`
	PublicKey []byte           `json:"publicKey"`
}

type SignedTokenData 

type SignedTokenData struct {
	JSON      string     `json:"data" coerce:"name:json"`
	Data      *TokenData `json:"-" coerce:"name:data"`
	Signature []byte     `json:"signature"`
	PublicKey []byte     `json:"publicKey"`
}

type SigningSettings 

type SigningSettings struct {
	Keys []*crypto.Key `json:"keys"`
}

func (*SigningSettings) Key 

func (s *SigningSettings) Key(name string) *crypto.Key

type Slot 

type Slot struct {
	ID []byte `json:"id"`
}

type SortedSet 

type SortedSet interface {
	Object
	Del([]byte) (bool, error)
	Add([]byte, int64) error
	Range(int64, int64) ([]*SortedSetEntry, error)
	RangeByScore(int64, int64) ([]*SortedSetEntry, error)
	At(int64) (*SortedSetEntry, error)
	Score([]byte) (int64, error)
	PopMin(int64) ([]*SortedSetEntry, error)
	RemoveRangeByScore(int64, int64) error
}

type SortedSetEntry 

type SortedSetEntry struct {
	Score int64
	Data  []byte
}

type StatsValue 

type StatsValue struct {
	Name  string            `json:"name"`
	From  time.Time         `json:"from"`
	To    time.Time         `json:"to"`
	Data  map[string]string `json:"data"`
	Value int64             `json:"value"`
}

type StorageSettings 

type StorageSettings struct {
	Keys            []*crypto.Key          `json:"keys,omitempty"`
	SettingsTTLDays int64                  `json:"settings_ttl_days"`
	HTTP            *HTTPServerSettings    `json:"http,omitempty"`
	JSONRPC         *JSONRPCServerSettings `json:"jsonrpc,omitempty"`
	REST            *RESTServerSettings    `json:"rest,omitempty"`
}

type StoreProviderDataParams 

type StoreProviderDataParams struct {
	Timestamp     time.Time                 `json:"timestamp"`
	EncryptedData *crypto.ECDHEncryptedData `json:"encryptedData"`
	Code          []byte                    `json:"code"`
}

type StoreProviderDataSignedParams 

type StoreProviderDataSignedParams struct {
	JSON      string                   `json:"data" coerce:"name:json"`
	Data      *StoreProviderDataParams `json:"-" coerce:"name:data"`
	Signature []byte                   `json:"signature"`
	PublicKey []byte                   `json:"publicKey"`
}

type StoreSettingsParams 

type StoreSettingsParams struct {
	ID   []byte      `json:"id"`
	Data interface{} `json:"data"`
}

type TLSSettings 

type TLSSettings struct {
	CACertificateFile string `json:"ca_certificate_file"`
	CertificateFile   string `json:"certificate_file"`
	KeyFile           string `json:"key_file"`
}

type TimeWindow 

type TimeWindow struct {
	From int64
	To   int64
	Type string
}

func Day 

func Day(value int64) TimeWindow

func Hour 

func Hour(value int64) TimeWindow

func MakeTimeWindow 

func MakeTimeWindow(t int64, twType string) TimeWindow

func Minute 

func Minute(value int64) TimeWindow

func Month 

func Month(value int64) TimeWindow

func QuarterHour 

func QuarterHour(value int64) TimeWindow

func Second 

func Second(value int64) TimeWindow

func Week 

func Week(value int64) TimeWindow

func (*TimeWindow) Copy 

func (t *TimeWindow) Copy() TimeWindow

func (*TimeWindow) EqualTo 

func (t *TimeWindow) EqualTo(tw *TimeWindow) bool

func (*TimeWindow) IncreaseBy 

func (t *TimeWindow) IncreaseBy(n int64)

type TimeWindowFunc 

type TimeWindowFunc func(int64) TimeWindow

type TokenData 

type TokenData struct {
	JSON      string         `json:"data" coerce:"name:json"`
	Data      *PriorityToken `json:"-" coerce:"name:data"`
	PublicKey []byte         `json:"publicKey"`
	Token     []byte         `json:"token"`
	Hash      []byte         `json:"hash"`
}

func (*TokenData) Sign 

func (k *TokenData) Sign(key *crypto.Key) (*SignedTokenData, error)

type UploadDistancesParams 

type UploadDistancesParams struct {
	Timestamp time.Time  `json:"timestamp"`
	Type      string     `json:"type"`
	Distances []Distance `json:"distances"`
}

type UploadDistancesSignedParams 

type UploadDistancesSignedParams struct {
	JSON      string                 `json:"data" coerce:"name:json"`
	Data      *UploadDistancesParams `json:"-" coerce:"name:data"`
	Signature []byte                 `json:"signature"`
	PublicKey []byte                 `json:"publicKey"`
}

type ValidateSettings 

type ValidateSettings struct {
	AppointmentDurationMax      int64    `json:"appointment_duration_max"`
	AppointmentDurationMin      int64    `json:"appointment_duration_min"`
	AnonMaxTimeWindow           int64    `json:"anon_max_time_window"`
	AnonAggregatedMaxTimeWindow int64    `json:"anon_aggregated_max_time_window"`
	ProviderMaxTimeWindow       int64    `json:"provider_max_time_window"`
	Vaccines                    []string `json:"vaccines"`
}

Settings for the appointments server validator

type ValidateUserParams 

type ValidateUserParams struct {
	SignedTokenData *SignedTokenData `json:"signedTokenData"`
	Timestamp       time.Time        `json:"timestamp"`
}

type ValidateUserSignedParams 

type ValidateUserSignedParams struct {
	JSON      string              `json:"data" coerce:"name:json"`
	Data      *ValidateUserParams `json:"-" coerce:"name:data"`
	Signature []byte              `json:"signature"`
	PublicKey []byte              `json:"publicKey"`
}

type Value 

type Value interface {
	Object
	Set(value []byte, ttl time.Duration) error
	Get() ([]byte, error)
	Del() error
}

Source Files

View all Source files

Directories

Path Synopsis
cmd
helpers
kiebitz command
fixtures

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.