Files
pipelines/internal/pipeline/search.go
T
alan 6ca415c134 Search: order results newest first in every group
Chat hits sort by the chat's last use whatever field matched, and run,
step, field, artifact and pipeline hits sort by their own date, before
the result cap applies so the cap drops the oldest. Each kind's row scan
also walks newest first. Score still reports the match tier. The app
sorts both groups newest first as well.
2026-11-03 13:35:27 +00:00

721 lines
23 KiB
Go

package pipeline
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"sort"
"strconv"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// Search answers one ranked, bounded, read-only query over the existing tables.
// It scans no artifact contents and makes no follow-up calls: each kind runs at
// most one query, field text is decoded with decodeValues over a fixed scan
// budget, and ranking/tie-breaking happens in memory over the candidate set.
func (s *Store) Search(ctx context.Context, req protocol.SearchRequest, now time.Time) (*protocol.SearchResponse, error) {
kind := strings.TrimSpace(req.Kind)
if kind != "" && searchKindIndex(kind) < 0 {
return nil, fmt.Errorf("unknown search kind %q; use one of %s", req.Kind, strings.Join(protocol.SearchKinds, ", "))
}
response := &protocol.SearchResponse{
Query: req.Query,
Kind: kind,
Results: []protocol.SearchResult{},
Cap: searchLimit(req.Limit),
ScanBoundBytes: protocol.SearchMaxScanBytes,
}
// Empty text without a kind remains a no-op. A validated kind explicitly
// requests bounded recent canonical rows, never a wildcard text search.
browse := strings.TrimSpace(req.Query) == ""
if browse && kind == "" {
return response, nil
}
terms := parseSearchTerms(req.Query, now)
terms.Browse = browse
terms.Limit = response.Cap
// A bare status word or date selects runs; it is never treated as body text.
selectorOnly := terms.Text == "" && !browse
tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return nil, err
}
defer tx.Rollback()
var results []protocol.SearchResult
var scan searchScan
for i, candidate := range protocol.SearchKinds {
if kind != "" && searchKindIndex(kind) != i {
continue
}
if selectorOnly && candidate != protocol.SearchKindRun {
continue
}
var hits []protocol.SearchResult
var err error
switch candidate {
case protocol.SearchKindPipeline:
hits, err = searchPipelines(ctx, tx, terms, &scan)
case protocol.SearchKindVersion:
hits, err = searchVersions(ctx, tx, terms, &scan)
case protocol.SearchKindRun:
hits, err = searchRuns(ctx, tx, terms, &scan)
case protocol.SearchKindStep:
hits, err = searchSteps(ctx, tx, terms, &scan)
case protocol.SearchKindField:
hits, err = searchFields(ctx, tx, terms, &scan)
case protocol.SearchKindArtifact:
hits, err = searchArtifacts(ctx, tx, terms, &scan)
}
if err != nil {
return nil, err
}
results = append(results, hits...)
}
if err := tx.Commit(); err != nil {
return nil, err
}
response.ScannedSteps = scan.steps
response.ScannedBytes = scan.bytes
if scan.truncated {
response.Truncated = true
}
if browse {
for i := range results {
results[i].Score = 0
}
}
// Hits are ordered newest first before the cap, so the cap drops the
// oldest; Score still records how each hit matched.
sortRecentSearchResults(results)
if len(results) > response.Cap {
results = results[:response.Cap]
response.Truncated = true
}
if results == nil {
results = []protocol.SearchResult{}
}
response.Results = results
return response, nil
}
func searchKindIndex(kind string) int {
for i, k := range protocol.SearchKinds {
if k == kind {
return i
}
}
return -1
}
// searchLimit clamps a requested cap. Zero, negative or over-max requests fall
// back to the default or the maximum, so the cap is always enforced server-side.
func searchLimit(limit int) int {
if limit <= 0 {
return protocol.SearchDefaultLimit
}
if limit > protocol.SearchMaxLimit {
return protocol.SearchMaxLimit
}
return limit
}
// searchTerms is the parsed query. Text carries free text; Status and the
// From/To window carry a bare status word or a date expression that selects runs.
type searchTerms struct {
Browse bool
Limit int
Text string
Status string
HasDate bool
From time.Time
To time.Time
}
// parseSearchTerms recognises a lone status word and a lone date expression and
// leaves everything else as free text, so ordinary words are never misread as a
// selector. Relative dates resolve against the injected now in its own location;
// the comparison window is converted to UTC to match the stored timestamps.
func parseSearchTerms(query string, now time.Time) searchTerms {
trimmed := strings.TrimSpace(query)
lower := strings.ToLower(trimmed)
for _, status := range protocol.SearchStatuses {
if lower == status {
return searchTerms{Status: status}
}
}
location := now.Location()
day := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location)
switch lower {
case "today":
return dateTerms(day, day.AddDate(0, 0, 1))
case "yesterday":
return dateTerms(day.AddDate(0, 0, -1), day)
case "this week":
// Monday 00:00 local is the start of the week.
start := day.AddDate(0, 0, -((int(day.Weekday()) + 6) % 7))
return dateTerms(start, start.AddDate(0, 0, 7))
}
if parsed, err := time.ParseInLocation("2006-01-02", trimmed, location); err == nil {
return dateTerms(parsed, parsed.AddDate(0, 0, 1))
}
return searchTerms{Text: trimmed}
}
func dateTerms(from, to time.Time) searchTerms {
return searchTerms{HasDate: true, From: from.UTC(), To: to.UTC()}
}
const searchSQLTime = "2006-01-02 15:04:05"
// searchStepJoin is the shared run_steps/step_control source and projections the
// step and field scans build on, so those queries cannot drift apart.
const (
searchStepJoin = `FROM run_steps s LEFT JOIN step_control c ON c.run_id=s.run_id AND c.sequence=s.sequence`
searchStepEvidence = `COALESCE(c.evidence_json,'')`
searchStepRecency = `COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',s.started_at),'')`
)
// searchRowBudget bounds how many raw rows one non-body kind scans before it
// stops and reports Truncated, so a LIKE scan over a very large table cannot
// scale without limit. Field text uses the separate SearchMaxScanSteps budget.
const searchRowBudget = 2000
func searchCandidateLimit(terms searchTerms) int {
if terms.Browse {
return searchLimit(terms.Limit) + 1
}
return searchRowBudget + 1
}
// searchLike builds a case-insensitive substring pattern, escaping LIKE
// metacharacters so a query can never broaden the pattern.
func searchLike(text string) string {
escaped := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(strings.ToLower(text))
return "%" + escaped + "%"
}
// searchTier ranks a "name" match: exact beats a substring. The third tier (a
// body-text match) is assigned by the caller.
func searchTier(value, text string) (int, bool) {
if text == "" {
return 0, false
}
if strings.EqualFold(value, text) {
return 3, true
}
if strings.Contains(strings.ToLower(value), strings.ToLower(text)) {
return 2, true
}
return 0, false
}
func searchContains(value, text string) bool {
return text != "" && strings.Contains(strings.ToLower(value), strings.ToLower(text))
}
// sortRecentSearchResults orders hits newest first by Recency, for a text
// search and a browse alike. Numeric entity IDs, then visit/version IDs, break
// equal timestamps deterministically (not lexical "run:9" vs "run:10").
func sortRecentSearchResults(results []protocol.SearchResult) {
identity := func(hit protocol.SearchResult) (int64, int) {
switch {
case hit.Pipeline != nil:
return hit.Pipeline.ID, hit.Pipeline.Version
case hit.Version != nil:
return hit.Version.PipelineID, hit.Version.Version
case hit.Run != nil:
return hit.Run.ID, 0
case hit.Step != nil:
return hit.Step.RunID, hit.Step.Sequence
case hit.Field != nil:
return hit.Field.RunID, hit.Field.Sequence
case hit.Artifact != nil:
return hit.Artifact.RunID, hit.Artifact.Sequence
}
return 0, 0
}
sort.SliceStable(results, func(i, j int) bool {
a, b := results[i], results[j]
if a.Recency != b.Recency {
return a.Recency > b.Recency
}
ai, as := identity(a)
bi, bs := identity(b)
if ai != bi {
return ai > bi
}
if as != bs {
return as > bs
}
return a.Target < b.Target
})
}
func searchPipelines(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
if terms.Text == "" && !terms.Browse {
return nil, nil
}
query := `SELECT p.id,p.name,v.version,json_array_length(v.graph_json,'$.stages'),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',v.created_at),'')
FROM pipelines p JOIN pipeline_versions v ON v.pipeline_id=p.id
WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=p.id)`
var args []any
if terms.Browse {
query += " ORDER BY v.created_at DESC,v.pipeline_id DESC,v.version DESC LIMIT ?"
} else {
query += ` AND lower(p.name) LIKE ? ESCAPE '\' ORDER BY v.created_at DESC,v.pipeline_id DESC LIMIT ?`
args = append(args, searchLike(terms.Text))
}
args = append(args, searchCandidateLimit(terms))
rows, err := tx.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var results []protocol.SearchResult
scanned := 0
for rows.Next() {
if scanned == searchRowBudget {
scan.truncated = true
break
}
scanned++
var id int64
var name, recency string
var version, stages int
if err := rows.Scan(&id, &name, &version, &stages, &recency); err != nil {
return nil, err
}
score, ok := searchTier(name, terms.Text)
if terms.Browse {
score, ok = 0, true
}
if !ok {
continue
}
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindPipeline, Target: searchPipelineTarget(id),
Score: score, MatchedField: "name", Recency: recency,
Pipeline: &protocol.SearchPipeline{ID: id, Name: name, Version: version, Stages: stages},
})
}
return results, rows.Err()
}
func searchVersions(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
if terms.Text == "" && !terms.Browse {
return nil, nil
}
source := "v.source"
if terms.Browse {
source = "''" // Browsing needs metadata only, never retained source text.
}
query := `SELECT v.pipeline_id,v.version,v.content_hash,COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',v.created_at),''),` + source + `
FROM pipeline_versions v`
var args []any
if !terms.Browse {
query += ` WHERE lower(v.source) LIKE ? ESCAPE '\'`
args = append(args, searchLike(terms.Text))
}
var wanted int64
numeric := false
if n, err := parsePositiveInt(terms.Text); err == nil {
query += " OR v.version=?"
args = append(args, n)
wanted, numeric = n, true
}
query += " ORDER BY v.created_at DESC,v.pipeline_id DESC,v.version DESC LIMIT ?"
args = append(args, searchCandidateLimit(terms))
rows, err := tx.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var results []protocol.SearchResult
scanned := 0
for rows.Next() {
if scanned == searchRowBudget {
scan.truncated = true
break
}
scanned++
var pipelineID int64
var version int
var hash, recency, source string
if err := rows.Scan(&pipelineID, &version, &hash, &recency, &source); err != nil {
return nil, err
}
score, matched := 1, "source"
if terms.Browse {
score, matched = 0, ""
} else if numeric && int64(version) == wanted {
score, matched = 3, "version"
} else if !searchContains(source, terms.Text) {
continue
}
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindVersion, Target: searchVersionTarget(pipelineID, version),
Score: score, MatchedField: matched, Recency: recency,
Version: &protocol.SearchVersion{PipelineID: pipelineID, Version: version, ContentHash: hash, CreatedAt: recency},
})
}
return results, rows.Err()
}
func searchRuns(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
// Reuse runSelect's join and timestamp projection rather than restating the
// run-row SELECT; only the fields search needs are added.
base := `SELECT r.id,p.name,r.status,r.workspace,` + runStamps + `,r.diagnostic ` + runFrom
var query string
var args []any
switch {
case terms.Browse:
query = base
case terms.Status != "":
query = base + " WHERE r.status=?"
args = append(args, terms.Status)
case terms.HasDate:
query = base + " WHERE r.created_at>=? AND r.created_at<?"
args = append(args, terms.From.Format(searchSQLTime), terms.To.Format(searchSQLTime))
default:
query = base + ` WHERE lower(p.name) LIKE ? ESCAPE '\' OR lower(r.workspace) LIKE ? ESCAPE '\' OR lower(r.status) LIKE ? ESCAPE '\' OR lower(r.diagnostic) LIKE ? ESCAPE '\' OR CAST(r.id AS TEXT)=?`
pattern := searchLike(terms.Text)
args = append(args, pattern, pattern, pattern, pattern, terms.Text)
}
query += " ORDER BY r.created_at DESC,r.id DESC LIMIT ?"
args = append(args, searchCandidateLimit(terms))
rows, err := tx.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var results []protocol.SearchResult
scanned := 0
for rows.Next() {
if scanned == searchRowBudget {
scan.truncated = true
break
}
scanned++
var id int64
var name, status, workspace, created, finished, diagnostic string
if err := rows.Scan(&id, &name, &status, &workspace, &created, &finished, &diagnostic); err != nil {
return nil, err
}
score, matched := 1, "status"
if terms.Browse {
score, matched = 0, ""
} else if terms.Status != "" {
matched = "status"
} else if terms.HasDate {
matched = "created_at"
} else if s, ok := searchTier(name, terms.Text); ok {
score, matched = s, "pipeline_name"
} else if numericEqual(terms.Text, id) {
score, matched = 3, "id"
} else if searchContains(workspace, terms.Text) {
matched = "workspace"
} else if searchContains(status, terms.Text) {
matched = "status"
} else if searchContains(diagnostic, terms.Text) {
matched = "diagnostic"
} else {
continue
}
run := &protocol.SearchRun{ID: id, PipelineName: name, Status: status, Workspace: workspace, CreatedAt: created, FinishedAt: finished}
if created != "" && finished != "" {
if secs, ok := durationSeconds(created, finished); ok {
run.DurationSeconds = secs
}
}
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindRun, Target: searchRunTarget(id),
Score: score, MatchedField: matched, Recency: created, Run: run,
})
}
return results, rows.Err()
}
func searchSteps(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
if terms.Text == "" && !terms.Browse {
return nil, nil
}
query := `SELECT s.run_id,s.sequence,s.stage_key,s.outcome,s.target,s.diagnostic,` + searchStepRecency + `,` + searchStepEvidence + ` ` + searchStepJoin
var args []any
if terms.Browse {
query += " ORDER BY s.started_at DESC,s.run_id DESC,s.sequence DESC LIMIT ?"
} else {
query += ` WHERE lower(s.stage_key) LIKE ? ESCAPE '\' OR lower(s.outcome) LIKE ? ESCAPE '\' OR lower(s.target) LIKE ? ESCAPE '\' OR lower(s.diagnostic) LIKE ? ESCAPE '\' ORDER BY s.started_at DESC,s.run_id DESC,s.sequence DESC LIMIT ?`
pattern := searchLike(terms.Text)
args = append(args, pattern, pattern, pattern, pattern)
}
args = append(args, searchCandidateLimit(terms))
rows, err := tx.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var results []protocol.SearchResult
scanned := 0
for rows.Next() {
if scanned == searchRowBudget {
scan.truncated = true
break
}
scanned++
var runID int64
var sequence int
var stage, outcome, target, diagnostic, recency, control string
if err := rows.Scan(&runID, &sequence, &stage, &outcome, &target, &diagnostic, &recency, &control); err != nil {
return nil, err
}
score, matched := 1, "diagnostic"
if terms.Browse {
score, matched = 0, ""
} else if s, ok := searchTier(stage, terms.Text); ok {
score, matched = s, "stage"
} else if searchContains(outcome, terms.Text) {
matched = "outcome"
} else if searchContains(target, terms.Text) {
matched = "target"
} else if searchContains(diagnostic, terms.Text) {
matched = "diagnostic"
} else {
continue
}
visit := 0
if control != "" && control != "null" {
var evidence protocol.ControlEvidence
if err := json.Unmarshal([]byte(control), &evidence); err == nil {
visit = evidence.Visit
}
}
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindStep, Target: searchStepTarget(runID, sequence),
Score: score, MatchedField: matched, Recency: recency,
Step: &protocol.SearchStep{RunID: runID, Sequence: sequence, Stage: stage, Visit: visit, Outcome: outcome, Target: target, Diagnostic: diagnostic},
})
}
return results, rows.Err()
}
// searchScan accumulates the shared bounded-scan budget so the response can
// report how much body text was inspected and whether any bound was reached.
type searchScan struct {
steps int
bytes int
truncated bool
}
func searchFields(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
if terms.Text == "" && !terms.Browse {
return nil, nil
}
// One extra step is requested so a scan that hits the step bound can see that
// more rows remain and report Truncated rather than ending silently.
query := `SELECT s.run_id,s.sequence,s.input_json,s.output_json,s.transcript,` + searchStepEvidence + `,` + searchStepRecency + ` ` + searchStepJoin
query += " ORDER BY s.started_at DESC,s.run_id DESC,s.sequence DESC LIMIT ?"
rows, err := tx.QueryContext(ctx, query, protocol.SearchMaxScanSteps+1)
if err != nil {
return nil, err
}
defer rows.Close()
var results []protocol.SearchResult
for rows.Next() {
if scan.steps >= protocol.SearchMaxScanSteps {
scan.truncated = true
break
}
var runID int64
var sequence int
var input, output, transcript, evidence, recency string
if err := rows.Scan(&runID, &sequence, &input, &output, &transcript, &evidence, &recency); err != nil {
return nil, err
}
size := len(input) + len(output) + len(transcript) + len(evidence)
if scan.bytes+size > protocol.SearchMaxScanBytes {
scan.truncated = true
break
}
scan.bytes += size
scan.steps++
for _, field := range []struct {
name string
raw string
}{
{name: "input", raw: input},
{name: "output", raw: output},
{name: "evidence", raw: evidence},
} {
if field.raw == "" {
continue
}
var values map[string]any
// A malformed retained row cannot match anything, so it is skipped
// rather than failing the whole query and hiding every other hit.
if err := decodeValues(field.raw, &values); err != nil {
continue
}
text, ok := findMatch(values, terms.Text)
if !ok {
continue
}
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindField, Target: searchFieldTarget(runID, sequence, field.name),
Score: 1, MatchedField: field.name, Recency: recency,
Field: &protocol.SearchField{RunID: runID, Sequence: sequence, Field: field.name, Snippet: searchSnippet(text, terms.Text)},
})
}
if searchContains(transcript, terms.Text) || (terms.Browse && transcript != "") {
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindField, Target: searchFieldTarget(runID, sequence, "transcript"),
Score: 1, MatchedField: "transcript", Recency: recency,
Field: &protocol.SearchField{RunID: runID, Sequence: sequence, Field: "transcript", Snippet: searchSnippet(transcript, terms.Text)},
})
}
}
return results, rows.Err()
}
func searchArtifacts(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
if terms.Text == "" && !terms.Browse {
return nil, nil
}
query := `SELECT a.run_id,a.sequence,a.artifacts_json,COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',r.created_at),'')
FROM step_artifacts a JOIN pipeline_runs r ON r.id=a.run_id`
var args []any
if terms.Browse {
query = `SELECT a.run_id,a.sequence,a.artifacts_json,COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',r.created_at),'')
FROM pipeline_runs r CROSS JOIN step_artifacts a ON a.run_id=r.id
ORDER BY r.created_at DESC,r.id DESC,a.sequence DESC LIMIT ?`
} else {
query += ` WHERE lower(a.artifacts_json) LIKE ? ESCAPE '\' ORDER BY r.created_at DESC,r.id DESC,a.sequence DESC LIMIT ?`
args = append(args, searchLike(terms.Text))
}
// Metadata rows can contain several artifacts or malformed retained JSON.
args = append(args, searchRowBudget+1)
rows, err := tx.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var results []protocol.SearchResult
scanned := 0
for rows.Next() {
if scanned == searchRowBudget {
scan.truncated = true
break
}
scanned++
var runID int64
var sequence int
var artifacts, recency string
if err := rows.Scan(&runID, &sequence, &artifacts, &recency); err != nil {
return nil, err
}
var evidence stageArtifactsEvidence
// A malformed retained row cannot match anything, so it is skipped
// rather than failing the whole query and hiding every other hit.
if err := json.Unmarshal([]byte(artifacts), &evidence); err != nil {
continue
}
for _, file := range evidence.Files {
score, matched := 1, "content_type"
if terms.Browse {
score, matched = 0, ""
} else if s, ok := searchTier(file.Name, terms.Text); ok {
score, matched = s, "name"
} else if !searchContains(file.ContentType, terms.Text) {
continue
}
results = append(results, protocol.SearchResult{
Kind: protocol.SearchKindArtifact, Target: file.URL,
Score: score, MatchedField: matched, Recency: recency,
Artifact: &protocol.SearchArtifact{RunID: runID, Sequence: sequence, Name: file.Name, ContentType: file.ContentType, SizeBytes: file.SizeBytes, URL: file.URL},
})
}
}
return results, rows.Err()
}
// findMatch walks decoded JSON values in a stable key order and returns the
// first string leaf containing the query, so a hit and its snippet are
// deterministic rather than map-iteration dependent.
func findMatch(value any, text string) (string, bool) {
switch typed := value.(type) {
case string:
if searchContains(typed, text) || (text == "" && typed != "") {
return typed, true
}
case map[string]any:
keys := make([]string, 0, len(typed))
for key := range typed {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
if match, ok := findMatch(typed[key], text); ok {
return match, true
}
}
case []any:
for _, item := range typed {
if match, ok := findMatch(item, text); ok {
return match, true
}
}
}
return "", false
}
// searchSnippet is the shared protocol snippet window.
func searchSnippet(text, query string) string { return protocol.SearchSnippet(text, query) }
func searchPipelineTarget(id int64) string { return fmt.Sprintf("pipeline:%d", id) }
func searchVersionTarget(id int64, version int) string {
return fmt.Sprintf("pipeline:%d:v%d", id, version)
}
func searchRunTarget(id int64) string { return fmt.Sprintf("run:%d", id) }
func searchStepTarget(id int64, sequence int) string { return fmt.Sprintf("run:%d:%d", id, sequence) }
func searchFieldTarget(id int64, sequence int, field string) string {
return fmt.Sprintf("run:%d:%d:%s", id, sequence, field)
}
func parsePositiveInt(text string) (int64, error) {
n, err := strconv.ParseInt(strings.TrimSpace(text), 10, 64)
if err != nil || n <= 0 {
return 0, fmt.Errorf("not a positive integer")
}
return n, nil
}
func numericEqual(text string, id int64) bool {
n, err := parsePositiveInt(text)
return err == nil && n == id
}
func durationSeconds(created, finished string) (float64, bool) {
start, err := time.Parse(time.RFC3339, created)
if err != nil {
return 0, false
}
end, err := time.Parse(time.RFC3339, finished)
if err != nil {
return 0, false
}
if end.Before(start) {
return 0, false
}
return end.Sub(start).Seconds(), true
}