common

type Attribute ¶ added in v1.0.0

type Attribute struct {
	AttributeKey   string `json:"attribute_key"`
	AttributeValue string `json:"attribute_value"`
	Id             int    `sql:"AUTO_INCREMENT"`
}

An Attribute of a user is something that is used in the ABAC part of our AuthZ scheme. Not every role would be checked for atributes. For now, only if the user has a role of tenant, it's attribute for key "tenant" is checked against the tenant ID by tenant service.

type AuthMiddleware ¶

type AuthMiddleware struct {
	PublicKey   *rsa.PublicKey
	AllowedURLs []string
}

AuthMiddleware wrapper for auth.

func NewAuthMiddleware(service Service) (AuthMiddleware, error)

func (am AuthMiddleware) Keyfunc(*jwt.Token) (interface{}, error)

func (am AuthMiddleware) ServeHTTP(writer http.ResponseWriter, request *http.Request, next http.HandlerFunc)

type AuthTokenMessage ¶ added in v1.0.0

type AuthTokenMessage struct {
	Token     string `json:"token"`
	PublicKey []byte `json:"public_key"`
}

AuthTokenMessage is returned by Root service upon a client's authentication. The token is generated by the root server depending on the information looked up on the user (roles and attributes) and the public key is the root server's public key to verify the token (which is signed by root's private key).

type AuthZChecker ¶ added in v1.0.0

type AuthZChecker func(ctx RestContext) bool

AuthZChecker takes a user and outputs whether the user is allowed to access a resource. If defined on a Route, it will be automatically invoked by wrapHandler(), which will provide RestContext.

type Config ¶

type Config struct {
	EtcdEndpoints       []string
	EtcdPrefix          string
	InitialTopologyFile *string
	Mock                bool
}

Config is the configuration required for a Romana client library. TODO it is here temporarily until circular imports are resolved.

type Credential ¶ added in v0.8.2

type Credential struct {
	Type CredentialType

	Username string
	Password string
	// contains filtered or unexported fields
}

Container for various credentials. Currently containing Username/Password but keys, certificates, etc. can be used in the future.

func NewCredential(flagSet *flag.FlagSet) *Credential

func NewCredentialCobra(cmd *cli.Command) *Credential

func (c *Credential) Initialize() error

func (c *Credential) String() string

type CredentialType ¶ added in v0.8.2

type CredentialType string

Represents the type of credential (e.g., certificate, username-password, etc.)

type ExecErrorDetails ¶ added in v0.9.0

type ExecErrorDetails struct {
	Error string
}

type FindFlag ¶ added in v0.9.1

type FindFlag string

type HttpError ¶

type HttpError struct {
	// HTTP status code
	StatusCode int         `json:"status_code"`
	Details    interface{} `json:"details,omitempty"`
	// ResourceID specifies the relevant resource ID, if applicable
	ResourceID string `json:"resource_id,omitempty"`
	// ResourceType specifies the relevant resource type, if applicable
	ResourceType string `json:"resource_type,omitempty"`
	SeeAlso      string `json:"see_also, omitempty"`
}

HttpError is a structure that represents, well, an HTTP error.

func NewError400(details interface{}) HttpError

func NewError403() HttpError

func NewError404(resourceType string, resourceID string) HttpError

func NewError500(details interface{}) HttpError

func NewErrorConflict(details interface{}) HttpError

func NewHttpError(code int, details interface{}) HttpError

func NewUnprocessableEntityError(details interface{}) HttpError

func (httpErr HttpError) Error() string

func (err HttpError) StatusText() string

type IP ¶

type IP struct {
	// contains filtered or unexported fields
}

func MakeIPv4(a, b, c, d byte) IP

type KeyValue ¶ added in v0.9.3

type KeyValue struct {
	Key   string
	Value interface{}
}

KeyValue represents a key-value pair (similar to Java's Map.Entry)

func KV(key string, value interface{}) KeyValue

type LinkResponse ¶

type LinkResponse struct {
	Href string `json:"href,omitempty"`
	Rel  string `json:"rel,omitempty"`
}

LinkResponse structure represents the commonly occurring

{
       "href" : "https://<own-addr>",
       "rel"  : "self"
 }

part of the response.

type Links ¶

type Links []LinkResponse

func (links Links) FindByRel(rel string) string

type MakeMessage ¶

type MakeMessage func() interface{}

MakeMessage is a factory function, which should return a pointer to an instance into which we will unmarshal wire data.

type Marshaller ¶

type Marshaller interface {
	Marshal(v interface{}) ([]byte, error)
	Unmarshal(data []byte, v interface{}) error
}

Marshaller is capable of marshalling and unmarshalling data to/from the wire.

type MultiError ¶

type MultiError struct {
	// contains filtered or unexported fields
}

MultiError is a facility to collect multiple number of errors but present them as a single error interface. For example, GORM does not return errors at every turn. It accumulates them and returns them whenever you feel like calling GetErrors() (https://godoc.org/github.com/jinzhu/gorm#DB.GetErrors). Since this is not consistent with the rest of the code, I prefer to isolate it here and make an adapter.

func NewMultiError() *MultiError

func (me MultiError) Add(err error)

func (m *MultiError) Error() string

func (m *MultiError) GetError() error

func (m *MultiError) GetErrors() []error

type NegotiatorMiddleware ¶

type NegotiatorMiddleware struct {
}

func NewNegotiator() *NegotiatorMiddleware

func (negotiator NegotiatorMiddleware) ServeHTTP(writer http.ResponseWriter, request *http.Request, next http.HandlerFunc)

type PortUpdateMessage ¶

type PortUpdateMessage struct {
	Port uint64 `json:"port"`
}

Message to register with the root service the actual port a service is listening on.

type Raw ¶ added in v0.9.0

type Raw struct {
	Body string
}

Raw is a type that can be returned from any service's route and the middleware will not try to marshal it.

type RestContext ¶

type RestContext struct {
	// Path variables as described in https://godoc.org/code.google.com/p/gorilla/mux
	PathVariables map[string]string
	// QueryVariables stores key-value-list map of query variables, see url.Values
	// for more details.
	QueryVariables url.Values
	// Unique identifier for a request.
	RequestToken string
	User         User
	// Output of the hook if any run before the execution of the handler.
	HookOutput string
}

RestContext contains the context of the REST request other than the body data that has been unmarshaled.

type RestHandler ¶

type RestHandler func(input interface{}, context RestContext) (interface{}, error)

RestHandler specifies type of a function that each Route provides. It takes (for now) an interface as input, and returns any interface. The middleware provided in this file takes care of unmarshalling the data from the wire to the input object (the type of the object created will be determined by the type of the instance provided in Consumes field of Route type, below), and of marshalling the returned object to the wire (the type of which is determined by type of the instance provided in Produces field of Route type, below).

type RestServiceInfo ¶

type RestServiceInfo struct {
	// Address being listened on (as host:port)
	Address string
	// Channel to communicate with the service
	Channel chan ServiceMessage
}

RestServiceInfo describes information about a running Romana service.

func InitializeService(service Service, config Config) (*RestServiceInfo, error)

func ListenAndServe(svr *http.Server) (*RestServiceInfo, error)

func RunNegroni(n *negroni.Negroni, addr string) (*RestServiceInfo, error)

type Role ¶ added in v0.8.2

type Role struct {
	Name string `json:"name"`
	Id   int    `sql:"AUTO_INCREMENT"`
}

type RomanaHandler ¶

type RomanaHandler struct {
	// contains filtered or unexported fields
}

RomanaHandler interface to comply with http.Handler

func (romanaHandler RomanaHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

type RomanaTestSuite ¶ added in v1.0.0

type RomanaTestSuite struct {
	// contains filtered or unexported fields
}

RomanaTestSuite holds state for use in testing.

func (rts *RomanaTestSuite) CleanUp()

func (rts *RomanaTestSuite) GetMockSqliteFile(svc string) string

type Route ¶

type Route struct {
	// REST method
	Method string

	// Pattern (see http://www.gorillatoolkit.org/pkg/mux)
	Pattern string

	// Handler (see documentation above)
	Handler RestHandler

	// This should return a POINTER to an instance which
	// this route expects as an input.
	MakeMessage MakeMessage

	// Whether this route is using a request token. If true, the
	// request token will be parsed out of the request and made
	// available in RestContext. It can then
	// used by the handler to achieve idempotence.
	UseRequestToken bool

	AuthZChecker AuthZChecker
}

Route determines an action taken on a URL pattern/HTTP method. Each service can define a route See routes.go and handlers.go in root package for a demonstration of use

type Routes ¶

type Routes []Route

Routes provided by each service.

type Service ¶

type Service interface {
	Initialize(clientConfig Config) error

	// Returns the routes that this service works with
	Routes() Routes

	// Name returns the name of this service.
	Name() string

	// GetAddr returns the host/port the service is listening on.
	GetAddress() string
}

Service is the interface that services implement.

type ServiceMessage ¶

type ServiceMessage string

Type definitions

type ServiceUtils ¶

type ServiceUtils struct {
	// ResourceIdToStatus is a maps request ID
	// to status. A request ID can be a RequestToken if required,
	// or a resource ID. In general the idea is that this is used
	// in conjunction with RequestToken.
	// See also
	// - Route.UseRequestToken
	// - RestContext.RequestToken
	RequestIdToStatus map[string]interface{}

	// RequestIdToTimestamp maps request ID (for more information
	// on what that is see RequestIdToStatus) to the timestamp
	// of the original request. It will later be used for things
	// such as possible expiration, etc., but for now it's just a
	// placeholder.
	RequestIdToTimestamp map[string]int64
}

ServiceUtils represents functionality common to various services. One example of such functionality is asynchronous processing -- a service can accept a request for creation of an object and return a 202 ACCEPTED, creating an entry that can be queried for status.

func (s ServiceUtils) AddStatus(requestId string, value interface{})

func (s ServiceUtils) GetStatus(resourceType string, requestId string) (interface{}, error)

type UnmarshallerMiddleware ¶

type UnmarshallerMiddleware struct {
}

func NewUnmarshaller() *UnmarshallerMiddleware

func (m UnmarshallerMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type UnwrappedRestHandlerInput ¶

type UnwrappedRestHandlerInput struct {
	ResponseWriter http.ResponseWriter
	Request        *http.Request
}

UnwrappedRestHandlerInput is used to pass in http.Request and http.ResponseWriter, should some service like unfettered access directly to them. In such a case, the service's RestHandler's input will be of this type; and the return value will be ignored.

type User ¶ added in v1.0.0

type User struct {
	UserId             int `sql:"AUTO_INCREMENT" json:"user_id" gorm:"primary_key"`
	jwt.StandardClaims `json:"claims"`
	Username           string      `json:"username,omitempty"`
	Password           string      `json:"password,omitempty"`
	Roles              []Role      `gorm:"many2many:user_roles;ForeignKey:user_id"`
	Attributes         []Attribute `gorm:"many2many:user_attributes;ForeignKey:user_id"`
}

User has multiple roles and multiple attributes.

var DefaultAdminUser User