models

Documentation

Index

• Constants
• Variables
• func GenerateETagForJob(updatedJob Job) (eTag string, err error)
• func ParseTaskName(taskName string, taskNames map[string]bool) error
• type Job
  • func NewJob(id string) (Job, error)
• type JobLinks
• type Jobs
• type ReindexRequested
• type Task
  • func NewTask(jobID, taskName string, numDocuments int, bindAddress string) Task
• type TaskLinks
• type TaskToCreate
  • func (task TaskToCreate) Validate(taskNames map[string]bool) error
• type Tasks

Constants

const (
	JobNoOfTasksPath            = "/number_of_tasks"
	JobStatePath                = "/state"
	JobTotalSearchDocumentsPath = "/total_search_documents"
)

Paths of fields in a job resource

const (
	JobETagBSONKey                 = "e_tag"
	JobLastUpdatedBSONKey          = "last_updated"
	JobReindexStartedBSONKey       = "reindex_started"
	JobReindexCompletedBSONKey     = "reindex_completed"
	JobReindexFailedBSONKey        = "reindex_failed"
	JobNoOfTasksBSONKey            = "number_of_tasks"
	JobStateBSONKey                = "state"
	JobTotalSearchDocumentsBSONKey = "total_search_documents"
)

BSON keys for each field in the job resource so that there is a source of truth

const (
	JobStateCreated    = "created" // this is the default value of state in a new job
	JobStateCompleted  = "completed"
	JobStateFailed     = "failed"
	JobStateInProgress = "in-progress"
)

JOB STATE - Possible values of a job's state

Variables

var (
	// ValidJobStates is used for logging available job states
	ValidJobStates = []string{
		JobStateCreated,
		JobStateCompleted,
		JobStateFailed,
		JobStateInProgress,
	}

	// ValidJobStatesMap is used for searching available job states
	ValidJobStatesMap = map[string]bool{
		JobStateCreated:    true,
		JobStateCompleted:  true,
		JobStateFailed:     true,
		JobStateInProgress: true,
	}
)

var (
	// ValidPatchOps is used for logging available patch operations
	ValidPatchOps = []string{
		dprequest.OpReplace.String(),
	}

	// ValidPatchOpsMap is used for searching available patch operations
	ValidPatchOpsMap = map[string]bool{
		dprequest.OpReplace.String(): true,
	}
)

PATCH-OPERATIONS - Possible patch operations available in search-reindex-api

Functions

func GenerateETagForJob

func GenerateETagForJob(updatedJob Job) (eTag string, err error)

GenerateETagForJob generates a new eTag for a job resource

func ParseTaskName

func ParseTaskName(taskName string, taskNames map[string]bool) error

ParseTaskName returns ErrTaskInvalidName if it cannot find a valid task name matching the given taskName string

Types

type Job

type Job struct {
	ETag                         string    `bson:"e_tag"                            json:"e_tag"`
	ID                           string    `bson:"_id"                              json:"id"`
	LastUpdated                  time.Time `bson:"last_updated"                     json:"last_updated"`
	Links                        *JobLinks `bson:"links"                            json:"links"`
	NumberOfTasks                int       `bson:"number_of_tasks"                  json:"number_of_tasks"`
	ReindexCompleted             time.Time `bson:"reindex_completed"                json:"reindex_completed"`
	ReindexFailed                time.Time `bson:"reindex_failed"                   json:"reindex_failed"`
	ReindexStarted               time.Time `bson:"reindex_started"                  json:"reindex_started"`
	SearchIndexName              string    `bson:"search_index_name"                json:"search_index_name"`
	State                        string    `bson:"state"                            json:"state"`
	TotalSearchDocuments         int       `bson:"total_search_documents"           json:"total_search_documents"`
	TotalInsertedSearchDocuments int       `bson:"total_inserted_search_documents"  json:"total_inserted_search_documents"`
}

Job represents a job metadata model and json representation for API

func NewJob

func NewJob(id string) (Job, error)

NewJob returns a new Job resource that it creates and populates with default values.

type JobLinks

type JobLinks struct {
	Tasks string `json:"tasks"`
	Self  string `json:"self"`
}

JobLinks is a type that contains links to the endpoints for returning a specific job (self), and the tasks that it contains (tasks), respectively.

type Jobs

type Jobs struct {
	Count      int   `bson:"count,omitempty"        json:"count"`
	JobList    []Job `bson:"jobs,omitempty"         json:"jobs"`
	Limit      int   `bson:"limit,omitempty"        json:"limit"`
	Offset     int   `bson:"offset,omitempty"       json:"offset"`
	TotalCount int   `bson:"total_count,omitempty"  json:"total_count"`
}

Jobs represents an array of Job resources and json representation for API

type ReindexRequested

type ReindexRequested struct {
	JobID       string `avro:"job_id"`
	SearchIndex string `avro:"search_index"`
	TraceID     string `avro:"trace_id"`
}

ReindexRequested provides an avro structure for a Reindex Requested event

type Task

type Task struct {
	JobID             string     `bson:"job_id" json:"job_id"`
	LastUpdated       time.Time  `bson:"last_updated" json:"last_updated"`
	Links             *TaskLinks `bson:"links" json:"links"`
	NumberOfDocuments int        `bson:"number_of_documents" json:"number_of_documents"`
	TaskName          string     `bson:"task_name" json:"task_name"`
}

Task represents a job metadata model and json representation for API

func NewTask

func NewTask(jobID, taskName string, numDocuments int, bindAddress string) Task

NewTask returns a new Task resource that it creates and populates with default values.

type TaskLinks

type TaskLinks struct {
	Self string `json:"self"`
	Job  string `json:"job"`
}

TaskLinks is a type that contains links to the endpoints for returning a specific task (self), and the job that it is part of (job), respectively.

type TaskToCreate

type TaskToCreate struct {
	TaskName          string `json:"task_name"`
	NumberOfDocuments int    `json:"number_of_documents"`
}

TaskToCreate is a type that contains the details required for creating a Task type.

func (TaskToCreate) Validate

func (task TaskToCreate) Validate(taskNames map[string]bool) error

Validate checks that the TaskToCreate contains a valid TaskName that is not an empty string.

type Tasks

type Tasks struct {
	Count      int    `bson:"count,omitempty"        json:"count"`
	TaskList   []Task `bson:"jobs,omitempty"         json:"tasks"`
	Limit      int    `bson:"limit,omitempty"        json:"limit"`
	Offset     int    `bson:"offset,omitempty"       json:"offset"`
	TotalCount int    `bson:"total_count,omitempty"  json:"total_count"`
}

Tasks represents an array of Task resources and json representation for API