func getConvertCommand() cli.Command {
return cli.Command{
Name: "convert",
ShortName: "conv",
Usage: "Convert DB",
Description: `
Gohan convert can be used to migrate Gohan resources between different types of databases.
Setting meta-schema option will additionaly convert meta-schema table with schema resources.
Useful for development purposes.`,
Flags: []cli.Flag{
cli.StringFlag{Name: "in-type, it", Value: "", Usage: "Input db type (yaml, json, sqlite3, mysql)"},
cli.StringFlag{Name: "in, i", Value: "", Usage: "Input db connection spec (or filename)"},
cli.StringFlag{Name: "out-type, ot", Value: "", Usage: "Output db type (yaml, json, sqlite3, mysql)"},
cli.StringFlag{Name: "out, o", Value: "", Usage: "Output db connection spec (or filename)"},
cli.StringFlag{Name: "schema, s", Value: "", Usage: "Schema file"},
cli.StringFlag{Name: "meta-schema, m", Value: "", Usage: "Meta-schema file (optional)"},
},
Action: func(c *cli.Context) {
inType, in := c.String("in-type"), c.String("in")
if inType == "" || in == "" {
util.ExitFatal("Need to provide input database specification")
}
outType, out := c.String("out-type"), c.String("out")
if outType == "" || out == "" {
util.ExitFatal("Need to provide output database specification")
}
schemaFile := c.String("schema")
if schemaFile == "" {
util.ExitFatal("Need to provide schema file")
}
metaSchemaFile := c.String("meta-schema")
schemaManager := schema.GetManager()
err := schemaManager.LoadSchemasFromFiles(schemaFile, metaSchemaFile)
if err != nil {
util.ExitFatal("Error loading schema:", err)
}
inDB, err := db.ConnectDB(inType, in)
if err != nil {
util.ExitFatal(err)
}
outDB, err := db.ConnectDB(outType, out)
if err != nil {
util.ExitFatal(err)
}
err = db.CopyDBResources(inDB, outDB)
if err != nil {
util.ExitFatal(err)
}
fmt.Println("Conversion complete")
},
}
}
func newDBConnection(dbfilename string) (db.DB, error) {
connection, err := db.ConnectDB("sqlite3", dbfilename, db.DefaultMaxOpenConn)
if err != nil {
return nil, err
}
return connection, nil
}
func (server *Server) connectDB() error {
config := util.GetConfig()
dbType, dbConnection, _, _ := server.getDatabaseConfig()
maxConn := config.GetInt("database/max_open_conn", db.DefaultMaxOpenConn)
dbConn, err := db.ConnectDB(dbType, dbConnection, maxConn)
if server.sync == nil {
server.db = dbConn
} else {
server.db = &DbSyncWrapper{dbConn}
}
return err
}
RunSpecs(t, "Server Suite")
}
var _ = Describe("Suit set up and tear down", func() {
var conn, dbType string
if os.Getenv("MYSQL_TEST") == "true" {
conn = "root@/gohan_test"
dbType = "mysql"
} else {
conn = "./test.db"
dbType = "sqlite3"
}
var _ = BeforeSuite(func() {
var err error
testDB, err = db.ConnectDB(dbType, conn)
Expect(err).ToNot(HaveOccurred(), "Failed to connect database.")
if os.Getenv("MYSQL_TEST") == "true" {
err = startTestServer("./server_test_mysql_config.yaml")
} else {
err = startTestServer("./server_test_config.yaml")
}
Expect(err).ToNot(HaveOccurred(), "Failed to start test server.")
})
var _ = AfterSuite(func() {
schema.ClearManager()
os.Remove(conn)
})
})
var conn string
var tx transaction.Transaction
var sqlConn *DB
BeforeEach(func() {
var dbType string
if os.Getenv("MYSQL_TEST") == "true" {
conn = "gohan:gohan@/gohan_test"
dbType = "mysql"
} else {
conn = "./test.db"
dbType = "sqlite3"
}
manager := schema.GetManager()
dbc, err := db.ConnectDB(dbType, conn, db.DefaultMaxOpenConn)
sqlConn = dbc.(*DB)
Expect(err).ToNot(HaveOccurred())
Expect(manager.LoadSchemasFromFiles(
"../../etc/schema/gohan.json", "../../tests/test_abstract_schema.yaml", "../../tests/test_schema.yaml")).To(Succeed())
db.InitDBWithSchemas(dbType, conn, true, false)
// Insert fixture data
fixtureDB, err := db.ConnectDB("json", "test_fixture.json", db.DefaultMaxOpenConn)
Expect(err).ToNot(HaveOccurred())
db.CopyDBResources(fixtureDB, dbc, true)
tx, err = dbc.Begin()
Expect(err).ToNot(HaveOccurred())
})
Expect(subnetResource.Path()).To(Equal("/v2.0/subnets/subnetRed"))
server := map[string]interface{}{
"id": "serverRed",
"name": "serverRed",
"tenant_id": "red",
"network_id": "networkRed",
"description": "red server",
"cidr": "10.0.0.0/24"}
serverResource, err = manager.LoadResource("server", server)
Expect(err).ToNot(HaveOccurred())
})
JustBeforeEach(func() {
os.Remove(conn)
dataStore, err = db.ConnectDB(dbType, conn, db.DefaultMaxOpenConn)
Expect(err).ToNot(HaveOccurred())
for _, s := range manager.Schemas() {
Expect(dataStore.RegisterTable(s, false)).To(Succeed())
}
tx, err = dataStore.Begin()
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
tx.Close()
})
Describe("Using sql", func() {
var (
testDB1 db.DB
testDB2 db.DB
)
func TestExtension(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Extension Suite")
}
var _ = Describe("Suite set up and tear down", func() {
const (
testDBFile1 = "./extensionTest1.db"
testDBFile2 = "./extensionTest2.db"
)
var _ = BeforeSuite(func() {
var err error
testDB1, err = db.ConnectDB("sqlite3", testDBFile1)
Expect(err).NotTo(HaveOccurred())
testDB2, err = db.ConnectDB("sqlite3", testDBFile2)
Expect(err).NotTo(HaveOccurred())
})
var _ = AfterSuite(func() {
os.Remove(testDBFile1)
os.Remove(testDBFile2)
})
})
var (
testDB1 db.DB
testDB2 db.DB
)
func TestExtension(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Extension Suite")
}
var _ = Describe("Suite set up and tear down", func() {
const (
testDBFile1 = "./extensionTest1.db"
testDBFile2 = "./extensionTest2.db"
)
var _ = BeforeSuite(func() {
var err error
testDB1, err = db.ConnectDB("sqlite3", testDBFile1, db.DefaultMaxOpenConn)
Expect(err).NotTo(HaveOccurred())
testDB2, err = db.ConnectDB("sqlite3", testDBFile2, db.DefaultMaxOpenConn)
Expect(err).NotTo(HaveOccurred())
})
var _ = AfterSuite(func() {
os.Remove(testDBFile1)
os.Remove(testDBFile2)
})
})
subnetResource.SetParentID("networkRed")
Expect(subnetResource.Path()).To(Equal("/v2.0/subnets/subnetRed"))
server := map[string]interface{}{
"id": "serverRed",
"name": "serverRed",
"tenant_id": "red",
"network_id": "networkRed",
"cidr": "10.0.0.0/24"}
serverResource, err = manager.LoadResource("server", server)
Expect(err).ToNot(HaveOccurred())
})
JustBeforeEach(func() {
os.Remove(conn)
dataStore, err = db.ConnectDB(dbType, conn)
Expect(err).ToNot(HaveOccurred())
for _, s := range manager.Schemas() {
Expect(dataStore.RegisterTable(s, false)).To(Succeed())
}
tx, err = dataStore.Begin()
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
tx.Close()
})
Describe("Using sql", func() {
//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
}
func (server *Server) connectDB() error {
dbType, dbConnection, _, _ := server.getDatabaseConfig()
dbConn, err := db.ConnectDB(dbType, dbConnection)
server.db = &DbSyncWrapper{dbConn}
return err
}
func beforeEach() {
os.Remove(conn)
dataStore, _ = db.ConnectDB(dbtype, conn)
}
func beforeEach() {
timelimit = time.Duration(1) * time.Second
os.Remove(conn)
dataStore, _ = db.ConnectDB(dbtype, conn)
}
//ConnectDB start connection to db
func ConnectDB(dbType string, connection string, maxOpenConn int) (db.DB, error) {
return db.ConnectDB(dbType, connection, maxOpenConn)
}
//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
port := os.Getenv("PORT")
if port == "" {
port = "9091"
}
setupEditor(server)
server.timelimit = config.GetInt("extension/timelimit", 30)
server.extensions = config.GetStringList("extension/use", []string{
"javascript",
"gohanscript",
"go",
})
schema.DefaultExtension = config.GetString("extension/default", "javascript")
server.address = config.GetString("address", ":"+port)
if config.GetBool("tls/enabled", false) {
log.Info("TLS enabled")
server.tls = &tlsConfig{
KeyFile: config.GetString("tls/key_file", "./etc/key.pem"),
CertFile: config.GetString("tls/cert_file", "./etc/cert.pem"),
}
}
etcdServers := config.GetStringList("etcd", nil)
if etcdServers != nil {
log.Info("etcd servers: %s", etcdServers)
server.sync = etcd.NewSync(etcdServers)
}
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)
}
}
if !config.GetBool("database/no_init", false) {
server.initDB()
}
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, db.DefaultMaxOpenConn)
if err != nil {
log.Fatal(err)
}
db.CopyDBResources(inDB, server.db, false)
}
}
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")
} 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())
} else {
m.MapTo(&middleware.NoIdentityService{}, (*middleware.IdentityService)(nil))
m.Map(schema.NewAuthorization("admin", "admin", "admin_token", []string{"admin"}, nil))
}
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-Expose-Headers", "X-Total-Count")
rw.Header().Add("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE")
})
}
documentRoot := config.GetString("document_root", "embed")
if config.GetBool("webui_config/enabled", false) {
m.Use(func(res http.ResponseWriter, req *http.Request, c martini.Context) {
if req.URL.Path != "/webui/config.json" {
c.Next()
return
}
address := config.GetString("webui_config/address", server.address)
if address[0] == ':' {
address = "__HOST__" + address
}
baseURL := "http://" + address
authURL := "http://" + address + "/v2.0"
if config.GetBool("webui_config/tls", config.GetBool("tls/enabled", false)) {
baseURL = "https://" + address
authURL = "https://" + address + "/v2.0"
}
authURL = config.GetString("webui_config/auth_url", authURL)
webUIConfig := map[string]interface{}{
"authUrl": authURL,
"gohan": map[string]interface{}{
"schema": "/gohan/v0.1/schemas",
"url": baseURL,
},
}
routes.ServeJson(res, webUIConfig)
})
}
if documentRoot == "embed" {
m.Use(staticbin.Static("public", util.Asset, staticbin.Options{
SkipLogging: true,
}))
} else {
log.Info("Static file serving from %s", documentRoot)
documentRootABS, err := filepath.Abs(documentRoot)
if err != nil {
return nil, err
}
server.martini.Use(martini.Static(documentRootABS, martini.StaticOptions{
SkipLogging: true,
}))
}
server.mapRoutes()
maxWorkerCount := config.GetInt("workers", 100)
server.queue = job.NewQueue(uint(maxWorkerCount))
return server, nil
}
return err
}
}
return nil
}
func TestOttoExtension(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Otto Extension Suite")
}
var _ = Describe("Suite set up and tear down", func() {
var _ = BeforeSuite(func() {
var err error
Expect(os.Chdir(configDir)).To(Succeed())
testDB, err = db.ConnectDB(dbType, dbFile)
Expect(err).ToNot(HaveOccurred(), "Failed to connect database.")
manager := schema.GetManager()
config := util.GetConfig()
Expect(config.ReadConfig(configFile)).To(Succeed())
schemaFiles := config.GetStringList("schemas", nil)
Expect(schemaFiles).NotTo(BeNil())
Expect(manager.LoadSchemasFromFiles(schemaFiles...)).To(Succeed())
Expect(db.InitDBWithSchemas(dbType, dbFile, false, false)).To(Succeed())
})
var _ = AfterSuite(func() {
schema.ClearManager()
os.Remove(dbFile)
})
})
return err
}
}
return nil
}
func TestOttoExtension(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Otto Extension Suite")
}
var _ = Describe("Suite set up and tear down", func() {
var _ = BeforeSuite(func() {
var err error
Expect(os.Chdir(configDir)).To(Succeed())
testDB, err = db.ConnectDB(dbType, dbFile, db.DefaultMaxOpenConn)
Expect(err).ToNot(HaveOccurred(), "Failed to connect database.")
manager := schema.GetManager()
config := util.GetConfig()
Expect(config.ReadConfig(configFile)).To(Succeed())
schemaFiles := config.GetStringList("schemas", nil)
Expect(schemaFiles).NotTo(BeNil())
Expect(manager.LoadSchemasFromFiles(schemaFiles...)).To(Succeed())
Expect(db.InitDBWithSchemas(dbType, dbFile, false, false)).To(Succeed())
})
var _ = AfterSuite(func() {
schema.ClearManager()
os.Remove(dbFile)
})
})
var conn string
var tx transaction.Transaction
BeforeEach(func() {
var dbType string
if os.Getenv("MYSQL_TEST") == "true" {
conn = "root@/gohan_test"
dbType = "mysql"
} else {
conn = "./test.db"
dbType = "sqlite3"
}
manager := schema.GetManager()
dbc, err := db.ConnectDB(dbType, conn)
Expect(err).ToNot(HaveOccurred())
Expect(manager.LoadSchemasFromFiles(
"../../etc/schema/gohan.json", "../../tests/test_schema.yaml")).To(Succeed())
db.InitDBWithSchemas(dbType, conn, true, false)
// Insert fixture data
fixtureDB, err := db.ConnectDB("json", "test_fixture.json")
Expect(err).ToNot(HaveOccurred())
db.CopyDBResources(fixtureDB, dbc)
tx, err = dbc.Begin()
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
