Docker/portainer
Docker/portainer
1
0
Fork 0
mirror of https://github.com/portainer/portainer.git synced 2025-07-24 15:59:41 +02:00
Code Issues Releases Activity

refactor(api): refactor

Browse source
This commit is contained in:
Anthony Lapenna 2017-02-07 16:26:12 +13:00
parent dc78ec5135
commit f129bf3e97
5 changed files with 152 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

114
api/cmd/portainer/main.go
View file

@ -13,7 +13,7 @@ import (
"log"
)
func main() {
func initCLI() *portainer.CLIFlags {
var cli portainer.CLIService = &cli.Service{}
flags, err := cli.ParseFlags(portainer.APIVersion)
if err != nil {
@ -24,54 +24,80 @@ func main() {
if err != nil {
log.Fatal(err)
}
return flags
}
fileService, err := file.NewService(*flags.Data, "")
func initFileService(dataStorePath string) portainer.FileService {
fileService, err := file.NewService(dataStorePath, "")
if err != nil {
log.Fatal(err)
}
return fileService
}
var store = bolt.NewStore(*flags.Data)
err = store.Open()
func initStore(dataStorePath string) *bolt.Store {
var store = bolt.NewStore(dataStorePath)
err := store.Open()
if err != nil {
log.Fatal(err)
}
defer store.Close()
return store
}
var jwtService portainer.JWTService
if !*flags.NoAuth {
jwtService, err = jwt.NewService()
func initJWTService(authenticationEnabled bool) portainer.JWTService {
if authenticationEnabled {
jwtService, err := jwt.NewService()
if err != nil {
log.Fatal(err)
}
return jwtService
}
return nil
}
var cryptoService portainer.CryptoService = &crypto.Service{}
func initCryptoService() portainer.CryptoService {
return &crypto.Service{}
}
var endpointWatcher portainer.EndpointWatcher
func initEndpointWatcher(endpointService portainer.EndpointService, externalEnpointFile string, syncInterval string) bool {
authorizeEndpointMgmt := true
if *flags.ExternalEndpoints != "" {
log.Println("Using external endpoint definition. Disabling endpoint management via API.")
if externalEnpointFile != "" {
authorizeEndpointMgmt = false
endpointWatcher = cron.NewWatcher(store.EndpointService, *flags.SyncInterval)
err = endpointWatcher.WatchEndpointFile(*flags.ExternalEndpoints)
log.Println("Using external endpoint definition. Endpoint management via the API will be disabled.")
endpointWatcher := cron.NewWatcher(endpointService, syncInterval)
err := endpointWatcher.WatchEndpointFile(externalEnpointFile)
if err != nil {
log.Fatal(err)
}
}
return authorizeEndpointMgmt
}
settings := &portainer.Settings{
func initSettings(authorizeEndpointMgmt bool, flags *portainer.CLIFlags) *portainer.Settings {
return &portainer.Settings{
HiddenLabels: *flags.Labels,
Logo: *flags.Logo,
Authentication: !*flags.NoAuth,
EndpointManagement: authorizeEndpointMgmt,
}
}
// Initialize the active endpoint from the CLI only if there is no
// active endpoint defined yet.
var activeEndpoint *portainer.Endpoint
if *flags.Endpoint != "" {
activeEndpoint, err = store.EndpointService.GetActive()
if err == portainer.ErrEndpointNotFound {
func initActiveEndpointFromFirstEndpointInDatabase(endpointService portainer.EndpointService) {
}
func retrieveFirstEndpointFromDatabase(endpointService portainer.EndpointService) *portainer.Endpoint {
endpoints, err := endpointService.Endpoints()
if err != nil {
log.Fatal(err)
}
return &endpoints[0]
}
func initActiveEndpoint(endpointService portainer.EndpointService, flags *portainer.CLIFlags) *portainer.Endpoint {
activeEndpoint, err := endpointService.GetActive()
if err == portainer.ErrEndpointNotFound {
if *flags.Endpoint != "" {
activeEndpoint = &portainer.Endpoint{
Name: "primary",
URL: *flags.Endpoint,
@ -80,30 +106,36 @@ func main() {
TLSCertPath: *flags.TLSCert,
TLSKeyPath: *flags.TLSKey,
}
err = store.EndpointService.CreateEndpoint(activeEndpoint)
err = endpointService.CreateEndpoint(activeEndpoint)
if err != nil {
log.Fatal(err)
}
} else if err != nil {
log.Fatal(err)
}
}
if *flags.ExternalEndpoints != "" {
activeEndpoint, err = store.EndpointService.GetActive()
if err == portainer.ErrEndpointNotFound {
var endpoints []portainer.Endpoint
endpoints, err = store.EndpointService.Endpoints()
if err != nil {
log.Fatal(err)
}
err = store.EndpointService.SetActive(&endpoints[0])
if err != nil {
log.Fatal(err)
}
} else if err != nil {
log.Fatal(err)
} else if *flags.ExternalEndpoints != "" {
activeEndpoint = retrieveFirstEndpointFromDatabase(endpointService)
}
} else if err != nil {
log.Fatal(err)
}
return activeEndpoint
}
func main() {
flags := initCLI()
fileService := initFileService(*flags.Data)
store := initStore(*flags.Data)
defer store.Close()
jwtService := initJWTService(!*flags.NoAuth)
cryptoService := initCryptoService()
authorizeEndpointMgmt := initEndpointWatcher(store.EndpointService, *flags.ExternalEndpoints, *flags.SyncInterval)
settings := initSettings(authorizeEndpointMgmt, flags)
activeEndpoint := initActiveEndpoint(store.EndpointService, flags)
var server portainer.Server = &http.Server{
BindAddress: *flags.Addr,
@ -121,7 +153,7 @@ func main() {
}
log.Printf("Starting Portainer on %s", *flags.Addr)
err = server.Start()
err := server.Start()
if err != nil {
log.Fatal(err)
}