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
}