2017-05-23 18:56:10 +00:00
|
|
|
package proxy
|
|
|
|
|
|
|
|
import (
|
|
|
|
"net/http"
|
|
|
|
"net/url"
|
2018-12-09 03:49:27 +00:00
|
|
|
"strconv"
|
2017-05-23 18:56:10 +00:00
|
|
|
|
|
|
|
"github.com/orcaman/concurrent-map"
|
2019-03-21 01:20:14 +00:00
|
|
|
"github.com/portainer/portainer/api"
|
2017-05-23 18:56:10 +00:00
|
|
|
)
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// TODO: contain code related to legacy extension management
|
|
|
|
|
|
|
|
var extensionPorts = map[portainer.ExtensionID]string{
|
2019-02-18 01:46:34 +00:00
|
|
|
portainer.RegistryManagementExtension: "7001",
|
|
|
|
portainer.OAuthAuthenticationExtension: "7002",
|
2018-12-09 03:49:27 +00:00
|
|
|
}
|
|
|
|
|
2018-05-06 07:15:57 +00:00
|
|
|
type (
|
|
|
|
// Manager represents a service used to manage Docker proxies.
|
|
|
|
Manager struct {
|
2018-12-09 03:49:27 +00:00
|
|
|
proxyFactory *proxyFactory
|
|
|
|
proxies cmap.ConcurrentMap
|
|
|
|
extensionProxies cmap.ConcurrentMap
|
|
|
|
legacyExtensionProxies cmap.ConcurrentMap
|
2018-05-06 07:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ManagerParams represents the required parameters to create a new Manager instance.
|
|
|
|
ManagerParams struct {
|
|
|
|
ResourceControlService portainer.ResourceControlService
|
|
|
|
TeamMembershipService portainer.TeamMembershipService
|
|
|
|
SettingsService portainer.SettingsService
|
|
|
|
RegistryService portainer.RegistryService
|
|
|
|
DockerHubService portainer.DockerHubService
|
|
|
|
SignatureService portainer.DigitalSignatureService
|
|
|
|
}
|
|
|
|
)
|
2017-05-23 18:56:10 +00:00
|
|
|
|
|
|
|
// NewManager initializes a new proxy Service
|
2018-05-06 07:15:57 +00:00
|
|
|
func NewManager(parameters *ManagerParams) *Manager {
|
2017-05-23 18:56:10 +00:00
|
|
|
return &Manager{
|
2018-12-09 03:49:27 +00:00
|
|
|
proxies: cmap.New(),
|
|
|
|
extensionProxies: cmap.New(),
|
|
|
|
legacyExtensionProxies: cmap.New(),
|
2017-05-23 18:56:10 +00:00
|
|
|
proxyFactory: &proxyFactory{
|
2018-05-06 07:15:57 +00:00
|
|
|
ResourceControlService: parameters.ResourceControlService,
|
|
|
|
TeamMembershipService: parameters.TeamMembershipService,
|
|
|
|
SettingsService: parameters.SettingsService,
|
|
|
|
RegistryService: parameters.RegistryService,
|
|
|
|
DockerHubService: parameters.DockerHubService,
|
|
|
|
SignatureService: parameters.SignatureService,
|
2017-05-23 18:56:10 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// GetProxy returns the proxy associated to a key
|
|
|
|
func (manager *Manager) GetProxy(key string) http.Handler {
|
|
|
|
proxy, ok := manager.proxies.Get(key)
|
|
|
|
if !ok {
|
|
|
|
return nil
|
2018-05-06 07:15:57 +00:00
|
|
|
}
|
2018-12-09 03:49:27 +00:00
|
|
|
return proxy.(http.Handler)
|
2018-05-28 14:40:33 +00:00
|
|
|
}
|
2018-05-06 07:15:57 +00:00
|
|
|
|
2018-05-28 14:40:33 +00:00
|
|
|
// CreateAndRegisterProxy creates a new HTTP reverse proxy based on endpoint properties and and adds it to the registered proxies.
|
|
|
|
// It can also be used to create a new HTTP reverse proxy and replace an already registered proxy.
|
|
|
|
func (manager *Manager) CreateAndRegisterProxy(endpoint *portainer.Endpoint) (http.Handler, error) {
|
|
|
|
proxy, err := manager.createProxy(endpoint)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2017-05-23 18:56:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
manager.proxies.Set(string(endpoint.ID), proxy)
|
|
|
|
return proxy, nil
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// DeleteProxy deletes the proxy associated to a key
|
|
|
|
func (manager *Manager) DeleteProxy(key string) {
|
|
|
|
manager.proxies.Remove(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetExtensionProxy returns an extension proxy associated to an extension identifier
|
|
|
|
func (manager *Manager) GetExtensionProxy(extensionID portainer.ExtensionID) http.Handler {
|
|
|
|
proxy, ok := manager.extensionProxies.Get(strconv.Itoa(int(extensionID)))
|
2017-05-23 18:56:10 +00:00
|
|
|
if !ok {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return proxy.(http.Handler)
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// CreateExtensionProxy creates a new HTTP reverse proxy for an extension and
|
|
|
|
// registers it in the extension map associated to the specified extension identifier
|
|
|
|
func (manager *Manager) CreateExtensionProxy(extensionID portainer.ExtensionID) (http.Handler, error) {
|
|
|
|
address := "http://localhost:" + extensionPorts[extensionID]
|
2018-02-23 02:10:26 +00:00
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
extensionURL, err := url.Parse(address)
|
2018-02-23 02:10:26 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2018-05-28 14:40:33 +00:00
|
|
|
proxy := manager.proxyFactory.newHTTPProxy(extensionURL)
|
2018-12-09 03:49:27 +00:00
|
|
|
manager.extensionProxies.Set(strconv.Itoa(int(extensionID)), proxy)
|
|
|
|
|
2018-02-23 02:10:26 +00:00
|
|
|
return proxy, nil
|
|
|
|
}
|
|
|
|
|
2019-03-10 23:50:10 +00:00
|
|
|
// GetExtensionURL retrieves the URL of an extension running locally based on the extension port table
|
2019-02-18 01:46:34 +00:00
|
|
|
func (manager *Manager) GetExtensionURL(extensionID portainer.ExtensionID) string {
|
|
|
|
return "http://localhost:" + extensionPorts[extensionID]
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// DeleteExtensionProxy deletes the extension proxy associated to an extension identifier
|
|
|
|
func (manager *Manager) DeleteExtensionProxy(extensionID portainer.ExtensionID) {
|
|
|
|
manager.extensionProxies.Remove(strconv.Itoa(int(extensionID)))
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetLegacyExtensionProxy returns a legacy extension proxy associated to a key
|
|
|
|
func (manager *Manager) GetLegacyExtensionProxy(key string) http.Handler {
|
|
|
|
proxy, ok := manager.legacyExtensionProxies.Get(key)
|
2018-02-23 02:10:26 +00:00
|
|
|
if !ok {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return proxy.(http.Handler)
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// CreateLegacyExtensionProxy creates a new HTTP reverse proxy for a legacy extension and adds it to the registered proxies.
|
|
|
|
func (manager *Manager) CreateLegacyExtensionProxy(key, extensionAPIURL string) (http.Handler, error) {
|
|
|
|
extensionURL, err := url.Parse(extensionAPIURL)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
proxy := manager.proxyFactory.newHTTPProxy(extensionURL)
|
|
|
|
manager.extensionProxies.Set(key, proxy)
|
|
|
|
return proxy, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (manager *Manager) createDockerProxy(endpointURL *url.URL, tlsConfig *portainer.TLSConfiguration) (http.Handler, error) {
|
|
|
|
if endpointURL.Scheme == "tcp" {
|
|
|
|
if tlsConfig.TLS || tlsConfig.TLSSkipVerify {
|
|
|
|
return manager.proxyFactory.newDockerHTTPSProxy(endpointURL, tlsConfig, false)
|
2018-02-23 02:10:26 +00:00
|
|
|
}
|
2018-12-09 03:49:27 +00:00
|
|
|
return manager.proxyFactory.newDockerHTTPProxy(endpointURL, false), nil
|
|
|
|
}
|
|
|
|
return manager.proxyFactory.newLocalProxy(endpointURL.Path), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (manager *Manager) createProxy(endpoint *portainer.Endpoint) (http.Handler, error) {
|
|
|
|
endpointURL, err := url.Parse(endpoint.URL)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
switch endpoint.Type {
|
|
|
|
case portainer.AgentOnDockerEnvironment:
|
|
|
|
return manager.proxyFactory.newDockerHTTPSProxy(endpointURL, &endpoint.TLSConfig, true)
|
|
|
|
case portainer.AzureEnvironment:
|
|
|
|
return newAzureProxy(&endpoint.AzureCredentials)
|
|
|
|
default:
|
|
|
|
return manager.createDockerProxy(endpointURL, &endpoint.TLSConfig)
|
2018-02-23 02:10:26 +00:00
|
|
|
}
|
|
|
|
}
|