func main() {
	flag.Parse()

	log.Printf("using store: %s\n", storePath)

	store := libmachine.NewFilestore(storePath, "", "")

	m, err := libmachine.New(store)
	if err != nil {
		log.Fatal(err)
	}

	mcn = m

	wsContainer := restful.NewContainer()
	h := HostResource{}
	h.Register(wsContainer)

	config := swagger.Config{
		WebServices:     wsContainer.RegisteredWebServices(),
		WebServicesUrl:  "http://localhost:8080",
		ApiPath:         "/apidocs.json",
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "swagger"}

	swagger.RegisterSwaggerService(config, wsContainer)

	log.Printf("start listening on localhost:8080")
	server := &http.Server{Addr: ":8080", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}

func main() {
	// to see what happens in the package, uncomment the following
	//restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))

	wsContainer := restful.NewContainer()
	u := UserResource{map[string]User{}}
	u.Register(wsContainer)

	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.
	config := swagger.Config{
		WebServices:    wsContainer.RegisteredWebServices(), // you control what services are visible
		WebServicesUrl: "http://localhost:8080",
		ApiPath:        "/apidocs.json",

		// Optionally, specifiy where the UI is located
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "/Users/emicklei/xProjects/swagger-ui/dist"}
	swagger.RegisterSwaggerService(config, wsContainer)

	log.Printf("start listening on localhost:8080")
	server := &http.Server{Addr: ":8080", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}

func runRestAPI(wsContainer *restful.Container) {
	config := swagger.Config{
		WebServices:     wsContainer.RegisteredWebServices(),
		WebServicesUrl:  "/", // host + port,
		ApiPath:         "/forewind/security.json",
		SwaggerPath:     "/forewind/doc/",
		SwaggerFilePath: "./dist",
		// TODO set it Title:           "libsecurity-go",
		// TODO set it Description:     "The libsecurity-go tool is for",
	}

	swagger.RegisterSwaggerService(config, wsContainer)
	if *generateJSONFlag {
		go generateJSON(config.ApiPath, config.SwaggerFilePath+"/")
	}
	log.Printf("start listening on %v", *host)
	var err error
	if strings.HasPrefix(strings.ToLower(*protocol), httpsStr) {
		err = http.ListenAndServeTLS(*host, *sslServerCert, *sslServerKey, wsContainer)
	} else {
		err = http.ListenAndServe(*host, wsContainer)
	}
	if err != nil {
		log.Fatal(err)
	}
}

// InstallSwaggerAPI installs the /swaggerapi/ endpoint to allow schema discovery
// and traversal.  It is optional to allow consumers of the Kubernetes master to
// register their own web services into the Kubernetes mux prior to initialization
// of swagger, so that other resource types show up in the documentation.
func (m *Master) InstallSwaggerAPI() {
	hostAndPort := m.externalHost
	protocol := "https://"

	// TODO: this is kind of messed up, we should just pipe in the full URL from the outside, rather
	// than guessing at it.
	if len(m.externalHost) == 0 && m.clusterIP != nil {
		host := m.clusterIP.String()
		if m.publicReadWritePort != 0 {
			hostAndPort = net.JoinHostPort(host, strconv.Itoa(m.publicReadWritePort))
		} else {
			// Use the read only port.
			hostAndPort = net.JoinHostPort(host, strconv.Itoa(m.publicReadOnlyPort))
			protocol = "http://"
		}
	}
	webServicesUrl := protocol + hostAndPort

	// Enable swagger UI and discovery API
	swaggerConfig := swagger.Config{
		WebServicesUrl:  webServicesUrl,
		WebServices:     m.handlerContainer.RegisteredWebServices(),
		ApiPath:         "/swaggerapi/",
		SwaggerPath:     "/swaggerui/",
		SwaggerFilePath: "/swagger-ui/",
	}
	swagger.RegisterSwaggerService(swaggerConfig, m.handlerContainer)
}

func enableSwagger() {
	config := swagger.Config{
		WebServices:     restful.DefaultContainer.RegisteredWebServices(), // you control what services are visible
		ApiPath:         "/apidocs.json",
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "swagger-ui/"}
	swagger.RegisterSwaggerService(config, restful.DefaultContainer)
}

func (a *Application) initSwagger() {
	swconfig := swagger.Config{
		WebServices:     a.Container.RegisteredWebServices(),
		WebServicesUrl:  a.Config.Get("swagger.ws_url").(string),
		ApiPath:         a.Config.Get("swagger.api_path").(string),
		SwaggerPath:     a.Config.Get("swagger.url").(string),
		SwaggerFilePath: a.Config.Get("swagger.file_path").(string),
	}
	swagger.RegisterSwaggerService(swconfig, a.Container)
}

func Swagger(wsContainer *restful.Container, apiPath, swaggerPath, swaggerFilepath string) {
	config := swagger.Config{
		WebServices: wsContainer.RegisteredWebServices(), // you control what services are visible
		ApiPath:     apiPath,

		// Optionally, specifiy where the UI is located
		SwaggerPath:     swaggerPath,
		SwaggerFilePath: swaggerFilepath,
	}
	swagger.RegisterSwaggerService(config, wsContainer)
}

func main() {
	flag.Parse()

	log.Printf("loading configuration from [%s]", *propertiesFile)
	var err error
	if props, err = properties.LoadFile(*propertiesFile, properties.UTF8); err != nil {
		log.Fatalf("[soysos][error] Unable to read properties:%v\n", err)
	}

	addr := props.MustGet("http.server.host") + ":" + props.MustGet("http.server.port")
	basePath := "http://" + addr
	SwaggerPath = props.GetString("swagger.path", "")

	cmap := make(map[string]CatFact)
	cmap["Lion"] = CatFact{"", "Lion", "Lions have sharp teef :D"}

	cat := CatResource{cmap}
	root := RootResource{SwaggerPath}
	user := UserResource{}

	wsContainer := restful.NewContainer()
	wsContainer.Filter(GlobalLogging)
	wsContainer.Filter(enableCORS)

	restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))
	cat.Register(wsContainer)
	root.Register(wsContainer)
	user.Register(wsContainer)

	config := swagger.Config{
		WebServices:     wsContainer.RegisteredWebServices(),
		WebServicesUrl:  basePath,
		ApiPath:         "/apidocs.json",
		SwaggerPath:     SwaggerPath,
		SwaggerFilePath: props.GetString("swagger.file.path", "")}

	swagger.RegisterSwaggerService(config, wsContainer)

	cors := restful.CrossOriginResourceSharing{
		AllowedHeaders: []string{"Accept", "Authorization"},
		AllowedMethods: []string{"GET"},
		CookiesAllowed: false,
		Container:      wsContainer}

	//wsContainer.Filter(wsContainer.OPTIONSFilter)
	wsContainer.Filter(cors.Filter)

	server := &http.Server{Addr: addr, Handler: wsContainer}

	log.Printf("start listening on %s", basePath)

	log.Fatal(server.ListenAndServe())
}

func main() {

	datastore, err := kv.Open("mpush.kvdb", &kv.Options{})

	if err != nil {
		log.Fatal(err)
	}
	defer datastore.Close()

	wsContainer := restful.NewContainer()

	restful.Filter(globalLogging)

	dsl := DistributionListResource{datastore}
	dsl.Register(wsContainer)

	wsPush := new(restful.WebService)

	wsPush.Path("/api/push")
	wsPush.Route(wsPush.POST("").
		Consumes("application/x-www-form-urlencoded").
		To(func(request *restful.Request, response *restful.Response) { pushHandler(request, response, datastore) }).
		// docs
		Doc("push to a distribution list").
		Param(wsPush.BodyParameter("List", "list to send to").DataType("string")).
		Param(wsPush.BodyParameter("Title", "title of notification").DataType("string")).
		Param(wsPush.BodyParameter("Body", "body of notification").DataType("string")).
		Reads(PushNotification{})) // from the request
	wsContainer.Add(wsPush)

	// static files
	wsStatic := new(restful.WebService)
	wsStatic.Route(wsStatic.GET("/static/{resource}").To(staticFromPathParam))
	wsStatic.Route(wsStatic.GET("/static").To(staticFromQueryParam))
	wsContainer.Add(wsStatic)

	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.
	config := swagger.Config{
		WebServices:    wsContainer.RegisteredWebServices(), // you control what services are visible
		WebServicesUrl: "http://localhost:8080",
		ApiPath:        "/apidocs.json",

		// Optionally, specifiy where the UI is located
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "/home/dgryski/work/src/cvs/swagger-ui/dist"}
	swagger.RegisterSwaggerService(config, wsContainer)

	log.Printf("start listening on localhost:8080")
	server := &http.Server{Addr: ":8080", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}

// InstallSwaggerAPI installs the /swaggerapi/ endpoint to allow schema discovery
// and traversal.  It is optional to allow consumers of the Kubernetes master to
// register their own web services into the Kubernetes mux prior to initialization
// of swagger, so that other resource types show up in the documentation.
func (m *Master) InstallSwaggerAPI() {
	// Enable swagger UI and discovery API
	swaggerConfig := swagger.Config{
		WebServicesUrl: m.readWriteServer,
		WebServices:    m.handlerContainer.RegisteredWebServices(),
		// TODO: Parameterize the path?
		ApiPath:         "/swaggerapi/",
		SwaggerPath:     "/swaggerui/",
		SwaggerFilePath: "/swagger-ui/",
	}
	swagger.RegisterSwaggerService(swaggerConfig, m.handlerContainer)
}

func main() {
	flag.Parse()
	// to see what happens in the package, uncomment the following
	//restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))

	wsContainer := NewHandlerContainer()

	var application app.Application
	var err error

	// Check configuration file was given
	if configfile == "" {
		fmt.Fprintln(os.Stderr, "Please provide configuration file")
		os.Exit(1)
	}

	// Setup a new applications for common APIs

	appCollection := conf.LoadAppConfiguration(configfile)
	fmt.Println(appCollection)

	for _, element := range appCollection.Apps {
		fmt.Println("Initializing..", element)
		application, err = app.InitApp(element.Name, element.ConfigFilePath)

		err = application.SetRoutes(wsContainer)
		if err != nil {
			fmt.Println("Unable to create http server endpoints")
			os.Exit(1)
		}
	}

	// Install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.
	//fmt.Println("appCollection.Swagger.Status", appCollection.Swagger.Status)
	if appCollection.Swagger.Status {

		config := swagger.Config{}
		config.WebServices = wsContainer.RegisteredWebServices()
		config.WebServicesUrl = appCollection.Swagger.WebServicesUrl
		config.ApiPath = appCollection.Swagger.ApiPath
		config.SwaggerPath = appCollection.Swagger.SwaggerPath
		config.SwaggerFilePath = appCollection.Swagger.SwaggerFilePath

		swagger.RegisterSwaggerService(config, wsContainer)
	}
	log.Printf("start listening on localhost:8080")
	server := &http.Server{Addr: ":8080", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}

// InstallSwaggerAPI installs the /swaggerapi/ endpoint to allow schema discovery
// and traversal. It is optional to allow consumers of the Kubernetes GenericAPIServer to
// register their own web services into the Kubernetes mux prior to initialization
// of swagger, so that other resource types show up in the documentation.
func (s *GenericAPIServer) InstallSwaggerAPI() {
	hostAndPort := s.ExternalAddress
	protocol := "https://"
	webServicesUrl := protocol + hostAndPort

	// Enable swagger UI and discovery API
	swaggerConfig := swagger.Config{
		WebServicesUrl:  webServicesUrl,
		WebServices:     s.HandlerContainer.RegisteredWebServices(),
		ApiPath:         "/swaggerapi/",
		SwaggerPath:     "/swaggerui/",
		SwaggerFilePath: "/swagger-ui/",
	}
	swagger.RegisterSwaggerService(swaggerConfig, s.HandlerContainer)
}

func StartRestAPIServer() {
	registerWebServiceHistoricalReplicationControllerMetric()
	registerWebServiceHistoricalReplicationController()
	registerWebServiceHistoricalEvent()
	registerWebServiceHealthCheck()
	registerWebServiceAuditLog()
	registerWebServiceBuildLog()

	// Place the method+path to description mapping to map for audit
	for _, rws := range restful.DefaultContainer.RegisteredWebServices() {
		for _, r := range rws.Routes() {
			audit.AddDescription(r.String(), r.Doc)
		}
	}

	// You can install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.
	config := swagger.Config{
		WebServices: restful.DefaultContainer.RegisteredWebServices(), // you control what services are visible
		//WebServicesUrl: "http://localhost:8080",
		ApiPath: "/apidocs.json",

		// Optionally, specifiy where the UI is located
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "swaggerui"}
	swagger.RegisterSwaggerService(config, restful.DefaultContainer)

	restapiPort, ok := configuration.LocalConfiguration.GetInt("restapiPort")
	if ok == false {
		log.Error("Can't find restapiPort")
		panic("Can't find restapiPort")
	}

	server := &http.Server{Addr: ":" + strconv.Itoa(restapiPort), Handler: restful.DefaultContainer}

	certificate, ok := configuration.LocalConfiguration.GetString("certificate")
	if ok == false {
		log.Error("Can't find certificate path")
		panic("Can't find certificate path")
	}
	key, ok := configuration.LocalConfiguration.GetString("key")
	if ok == false {
		log.Error("Can't find certificate path")
		panic("Can't find key path")
	}
	server.ListenAndServeTLS(certificate, key)
}

// Install adds the SwaggerUI webservice to the given mux.
func (s Swagger) Install(c *mux.APIContainer) {
	swagger.RegisterSwaggerService(swagger.Config{
		WebServicesUrl:  "https://" + s.ExternalAddress,
		WebServices:     c.RegisteredWebServices(),
		ApiPath:         "/swaggerapi/",
		SwaggerPath:     "/swaggerui/",
		SwaggerFilePath: "/swagger-ui/",
		SchemaFormatHandler: func(typeName string) string {
			switch typeName {
			case "metav1.Time", "*metav1.Time":
				return "date-time"
			}
			return ""
		},
	}, c.Container)
}

func main() {
	// to see what happens in the package, uncomment the following
	restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))

	wsContainer := restful.NewContainer()

	// Root
	var root = resources.RootResource{}
	root.Register(wsContainer)

	// lookups
	resourcesv1.EmploymentTypesResource{}.Register(wsContainer)
	resourcesv1.TagsResource{}.Register(wsContainer)
	resourcesv1.PostsResource{}.Register(wsContainer)
	resourcesv1.ScrumTeamsResource{}.Register(wsContainer)
	resourcesv1.SprintsResource{}.Register(wsContainer)

	// Add container filter to enable CORS
	cors := restful.CrossOriginResourceSharing{
		ExposeHeaders:  []string{"X-My-Header"},
		AllowedHeaders: []string{"Content-Type"},
		CookiesAllowed: false,
		Container:      wsContainer}
	wsContainer.Filter(cors.Filter)

	// Add container filter to respond to OPTIONS
	wsContainer.Filter(wsContainer.OPTIONSFilter)

	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.

	config := swagger.Config{
		WebServices:    wsContainer.RegisteredWebServices(), // you control what services are visible
		WebServicesUrl: "http://localhost:5555",
		ApiPath:        "/apidocs.json",

		// Optionally, specifiy where the UI is located
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "./swagger-ui/dist"}
	swagger.RegisterSwaggerService(config, wsContainer)

	log.Printf("start listening on localhost:5555")
	server := &http.Server{Addr: ":5555", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}

// New creates a new Docker remote API service instance in the form of an
// http.Handler.
func New(impl api.Service, swaggerFilePath string) http.Handler {
	baseSrv := newBaseServer(impl)
	containersSrv := newContainersServer(impl)

	container := restful.NewContainer()
	container.Add(baseSrv.WebService)
	container.Add(containersSrv.WebService)

	swaggerConf := swagger.Config{
		WebServices:     container.RegisteredWebServices(),
		ApiPath:         "/docs/apidocs.json",
		SwaggerPath:     "/docs/swagger/",
		SwaggerFilePath: swaggerFilePath,
	}
	swagger.RegisterSwaggerService(swaggerConf, container)

	return container
}

func StartServer(e *env.Env) {
	restful.SetLogger(e.Log)
	aEnv := ApiEnv{e}

	wsContainer := restful.NewContainer()

	// Enable gzip encoding
	//wsContainer.EnableContentEncoding(true)

	// Request logging
	wsContainer.Filter(aEnv.ReqLogger)

	// Route error handling
	wsContainer.ServiceErrorHandler(aEnv.WriteServiceErrorJson)

	// Register apis
	aEnv.registerUserApis(wsContainer)
	aEnv.registerPostApis(wsContainer)
	aEnv.registerVoteApis(wsContainer)

	// Some bullshit so ServiceErrorHandler works...
	errWs := new(restful.WebService)
	errWs.Path("/")
	wsContainer.Add(errWs)

	if e.SwaggerPath != "" {
		config := swagger.Config{
			WebServices:     wsContainer.RegisteredWebServices(),
			ApiPath:         "/swagger/apidocs.json",
			SwaggerPath:     "/swagger/apidocs/",
			SwaggerFilePath: e.SwaggerPath,
		}

		//Container just for swagger
		swContainer := restful.NewContainer()
		swagger.RegisterSwaggerService(config, swContainer)
		http.Handle("/swagger/", swContainer)
	}

	http.Handle("/", wsContainer)
	e.Log.Info("[server/api] start listening on localhost:" + e.ApiPort)

	e.Log.Fatal(http.ListenAndServe(":"+e.ApiPort, nil))
}

//main - Application.
func main() {

	log.Printf("Configuring container.")
	container := restful.NewContainer()
	container.Filter(filter.NCSACommonLogFormatLogger())
	container.Add(webservice.TaskWebService())

	log.Printf("Registering Swagger.")
	config := swagger.Config{
		WebServices: container.RegisteredWebServices(),
		ApiPath:     "/apidocs.json",
		ApiVersion:  "1.0",
		Info:        swagger.Info{Title: "hubertwo/go-todo", Description: "Simple TODO list manager in Go."}}
	swagger.RegisterSwaggerService(config, container)

	log.Printf("Starting server.")
	server := &http.Server{Addr: ":8080", Handler: container}
	log.Fatal(server.ListenAndServe())
}

// InstallSwaggerAPI installs the /swaggerapi/ endpoint to allow schema discovery
// and traversal.  It is optional to allow consumers of the Kubernetes master to
// register their own web services into the Kubernetes mux prior to initialization
// of swagger, so that other resource types show up in the documentation.
func (m *Master) InstallSwaggerAPI() {
	webServicesUrl := ""
	// Use the secure read write port, if available.
	if m.publicReadWritePort != 0 {
		webServicesUrl = "https://" + net.JoinHostPort(m.publicIP.String(), strconv.Itoa(m.publicReadWritePort))
	} else {
		// Use the read only port.
		webServicesUrl = "http://" + net.JoinHostPort(m.publicIP.String(), strconv.Itoa(m.publicReadOnlyPort))
	}
	// Enable swagger UI and discovery API
	swaggerConfig := swagger.Config{
		WebServicesUrl:  webServicesUrl,
		WebServices:     m.handlerContainer.RegisteredWebServices(),
		ApiPath:         "/swaggerapi/",
		SwaggerPath:     "/swaggerui/",
		SwaggerFilePath: "/swagger-ui/",
	}
	swagger.RegisterSwaggerService(swaggerConfig, m.handlerContainer)
}

func main() {
	err := config.LoadGlobalConfig()
	if err != nil {
		log.Fatalf("Failed to load config: %v", err)
	}

	go images.StartGC()
	go images.StartImageUpdate()
	// to see what happens in the package, uncomment the following
	//restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))

	wsContainer := restful.NewContainer()
	u := DockerResource{url: "unix:///var/run/docker.sock"}
	u.Register(wsContainer)

	wsContainer.Filter(func(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) {
		resp.AddHeader("Access-Control-Allow-Origin", "*")
		chain.ProcessFilter(req, resp)
	})

	wsContainer.Handle("/", http.FileServer(assetFS()))

	// Optionally, you can install the Swagger Service which provides a nice Web UI on your REST API
	// You need to download the Swagger HTML5 assets and change the FilePath location in the config below.
	// Open http://localhost:8080/apidocs and enter http://localhost:8080/apidocs.json in the api input field.
	config := swagger.Config{
		WebServices:    wsContainer.RegisteredWebServices(), // you control what services are visible
		WebServicesUrl: "http://localhost:8080",
		ApiPath:        "/apidocs.json",

		// Optionally, specifiy where the UI is located
		SwaggerPath:     "/apidocs/",
		SwaggerFilePath: "/Users/emicklei/xProjects/swagger-ui/dist"}
	swagger.RegisterSwaggerService(config, wsContainer)

	log.Printf("start listening on localhost:8080")
	server := &http.Server{Addr: ":8080", Handler: wsContainer}
	log.Fatal(server.ListenAndServe())
}