sauce

type AcmeAccount struct {
	// status (required, string):
	// The status of this account.
	// Possible values are: "valid", "deactivated", and "revoked".
	// The value "deactivated" should be used to indicate client-initiated deactivation
	// whereas "revoked" should be used to indicate server- initiated deactivation. (See Section 7.1.6)
	Status string `json:"status,omitempty"`

	// contact (optional, array of string):
	// An array of URLs that the server can use to contact the client for issues related to this account.
	// For example, the server may wish to notify the client about server-initiated revocation or certificate expiration.
	// For information on supported URL schemes, see Section 7.3
	Contact []string `json:"contact,omitempty"`

	// termsOfServiceAgreed (optional, boolean):
	// Including this field in a new-account request,
	// with a value of true, indicates the client's agreement with the terms of service.
	// This field is not updateable by the client.
	TermsOfServiceAgreed bool `json:"termsOfServiceAgreed,omitempty"`

	// orders (required, string):
	// A URL from which a list of orders submitted by this account can be fetched via a POST-as-GET request,
	// as described in Section 7.1.2.1.
	Orders string `json:"orders,omitempty"`

	// onlyReturnExisting (optional, boolean):
	// If this field is present with the value "true",
	// then the server MUST NOT create a new account if one does not already exist.
	// This allows a client to look up an account URL based on an account key (see Section 7.3.1).
	OnlyReturnExisting bool `json:"onlyReturnExisting,omitempty"`

	// externalAccountBinding (optional, object):
	// An optional field for binding the new account with an existing non-ACME account (see Section 7.3.4).
	ExternalAccountBinding json.RawMessage `json:"externalAccountBinding,omitempty"`
}

type AcmeResource struct {
	Body AcmeAccount `json:"body,omitempty"`
	URI  string      `json:"uri,omitempty"`
}

type AcmeUser struct {
	Email        string
	Registration *AcmeResource
	PrivateKey   crypto.PrivateKey
}

type Application interface {
	context.Context
	gluten.InitializingBean
	gluten.NamedBean
	Component

	/**
	Add beans to application context
	*/
	AppendBeans(beans ...interface{})

	/**
	Gets application name, represents lower case normalized executable name
	*/
	Name() string

	/**
	Gets application version at the time of compilation
	*/
	Version() string

	/**
	Gets application build at the time of compilation
	*/
	Build() string

	/**
	Gets application runtime profile, could be: dev, qa, prod and etc.
	*/
	Profile() string

	/**
	Checks if application running in dev mode
	*/
	IsDev() bool

	/**
	Gets application binary name, used on startup, could be different with application name
	*/
	Executable() string

	/**
	Gets home directory of the application, usually parent directory of binary folder where executable is running, not current directory
	*/
	ApplicationDir() string

	/**
	Run application with command line arguments
	*/
	Run(args []string) error

	/**
	Indicator if application is active and not in shutting down mode
	*/
	Active() bool

	/**
	Sets the flag that application is in shutting down mode then notify all go routines by ShutdownChannel then notify signal channel with interrupt signal

	Additionally sets the flag that application is going to be restarted after shutdown
	*/
	Shutdown(restart bool)

	/**
	Indicator if application needs to be restarted by autoupdate or remote command after shutdown
	*/
	Restarting() bool
}

type ApplicationFlags interface {
	gluten.PropertyResolver

	Daemon() bool

	Verbose() bool

	Properties() map[string]string
}

type AsymmetricSealer interface {
	PublicKey() crypto.PublicKey

	PrivateKey() crypto.PrivateKey

	EncodePublicKey() (string, error)

	EncodePrivateKey() (string, error)

	Seal(plaintext []byte, recipient crypto.PublicKey) (ciphertext []byte, err error)

	Open(ciphertext []byte, sender crypto.PublicKey) (plaintext []byte, err error)
}

type AsymmetricSigner interface {
	PublicKey() crypto.PublicKey

	PrivateKey() crypto.PrivateKey

	EncodePublicKey() (string, error)

	EncodePrivateKey() (string, error)

	Sign(plaintext []byte) (sign []byte, err error)

	Verify(plaintext, sign []byte) (valid bool, err error)
}

type AuthenticatedCipher interface {
	Key() cipher.AEAD

	Encrypt(plaintext []byte) (ciphertext []byte, err error)

	Decrypt(ciphertext []byte) (plaintext []byte, err error)
}

type AuthorizationMiddleware interface {
	gluten.InitializingBean

	Authenticate(ctx context.Context) (context.Context, error)

	GetUser(ctx context.Context) (*AuthorizedUser, bool)

	HasUserRole(ctx context.Context, role string) bool

	UserContext(ctx context.Context, name string) (string, bool)

	GenerateToken(user *AuthorizedUser) (string, error)

	ParseToken(token string) (*AuthorizedUser, error)

	InvalidateToken(token string)
}

type AuthorizedUser struct {
	Username  string
	Roles     map[string]bool
	Context   map[string]string
	ExpiresAt int64
	Token     string
}

type AutocertStorage interface {
	Cache(serverName string) autocert.Cache
}

type AutoupdateService interface {
	gluten.InitializingBean
	gluten.DisposableBean

	Freeze(jobName string) int64

	Unfreeze(handle int64)

	FreezeJobs() map[int64]string
}

type CertificateDesc struct {
	Organization string
	Country      string
	Province     string
	City         string
	Street       string
	Zip          string
}

type CertificateIssueService interface {
	LoadCertificateDesc() (*CertificateDesc, error)

	CreateIssuer(cn string, info *CertificateDesc) (CertificateIssuer, error)

	LoadIssuer(*saucepb.SelfSigner) (CertificateIssuer, error)

	LocalIPAddresses(addLocalhost bool) ([]net.IP, error)
}

type CertificateIssuer interface {
	Parent() (CertificateIssuer, bool)

	Certificate() IssuedCertificate

	IssueInterCert(cn string) (CertificateIssuer, error)

	IssueClientCert(cn string, password string) (cert IssuedCertificate, pfxData []byte, err error)

	IssueServerCert(cn string, domains []string, ipAddresses []net.IP) (IssuedCertificate, error)
}

type CertificateManager interface {
	gluten.InitializingBean
	gluten.DisposableBean

	GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error)

	InvalidateCache(domain string)

	ListActive() map[string]error

	ListRenewal() map[string]time.Time

	ListUnknown() map[string]time.Time

	ExecuteCommand(cmd string, args []string) (string, error)
}

type CertificateRepository interface {
	gluten.DisposableBean

	/**
	Self Signer CRUID
	*/
	SaveSelfSigner(self *saucepb.SelfSigner) error

	FindSelfSigner(name string) (*saucepb.SelfSigner, error)

	ListSelfSigners(prefix string, cb func(*saucepb.SelfSigner) bool) error

	DeleteSelfSigner(name string) error

	/**
	Acme Account CRUID
	*/
	SaveAccount(account *saucepb.AcmeAccount) error

	FindAccount(email string) (*saucepb.AcmeAccount, error)

	ListAccounts(prefix string, cb func(*saucepb.AcmeAccount) bool) error

	DeleteAccount(email string) error

	SaveZone(zone *saucepb.Zone) error

	FindZone(zone string) (*saucepb.Zone, error)

	ListZones(prefix string, cb func(*saucepb.Zone) bool) error

	DeleteZone(zone string) error

	Watch(ctx context.Context, cb func(zone, event string) bool) (cancel context.CancelFunc, err error)

	Backend() fastfood.DataStore

	/**
	Sets backend using for storing certificates
	*/
	SetBackend(storage fastfood.DataStore)
}

type CertificateService interface {
	gluten.InitializingBean

	CreateAcmeAccount(email string) error

	GetOrCreateAcmeUser(email string) (user *AcmeUser, err error)

	CreateSelfSigner(cn string, withInter bool) error

	RenewCertificate(zone string) error

	ExecuteCommand(cmd string, args []string) (string, error)

	IssueAcmeCertificate(entry *saucepb.Zone) (string, error)

	IssueSelfSignedCertificate(entry *saucepb.Zone) error
}

type CipherOption interface {
	Apply(*CipherOptions) error
}

type CipherOptions struct {
	Algorithm string

	Block cipher.Block
}

type ClientScanner interface {
	ClientBeans() []interface{}
}

type Command interface {
	gluten.NamedBean

	Run(args []string) error

	Desc() string
}

type Component interface {
	gluten.NamedBean

	GetStats(cb func(name, value string) bool) error
}

type ConfigRepository interface {
	gluten.DisposableBean
	gluten.PropertyResolver

	Get(key string) (string, error)

	EnumerateAll(prefix string, cb func(key, value string) bool) error

	Set(key, value string) error

	Watch(context context.Context, prefix string, cb func(key, value string) bool) (context.CancelFunc, error)

	Backend() fastfood.DataStore

	/**
	Sets backend using for storing properties
	*/
	SetBackend(storage fastfood.DataStore)
}

type ControlClient interface {
	gluten.InitializingBean
	gluten.DisposableBean

	Status() (string, error)

	Shutdown(restart bool) (string, error)

	ConfigCommand(command string, args []string) (string, error)

	CertificateCommand(command string, args []string) (string, error)

	JobCommand(command string, args []string) (string, error)

	StorageCommand(command string, args []string) (string, error)

	StorageConsole(writer io.StringWriter, errWriter io.StringWriter) error
}

type CoreScanner interface {

	/**
	Gets core beans that will extend application beans, parent context.
	*/
	CoreBeans() []interface{}
}

type DNSProvider interface {
	gluten.NamedBean

	Detect(whois *Whois) bool

	RegisterChallenge(legoClient interface{}, token string) error

	NewClient() (DNSProviderClient, error)
}

type DNSProviderClient interface {
	GetPublicIP() (addr string, err error)

	GetRecords(zoneID string) ([]*DNSRecord, error)

	CreateRecord(zoneID string, record *DNSRecord) (*DNSRecord, error)

	RemoveRecord(zoneID, recordID string) error
}

type DNSRecord struct {
	ID       string `json:"id,omitempty"`
	Hostname string `json:"hostname,omitempty"`
	TTL      int    `json:"ttl,omitempty"`
	Type     string `json:"type,omitempty"`
	Priority int    `json:"priority,omitempty"`
	Value    string `json:"value,omitempty"`
}

type DynDNSService interface {
	gluten.NamedBean
	gluten.InitializingBean

	EnsureAllPublic(subDomains ...string) error

	EnsureCustom(func(client DNSProviderClient, zone string, externalIP string) error) error
}

type FlagSetRegistrar interface {
	RegisterFlags(fs *flag.FlagSet)

	RegisterServerArgs(args []string) []string
}

type IssuedCertificate interface {
	KeyFileContents() []byte

	CertFileContents() []byte

	PrivateKey() crypto.Signer

	Certificate() *x509.Certificate
}

type JobInfo struct {
	Name        string
	Schedule    string
	ExecutionFn func(context.Context) error
}

type JobService interface {
	ListJobs() ([]string, error)

	AddJob(*JobInfo) error

	CancelJob(name string) error

	RunJob(ctx context.Context, name string) error

	ExecuteCommand(cmd string, args []string) (string, error)
}

type Mail struct {
	Sender       string
	Recipients   []string
	Subject      string
	TextTemplate string
	HtmlTemplate string // optional
	Data         interface{}
	Attachments  []string // optional
}

type MailService interface {
	gluten.NamedBean

	SendMail(mail *Mail, timeout time.Duration, async bool) error
}

type NatService interface {
	AllowMapping() bool

	AddMapping(protocol string, extport, intport int, name string, lifetime time.Duration) error

	DeleteMapping(protocol string, extport, intport int) error

	ExternalIP() (net.IP, error)

	ServiceName() string
}

type NodeService interface {
	gluten.InitializingBean
	Component

	NodeId() uint64

	NodeIdHex() string

	Issue() uuid.UUID

	Parse(uuid.UUID) (timestampMillis int64, nodeId int64, clock int)
}

type Page interface {
	http.Handler

	Pattern() string
}

type Record struct {
	Key   []byte
	Value []byte
}

type ResourceService interface {
	GetResource(name string) ([]byte, error)

	TextTemplate(name string) (*textTemplate.Template, error)

	HtmlTemplate(name string) (*htmlTemplate.Template, error)

	GetLicenses(name string) (string, error)

	GetOpenAPI(source string) string
}

type SealService interface {
	IssueSealer(algorithm string, bits int) (AsymmetricSealer, error)

	Sealer(options ...SealerOption) (AsymmetricSealer, error)

	IssueSigner(algorithm string, bits int) (AsymmetricSigner, error)

	Signer(options ...SealerOption) (AsymmetricSigner, error)

	AuthenticatedCipher(options ...CipherOption) (AuthenticatedCipher, error)
}

type SealerOption interface {
	Apply(*SealerOptions) error
}

type SealerOptions struct {
	Algorithm string

	PublicKey crypto.PublicKey

	PrivateKey crypto.PrivateKey // optional

}

type Server interface {
	gluten.InitializingBean
	gluten.DisposableBean

	Bind() error

	Active() bool

	ListenAddress() net.Addr

	Serve() error

	Stop()
}

type ServerScanner interface {
	ServerBeans() []interface{}
}

type StorageConsoleStream interface {
	Send(*saucepb.StorageConsoleResponse) error

	Recv() (*saucepb.StorageConsoleRequest, error)
}

type StorageService interface {
	gluten.InitializingBean

	Execute(name, query string, cb func(string) bool) error

	ExecuteCommand(cmd string, args []string) (string, error)

	Console(stream StorageConsoleStream) error

	LocalConsole(writer io.StringWriter, errWriter io.StringWriter) error
}

type SystemEnvironmentPropertyResolver interface {
	PromptProperty(key string) (string, bool)

	Environ(withValues bool) []string
}

type Whois struct {
	Domain    string
	NServer   []string
	State     string
	Person    string
	Email     string
	Registrar string
	Created   string
	PaidTill  string
}

type WhoisService interface {
	Parse(whoisResp string) *Whois

	Whois(domain string) (string, error)
}