func serve(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
if config.Debug() {
logs.Level(logs.DebugLevel)
}
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var app = application.New()
if app.Components["DB"], err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
app.Components["DB"].(*gorm.DB).AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
app.Components["Templates"] = views.Templates()
// app.Components["Mux"] = router.New()
app.Components["Mux"] = gojimux.New()
if config.Debug() {
app.Use(router.Logger)
}
app.Use(app.Apply)
app.Get("/users/register", controllers.Register)
app.Post("/users/auth", controllers.Auth)
app.Post("/users/register", controllers.Register)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
return app.Serve(server.String())
}
// Index indexes a contact into elasticsearch
func index(Contact *models.Contact, s *elastic.Client) error {
id := strconv.Itoa(int(Contact.ID))
if id == "" {
logs.Error("id is nil")
return errors.New("id is nil")
}
if Contact.Address.Longitude == "null" || Contact.Address.Latitude == "null" {
logs.Debug("Could not index contact %s", id)
return nil
}
if Contact.Address.Latitude != "" && Contact.Address.Longitude != "" {
Contact.Address.Location = fmt.Sprintf("%s,%s", Contact.Address.Latitude, Contact.Address.Longitude)
}
_, err := s.Index().
Index("contacts").
Type("contact").
Id(id).
BodyJson(Contact).
Do()
if err != nil {
logs.Critical(err)
return err
}
logs.Debug("Contact %s indexed", id)
return nil
}
//Find the last indexed Contact's ID
func findID(s *elastic.Client) (int, error) {
termQuery := elastic.NewMatchAllQuery()
searchResult, err := s.Search().
Index("contacts").
Query(&termQuery).
Fields("_timestamp").
Sort("_timestamp", false).
Size(1).
Pretty(true).
Do()
if err != nil {
logs.Critical(err)
return 0, err
}
var ID int
if searchResult.Hits != nil {
for _, hit := range searchResult.Hits.Hits {
ID, err = strconv.Atoi(hit.Id)
if err != nil {
return 0, err
}
}
} else {
logs.Debug("No results, ID is 1")
return 1, nil
}
return ID, nil
}
func serve(ctx *cli.Context) error {
var app = application.New()
config, err := settings.Parse(ctx.String("config"))
if err != nil && ctx.String("config") != "" {
logs.Error(err)
}
if ctx.Bool("debug") || config.Debug() {
logs.Level(logs.DebugLevel)
}
app.Components["Mux"] = router.New()
if ctx.Bool("debug") || config.Debug() {
app.Use(router.Logger)
}
app.Use(app.Apply)
app.Post("/trigger/:id", controllers.TriggerBuild)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
return app.Serve(server.String())
}
// Index indexes a contact into elasticsearch
func index(Contact *models.Contact, s *elastic.Client) error {
id := strconv.Itoa(int(Contact.ID))
if id == "" {
logs.Error("id is nil")
return errors.New("id is nil")
}
_, err := s.Index().
Index("contacts").
Type("contact").
Id(id).
BodyJson(Contact).
Do()
if err != nil {
logs.Critical(err)
return err
}
logs.Debug("Indexed")
return nil
}
func script(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
logs.Level(logs.DebugLevel)
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var db *gorm.DB
if db, err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
db.AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
db.LogMode(true)
ElasticSettings, err := config.Elasticsearch()
var client *elastic.Client
client, err = dialElasticRetry(ElasticSettings.String())
if err != nil {
logs.Critical(err)
os.Exit(1)
}
// Use the IndexExists service to check if a specified index exists.
exists, err := client.IndexExists("contacts").Do()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
if !exists {
logs.Critical("No contacts index")
os.Exit(1)
}
ID := config.Int("id")
if ID == -1 {
logs.Debug("Looking for ID")
ID, err = findID(client)
if err != nil {
logs.Debug(err)
os.Exit(1)
}
}
logs.Debug("Last ID is : %d", ID)
contacts, err := findContacts(ID, db)
doContacts := config.Bool("contacts")
doFacts := config.Bool("facts")
if doContacts == false && doFacts == false {
logs.Debug("Nothing to be done, please activate some options")
os.Exit(1)
}
for _, contact := range contacts {
id := contact.ID
if id != 0 {
contact, err := addAddresses(contact, db)
if err == nil {
if contact != nil {
if doContacts {
logs.Debug("Indexing contact %d : %s %s", id, contact.Surname, contact.Firstname)
err = index(contact, client)
if err != nil {
logs.Critical(err)
}
}
if doFacts {
logs.Debug("Creating and indexing fact for contact %d : %s %s", id, contact.Surname, contact.Firstname)
err = createFact(contact, client, db)
if err != nil {
logs.Critical(err)
}
}
} else {
logs.Debug("Could not index contact %d", id)
}
}
}
}
return nil
}
func serve(ctx *cli.Context) error {
clientID := ctx.String("client-id")
clientSecret := ctx.String("client-secret")
var config settings.Config
var err error
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
if config.Debug() {
logs.Level(logs.DebugLevel)
}
redisSettings, err := config.Redis()
client := redis.NewClient(&redis.Options{Addr: redisSettings.String()})
if _, err := client.Ping().Result(); err != nil {
return err
}
logs.Debug("Connected to Redis at %s", redisSettings.String())
store := components.NewRedisStore(client)
proxy := goproxy.NewProxyHttpServer()
if config.Debug() {
proxy.Verbose = true
}
// Treat only requests with an SID cookie or POSTing username and password.
var session = goproxy.ReqConditionFunc(func(req *http.Request, ctx *goproxy.ProxyCtx) bool {
_, err := req.Cookie("SID")
return err == nil || (req.Method == "POST" && req.FormValue("username") != "" && req.FormValue("password") != "") // The form is already parsed.
})
proxy.NonproxyHandler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
dump, _ := httputil.DumpRequest(req, true)
fmt.Println(string(dump))
req.URL.Scheme = req.Header.Get("X-Scheme")
req.URL.Host = req.Host
proxy.ServeHTTP(w, req)
})
proxy.OnRequest(session).DoFunc(
func(req *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) {
//dump, _ := httputil.DumpRequest(req, true)
//fmt.Println(string(dump))
cookie, err := req.Cookie("SID")
if err == nil {
session, err := store.Load(cookie.Value)
if err != nil {
return req, goproxy.NewResponse(req, "text/plain", http.StatusForbidden, "Invalid cookie")
}
req.Header.Del("Cookie")
req.Header.Add("Authorization", "Bearer "+session.AccessToken)
return req, nil
}
// Perform an OAuth "Resource Owner Password Credentials Grant"
req.Form.Add("grant_type", "password")
req.SetBasicAuth(clientID, clientSecret)
// We must update the body and the content size for our new post value.
var buffer io.Reader = strings.NewReader(req.Form.Encode())
req.Body = ioutil.NopCloser(buffer)
switch v := buffer.(type) {
case *bytes.Buffer:
req.ContentLength = int64(v.Len())
case *bytes.Reader:
req.ContentLength = int64(v.Len())
case *strings.Reader:
req.ContentLength = int64(v.Len())
}
//req.RequestURI = "" // Must be removed for client requests
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return req, nil
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return req, nil
}
// TODO: Check http status for errors
access := new(components.AccessData)
if err := json.Unmarshal(body, access); err != nil {
return req, nil
}
session := &components.Session{
ID: strings.TrimRight(base64.StdEncoding.EncodeToString(uuid.NewRandom()), "="),
AccessToken: access.AccessToken,
RefreshToken: access.RefreshToken,
ExpiresIn: access.ExpiresIn,
}
if err := store.Save(session); err != nil {
return req, nil
}
// TODO: Give a json response to clients
resp = goproxy.NewResponse(req, "text/plain", http.StatusOK, "")
cookie = &http.Cookie{Name: "SID", Value: session.ID}
resp.Header.Add("Set-Cookie", cookie.String())
return req, resp
},
)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Info("Listening on %s", server.String())
return http.ListenAndServe(server.String(), proxy)
}
func script(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
logs.Level(logs.DebugLevel)
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var db *gorm.DB
if db, err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
db.AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
db.LogMode(true)
ElasticSettings, err := config.Elasticsearch()
var client *elastic.Client
client, err = dialElasticRetry(ElasticSettings.String())
if err != nil {
logs.Critical(err)
os.Exit(1)
}
// Use the IndexExists service to check if a specified index exists.
exists, err := client.IndexExists("contacts").Do()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
if !exists {
logs.Critical("No contacts index")
os.Exit(1)
}
ID, err := findID(client)
if err != nil {
logs.Debug(err)
os.Exit(1)
}
logs.Debug("Last ID is : %d", ID)
contacts, err := findContacts(ID, db)
for _, contact := range contacts {
contact, err := addAddresses(contact, db)
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("Indexing contact %d : %s %s", contact.ID, contact.Surname, contact.Firstname)
err = index(contact, client)
if err != nil {
logs.Critical(err)
os.Exit(1)
}
}
return nil
}
func serve(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
if config.Debug() {
logs.Level(logs.DebugLevel)
}
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var app = application.New()
if app.Components["DB"], err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
app.Components["DB"].(*gorm.DB).AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
redisSettings, err := config.Redis()
client := redis.NewClient(&redis.Options{Addr: redisSettings.String()})
if _, err := client.Ping().Result(); err != nil {
return err
}
logs.Debug("Connected to Redis at %s", redisSettings.String())
app.Components["Redis"] = client
cfg := osin.NewServerConfig()
cfg.AllowedAuthorizeTypes = osin.AllowedAuthorizeType{osin.CODE, osin.TOKEN}
cfg.AllowedAccessTypes = osin.AllowedAccessType{osin.AUTHORIZATION_CODE,
osin.REFRESH_TOKEN, osin.PASSWORD}
oauthServer := osin.NewServer(cfg, components.NewRedisStorage(client))
app.Components["OAuth"] = oauthServer
app.Components["Templates"] = views.Templates()
app.Components["Mux"] = gojimux.New()
if config.Debug() {
app.Components["DB"].(*gorm.DB).LogMode(true)
app.Use(router.Logger)
}
app.Use(app.Apply)
app.Get("/oauth2/authorize", controllers.Authorize)
app.Post("/oauth2/token", controllers.Token)
app.Get("/oauth2/info", controllers.Info)
app.Post("/users/register", controllers.Register)
app.Get("/users/:id", controllers.RetrieveUser)
app.Get("/groups", controllers.RetrieveGroupCollection)
app.Post("/groups", controllers.CreateGroup)
app.Get("/groups/:id", controllers.RetrieveGroup)
app.Delete("/groups/:id", controllers.DeleteGroup)
app.Patch("/groups/:id", controllers.UpdateGroup)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
return app.Serve(server.String())
}
func add(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
var mail = ctx.String("mail")
var password = ctx.String("password")
var firstname = ctx.String("firstname")
var surname = ctx.String("surname")
var groupID = ctx.String("group")
if mail == "" || password == "" || firstname == "" || surname == "" {
logs.Error("All arguments are required")
return errors.New("all arguments are required")
}
passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
panic(err)
}
var convGroupID = 0
if groupID != "" {
convGroupID, err = strconv.Atoi(groupID)
if err != nil {
logs.Error(err)
return err
}
}
u := &models.User{
Mail: sPtr(mail),
Password: sPtr(string(passwordHash)),
Firstname: sPtr(firstname),
Surname: sPtr(surname),
GroupID: uint(convGroupID),
}
errs := u.Validate()
logs.Level(logs.DebugLevel)
if len(errs) > 0 {
logs.Error(errs)
return errors.New("Informations are not valid")
}
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var db *gorm.DB
if db, err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
db.AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
db.LogMode(true)
var store = models.UserStore(db)
err = store.Save(u)
if err != nil {
logs.Error(err)
return err
}
logs.Debug("New user :"******"-Mail : %s", mail)
logs.Debug("-Password : %s", password)
logs.Debug("-Firstname : %s", firstname)
logs.Debug("-Surname : %s", surname)
logs.Debug("-GroupID : %d", convGroupID)
return nil
}