func createTables(db *gorm.DB, values ...interface{}) error {
for _, value := range values {
if !db.HasTable(value) {
err := db.CreateTable(value).Error
if err != nil {
errClose := db.Close()
if errClose != nil {
fmt.Printf("%s", errClose)
}
return err
}
}
}
return nil
}
func main() {
var db gorm.DB
var err error
db, err = gorm.Open("mysql", "root:yunjikeji@tcp(10.0.1.31:3306)/osinstall?charset=utf8&parseTime=True&loc=Local")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
defer db.Close()
//db.SingularTable(true)
err = initdb.DropOsInstallTables(&db, nil)
err = initdb.InitOsInstallTables(&db, nil)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
fmt.Println("done")
}
func dbCloseOpen(prevDb *gorm.DB) (*gorm.DB, error) {
prevDb.Close()
return dbOpen()
}
api = api2go.NewAPIWithBaseURL("v0", "http://localhost:31415")
var err error
db, err = storage.InitDB()
if err != nil {
panic(err)
}
userStorage := storage.NewUserStorage(db)
chocStorage := storage.NewChocolateStorage(db)
api.AddResource(model.User{}, resource.UserResource{ChocStorage: chocStorage, UserStorage: userStorage})
api.AddResource(model.Chocolate{}, resource.ChocolateResource{ChocStorage: chocStorage, UserStorage: userStorage})
rec = httptest.NewRecorder()
})
AfterEach(func() {
db.Exec("DROP TABLE chocolates")
db.Exec("DROP TABLE users")
db.Close()
})
var createUser = func() {
rec = httptest.NewRecorder()
req, err := http.NewRequest("POST", "/v0/users", strings.NewReader(`
{
"data": {
"type": "users",
"attributes": {
"user-name": "marvin"
}
}
}
`))
Expect(err).ToNot(HaveOccurred())
func main() {
// --------------------------------------------------------------------
// Parse flags
// --------------------------------------------------------------------
var configFilePath string
var printConfig bool
var migrateDB bool
var scheduler *remoteworkitem.Scheduler
flag.StringVar(&configFilePath, "config", "", "Path to the config file to read")
flag.BoolVar(&printConfig, "printConfig", false, "Prints the config (including merged environment variables) and exits")
flag.BoolVar(&migrateDB, "migrateDatabase", false, "Migrates the database to the newest version and exits.")
flag.Parse()
// Override default -config switch with environment variable only if -config switch was
// not explicitly given via the command line.
configSwitchIsSet := false
flag.Visit(func(f *flag.Flag) {
if f.Name == "config" {
configSwitchIsSet = true
}
})
if !configSwitchIsSet {
if envConfigPath, ok := os.LookupEnv("ALMIGHTY_CONFIG_FILE_PATH"); ok {
configFilePath = envConfigPath
}
}
var err error
if err = configuration.Setup(configFilePath); err != nil {
logrus.Panic(nil, map[string]interface{}{
"configFilePath": configFilePath,
"err": err,
}, "failed to setup the configuration")
}
if printConfig {
os.Exit(0)
}
// Initialized developer mode flag for the logger
log.InitializeLogger(configuration.IsPostgresDeveloperModeEnabled())
printUserInfo()
var db *gorm.DB
for {
db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
db.Close()
log.Logger().Errorf("ERROR: Unable to open connection to database %v\n", err)
log.Logger().Infof("Retrying to connect in %v...\n", configuration.GetPostgresConnectionRetrySleep())
time.Sleep(configuration.GetPostgresConnectionRetrySleep())
} else {
defer db.Close()
break
}
}
if configuration.IsPostgresDeveloperModeEnabled() {
db = db.Debug()
}
// Migrate the schema
err = migration.Migrate(db.DB())
if err != nil {
log.Panic(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed migration")
}
// Nothing to here except exit, since the migration is already performed.
if migrateDB {
os.Exit(0)
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if configuration.GetPopulateCommonTypes() {
// set a random request ID for the context
ctx, req_id := client.ContextWithRequestID(context.Background())
log.Debug(ctx, nil, "Initializing the population of the database... Request ID: %v", req_id)
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(ctx, tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
log.Panic(ctx, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to populate common types")
}
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.BootstrapWorkItemLinking(ctx, link.NewWorkItemLinkCategoryRepository(tx), link.NewWorkItemLinkTypeRepository(tx))
}); err != nil {
log.Panic(ctx, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to bootstap work item linking")
}
}
// Scheduler to fetch and import remote tracker items
scheduler = remoteworkitem.NewScheduler(db)
defer scheduler.Stop()
scheduler.ScheduleAllQueries()
// Create service
service := goa.New("alm")
// Mount middleware
service.Use(middleware.RequestID())
service.Use(middleware.LogRequest(configuration.IsPostgresDeveloperModeEnabled()))
service.Use(gzip.Middleware(9))
service.Use(jsonapi.ErrorHandler(service, true))
service.Use(middleware.Recover())
service.WithLogger(goalogrus.New(log.Logger()))
publicKey, err := token.ParsePublicKey(configuration.GetTokenPublicKey())
if err != nil {
log.Panic(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to parse public token")
}
// Setup Account/Login/Security
identityRepository := account.NewIdentityRepository(db)
userRepository := account.NewUserRepository(db)
tokenManager := token.NewManager(publicKey)
app.UseJWTMiddleware(service, jwt.New(publicKey, nil, app.NewJWTSecurity()))
service.Use(login.InjectTokenManager(tokenManager))
// Mount "login" controller
oauth := &oauth2.Config{
ClientID: configuration.GetKeycloakClientID(),
ClientSecret: configuration.GetKeycloakSecret(),
Scopes: []string{"user:email"},
Endpoint: oauth2.Endpoint{
AuthURL: configuration.GetKeycloakEndpointAuth(),
TokenURL: configuration.GetKeycloakEndpointToken(),
},
}
appDB := gormapplication.NewGormDB(db)
loginService := login.NewKeycloakOAuthProvider(oauth, identityRepository, userRepository, tokenManager, appDB)
loginCtrl := NewLoginController(service, loginService, tokenManager)
app.MountLoginController(service, loginCtrl)
// Mount "status" controller
statusCtrl := NewStatusController(service, db)
app.MountStatusController(service, statusCtrl)
// Mount "workitem" controller
workitemCtrl := NewWorkitemController(service, appDB)
app.MountWorkitemController(service, workitemCtrl)
// Mount "workitemtype" controller
workitemtypeCtrl := NewWorkitemtypeController(service, appDB)
app.MountWorkitemtypeController(service, workitemtypeCtrl)
// Mount "work item link category" controller
workItemLinkCategoryCtrl := NewWorkItemLinkCategoryController(service, appDB)
app.MountWorkItemLinkCategoryController(service, workItemLinkCategoryCtrl)
// Mount "work item link type" controller
workItemLinkTypeCtrl := NewWorkItemLinkTypeController(service, appDB)
app.MountWorkItemLinkTypeController(service, workItemLinkTypeCtrl)
// Mount "work item link" controller
workItemLinkCtrl := NewWorkItemLinkController(service, appDB)
app.MountWorkItemLinkController(service, workItemLinkCtrl)
// Mount "work item comments" controller
workItemCommentsCtrl := NewWorkItemCommentsController(service, appDB)
app.MountWorkItemCommentsController(service, workItemCommentsCtrl)
// Mount "work item relationships links" controller
workItemRelationshipsLinksCtrl := NewWorkItemRelationshipsLinksController(service, appDB)
app.MountWorkItemRelationshipsLinksController(service, workItemRelationshipsLinksCtrl)
// Mount "comments" controller
commentsCtrl := NewCommentsController(service, appDB)
app.MountCommentsController(service, commentsCtrl)
// Mount "tracker" controller
c5 := NewTrackerController(service, appDB, scheduler)
app.MountTrackerController(service, c5)
// Mount "trackerquery" controller
c6 := NewTrackerqueryController(service, appDB, scheduler)
app.MountTrackerqueryController(service, c6)
// Mount "space" controller
spaceCtrl := NewSpaceController(service, appDB)
app.MountSpaceController(service, spaceCtrl)
// Mount "user" controller
userCtrl := NewUserController(service, appDB, tokenManager)
app.MountUserController(service, userCtrl)
// Mount "search" controller
searchCtrl := NewSearchController(service, appDB)
app.MountSearchController(service, searchCtrl)
// Mount "indentity" controller
identityCtrl := NewIdentityController(service, appDB)
app.MountIdentityController(service, identityCtrl)
// Mount "users" controller
usersCtrl := NewUsersController(service, appDB)
app.MountUsersController(service, usersCtrl)
// Mount "iterations" controller
iterationCtrl := NewIterationController(service, appDB)
app.MountIterationController(service, iterationCtrl)
// Mount "spaceiterations" controller
spaceIterationCtrl := NewSpaceIterationsController(service, appDB)
app.MountSpaceIterationsController(service, spaceIterationCtrl)
// Mount "userspace" controller
userspaceCtrl := NewUserspaceController(service, db)
app.MountUserspaceController(service, userspaceCtrl)
// Mount "render" controller
renderCtrl := NewRenderController(service)
app.MountRenderController(service, renderCtrl)
// Mount "areas" controller
areaCtrl := NewAreaController(service, appDB)
app.MountAreaController(service, areaCtrl)
spaceAreaCtrl := NewSpaceAreasController(service, appDB)
app.MountSpaceAreasController(service, spaceAreaCtrl)
log.Logger().Infoln("Git Commit SHA: ", Commit)
log.Logger().Infoln("UTC Build Time: ", BuildTime)
log.Logger().Infoln("UTC Start Time: ", StartTime)
log.Logger().Infoln("Dev mode: ", configuration.IsPostgresDeveloperModeEnabled())
http.Handle("/api/", service.Mux)
http.Handle("/", http.FileServer(assetFS()))
http.Handle("/favicon.ico", http.NotFoundHandler())
// Start http
if err := http.ListenAndServe(configuration.GetHTTPAddress(), nil); err != nil {
log.Error(nil, map[string]interface{}{
"addr": configuration.GetHTTPAddress(),
"err": err,
}, "unable to connect to server")
service.LogError("startup", "err", err)
}
}
// Monitor bind and monitor for DNS packets. This will also
// handle the various output methods.
func Monitor(options *Options) {
if !options.Quiet {
fmt.Printf("\n %s (%s) - %s\n\n",
Name,
Version,
Description,
)
fmt.Printf(" Hostname: %s\n", options.Hostname)
fmt.Printf(" Interface: %s (%s)\n",
options.InterfaceData.Name, options.InterfaceData.HardwareAddr.String())
fmt.Printf(" IP Address: %s\n", options.Ip)
// addrs, err := options.InterfaceData.Addrs()
// if err == nil {
// var list []string
// for _, addr := range addrs {
// list = append(list, addr.String())
// }
// fmt.Printf(" Addresses: %s\n\n", strings.Join(list, ", "))
// } else {
// fmt.Printf("\n")
// }
}
expr := fmt.Sprintf("port %d", options.Port)
h, err := pcap.OpenLive(options.Interface, int32(snaplen), true, 500)
if h == nil {
fmt.Fprintf(os.Stderr, "%s Error: %s\n", Name, err)
os.Exit(-1)
}
ferr := h.SetFilter(expr)
if ferr != nil {
fmt.Fprintf(os.Stderr, "%s Error: %s", Name, ferr)
os.Exit(-1)
}
var file *os.File
if options.Write != "" {
file = OpenFile(options.Write)
defer func() {
if err := file.Close(); err != nil {
panic(err)
}
}()
}
var db gorm.DB
var clientId int64 = 0
queue := make(chan *Question)
if options.Mysql || options.Postgres || options.Sqlite3 {
db, err = DatabaseConnect(options)
if err != nil {
fmt.Println("\n Error: ", err.Error(), "\n")
os.Exit(1)
}
clientId = CreateClient(db, options)
go func() {
for elem := range queue {
elem.ToDatabase(db, options)
}
}()
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
defer func() {
if r := recover(); r != nil {
fmt.Println("DB Queue - Recovered:", r)
fmt.Println("Please report this issue. https://github.com/mephux/dnas")
}
}()
for sig := range c {
if sig.String() == "interrupt" {
file.Close()
close(queue)
if options.Mysql || options.Postgres || options.Sqlite3 {
db.Close()
}
os.Exit(1)
}
}
}()
if options.User != "" {
chuser(options.User)
}
defer func() {
if r := recover(); r != nil {
fmt.Println("Monitor - Recovered:", r)
fmt.Println("Please report this issue. https://github.com/mephux/dnas")
}
}()
for pkt, r := h.NextEx(); r >= 0; pkt, r = h.NextEx() {
if r == 0 {
continue
}
message, err := DNS(pkt, options)
if err == nil {
if options.Write != "" {
go func() {
json, err := message.ToJSON()
if err != nil {
fmt.Println(err.Error())
os.Exit(-1)
}
WriteToFile(file, json)
}()
}
if options.Mysql || options.Postgres || options.Sqlite3 {
message.ClientId = clientId
queue <- message
}
if !options.Quiet {
message.ToStdout(options)
}
}
}
fmt.Fprintf(os.Stderr, "%s Error: %s\n", Name, h.Geterror())
}