// Down rolls back all migrations. func Down(pipe chan interface{}, url, migrationsPath string) { d, files, versions, err := initDriverAndReadMigrationFilesAndGetVersions(url, migrationsPath) defer func() { if err != nil { pipe <- err } if d != nil { if err = d.Close(); err != nil { pipe <- err } } go pipep.Close(pipe, nil) }() if err != nil { return } applyMigrationFiles, err := files.Applied(versions) if err != nil { return } if len(applyMigrationFiles) > 0 { for _, f := range applyMigrationFiles { pipe1 := pipep.New() go d.Migrate(f, pipe1) if ok := pipep.WaitAndRedirect(pipe1, pipe, handleInterrupts()); !ok { break } } } }
// Reset runs the down and up migration function. func Reset(pipe chan interface{}, url, migrationsPath string) { pipe1 := pipep.New() go Down(pipe1, url, migrationsPath) if ok := pipep.WaitAndRedirect(pipe1, pipe, handleInterrupts()); !ok { go pipep.Close(pipe, nil) return } go Up(pipe, url, migrationsPath) }
func migrate(t *testing.T, driverUrl string) { d := &Driver{} if err := d.Initialize(driverUrl); err != nil { t.Fatal(err) } files := []file.File{ { Path: "/foobar", FileName: "20060102150405_foobar.up.sql", Version: 20060102150405, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE yolo ( id serial not null primary key ); `), }, { Path: "/foobar", FileName: "20060102150405_foobar.down.sql", Version: 20060102150405, Name: "foobar", Direction: direction.Down, Content: []byte(` DROP TABLE yolo; `), }, { Path: "/foobar", FileName: "20060102150406_foobar.up.sql", Version: 20060102150406, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE error ( id THIS WILL CAUSE AN ERROR ) `), }, } pipe := pipep.New() go d.Migrate(files[0], pipe) errs := pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } version, err := d.Version() if err != nil { t.Fatal(err) } if version != 20060102150405 { t.Errorf("Expected version to be: %d, got: %d", 20060102150405, version) } // Check versions applied in DB expectedVersions := file.Versions{20060102150405} versions, err := d.Versions() if err != nil { t.Errorf("Could not fetch versions: %s", err) } if !reflect.DeepEqual(versions, expectedVersions) { t.Errorf("Expected versions to be: %v, got: %v", expectedVersions, versions) } pipe = pipep.New() go d.Migrate(files[1], pipe) errs = pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } pipe = pipep.New() go d.Migrate(files[2], pipe) errs = pipep.ReadErrors(pipe) if len(errs) == 0 { t.Error("Expected test case to fail") } // Check versions applied in DB expectedVersions = file.Versions{} versions, err = d.Versions() if err != nil { t.Errorf("Could not fetch versions: %s", err) } if !reflect.DeepEqual(versions, expectedVersions) { t.Errorf("Expected versions to be: %v, got: %v", expectedVersions, versions) } if err := d.Close(); err != nil { t.Fatal(err) } }
func TestMigrate(t *testing.T) { var session *gocql.Session host := os.Getenv("CASSANDRA_PORT_9042_TCP_ADDR") port := os.Getenv("CASSANDRA_PORT_9042_TCP_PORT") driverURL := "cassandra://" + host + ":" + port + "/system?protocol=4" // prepare a clean test database. u, err := url.Parse(driverURL) if err != nil { t.Fatal(err) } cluster := gocql.NewCluster(u.Host) cluster.Keyspace = u.Path[1:len(u.Path)] cluster.Consistency = gocql.All cluster.Timeout = 1 * time.Minute cluster.ProtoVersion = 4 session, err = cluster.CreateSession() if err != nil { //t.Fatal(err) } if err := resetKeySpace(session); err != nil { t.Fatal(err) } cluster.Keyspace = "migrate" session, err = cluster.CreateSession() driverURL = "cassandra://" + host + ":" + port + "/migrate?protocol=4" d := &Driver{} if err := d.Initialize(driverURL); err != nil { t.Fatal(err) } files := []file.File{ { Path: "/foobar", FileName: "20060102150405_foobar.up.sql", Version: 20060102150405, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE yolo ( id varint primary key, msg text ); CREATE INDEX ON yolo (msg); `), }, { Path: "/foobar", FileName: "20060102150405_foobar.down.sql", Version: 20060102150405, Name: "foobar", Direction: direction.Down, Content: []byte(` DROP TABLE yolo; `), }, { Path: "/foobar", FileName: "20060102150406_foobar.up.sql", Version: 20060102150406, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE error ( id THIS WILL CAUSE AN ERROR ) `), }, } pipe := pipep.New() go d.Migrate(files[0], pipe) errs := pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } version, err := d.Version() if err != nil { t.Fatal(err) } if version != 20060102150405 { t.Errorf("Expected version to be: %d, got: %d", 20060102150405, version) } // Check versions applied in DB. expectedVersions := file.Versions{20060102150405} versions, err := d.Versions() if err != nil { t.Errorf("Could not fetch versions: %s", err) } if !reflect.DeepEqual(versions, expectedVersions) { t.Errorf("Expected versions to be: %v, got: %v", expectedVersions, versions) } pipe = pipep.New() go d.Migrate(files[1], pipe) errs = pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } pipe = pipep.New() go d.Migrate(files[2], pipe) errs = pipep.ReadErrors(pipe) if len(errs) == 0 { t.Error("Expected test case to fail") } // Check versions applied in DB. expectedVersions = file.Versions{} versions, err = d.Versions() if err != nil { t.Errorf("Could not fetch versions: %s", err) } if !reflect.DeepEqual(versions, expectedVersions) { t.Errorf("Expected versions to be: %v, got: %v", expectedVersions, versions) } if err := resetKeySpace(session); err != nil { t.Fatal(err) } if err := d.Close(); err != nil { t.Fatal(err) } }
// TestMigrate runs some additional tests on Migrate() // Basic testing is already done in migrate/migrate_test.go func TestMigrate(t *testing.T) { f, err := ioutil.TempFile(os.TempDir(), "migrate_test") if err != nil { t.Fatal(err) } defer os.Remove(f.Name()) d := &Driver{} if err := d.Initialize("sqlite3://" + f.Name()); err != nil { t.Fatal(err) } files := []file.File{ { Path: "/foobar", FileName: "20060102150405_foobar.up.sql", Version: 20060102150405, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE yolo ( id INTEGER PRIMARY KEY AUTOINCREMENT ); `), }, { Path: "/foobar", FileName: "20060102200405_alter_table.up.sql", Version: 20060102200405, Name: "alter_table", Direction: direction.Up, Content: []byte(` ALTER TABLE yolo ADD COLUMN data1 VCHAR(255); ALTER TABLE yolo ADD COLUMN data2 VCHAR(255); `), }, { Path: "/foobar", FileName: "20060102150405_foobar.down.sql", Version: 20060102150405, Name: "foobar", Direction: direction.Down, Content: []byte(` DROP TABLE yolo; `), }, { Path: "/foobar", FileName: "20060102150406_failing.up.sql", Version: 20060103200406, Name: "failing", Direction: direction.Down, Content: []byte(` CREATE TABLE error ( THIS; WILL CAUSE; AN ERROR; ) `), }, } pipe := pipep.New() go d.Migrate(files[0], pipe) errs := pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } version, err := d.Version() if err != nil { t.Fatal(err) } if version != files[0].Version { t.Errorf("Expected version to be: %d, got: %d", files[0].Version, version) } // Check versions applied in DB. expectedVersions := file.Versions{files[0].Version} versions, err := d.Versions() if err != nil { t.Errorf("Could not fetch versions: %s", err) } if !reflect.DeepEqual(versions, expectedVersions) { t.Errorf("Expected versions to be: %v, got: %v", expectedVersions, versions) } pipe = pipep.New() go d.Migrate(files[1], pipe) errs = pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } if _, err := d.db.Query("SELECT id, data1, data2 FROM yolo"); err != nil { t.Errorf("Sequential migration failed: %v", err) } // Check versions applied in DB. expectedVersions = file.Versions{files[1].Version, files[0].Version} versions, err = d.Versions() if err != nil { t.Errorf("Could not fetch versions: %s", err) } if !reflect.DeepEqual(versions, expectedVersions) { t.Errorf("Expected versions to be: %v, got: %v", expectedVersions, versions) } pipe = pipep.New() go d.Migrate(files[2], pipe) errs = pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } pipe = pipep.New() go d.Migrate(files[3], pipe) errs = pipep.ReadErrors(pipe) if len(errs) == 0 { t.Error("Expected test case to fail") } if err := d.Close(); err != nil { t.Fatal(err) } }
func main() { flag.Usage = func() { helpCmd() } flag.Parse() command := flag.Arg(0) if *version { fmt.Println(Version) os.Exit(0) } if *migrationsPath == "" { *migrationsPath, _ = os.Getwd() } switch command { case "create": verifyMigrationsPath(*migrationsPath) name := flag.Arg(1) if name == "" { fmt.Println("Please specify name.") os.Exit(1) } migrationFile, err := migrate.Create(*url, *migrationsPath, name) if err != nil { fmt.Println(err) os.Exit(1) } fmt.Printf("Version %v migration files created in %v:\n", migrationFile.Version, *migrationsPath) fmt.Println(migrationFile.UpFile.FileName) fmt.Println(migrationFile.DownFile.FileName) case "migrate": verifyMigrationsPath(*migrationsPath) relativeN := flag.Arg(1) relativeNInt, err := strconv.Atoi(relativeN) if err != nil { fmt.Println("Unable to parse param <n>.") os.Exit(1) } timerStart = time.Now() pipe := pipep.New() go migrate.Migrate(pipe, *url, *migrationsPath, relativeNInt) ok := writePipe(pipe) printTimer() if !ok { os.Exit(1) } case "goto": verifyMigrationsPath(*migrationsPath) toVersion := flag.Arg(1) toVersionInt, err := strconv.Atoi(toVersion) if err != nil || toVersionInt < 0 { fmt.Println("Unable to parse param <v>.") os.Exit(1) } currentVersion, err := migrate.Version(*url, *migrationsPath) if err != nil { fmt.Println(err) os.Exit(1) } relativeNInt := toVersionInt - int(currentVersion) timerStart = time.Now() pipe := pipep.New() go migrate.Migrate(pipe, *url, *migrationsPath, relativeNInt) ok := writePipe(pipe) printTimer() if !ok { os.Exit(1) } case "up": verifyMigrationsPath(*migrationsPath) timerStart = time.Now() pipe := pipep.New() go migrate.Up(pipe, *url, *migrationsPath) ok := writePipe(pipe) printTimer() if !ok { os.Exit(1) } case "down": verifyMigrationsPath(*migrationsPath) timerStart = time.Now() pipe := pipep.New() go migrate.Down(pipe, *url, *migrationsPath) ok := writePipe(pipe) printTimer() if !ok { os.Exit(1) } case "redo": verifyMigrationsPath(*migrationsPath) timerStart = time.Now() pipe := pipep.New() go migrate.Redo(pipe, *url, *migrationsPath) ok := writePipe(pipe) printTimer() if !ok { os.Exit(1) } case "reset": verifyMigrationsPath(*migrationsPath) timerStart = time.Now() pipe := pipep.New() go migrate.Reset(pipe, *url, *migrationsPath) ok := writePipe(pipe) printTimer() if !ok { os.Exit(1) } case "version": verifyMigrationsPath(*migrationsPath) version, err := migrate.Version(*url, *migrationsPath) if err != nil { fmt.Println(err) os.Exit(1) } fmt.Println(version) default: helpCmd() os.Exit(1) case "help": helpCmd() } }
func TestMigrate(t *testing.T) { host := os.Getenv("CRATE_PORT_4200_TCP_ADDR") port := os.Getenv("CRATE_PORT_4200_TCP_PORT") url := fmt.Sprintf("crate://%s:%s", host, port) driver := &Driver{} if err := driver.Initialize(url); err != nil { t.Fatal(err) } successFiles := []file.File{ { Path: "/foobar", FileName: "20161122192905_foobar.up.sql", Version: 20161122192905, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE yolo ( id integer primary key, msg string ); `), }, { Path: "/foobar", FileName: "20161122192905_foobar.down.sql", Version: 20161122192905, Name: "foobar", Direction: direction.Down, Content: []byte(` DROP TABLE yolo; `), }, } failFiles := []file.File{ { Path: "/foobar", FileName: "20161122193005_foobar.up.sql", Version: 20161122193005, Name: "foobar", Direction: direction.Up, Content: []byte(` CREATE TABLE error ( id THIS WILL CAUSE AN ERROR ) `), }, } for _, file := range successFiles { pipe := pipep.New() go driver.Migrate(file, pipe) errs := pipep.ReadErrors(pipe) if len(errs) > 0 { t.Fatal(errs) } } for _, file := range failFiles { pipe := pipep.New() go driver.Migrate(file, pipe) errs := pipep.ReadErrors(pipe) if len(errs) == 0 { t.Fatal("Migration should have failed but succeeded") } } if err := driver.Close(); err != nil { t.Fatal(err) } }
// DownSync is synchronous version of Down(). func DownSync(url, migrationsPath string) (err []error, ok bool) { pipe := pipep.New() go Down(pipe, url, migrationsPath) err = pipep.ReadErrors(pipe) return err, len(err) == 0 }
// NewPipe is a convenience function for pipe.New(). // This is helpful if the user just wants to import this package and nothing else. func NewPipe() chan interface{} { return pipep.New() }
// MigrateSync is synchronous version of Migrate(). func MigrateSync(url, migrationsPath string, relativeN int) (err []error, ok bool) { pipe := pipep.New() go Migrate(pipe, url, migrationsPath, relativeN) err = pipep.ReadErrors(pipe) return err, len(err) == 0 }