func (g *GrabService) execService() {
g.LastGrabStat = false
go func(g *GrabService) {
for g.ServiceRunningStat {
if g.LastGrabStat {
<-time.After(g.GrabInterval)
} else {
<-time.After(g.TimeOutInterval)
}
if !g.ServiceRunningStat {
continue
}
g.ErrorNotes = ""
g.LastGrabExe = time.Now()
g.NextGrabExe = time.Now().Add(g.GrabInterval)
g.LastGrabStat = true
g.Log.AddLog(fmt.Sprintf("[%s] Grab Started %s", g.Name, g.Url), "INFO")
g.GrabCount += 1
keySetting := []string{}
switch g.SourceType {
case SourceType_HttpHtml, SourceType_HttpJson:
if e := g.ServGrabber.Grab(nil); e != nil {
g.ErrorNotes = fmt.Sprintf("[%s] Grab Failed %s, repeat after %s :%s", g.Name, g.Url, g.TimeOutIntervalInfo, e)
g.Log.AddLog(g.ErrorNotes, "ERROR")
g.NextGrabExe = time.Now().Add(g.TimeOutInterval)
g.LastGrabStat = false
g.ErrorFound += 1
} else {
g.Log.AddLog(fmt.Sprintf("[%s] Grab Success %s", g.Name, g.Url), "INFO")
}
for key, _ := range g.ServGrabber.Config.DataSettings {
keySetting = append(keySetting, key)
}
// keySetting = g.sGrabber.Config.DataSettings
case SourceType_DocExcel:
// e = g.sGetData.ResultFromDatabase(key, &docs)
// if e != nil {
// g.LastGrabStat = false
// }
for key, _ := range g.ServGetData.CollectionSettings {
keySetting = append(keySetting, key)
}
}
// if e := g.ServGrabber.Grab(nil); e != nil {
// g.ErrorNotes = fmt.Sprintf("[%s] Grab Failed %s, repeat after %s :%s", g.Name, g.Url, g.TimeOutIntervalInfo, e)
// g.Log.AddLog(g.ErrorNotes, "ERROR")
// g.NextGrabExe = time.Now().Add(g.TimeOutInterval)
// g.LastGrabStat = false
// g.ErrorFound += 1
// continue
// } else {
// g.Log.AddLog(fmt.Sprintf("[%s] Grab Success %s", g.Name, g.Url), "INFO")
// }
if g.LastGrabStat {
for _, key := range keySetting {
var e error
g.Log.AddLog(fmt.Sprintf("[%s-%s] Fetch Data to destination started", g.Name, key), "INFO")
docs := []toolkit.M{}
switch g.SourceType {
case SourceType_HttpHtml, SourceType_HttpJson:
e = g.ServGrabber.ResultFromHtml(key, &docs)
case SourceType_DocExcel:
e = g.ServGetData.ResultFromDatabase(key, &docs)
if e != nil {
g.LastGrabStat = false
}
}
if e != nil || !(g.LastGrabStat) {
g.ErrorNotes = fmt.Sprintf("[%s-%s] Fetch Result Failed : ", g.Name, key, e)
g.Log.AddLog(g.ErrorNotes, "ERROR")
}
e = g.DestDbox[key].IConnection.Connect()
if e != nil {
g.ErrorNotes = fmt.Sprintf("[%s-%s] Connect to destination failed [%s-%s]:%s", g.Name, key, g.DestDbox[key].Desttype, g.DestDbox[key].IConnection.Info().Host, e)
g.Log.AddLog(g.ErrorNotes, "ERROR")
}
var q dbox.IQuery
if g.DestDbox[key].Collection == "" {
q = g.DestDbox[key].IConnection.NewQuery().SetConfig("multiexec", true).Save()
} else {
q = g.DestDbox[key].IConnection.NewQuery().SetConfig("multiexec", true).From(g.DestDbox[key].Collection).Save()
}
xN := 0
iN := 0
for _, doc := range docs {
for key, val := range doc {
doc[key] = strings.TrimSpace(fmt.Sprintf("%s", val))
}
if g.DestDbox[key].Desttype == "mongo" {
doc["_id"] = toolkit.GenerateRandomString("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnpqrstuvwxyz", 32)
}
e = q.Exec(toolkit.M{
"data": doc,
})
if g.DestDbox[key].Desttype == "mongo" {
delete(doc, "_id")
}
if e != nil {
g.ErrorNotes = fmt.Sprintf("[%s-%s] Unable to insert [%s-%s]:%s", g.Name, key, g.DestDbox[key].Desttype, g.DestDbox[key].IConnection.Info().Host, e)
g.Log.AddLog(g.ErrorNotes, "ERROR")
g.ErrorFound += 1
} else {
iN += 1
}
xN++
}
g.RowGrabbed += xN
q.Close()
g.DestDbox[key].IConnection.Close()
g.Log.AddLog(fmt.Sprintf("[%s-%s] Fetch Data to destination finished with %d record fetch", g.Name, key, xN), "INFO")
if g.HistoryPath != "" && g.HistoryRecPath != "" {
recfile := g.AddRecHistory(key, docs)
historyservice := toolkit.M{}.Set("datasettingname", key).Set("grabdate", g.LastGrabExe).Set("rowgrabbed", g.RowGrabbed).
Set("rowsaved", iN).Set("note", g.ErrorNotes).Set("grabstatus", "SUCCESS").Set("recfile", recfile)
if !(g.LastGrabStat) {
historyservice.Set("grabstatus", "FAILED")
}
g.AddHistory(historyservice)
}
}
} else {
if g.HistoryPath != "" {
historyservice := toolkit.M{}.Set("datasettingname", "-").Set("grabdate", g.LastGrabExe).Set("rowgrabbed", g.RowGrabbed).
Set("rowsaved", 0).Set("note", g.ErrorNotes).Set("grabstatus", "FAILED").Set("recfile", "")
g.AddHistory(historyservice)
}
}
}
}(g)
}
func streamsavedata(intms <-chan toolkit.M, sQ dbox.IQuery, key string, dt toolkit.M) {
var err error
iN, note := 0, ""
for intm := range intms {
if destDboxs[key].desttype == "mongo" {
intm.Set("_id", toolkit.GenerateRandomString("", 32))
}
if len(intm) == 0 {
continue
}
//Pre Execute Program
if extCommand.Has("pre") && toolkit.ToString(extCommand["pre"]) != "" {
sintm := toolkit.JsonString(intm)
arrcmd := make([]string, 0, 0)
// if runtime.GOOS == "windows" {
// arrcmd = append(arrcmd, "cmd")
// arrcmd = append(arrcmd, "/C")
// }
arrcmd = append(arrcmd, toolkit.ToString(extCommand["pre"]))
arrcmd = append(arrcmd, sintm)
// output, err := toolkit.RunCommand(arrcmd[0], arrcmd[1:])
output, err := toolkit.RunCommand(arrcmd[0], arrcmd[1])
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to execute pre external command :%s", key, err.Error()), "ERROR")
note = "Error Found"
continue
}
err = toolkit.UnjsonFromString(output, &intm)
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to get pre external command output :%s", key, err.Error()), "ERROR")
note = "Error Found"
continue
}
}
err = sQ.Exec(toolkit.M{
"data": intm,
})
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to insert data [%s-%s]:%s", key, "csv", destDboxs[key].IConnection.Info().Host, err.Error()), "ERROR")
note = "Error Found"
continue
}
err = saverechistory(key, intm)
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to insert record data [%s-%s]:%s", key, "csv", destDboxs[key].IConnection.Info().Host, err.Error()), "ERROR")
note = "Error Found"
}
iN += 1
if math.Mod(float64(iN), 100) == 0 {
_ = updatesnapshot(iN, key)
dt = dt.Set("rowsaved", (toolkit.ToInt(dt.Get("rowsaved", 0), toolkit.RoundingAuto) + iN))
iN = 0
}
//Post Execute Program
if extCommand.Has("post") {
sintm := toolkit.JsonString(intm)
arrcmd := make([]string, 0, 0)
// if runtime.GOOS == "windows" {
// arrcmd = append(arrcmd, "cmd")
// arrcmd = append(arrcmd, "/C")
// }
arrcmd = append(arrcmd, toolkit.ToString(extCommand["post"]))
arrcmd = append(arrcmd, sintm)
// output, err := toolkit.RunCommand(arrcmd[0], arrcmd[1:])
output, err := toolkit.RunCommand(arrcmd[0], arrcmd[1])
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to execute post external command :%s", key, err.Error()), "ERROR")
note = "Error Found"
continue
}
err = toolkit.UnjsonFromString(output, &intm)
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to get post external command output :%s", key, err.Error()), "ERROR")
note = "Error Found"
continue
}
}
}
dt = dt.Set("note", note).
Set("grabstatus", "done").
Set("rowsaved", (toolkit.ToInt(dt.Get("rowsaved", 0), toolkit.RoundingAuto) + iN))
_ = updatesnapshot(iN, key)
err = savehistory(dt)
if err != nil {
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Unable to save history : %s", key), "ERROR")
}
Log.AddLog(fmt.Sprintf("[savedatagrab.%s] Finish save data", key), "INFO")
destDboxs[key].IConnection.Close()
}
