// return map[location][class_name]*JobInfoEntry func getGroupedJobInfo() (map[string]map[string]*JobInfoEntry, error) { res := make(map[string]map[string]*JobInfoEntry) rows, err := db.Query(QUERY_GET_JOB_INFO) if err != nil { return nil, err } for rows.Next() { entry := new(JobInfoEntry) err = rows.Scan( &entry.generation_id, &entry.class_name, &entry.location, &entry.init_jobs_ts, &entry.jobs_generated_ts, &entry.finish_jobs_ts, &entry.next_generate_job_ts, &entry.settings_id) if err != nil { return nil, err } if _, ok := res[entry.class_name]; !ok { res[entry.class_name] = make(map[string]*JobInfoEntry) } res[entry.class_name][entry.location] = entry } return res, nil }
// get existing ids from db for provided checkIds list func getExistingTTIds(checkIds []uint64) (map[uint64]bool, error) { res := make(map[uint64]bool, len(checkIds)) if len(checkIds) == 0 { return res, nil } rows, err := db.Query(QUERY_CHECK_TT_IDS, "ids", db.INUint64(checkIds)) if err != nil { return nil, err } defer rows.Close() var id uint64 for rows.Next() { err = rows.Scan(&id) if err != nil { return nil, err } res[id] = true } return res, nil }
func selectTimetable() (map[string]map[string][]*TimetableEntry, error) { timetableRows := make(map[string]map[string][]*TimetableEntry) rows, err := db.Query(QUERY_SELECT_FROM_TIMETABLE, "add_where", "") if err != nil { return nil, err } defer rows.Close() for rows.Next() { tt_entry, err := scanTimetableEntry(rows) if err != nil { return nil, err } perLoc, ok := timetableRows[tt_entry.class_name] if !ok { perLoc = make(map[string][]*TimetableEntry) timetableRows[tt_entry.class_name] = perLoc } if _, ok := perLoc[tt_entry.location]; !ok { perLoc[tt_entry.location] = make([]*TimetableEntry, 0) } perLoc[tt_entry.location] = append(perLoc[tt_entry.location], tt_entry) } return timetableRows, nil }
func getFlags() (map[string]*FlagEntry, error) { res := make(map[string]*FlagEntry) rows, err := db.Query(QUERY_GET_FLAGS) if err != nil { return nil, err } for rows.Next() { entry := new(FlagEntry) err = rows.Scan( &entry.class_name, &entry.run_requested_ts, &entry.run_accepted_ts, &entry.pause_requested_ts, &entry.kill_requested_ts, &entry.kill_request_employee_id, &entry.run_queue_killed_ts, &entry.killed_ts, &entry.paused_ts) if err != nil { return nil, err } res[entry.class_name] = entry } return res, nil }
func getScriptRusageStats() (map[string]*ScriptRusageEntry, error) { res := make(map[string]*ScriptRusageEntry) rows, err := db.Query(QUERY_GET_SCRIPTS_RUSAGE_STATS) if err != nil { return nil, err } var ( class_name string max_memory int64 user_time float64 sys_time float64 real_time float64 ) for rows.Next() { entry := new(ScriptRusageEntry) err = rows.Scan( &class_name, &real_time, &sys_time, &user_time, &max_memory) if err != nil { return nil, err } entry.cpu_usage = defaultRusage entry.max_memory = defaultMaxMemory if max_memory > 0 { entry.max_memory = max_memory } if (user_time > 0 || sys_time > 0) && real_time > 0 { entry.cpu_usage = (user_time + sys_time) / real_time } res[class_name] = entry } return res, nil }
func SelectRunQueue() (map[string][]*RunQueueEntry, error) { rqRows := make(map[string][]*RunQueueEntry, 0) rows, err := db.Query(QUERY_GET_RUNQUEUE, "where", "") if err != nil { return nil, err } for rows.Next() { rq_entry, err := scanRqEntry(rows) if err != nil { return nil, err } rqRows[rq_entry.hostname] = append(rqRows[rq_entry.hostname], rq_entry) } return rqRows, nil }
func getRunningInfo(run_id uint64) (*RunQueueEntry, error) { rows, err := db.Query(QUERY_GET_RUNQUEUE, "where", &db.RawData{Data: fmt.Sprintf("WHERE id = %d", run_id)}) if err != nil { return nil, err } defer rows.Close() for rows.Next() { rq_entry, err := scanRqEntry(rows) if err != nil { return nil, err } return rq_entry, nil } return nil, errorNoRow }
func getAvailableHosts() (map[string][]string, map[string]*ServerInfo, error) { rows, err := db.Query(QUERY_GET_AVAILABLE_HOSTS) if err != nil { return nil, nil, err } hosts := make(map[string][]string) info := make(map[string]*ServerInfo) defer rows.Close() for rows.Next() { entry := new(ServerInfo) err = rows.Scan( &entry.hostname, &entry.group, &entry.cpu_idle_parrots, &entry.cpu_parrots_per_core, &entry.cpu_idle_cores, &entry.cpu_cores, &entry.cpu_parasite, &entry.mem_total, &entry.mem_free, &entry.mem_cached, &entry.mem_parasite, &entry.swap_used, &entry.min_memory, &entry.min_memory_ratio) if err != nil { return nil, nil, err } hosts[entry.group] = append(hosts[entry.group], entry.hostname) info[entry.hostname] = entry } return hosts, info, nil }
func selectTimetableByIds(ids []uint64) ([]*TimetableEntry, error) { timetableRows := make([]*TimetableEntry, 0, len(ids)) if len(ids) == 0 { return timetableRows, nil } rows, err := db.Query(QUERY_SELECT_FROM_TIMETABLE, "add_where", &db.RawData{Data: fmt.Sprintf("WHERE id IN (%s)", db.INUint64(ids).Data)}) if err != nil { return nil, err } defer rows.Close() for rows.Next() { tt_entry, err := scanTimetableEntry(rows) if err != nil { return nil, err } timetableRows = append(timetableRows, tt_entry) } return timetableRows, nil }
func getAutoIncrementIncrement() int64 { rows, err := db.Query("SHOW VARIABLES LIKE 'auto_increment_increment'") if err != nil { log.Fatal("Could not get auto_increment_increment variable from DB: " + err.Error()) } defer rows.Close() var varName string var res int64 for rows.Next() { if err := rows.Scan(&varName, &res); err != nil { log.Fatal("Could not fetch results for auto_increment_increment variable: " + err.Error()) } if varName == "auto_increment_increment" { return res } } return 1 // default value if no special variable is set }
func getGroupedScriptsForPlatform() (map[string]*ScriptEntry, error) { res := make(map[string]*ScriptEntry) rows, err := db.Query(QUERY_SIMPLE_GET_SCRIPTS_FOR_PLATFORM) if err != nil { return nil, err } for rows.Next() { entry := new(ScriptEntry) err = rows.Scan( &entry.class_name, &entry.settings_id) if err != nil { return nil, err } res[entry.class_name] = entry } return res, nil }
func getRunningInfos(run_ids []uint64) ([]*RunQueueEntry, error) { res := make([]*RunQueueEntry, 0, len(run_ids)) if len(run_ids) == 0 { return res, nil } rows, err := db.Query(QUERY_GET_RUNQUEUE, "where", &db.RawData{Data: fmt.Sprintf("WHERE id IN (%s)", db.INUint64(run_ids).Data)}) if err != nil { return nil, err } defer rows.Close() for rows.Next() { rq_entry, err := scanRqEntry(rows) if err != nil { return nil, err } res = append(res, rq_entry) } return res, nil }
func loadNewIds(newIds map[uint64]bool) error { if len(newIds) == 0 { return nil } var ids []string for id := range newIds { ids = append(ids, strconv.FormatUint(id, 10)) } rows, err := db.Query(QUERY_GET_NEW_SETTINGS, "new_settings_ids", strings.Join(ids, ",")) if err != nil { return err } for rows.Next() { entry := new(ScriptSettings) var ( jobsStr string nextTsCallbackStr sql.NullString ) err = rows.Scan( &entry.id, &entry.class_name, &entry.instance_count, &entry.max_time, &jobsStr, &nextTsCallbackStr, &entry.repeat, &entry.retry, &entry.ttl, &entry.repeat_job, &entry.retry_job, &entry.location, &entry.location_type, &entry.developer, &entry.max_retries, &entry.profiling_enabled, &entry.debug_enabled, &entry.named_params, &entry.created) if err != nil { log.Errorf("Invalid settings: %s", err.Error()) err = nil continue } entry.jobs, err = parseJobs(jobsStr) if err != nil { log.Errorf("Could not parse Jobs for %s #%d: %s", entry.class_name, entry.id, err.Error()) err = nil continue } if nextTsCallbackStr.Valid { entry.have_next_ts_callback = true entry.next_ts_callback, err = parseNextTsCallback(nextTsCallbackStr.String) if err != nil { log.Errorf("Could not parse next ts callback for %s #%d: %s", entry.class_name, entry.id, err.Error()) err = nil continue } } else { entry.have_next_ts_callback = false } if err != nil { log.Errorf("Scan error in loadNewIds: %s", err.Error()) err = nil continue } allSettingsMutex.Lock() allSettings[entry.id] = entry allSettingsMutex.Unlock() } return nil }