mutablelogic / go-server Goto Github PK

Fixup provider cancellation of tasks

Should cancel tasks in the reverse order to which they were created
and wait for each task to finish before cancelling the next one.

Provider is generally pretty ugly code so it does need a refactor.

• Add cache
• Cache expires older entries
• Add gateway which publishes API's
• Add some sort of scope support
• Add static file serving to router
• Add middleware for gateways
• Consider renaming gateway to service
• Configuration should have "self" option to add router as endpoint
• Delay endpoint registration until "run" so that we can do logging
• Scopes method (and indeed, all the endpoint reflection) should only output scopes and routes for the requested hostname (or if the hostname is empty) - so that each individual hostname can output a different set of reflections
• Reflection API should include /scopes (returns all scopes) and /services (returns label and description of each service, and then lists the routes and methods)
• Should be able to filter services so that we only - for example - return static-handler services and their prefixes
• Make a client to query the router

Test the fastCGI socket option for go-server. Might need to add Owner, Group and Mode permissions and come up with a nginx.conf file

• Create a certmanager handler
• Should be able to create a CA
• Should be able to import a CA
• Should be able to query and delete a CA. CA should not be deletable if there are certs which are signed by it
• Should be able to create a new cert from a CA
• Should be able to query, renew, export and delete a cert

Integrate certs into nginx
Add Let's Encrypt cert generation
Create an API client for interacting with the cert manager

Implement an nginx service tasks:

• Start, stop, reload and test configuration
• Create new configurations, update, enable , disable and delete them
• Command-line client for control of nginx
• Add a client which can be used for client-side control
• Permissions on the TEMP directory need to be 755 rather than 700
• Permissions on any socket directory need to reflect User and Group in httpserver
• Add scopes for nginx for permissions
• Add data (for sockets/pid) and log paths
• Use a mutex lock to guard against concurrency in various places
• Add "readonly" property to Template so that it cannot be disabled, enabled, changed or deleted
• Add template variables for rending a configuration from a text/template
• Allow PATCH method to write body of enabled configuration
• Log rotation
• Check remaining TODO's

The repository link is:
https://github.com/mutablelogic/go-server/tree/v4/pkg/handler/nginx

Create middleware to validate API tokens (Bearer) against an interface

• Middleware gets JWT and a secret from the interface, and scope from the route ("permissable scope")
• Interface provides a secret to validate the a JWT, or empty string
• Checks against JWT using secret - if token is valid and route scope is in token scopes, skip the interface, get parameters
• Otherwise, Interface takes a token and optionally a scope, returns all the parameters and all allowed scopes, or
• Not Authorized if the scope is not allowed
• Call the child method
• After child method, store parameters and scope in JWT with the secret and pass as a cookie back to the client

The interface can store API key against parameters and allowed scopes. Interface should probably update the "last accessed date" against a token

Check for API revoke, secret revoke

The provider (and the command line executable) should:

• Load all the plugins through a -plugins option
• List the plugins loaded
• Reflect on the configuration of the plugins
• Display the configuration with -help
• Create a new empty configuation
• Set and get properties within each configuration
• Create a graph of dependencies based on setting properties
• Create tasks in the right graph order
• Run the tasks, and stop them in the reverse order when signal is received

It will be a further step to express the configuration in HCL or another config language, later.

Repository link:
https://github.com/mutablelogic/go-server/tree/v2/pkg/expr

Implement the parser for expressions (rather than HCL blocks)

Also implement the ability to walk the parse tree to discover dependencies
And the ability to execute a parse tree given a set of contexts (variables, functions)