patcher

type Averager struct {
	// contains filtered or unexported fields
}

type BasicFileInfo struct {
	// When the file was last modified.
	ModTime time.Time
}

type DeterminedActions struct {
	// Which patch files to download.
	ToDownload []DownloadInstr
	// Which game files to install/update.
	ToUpdate []UpdateInstr
	// Which game files to delete.
	ToDelete []string
}

type DownloadConfig struct {
	// Maximum number of attempts.
	MaxAttempts int

	// Minimum time between retries.
	RetryBaseDelay time.Duration

	// How much to increment the delay between retries (factor, so 2 = double every retry).
	RetryWaitIncrementFactor float64

	// How many seconds to average the download speed over.
	DownloadSpeedWindow int

	// How much time to allow to send a request and receive the start of a response.
	DownloadRequestTimeout time.Duration

	// How much time to allow between receiving any data in a download.
	DownloadStallTimeout time.Duration
}

type DownloadInstr struct {
	// Location of the patch file relative to the directory containing instructions.json.
	RemotePath string

	// Filename for the patch file on disk.
	LocalPath string

	// Checksum the patch file should have.
	Checksum string

	// Size of the patch file in bytes.
	Size int64
}

type DownloadStats struct {
	// Running average of download speed in bytes/second.
	Speed int64

	// Total number of bytes downloaded.
	TotalBytes int64
}

type Downloader struct {
	// contains filtered or unexported fields
}

type Instruction struct {
	// Path relative to install dir.  This is backslash encoded in the JSON but
	// DecodeInstructions will transform backslashes to slashes.
	Path string
	// For a delta patch the hash that the existing file should have.
	OldHash string
	// The hash the file should have after patching. If nil the file should be deleted.
	NewHash *string
	// The hash of the full (not delta) patch file.
	CompressedHash *string
	// If a delta patch exists the hash of the delta patch file.
	DeltaHash *string
	// Size of the file. May be 0 as this is a new field and instructions.json might not have it yet.
	FileSize int64 `json:"FileSize"`
	// Size in bytes of the full patch file.
	FullReplaceSize int64
	// Size in bytes of the delta patch file. Zero if there is no delta patch file.
	DeltaSize int64
}

type Manifest struct {
	// Identifier for whatever game is installed, something like "renx_alpha".
	Product string
	Entries map[string]ManifestEntry
}

type ManifestEntry struct {
	LastChange   time.Time `json:"last_change"`
	LastChecksum string    `json:"last_checksum"`
}

type PatcherConfig struct {
	// URL containing instructions.json
	BaseUrl *url.URL

	// Directory where the game should be installed.
	InstallDir string

	// Product name that should be stored in the manifest.
	Product string

	// How many concurrent workers in verify phase.
	VerifyWorkers int

	// How many concurrent workers in download phase.
	DownloadWorkers int

	// How many concurrent workers in apply phase.
	ApplyWorkers int

	// Configuration of the download system.
	DownloadConfig DownloadConfig

	// Where to find the xdelta binary. If just a basename without directory
	// will look in PATH and also in the current directory.
	XDeltaBinPath string

	// A function that gets called every few seconds with the current progress
	// until the context passed to RunPatcher is canceled.
	ProgressFunc func(Progress)

	// How often to call ProgressFunc.
	ProgressInterval time.Duration
}

type Phase int

type Progress struct {
	// Running average of download speed in bytes per second.
	DownloadSpeed int64 `json:"downloadSpeed"`

	// Total bytes downloaded.
	DownloadTotalBytes int64 `json:"downloadTotalBytes"`

	// Progress in the verify phase.
	Verify ProgressPhase `json:"verify"`

	// Progress in the download phase.
	Download ProgressPhase `json:"download"`

	// Progress in the apply phase.
	Apply ProgressPhase `json:"apply"`
}

type ProgressPhase struct {
	// How many items are being processed.
	Processing int `json:"processing"`
	// How many items have been successfully processed.
	Completed int `json:"completed"`
	// How many items have errored.
	Errors int `json:"errors"`
	// How many items should be processed.
	Needed int `json:"needed"`
	// Whether the Needed value is known. If this is false the Needed value
	// will be 0 but doesn't mean anything yet.
	NeededKnown bool `json:"needed_known"`
	// Whether the phase is completed.
	// In the case of completed == 0 the phase might be not started yet
	// or completed.
	Done bool `json:"done"`
	// How much time was spent in the stage at the last time progress was reported, in seconds.
	Duration int `json:"duration"`
	// contains filtered or unexported fields
}

type ProgressTracker struct {
	// contains filtered or unexported fields
}

type ResolvedInstructions struct {
	Instructions []Instruction
	BaseUrl      *url.URL
	VersionName  string
}

type UpdateInstr struct {
	// Filename for the patch file on disk.
	PatchPath string

	// Filename for the file to patch.
	FilePath string

	// Temporary filename for the new file.
	TempFilename string

	// Whether the patch should be applied as a delta patch.
	IsDelta bool

	// The final hash the file should have.
	Checksum string

	// The size the file is expected to have. It may be 0 if this is unknown.
	Size int64
}

type XDelta struct {
	// contains filtered or unexported fields
}