func (server *Server) mapRoutes() { config := util.GetConfig() schemaManager := schema.GetManager() MapNamespacesRoutes(server.martini) MapRouteBySchemas(server, server.db) tx, err := server.db.Begin() if err != nil { log.Fatal(err) } defer tx.Close() coreSchema, _ := schemaManager.Schema("schema") if coreSchema == nil { log.Fatal("Gohan core schema not found") return } policySchema, _ := schemaManager.Schema("policy") policyList, _, err := tx.List(policySchema, nil, nil) if err != nil { log.Info(err.Error()) } schemaManager.LoadPolicies(policyList) extensionSchema, _ := schemaManager.Schema("extension") extensionList, _, err := tx.List(extensionSchema, nil, nil) if err != nil { log.Info(err.Error()) } schemaManager.LoadExtensions(extensionList) namespaceSchema, _ := schemaManager.Schema("namespace") if namespaceSchema == nil { log.Error("No gohan schema. Disabling schema editing mode") return } namespaceList, _, err := tx.List(namespaceSchema, nil, nil) if err != nil { log.Info(err.Error()) } err = tx.Commit() if err != nil { log.Info(err.Error()) } schemaManager.LoadNamespaces(namespaceList) if config.GetBool("keystone/fake", false) { middleware.FakeKeystone(server.martini) } }
//NewServer returns new GohanAPIServer func NewServer(configFile string) (*Server, error) { manager := schema.GetManager() config := util.GetConfig() err := config.ReadConfig(configFile) err = os.Chdir(path.Dir(configFile)) if err != nil { return nil, fmt.Errorf("Config load error: %s", err) } err = l.SetUpLogging(config) if err != nil { return nil, fmt.Errorf("Logging setup error: %s", err) } log.Info("logging initialized") server := &Server{} m := martini.Classic() m.Handlers() m.Use(middleware.Logging()) m.Use(martini.Recovery()) m.Use(middleware.JSONURLs()) m.Use(middleware.WithContext()) server.martini = m server.address = config.GetString("address", ":9091") if config.GetBool("tls/enabled", false) { log.Info("TLS enabled") server.tls = &tls{ KeyFile: config.GetString("tls/key_file", "./etc/key.pem"), CertFile: config.GetString("tls/cert_file", "./etc/cert.pem"), } } server.connectDB() schemaFiles := config.GetStringList("schemas", nil) if schemaFiles == nil { log.Fatal("No schema specified in configuraion") } else { err = manager.LoadSchemasFromFiles(schemaFiles...) if err != nil { return nil, fmt.Errorf("invalid schema: %s", err) } } server.initDB() etcdServers := config.GetStringList("etcd", nil) log.Info("etcd servers: %s", etcdServers) server.sync = etcd.NewSync(etcdServers) if config.GetList("database/initial_data", nil) != nil { initialDataList := config.GetList("database/initial_data", nil) for _, initialData := range initialDataList { initialDataConfig := initialData.(map[string]interface{}) inType := initialDataConfig["type"].(string) inConnection := initialDataConfig["connection"].(string) log.Info("Importing data from %s ...", inConnection) inDB, err := db.ConnectDB(inType, inConnection) if err != nil { log.Fatal(err) } db.CopyDBResources(inDB, server.db) } } if config.GetBool("keystone/use_keystone", false) { //TODO remove this if config.GetBool("keystone/fake", false) { server.keystoneIdentity = &middleware.FakeIdentity{} //TODO(marcin) requests to fake server also get authenticated // we need a separate routing Group log.Info("Debug Mode with Fake Keystone Server") middleware.FakeKeystone(server.martini) } else { log.Info("Keystone backend server configured") server.keystoneIdentity, err = cloud.NewKeystoneIdentity( config.GetString("keystone/auth_url", "http://localhost:35357/v3"), config.GetString("keystone/user_name", "admin"), config.GetString("keystone/password", "password"), config.GetString("keystone/domain_name", "Default"), config.GetString("keystone/tenant_name", "admin"), config.GetString("keystone/version", ""), ) if err != nil { log.Fatal(err) } } m.MapTo(server.keystoneIdentity, (*middleware.IdentityService)(nil)) m.Use(middleware.Authentication()) //m.Use(Authorization()) } if err != nil { return nil, fmt.Errorf("invalid base dir: %s", err) } server.addOptionsRoute() cors := config.GetString("cors", "") if cors != "" { log.Info("Enabling CORS for %s", cors) if cors == "*" { log.Warning("cors for * have security issue") } server.martini.Use(func(rw http.ResponseWriter, r *http.Request) { rw.Header().Add("Access-Control-Allow-Origin", cors) rw.Header().Add("Access-Control-Allow-Headers", "X-Auth-Token, Content-Type") rw.Header().Add("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE") }) } documentRoot := config.GetString("document_root", "./") log.Info("Static file serving from %s", documentRoot) documentRootABS, err := filepath.Abs(documentRoot) server.martini.Use(martini.Static(documentRootABS)) server.mapRoutes() return server, nil }