Moving factories and start minio method to server package

master
Frederick F. Kautz IV 10 years ago
parent c75b9d58f5
commit 5a607a6762
  1. 122
      main.go
  2. 109
      pkg/server/server.go

@ -26,17 +26,11 @@ import (
"strings" "strings"
"time" "time"
"errors"
"reflect"
"github.com/dustin/go-humanize" "github.com/dustin/go-humanize"
"github.com/minio-io/cli" "github.com/minio-io/cli"
"github.com/minio-io/minio/pkg/api"
"github.com/minio-io/minio/pkg/api/web"
"github.com/minio-io/minio/pkg/iodine" "github.com/minio-io/minio/pkg/iodine"
"github.com/minio-io/minio/pkg/server"
"github.com/minio-io/minio/pkg/server/httpserver" "github.com/minio-io/minio/pkg/server/httpserver"
"github.com/minio-io/minio/pkg/storage/drivers/donut"
"github.com/minio-io/minio/pkg/storage/drivers/memory"
"github.com/minio-io/minio/pkg/utils/log" "github.com/minio-io/minio/pkg/utils/log"
) )
@ -99,43 +93,6 @@ EXAMPLES:
`, `,
} }
type memoryFactory struct {
httpserver.Config
maxMemory uint64
}
func (f memoryFactory) getStartServerFunc() startServerFunc {
return func() (chan<- string, <-chan error) {
_, _, driver := memory.Start(f.maxMemory)
ctrl, status, _ := httpserver.Start(api.HTTPHandler(f.Domain, driver), f.Config)
return ctrl, status
}
}
type webFactory struct {
httpserver.Config
}
func (f webFactory) getStartServerFunc() startServerFunc {
return func() (chan<- string, <-chan error) {
ctrl, status, _ := httpserver.Start(web.HTTPHandler(), f.Config)
return ctrl, status
}
}
type donutFactory struct {
httpserver.Config
paths []string
}
func (f donutFactory) getStartServerFunc() startServerFunc {
return func() (chan<- string, <-chan error) {
_, _, driver := donut.Start(f.paths)
ctrl, status, _ := httpserver.Start(api.HTTPHandler(f.Domain, driver), f.Config)
return ctrl, status
}
}
var flags = []cli.Flag{ var flags = []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: "domain,d", Name: "domain,d",
@ -178,8 +135,6 @@ func init() {
} }
} }
type startServerFunc func() (chan<- string, <-chan error)
func runMemory(c *cli.Context) { func runMemory(c *cli.Context) {
if len(c.Args()) < 1 { if len(c.Args()) < 1 {
cli.ShowCommandHelpAndExit(c, "memory", 1) // last argument is exit code cli.ShowCommandHelpAndExit(c, "memory", 1) // last argument is exit code
@ -189,14 +144,14 @@ func runMemory(c *cli.Context) {
if err != nil { if err != nil {
log.Fatalf("MaxMemory not a numeric value with reason: %s", err) log.Fatalf("MaxMemory not a numeric value with reason: %s", err)
} }
memoryDriver := memoryFactory{ memoryDriver := server.MemoryFactory{
Config: apiServerConfig, Config: apiServerConfig,
maxMemory: maxMemory, MaxMemory: maxMemory,
} }
apiServer := memoryDriver.getStartServerFunc() apiServer := memoryDriver.GetStartServerFunc()
webServer := getWebServerConfigFunc(c) webServer := getWebServerConfigFunc(c)
servers := []startServerFunc{apiServer, webServer} servers := []server.StartServerFunc{apiServer, webServer}
startMinio(servers) server.StartMinio(servers)
} }
func runDonut(c *cli.Context) { func runDonut(c *cli.Context) {
@ -219,14 +174,14 @@ func runDonut(c *cli.Context) {
} }
} }
apiServerConfig := getAPIServerConfig(c) apiServerConfig := getAPIServerConfig(c)
donutDriver := donutFactory{ donutDriver := server.DonutFactory{
Config: apiServerConfig, Config: apiServerConfig,
paths: paths, Paths: paths,
} }
apiServer := donutDriver.getStartServerFunc() apiServer := donutDriver.GetStartServerFunc()
webServer := getWebServerConfigFunc(c) webServer := getWebServerConfigFunc(c)
servers := []startServerFunc{apiServer, webServer} servers := []server.StartServerFunc{apiServer, webServer}
startMinio(servers) server.StartMinio(servers)
} }
func getAPIServerConfig(c *cli.Context) httpserver.Config { func getAPIServerConfig(c *cli.Context) httpserver.Config {
@ -245,7 +200,7 @@ func getAPIServerConfig(c *cli.Context) httpserver.Config {
} }
} }
func getWebServerConfigFunc(c *cli.Context) startServerFunc { func getWebServerConfigFunc(c *cli.Context) server.StartServerFunc {
config := httpserver.Config{ config := httpserver.Config{
Domain: c.GlobalString("domain"), Domain: c.GlobalString("domain"),
Address: c.GlobalString("web-address"), Address: c.GlobalString("web-address"),
@ -253,59 +208,10 @@ func getWebServerConfigFunc(c *cli.Context) startServerFunc {
CertFile: "", CertFile: "",
KeyFile: "", KeyFile: "",
} }
webDrivers := webFactory{ webDrivers := server.WebFactory{
Config: config, Config: config,
} }
return webDrivers.getStartServerFunc() return webDrivers.GetStartServerFunc()
}
func startMinio(servers []startServerFunc) {
var ctrlChannels []chan<- string
var errChannels []<-chan error
for _, server := range servers {
ctrlChannel, errChannel := server()
ctrlChannels = append(ctrlChannels, ctrlChannel)
errChannels = append(errChannels, errChannel)
}
cases := createSelectCases(errChannels)
for len(cases) > 0 {
chosen, value, recvOk := reflect.Select(cases)
switch recvOk {
case true:
// Status Message Received
switch true {
case value.Interface() != nil:
// For any error received cleanup all existing channels and fail
for _, ch := range ctrlChannels {
close(ch)
}
msg := fmt.Sprintf("%q", value.Interface())
log.Fatal(iodine.New(errors.New(msg), nil))
}
case false:
// Channel closed, remove from list
var aliveStatusChans []<-chan error
for i, ch := range errChannels {
if i != chosen {
aliveStatusChans = append(aliveStatusChans, ch)
}
}
// create new select cases without defunct channel
errChannels = aliveStatusChans
cases = createSelectCases(errChannels)
}
}
}
func createSelectCases(channels []<-chan error) []reflect.SelectCase {
cases := make([]reflect.SelectCase, len(channels))
for i, ch := range channels {
cases[i] = reflect.SelectCase{
Dir: reflect.SelectRecv,
Chan: reflect.ValueOf(ch),
}
}
return cases
} }
// Tries to get os/arch/platform specific information // Tries to get os/arch/platform specific information

@ -16,4 +16,111 @@
package server package server
// Config - http server parameters import (
"errors"
"fmt"
"github.com/minio-io/minio/pkg/api"
"github.com/minio-io/minio/pkg/api/web"
"github.com/minio-io/minio/pkg/iodine"
"github.com/minio-io/minio/pkg/server/httpserver"
"github.com/minio-io/minio/pkg/storage/drivers/donut"
"github.com/minio-io/minio/pkg/storage/drivers/memory"
"github.com/minio-io/minio/pkg/utils/log"
"reflect"
)
// MemoryFactory is used to build memory api servers
type MemoryFactory struct {
httpserver.Config
MaxMemory uint64
}
// GetStartServerFunc builds memory api servers
func (f MemoryFactory) GetStartServerFunc() StartServerFunc {
return func() (chan<- string, <-chan error) {
_, _, driver := memory.Start(f.MaxMemory)
ctrl, status, _ := httpserver.Start(api.HTTPHandler(f.Domain, driver), f.Config)
return ctrl, status
}
}
// WebFactory is used to build web cli servers
type WebFactory struct {
httpserver.Config
}
// GetStartServerFunc builds web cli servers
func (f WebFactory) GetStartServerFunc() StartServerFunc {
return func() (chan<- string, <-chan error) {
ctrl, status, _ := httpserver.Start(web.HTTPHandler(), f.Config)
return ctrl, status
}
}
// DonutFactory is used to build donut api servers
type DonutFactory struct {
httpserver.Config
Paths []string
}
// GetStartServerFunc DonutFactory builds donut api servers
func (f DonutFactory) GetStartServerFunc() StartServerFunc {
return func() (chan<- string, <-chan error) {
_, _, driver := donut.Start(f.Paths)
ctrl, status, _ := httpserver.Start(api.HTTPHandler(f.Domain, driver), f.Config)
return ctrl, status
}
}
// StartServerFunc describes a function that can be used to start a server with StartMinio
type StartServerFunc func() (chan<- string, <-chan error)
// StartMinio starts minio servers
func StartMinio(servers []StartServerFunc) {
var ctrlChannels []chan<- string
var errChannels []<-chan error
for _, server := range servers {
ctrlChannel, errChannel := server()
ctrlChannels = append(ctrlChannels, ctrlChannel)
errChannels = append(errChannels, errChannel)
}
cases := createSelectCases(errChannels)
for len(cases) > 0 {
chosen, value, recvOk := reflect.Select(cases)
switch recvOk {
case true:
// Status Message Received
switch true {
case value.Interface() != nil:
// For any error received cleanup all existing channels and fail
for _, ch := range ctrlChannels {
close(ch)
}
msg := fmt.Sprintf("%q", value.Interface())
log.Fatal(iodine.New(errors.New(msg), nil))
}
case false:
// Channel closed, remove from list
var aliveStatusChans []<-chan error
for i, ch := range errChannels {
if i != chosen {
aliveStatusChans = append(aliveStatusChans, ch)
}
}
// create new select cases without defunct channel
errChannels = aliveStatusChans
cases = createSelectCases(errChannels)
}
}
}
func createSelectCases(channels []<-chan error) []reflect.SelectCase {
cases := make([]reflect.SelectCase, len(channels))
for i, ch := range channels {
cases[i] = reflect.SelectCase{
Dir: reflect.SelectRecv,
Chan: reflect.ValueOf(ch),
}
}
return cases
}

Loading…
Cancel
Save