butlerd

package
v15.11.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 26, 2019 License: MIT Imports: 39 Imported by: 29

README

butlerd

butlerd (butler daemon) is a JSON-RPC 2.0 service over TCP that allows using butler for long-running tasks (called operations) or one-off requests.

Documentation

Comprehensive documentation is available at http://docs.itch.ovh/butlerd/master/

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var GameClassificationList = []interface{}{
	itchio.GameClassificationGame,
	itchio.GameClassificationTool,
	itchio.GameClassificationAssets,
	itchio.GameClassificationGameMod,
	itchio.GameClassificationPhysicalGame,
	itchio.GameClassificationSoundtrack,
	itchio.GameClassificationOther,
	itchio.GameClassificationComic,
	itchio.GameClassificationBook,
}

Functions

func FromDateTime 

func FromDateTime(s string) (time.Time, error)

func H 

func H(f CoolHandler) http.HandlerFunc

func HTTPError 

func HTTPError(code int, msg string, args ...interface{}) error

func NewStateConsumer 

func NewStateConsumer(params *NewStateConsumerParams) (*state.Consumer, error)

func ToDateTime 

func ToDateTime(t time.Time) string

Types

type AcceptLicenseParams 

type AcceptLicenseParams struct {
	// The full text of the license agreement, in its default
	// language, which is usually English.
	Text string `json:"text"`
}

Sent during @@LaunchParams if the game/application comes with a service license agreement (at the time of this writing, this only happens if it was installed from a DMG file).

@tags Dialogs @category Launch @caller server

func (AcceptLicenseParams) Validate 

func (p AcceptLicenseParams) Validate() error

type AcceptLicenseResult 

type AcceptLicenseResult struct {
	// true if the user accepts the terms of the license, false otherwise.
	// Note that false will cancel the launch.
	Accept bool `json:"accept"`
}

type Action 

type Action struct {
	// human-readable or standard name
	Name string `json:"name"`

	// file path (relative to manifest or absolute), URL, etc.
	Path string `json:"path"`

	// icon name (see static/fonts/icomoon/demo.html, don't include `icon-` prefix)
	Icon string `json:"icon,omitempty"`

	// command-line arguments
	Args []string `json:"args,omitempty"`

	// sandbox opt-in
	Sandbox bool `json:"sandbox,omitempty"`

	// requested API scope
	Scope string `json:"scope,omitempty"`

	// don't redirect stdout/stderr, open in new console window
	Console bool `json:"console,omitempty"`

	// platform to restrict this action too
	Platform ox.Platform `json:"platform,omitempty"`

	// localized action name
	Locales map[string]*ActionLocale `json:"locales,omitempty"`
}

An Action is a choice for the user to pick when launching a game.

see https://itch.io/docs/itch/integrating/manifest.html

type ActionLocale 

type ActionLocale struct {
	// A localized action name
	Name string `json:"name"`
}

type AllowSandboxSetupParams 

type AllowSandboxSetupParams struct{}

Ask the user to allow sandbox setup. Will be followed by a UAC prompt (on Windows) or a pkexec dialog (on Linux) if the user allows.

Sent during @@LaunchParams.

@category Launch @tags Dialogs @caller server

func (AllowSandboxSetupParams) Validate 

func (p AllowSandboxSetupParams) Validate() error

type AllowSandboxSetupResult 

type AllowSandboxSetupResult struct {
	// Set to true if user allowed the sandbox setup, false otherwise
	Allow bool `json:"allow"`
}

type BackgroundTask 

type BackgroundTask struct {
	Desc string
	Do   func(rc *RequestContext) error
}

type BackgroundTaskFunc 

type BackgroundTaskFunc func(rc *RequestContext) error

type BackgroundTaskID 

type BackgroundTaskID int64

type CancelFuncs 

type CancelFuncs struct {
	Funcs map[string]context.CancelFunc
}

func (*CancelFuncs) Add 

func (cf *CancelFuncs) Add(id string, f context.CancelFunc)

func (*CancelFuncs) Call 

func (cf *CancelFuncs) Call(id string) bool

func (*CancelFuncs) Remove 

func (cf *CancelFuncs) Remove(id string)

type Cave 

type Cave struct {
	ID string `json:"id"`

	Game   *itchio.Game   `json:"game"`
	Upload *itchio.Upload `json:"upload"`
	Build  *itchio.Build  `json:"build"`

	Stats       *CaveStats       `json:"stats"`
	InstallInfo *CaveInstallInfo `json:"installInfo"`
}

type CaveInstallInfo 

type CaveInstallInfo struct {
	InstalledSize   int64  `json:"installedSize"`
	InstallLocation string `json:"installLocation"`
	InstallFolder   string `json:"installFolder"`
	Pinned          bool   `json:"pinned,omitempty"`
}

type CaveStats 

type CaveStats struct {
	InstalledAt   *time.Time `json:"installedAt"`
	LastTouchedAt *time.Time `json:"lastTouchedAt"`
	SecondsRun    int64      `json:"secondsRun"`
}

type CaveSummary 

type CaveSummary struct {
	ID string `json:"id"`

	GameID int64 `json:"gameId"`

	LastTouchedAt *time.Time `json:"lastTouchedAt"`
	SecondsRun    int64      `json:"secondsRun"`
	InstalledSize int64      `json:"installedSize"`
}

type CavesFilters 

type CavesFilters struct {
	// @optional
	Classification itchio.GameClassification `json:"classification"`

	// @optional
	GameID int64 `json:"gameId"`

	// @optional
	InstallLocationID string `json:"installLocationId"`
}

func (CavesFilters) Validate 

func (p CavesFilters) Validate() error

type CavesSetPinnedParams 

type CavesSetPinnedParams struct {
	// ID of the cave to pin/unpin
	CaveID string `json:"caveId"`

	// Pinned state the cave should have after this call
	Pinned bool `json:"pinned"`
}

@name Caves.SetPinned @category Install @caller client

func (CavesSetPinnedParams) Validate 

func (p CavesSetPinnedParams) Validate() error

type CavesSetPinnedResult 

type CavesSetPinnedResult struct{}

type CheckUpdateParams 

type CheckUpdateParams struct {
	// If specified, will only look for updates to these caves
	// @optional
	CaveIDs []string `json:"caveIds"`

	// If specified, will log information even when we have no warnings/errors
	// @optional
	Verbose bool `json:"verbose"`
}

Looks for game updates.

If a list of cave identifiers is passed, will only look for updates for these caves *and will ignore snooze*.

Otherwise, will look for updates for all games, respecting snooze.

Updates found are regularly sent via @@GameUpdateAvailableNotification, and then all at once in the result.

@category Update @caller client

func (CheckUpdateParams) Validate 

func (p CheckUpdateParams) Validate() error

type CheckUpdateResult 

type CheckUpdateResult struct {
	// Any updates found (might be empty)
	Updates []*GameUpdate `json:"updates"`
	// Warnings messages logged while looking for updates
	Warnings []string `json:"warnings"`
}

type CleanDownloadsApplyParams 

type CleanDownloadsApplyParams struct {
	Entries []*CleanDownloadsEntry `json:"entries"`
}

Remove the specified entries from disk, freeing up disk space.

@name CleanDownloads.Apply @category Clean Downloads @caller client

func (CleanDownloadsApplyParams) Validate 

func (p CleanDownloadsApplyParams) Validate() error

type CleanDownloadsApplyResult 

type CleanDownloadsApplyResult struct{}

@category Clean Downloads

type CleanDownloadsEntry 

type CleanDownloadsEntry struct {
	// The complete path of the file or folder we intend to remove
	Path string `json:"path"`
	// The size of the folder or file, in bytes
	Size int64 `json:"size"`
}

@category Clean Downloads

type CleanDownloadsSearchParams 

type CleanDownloadsSearchParams struct {
	// A list of folders to scan for potential subfolders to clean up
	Roots []string `json:"roots"`
	// A list of subfolders to not consider when cleaning
	// (staging folders for in-progress downloads)
	Whitelist []string `json:"whitelist"`
}

Look for folders we can clean up in various download folders. This finds anything that doesn't correspond to any current downloads we know about.

@name CleanDownloads.Search @category Clean Downloads @caller client

func (CleanDownloadsSearchParams) Validate 

func (p CleanDownloadsSearchParams) Validate() error

type CleanDownloadsSearchResult 

type CleanDownloadsSearchResult struct {
	// Entries we found that could use some cleaning (with path and size information)
	Entries []*CleanDownloadsEntry `json:"entries"`
}

@category Clean Downloads

type Code 

type Code int64

butlerd JSON-RPC 2.0 error codes 

const (
	// An operation was cancelled gracefully
	CodeOperationCancelled Code = 499
	// An operation was aborted by the user
	CodeOperationAborted Code = 410

	// We tried to launch something, but the install folder just wasn't there
	CodeInstallFolderDisappeared Code = 404

	// We tried to install something, but could not find compatible uploads
	CodeNoCompatibleUploads Code = 2001

	// This title is packaged in a way that is not supported.
	CodeUnsupportedPackaging Code = 3000

	// This title is hosted on an incompatible third-party website
	CodeUnsupportedHost Code = 3001

	// Nothing that can be launched was found
	CodeNoLaunchCandidates Code = 5000

	// Java Runtime Environment is required to launch this title.
	CodeJavaRuntimeNeeded Code = 6000

	// There is no Internet connection
	CodeNetworkDisconnected Code = 9000

	// API error
	CodeAPIError Code = 12000

	// The database is busy
	CodeDatabaseBusy Code = 16000

	// An install location could not be removed because it has active downloads
	CodeCantRemoveLocationBecauseOfActiveDownloads Code = 18000
)

func (Code) Error 

func (code Code) Error() string

func (Code) RpcErrorCode 

func (code Code) RpcErrorCode() int64

func (Code) RpcErrorData 

func (code Code) RpcErrorData() map[string]interface{}

func (Code) RpcErrorMessage 

func (code Code) RpcErrorMessage() string

func (Code) String 

func (code Code) String() string

type CollectionGamesFilters 

type CollectionGamesFilters struct {
	Installed      bool                      `json:"installed"`
	Classification itchio.GameClassification `json:"classification"`
}

func (CollectionGamesFilters) Validate 

func (p CollectionGamesFilters) Validate() error

type Conn 

type Conn interface {
	Notify(ctx context.Context, method string, params interface{}) error
	Call(ctx context.Context, method string, params interface{}, result interface{}) error
}

type CoolHandler 

type CoolHandler func(w http.ResponseWriter, r *http.Request) error

type Cursor 

type Cursor string

type DiskUsageInfo 

type DiskUsageInfo struct {
	FinalDiskUsage  int64  `json:"finalDiskUsage"`
	NeededFreeSpace int64  `json:"neededFreeSpace"`
	Accuracy        string `json:"accuracy"`
}

type Download 

type Download struct {
	ID            string         `json:"id"`
	Error         *string        `json:"error"`
	ErrorMessage  *string        `json:"errorMessage"`
	ErrorCode     *int64         `json:"errorCode"`
	Reason        DownloadReason `json:"reason"`
	Position      int64          `json:"position"`
	CaveID        string         `json:"caveId"`
	Game          *itchio.Game   `json:"game"`
	Upload        *itchio.Upload `json:"upload"`
	Build         *itchio.Build  `json:"build"`
	StartedAt     *time.Time     `json:"startedAt"`
	FinishedAt    *time.Time     `json:"finishedAt"`
	StagingFolder string         `json:"stagingFolder"`
}

Represents a download queued, which will be performed whenever @@DownloadsDriveParams is called.

type DownloadKeySummary 

type DownloadKeySummary struct {
	// Site-wide unique identifier generated by itch.io
	ID int64 `json:"id"`

	// Identifier of the game to which this download key grants access
	GameID int64 `json:"gameId"`

	// Date this key was created at (often coincides with purchase time)
	CreatedAt *time.Time `json:"createdAt"`
}

type DownloadProgress 

type DownloadProgress struct {
	Stage    string  `json:"stage"`
	Progress float64 `json:"progress"`
	ETA      float64 `json:"eta"`
	BPS      float64 `json:"bps"`
}

type DownloadReason 

type DownloadReason string
const (
	DownloadReasonInstall       DownloadReason = "install"
	DownloadReasonReinstall     DownloadReason = "reinstall"
	DownloadReasonUpdate        DownloadReason = "update"
	DownloadReasonVersionSwitch DownloadReason = "version-switch"
)

type DownloadsClearFinishedParams 

type DownloadsClearFinishedParams struct {
}

Removes all finished downloads from the queue.

@name Downloads.ClearFinished @category Downloads @caller client

func (DownloadsClearFinishedParams) Validate 

func (p DownloadsClearFinishedParams) Validate() error

type DownloadsClearFinishedResult 

type DownloadsClearFinishedResult struct {
}

type DownloadsDiscardParams 

type DownloadsDiscardParams struct {
	DownloadID string `json:"downloadId"`
}

Attempts to discard a download

@name Downloads.Discard @category Downloads @caller client

func (DownloadsDiscardParams) Validate 

func (p DownloadsDiscardParams) Validate() error

type DownloadsDiscardResult 

type DownloadsDiscardResult struct{}

type DownloadsDriveCancelParams 

type DownloadsDriveCancelParams struct{}

Stop driving downloads gracefully.

@name Downloads.Drive.Cancel @category Downloads @caller client

func (DownloadsDriveCancelParams) Validate 

func (p DownloadsDriveCancelParams) Validate() error

type DownloadsDriveCancelResult 

type DownloadsDriveCancelResult struct {
	DidCancel bool `json:"didCancel"`
}

type DownloadsDriveDiscardedNotification 

type DownloadsDriveDiscardedNotification struct {
	Download *Download `json:"download"`
}

@name Downloads.Drive.Discarded

type DownloadsDriveErroredNotification 

type DownloadsDriveErroredNotification struct {
	// The download that errored. It contains all the error
	// information: a short message, a full stack trace,
	// and a butlerd error code.
	Download *Download `json:"download"`
}

@name Downloads.Drive.Errored

type DownloadsDriveFinishedNotification 

type DownloadsDriveFinishedNotification struct {
	Download *Download `json:"download"`
}

@name Downloads.Drive.Finished

type DownloadsDriveNetworkStatusNotification 

type DownloadsDriveNetworkStatusNotification struct {
	// The current network status
	Status NetworkStatus `json:"status"`
}

Sent during @@DownloadsDriveParams to inform on network status changes.

@name Downloads.Drive.NetworkStatus

type DownloadsDriveParams 

type DownloadsDriveParams struct{}

Drive downloads, which is: perform them one at a time, until they're all finished.

@name Downloads.Drive @category Downloads @caller client

func (DownloadsDriveParams) Validate 

func (p DownloadsDriveParams) Validate() error

type DownloadsDriveProgressNotification 

type DownloadsDriveProgressNotification struct {
	Download *Download         `json:"download"`
	Progress *DownloadProgress `json:"progress"`
	// BPS values for the last minute
	SpeedHistory []float64 `json:"speedHistory"`
}

@name Downloads.Drive.Progress

type DownloadsDriveResult 

type DownloadsDriveResult struct{}

type DownloadsDriveStartedNotification 

type DownloadsDriveStartedNotification struct {
	Download *Download `json:"download"`
}

@name Downloads.Drive.Started

type DownloadsListParams 

type DownloadsListParams struct {
}

List all known downloads.

@name Downloads.List @category Downloads @caller client

func (DownloadsListParams) Validate 

func (p DownloadsListParams) Validate() error

type DownloadsListResult 

type DownloadsListResult struct {
	Downloads []*Download `json:"downloads"`
}

type DownloadsPrioritizeParams 

type DownloadsPrioritizeParams struct {
	DownloadID string `json:"downloadId"`
}

Put a download on top of the queue.

@name Downloads.Prioritize @category Downloads @caller client

func (DownloadsPrioritizeParams) Validate 

func (p DownloadsPrioritizeParams) Validate() error

type DownloadsPrioritizeResult 

type DownloadsPrioritizeResult struct {
}

type DownloadsQueueParams 

type DownloadsQueueParams struct {
	Item *InstallQueueResult `json:"item"`
}

Queue a download that will be performed later by @@DownloadsDriveParams.

@name Downloads.Queue @category Downloads @caller client

func (DownloadsQueueParams) Validate 

func (p DownloadsQueueParams) Validate() error

type DownloadsQueueResult 

type DownloadsQueueResult struct {
}

type DownloadsRetryParams 

type DownloadsRetryParams struct {
	DownloadID string `json:"downloadId"`
}

Retries a download that has errored

@name Downloads.Retry @category Downloads @caller client

func (DownloadsRetryParams) Validate 

func (p DownloadsRetryParams) Validate() error

type DownloadsRetryResult 

type DownloadsRetryResult struct{}

type Error 

type Error interface {
	error
	RpcErrorCode() int64
	RpcErrorMessage() string
	RpcErrorData() map[string]interface{}
}

func AsButlerdError 

func AsButlerdError(err error) (Error, bool)

func StandardRpcError 

func StandardRpcError(Code int64) Error

type FetchCaveParams 

type FetchCaveParams struct {
	CaveID string `json:"caveId"`
}

Retrieve info on a cave by ID.

@name Fetch.Cave @category Fetch @caller client

func (FetchCaveParams) Validate 

func (p FetchCaveParams) Validate() error

type FetchCaveResult 

type FetchCaveResult struct {
	Cave *Cave `json:"cave"`
}

type FetchCavesParams 

type FetchCavesParams struct {
	// Maximum number of caves to return at a time.
	// @optional
	Limit int64 `json:"limit"`

	// When specified only shows game titles that contain this string
	// @optional
	Search string `json:"search"`

	// @optional
	SortBy string `json:"sortBy"`

	// Filters
	// @optional
	Filters CavesFilters `json:"filters"`

	// @optional
	Reverse bool `json:"reverse"`

	// Used for pagination, if specified
	// @optional
	Cursor Cursor `json:"cursor"`
}

Retrieve info for all caves.

@name Fetch.Caves @category Fetch @caller client

func (FetchCavesParams) GetCursor 

func (p FetchCavesParams) GetCursor() Cursor

func (FetchCavesParams) GetLimit 

func (p FetchCavesParams) GetLimit() int64

func (FetchCavesParams) Validate 

func (p FetchCavesParams) Validate() error

type FetchCavesResult 

type FetchCavesResult struct {
	Items []*Cave `json:"items"`

	// Use to fetch the next 'page' of results
	// @optional
	NextCursor Cursor `json:"nextCursor,omitempty"`
}

type FetchCollectionGamesParams 

type FetchCollectionGamesParams struct {
	// Profile to use to fetch collection
	ProfileID int64 `json:"profileId"`

	// Identifier of the collection to look for
	CollectionID int64 `json:"collectionId"`

	// Maximum number of games to return at a time.
	// @optional
	Limit int64 `json:"limit"`

	// When specified only shows game titles that contain this string
	// @optional
	Search string `json:"search"`

	// Criterion to sort by
	// @optional
	SortBy string `json:"sortBy"`

	// Filters
	// @optional
	Filters CollectionGamesFilters `json:"filters"`

	// @optional
	Reverse bool `json:"reverse"`

	// Used for pagination, if specified
	// @optional
	Cursor Cursor `json:"cursor"`

	// If set, will force fresh data
	// @optional
	Fresh bool `json:"fresh"`
}

Fetches information about a collection and the games it contains.

@name Fetch.Collection.Games @category Fetch @caller client

func (FetchCollectionGamesParams) GetCursor 

func (p FetchCollectionGamesParams) GetCursor() Cursor

func (FetchCollectionGamesParams) GetLimit 

func (p FetchCollectionGamesParams) GetLimit() int64

func (FetchCollectionGamesParams) IsFresh 

func (p FetchCollectionGamesParams) IsFresh() bool

func (FetchCollectionGamesParams) Validate 

func (p FetchCollectionGamesParams) Validate() error

type FetchCollectionGamesResult 

type FetchCollectionGamesResult struct {
	// Requested games for this collection
	Items []*itchio.CollectionGame `json:"items"`

	// Use to fetch the next 'page' of results
	// @optional
	NextCursor Cursor `json:"nextCursor,omitempty"`

	// If true, re-issue request with 'Fresh'
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchCollectionGamesResult) SetStale 

func (r *FetchCollectionGamesResult) SetStale(stale bool)

type FetchCollectionParams 

type FetchCollectionParams struct {
	// Profile to use to fetch collection
	ProfileID int64 `json:"profileId"`

	// Collection to fetch
	CollectionID int64 `json:"collectionId"`

	// Force an API request before replying.
	// Usually set after getting 'stale' in the response.
	// @optional
	Fresh bool `json:"fresh"`
}

Fetch a collection's title, gamesCount, etc. but not its games.

@name Fetch.Collection @category Fetch @caller client

func (FetchCollectionParams) IsFresh 

func (p FetchCollectionParams) IsFresh() bool

func (FetchCollectionParams) Validate 

func (p FetchCollectionParams) Validate() error

type FetchCollectionResult 

type FetchCollectionResult struct {
	// Collection info
	Collection *itchio.Collection `json:"collection"`

	// True if the info was from local DB and
	// it should be re-queried using "Fresh"
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchCollectionResult) SetStale 

func (r *FetchCollectionResult) SetStale(stale bool)

type FetchCommonsParams 

type FetchCommonsParams struct{}

@name Fetch.Commons @category Fetch @caller client

func (FetchCommonsParams) Validate 

func (p FetchCommonsParams) Validate() error

type FetchCommonsResult 

type FetchCommonsResult struct {
	DownloadKeys     []*DownloadKeySummary     `json:"downloadKeys"`
	Caves            []*CaveSummary            `json:"caves"`
	InstallLocations []*InstallLocationSummary `json:"installLocations"`
}

type FetchDownloadKeyParams 

type FetchDownloadKeyParams struct {
	DownloadKeyID int64 `json:"downloadKeyId"`

	ProfileID int64 `json:"profileId"`

	// Force an API request
	// @optional
	Fresh bool `json:"fresh"`
}

Fetches a download key

@name Fetch.DownloadKey @category Fetch @caller client

func (FetchDownloadKeyParams) IsFresh 

func (p FetchDownloadKeyParams) IsFresh() bool

func (FetchDownloadKeyParams) Validate 

func (p FetchDownloadKeyParams) Validate() error

type FetchDownloadKeyResult 

type FetchDownloadKeyResult struct {
	DownloadKey *itchio.DownloadKey `json:"downloadKey"`

	// Marks that a request should be issued afterwards with 'Fresh' set
	// @optional
	Stale bool `json:"stale,omitempty"`
}

type FetchExpireAllParams 

type FetchExpireAllParams struct{}

Mark all local data as stale.

@name Fetch.ExpireAll @category Fetch @caller client

func (FetchExpireAllParams) Validate 

func (p FetchExpireAllParams) Validate() error

type FetchExpireAllResult 

type FetchExpireAllResult struct{}

type FetchGameParams 

type FetchGameParams struct {
	// Identifier of game to look for
	GameID int64 `json:"gameId"`

	// Force an API request
	// @optional
	Fresh bool `json:"fresh"`
}

Fetches information for an itch.io game.

@name Fetch.Game @category Fetch @caller client

func (FetchGameParams) IsFresh 

func (p FetchGameParams) IsFresh() bool

func (FetchGameParams) Validate 

func (p FetchGameParams) Validate() error

type FetchGameResult 

type FetchGameResult struct {
	// Game info
	Game *itchio.Game `json:"game"`

	// Marks that a request should be issued afterwards with 'Fresh' set
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchGameResult) SetStale 

func (r *FetchGameResult) SetStale(stale bool)

type FetchGameUploadsParams 

type FetchGameUploadsParams struct {
	// Identifier of the game whose uploads we should look for
	GameID int64 `json:"gameId"`

	// Only returns compatible uploads
	OnlyCompatible bool `json:"compatible"`

	// Force an API request
	// @optional
	Fresh bool `json:"fresh"`
}

Fetches uploads for an itch.io game

@name Fetch.GameUploads @category Fetch @caller client

func (FetchGameUploadsParams) IsFresh 

func (p FetchGameUploadsParams) IsFresh() bool

func (FetchGameUploadsParams) Validate 

func (p FetchGameUploadsParams) Validate() error

type FetchGameUploadsResult 

type FetchGameUploadsResult struct {
	// List of uploads
	Uploads []*itchio.Upload `json:"uploads"`

	// Marks that a request should be issued
	// afterwards with 'Fresh' set
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchGameUploadsResult) SetStale 

func (r *FetchGameUploadsResult) SetStale(stale bool)

type FetchProfileCollectionsParams 

type FetchProfileCollectionsParams struct {
	// Profile for which to fetch collections
	ProfileID int64 `json:"profileId"`

	// Maximum number of collections to return at a time.
	// @optional
	Limit int64 `json:"limit"`

	// When specified only shows collection titles that contain this string
	// @optional
	Search string `json:"search"`

	// Criterion to sort by
	// @optional
	SortBy string `json:"sortBy"`

	// @optional
	Reverse bool `json:"reverse"`

	// Used for pagination, if specified
	// @optional
	Cursor Cursor `json:"cursor"`

	// If set, will force fresh data
	// @optional
	Fresh bool `json:"fresh"`
}

Lists collections for a profile. Does not contain games.

@name Fetch.ProfileCollections @category Fetch @caller client

func (FetchProfileCollectionsParams) GetCursor 

func (p FetchProfileCollectionsParams) GetCursor() Cursor

func (FetchProfileCollectionsParams) GetLimit 

func (p FetchProfileCollectionsParams) GetLimit() int64

func (FetchProfileCollectionsParams) IsFresh 

func (p FetchProfileCollectionsParams) IsFresh() bool

func (FetchProfileCollectionsParams) Validate 

func (p FetchProfileCollectionsParams) Validate() error

type FetchProfileCollectionsResult 

type FetchProfileCollectionsResult struct {
	// Collections belonging to the profile
	Items []*itchio.Collection `json:"items"`

	// Used to fetch the next page
	// @optional
	NextCursor Cursor `json:"nextCursor,omitempty"`

	// If true, re-issue request with "Fresh"
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchProfileCollectionsResult) SetStale 

func (r *FetchProfileCollectionsResult) SetStale(stale bool)

type FetchProfileGamesParams 

type FetchProfileGamesParams struct {
	// Profile for which to fetch games
	ProfileID int64 `json:"profileId"`

	// Maximum number of items to return at a time.
	// @optional
	Limit int64 `json:"limit"`

	// When specified only shows game titles that contain this string
	// @optional
	Search string `json:"search"`

	// Criterion to sort by
	// @optional
	SortBy string `json:"sortBy"`

	// Filters
	// @optional
	Filters ProfileGameFilters `json:"filters"`

	// @optional
	Reverse bool `json:"reverse"`

	// Used for pagination, if specified
	// @optional
	Cursor Cursor `json:"cursor"`

	// If set, will force fresh data
	// @optional
	Fresh bool `json:"fresh"`
}

@name Fetch.ProfileGames @category Fetch @caller client

func (FetchProfileGamesParams) GetCursor 

func (p FetchProfileGamesParams) GetCursor() Cursor

func (FetchProfileGamesParams) GetLimit 

func (p FetchProfileGamesParams) GetLimit() int64

func (FetchProfileGamesParams) IsFresh 

func (p FetchProfileGamesParams) IsFresh() bool

func (FetchProfileGamesParams) Validate 

func (p FetchProfileGamesParams) Validate() error

type FetchProfileGamesResult 

type FetchProfileGamesResult struct {
	// Profile games
	Items []*ProfileGame `json:"items"`

	// Used to fetch the next page
	// @optional
	NextCursor Cursor `json:"nextCursor,omitempty"`

	// If true, re-issue request with "Fresh"
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchProfileGamesResult) SetStale 

func (r *FetchProfileGamesResult) SetStale(stale bool)

type FetchProfileOwnedKeysParams 

type FetchProfileOwnedKeysParams struct {
	// Profile to use to fetch game
	ProfileID int64 `json:"profileId"`

	// Maximum number of collections to return at a time.
	// @optional
	Limit int64 `json:"limit"`

	// When specified only shows game titles that contain this string
	// @optional
	Search string `json:"search"`

	// Criterion to sort by
	// @optional
	SortBy string `json:"sortBy"`

	// Filters
	// @optional
	Filters ProfileOwnedKeysFilters `json:"filters"`

	// @optional
	Reverse bool `json:"reverse"`

	// Used for pagination, if specified
	// @optional
	Cursor Cursor `json:"cursor"`

	// If set, will force fresh data
	// @optional
	Fresh bool `json:"fresh"`
}

@name Fetch.ProfileOwnedKeys @category Fetch @caller client

func (FetchProfileOwnedKeysParams) GetCursor 

func (p FetchProfileOwnedKeysParams) GetCursor() Cursor

func (FetchProfileOwnedKeysParams) GetLimit 

func (p FetchProfileOwnedKeysParams) GetLimit() int64

func (FetchProfileOwnedKeysParams) IsFresh 

func (p FetchProfileOwnedKeysParams) IsFresh() bool

func (FetchProfileOwnedKeysParams) Validate 

func (p FetchProfileOwnedKeysParams) Validate() error

type FetchProfileOwnedKeysResult 

type FetchProfileOwnedKeysResult struct {
	// Download keys fetched for profile
	Items []*itchio.DownloadKey `json:"items"`

	// Used to fetch the next page
	// @optional
	NextCursor Cursor `json:"nextCursor,omitempty"`

	// If true, re-issue request with "Fresh"
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchProfileOwnedKeysResult) SetStale 

func (r *FetchProfileOwnedKeysResult) SetStale(stale bool)

type FetchSaleParams 

type FetchSaleParams struct {
	// Identifier of the game for which to look for a sale
	GameID int64 `json:"gameId"`
}

Fetches the best current *locally cached* sale for a given game.

@name Fetch.Sale @category Fetch @caller client

func (FetchSaleParams) Validate 

func (p FetchSaleParams) Validate() error

type FetchSaleResult 

type FetchSaleResult struct {
	// @optional
	Sale *itchio.Sale `json:"sale"`
}

type FetchUserParams 

type FetchUserParams struct {
	// Identifier of the user to look for
	UserID int64 `json:"userId"`

	// Profile to use to look upser
	ProfileID int64 `json:"profileId"`

	// Force an API request
	// @optional
	Fresh bool `json:"fresh"`
}

Fetches information for an itch.io user.

@name Fetch.User @category Fetch @caller client

func (FetchUserParams) IsFresh 

func (p FetchUserParams) IsFresh() bool

func (FetchUserParams) Validate 

func (p FetchUserParams) Validate() error

type FetchUserResult 

type FetchUserResult struct {
	// User info
	User *itchio.User `json:"user"`

	// Marks that a request should be issued
	// afterwards with 'Fresh' set
	// @optional
	Stale bool `json:"stale,omitempty"`
}

func (*FetchUserResult) SetStale 

func (r *FetchUserResult) SetStale(stale bool)

type GameCredentials 

type GameCredentials struct {
	// A valid itch.io API key
	APIKey string `json:"apiKey"`
	// A download key identifier, or 0 if no download key is available
	// @optional
	DownloadKey int64 `json:"downloadKey"`
}

GameCredentials contains all the credentials required to make API requests including the download key if any.

func (*GameCredentials) JustAPIKey 

func (gc *GameCredentials) JustAPIKey() *GameCredentials

type GameFindUploadsParams 

type GameFindUploadsParams struct {
	// Which game to find uploads for
	Game *itchio.Game `json:"game"`
}

Finds uploads compatible with the current runtime, for a given game.

@name Game.FindUploads @category Install @caller client

func (GameFindUploadsParams) Validate 

func (p GameFindUploadsParams) Validate() error

type GameFindUploadsResult 

type GameFindUploadsResult struct {
	// A list of uploads that were found to be compatible.
	Uploads []*itchio.Upload `json:"uploads"`
}

type GameUpdate 

type GameUpdate struct {
	// Cave we found an update for
	CaveID string `json:"caveId"`

	// Game we found an update for
	Game *itchio.Game `json:"game"`

	// True if this is a direct update, ie. we're on
	// a channel that still exists, and there's a new build
	// False if it's an indirect update, for example a new
	// upload that appeared after we installed, but we're
	// not sure if it's an upgrade or other additional content
	Direct bool `json:"direct"`

	// Available choice of updates
	Choices []*GameUpdateChoice `json:"choices"`
}

Describes an available update for a particular game install.

@category Update

type GameUpdateAvailableNotification 

type GameUpdateAvailableNotification struct {
	Update *GameUpdate `json:"update"`
}

Sent during @@CheckUpdateParams, every time butler finds an update for a game. Can be safely ignored if displaying updates as they are found is not a requirement for the client.

@category Update @tags Optional

type GameUpdateChoice 

type GameUpdateChoice struct {
	// Upload to be installed
	Upload *itchio.Upload `json:"upload"`
	// Build to be installed (may be nil)
	Build *itchio.Build `json:"build"`
	// How confident we are that this is the right upgrade
	Confidence float64 `json:"confidence"`
}

One possible upload/build choice to upgrade a cave

@category update

type GetClientFunc 

type GetClientFunc func(key string) *itchio.Client

type HTMLLaunchParams 

type HTMLLaunchParams struct {
	// Absolute path on disk to serve
	RootFolder string `json:"rootFolder"`
	// Path of index file, relative to root folder
	IndexPath string `json:"indexPath"`

	// Command-line arguments, to pass as `global.Itch.args`
	Args []string `json:"args"`
	// Environment variables, to pass as `global.Itch.env`
	Env map[string]string `json:"env"`
}

Ask the client to perform an HTML launch, ie. open an HTML5 game, ideally in an embedded browser.

Sent during @@LaunchParams.

@category Launch @caller server

func (HTMLLaunchParams) Validate 

func (p HTMLLaunchParams) Validate() error

type HTMLLaunchResult 

type HTMLLaunchResult struct {
}

type InFlightBackgroundTask 

type InFlightBackgroundTask struct {
	QueuedAt time.Time
	Desc     string
}

type InFlightRequest 

type InFlightRequest struct {
	DispatchedAt time.Time
	Desc         string
}

type InstallCancelParams 

type InstallCancelParams struct {
	// The UUID of the task to cancel, as passed to @@OperationStartParams
	ID string `json:"id"`
}

Attempt to gracefully cancel an ongoing operation.

@name Install.Cancel @category Install @caller client

func (InstallCancelParams) Validate 

func (p InstallCancelParams) Validate() error

type InstallCancelResult 

type InstallCancelResult struct {
	DidCancel bool `json:"didCancel"`
}

type InstallLocationSizeInfo 

type InstallLocationSizeInfo struct {
	// Number of bytes used by caves installed in this location
	InstalledSize int64 `json:"installedSize"`
	// Free space at this location (depends on the partition/disk on which
	// it is), or a negative value if we can't find it
	FreeSize int64 `json:"freeSize"`
	// Total space of this location (depends on the partition/disk on which
	// it is), or a negative value if we can't find it
	TotalSize int64 `json:"totalSize"`
}

type InstallLocationSummary 

type InstallLocationSummary struct {
	ID       string                   `json:"id"`
	Path     string                   `json:"path"`
	SizeInfo *InstallLocationSizeInfo `json:"sizeInfo,omitempty"`
}

type InstallLocationsAddParams 

type InstallLocationsAddParams struct {
	// identifier of the new install location.
	// if not specified, will be generated.
	// @optional
	ID string `json:"id"`

	// path of the new install location
	Path string `json:"path"`
}

@name Install.Locations.Add @category Install @caller client

func (InstallLocationsAddParams) Validate 

func (p InstallLocationsAddParams) Validate() error

type InstallLocationsAddResult 

type InstallLocationsAddResult struct {
	InstallLocation *InstallLocationSummary `json:"installLocation"`
}

type InstallLocationsGetByIDParams 

type InstallLocationsGetByIDParams struct {
	// identifier of the install location to remove
	ID string `json:"id"`
}

@name Install.Locations.GetByID @category Install @caller client

func (InstallLocationsGetByIDParams) Validate 

func (p InstallLocationsGetByIDParams) Validate() error

type InstallLocationsGetByIDResult 

type InstallLocationsGetByIDResult struct {
	InstallLocation *InstallLocationSummary `json:"installLocation"`
}

type InstallLocationsListParams 

type InstallLocationsListParams struct {
}

@name Install.Locations.List @category Install @caller client

func (InstallLocationsListParams) Validate 

func (p InstallLocationsListParams) Validate() error

type InstallLocationsListResult 

type InstallLocationsListResult struct {
	InstallLocations []*InstallLocationSummary `json:"installLocations"`
}

type InstallLocationsRemoveParams 

type InstallLocationsRemoveParams struct {
	// identifier of the install location to remove
	ID string `json:"id"`
}

@name Install.Locations.Remove @category Install @caller client

func (InstallLocationsRemoveParams) Validate 

func (p InstallLocationsRemoveParams) Validate() error

type InstallLocationsRemoveResult 

type InstallLocationsRemoveResult struct {
}

type InstallLocationsScanConfirmImportParams 

type InstallLocationsScanConfirmImportParams struct {
	// number of items that will be imported
	NumItems int64 `json:"numItems"`
}

Sent at the end of @@InstallLocationsScanParams

@name Install.Locations.Scan.ConfirmImport @category Install @caller server

func (InstallLocationsScanConfirmImportParams) Validate 

func (p InstallLocationsScanConfirmImportParams) Validate() error

type InstallLocationsScanConfirmImportResult 

type InstallLocationsScanConfirmImportResult struct {
	Confirm bool `json:"confirm"`
}

type InstallLocationsScanParams 

type InstallLocationsScanParams struct {
	// path to a legacy marketDB
	// @optional
	LegacyMarketPath string `json:"legacyMarketPath"`
}

@name Install.Locations.Scan @category Install @caller client

func (InstallLocationsScanParams) Validate 

func (p InstallLocationsScanParams) Validate() error

type InstallLocationsScanResult 

type InstallLocationsScanResult struct {
	NumFoundItems    int64 `json:"numFoundItems"`
	NumImportedItems int64 `json:"numImportedItems"`
}

type InstallLocationsScanYieldNotification 

type InstallLocationsScanYieldNotification struct {
	Game *itchio.Game `json:"game"`
}

Sent during @@InstallLocationsScanParams whenever a game is found.

@name Install.Locations.Scan.Yield @category Install

type InstallPerformParams 

type InstallPerformParams struct {
	// ID that can be later used in @@InstallCancelParams
	ID string `json:"id"`

	// The folder turned by @@InstallQueueParams
	StagingFolder string `json:"stagingFolder"`
}

Perform an install that was previously queued via @@InstallQueueParams.

Can be cancelled by passing the same `ID` to @@InstallCancelParams.

@name Install.Perform @category Install @tags Cancellable @caller client

func (InstallPerformParams) Validate 

func (p InstallPerformParams) Validate() error

type InstallPerformResult 

type InstallPerformResult struct{}

type InstallPlanInfo 

type InstallPlanInfo struct {
	Upload    *itchio.Upload `json:"upload"`
	Build     *itchio.Build  `json:"build"`
	Type      string         `json:"type"`
	DiskUsage *DiskUsageInfo `json:"diskUsage"`

	Error        string `json:"error,omitempty"`
	ErrorMessage string `json:"errorMessage,omitempty"`
	ErrorCode    int64  `json:"errorCode,omitempty"`
}

type InstallPlanParams 

type InstallPlanParams struct {
	// The ID of the game we're planning to install
	GameID int64 `json:"gameId"`

	// The download session ID to use for this install plan
	// @optional
	DownloadSessionID string `json:"downloadSessionId"`

	// @optional
	UploadID int64 `json:"uploadId"`
}

For modal-first install

@name Install.Plan @category Install @caller client

func (InstallPlanParams) Validate 

func (p InstallPlanParams) Validate() error

type InstallPlanResult 

type InstallPlanResult struct {
	Game    *itchio.Game     `json:"game"`
	Uploads []*itchio.Upload `json:"uploads"`

	Info *InstallPlanInfo `json:"info"`
}

type InstallQueueParams 

type InstallQueueParams struct {
	// ID of the cave to perform the install for.
	// If not specified, will create a new cave.
	// @optional
	CaveID string `json:"caveId"`

	// If unspecified, will default to 'install'
	// @optional
	Reason DownloadReason `json:"reason"`

	// If CaveID is not specified, ID of an install location
	// to install to.
	// @optional
	InstallLocationID string `json:"installLocationId"`

	// If set, InstallFolder can be set and no cave
	// record will be read or modified
	// @optional
	NoCave bool `json:"noCave"`

	// When NoCave is set, exactly where to install
	// @optional
	InstallFolder string `json:"installFolder"`

	// Which game to install.
	//
	// If unspecified and caveId is specified, the same game will be used.
	// @optional
	Game *itchio.Game `json:"game"`

	// Which upload to install.
	//
	// If unspecified and caveId is specified, the same upload will be used.
	// @optional
	Upload *itchio.Upload `json:"upload"`

	// Which build to install
	//
	// If unspecified and caveId is specified, the same build will be used.
	// @optional
	Build *itchio.Build `json:"build"`

	// If true, do not run windows installers, just extract
	// whatever to the install folder.
	// @optional
	IgnoreInstallers bool `json:"ignoreInstallers,omitempty"`

	// A folder that butler can use to store temporary files, like
	// partial downloads, checkpoint files, etc.
	// @optional
	StagingFolder string `json:"stagingFolder"`

	// If set, and the install operation is successfully disambiguated,
	// will queue it as a download for butler to drive.
	// See @@DownloadsDriveParams.
	// @optional
	QueueDownload bool `json:"queueDownload"`

	// Don't run install prepare (assume we can just run it at perform time)
	// @optional
	FastQueue bool `json:"fastQueue"`
}

Queues an install operation to be later performed via @@InstallPerformParams.

@name Install.Queue @category Install @caller client

func (InstallQueueParams) Validate 

func (p InstallQueueParams) Validate() error

type InstallQueueResult 

type InstallQueueResult struct {
	ID                string         `json:"id"`
	Reason            DownloadReason `json:"reason"`
	CaveID            string         `json:"caveId"`
	Game              *itchio.Game   `json:"game"`
	Upload            *itchio.Upload `json:"upload"`
	Build             *itchio.Build  `json:"build"`
	InstallFolder     string         `json:"installFolder"`
	StagingFolder     string         `json:"stagingFolder"`
	InstallLocationID string         `json:"installLocationId"`
}

type InstallResult 

type InstallResult struct {
	// The game we installed
	Game *itchio.Game `json:"game"`
	// The upload we installed
	Upload *itchio.Upload `json:"upload"`
	// The build we installed
	// @optional
	Build *itchio.Build `json:"build"`
}

What was installed by a subtask of @@OperationStartParams.

See @@TaskSucceededNotification.

@category Install @kind type

type InstallVersionSwitchPickParams 

type InstallVersionSwitchPickParams struct {
	Cave   *Cave           `json:"cave"`
	Upload *itchio.Upload  `json:"upload"`
	Builds []*itchio.Build `json:"builds"`
}

Let the user pick which version to switch to.

@category Install @caller server

func (InstallVersionSwitchPickParams) Validate 

func (p InstallVersionSwitchPickParams) Validate() error

type InstallVersionSwitchPickResult 

type InstallVersionSwitchPickResult struct {
	// A negative index aborts the version switch
	Index int64 `json:"index"`
}

type InstallVersionSwitchQueueParams 

type InstallVersionSwitchQueueParams struct {
	// The cave to switch to a different version
	CaveID string `json:"caveId"`
}

Prepare to queue a version switch. The client will receive an @@InstallVersionSwitchPickParams.

@name Install.VersionSwitch.Queue @category Install @caller client

func (InstallVersionSwitchQueueParams) Validate 

func (p InstallVersionSwitchQueueParams) Validate() error

type InstallVersionSwitchQueueResult 

type InstallVersionSwitchQueueResult struct {
}

type JsonRPC2Conn 

type JsonRPC2Conn struct {
	Conn *jsonrpc2.Conn
}

func (*JsonRPC2Conn) Call 

func (jc *JsonRPC2Conn) Call(ctx context.Context, method string, params interface{}, result interface{}) error

func (*JsonRPC2Conn) Close 

func (jc *JsonRPC2Conn) Close() error

func (*JsonRPC2Conn) Notify 

func (jc *JsonRPC2Conn) Notify(ctx context.Context, method string, params interface{}) error

type LFObjectCodec 

type LFObjectCodec struct{}

func (LFObjectCodec) ReadObject 

func (LFObjectCodec) ReadObject(stream *bufio.Reader, v interface{}) error

func (LFObjectCodec) WriteObject 

func (LFObjectCodec) WriteObject(stream io.Writer, obj interface{}) error

type LaunchExitedNotification 

type LaunchExitedNotification struct{}

Sent during @@LaunchParams, when the game has actually exited.

@category Launch

type LaunchParams 

type LaunchParams struct {
	// The ID of the cave to launch
	CaveID string `json:"caveId"`

	// The directory to use to store installer files for prerequisites
	PrereqsDir string `json:"prereqsDir"`

	// Force installing all prerequisites, even if they're already marked as installed
	// @optional
	ForcePrereqs bool `json:"forcePrereqs,omitempty"`

	// Enable sandbox (regardless of manifest opt-in)
	// @optional
	Sandbox bool `json:"sandbox,omitempty"`
}

Attempt to launch an installed game.

@name Launch @category Launch @caller client

func (LaunchParams) Validate 

func (p LaunchParams) Validate() error

type LaunchResult 

type LaunchResult struct {
}

type LaunchRunningNotification 

type LaunchRunningNotification struct{}

Sent during @@LaunchParams, when the game is configured, prerequisites are installed sandbox is set up (if enabled), and the game is actually running.

@category Launch

type LogLevel 

type LogLevel string
const (
	// Hidden from logs by default, noisy
	LogLevelDebug LogLevel = "debug"
	// Just thinking out loud
	LogLevelInfo LogLevel = "info"
	// We're continuing, but we're not thrilled about it
	LogLevelWarning LogLevel = "warning"
	// We're eventually going to fail loudly
	LogLevelError LogLevel = "error"
)

type LogNotification 

type LogNotification struct {
	// Level of the message (`info`, `warn`, etc.)
	Level LogLevel `json:"level"`
	// Contents of the message.
	//
	// Note: logs may contain non-ASCII characters, or even emojis.
	Message string `json:"message"`
}

Sent any time butler needs to send a log message. The client should relay them in their own stdout / stderr, and collect them so they can be part of an issue report if something goes wrong.

type Manifest 

type Manifest struct {
	// Actions are a list of options to give the user when launching a game.
	Actions []*Action `json:"actions"`

	// Prereqs describe libraries or frameworks that must be installed
	// prior to launching a game
	Prereqs []*Prereq `json:"prereqs,omitempty"`
}

A Manifest describes prerequisites (dependencies) and actions that can be taken while launching a game.

type MetaAuthenticateParams 

type MetaAuthenticateParams struct {
	Secret string `json:"secret"`
}

When using TCP transport, must be the first message sent

@name Meta.Authenticate @category Utilities @caller client

func (MetaAuthenticateParams) Validate 

func (p MetaAuthenticateParams) Validate() error

type MetaAuthenticateResult 

type MetaAuthenticateResult struct {
	OK bool `json:"ok"`
}

type MetaFlowEstablishedNotification 

type MetaFlowEstablishedNotification struct {
	// The identifier of the daemon process for which the flow was established
	PID int64 `json:"pid"`
}

The first notification sent when @@MetaFlowParams is called.

@category Utilities

type MetaFlowParams 

type MetaFlowParams struct {
}

When called, defines the entire duration of the daemon's life.

Cancelling that conversation (or closing the TCP connection) will shut down the daemon after all other requests have finished. This allows gracefully switching to another daemon.

This conversation is also used to send all global notifications, regarding data that's fetched, network state, etc.

Note that this call never returns - you have to cancel it when you're done with the daemon.

@name Meta.Flow @category Utilities @caller client

func (MetaFlowParams) Validate 

func (p MetaFlowParams) Validate() error

type MetaFlowResult 

type MetaFlowResult struct {
}

type MetaShutdownParams 

type MetaShutdownParams struct {
}

When called, gracefully shutdown the butler daemon. @name Meta.Shutdown @category Utilities @caller client

func (MetaShutdownParams) Validate 

func (p MetaShutdownParams) Validate() error

type MetaShutdownResult 

type MetaShutdownResult struct {
}

type NetworkSetBandwidthThrottleParams 

type NetworkSetBandwidthThrottleParams struct {
	// If true, will limit. If false, will clear any bandwidth throttles in place
	Enabled bool `json:"enabled"`
	// The target bandwidth, in kbps
	Rate int64 `json:"rate"`
}

@name Network.SetBandwidthThrottle @category Utilities @caller client

func (NetworkSetBandwidthThrottleParams) Validate 

func (p NetworkSetBandwidthThrottleParams) Validate() error

type NetworkSetBandwidthThrottleResult 

type NetworkSetBandwidthThrottleResult struct{}

type NetworkSetSimulateOfflineParams 

type NetworkSetSimulateOfflineParams struct {
	// If true, all operations after this point will behave
	// as if there were no network connections
	Enabled bool `json:"enabled"`
}

@name Network.SetSimulateOffline @category Utilities @caller client

func (NetworkSetSimulateOfflineParams) Validate 

func (p NetworkSetSimulateOfflineParams) Validate() error

type NetworkSetSimulateOfflineResult 

type NetworkSetSimulateOfflineResult struct{}

type NetworkStatus 

type NetworkStatus string
const (
	NetworkStatusOnline  NetworkStatus = "online"
	NetworkStatusOffline NetworkStatus = "offline"
)

type NewStateConsumerParams 

type NewStateConsumerParams struct {
	// Mandatory
	Conn Conn
	Ctx  context.Context

	// Optional
	LogFile *os.File
}

type NotificationHandler 

type NotificationHandler func(rc *RequestContext)

type NotificationInterceptor 

type NotificationInterceptor func(method string, params interface{}) error

type PickManifestActionParams 

type PickManifestActionParams struct {
	// A list of actions to pick from. Must be shown to the user in the order they're passed.
	Actions []*Action `json:"actions"`
}

Sent during @@LaunchParams, ask the user to pick a manifest action to launch.

See [itch app manifests](https://itch.io/docs/itch/integrating/manifest.html).

@tags Dialogs @category Launch @caller server

func (PickManifestActionParams) Validate 

func (p PickManifestActionParams) Validate() error

type PickManifestActionResult 

type PickManifestActionResult struct {
	// Index of action picked by user, or negative if aborting
	Index int `json:"index"`
}

type PickUploadParams 

type PickUploadParams struct {
	// An array of upload objects to choose from
	Uploads []*itchio.Upload `json:"uploads"`
}

Asks the user to pick between multiple available uploads

@category Install @tags Dialog @caller server

func (PickUploadParams) Validate 

func (p PickUploadParams) Validate() error

type PickUploadResult 

type PickUploadResult struct {
	// The index (in the original array) of the upload that was picked,
	// or a negative value to cancel.
	Index int64 `json:"index"`
}

type Prereq 

type Prereq struct {
	// A prerequisite to be installed, see <https://itch.io/docs/itch/integrating/prereqs/> for the full list.
	Name string `json:"name"`
}

type PrereqStatus 

type PrereqStatus string

@category Launch 

const (
	// Prerequisite has not started downloading yet
	PrereqStatusPending PrereqStatus = "pending"
	// Prerequisite is currently being downloaded
	PrereqStatusDownloading PrereqStatus = "downloading"
	// Prerequisite has been downloaded and is pending installation
	PrereqStatusReady PrereqStatus = "ready"
	// Prerequisite is currently installing
	PrereqStatusInstalling PrereqStatus = "installing"
	// Prerequisite was installed (successfully or not)
	PrereqStatusDone PrereqStatus = "done"
)

type PrereqTask 

type PrereqTask struct {
	// Full name of the prerequisite, for example: `Microsoft .NET Framework 4.6.2`
	FullName string `json:"fullName"`
	// Order of task in the list. Respect this order in the UI if you want consistent progress indicators.
	Order int `json:"order"`
}

Information about a prerequisite task.

@category Launch

type PrereqsEndedNotification 

type PrereqsEndedNotification struct {
}

Sent during @@LaunchParams, when all prereqs have finished installing (successfully or not)

After this is received, it's safe to close any UI element showing prereq task state.

@category Launch

type PrereqsFailedParams 

type PrereqsFailedParams struct {
	// Short error
	Error string `json:"error"`
	// Longer error (to include in logs)
	ErrorStack string `json:"errorStack"`
}

Sent during @@LaunchParams, when one or more prerequisites have failed to install. The user may choose to proceed with the launch anyway.

@category Launch @caller server

func (PrereqsFailedParams) Validate 

func (p PrereqsFailedParams) Validate() error

type PrereqsFailedResult 

type PrereqsFailedResult struct {
	// Set to true if the user wants to proceed with the launch in spite of the prerequisites failure
	Continue bool `json:"continue"`
}

type PrereqsStartedNotification 

type PrereqsStartedNotification struct {
	// A list of prereqs that need to be tended to
	Tasks map[string]*PrereqTask `json:"tasks"`
}

Sent during @@LaunchParams, when some prerequisites are about to be installed.

This is a good time to start showing a UI element with the state of prereq tasks.

Updates are regularly provided via @@PrereqsTaskStateNotification.

@category Launch

type PrereqsTaskStateNotification 

type PrereqsTaskStateNotification struct {
	// Short name of the prerequisite task (e.g. `xna-4.0`)
	Name string `json:"name"`
	// Current status of the prereq
	Status PrereqStatus `json:"status"`
	// Value between 0 and 1 (floating)
	Progress float64 `json:"progress"`
	// ETA in seconds (floating)
	ETA float64 `json:"eta"`
	// Network bandwidth used in bytes per second (floating)
	BPS float64 `json:"bps"`
}

Current status of a prerequisite task

Sent during @@LaunchParams, after @@PrereqsStartedNotification, repeatedly until all prereq tasks are done.

@category Launch

type Profile 

type Profile struct {
	// itch.io user ID, doubling as profile ID
	ID int64 `json:"id"`

	// Timestamp the user last connected at (to the client)
	LastConnected time.Time `json:"lastConnected"`

	// User information
	User *itchio.User `json:"user"`
}

Represents a user for which we have profile information, ie. that we can connect as, etc.

type ProfileDataGetParams 

type ProfileDataGetParams struct {
	ProfileID int64  `json:"profileId"`
	Key       string `json:"key"`
}

Retrieves some data associated to a profile, by key.

@name Profile.Data.Get @category Profile @caller client

func (ProfileDataGetParams) Validate 

func (p ProfileDataGetParams) Validate() error

type ProfileDataGetResult 

type ProfileDataGetResult struct {
	// True if the value existed
	OK    bool   `json:"ok"`
	Value string `json:"value"`
}

type ProfileDataPutParams 

type ProfileDataPutParams struct {
	ProfileID int64  `json:"profileId"`
	Key       string `json:"key"`
	Value     string `json:"value"`
}

Stores some data associated to a profile, by key.

@name Profile.Data.Put @category Profile @caller client

func (ProfileDataPutParams) Validate 

func (p ProfileDataPutParams) Validate() error

type ProfileDataPutResult 

type ProfileDataPutResult struct {
}

type ProfileForgetParams 

type ProfileForgetParams struct {
	ProfileID int64 `json:"profileId"`
}

Forgets a remembered profile - it won't appear in the @@ProfileListParams results anymore.

@name Profile.Forget @category Profile @caller client

func (ProfileForgetParams) Validate 

func (p ProfileForgetParams) Validate() error

type ProfileForgetResult 

type ProfileForgetResult struct {
	// True if the profile did exist (and was successfully forgotten)
	Success bool `json:"success"`
}

type ProfileGame 

type ProfileGame struct {
	Game *itchio.Game `json:"game"`

	ViewsCount     int64 `json:"viewsCount"`
	DownloadsCount int64 `json:"downloadsCount"`
	PurchasesCount int64 `json:"purchasesCount"`

	Published bool `json:"published"`
}

type ProfileGameFilters 

type ProfileGameFilters struct {
	Visibility string `json:"visibility"`
	PaidStatus string `json:"paidStatus"`
}

func (ProfileGameFilters) Validate 

func (p ProfileGameFilters) Validate() error

type ProfileListParams 

type ProfileListParams struct {
}

Lists remembered profiles

@name Profile.List @category Profile @caller client

func (ProfileListParams) Validate 

func (p ProfileListParams) Validate() error

type ProfileListResult 

type ProfileListResult struct {
	// A list of remembered profiles
	Profiles []*Profile `json:"profiles"`
}

type ProfileLoginWithAPIKeyParams 

type ProfileLoginWithAPIKeyParams struct {
	// The API token to use
	APIKey string `json:"apiKey"`
}

Add a new profile by API key login. This can be used for integration tests, for example. Note that no cookies are returned for this kind of login.

@name Profile.LoginWithAPIKey @category Profile @caller client

func (ProfileLoginWithAPIKeyParams) Validate 

func (p ProfileLoginWithAPIKeyParams) Validate() error

type ProfileLoginWithAPIKeyResult 

type ProfileLoginWithAPIKeyResult struct {
	// Information for the new profile, now remembered
	Profile *Profile `json:"profile"`
}

type ProfileLoginWithPasswordParams 

type ProfileLoginWithPasswordParams struct {
	// The username (or e-mail) to use for login
	Username string `json:"username"`

	// The password to use
	Password string `json:"password"`
}

Add a new profile by password login

@name Profile.LoginWithPassword @category Profile @caller client

func (ProfileLoginWithPasswordParams) Validate 

func (p ProfileLoginWithPasswordParams) Validate() error

type ProfileLoginWithPasswordResult 

type ProfileLoginWithPasswordResult struct {
	// Information for the new profile, now remembered
	Profile *Profile `json:"profile"`

	// Profile cookie for website
	Cookie map[string]string `json:"cookie"`
}

type ProfileOwnedKeysFilters 

type ProfileOwnedKeysFilters struct {
	Installed      bool                      `json:"installed"`
	Classification itchio.GameClassification `json:"classification"`
}

func (ProfileOwnedKeysFilters) Validate 

func (p ProfileOwnedKeysFilters) Validate() error

type ProfileRequestCaptchaParams 

type ProfileRequestCaptchaParams struct {
	// Address of page containing a recaptcha widget
	RecaptchaURL string `json:"recaptchaUrl"`
}

Ask the user to solve a captcha challenge Sent during @@ProfileLoginWithPasswordParams if certain conditions are met.

@name Profile.RequestCaptcha @category Profile @caller server

func (ProfileRequestCaptchaParams) Validate 

func (p ProfileRequestCaptchaParams) Validate() error

type ProfileRequestCaptchaResult 

type ProfileRequestCaptchaResult struct {
	// The response given by recaptcha after it's been filled
	RecaptchaResponse string `json:"recaptchaResponse"`
}

type ProfileRequestTOTPParams 

type ProfileRequestTOTPParams struct {
}

Ask the user to provide a TOTP token. Sent during @@ProfileLoginWithPasswordParams if the user has two-factor authentication enabled.

@name Profile.RequestTOTP @category Profile @caller server

func (ProfileRequestTOTPParams) Validate 

func (p ProfileRequestTOTPParams) Validate() error

type ProfileRequestTOTPResult 

type ProfileRequestTOTPResult struct {
	// The TOTP code entered by the user
	Code string `json:"code"`
}

type ProfileUseSavedLoginParams 

type ProfileUseSavedLoginParams struct {
	ProfileID int64 `json:"profileId"`
}

Use saved login credentials to validate a profile.

@name Profile.UseSavedLogin @category Profile @caller client

func (ProfileUseSavedLoginParams) Validate 

func (p ProfileUseSavedLoginParams) Validate() error

type ProfileUseSavedLoginResult 

type ProfileUseSavedLoginResult struct {
	// Information for the now validated profile
	Profile *Profile `json:"profile"`
}

type ProgressNotification 

type ProgressNotification struct {
	// An overall progress value between 0 and 1
	Progress float64 `json:"progress"`
	// Estimated completion time for the operation, in seconds (floating)
	ETA float64 `json:"eta"`
	// Network bandwidth used, in bytes per second (floating)
	BPS float64 `json:"bps"`
}

Sent periodically during @@InstallPerformParams to inform on the current state of an install

@name Progress @category Install

type RequestContext 

type RequestContext struct {
	Ctx                 context.Context
	Consumer            *state.Consumer
	Client              GetClientFunc
	QueueBackgroundTask func(bt BackgroundTask)

	HTTPClient    *http.Client
	HTTPTransport *http.Transport

	Params      *json.RawMessage
	Conn        Conn
	CancelFuncs *CancelFuncs

	ButlerVersion       string
	ButlerVersionString string

	Group    *singleflight.Group
	Shutdown func()
	// contains filtered or unexported fields
}

func (*RequestContext) Call 

func (rc *RequestContext) Call(method string, params interface{}, res interface{}) error

func (*RequestContext) EndProgress 

func (rc *RequestContext) EndProgress()

func (*RequestContext) GetConn 

func (rc *RequestContext) GetConn() *sqlite.Conn

func (*RequestContext) InterceptNotification 

func (rc *RequestContext) InterceptNotification(method string, interceptor NotificationInterceptor)

func (*RequestContext) Notify 

func (rc *RequestContext) Notify(method string, params interface{}) error

func (*RequestContext) ProfileClient 

func (rc *RequestContext) ProfileClient(profileID int64) (*models.Profile, *itchio.Client)

func (*RequestContext) PutConn 

func (rc *RequestContext) PutConn(conn *sqlite.Conn)

func (*RequestContext) RootClient 

func (rc *RequestContext) RootClient() *itchio.Client

func (*RequestContext) StartProgress 

func (rc *RequestContext) StartProgress()

func (*RequestContext) StartProgressWithInitialAndTotal 

func (rc *RequestContext) StartProgressWithInitialAndTotal(initialProgress float64, totalBytes int64)

func (*RequestContext) StartProgressWithTotalBytes 

func (rc *RequestContext) StartProgressWithTotalBytes(totalBytes int64)

func (*RequestContext) StopInterceptingNotification 

func (rc *RequestContext) StopInterceptingNotification(method string)

func (*RequestContext) WithConn 

func (rc *RequestContext) WithConn(f func(conn *sqlite.Conn))

func (*RequestContext) WithConnBool 

func (rc *RequestContext) WithConnBool(f func(conn *sqlite.Conn) bool) bool

func (*RequestContext) WithConnString 

func (rc *RequestContext) WithConnString(f func(conn *sqlite.Conn) string) string

type RequestHandler 

type RequestHandler func(rc *RequestContext) (interface{}, error)

type Router 

type Router struct {
	Handlers             map[string]RequestHandler
	NotificationHandlers map[string]NotificationHandler
	CancelFuncs          *CancelFuncs

	Group        *singleflight.Group
	ShutdownChan chan struct{}

	ButlerVersion       string
	ButlerVersionString string
	// contains filtered or unexported fields
}

func NewRouter 

func NewRouter(dbPool *sqlite.Pool, getClient GetClientFunc, httpClient *http.Client, httpTransport *http.Transport) *Router

func (*Router) Dispatch 

func (r *Router) Dispatch(ctx context.Context, origConn *jsonrpc2.Conn, req *jsonrpc2.Request)

func (*Router) Logf 

func (r *Router) Logf(format string, args ...interface{})

func (*Router) QueueBackgroundTask 

func (r *Router) QueueBackgroundTask(bt BackgroundTask)

func (*Router) Register 

func (r *Router) Register(method string, rh RequestHandler)

func (*Router) RegisterNotification 

func (r *Router) RegisterNotification(method string, nh NotificationHandler)

type RpcError 

type RpcError struct {
	Code    int64
	Message string
}

func (*RpcError) Error 

func (re *RpcError) Error() string

func (*RpcError) RpcErrorCode 

func (re *RpcError) RpcErrorCode() int64

func (*RpcError) RpcErrorData 

func (re *RpcError) RpcErrorData() map[string]interface{}

func (*RpcError) RpcErrorMessage 

func (re *RpcError) RpcErrorMessage() string

type SearchGamesParams 

type SearchGamesParams struct {
	ProfileID int64 `json:"profileId"`

	Query string `json:"query"`
}

Searches for games.

@name Search.Games @category Search @caller client

func (SearchGamesParams) Validate 

func (p SearchGamesParams) Validate() error

type SearchGamesResult 

type SearchGamesResult struct {
	Games []*itchio.Game `json:"games"`
}

type SearchUsersParams 

type SearchUsersParams struct {
	ProfileID int64 `json:"profileId"`

	Query string `json:"query"`
}

Searches for users.

@name Search.Users @category Search @caller client

func (SearchUsersParams) Validate 

func (p SearchUsersParams) Validate() error

type SearchUsersResult 

type SearchUsersResult struct {
	Users []*itchio.User `json:"users"`
}

type ServeHTTPParams 

type ServeHTTPParams struct {
	HTTPListener net.Listener

	HTTPSListener net.Listener
	TLSState      *TLSState

	Handler  jsonrpc2.Handler
	Consumer *state.Consumer

	ShutdownChan chan struct{}

	Log bool
}

type ServeTCPParams 

type ServeTCPParams struct {
	Handler   jsonrpc2.Handler
	Consumer  *state.Consumer
	Listener  net.Listener
	Secret    string
	Log       bool
	KeepAlive bool

	ShutdownChan chan struct{}
}

type Server 

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

func NewServer 

func NewServer(secret string) *Server

func (*Server) ServeHTTP 

func (s *Server) ServeHTTP(ctx context.Context, params ServeHTTPParams) error

func (*Server) ServeTCP 

func (s *Server) ServeTCP(ctx context.Context, params ServeTCPParams) error

type ShellLaunchParams 

type ShellLaunchParams struct {
	// Absolute path of item to open, e.g. `D:\\Games\\Itch\\garden\\README.txt`
	ItemPath string `json:"itemPath"`
}

Ask the client to perform a shell launch, ie. open an item with the operating system's default handler (File explorer).

Sent during @@LaunchParams.

@category Launch @caller server

func (ShellLaunchParams) Validate 

func (p ShellLaunchParams) Validate() error

type ShellLaunchResult 

type ShellLaunchResult struct {
}

type SnoozeCaveParams 

type SnoozeCaveParams struct {
	CaveID string `json:"caveId"`
}

Snoozing a cave means we ignore all new uploads (that would be potential updates) between the cave's last install operation and now.

This can be undone by calling @@CheckUpdateParams with this specific cave identifier.

@category Update @caller client

func (SnoozeCaveParams) Validate 

func (p SnoozeCaveParams) Validate() error

type SnoozeCaveResult 

type SnoozeCaveResult struct {
}

type SystemStatFSParams 

type SystemStatFSParams struct {
	Path string `json:"path"`
}

Get information on a filesystem.

@name System.StatFS @category System @caller client

func (SystemStatFSParams) Validate 

func (p SystemStatFSParams) Validate() error

type SystemStatFSResult 

type SystemStatFSResult struct {
	FreeSize  int64 `json:"freeSize"`
	TotalSize int64 `json:"totalSize"`
}

type TLSState 

type TLSState struct {
	Config       *tls.Config
	CertPEMBlock []byte
}

func MakeTLSState 

func MakeTLSState() (*TLSState, error)

type TaskReason 

type TaskReason string

@category Install 

const (
	// Task was started for an install operation
	TaskReasonInstall TaskReason = "install"
	// Task was started for an uninstall operation
	TaskReasonUninstall TaskReason = "uninstall"
)

type TaskStartedNotification 

type TaskStartedNotification struct {
	// Why this task was started
	Reason TaskReason `json:"reason"`
	// Is this task a download? An install?
	Type TaskType `json:"type"`
	// The game this task is dealing with
	Game *itchio.Game `json:"game"`
	// The upload this task is dealing with
	Upload *itchio.Upload `json:"upload"`
	// The build this task is dealing with (if any)
	Build *itchio.Build `json:"build,omitempty"`
	// Total size in bytes
	TotalSize int64 `json:"totalSize,omitempty"`
}

Each operation is made up of one or more tasks. This notification is sent during @@OperationStartParams whenever a specific task starts.

@category Install

type TaskSucceededNotification 

type TaskSucceededNotification struct {
	Type TaskType `json:"type"`
	// If the task installed something, then this contains
	// info about the game, upload, build that were installed
	InstallResult *InstallResult `json:"installResult,omitempty"`
}

Sent during @@OperationStartParams whenever a task succeeds for an operation.

@category Install

type TaskType 

type TaskType string

@category Install 

const (
	// We're fetching files from a remote server
	TaskTypeDownload TaskType = "download"
	// We're running an installer
	TaskTypeInstall TaskType = "install"
	// We're running an uninstaller
	TaskTypeUninstall TaskType = "uninstall"
	// We're applying some patches
	TaskTypeUpdate TaskType = "update"
	// We're healing from a signature and heal source
	TaskTypeHeal TaskType = "heal"
)

type TestDoubleParams 

type TestDoubleParams struct {
	// The number to double
	Number int64 `json:"number"`
}

Test request: return a number, doubled. Implement that to use @@TestDoubleTwiceParams in your testing.

@name Test.Double @category Test @caller server

func (TestDoubleParams) Validate 

func (p TestDoubleParams) Validate() error

type TestDoubleResult 

type TestDoubleResult struct {
	// The number, doubled
	Number int64 `json:"number"`
}

Result for Test.Double

type TestDoubleTwiceParams 

type TestDoubleTwiceParams struct {
	// The number to quadruple
	Number int64 `json:"number"`
}

Test request: asks butler to double a number twice. First by calling @@TestDoubleParams, then by returning the result of that call doubled.

Use that to try out your JSON-RPC 2.0 over TCP implementation.

@name Test.DoubleTwice @category Test @caller client

func (TestDoubleTwiceParams) Validate 

func (p TestDoubleTwiceParams) Validate() error

type TestDoubleTwiceResult 

type TestDoubleTwiceResult struct {
	// The input, quadrupled
	Number int64 `json:"number"`
}

@category Test

type URLLaunchParams 

type URLLaunchParams struct {
	// URL to open, e.g. `https://itch.io/community`
	URL string `json:"url"`
}

Ask the client to perform an URL launch, ie. open an address with the system browser or appropriate.

Sent during @@LaunchParams.

@category Launch @caller server

func (URLLaunchParams) Validate 

func (p URLLaunchParams) Validate() error

type URLLaunchResult 

type URLLaunchResult struct{}

type UninstallPerformParams 

type UninstallPerformParams struct {
	// The cave to uninstall
	CaveID string `json:"caveId"`

	// If true, don't attempt to run any uninstallers, just
	// remove the DB record and burn the install folder to the ground.
	// @optional
	Hard bool `json:"hard"`
}

UninstallParams contains all the parameters needed to perform an uninstallation for a game via @@OperationStartParams.

@name Uninstall.Perform @category Install @caller client

func (UninstallPerformParams) Validate 

func (p UninstallPerformParams) Validate() error

type UninstallPerformResult 

type UninstallPerformResult struct{}

type VersionGetParams 

type VersionGetParams struct{}

Retrieves the version of the butler instance the client is connected to.

This endpoint is meant to gather information when reporting issues, rather than feature sniffing. Conforming clients should automatically download new versions of butler, see the **Updating** section.

@name Version.Get @category Utilities @tags Offline @caller client

func (VersionGetParams) Validate 

func (p VersionGetParams) Validate() error

type VersionGetResult 

type VersionGetResult struct {
	// Something short, like `v8.0.0`
	Version string `json:"version"`

	// Something long, like `v8.0.0, built on Aug 27 2017 @ 01:13:55, ref d833cc0aeea81c236c81dffb27bc18b2b8d8b290`
	VersionString string `json:"versionString"`
}

type WithParamsFunc 

type WithParamsFunc func() (interface{}, error)

Source Files

View all Source files

Directories

Path Synopsis
spec

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.