diff --git a/.gitlab-ci.yml.bak b/.gitlab-ci.yml.bak
new file mode 100644
index 0000000000000000000000000000000000000000..4b87522663fe35cfeee52026a928ed7971b0ddfa
--- /dev/null
+++ b/.gitlab-ci.yml.bak
@@ -0,0 +1,17 @@
+image: quay.io/goswagger/swagger:latest
+
+before_script:
+ - mkdir .ssh
+ - echo $SSH_PRIVATE_KEY > .ssh/gitlab-ci
+ - echo "Host code.fbi.h-da.de" > .ssh/config
+ - echo " Hostname code.fbi.h-da.de" >> .ssh/config
+ - echo " User git" >> .ssh/config
+ - echo " IdentityFile ~/.ssh/gitlab-ci" >> .ssh/config
+ - git config --global url.ssh://git@code.fbi.h-da.de/.insteadOf https://code.fbi.h-da.de/
+
+Build:
+ stage: build
+ script:
+ - go mod init code.fbi.h-da.de/cocsn/cocsn-api
+ - swagger generate server -A cocsn -f ./cocsn-v0.0.1.yml
+ - git push origin HEAD:$CI_COMMIT_REF_NAME
\ No newline at end of file
diff --git a/cmd/cocsn-server/main.go b/cmd/cocsn-server/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..5ed66a403755bbfe91a08eea875df0cb6c415179
--- /dev/null
+++ b/cmd/cocsn-server/main.go
@@ -0,0 +1,56 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package main
+
+import (
+ "log"
+ "os"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/restapi"
+ "code.fbi.h-da.de/cocsn/cocsn-api/restapi/operations"
+ "github.com/go-openapi/loads"
+ flags "github.com/jessevdk/go-flags"
+)
+
+// This file was generated by the swagger tool.
+// Make sure not to overwrite this file after you generated it because all your edits would be lost!
+
+func main() {
+
+ swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
+ if err != nil {
+ log.Fatalln(err)
+ }
+
+ api := operations.NewCocsnAPI(swaggerSpec)
+ server := restapi.NewServer(api)
+ defer server.Shutdown()
+
+ parser := flags.NewParser(server, flags.Default)
+ parser.ShortDescription = "CoCSN"
+ parser.LongDescription = "Simple RESTCONF API"
+ server.ConfigureFlags()
+ for _, optsGroup := range api.CommandLineOptionsGroups {
+ _, err := parser.AddGroup(optsGroup.ShortDescription, optsGroup.LongDescription, optsGroup.Options)
+ if err != nil {
+ log.Fatalln(err)
+ }
+ }
+
+ if _, err := parser.Parse(); err != nil {
+ code := 1
+ if fe, ok := err.(*flags.Error); ok {
+ if fe.Type == flags.ErrHelp {
+ code = 0
+ }
+ }
+ os.Exit(code)
+ }
+
+ server.ConfigureAPI()
+
+ if err := server.Serve(); err != nil {
+ log.Fatalln(err)
+ }
+
+}
diff --git a/cocsn-v0.0.1.yml b/cocsn-v0.0.1.yml
new file mode 100644
index 0000000000000000000000000000000000000000..7e788a75687ce1e2f7428e64ff32a8faa51fa89f
--- /dev/null
+++ b/cocsn-v0.0.1.yml
@@ -0,0 +1,98 @@
+swagger: '2.0'
+info:
+ version: '0.0.1'
+ title: CoCSN
+ description: Simple RESTCONF API
+ contact:
+ name: Your name
+basePath: /restconf
+schemes:
+ - http
+consumes:
+ - application/json
+produces:
+ - application/json
+paths:
+ /data/cocsn-interfaces:
+ get:
+ summary: 'Returns a list of interfaces'
+ operationId: getInterfaces
+ tags:
+ - interface
+ produces:
+ - application/json
+ responses:
+ 200:
+ description: OK
+ schema:
+ $ref: '#/definitions/Interfaces'
+ 404:
+ description: An error occurred.
+ default:
+ description: Unexpected error
+ /data/cocsn-interface/{interface}/ip-addresses:
+ get:
+ summary: 'Returns IP addresses of an interface'
+ operationId: getIPAddresses
+ parameters:
+ - in: path
+ name: interface
+ description: interface to fetch
+ required: true
+ type: string
+ tags:
+ - interface
+ produces:
+ - application/json
+ responses:
+ 200:
+ description: OK
+ schema:
+ $ref: '#/definitions/LogicalAddresses'
+ 404:
+ description: An error occurred.
+ default:
+ description: Unexpected error
+ /data/cocsn-interface/{interface}/mac-address:
+ get:
+ summary: 'Returns MAC address of an interface'
+ operationId: getMACAddress
+ parameters:
+ - in: path
+ name: interface
+ description: interface to fetch
+ required: true
+ type: string
+ tags:
+ - interface
+ produces:
+ - application/json
+ responses:
+ 200:
+ description: OK
+ schema:
+ $ref: '#/definitions/PhysicalAddress'
+ 404:
+ description: An error occurred.
+ default:
+ description: Unexpected error
+definitions:
+ Interfaces:
+ type: array
+ items:
+ type: string
+ properties:
+ name:
+ type: string
+ PhysicalAddress:
+ type: string
+ properties:
+ name:
+ type: string
+ LogicalAddresses:
+ type: array
+ items:
+ type: string
+ properties:
+ name:
+ type: string
\ No newline at end of file
diff --git a/models/interface.go b/models/interface.go
new file mode 100644
index 0000000000000000000000000000000000000000..ee434cf6b88c8738d0a8538ac008fbccd9132bc1
--- /dev/null
+++ b/models/interface.go
@@ -0,0 +1,26 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/strfmt"
+)
+
+// Interface interface
+//
+// swagger:model Interface
+type Interface []string
+
+// Validate validates this interface
+func (m Interface) Validate(formats strfmt.Registry) error {
+ var res []error
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
diff --git a/models/interfaces.go b/models/interfaces.go
new file mode 100644
index 0000000000000000000000000000000000000000..689857dc1a7735be7d9c923604595c8053674fa8
--- /dev/null
+++ b/models/interfaces.go
@@ -0,0 +1,26 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/strfmt"
+)
+
+// Interfaces interfaces
+//
+// swagger:model Interfaces
+type Interfaces []string
+
+// Validate validates this interfaces
+func (m Interfaces) Validate(formats strfmt.Registry) error {
+ var res []error
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
diff --git a/models/logical_addresses.go b/models/logical_addresses.go
new file mode 100644
index 0000000000000000000000000000000000000000..baa93b3354c26e9804ceee18fa0dd45da690e8bb
--- /dev/null
+++ b/models/logical_addresses.go
@@ -0,0 +1,26 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/strfmt"
+)
+
+// LogicalAddresses logical addresses
+//
+// swagger:model LogicalAddresses
+type LogicalAddresses []string
+
+// Validate validates this logical addresses
+func (m LogicalAddresses) Validate(formats strfmt.Registry) error {
+ var res []error
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
diff --git a/models/physical_address.go b/models/physical_address.go
new file mode 100644
index 0000000000000000000000000000000000000000..d139da9ffe7871cb1c1f628b301ecf02ec794e6f
--- /dev/null
+++ b/models/physical_address.go
@@ -0,0 +1,26 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package models
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/strfmt"
+)
+
+// PhysicalAddress physical address
+//
+// swagger:model PhysicalAddress
+type PhysicalAddress string
+
+// Validate validates this physical address
+func (m PhysicalAddress) Validate(formats strfmt.Registry) error {
+ var res []error
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
diff --git a/restapi/configure_cocsn.go b/restapi/configure_cocsn.go
new file mode 100644
index 0000000000000000000000000000000000000000..1db0a2805cc65897cd324866c557ae74ebf97115
--- /dev/null
+++ b/restapi/configure_cocsn.go
@@ -0,0 +1,76 @@
+// This file is safe to edit. Once it exists it will not be overwritten
+
+package restapi
+
+import (
+ "crypto/tls"
+ "net/http"
+
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/runtime"
+ "github.com/go-openapi/runtime/middleware"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/api/restapi/operations"
+ "code.fbi.h-da.de/cocsn/cocsn-api/api/restapi/operations/interface_operations"
+)
+
+//go:generate swagger generate server --target ../../generated --name Cocsn --spec ../../cocsn-v0.0.1.yml --principal interface{}
+
+func configureFlags(api *operations.CocsnAPI) {
+ // api.CommandLineOptionsGroups = []swag.CommandLineOptionsGroup{ ... }
+}
+
+func configureAPI(api *operations.CocsnAPI) http.Handler {
+ // configure the api here
+ api.ServeError = errors.ServeError
+
+ // Set your custom logger if needed. Default one is log.Printf
+ // Expected interface func(string, ...interface{})
+ //
+ // Example:
+ // api.Logger = log.Printf
+
+ api.UseSwaggerUI()
+ // To continue using redoc as your UI, uncomment the following line
+ // api.UseRedoc()
+
+ api.JSONConsumer = runtime.JSONConsumer()
+
+ api.JSONProducer = runtime.JSONProducer()
+
+ if api.InterfaceOperationsGetInterfacesHandler == nil {
+ api.InterfaceOperationsGetInterfacesHandler = interface_operations.GetInterfacesHandlerFunc(func(params interface_operations.GetInterfacesParams) middleware.Responder {
+ return middleware.NotImplemented("operation interface_operations.GetInterfaces has not yet been implemented")
+ })
+ }
+
+ api.PreServerShutdown = func() {}
+
+ api.ServerShutdown = func() {}
+
+ return setupGlobalMiddleware(api.Serve(setupMiddlewares))
+}
+
+// The TLS configuration before HTTPS server starts.
+func configureTLS(tlsConfig *tls.Config) {
+ // Make all necessary changes to the TLS configuration here.
+}
+
+// As soon as server is initialized but not run yet, this function will be called.
+// If you need to modify a config, store server instance to stop it individually later, this is the place.
+// This function can be called multiple times, depending on the number of serving schemes.
+// scheme value will be set accordingly: "http", "https" or "unix"
+func configureServer(s *http.Server, scheme, addr string) {
+}
+
+// The middleware configuration is for the handler executors. These do not apply to the swagger.json document.
+// The middleware executes after routing but before authentication, binding and validation
+func setupMiddlewares(handler http.Handler) http.Handler {
+ return handler
+}
+
+// The middleware configuration happens before anything, this middleware also applies to serving the swagger.json document.
+// So this is a good place to plug in a panic handling middleware, logging and metrics
+func setupGlobalMiddleware(handler http.Handler) http.Handler {
+ return handler
+}
diff --git a/restapi/doc.go b/restapi/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..0e478f6cd8e660a928ffec27a7bc8987ecac5ea6
--- /dev/null
+++ b/restapi/doc.go
@@ -0,0 +1,20 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// Package restapi CoCSN
+//
+// Simple RESTCONF API
+// Schemes:
+// http
+// Host: localhost
+// BasePath: /restconf
+// Version: 0.0.1
+// Contact: Your name
+//
+// Consumes:
+// - application/json
+//
+// Produces:
+// - application/json
+//
+// swagger:meta
+package restapi
diff --git a/restapi/embedded_spec.go b/restapi/embedded_spec.go
new file mode 100644
index 0000000000000000000000000000000000000000..95b6f4629b693bb3e0ea21deb41883c32065cfd3
--- /dev/null
+++ b/restapi/embedded_spec.go
@@ -0,0 +1,322 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package restapi
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "encoding/json"
+)
+
+var (
+ // SwaggerJSON embedded version of the swagger document used at generation time
+ SwaggerJSON json.RawMessage
+ // FlatSwaggerJSON embedded flattened version of the swagger document used at generation time
+ FlatSwaggerJSON json.RawMessage
+)
+
+func init() {
+ SwaggerJSON = json.RawMessage([]byte(`{
+ "consumes": [
+ "application/json"
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "schemes": [
+ "http"
+ ],
+ "swagger": "2.0",
+ "info": {
+ "description": "Simple RESTCONF API",
+ "title": "CoCSN",
+ "contact": {
+ "name": "Your name"
+ },
+ "version": "0.0.1"
+ },
+ "basePath": "/restconf",
+ "paths": {
+ "/data/cocsn-interface/{interface}/ip-addresses": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "interface"
+ ],
+ "summary": "Returns IP addresses of an interface",
+ "operationId": "getIPAddresses",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "interface to fetch",
+ "name": "interface",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/LogicalAddresses"
+ }
+ },
+ "404": {
+ "description": "An error occurred."
+ },
+ "default": {
+ "description": "Unexpected error"
+ }
+ }
+ }
+ },
+ "/data/cocsn-interface/{interface}/mac-address": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "interface"
+ ],
+ "summary": "Returns MAC address of an interface",
+ "operationId": "getMACAddress",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "interface to fetch",
+ "name": "interface",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/PhysicalAddress"
+ }
+ },
+ "404": {
+ "description": "An error occurred."
+ },
+ "default": {
+ "description": "Unexpected error"
+ }
+ }
+ }
+ },
+ "/data/cocsn-interfaces": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "interface"
+ ],
+ "summary": "Returns a list of interfaces",
+ "operationId": "getInterfaces",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/Interfaces"
+ }
+ },
+ "404": {
+ "description": "An error occurred."
+ },
+ "default": {
+ "description": "Unexpected error"
+ }
+ }
+ }
+ }
+ },
+ "definitions": {
+ "Interfaces": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "properties": {
+ "name": {
+ "type": "string"
+ }
+ }
+ },
+ "LogicalAddresses": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "properties": {
+ "name": {
+ "type": "string"
+ }
+ }
+ },
+ "PhysicalAddress": {
+ "type": "string",
+ "properties": {
+ "name": {
+ "type": "string"
+ }
+ }
+ }
+ }
+}`))
+ FlatSwaggerJSON = json.RawMessage([]byte(`{
+ "consumes": [
+ "application/json"
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "schemes": [
+ "http"
+ ],
+ "swagger": "2.0",
+ "info": {
+ "description": "Simple RESTCONF API",
+ "title": "CoCSN",
+ "contact": {
+ "name": "Your name"
+ },
+ "version": "0.0.1"
+ },
+ "basePath": "/restconf",
+ "paths": {
+ "/data/cocsn-interface/{interface}/ip-addresses": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "interface"
+ ],
+ "summary": "Returns IP addresses of an interface",
+ "operationId": "getIPAddresses",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "interface to fetch",
+ "name": "interface",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/LogicalAddresses"
+ }
+ },
+ "404": {
+ "description": "An error occurred."
+ },
+ "default": {
+ "description": "Unexpected error"
+ }
+ }
+ }
+ },
+ "/data/cocsn-interface/{interface}/mac-address": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "interface"
+ ],
+ "summary": "Returns MAC address of an interface",
+ "operationId": "getMACAddress",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "interface to fetch",
+ "name": "interface",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/PhysicalAddress"
+ }
+ },
+ "404": {
+ "description": "An error occurred."
+ },
+ "default": {
+ "description": "Unexpected error"
+ }
+ }
+ }
+ },
+ "/data/cocsn-interfaces": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "interface"
+ ],
+ "summary": "Returns a list of interfaces",
+ "operationId": "getInterfaces",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/Interfaces"
+ }
+ },
+ "404": {
+ "description": "An error occurred."
+ },
+ "default": {
+ "description": "Unexpected error"
+ }
+ }
+ }
+ }
+ },
+ "definitions": {
+ "Interfaces": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "properties": {
+ "name": {
+ "type": "string"
+ }
+ }
+ },
+ "LogicalAddresses": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "properties": {
+ "name": {
+ "type": "string"
+ }
+ }
+ },
+ "PhysicalAddress": {
+ "type": "string",
+ "properties": {
+ "name": {
+ "type": "string"
+ }
+ }
+ }
+ }
+}`))
+}
diff --git a/restapi/operations/cocsn_api.go b/restapi/operations/cocsn_api.go
new file mode 100644
index 0000000000000000000000000000000000000000..781e0b50a1bed3e5ece1f555be32d8c82f7cb98e
--- /dev/null
+++ b/restapi/operations/cocsn_api.go
@@ -0,0 +1,324 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "fmt"
+ "net/http"
+ "strings"
+
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/loads"
+ "github.com/go-openapi/runtime"
+ "github.com/go-openapi/runtime/middleware"
+ "github.com/go-openapi/runtime/security"
+ "github.com/go-openapi/spec"
+ "github.com/go-openapi/strfmt"
+ "github.com/go-openapi/swag"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/restapi/operations/interface_operations"
+)
+
+// NewCocsnAPI creates a new Cocsn instance
+func NewCocsnAPI(spec *loads.Document) *CocsnAPI {
+ return &CocsnAPI{
+ handlers: make(map[string]map[string]http.Handler),
+ formats: strfmt.Default,
+ defaultConsumes: "application/json",
+ defaultProduces: "application/json",
+ customConsumers: make(map[string]runtime.Consumer),
+ customProducers: make(map[string]runtime.Producer),
+ PreServerShutdown: func() {},
+ ServerShutdown: func() {},
+ spec: spec,
+ useSwaggerUI: false,
+ ServeError: errors.ServeError,
+ BasicAuthenticator: security.BasicAuth,
+ APIKeyAuthenticator: security.APIKeyAuth,
+ BearerAuthenticator: security.BearerAuth,
+
+ JSONConsumer: runtime.JSONConsumer(),
+
+ JSONProducer: runtime.JSONProducer(),
+
+ InterfaceOperationsGetIPAddressesHandler: interface_operations.GetIPAddressesHandlerFunc(func(params interface_operations.GetIPAddressesParams) middleware.Responder {
+ return middleware.NotImplemented("operation interface_operations.GetIPAddresses has not yet been implemented")
+ }),
+ InterfaceOperationsGetInterfacesHandler: interface_operations.GetInterfacesHandlerFunc(func(params interface_operations.GetInterfacesParams) middleware.Responder {
+ return middleware.NotImplemented("operation interface_operations.GetInterfaces has not yet been implemented")
+ }),
+ InterfaceOperationsGetMACAddressHandler: interface_operations.GetMACAddressHandlerFunc(func(params interface_operations.GetMACAddressParams) middleware.Responder {
+ return middleware.NotImplemented("operation interface_operations.GetMACAddress has not yet been implemented")
+ }),
+ }
+}
+
+/*CocsnAPI Simple RESTCONF API */
+type CocsnAPI struct {
+ spec *loads.Document
+ context *middleware.Context
+ handlers map[string]map[string]http.Handler
+ formats strfmt.Registry
+ customConsumers map[string]runtime.Consumer
+ customProducers map[string]runtime.Producer
+ defaultConsumes string
+ defaultProduces string
+ Middleware func(middleware.Builder) http.Handler
+ useSwaggerUI bool
+
+ // BasicAuthenticator generates a runtime.Authenticator from the supplied basic auth function.
+ // It has a default implementation in the security package, however you can replace it for your particular usage.
+ BasicAuthenticator func(security.UserPassAuthentication) runtime.Authenticator
+ // APIKeyAuthenticator generates a runtime.Authenticator from the supplied token auth function.
+ // It has a default implementation in the security package, however you can replace it for your particular usage.
+ APIKeyAuthenticator func(string, string, security.TokenAuthentication) runtime.Authenticator
+ // BearerAuthenticator generates a runtime.Authenticator from the supplied bearer token auth function.
+ // It has a default implementation in the security package, however you can replace it for your particular usage.
+ BearerAuthenticator func(string, security.ScopedTokenAuthentication) runtime.Authenticator
+
+ // JSONConsumer registers a consumer for the following mime types:
+ // - application/json
+ JSONConsumer runtime.Consumer
+
+ // JSONProducer registers a producer for the following mime types:
+ // - application/json
+ JSONProducer runtime.Producer
+
+ // InterfaceOperationsGetIPAddressesHandler sets the operation handler for the get IP addresses operation
+ InterfaceOperationsGetIPAddressesHandler interface_operations.GetIPAddressesHandler
+ // InterfaceOperationsGetInterfacesHandler sets the operation handler for the get interfaces operation
+ InterfaceOperationsGetInterfacesHandler interface_operations.GetInterfacesHandler
+ // InterfaceOperationsGetMACAddressHandler sets the operation handler for the get m a c address operation
+ InterfaceOperationsGetMACAddressHandler interface_operations.GetMACAddressHandler
+ // ServeError is called when an error is received, there is a default handler
+ // but you can set your own with this
+ ServeError func(http.ResponseWriter, *http.Request, error)
+
+ // PreServerShutdown is called before the HTTP(S) server is shutdown
+ // This allows for custom functions to get executed before the HTTP(S) server stops accepting traffic
+ PreServerShutdown func()
+
+ // ServerShutdown is called when the HTTP(S) server is shut down and done
+ // handling all active connections and does not accept connections any more
+ ServerShutdown func()
+
+ // Custom command line argument groups with their descriptions
+ CommandLineOptionsGroups []swag.CommandLineOptionsGroup
+
+ // User defined logger function.
+ Logger func(string, ...interface{})
+}
+
+// UseRedoc for documentation at /docs
+func (o *CocsnAPI) UseRedoc() {
+ o.useSwaggerUI = false
+}
+
+// UseSwaggerUI for documentation at /docs
+func (o *CocsnAPI) UseSwaggerUI() {
+ o.useSwaggerUI = true
+}
+
+// SetDefaultProduces sets the default produces media type
+func (o *CocsnAPI) SetDefaultProduces(mediaType string) {
+ o.defaultProduces = mediaType
+}
+
+// SetDefaultConsumes returns the default consumes media type
+func (o *CocsnAPI) SetDefaultConsumes(mediaType string) {
+ o.defaultConsumes = mediaType
+}
+
+// SetSpec sets a spec that will be served for the clients.
+func (o *CocsnAPI) SetSpec(spec *loads.Document) {
+ o.spec = spec
+}
+
+// DefaultProduces returns the default produces media type
+func (o *CocsnAPI) DefaultProduces() string {
+ return o.defaultProduces
+}
+
+// DefaultConsumes returns the default consumes media type
+func (o *CocsnAPI) DefaultConsumes() string {
+ return o.defaultConsumes
+}
+
+// Formats returns the registered string formats
+func (o *CocsnAPI) Formats() strfmt.Registry {
+ return o.formats
+}
+
+// RegisterFormat registers a custom format validator
+func (o *CocsnAPI) RegisterFormat(name string, format strfmt.Format, validator strfmt.Validator) {
+ o.formats.Add(name, format, validator)
+}
+
+// Validate validates the registrations in the CocsnAPI
+func (o *CocsnAPI) Validate() error {
+ var unregistered []string
+
+ if o.JSONConsumer == nil {
+ unregistered = append(unregistered, "JSONConsumer")
+ }
+
+ if o.JSONProducer == nil {
+ unregistered = append(unregistered, "JSONProducer")
+ }
+
+ if o.InterfaceOperationsGetIPAddressesHandler == nil {
+ unregistered = append(unregistered, "interface_operations.GetIPAddressesHandler")
+ }
+ if o.InterfaceOperationsGetInterfacesHandler == nil {
+ unregistered = append(unregistered, "interface_operations.GetInterfacesHandler")
+ }
+ if o.InterfaceOperationsGetMACAddressHandler == nil {
+ unregistered = append(unregistered, "interface_operations.GetMACAddressHandler")
+ }
+
+ if len(unregistered) > 0 {
+ return fmt.Errorf("missing registration: %s", strings.Join(unregistered, ", "))
+ }
+
+ return nil
+}
+
+// ServeErrorFor gets a error handler for a given operation id
+func (o *CocsnAPI) ServeErrorFor(operationID string) func(http.ResponseWriter, *http.Request, error) {
+ return o.ServeError
+}
+
+// AuthenticatorsFor gets the authenticators for the specified security schemes
+func (o *CocsnAPI) AuthenticatorsFor(schemes map[string]spec.SecurityScheme) map[string]runtime.Authenticator {
+ return nil
+}
+
+// Authorizer returns the registered authorizer
+func (o *CocsnAPI) Authorizer() runtime.Authorizer {
+ return nil
+}
+
+// ConsumersFor gets the consumers for the specified media types.
+// MIME type parameters are ignored here.
+func (o *CocsnAPI) ConsumersFor(mediaTypes []string) map[string]runtime.Consumer {
+ result := make(map[string]runtime.Consumer, len(mediaTypes))
+ for _, mt := range mediaTypes {
+ switch mt {
+ case "application/json":
+ result["application/json"] = o.JSONConsumer
+ }
+
+ if c, ok := o.customConsumers[mt]; ok {
+ result[mt] = c
+ }
+ }
+ return result
+}
+
+// ProducersFor gets the producers for the specified media types.
+// MIME type parameters are ignored here.
+func (o *CocsnAPI) ProducersFor(mediaTypes []string) map[string]runtime.Producer {
+ result := make(map[string]runtime.Producer, len(mediaTypes))
+ for _, mt := range mediaTypes {
+ switch mt {
+ case "application/json":
+ result["application/json"] = o.JSONProducer
+ }
+
+ if p, ok := o.customProducers[mt]; ok {
+ result[mt] = p
+ }
+ }
+ return result
+}
+
+// HandlerFor gets a http.Handler for the provided operation method and path
+func (o *CocsnAPI) HandlerFor(method, path string) (http.Handler, bool) {
+ if o.handlers == nil {
+ return nil, false
+ }
+ um := strings.ToUpper(method)
+ if _, ok := o.handlers[um]; !ok {
+ return nil, false
+ }
+ if path == "/" {
+ path = ""
+ }
+ h, ok := o.handlers[um][path]
+ return h, ok
+}
+
+// Context returns the middleware context for the cocsn API
+func (o *CocsnAPI) Context() *middleware.Context {
+ if o.context == nil {
+ o.context = middleware.NewRoutableContext(o.spec, o, nil)
+ }
+
+ return o.context
+}
+
+func (o *CocsnAPI) initHandlerCache() {
+ o.Context() // don't care about the result, just that the initialization happened
+ if o.handlers == nil {
+ o.handlers = make(map[string]map[string]http.Handler)
+ }
+
+ if o.handlers["GET"] == nil {
+ o.handlers["GET"] = make(map[string]http.Handler)
+ }
+ o.handlers["GET"]["/data/cocsn-interface/{interface}/ip-addresses"] = interface_operations.NewGetIPAddresses(o.context, o.InterfaceOperationsGetIPAddressesHandler)
+ if o.handlers["GET"] == nil {
+ o.handlers["GET"] = make(map[string]http.Handler)
+ }
+ o.handlers["GET"]["/data/cocsn-interfaces"] = interface_operations.NewGetInterfaces(o.context, o.InterfaceOperationsGetInterfacesHandler)
+ if o.handlers["GET"] == nil {
+ o.handlers["GET"] = make(map[string]http.Handler)
+ }
+ o.handlers["GET"]["/data/cocsn-interface/{interface}/mac-address"] = interface_operations.NewGetMACAddress(o.context, o.InterfaceOperationsGetMACAddressHandler)
+}
+
+// Serve creates a http handler to serve the API over HTTP
+// can be used directly in http.ListenAndServe(":8000", api.Serve(nil))
+func (o *CocsnAPI) Serve(builder middleware.Builder) http.Handler {
+ o.Init()
+
+ if o.Middleware != nil {
+ return o.Middleware(builder)
+ }
+ if o.useSwaggerUI {
+ return o.context.APIHandlerSwaggerUI(builder)
+ }
+ return o.context.APIHandler(builder)
+}
+
+// Init allows you to just initialize the handler cache, you can then recompose the middleware as you see fit
+func (o *CocsnAPI) Init() {
+ if len(o.handlers) == 0 {
+ o.initHandlerCache()
+ }
+}
+
+// RegisterConsumer allows you to add (or override) a consumer for a media type.
+func (o *CocsnAPI) RegisterConsumer(mediaType string, consumer runtime.Consumer) {
+ o.customConsumers[mediaType] = consumer
+}
+
+// RegisterProducer allows you to add (or override) a producer for a media type.
+func (o *CocsnAPI) RegisterProducer(mediaType string, producer runtime.Producer) {
+ o.customProducers[mediaType] = producer
+}
+
+// AddMiddlewareFor adds a http middleware to existing handler
+func (o *CocsnAPI) AddMiddlewareFor(method, path string, builder middleware.Builder) {
+ um := strings.ToUpper(method)
+ if path == "/" {
+ path = ""
+ }
+ o.Init()
+ if h, ok := o.handlers[um][path]; ok {
+ o.handlers[method][path] = builder(h)
+ }
+}
diff --git a/restapi/operations/interface_operations/get_h_w_addresses.go b/restapi/operations/interface_operations/get_h_w_addresses.go
new file mode 100644
index 0000000000000000000000000000000000000000..f17a3ac83f2b02f41b11986482988481d59b5247
--- /dev/null
+++ b/restapi/operations/interface_operations/get_h_w_addresses.go
@@ -0,0 +1,58 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime/middleware"
+)
+
+// GetHWAddressesHandlerFunc turns a function with the right signature into a get h w addresses handler
+type GetHWAddressesHandlerFunc func(GetHWAddressesParams) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn GetHWAddressesHandlerFunc) Handle(params GetHWAddressesParams) middleware.Responder {
+ return fn(params)
+}
+
+// GetHWAddressesHandler interface for that can handle valid get h w addresses params
+type GetHWAddressesHandler interface {
+ Handle(GetHWAddressesParams) middleware.Responder
+}
+
+// NewGetHWAddresses creates a new http.Handler for the get h w addresses operation
+func NewGetHWAddresses(ctx *middleware.Context, handler GetHWAddressesHandler) *GetHWAddresses {
+ return &GetHWAddresses{Context: ctx, Handler: handler}
+}
+
+/*GetHWAddresses swagger:route GET /data/cocsn-interface/{interface}/mac-address interface getHWAddresses
+
+Returns harware address of an interface
+
+*/
+type GetHWAddresses struct {
+ Context *middleware.Context
+ Handler GetHWAddressesHandler
+}
+
+func (o *GetHWAddresses) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+ route, rCtx, _ := o.Context.RouteInfo(r)
+ if rCtx != nil {
+ r = rCtx
+ }
+ var Params = NewGetHWAddressesParams()
+
+ if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
+ o.Context.Respond(rw, r, route.Produces, route, err)
+ return
+ }
+
+ res := o.Handler.Handle(Params) // actually handle the request
+
+ o.Context.Respond(rw, r, route.Produces, route, res)
+
+}
diff --git a/restapi/operations/interface_operations/get_h_w_addresses_parameters.go b/restapi/operations/interface_operations/get_h_w_addresses_parameters.go
new file mode 100644
index 0000000000000000000000000000000000000000..1a7f7199a8ca957c288d0aac93899ec02a725661
--- /dev/null
+++ b/restapi/operations/interface_operations/get_h_w_addresses_parameters.go
@@ -0,0 +1,72 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/runtime/middleware"
+ "github.com/go-openapi/strfmt"
+)
+
+// NewGetHWAddressesParams creates a new GetHWAddressesParams object
+// no default values defined in spec.
+func NewGetHWAddressesParams() GetHWAddressesParams {
+
+ return GetHWAddressesParams{}
+}
+
+// GetHWAddressesParams contains all the bound params for the get h w addresses operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters getHWAddresses
+type GetHWAddressesParams struct {
+
+ // HTTP Request Object
+ HTTPRequest *http.Request `json:"-"`
+
+ /*interface to fetch
+ Required: true
+ In: path
+ */
+ Interface string
+}
+
+// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
+// for simple values it will use straight method calls.
+//
+// To ensure default values, the struct must have been initialized with NewGetHWAddressesParams() beforehand.
+func (o *GetHWAddressesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+ var res []error
+
+ o.HTTPRequest = r
+
+ rInterface, rhkInterface, _ := route.Params.GetOK("interface")
+ if err := o.bindInterface(rInterface, rhkInterface, route.Formats); err != nil {
+ res = append(res, err)
+ }
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
+
+// bindInterface binds and validates parameter Interface from path.
+func (o *GetHWAddressesParams) bindInterface(rawData []string, hasKey bool, formats strfmt.Registry) error {
+ var raw string
+ if len(rawData) > 0 {
+ raw = rawData[len(rawData)-1]
+ }
+
+ // Required: true
+ // Parameter is provided by construction from the route
+
+ o.Interface = raw
+
+ return nil
+}
diff --git a/restapi/operations/interface_operations/get_h_w_addresses_responses.go b/restapi/operations/interface_operations/get_h_w_addresses_responses.go
new file mode 100644
index 0000000000000000000000000000000000000000..a38bc7c3e338ae153ca44e9b032f40a4ba710c06
--- /dev/null
+++ b/restapi/operations/interface_operations/get_h_w_addresses_responses.go
@@ -0,0 +1,118 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/api/models"
+)
+
+// GetHWAddressesOKCode is the HTTP code returned for type GetHWAddressesOK
+const GetHWAddressesOKCode int = 200
+
+/*GetHWAddressesOK OK
+
+swagger:response getHWAddressesOK
+*/
+type GetHWAddressesOK struct {
+
+ /*
+ In: Body
+ */
+ Payload models.PhysicalAddress `json:"body,omitempty"`
+}
+
+// NewGetHWAddressesOK creates GetHWAddressesOK with default headers values
+func NewGetHWAddressesOK() *GetHWAddressesOK {
+
+ return &GetHWAddressesOK{}
+}
+
+// WithPayload adds the payload to the get h w addresses o k response
+func (o *GetHWAddressesOK) WithPayload(payload models.PhysicalAddress) *GetHWAddressesOK {
+ o.Payload = payload
+ return o
+}
+
+// SetPayload sets the payload to the get h w addresses o k response
+func (o *GetHWAddressesOK) SetPayload(payload models.PhysicalAddress) {
+ o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *GetHWAddressesOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.WriteHeader(200)
+ payload := o.Payload
+ if err := producer.Produce(rw, payload); err != nil {
+ panic(err) // let the recovery middleware deal with this
+ }
+}
+
+// GetHWAddressesNotFoundCode is the HTTP code returned for type GetHWAddressesNotFound
+const GetHWAddressesNotFoundCode int = 404
+
+/*GetHWAddressesNotFound An error occurred.
+
+swagger:response getHWAddressesNotFound
+*/
+type GetHWAddressesNotFound struct {
+}
+
+// NewGetHWAddressesNotFound creates GetHWAddressesNotFound with default headers values
+func NewGetHWAddressesNotFound() *GetHWAddressesNotFound {
+
+ return &GetHWAddressesNotFound{}
+}
+
+// WriteResponse to the client
+func (o *GetHWAddressesNotFound) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(404)
+}
+
+/*GetHWAddressesDefault Unexpected error
+
+swagger:response getHWAddressesDefault
+*/
+type GetHWAddressesDefault struct {
+ _statusCode int
+}
+
+// NewGetHWAddressesDefault creates GetHWAddressesDefault with default headers values
+func NewGetHWAddressesDefault(code int) *GetHWAddressesDefault {
+ if code <= 0 {
+ code = 500
+ }
+
+ return &GetHWAddressesDefault{
+ _statusCode: code,
+ }
+}
+
+// WithStatusCode adds the status to the get h w addresses default response
+func (o *GetHWAddressesDefault) WithStatusCode(code int) *GetHWAddressesDefault {
+ o._statusCode = code
+ return o
+}
+
+// SetStatusCode sets the status to the get h w addresses default response
+func (o *GetHWAddressesDefault) SetStatusCode(code int) {
+ o._statusCode = code
+}
+
+// WriteResponse to the client
+func (o *GetHWAddressesDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(o._statusCode)
+}
diff --git a/restapi/operations/interface_operations/get_h_w_addresses_urlbuilder.go b/restapi/operations/interface_operations/get_h_w_addresses_urlbuilder.go
new file mode 100644
index 0000000000000000000000000000000000000000..735ae77ae5e70f2e3a3a6227c496214dfd836014
--- /dev/null
+++ b/restapi/operations/interface_operations/get_h_w_addresses_urlbuilder.go
@@ -0,0 +1,99 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "errors"
+ "net/url"
+ golangswaggerpaths "path"
+ "strings"
+)
+
+// GetHWAddressesURL generates an URL for the get h w addresses operation
+type GetHWAddressesURL struct {
+ Interface string
+
+ _basePath string
+ // avoid unkeyed usage
+ _ struct{}
+}
+
+// WithBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetHWAddressesURL) WithBasePath(bp string) *GetHWAddressesURL {
+ o.SetBasePath(bp)
+ return o
+}
+
+// SetBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetHWAddressesURL) SetBasePath(bp string) {
+ o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *GetHWAddressesURL) Build() (*url.URL, error) {
+ var _result url.URL
+
+ var _path = "/data/cocsn-interface/{interface}/mac-address"
+
+ interfaceVar := o.Interface
+ if interfaceVar != "" {
+ _path = strings.Replace(_path, "{interface}", interfaceVar, -1)
+ } else {
+ return nil, errors.New("interface is required on GetHWAddressesURL")
+ }
+
+ _basePath := o._basePath
+ if _basePath == "" {
+ _basePath = "/restconf"
+ }
+ _result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+ return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *GetHWAddressesURL) Must(u *url.URL, err error) *url.URL {
+ if err != nil {
+ panic(err)
+ }
+ if u == nil {
+ panic("url can't be nil")
+ }
+ return u
+}
+
+// String returns the string representation of the path with query string
+func (o *GetHWAddressesURL) String() string {
+ return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *GetHWAddressesURL) BuildFull(scheme, host string) (*url.URL, error) {
+ if scheme == "" {
+ return nil, errors.New("scheme is required for a full url on GetHWAddressesURL")
+ }
+ if host == "" {
+ return nil, errors.New("host is required for a full url on GetHWAddressesURL")
+ }
+
+ base, err := o.Build()
+ if err != nil {
+ return nil, err
+ }
+
+ base.Scheme = scheme
+ base.Host = host
+ return base, nil
+}
+
+// StringFull returns the string representation of a complete url
+func (o *GetHWAddressesURL) StringFull(scheme, host string) string {
+ return o.Must(o.BuildFull(scheme, host)).String()
+}
diff --git a/restapi/operations/interface_operations/get_interfaces.go b/restapi/operations/interface_operations/get_interfaces.go
new file mode 100644
index 0000000000000000000000000000000000000000..cba107c3de571db8bb388570681755f4aa7f0efa
--- /dev/null
+++ b/restapi/operations/interface_operations/get_interfaces.go
@@ -0,0 +1,58 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime/middleware"
+)
+
+// GetInterfacesHandlerFunc turns a function with the right signature into a get interfaces handler
+type GetInterfacesHandlerFunc func(GetInterfacesParams) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn GetInterfacesHandlerFunc) Handle(params GetInterfacesParams) middleware.Responder {
+ return fn(params)
+}
+
+// GetInterfacesHandler interface for that can handle valid get interfaces params
+type GetInterfacesHandler interface {
+ Handle(GetInterfacesParams) middleware.Responder
+}
+
+// NewGetInterfaces creates a new http.Handler for the get interfaces operation
+func NewGetInterfaces(ctx *middleware.Context, handler GetInterfacesHandler) *GetInterfaces {
+ return &GetInterfaces{Context: ctx, Handler: handler}
+}
+
+/*GetInterfaces swagger:route GET /data/cocsn-interfaces interface getInterfaces
+
+Returns a list of interfaces
+
+*/
+type GetInterfaces struct {
+ Context *middleware.Context
+ Handler GetInterfacesHandler
+}
+
+func (o *GetInterfaces) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+ route, rCtx, _ := o.Context.RouteInfo(r)
+ if rCtx != nil {
+ r = rCtx
+ }
+ var Params = NewGetInterfacesParams()
+
+ if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
+ o.Context.Respond(rw, r, route.Produces, route, err)
+ return
+ }
+
+ res := o.Handler.Handle(Params) // actually handle the request
+
+ o.Context.Respond(rw, r, route.Produces, route, res)
+
+}
diff --git a/restapi/operations/interface_operations/get_interfaces_parameters.go b/restapi/operations/interface_operations/get_interfaces_parameters.go
new file mode 100644
index 0000000000000000000000000000000000000000..330b0af7ebff75099597a508361325b1d01770a0
--- /dev/null
+++ b/restapi/operations/interface_operations/get_interfaces_parameters.go
@@ -0,0 +1,45 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/runtime/middleware"
+)
+
+// NewGetInterfacesParams creates a new GetInterfacesParams object
+// no default values defined in spec.
+func NewGetInterfacesParams() GetInterfacesParams {
+
+ return GetInterfacesParams{}
+}
+
+// GetInterfacesParams contains all the bound params for the get interfaces operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters getInterfaces
+type GetInterfacesParams struct {
+
+ // HTTP Request Object
+ HTTPRequest *http.Request `json:"-"`
+}
+
+// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
+// for simple values it will use straight method calls.
+//
+// To ensure default values, the struct must have been initialized with NewGetInterfacesParams() beforehand.
+func (o *GetInterfacesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+ var res []error
+
+ o.HTTPRequest = r
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
diff --git a/restapi/operations/interface_operations/get_interfaces_responses.go b/restapi/operations/interface_operations/get_interfaces_responses.go
new file mode 100644
index 0000000000000000000000000000000000000000..f46829657a97e5285f52284e05e67f39ba489a10
--- /dev/null
+++ b/restapi/operations/interface_operations/get_interfaces_responses.go
@@ -0,0 +1,123 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/models"
+)
+
+// GetInterfacesOKCode is the HTTP code returned for type GetInterfacesOK
+const GetInterfacesOKCode int = 200
+
+/*GetInterfacesOK OK
+
+swagger:response getInterfacesOK
+*/
+type GetInterfacesOK struct {
+
+ /*
+ In: Body
+ */
+ Payload models.Interfaces `json:"body,omitempty"`
+}
+
+// NewGetInterfacesOK creates GetInterfacesOK with default headers values
+func NewGetInterfacesOK() *GetInterfacesOK {
+
+ return &GetInterfacesOK{}
+}
+
+// WithPayload adds the payload to the get interfaces o k response
+func (o *GetInterfacesOK) WithPayload(payload models.Interfaces) *GetInterfacesOK {
+ o.Payload = payload
+ return o
+}
+
+// SetPayload sets the payload to the get interfaces o k response
+func (o *GetInterfacesOK) SetPayload(payload models.Interfaces) {
+ o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *GetInterfacesOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.WriteHeader(200)
+ payload := o.Payload
+ if payload == nil {
+ // return empty array
+ payload = models.Interfaces{}
+ }
+
+ if err := producer.Produce(rw, payload); err != nil {
+ panic(err) // let the recovery middleware deal with this
+ }
+}
+
+// GetInterfacesNotFoundCode is the HTTP code returned for type GetInterfacesNotFound
+const GetInterfacesNotFoundCode int = 404
+
+/*GetInterfacesNotFound An error occurred.
+
+swagger:response getInterfacesNotFound
+*/
+type GetInterfacesNotFound struct {
+}
+
+// NewGetInterfacesNotFound creates GetInterfacesNotFound with default headers values
+func NewGetInterfacesNotFound() *GetInterfacesNotFound {
+
+ return &GetInterfacesNotFound{}
+}
+
+// WriteResponse to the client
+func (o *GetInterfacesNotFound) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(404)
+}
+
+/*GetInterfacesDefault Unexpected error
+
+swagger:response getInterfacesDefault
+*/
+type GetInterfacesDefault struct {
+ _statusCode int
+}
+
+// NewGetInterfacesDefault creates GetInterfacesDefault with default headers values
+func NewGetInterfacesDefault(code int) *GetInterfacesDefault {
+ if code <= 0 {
+ code = 500
+ }
+
+ return &GetInterfacesDefault{
+ _statusCode: code,
+ }
+}
+
+// WithStatusCode adds the status to the get interfaces default response
+func (o *GetInterfacesDefault) WithStatusCode(code int) *GetInterfacesDefault {
+ o._statusCode = code
+ return o
+}
+
+// SetStatusCode sets the status to the get interfaces default response
+func (o *GetInterfacesDefault) SetStatusCode(code int) {
+ o._statusCode = code
+}
+
+// WriteResponse to the client
+func (o *GetInterfacesDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(o._statusCode)
+}
diff --git a/restapi/operations/interface_operations/get_interfaces_urlbuilder.go b/restapi/operations/interface_operations/get_interfaces_urlbuilder.go
new file mode 100644
index 0000000000000000000000000000000000000000..eff39694c876fb9058acd067177c0b4308283fe7
--- /dev/null
+++ b/restapi/operations/interface_operations/get_interfaces_urlbuilder.go
@@ -0,0 +1,87 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "errors"
+ "net/url"
+ golangswaggerpaths "path"
+)
+
+// GetInterfacesURL generates an URL for the get interfaces operation
+type GetInterfacesURL struct {
+ _basePath string
+}
+
+// WithBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetInterfacesURL) WithBasePath(bp string) *GetInterfacesURL {
+ o.SetBasePath(bp)
+ return o
+}
+
+// SetBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetInterfacesURL) SetBasePath(bp string) {
+ o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *GetInterfacesURL) Build() (*url.URL, error) {
+ var _result url.URL
+
+ var _path = "/data/cocsn-interfaces"
+
+ _basePath := o._basePath
+ if _basePath == "" {
+ _basePath = "/restconf"
+ }
+ _result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+ return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *GetInterfacesURL) Must(u *url.URL, err error) *url.URL {
+ if err != nil {
+ panic(err)
+ }
+ if u == nil {
+ panic("url can't be nil")
+ }
+ return u
+}
+
+// String returns the string representation of the path with query string
+func (o *GetInterfacesURL) String() string {
+ return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *GetInterfacesURL) BuildFull(scheme, host string) (*url.URL, error) {
+ if scheme == "" {
+ return nil, errors.New("scheme is required for a full url on GetInterfacesURL")
+ }
+ if host == "" {
+ return nil, errors.New("host is required for a full url on GetInterfacesURL")
+ }
+
+ base, err := o.Build()
+ if err != nil {
+ return nil, err
+ }
+
+ base.Scheme = scheme
+ base.Host = host
+ return base, nil
+}
+
+// StringFull returns the string representation of a complete url
+func (o *GetInterfacesURL) StringFull(scheme, host string) string {
+ return o.Must(o.BuildFull(scheme, host)).String()
+}
diff --git a/restapi/operations/interface_operations/get_ip_addresses.go b/restapi/operations/interface_operations/get_ip_addresses.go
new file mode 100644
index 0000000000000000000000000000000000000000..e3f2089c35cd417fd9a913b44c130598744b24f1
--- /dev/null
+++ b/restapi/operations/interface_operations/get_ip_addresses.go
@@ -0,0 +1,58 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime/middleware"
+)
+
+// GetIPAddressesHandlerFunc turns a function with the right signature into a get IP addresses handler
+type GetIPAddressesHandlerFunc func(GetIPAddressesParams) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn GetIPAddressesHandlerFunc) Handle(params GetIPAddressesParams) middleware.Responder {
+ return fn(params)
+}
+
+// GetIPAddressesHandler interface for that can handle valid get IP addresses params
+type GetIPAddressesHandler interface {
+ Handle(GetIPAddressesParams) middleware.Responder
+}
+
+// NewGetIPAddresses creates a new http.Handler for the get IP addresses operation
+func NewGetIPAddresses(ctx *middleware.Context, handler GetIPAddressesHandler) *GetIPAddresses {
+ return &GetIPAddresses{Context: ctx, Handler: handler}
+}
+
+/*GetIPAddresses swagger:route GET /data/cocsn-interface/{interface}/ip-addresses interface getIpAddresses
+
+Returns IP addresses of an interface
+
+*/
+type GetIPAddresses struct {
+ Context *middleware.Context
+ Handler GetIPAddressesHandler
+}
+
+func (o *GetIPAddresses) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+ route, rCtx, _ := o.Context.RouteInfo(r)
+ if rCtx != nil {
+ r = rCtx
+ }
+ var Params = NewGetIPAddressesParams()
+
+ if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
+ o.Context.Respond(rw, r, route.Produces, route, err)
+ return
+ }
+
+ res := o.Handler.Handle(Params) // actually handle the request
+
+ o.Context.Respond(rw, r, route.Produces, route, res)
+
+}
diff --git a/restapi/operations/interface_operations/get_ip_addresses_parameters.go b/restapi/operations/interface_operations/get_ip_addresses_parameters.go
new file mode 100644
index 0000000000000000000000000000000000000000..b20a991f97ae8f9e93a3ef152a2f0a0bac71d0b4
--- /dev/null
+++ b/restapi/operations/interface_operations/get_ip_addresses_parameters.go
@@ -0,0 +1,72 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/runtime/middleware"
+ "github.com/go-openapi/strfmt"
+)
+
+// NewGetIPAddressesParams creates a new GetIPAddressesParams object
+// no default values defined in spec.
+func NewGetIPAddressesParams() GetIPAddressesParams {
+
+ return GetIPAddressesParams{}
+}
+
+// GetIPAddressesParams contains all the bound params for the get IP addresses operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters getIPAddresses
+type GetIPAddressesParams struct {
+
+ // HTTP Request Object
+ HTTPRequest *http.Request `json:"-"`
+
+ /*interface to fetch
+ Required: true
+ In: path
+ */
+ Interface string
+}
+
+// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
+// for simple values it will use straight method calls.
+//
+// To ensure default values, the struct must have been initialized with NewGetIPAddressesParams() beforehand.
+func (o *GetIPAddressesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+ var res []error
+
+ o.HTTPRequest = r
+
+ rInterface, rhkInterface, _ := route.Params.GetOK("interface")
+ if err := o.bindInterface(rInterface, rhkInterface, route.Formats); err != nil {
+ res = append(res, err)
+ }
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
+
+// bindInterface binds and validates parameter Interface from path.
+func (o *GetIPAddressesParams) bindInterface(rawData []string, hasKey bool, formats strfmt.Registry) error {
+ var raw string
+ if len(rawData) > 0 {
+ raw = rawData[len(rawData)-1]
+ }
+
+ // Required: true
+ // Parameter is provided by construction from the route
+
+ o.Interface = raw
+
+ return nil
+}
diff --git a/restapi/operations/interface_operations/get_ip_addresses_responses.go b/restapi/operations/interface_operations/get_ip_addresses_responses.go
new file mode 100644
index 0000000000000000000000000000000000000000..7fd666f560805dd7b5b8ebc7cfec5434734e1023
--- /dev/null
+++ b/restapi/operations/interface_operations/get_ip_addresses_responses.go
@@ -0,0 +1,123 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/models"
+)
+
+// GetIPAddressesOKCode is the HTTP code returned for type GetIPAddressesOK
+const GetIPAddressesOKCode int = 200
+
+/*GetIPAddressesOK OK
+
+swagger:response getIpAddressesOK
+*/
+type GetIPAddressesOK struct {
+
+ /*
+ In: Body
+ */
+ Payload models.LogicalAddresses `json:"body,omitempty"`
+}
+
+// NewGetIPAddressesOK creates GetIPAddressesOK with default headers values
+func NewGetIPAddressesOK() *GetIPAddressesOK {
+
+ return &GetIPAddressesOK{}
+}
+
+// WithPayload adds the payload to the get Ip addresses o k response
+func (o *GetIPAddressesOK) WithPayload(payload models.LogicalAddresses) *GetIPAddressesOK {
+ o.Payload = payload
+ return o
+}
+
+// SetPayload sets the payload to the get Ip addresses o k response
+func (o *GetIPAddressesOK) SetPayload(payload models.LogicalAddresses) {
+ o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *GetIPAddressesOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.WriteHeader(200)
+ payload := o.Payload
+ if payload == nil {
+ // return empty array
+ payload = models.LogicalAddresses{}
+ }
+
+ if err := producer.Produce(rw, payload); err != nil {
+ panic(err) // let the recovery middleware deal with this
+ }
+}
+
+// GetIPAddressesNotFoundCode is the HTTP code returned for type GetIPAddressesNotFound
+const GetIPAddressesNotFoundCode int = 404
+
+/*GetIPAddressesNotFound An error occurred.
+
+swagger:response getIpAddressesNotFound
+*/
+type GetIPAddressesNotFound struct {
+}
+
+// NewGetIPAddressesNotFound creates GetIPAddressesNotFound with default headers values
+func NewGetIPAddressesNotFound() *GetIPAddressesNotFound {
+
+ return &GetIPAddressesNotFound{}
+}
+
+// WriteResponse to the client
+func (o *GetIPAddressesNotFound) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(404)
+}
+
+/*GetIPAddressesDefault Unexpected error
+
+swagger:response getIpAddressesDefault
+*/
+type GetIPAddressesDefault struct {
+ _statusCode int
+}
+
+// NewGetIPAddressesDefault creates GetIPAddressesDefault with default headers values
+func NewGetIPAddressesDefault(code int) *GetIPAddressesDefault {
+ if code <= 0 {
+ code = 500
+ }
+
+ return &GetIPAddressesDefault{
+ _statusCode: code,
+ }
+}
+
+// WithStatusCode adds the status to the get IP addresses default response
+func (o *GetIPAddressesDefault) WithStatusCode(code int) *GetIPAddressesDefault {
+ o._statusCode = code
+ return o
+}
+
+// SetStatusCode sets the status to the get IP addresses default response
+func (o *GetIPAddressesDefault) SetStatusCode(code int) {
+ o._statusCode = code
+}
+
+// WriteResponse to the client
+func (o *GetIPAddressesDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(o._statusCode)
+}
diff --git a/restapi/operations/interface_operations/get_ip_addresses_urlbuilder.go b/restapi/operations/interface_operations/get_ip_addresses_urlbuilder.go
new file mode 100644
index 0000000000000000000000000000000000000000..75fc2c3e247a8e0eccddedc39b8cfc1b5b0cafa2
--- /dev/null
+++ b/restapi/operations/interface_operations/get_ip_addresses_urlbuilder.go
@@ -0,0 +1,99 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "errors"
+ "net/url"
+ golangswaggerpaths "path"
+ "strings"
+)
+
+// GetIPAddressesURL generates an URL for the get IP addresses operation
+type GetIPAddressesURL struct {
+ Interface string
+
+ _basePath string
+ // avoid unkeyed usage
+ _ struct{}
+}
+
+// WithBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetIPAddressesURL) WithBasePath(bp string) *GetIPAddressesURL {
+ o.SetBasePath(bp)
+ return o
+}
+
+// SetBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetIPAddressesURL) SetBasePath(bp string) {
+ o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *GetIPAddressesURL) Build() (*url.URL, error) {
+ var _result url.URL
+
+ var _path = "/data/cocsn-interface/{interface}/ip-addresses"
+
+ interfaceVar := o.Interface
+ if interfaceVar != "" {
+ _path = strings.Replace(_path, "{interface}", interfaceVar, -1)
+ } else {
+ return nil, errors.New("interface is required on GetIPAddressesURL")
+ }
+
+ _basePath := o._basePath
+ if _basePath == "" {
+ _basePath = "/restconf"
+ }
+ _result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+ return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *GetIPAddressesURL) Must(u *url.URL, err error) *url.URL {
+ if err != nil {
+ panic(err)
+ }
+ if u == nil {
+ panic("url can't be nil")
+ }
+ return u
+}
+
+// String returns the string representation of the path with query string
+func (o *GetIPAddressesURL) String() string {
+ return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *GetIPAddressesURL) BuildFull(scheme, host string) (*url.URL, error) {
+ if scheme == "" {
+ return nil, errors.New("scheme is required for a full url on GetIPAddressesURL")
+ }
+ if host == "" {
+ return nil, errors.New("host is required for a full url on GetIPAddressesURL")
+ }
+
+ base, err := o.Build()
+ if err != nil {
+ return nil, err
+ }
+
+ base.Scheme = scheme
+ base.Host = host
+ return base, nil
+}
+
+// StringFull returns the string representation of a complete url
+func (o *GetIPAddressesURL) StringFull(scheme, host string) string {
+ return o.Must(o.BuildFull(scheme, host)).String()
+}
diff --git a/restapi/operations/interface_operations/get_m_a_c_address.go b/restapi/operations/interface_operations/get_m_a_c_address.go
new file mode 100644
index 0000000000000000000000000000000000000000..8c96a9e56bd2c66c74a27015de37b23731c4bd84
--- /dev/null
+++ b/restapi/operations/interface_operations/get_m_a_c_address.go
@@ -0,0 +1,58 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime/middleware"
+)
+
+// GetMACAddressHandlerFunc turns a function with the right signature into a get m a c address handler
+type GetMACAddressHandlerFunc func(GetMACAddressParams) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn GetMACAddressHandlerFunc) Handle(params GetMACAddressParams) middleware.Responder {
+ return fn(params)
+}
+
+// GetMACAddressHandler interface for that can handle valid get m a c address params
+type GetMACAddressHandler interface {
+ Handle(GetMACAddressParams) middleware.Responder
+}
+
+// NewGetMACAddress creates a new http.Handler for the get m a c address operation
+func NewGetMACAddress(ctx *middleware.Context, handler GetMACAddressHandler) *GetMACAddress {
+ return &GetMACAddress{Context: ctx, Handler: handler}
+}
+
+/*GetMACAddress swagger:route GET /data/cocsn-interface/{interface}/mac-address interface getMACAddress
+
+Returns MAC address of an interface
+
+*/
+type GetMACAddress struct {
+ Context *middleware.Context
+ Handler GetMACAddressHandler
+}
+
+func (o *GetMACAddress) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+ route, rCtx, _ := o.Context.RouteInfo(r)
+ if rCtx != nil {
+ r = rCtx
+ }
+ var Params = NewGetMACAddressParams()
+
+ if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
+ o.Context.Respond(rw, r, route.Produces, route, err)
+ return
+ }
+
+ res := o.Handler.Handle(Params) // actually handle the request
+
+ o.Context.Respond(rw, r, route.Produces, route, res)
+
+}
diff --git a/restapi/operations/interface_operations/get_m_a_c_address_parameters.go b/restapi/operations/interface_operations/get_m_a_c_address_parameters.go
new file mode 100644
index 0000000000000000000000000000000000000000..b8dd99c33e68aeb41d5bb547e6e3ccb541741d8e
--- /dev/null
+++ b/restapi/operations/interface_operations/get_m_a_c_address_parameters.go
@@ -0,0 +1,72 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/errors"
+ "github.com/go-openapi/runtime/middleware"
+ "github.com/go-openapi/strfmt"
+)
+
+// NewGetMACAddressParams creates a new GetMACAddressParams object
+// no default values defined in spec.
+func NewGetMACAddressParams() GetMACAddressParams {
+
+ return GetMACAddressParams{}
+}
+
+// GetMACAddressParams contains all the bound params for the get m a c address operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters getMACAddress
+type GetMACAddressParams struct {
+
+ // HTTP Request Object
+ HTTPRequest *http.Request `json:"-"`
+
+ /*interface to fetch
+ Required: true
+ In: path
+ */
+ Interface string
+}
+
+// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
+// for simple values it will use straight method calls.
+//
+// To ensure default values, the struct must have been initialized with NewGetMACAddressParams() beforehand.
+func (o *GetMACAddressParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+ var res []error
+
+ o.HTTPRequest = r
+
+ rInterface, rhkInterface, _ := route.Params.GetOK("interface")
+ if err := o.bindInterface(rInterface, rhkInterface, route.Formats); err != nil {
+ res = append(res, err)
+ }
+
+ if len(res) > 0 {
+ return errors.CompositeValidationError(res...)
+ }
+ return nil
+}
+
+// bindInterface binds and validates parameter Interface from path.
+func (o *GetMACAddressParams) bindInterface(rawData []string, hasKey bool, formats strfmt.Registry) error {
+ var raw string
+ if len(rawData) > 0 {
+ raw = rawData[len(rawData)-1]
+ }
+
+ // Required: true
+ // Parameter is provided by construction from the route
+
+ o.Interface = raw
+
+ return nil
+}
diff --git a/restapi/operations/interface_operations/get_m_a_c_address_responses.go b/restapi/operations/interface_operations/get_m_a_c_address_responses.go
new file mode 100644
index 0000000000000000000000000000000000000000..478c413d60e3911605cfa4273400fae4f439ff1a
--- /dev/null
+++ b/restapi/operations/interface_operations/get_m_a_c_address_responses.go
@@ -0,0 +1,118 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+ "net/http"
+
+ "github.com/go-openapi/runtime"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/models"
+)
+
+// GetMACAddressOKCode is the HTTP code returned for type GetMACAddressOK
+const GetMACAddressOKCode int = 200
+
+/*GetMACAddressOK OK
+
+swagger:response getMACAddressOK
+*/
+type GetMACAddressOK struct {
+
+ /*
+ In: Body
+ */
+ Payload models.PhysicalAddress `json:"body,omitempty"`
+}
+
+// NewGetMACAddressOK creates GetMACAddressOK with default headers values
+func NewGetMACAddressOK() *GetMACAddressOK {
+
+ return &GetMACAddressOK{}
+}
+
+// WithPayload adds the payload to the get m a c address o k response
+func (o *GetMACAddressOK) WithPayload(payload models.PhysicalAddress) *GetMACAddressOK {
+ o.Payload = payload
+ return o
+}
+
+// SetPayload sets the payload to the get m a c address o k response
+func (o *GetMACAddressOK) SetPayload(payload models.PhysicalAddress) {
+ o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *GetMACAddressOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.WriteHeader(200)
+ payload := o.Payload
+ if err := producer.Produce(rw, payload); err != nil {
+ panic(err) // let the recovery middleware deal with this
+ }
+}
+
+// GetMACAddressNotFoundCode is the HTTP code returned for type GetMACAddressNotFound
+const GetMACAddressNotFoundCode int = 404
+
+/*GetMACAddressNotFound An error occurred.
+
+swagger:response getMACAddressNotFound
+*/
+type GetMACAddressNotFound struct {
+}
+
+// NewGetMACAddressNotFound creates GetMACAddressNotFound with default headers values
+func NewGetMACAddressNotFound() *GetMACAddressNotFound {
+
+ return &GetMACAddressNotFound{}
+}
+
+// WriteResponse to the client
+func (o *GetMACAddressNotFound) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(404)
+}
+
+/*GetMACAddressDefault Unexpected error
+
+swagger:response getMACAddressDefault
+*/
+type GetMACAddressDefault struct {
+ _statusCode int
+}
+
+// NewGetMACAddressDefault creates GetMACAddressDefault with default headers values
+func NewGetMACAddressDefault(code int) *GetMACAddressDefault {
+ if code <= 0 {
+ code = 500
+ }
+
+ return &GetMACAddressDefault{
+ _statusCode: code,
+ }
+}
+
+// WithStatusCode adds the status to the get m a c address default response
+func (o *GetMACAddressDefault) WithStatusCode(code int) *GetMACAddressDefault {
+ o._statusCode = code
+ return o
+}
+
+// SetStatusCode sets the status to the get m a c address default response
+func (o *GetMACAddressDefault) SetStatusCode(code int) {
+ o._statusCode = code
+}
+
+// WriteResponse to the client
+func (o *GetMACAddressDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+ rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+ rw.WriteHeader(o._statusCode)
+}
diff --git a/restapi/operations/interface_operations/get_m_a_c_address_urlbuilder.go b/restapi/operations/interface_operations/get_m_a_c_address_urlbuilder.go
new file mode 100644
index 0000000000000000000000000000000000000000..ce8bf56661b549a90ca29454dbd5d930b5be8273
--- /dev/null
+++ b/restapi/operations/interface_operations/get_m_a_c_address_urlbuilder.go
@@ -0,0 +1,99 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package interface_operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the generate command
+
+import (
+ "errors"
+ "net/url"
+ golangswaggerpaths "path"
+ "strings"
+)
+
+// GetMACAddressURL generates an URL for the get m a c address operation
+type GetMACAddressURL struct {
+ Interface string
+
+ _basePath string
+ // avoid unkeyed usage
+ _ struct{}
+}
+
+// WithBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetMACAddressURL) WithBasePath(bp string) *GetMACAddressURL {
+ o.SetBasePath(bp)
+ return o
+}
+
+// SetBasePath sets the base path for this url builder, only required when it's different from the
+// base path specified in the swagger spec.
+// When the value of the base path is an empty string
+func (o *GetMACAddressURL) SetBasePath(bp string) {
+ o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *GetMACAddressURL) Build() (*url.URL, error) {
+ var _result url.URL
+
+ var _path = "/data/cocsn-interface/{interface}/mac-address"
+
+ interfaceVar := o.Interface
+ if interfaceVar != "" {
+ _path = strings.Replace(_path, "{interface}", interfaceVar, -1)
+ } else {
+ return nil, errors.New("interface is required on GetMACAddressURL")
+ }
+
+ _basePath := o._basePath
+ if _basePath == "" {
+ _basePath = "/restconf"
+ }
+ _result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+ return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *GetMACAddressURL) Must(u *url.URL, err error) *url.URL {
+ if err != nil {
+ panic(err)
+ }
+ if u == nil {
+ panic("url can't be nil")
+ }
+ return u
+}
+
+// String returns the string representation of the path with query string
+func (o *GetMACAddressURL) String() string {
+ return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *GetMACAddressURL) BuildFull(scheme, host string) (*url.URL, error) {
+ if scheme == "" {
+ return nil, errors.New("scheme is required for a full url on GetMACAddressURL")
+ }
+ if host == "" {
+ return nil, errors.New("host is required for a full url on GetMACAddressURL")
+ }
+
+ base, err := o.Build()
+ if err != nil {
+ return nil, err
+ }
+
+ base.Scheme = scheme
+ base.Host = host
+ return base, nil
+}
+
+// StringFull returns the string representation of a complete url
+func (o *GetMACAddressURL) StringFull(scheme, host string) string {
+ return o.Must(o.BuildFull(scheme, host)).String()
+}
diff --git a/restapi/server.go b/restapi/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..11a359a80ea9dbf087d0fd8b93c819bdbeae12eb
--- /dev/null
+++ b/restapi/server.go
@@ -0,0 +1,511 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+package restapi
+
+import (
+ "context"
+ "crypto/tls"
+ "crypto/x509"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "net"
+ "net/http"
+ "os"
+ "os/signal"
+ "strconv"
+ "sync"
+ "sync/atomic"
+ "syscall"
+ "time"
+
+ "github.com/go-openapi/runtime/flagext"
+ "github.com/go-openapi/swag"
+ flags "github.com/jessevdk/go-flags"
+ "golang.org/x/net/netutil"
+
+ "code.fbi.h-da.de/cocsn/cocsn-api/restapi/operations"
+)
+
+const (
+ schemeHTTP = "http"
+ schemeHTTPS = "https"
+ schemeUnix = "unix"
+)
+
+var defaultSchemes []string
+
+func init() {
+ defaultSchemes = []string{
+ schemeHTTP,
+ }
+}
+
+// NewServer creates a new api cocsn server but does not configure it
+func NewServer(api *operations.CocsnAPI) *Server {
+ s := new(Server)
+
+ s.shutdown = make(chan struct{})
+ s.api = api
+ s.interrupt = make(chan os.Signal, 1)
+ return s
+}
+
+// ConfigureAPI configures the API and handlers.
+func (s *Server) ConfigureAPI() {
+ if s.api != nil {
+ s.handler = configureAPI(s.api)
+ }
+}
+
+// ConfigureFlags configures the additional flags defined by the handlers. Needs to be called before the parser.Parse
+func (s *Server) ConfigureFlags() {
+ if s.api != nil {
+ configureFlags(s.api)
+ }
+}
+
+// Server for the cocsn API
+type Server struct {
+ EnabledListeners []string `long:"scheme" description:"the listeners to enable, this can be repeated and defaults to the schemes in the swagger spec"`
+ CleanupTimeout time.Duration `long:"cleanup-timeout" description:"grace period for which to wait before killing idle connections" default:"10s"`
+ GracefulTimeout time.Duration `long:"graceful-timeout" description:"grace period for which to wait before shutting down the server" default:"15s"`
+ MaxHeaderSize flagext.ByteSize `long:"max-header-size" description:"controls the maximum number of bytes the server will read parsing the request header's keys and values, including the request line. It does not limit the size of the request body." default:"1MiB"`
+
+ SocketPath flags.Filename `long:"socket-path" description:"the unix socket to listen on" default:"/var/run/cocsn.sock"`
+ domainSocketL net.Listener
+
+ Host string `long:"host" description:"the IP to listen on" default:"localhost" env:"HOST"`
+ Port int `long:"port" description:"the port to listen on for insecure connections, defaults to a random value" env:"PORT"`
+ ListenLimit int `long:"listen-limit" description:"limit the number of outstanding requests"`
+ KeepAlive time.Duration `long:"keep-alive" description:"sets the TCP keep-alive timeouts on accepted connections. It prunes dead TCP connections ( e.g. closing laptop mid-download)" default:"3m"`
+ ReadTimeout time.Duration `long:"read-timeout" description:"maximum duration before timing out read of the request" default:"30s"`
+ WriteTimeout time.Duration `long:"write-timeout" description:"maximum duration before timing out write of the response" default:"60s"`
+ httpServerL net.Listener
+
+ TLSHost string `long:"tls-host" description:"the IP to listen on for tls, when not specified it's the same as --host" env:"TLS_HOST"`
+ TLSPort int `long:"tls-port" description:"the port to listen on for secure connections, defaults to a random value" env:"TLS_PORT"`
+ TLSCertificate flags.Filename `long:"tls-certificate" description:"the certificate to use for secure connections" env:"TLS_CERTIFICATE"`
+ TLSCertificateKey flags.Filename `long:"tls-key" description:"the private key to use for secure connections" env:"TLS_PRIVATE_KEY"`
+ TLSCACertificate flags.Filename `long:"tls-ca" description:"the certificate authority file to be used with mutual tls auth" env:"TLS_CA_CERTIFICATE"`
+ TLSListenLimit int `long:"tls-listen-limit" description:"limit the number of outstanding requests"`
+ TLSKeepAlive time.Duration `long:"tls-keep-alive" description:"sets the TCP keep-alive timeouts on accepted connections. It prunes dead TCP connections ( e.g. closing laptop mid-download)"`
+ TLSReadTimeout time.Duration `long:"tls-read-timeout" description:"maximum duration before timing out read of the request"`
+ TLSWriteTimeout time.Duration `long:"tls-write-timeout" description:"maximum duration before timing out write of the response"`
+ httpsServerL net.Listener
+
+ api *operations.CocsnAPI
+ handler http.Handler
+ hasListeners bool
+ shutdown chan struct{}
+ shuttingDown int32
+ interrupted bool
+ interrupt chan os.Signal
+}
+
+// Logf logs message either via defined user logger or via system one if no user logger is defined.
+func (s *Server) Logf(f string, args ...interface{}) {
+ if s.api != nil && s.api.Logger != nil {
+ s.api.Logger(f, args...)
+ } else {
+ log.Printf(f, args...)
+ }
+}
+
+// Fatalf logs message either via defined user logger or via system one if no user logger is defined.
+// Exits with non-zero status after printing
+func (s *Server) Fatalf(f string, args ...interface{}) {
+ if s.api != nil && s.api.Logger != nil {
+ s.api.Logger(f, args...)
+ os.Exit(1)
+ } else {
+ log.Fatalf(f, args...)
+ }
+}
+
+// SetAPI configures the server with the specified API. Needs to be called before Serve
+func (s *Server) SetAPI(api *operations.CocsnAPI) {
+ if api == nil {
+ s.api = nil
+ s.handler = nil
+ return
+ }
+
+ s.api = api
+ s.handler = configureAPI(api)
+}
+
+func (s *Server) hasScheme(scheme string) bool {
+ schemes := s.EnabledListeners
+ if len(schemes) == 0 {
+ schemes = defaultSchemes
+ }
+
+ for _, v := range schemes {
+ if v == scheme {
+ return true
+ }
+ }
+ return false
+}
+
+// Serve the api
+func (s *Server) Serve() (err error) {
+ if !s.hasListeners {
+ if err = s.Listen(); err != nil {
+ return err
+ }
+ }
+
+ // set default handler, if none is set
+ if s.handler == nil {
+ if s.api == nil {
+ return errors.New("can't create the default handler, as no api is set")
+ }
+
+ s.SetHandler(s.api.Serve(nil))
+ }
+
+ wg := new(sync.WaitGroup)
+ once := new(sync.Once)
+ signalNotify(s.interrupt)
+ go handleInterrupt(once, s)
+
+ servers := []*http.Server{}
+
+ if s.hasScheme(schemeUnix) {
+ domainSocket := new(http.Server)
+ domainSocket.MaxHeaderBytes = int(s.MaxHeaderSize)
+ domainSocket.Handler = s.handler
+ if int64(s.CleanupTimeout) > 0 {
+ domainSocket.IdleTimeout = s.CleanupTimeout
+ }
+
+ configureServer(domainSocket, "unix", string(s.SocketPath))
+
+ servers = append(servers, domainSocket)
+ wg.Add(1)
+ s.Logf("Serving cocsn at unix://%s", s.SocketPath)
+ go func(l net.Listener) {
+ defer wg.Done()
+ if err := domainSocket.Serve(l); err != nil && err != http.ErrServerClosed {
+ s.Fatalf("%v", err)
+ }
+ s.Logf("Stopped serving cocsn at unix://%s", s.SocketPath)
+ }(s.domainSocketL)
+ }
+
+ if s.hasScheme(schemeHTTP) {
+ httpServer := new(http.Server)
+ httpServer.MaxHeaderBytes = int(s.MaxHeaderSize)
+ httpServer.ReadTimeout = s.ReadTimeout
+ httpServer.WriteTimeout = s.WriteTimeout
+ httpServer.SetKeepAlivesEnabled(int64(s.KeepAlive) > 0)
+ if s.ListenLimit > 0 {
+ s.httpServerL = netutil.LimitListener(s.httpServerL, s.ListenLimit)
+ }
+
+ if int64(s.CleanupTimeout) > 0 {
+ httpServer.IdleTimeout = s.CleanupTimeout
+ }
+
+ httpServer.Handler = s.handler
+
+ configureServer(httpServer, "http", s.httpServerL.Addr().String())
+
+ servers = append(servers, httpServer)
+ wg.Add(1)
+ s.Logf("Serving cocsn at http://%s", s.httpServerL.Addr())
+ go func(l net.Listener) {
+ defer wg.Done()
+ if err := httpServer.Serve(l); err != nil && err != http.ErrServerClosed {
+ s.Fatalf("%v", err)
+ }
+ s.Logf("Stopped serving cocsn at http://%s", l.Addr())
+ }(s.httpServerL)
+ }
+
+ if s.hasScheme(schemeHTTPS) {
+ httpsServer := new(http.Server)
+ httpsServer.MaxHeaderBytes = int(s.MaxHeaderSize)
+ httpsServer.ReadTimeout = s.TLSReadTimeout
+ httpsServer.WriteTimeout = s.TLSWriteTimeout
+ httpsServer.SetKeepAlivesEnabled(int64(s.TLSKeepAlive) > 0)
+ if s.TLSListenLimit > 0 {
+ s.httpsServerL = netutil.LimitListener(s.httpsServerL, s.TLSListenLimit)
+ }
+ if int64(s.CleanupTimeout) > 0 {
+ httpsServer.IdleTimeout = s.CleanupTimeout
+ }
+ httpsServer.Handler = s.handler
+
+ // Inspired by https://blog.bracebin.com/achieving-perfect-ssl-labs-score-with-go
+ httpsServer.TLSConfig = &tls.Config{
+ // Causes servers to use Go's default ciphersuite preferences,
+ // which are tuned to avoid attacks. Does nothing on clients.
+ PreferServerCipherSuites: true,
+ // Only use curves which have assembly implementations
+ // https://github.com/golang/go/tree/master/src/crypto/elliptic
+ CurvePreferences: []tls.CurveID{tls.CurveP256},
+ // Use modern tls mode https://wiki.mozilla.org/Security/Server_Side_TLS#Modern_compatibility
+ NextProtos: []string{"h2", "http/1.1"},
+ // https://www.owasp.org/index.php/Transport_Layer_Protection_Cheat_Sheet#Rule_-_Only_Support_Strong_Protocols
+ MinVersion: tls.VersionTLS12,
+ // These ciphersuites support Forward Secrecy: https://en.wikipedia.org/wiki/Forward_secrecy
+ CipherSuites: []uint16{
+ tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+ tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+ tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+ tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+ tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+ tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+ },
+ }
+
+ // build standard config from server options
+ if s.TLSCertificate != "" && s.TLSCertificateKey != "" {
+ httpsServer.TLSConfig.Certificates = make([]tls.Certificate, 1)
+ httpsServer.TLSConfig.Certificates[0], err = tls.LoadX509KeyPair(string(s.TLSCertificate), string(s.TLSCertificateKey))
+ if err != nil {
+ return err
+ }
+ }
+
+ if s.TLSCACertificate != "" {
+ // include specified CA certificate
+ caCert, caCertErr := ioutil.ReadFile(string(s.TLSCACertificate))
+ if caCertErr != nil {
+ return caCertErr
+ }
+ caCertPool := x509.NewCertPool()
+ ok := caCertPool.AppendCertsFromPEM(caCert)
+ if !ok {
+ return fmt.Errorf("cannot parse CA certificate")
+ }
+ httpsServer.TLSConfig.ClientCAs = caCertPool
+ httpsServer.TLSConfig.ClientAuth = tls.RequireAndVerifyClientCert
+ }
+
+ // call custom TLS configurator
+ configureTLS(httpsServer.TLSConfig)
+
+ if len(httpsServer.TLSConfig.Certificates) == 0 && httpsServer.TLSConfig.GetCertificate == nil {
+ // after standard and custom config are passed, this ends up with no certificate
+ if s.TLSCertificate == "" {
+ if s.TLSCertificateKey == "" {
+ s.Fatalf("the required flags `--tls-certificate` and `--tls-key` were not specified")
+ }
+ s.Fatalf("the required flag `--tls-certificate` was not specified")
+ }
+ if s.TLSCertificateKey == "" {
+ s.Fatalf("the required flag `--tls-key` was not specified")
+ }
+ // this happens with a wrong custom TLS configurator
+ s.Fatalf("no certificate was configured for TLS")
+ }
+
+ // must have at least one certificate or panics
+ httpsServer.TLSConfig.BuildNameToCertificate()
+
+ configureServer(httpsServer, "https", s.httpsServerL.Addr().String())
+
+ servers = append(servers, httpsServer)
+ wg.Add(1)
+ s.Logf("Serving cocsn at https://%s", s.httpsServerL.Addr())
+ go func(l net.Listener) {
+ defer wg.Done()
+ if err := httpsServer.Serve(l); err != nil && err != http.ErrServerClosed {
+ s.Fatalf("%v", err)
+ }
+ s.Logf("Stopped serving cocsn at https://%s", l.Addr())
+ }(tls.NewListener(s.httpsServerL, httpsServer.TLSConfig))
+ }
+
+ wg.Add(1)
+ go s.handleShutdown(wg, &servers)
+
+ wg.Wait()
+ return nil
+}
+
+// Listen creates the listeners for the server
+func (s *Server) Listen() error {
+ if s.hasListeners { // already done this
+ return nil
+ }
+
+ if s.hasScheme(schemeHTTPS) {
+ // Use http host if https host wasn't defined
+ if s.TLSHost == "" {
+ s.TLSHost = s.Host
+ }
+ // Use http listen limit if https listen limit wasn't defined
+ if s.TLSListenLimit == 0 {
+ s.TLSListenLimit = s.ListenLimit
+ }
+ // Use http tcp keep alive if https tcp keep alive wasn't defined
+ if int64(s.TLSKeepAlive) == 0 {
+ s.TLSKeepAlive = s.KeepAlive
+ }
+ // Use http read timeout if https read timeout wasn't defined
+ if int64(s.TLSReadTimeout) == 0 {
+ s.TLSReadTimeout = s.ReadTimeout
+ }
+ // Use http write timeout if https write timeout wasn't defined
+ if int64(s.TLSWriteTimeout) == 0 {
+ s.TLSWriteTimeout = s.WriteTimeout
+ }
+ }
+
+ if s.hasScheme(schemeUnix) {
+ domSockListener, err := net.Listen("unix", string(s.SocketPath))
+ if err != nil {
+ return err
+ }
+ s.domainSocketL = domSockListener
+ }
+
+ if s.hasScheme(schemeHTTP) {
+ listener, err := net.Listen("tcp", net.JoinHostPort(s.Host, strconv.Itoa(s.Port)))
+ if err != nil {
+ return err
+ }
+
+ h, p, err := swag.SplitHostPort(listener.Addr().String())
+ if err != nil {
+ return err
+ }
+ s.Host = h
+ s.Port = p
+ s.httpServerL = listener
+ }
+
+ if s.hasScheme(schemeHTTPS) {
+ tlsListener, err := net.Listen("tcp", net.JoinHostPort(s.TLSHost, strconv.Itoa(s.TLSPort)))
+ if err != nil {
+ return err
+ }
+
+ sh, sp, err := swag.SplitHostPort(tlsListener.Addr().String())
+ if err != nil {
+ return err
+ }
+ s.TLSHost = sh
+ s.TLSPort = sp
+ s.httpsServerL = tlsListener
+ }
+
+ s.hasListeners = true
+ return nil
+}
+
+// Shutdown server and clean up resources
+func (s *Server) Shutdown() error {
+ if atomic.CompareAndSwapInt32(&s.shuttingDown, 0, 1) {
+ close(s.shutdown)
+ }
+ return nil
+}
+
+func (s *Server) handleShutdown(wg *sync.WaitGroup, serversPtr *[]*http.Server) {
+ // wg.Done must occur last, after s.api.ServerShutdown()
+ // (to preserve old behaviour)
+ defer wg.Done()
+
+ <-s.shutdown
+
+ servers := *serversPtr
+
+ ctx, cancel := context.WithTimeout(context.TODO(), s.GracefulTimeout)
+ defer cancel()
+
+ // first execute the pre-shutdown hook
+ s.api.PreServerShutdown()
+
+ shutdownChan := make(chan bool)
+ for i := range servers {
+ server := servers[i]
+ go func() {
+ var success bool
+ defer func() {
+ shutdownChan <- success
+ }()
+ if err := server.Shutdown(ctx); err != nil {
+ // Error from closing listeners, or context timeout:
+ s.Logf("HTTP server Shutdown: %v", err)
+ } else {
+ success = true
+ }
+ }()
+ }
+
+ // Wait until all listeners have successfully shut down before calling ServerShutdown
+ success := true
+ for range servers {
+ success = success && <-shutdownChan
+ }
+ if success {
+ s.api.ServerShutdown()
+ }
+}
+
+// GetHandler returns a handler useful for testing
+func (s *Server) GetHandler() http.Handler {
+ return s.handler
+}
+
+// SetHandler allows for setting a http handler on this server
+func (s *Server) SetHandler(handler http.Handler) {
+ s.handler = handler
+}
+
+// UnixListener returns the domain socket listener
+func (s *Server) UnixListener() (net.Listener, error) {
+ if !s.hasListeners {
+ if err := s.Listen(); err != nil {
+ return nil, err
+ }
+ }
+ return s.domainSocketL, nil
+}
+
+// HTTPListener returns the http listener
+func (s *Server) HTTPListener() (net.Listener, error) {
+ if !s.hasListeners {
+ if err := s.Listen(); err != nil {
+ return nil, err
+ }
+ }
+ return s.httpServerL, nil
+}
+
+// TLSListener returns the https listener
+func (s *Server) TLSListener() (net.Listener, error) {
+ if !s.hasListeners {
+ if err := s.Listen(); err != nil {
+ return nil, err
+ }
+ }
+ return s.httpsServerL, nil
+}
+
+func handleInterrupt(once *sync.Once, s *Server) {
+ once.Do(func() {
+ for range s.interrupt {
+ if s.interrupted {
+ s.Logf("Server already shutting down")
+ continue
+ }
+ s.interrupted = true
+ s.Logf("Shutting down... ")
+ if err := s.Shutdown(); err != nil {
+ s.Logf("HTTP server Shutdown: %v", err)
+ }
+ }
+ })
+}
+
+func signalNotify(interrupt chan<- os.Signal) {
+ signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)
+}