transmissionrpc

package module
v3.0.0 Latest Latest
Warning

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

 Go to latest Published: Oct 30, 2023 License: MIT Imports: 17 Imported by: 10

README

TransmissionRPC

Go Reference Go report card

Golang bindings to Transmission (bittorrent) RPC interface.

Even if there is some high level wrappers/helpers, the goal of this lib is to stay close to the original API in terms of methods and payloads while enhancing certain types to be more "golangish": timestamps are converted from/to time.Time, numeric durations in time.Duration, booleans in numeric form are converted to real bool, etc...

Also payload generation aims to be precise: when several values can be added to a payload, only instanciated values will be forwarded (and kept !) to the final payload. This means that the default JSON marshalling (with omitempty) can't always be used and therefor a manual, reflect based, approach is used to build the final payload and accurately send what the user have instanciated, even if a value is at its default type value.

  • If you want a 100% compatible lib with rpc v15, please use the v1 releases.
  • If you want a 100% compatible lib with rpc v16, please use the v2 releases.

Version v3 of this library is compatible with RPC version 17 (Transmission v4) and is currently in beta.

Getting started

Install the v3 with:

go get github.com/hekmon/transmissionrpc/v3

First the main client object must be instantiated with New(). The library takes a parsed URL as input: it allows you to add any options you need to it (scheme, optional authentification, custom port, custom URI/prefix, etc...).

import (
    "net/url"

    "github.com/hekmon/transmissionrpc/v3"
)

endpoint, err := url.Parse("http://user:password@127.0.0.1:9091/transmission/rpc")
if err != nil {
    panic(err)
}
tbt, err := transmissionrpc.New(endpoint, nil)
if err != nil {
    panic(err)
}

The remote RPC version can be checked against this library before starting to operate:

ok, serverVersion, serverMinimumVersion, err := transmission.RPCVersion()
if err != nil {
    panic(err)
}
if !ok {
    panic(fmt.Sprintf("Remote transmission RPC version (v%d) is incompatible with the transmission library (v%d): remote needs at least v%d",
        serverVersion, transmissionrpc.RPCVersion, serverMinimumVersion))
}
fmt.Printf("Remote transmission RPC version (v%d) is compatible with our transmissionrpc library (v%d)\n",
    serverVersion, transmissionrpc.RPCVersion)

Features

Torrent Requests
Torrent Action Requests

Each rpc methods here can work with ID list, hash list or recently-active magic word. Therefor, there is 3 golang method variants for each of them.

transmissionbt.TorrentXXXXIDs(...)
transmissionbt.TorrentXXXXHashes(...)
transmissionbt.TorrentXXXXRecentlyActive()
  • torrent-start

Check TorrentStartIDs(), TorrentStartHashes() and TorrentStartRecentlyActive().

Ex:

err := transmissionbt.TorrentStartIDs(context.TODO(), []int64{55})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println("yay")
}
  • torrent-start-now

Check TorrentStartNowIDs(), TorrentStartNowHashes() and TorrentStartNowRecentlyActive().

Ex:

err := transmissionbt.TorrentStartNowHashes(context.TODO(), []string{"f07e0b0584745b7bcb35e98097488d34e68623d0"})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println("yay")
}
  • torrent-stop

Check TorrentStopIDs(), TorrentStopHashes() and TorrentStopRecentlyActive().

Ex:

err := transmissionbt.TorrentStopIDs(context.TODO(), []int64{55})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println("yay")
}
  • torrent-verify

Check TorrentVerifyIDs(), TorrentVerifyHashes() and TorrentVerifyRecentlyActive().

Ex:

err := transmissionbt.TorrentVerifyHashes(context.TODO(), []string{"f07e0b0584745b7bcb35e98097488d34e68623d0"})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println("yay")
}
  • torrent-reannounce

Check TorrentReannounceIDs(), TorrentReannounceHashes() and TorrentReannounceRecentlyActive().

Ex:

err := transmissionbt.TorrentReannounceRecentlyActive(context.TODO())
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println("yay")
}
Torrent Mutators
  • torrent-set

Mapped as TorrentSet().

Ex: apply a 1 MB/s limit to a torrent.

uploadLimited := true
uploadLimitKBps := int64(1000)
err := transmissionbt.TorrentSet(context.TODO(), transmissionrpc.TorrentSetPayload{
    IDs:           []int64{55},
    UploadLimited: &uploadLimited,
    UploadLimit:   &uploadLimitKBps,
})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println("yay")
}

There is a lot more mutators available.

Torrent Accessors
  • torrent-get

All fields for all torrents with TorrentGetAll():

torrents, err := transmissionbt.TorrentGetAll(context.TODO())
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println(torrents) // meh it's full of pointers
}

All fields for a restricted list of ids with TorrentGetAllFor():

torrents, err := transmissionbt.TorrentGetAllFor(context.TODO(), []int64{31})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    fmt.Println(torrents) // meh it's still full of pointers
}

Some fields for some torrents with the low level accessor TorrentGet():

torrents, err := transmissionbt.TorrentGet(context.TODO(), []string{"status"}, []int64{54, 55})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    for _, torrent := range torrents {
        fmt.Println(torrent.Status) // the only instanciated field, as requested
    }
}

Some fields for all torrents, still with the low level accessor TorrentGet():

torrents, err := transmissionbt.TorrentGet(context.TODO(), []string{"id", "name", "hashString"}, nil)
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    for _, torrent := range torrents {
        fmt.Println(torrent.ID)
        fmt.Println(torrent.Name)
        fmt.Println(torrent.HashString)
    }
}

Valid fields name can be found as JSON tag on the Torrent struct.

Adding a Torrent
  • torrent-add

Adding a torrent from a file (using TorrentAddFile wrapper):

filepath := "/home/hekmon/Downloads/ubuntu-17.10.1-desktop-amd64.iso.torrent"
torrent, err := transmissionbt.TorrentAddFile(context.TODO(), filepath)
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    // Only 3 fields will be returned/set in the Torrent struct
    fmt.Println(*torrent.ID)
    fmt.Println(*torrent.Name)
    fmt.Println(*torrent.HashString)
}

Adding a torrent from a file (using TorrentAddFileDownloadDir wrapper) to a specified DownloadDir (this allows for separation of downloads to target folders):

filepath := "/home/hekmon/Downloads/ubuntu-17.10.1-desktop-amd64.iso.torrent"
torrent, err := transmissionbt.TorrentAddFileDownloadDir(context.TODO(), filepath, "/path/to/other/download/dir")
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    // Only 3 fields will be returned/set in the Torrent struct
    fmt.Println(*torrent.ID)
    fmt.Println(*torrent.Name)
    fmt.Println(*torrent.HashString)
}

Adding a torrent from an URL (ex: a magnet) with the real TorrentAdd method:

magnet := "magnet:?xt=urn:btih:f07e0b0584745b7bcb35e98097488d34e68623d0&dn=ubuntu-17.10.1-desktop-amd64.iso&tr=http%3A%2F%2Ftorrent.ubuntu.com%3A6969%2Fannounce&tr=http%3A%2F%2Fipv6.torrent.ubuntu.com%3A6969%2Fannounce"
torrent, err := btserv.TorrentAdd(context.TODO(), transmissionrpc.TorrentAddPayload{
    Filename: &magnet,
})
if err != nil {
    fmt.Fprintln(os.Stderr, err)
} else {
    // Only 3 fields will be returned/set in the Torrent struct
    fmt.Println(*torrent.ID)
    fmt.Println(*torrent.Name)
    fmt.Println(*torrent.HashString)
}

Which would output:

55
ubuntu-17.10.1-desktop-amd64.iso
f07e0b0584745b7bcb35e98097488d34e68623d0

Adding a torrent from a file, starting it paused:

filepath := "/home/hekmon/Downloads/ubuntu-17.10.1-desktop-amd64.iso.torrent"
b64, err := transmissionrpc.File2Base64(filepath)
if err != nil {
    fmt.Fprintf(os.Stderr, "can't encode '%s' content as base64: %v", filepath, err)
} else {
    // Prepare and send payload
    paused := true
    torrent, err := transmissionbt.TorrentAdd(context.TODO(), transmissionrpc.TorrentAddPayload{MetaInfo: &b64, Paused: &paused})
}
Removing a Torrent
  • torrent-remove

Mapped as TorrentRemove().

Moving a Torrent
  • torrent-set-location

Mapped as TorrentSetLocation().

Renaming a Torrent path
  • torrent-rename-path

Mapped as TorrentRenamePath().

Session Requests
Session Arguments
  • session-set

Mapped as SessionArgumentsSet().

  • session-get

Mapped as SessionArgumentsGet().

Session Statistics
  • session-stats

Mapped as SessionStats().

Blocklist
  • blocklist-update

Mapped as BlocklistUpdate().

Port Checking
  • port-test

Mapped as PortTest().

Ex:

    st, err := transmissionbt.PortTest(context.TODO())
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
    }
    if st {
        fmt.Println("Open!")
    }
Session Shutdown
  • session-close

Mapped as SessionClose().

Queue Movement Requests
  • queue-move-top

Mapped as QueueMoveTop().

  • queue-move-up

Mapped as QueueMoveUp().

  • queue-move-down

Mapped as QueueMoveDown().

  • queue-move-bottom

Mapped as QueueMoveBottom().

Free Space
  • free-space

Mappped as FreeSpace().

Ex: Get the space available for /data.

    freeSpace, totalSpace, err := transmissionbt.FreeSpace(context.TODO(), "/data")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
    } else  {
        fmt.Printf("Free space: %s | %d | %v\n", freeSpace, freeSpace, freeSpace)
        fmt.Printf("Total space: %s | %d | %v\n", totalSpace, totalSpace, totalSpace)
    }
}

For more information about the freeSpace type, check the ComputerUnits library.

Bandwidth Groups
  • group-set

Mapped as BandwidthGroupSet().

  • group-get

Mapped as BandwidthGroupGet().

Debugging

If you want to (or need to) inspect the requests made by the lib, you can use a custom round tripper within a custom HTTP client. I personnaly like to use the debuglog package from the starr project. Example below.

package main

import (
	"context"
	"fmt"
	"net/url"
	"time"

	"github.com/hashicorp/go-cleanhttp"
	"github.com/hekmon/transmissionrpc/v3"
	"golift.io/starr/debuglog"
)

func main() {
    // Parse API endpoint
	endpoint, err := url.Parse("http://user:password@127.0.0.1:9091/transmission/rpc")
	if err != nil {
		panic(err)
	}

    // Create the HTTP client with debugging capabilities
    httpClient := cleanhttp.DefaultPooledClient()
	httpClient.Transport = debuglog.NewLoggingRoundTripper(debuglog.Config{
		Redact: []string{endpoint.User.String()},
	}, httpClient.Transport)

    // Initialize the transmission API client with the debbuging HTTP client
    tbt, err := transmissionrpc.New(endpoint, &transmissionrpc.Config{
		CustomClient: httpClient,
	})
	if err != nil {
		panic(err)
	}

    // do something with tbt now
}

Documentation

Index

Constants

View Source 
const (
	// RPCVersion indicates the exact transmission RPC version this library is build against
	RPCVersion = 17
)

Variables

This section is empty.

Functions

func File2Base64 

func File2Base64(filename string) (b64 string, err error)

File2Base64 returns the base64 encoding of the file provided by filename. This can then be passed as MetaInfo in TorrentAddPayload.

Types

type BandwidthGroup 

type BandwidthGroup struct {
	HonorSessionLimits    bool   `json:"honorSessionLimits"`
	Name                  string `json:"name"`
	SpeedLimitDownEnabled bool   `json:"speed-limit-down-enabled"`
	SpeedLimitDown        int64  `json:"speed-limit-down"`
	SpeedLimitUpEnabled   bool   `json:"speed-limit-up-enabled"`
	SpeedLimitUp          int64  `json:"speed-limit-up"`
}

BandwidthGroup represents all possible fields of data for a bandwidth group.

type Client 

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

Client is the base object to interract with a remote transmission rpc endpoint. It must be created with New().

func New 

func New(transmissionRPCendpoint *url.URL, extra *Config) (c *Client, err error)

New returns an initialized and ready to use Controller

func (*Client) BandwidthGroupGet 

func (c *Client) BandwidthGroupGet(ctx context.Context, groups []string) (bandwidthGroups []BandwidthGroup, err error)

BandwidthGroupGet returns the given fields for each bandwidth group provided. If no group names are provided, returns all groups. As of Transmission 4.0.3 it seems that filtering with group names does not work as documented here: https://github.com/transmission/transmission/blob/4.0.3/docs/rpc-spec.md#482-bandwidth-group-accessor-group-get Testing always yield the full list of bandwidth groups, even when submitting a filter.

func (*Client) BandwidthGroupSet 

func (c *Client) BandwidthGroupSet(ctx context.Context, bwGroup BandwidthGroup) (err error)

BandwidthGroupSet applies a list of mutator(s) to a bandwidth group.

func (*Client) BlocklistUpdate 

func (c *Client) BlocklistUpdate(ctx context.Context) (nbEntries int64, err error)

BlocklistUpdate triggers a blocklist update. It returns the number of entries of the updated blocklist.

func (*Client) FreeSpace 

func (c *Client) FreeSpace(ctx context.Context, path string) (freeSpace, totalSize cunits.Bits, err error)

FreeSpace allow to see how much free space is available in a client-specified folder.

func (*Client) PortTest 

func (c *Client) PortTest(ctx context.Context) (open bool, err error)

PortTest allows tests to see if your incoming peer port is accessible from the outside world.

func (*Client) QueueMoveBottom 

func (c *Client) QueueMoveBottom(ctx context.Context, IDs []int64) (err error)

QueueMoveBottom moves IDs to the bottom of the queue list.

func (*Client) QueueMoveDown 

func (c *Client) QueueMoveDown(ctx context.Context, IDs []int64) (err error)

QueueMoveDown moves IDs of one position down on the queue list.

func (*Client) QueueMoveTop 

func (c *Client) QueueMoveTop(ctx context.Context, IDs []int64) (err error)

QueueMoveTop moves IDs to the top of the queue list.

func (*Client) QueueMoveUp 

func (c *Client) QueueMoveUp(ctx context.Context, IDs []int64) (err error)

QueueMoveUp moves IDs of one position up on the queue list.

func (*Client) RPCVersion 

func (c *Client) RPCVersion(ctx context.Context) (ok bool, serverVersion int64, serverMinimumVersion int64, err error)

RPCVersion returns true if the lib RPC version is greater or equals to the remote server rpc minimum version.

func (*Client) SessionArgumentsGet 

func (c *Client) SessionArgumentsGet(ctx context.Context, fields []string) (sessionArgs SessionArguments, err error)

SessionArgumentsGet returns global/session values for specified fields. See the JSON tags of the SessionArguments struct for valid fields. https://github.com/transmission/transmission/blob/4.0.3/docs/rpc-spec.md#412-accessors

func (*Client) SessionArgumentsGetAll 

func (c *Client) SessionArgumentsGetAll(ctx context.Context) (sessionArgs SessionArguments, err error)

SessionArgumentsGetAll returns global/session values. https://github.com/transmission/transmission/blob/4.0.3/docs/rpc-spec.md#412-accessors

func (*Client) SessionArgumentsSet 

func (c *Client) SessionArgumentsSet(ctx context.Context, payload SessionArguments) (err error)

SessionArgumentsSet allows to modify global/session values. https://github.com/transmission/transmission/blob/4.0.3/docs/rpc-spec.md#411-mutators

func (*Client) SessionClose 

func (c *Client) SessionClose(ctx context.Context) (err error)

SessionClose tells the transmission session to shut down.

func (*Client) SessionStats 

func (c *Client) SessionStats(ctx context.Context) (stats SessionStats, err error)

SessionStats returns all (current/cumulative) statistics.

func (*Client) TorrentAdd 

func (c *Client) TorrentAdd(ctx context.Context, payload TorrentAddPayload) (torrent Torrent, err error)

TorrentAdd allows to send an Add payload. If successful (torrent added or duplicate) torrent return value will only have HashString, ID and Name fields set up.

func (*Client) TorrentAddFile 

func (c *Client) TorrentAddFile(ctx context.Context, filepath string) (torrent Torrent, err error)

TorrentAddFile is wrapper to directly add a torrent file (it handles the base64 encoding and payload generation). If successful (torrent added or duplicate) torrent return value will only have HashString, ID and Name fields set up.

func (*Client) TorrentAddFileDownloadDir 

func (c *Client) TorrentAddFileDownloadDir(ctx context.Context, filepath, downloaddir string) (torrent Torrent, err error)

TorrentAddFileDownloadDir is wrapper to directly add a torrent file (it handles the base64 encoding and payload generation) to a DownloadDir (not the default download dir). If successful (torrent added or duplicate) torrent return value will only have HashString, ID and Name fields set up.

func (*Client) TorrentGet 

func (c *Client) TorrentGet(ctx context.Context, fields []string, ids []int64) (torrents []Torrent, err error)

TorrentGet returns the given of fields (mandatory) for each ids (optionnal).

func (*Client) TorrentGetAll 

func (c *Client) TorrentGetAll(ctx context.Context) (torrents []Torrent, err error)

TorrentGetAll returns all the known fields for all the torrents.

func (*Client) TorrentGetAllFor 

func (c *Client) TorrentGetAllFor(ctx context.Context, ids []int64) (torrents []Torrent, err error)

TorrentGetAllFor returns all known fields for the given torrent's ids.

func (*Client) TorrentGetAllForHashes 

func (c *Client) TorrentGetAllForHashes(ctx context.Context, hashes []string) (torrents []Torrent, err error)

TorrentGetAllForHashes returns all known fields for the given torrent's ids by string (usually hash).

func (*Client) TorrentGetHashes 

func (c *Client) TorrentGetHashes(ctx context.Context, fields []string, hashes []string) (torrents []Torrent, err error)

TorrentGetHashes returns the given of fields (mandatory) for each ids (optionnal).

func (*Client) TorrentReannounceHashes 

func (c *Client) TorrentReannounceHashes(ctx context.Context, hashes []string) (err error)

TorrentReannounceHashes reannounces torrent(s) which hash is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentReannounceIDs 

func (c *Client) TorrentReannounceIDs(ctx context.Context, ids []int64) (err error)

TorrentReannounceIDs reannounces torrent(s) which id is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentReannounceRecentlyActive 

func (c *Client) TorrentReannounceRecentlyActive(ctx context.Context) (err error)

TorrentReannounceRecentlyActive reannounces torrent(s) which have been recently active.

func (*Client) TorrentRemove 

func (c *Client) TorrentRemove(ctx context.Context, payload TorrentRemovePayload) (err error)

TorrentRemove allows to delete one or more torrents only or with their data.

func (*Client) TorrentRenamePath 

func (c *Client) TorrentRenamePath(ctx context.Context, id int64, path, name string) (err error)

TorrentRenamePath allows to rename torrent name or path. 'path' is the path to the file or folder that will be renamed. 'name' the file or folder's new name

func (*Client) TorrentRenamePathHash 

func (c *Client) TorrentRenamePathHash(ctx context.Context, hash, path, name string) (err error)

TorrentRenamePathHash allows to rename torrent name or path by its hash.

func (*Client) TorrentSet 

func (c *Client) TorrentSet(ctx context.Context, payload TorrentSetPayload) (err error)

TorrentSet apply a list of mutator(s) to a list of torrent ids.

func (*Client) TorrentSetLocation 

func (c *Client) TorrentSetLocation(ctx context.Context, id int64, location string, move bool) (err error)

TorrentSetLocation allows to set a new location for one or more torrents. 'location' is the new torrent location. 'move' if true, move from previous location. Otherwise, search "location" for file.

func (*Client) TorrentSetLocationHash 

func (c *Client) TorrentSetLocationHash(ctx context.Context, hash, location string, move bool) (err error)

TorrentSetLocationHash allows to set a new location for one or more torrents. 'location' is the new torrent location. 'move' if true, move from previous location. Otherwise, search "location" for file.

func (*Client) TorrentStartHashes 

func (c *Client) TorrentStartHashes(ctx context.Context, hashes []string) (err error)

TorrentStartHashes starts torrent(s) which hash is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentStartIDs 

func (c *Client) TorrentStartIDs(ctx context.Context, ids []int64) (err error)

TorrentStartIDs starts torrent(s) which id is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentStartNowHashes 

func (c *Client) TorrentStartNowHashes(ctx context.Context, hashes []string) (err error)

TorrentStartNowHashes starts (now) torrent(s) which hash is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentStartNowIDs 

func (c *Client) TorrentStartNowIDs(ctx context.Context, ids []int64) (err error)

TorrentStartNowIDs starts (now) torrent(s) which id is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentStartNowRecentlyActive 

func (c *Client) TorrentStartNowRecentlyActive(ctx context.Context) (err error)

TorrentStartNowRecentlyActive starts (now) torrent(s) which have been recently active.

func (*Client) TorrentStartRecentlyActive 

func (c *Client) TorrentStartRecentlyActive(ctx context.Context) (err error)

TorrentStartRecentlyActive starts torrent(s) which have been recently active.

func (*Client) TorrentStopHashes 

func (c *Client) TorrentStopHashes(ctx context.Context, hashes []string) (err error)

TorrentStopHashes stops torrent(s) which hash is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentStopIDs 

func (c *Client) TorrentStopIDs(ctx context.Context, ids []int64) (err error)

TorrentStopIDs stops torrent(s) which id is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentStopRecentlyActive 

func (c *Client) TorrentStopRecentlyActive(ctx context.Context) (err error)

TorrentStopRecentlyActive stops torrent(s) which have been recently active.

func (*Client) TorrentVerifyHashes 

func (c *Client) TorrentVerifyHashes(ctx context.Context, hashes []string) (err error)

TorrentVerifyHashes verifys torrent(s) which hash is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentVerifyIDs 

func (c *Client) TorrentVerifyIDs(ctx context.Context, ids []int64) (err error)

TorrentVerifyIDs verifys torrent(s) which id is in the provided slice. Can be one, can be several, can be all (if slice is empty or nil).

func (*Client) TorrentVerifyRecentlyActive 

func (c *Client) TorrentVerifyRecentlyActive(ctx context.Context) (err error)

TorrentVerifyRecentlyActive verifys torrent(s) which have been recently active.

type Config 

type Config struct {
	// UserAgent is set to this package's url if not provided here.
	UserAgent string
	// Client is set to a clean and isolated client if not provided
	CustomClient *http.Client
}

Config is the input data needed to make a connection to Transmission RPC.

type Encryption 

type Encryption string
const (
	EncryptionRequired  Encryption = "required"
	EncryptionPreferred Encryption = "prefered"
	EncryptionTolerated Encryption = "tolerated"
)

type HTTPStatusCode 

type HTTPStatusCode int

HTTPStatusCode is a custom error type for HTTP errors

func (HTTPStatusCode) Error 

func (hsc HTTPStatusCode) Error() string

type Peer 

type Peer struct {
	Address            string  `json:"address"`
	ClientName         string  `json:"clientName"`
	ClientIsChoked     bool    `json:"clientIsChoked"`
	ClientIsInterested bool    `json:"clientIsInterested"`
	FlagStr            string  `json:"flagStr"`
	IsDownloadingFrom  bool    `json:"isDownloadingFrom"`
	IsEncrypted        bool    `json:"isEncrypted"`
	IsIncoming         bool    `json:"isIncoming"`
	IsUploadingTo      bool    `json:"isUploadingTo"`
	IsUTP              bool    `json:"isUTP"`
	PeerIsChoked       bool    `json:"peerIsChoked"`
	PeerIsInterested   bool    `json:"peerIsInterested"`
	Port               int64   `json:"port"`
	Progress           float64 `json:"progress"`
	RateToClient       int64   `json:"rateToClient"` // B/s
	RateToPeer         int64   `json:"rateToPeer"`   // B/s
}

Peer represent a peer metadata of a torrent's peer list.

func (*Peer) ConvertDownloadSpeed 

func (p *Peer) ConvertDownloadSpeed() (speed cunits.Bits)

ConvertDownloadSpeed will return the download speed from peer as cunits.Bits/second

func (*Peer) ConvertUploadSpeed 

func (p *Peer) ConvertUploadSpeed() (speed cunits.Bits)

ConvertUploadSpeed will return the upload speed to peer as cunits.Bits/second

type SeedRatioMode 

type SeedRatioMode int64

SeedRatioMode represents a torrent current seeding mode 

const (
	// SeedRatioModeGlobal represents the use of the global ratio for a torrent
	SeedRatioModeGlobal SeedRatioMode = 0
	// SeedRatioModeCustom represents the use of a custom ratio for a torrent
	SeedRatioModeCustom SeedRatioMode = 1
	// SeedRatioModeNoRatio represents the absence of ratio for a torrent
	SeedRatioModeNoRatio SeedRatioMode = 2
)

func (SeedRatioMode) GoString 

func (srm SeedRatioMode) GoString() string

GoString implements the GoStringer interface from the stdlib fmt package

func (SeedRatioMode) String 

func (srm SeedRatioMode) String() string

type SessionArguments 

type SessionArguments struct {
	AltSpeedDown                     *int64      `json:"alt-speed-down"`                       // max global download speed (KBps)
	AltSpeedEnabled                  *bool       `json:"alt-speed-enabled"`                    // true means use the alt speeds
	AltSpeedTimeBegin                *int64      `json:"alt-speed-time-begin"`                 // when to turn on alt speeds (units: minutes after midnight)
	AltSpeedTimeDay                  *int64      `json:"alt-speed-time-day"`                   // what day(s) to turn on alt speeds (look at tr_sched_day)
	AltSpeedTimeEnabled              *bool       `json:"alt-speed-time-enabled"`               // true means the scheduled on/off times are used
	AltSpeedTimeEnd                  *int64      `json:"alt-speed-time-end"`                   // when to turn off alt speeds (units: same)
	AltSpeedUp                       *int64      `json:"alt-speed-up"`                         // max global upload speed (KBps)
	BlocklistEnabled                 *bool       `json:"blocklist-enabled"`                    // true means enabled
	BlocklistSize                    *int64      `json:"blocklist-size"`                       // number of rules in the blocklist
	BlocklistURL                     *string     `json:"blocklist-url"`                        // location of the blocklist to use for "blocklist-update"
	CacheSizeMB                      *int64      `json:"cache-size-mb"`                        // maximum size of the disk cache (MB)
	ConfigDir                        *string     `json:"config-dir"`                           // location of transmission's configuration directory
	DefaultTrackers                  []string    `json:"default-trackers"`                     // list of default trackers to use on public torrents
	DHTEnabled                       *bool       `json:"dht-enabled"`                          // true means allow dht in public torrents
	DownloadDir                      *string     `json:"download-dir"`                         // default path to download torrents
	DownloadQueueEnabled             *bool       `json:"download-queue-enabled"`               // if true, limit how many torrents can be downloaded at once
	DownloadQueueSize                *int64      `json:"download-queue-size"`                  // max number of torrents to download at once (see download-queue-enabled)
	Encryption                       *Encryption `json:"encryption"`                           // "required", "preferred", "tolerated", see Encryption type constants
	IdleSeedingLimitEnabled          *bool       `json:"idle-seeding-limit-enabled"`           // true if the seeding inactivity limit is honored by default
	IdleSeedingLimit                 *int64      `json:"idle-seeding-limit"`                   // torrents we're seeding will be stopped if they're idle for this long
	IncompleteDirEnabled             *bool       `json:"incomplete-dir-enabled"`               // true means keep torrents in incomplete-dir until done
	IncompleteDir                    *string     `json:"incomplete-dir"`                       // path for incomplete torrents, when enabled
	LPDEnabled                       *bool       `json:"lpd-enabled"`                          // true means allow Local Peer Discovery in public torrents
	PeerLimitGlobal                  *int64      `json:"peer-limit-global"`                    // maximum global number of peers
	PeerLimitPerTorrent              *int64      `json:"peer-limit-per-torrent"`               // maximum global number of peers
	PeerPortRandomOnStart            *bool       `json:"peer-port-random-on-start"`            // true means pick a random peer port on launch
	PeerPort                         *int64      `json:"peer-port"`                            // port number
	PEXEnabled                       *bool       `json:"pex-enabled"`                          // true means allow pex in public torrents
	PortForwardingEnabled            *bool       `json:"port-forwarding-enabled"`              // true means enabled
	QueueStalledEnabled              *bool       `json:"queue-stalled-enabled"`                // whether or not to consider idle torrents as stalled
	QueueStalledMinutes              *int64      `json:"queue-stalled-minutes"`                // torrents that are idle for N minuets aren't counted toward seed-queue-size or download-queue-size
	RenamePartialFiles               *bool       `json:"rename-partial-files"`                 // true means append ".part" to incomplete files
	RPCVersionMinimum                *int64      `json:"rpc-version-minimum"`                  // the minimum RPC API version supported
	RPCVersionSemVer                 *string     `json:"rpc-version-semver"`                   // the current RPC API version in a semver-compatible string
	RPCVersion                       *int64      `json:"rpc-version"`                          // the current RPC API version
	ScriptTorrentAddedEnabled        *bool       `json:"script-torrent-added-enabled"`         // whether or not to call the added script
	ScriptTorrentAddedFilename       *string     `json:"script-torrent-added-filename"`        //filename of the script to run
	ScriptTorrentDoneEnabled         *bool       `json:"script-torrent-done-enabled"`          // whether or not to call the "done" script
	ScriptTorrentDoneFilename        *string     `json:"script-torrent-done-filename"`         // filename of the script to run
	ScriptTorrentDoneSeedingEnabled  *bool       `json:"script-torrent-done-seeding-enabled"`  // whether or not to call the seeding-done script
	ScriptTorrentDoneSeedingFilename *string     `json:"script-torrent-done-seeding-filename"` // filename of the script to run
	SeedQueueEnabled                 *bool       `json:"seed-queue-enabled"`                   // if true, limit how many torrents can be uploaded at once
	SeedQueueSize                    *int64      `json:"seed-queue-size"`                      // max number of torrents to uploaded at once (see seed-queue-enabled)
	SeedRatioLimit                   *float64    `json:"seedRatioLimit"`                       // the default seed ratio for torrents to use
	SeedRatioLimited                 *bool       `json:"seedRatioLimited"`                     // true if seedRatioLimit is honored by default
	SessionID                        *string     `json:"session-id"`                           // the current session ID
	SpeedLimitDownEnabled            *bool       `json:"speed-limit-down-enabled"`             // true means enabled
	SpeedLimitDown                   *int64      `json:"speed-limit-down"`                     // max global download speed (KBps)
	SpeedLimitUpEnabled              *bool       `json:"speed-limit-up-enabled"`               // true means enabled
	SpeedLimitUp                     *int64      `json:"speed-limit-up"`                       // max global upload speed (KBps)
	StartAddedTorrents               *bool       `json:"start-added-torrents"`                 // true means added torrents will be started right away
	TrashOriginalTorrentFiles        *bool       `json:"trash-original-torrent-files"`         // true means the .torrent file of added torrents will be deleted
	Units                            *Units      `json:"units"`                                // see units below
	UTPEnabled                       *bool       `json:"utp-enabled"`                          // true means allow utp
	Version                          *string     `json:"version"`                              // long version string "$version ($revision)"
}

SessionArguments represents all the global/session values.

func (SessionArguments) CacheSize 

func (sa SessionArguments) CacheSize() (size cunits.Bits)

CacheSize returns the cache size in a handy format

func (SessionArguments) MarshalJSON 

func (sa SessionArguments) MarshalJSON() (data []byte, err error)

MarshalJSON allows to marshall into JSON only the non nil fields. It differs from 'omitempty' which also skip default values (as 0 or false which can be valid here).

func (*SessionArguments) UnmarshalJSON 

func (sa *SessionArguments) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON allows to convert timestamps to golang time.Time values.

type SessionStats 

type SessionStats struct {
	ActiveTorrentCount int64               `json:"activeTorrentCount"`
	DownloadSpeed      int64               `json:"downloadSpeed"`
	PausedTorrentCount int64               `json:"pausedTorrentCount"`
	TorrentCount       int64               `json:"torrentCount"`
	UploadSpeed        int64               `json:"uploadSpeed"`
	CumulativeStats    SessionStatsDetails `json:"cumulative-stats"`
	CurrentStats       SessionStatsDetails `json:"current-stats"`
}

SessionStats represents all (current/cumulative) statistics.

type SessionStatsDetails 

type SessionStatsDetails struct {
	DownloadedBytes int64 `json:"downloadedBytes"`
	FilesAdded      int64 `json:"filesAdded"`
	SecondsActive   int64 `json:"secondsActive"`
	SessionCount    int64 `json:"sessionCount"`
	UploadedBytes   int64 `json:"uploadedBytes"`
}

CumulativeStats is subset of SessionStats.

func (*SessionStatsDetails) GetDownloaded 

func (cs *SessionStatsDetails) GetDownloaded() (downloaded cunits.Bits)

GetDownloaded returns cumulative stats downloaded size in a handy format

func (*SessionStatsDetails) GetUploaded 

func (cs *SessionStatsDetails) GetUploaded() (uploaded cunits.Bits)

GetUploaded returns cumulative stats uploaded size in a handy format

type Torrent 

type Torrent struct {
	ActivityDate            *time.Time        `json:"activityDate"`
	AddedDate               *time.Time        `json:"addedDate"`
	Availability            []int64           `json:"availability"` // RPC v17
	BandwidthPriority       *int64            `json:"bandwidthPriority"`
	Comment                 *string           `json:"comment"`
	CorruptEver             *int64            `json:"corruptEver"`
	Creator                 *string           `json:"creator"`
	DateCreated             *time.Time        `json:"dateCreated"`
	DesiredAvailable        *int64            `json:"desiredAvailable"`
	DoneDate                *time.Time        `json:"doneDate"`
	DownloadDir             *string           `json:"downloadDir"`
	DownloadedEver          *int64            `json:"downloadedEver"`
	DownloadLimit           *int64            `json:"downloadLimit"`
	DownloadLimited         *bool             `json:"downloadLimited"`
	EditDate                *time.Time        `json:"editDate"`
	Error                   *int64            `json:"error"`
	ErrorString             *string           `json:"errorString"`
	ETA                     *int64            `json:"eta"`
	ETAIdle                 *int64            `json:"etaIdle"`
	FileCount               *int64            `json:"file-count"` // RPC v17
	Files                   []TorrentFile     `json:"files"`
	FileStats               []TorrentFileStat `json:"fileStats"`
	Group                   *string           `json:"group"` // RPC v17
	HashString              *string           `json:"hashString"`
	HaveUnchecked           *int64            `json:"haveUnchecked"`
	HaveValid               *int64            `json:"haveValid"`
	HonorsSessionLimits     *bool             `json:"honorsSessionLimits"`
	ID                      *int64            `json:"id"`
	IsFinished              *bool             `json:"isFinished"`
	IsPrivate               *bool             `json:"isPrivate"`
	IsStalled               *bool             `json:"isStalled"`
	Labels                  []string          `json:"labels"` // RPC v16
	LeftUntilDone           *int64            `json:"leftUntilDone"`
	MagnetLink              *string           `json:"magnetLink"`
	ManualAnnounceTime      *int64            `json:"manualAnnounceTime"`
	MaxConnectedPeers       *int64            `json:"maxConnectedPeers"`
	MetadataPercentComplete *float64          `json:"metadataPercentComplete"`
	Name                    *string           `json:"name"`
	PeerLimit               *int64            `json:"peer-limit"`
	Peers                   []Peer            `json:"peers"`
	PeersConnected          *int64            `json:"peersConnected"`
	PeersFrom               *TorrentPeersFrom `json:"peersFrom"`
	PeersGettingFromUs      *int64            `json:"peersGettingFromUs"`
	PeersSendingToUs        *int64            `json:"peersSendingToUs"`
	PercentComplete         *float64          `json:"percentComplete"` // RPC v17
	PercentDone             *float64          `json:"percentDone"`
	Pieces                  *string           `json:"pieces"`
	PieceCount              *int64            `json:"pieceCount"`
	PieceSize               *cunits.Bits      `json:"PieceSize"`
	Priorities              []int64           `json:"priorities"`
	PrimaryMimeType         *string           `json:"primary-mime-type"` // RPC v17
	QueuePosition           *int64            `json:"queuePosition"`
	RateDownload            *int64            `json:"rateDownload"` // B/s
	RateUpload              *int64            `json:"rateUpload"`   // B/s
	RecheckProgress         *float64          `json:"recheckProgress"`
	TimeDownloading         *time.Duration    `json:"secondsDownloading"`
	TimeSeeding             *time.Duration    `json:"secondsSeeding"`
	SeedIdleLimit           *time.Duration    `json:"seedIdleLimit"`
	SeedIdleMode            *int64            `json:"seedIdleMode"`
	SeedRatioLimit          *float64          `json:"seedRatioLimit"`
	SeedRatioMode           *SeedRatioMode    `json:"seedRatioMode"`
	SizeWhenDone            *cunits.Bits      `json:"sizeWhenDone"`
	StartDate               *time.Time        `json:"startDate"`
	Status                  *TorrentStatus    `json:"status"`
	Trackers                []Tracker         `json:"trackers"`
	TrackerList             *string           `json:"trackerList"`
	TrackerStats            []TrackerStats    `json:"trackerStats"`
	TotalSize               *cunits.Bits      `json:"totalSize"`
	TorrentFile             *string           `json:"torrentFile"`
	UploadedEver            *int64            `json:"uploadedEver"`
	UploadLimit             *int64            `json:"uploadLimit"`
	UploadLimited           *bool             `json:"uploadLimited"`
	UploadRatio             *float64          `json:"uploadRatio"`
	Wanted                  []bool            `json:"wanted"`
	WebSeeds                []string          `json:"webseeds"`
	WebSeedsSendingToUs     *int64            `json:"webseedsSendingToUs"`
}

Torrent represents all the possible fields of data for a torrent. All fields are pointers to detect if the value is nil (field not requested) or real default value.

func (*Torrent) ConvertDownloadSpeed 

func (t *Torrent) ConvertDownloadSpeed() (speed cunits.Bits)

ConvertDownloadSpeed will return the download speed as cunits.Bits/second

func (*Torrent) ConvertUploadSpeed 

func (t *Torrent) ConvertUploadSpeed() (speed cunits.Bits)

ConvertUploadSpeed will return the upload speed as cunits.Bits/second

func (Torrent) MarshalJSON 

func (t Torrent) MarshalJSON() (data []byte, err error)

MarshalJSON allows to convert back golang values to original payload values.

func (*Torrent) UnmarshalJSON 

func (t *Torrent) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON allows to convert timestamps to golang time.Time values.

type TorrentAddPayload 

type TorrentAddPayload struct {
	Cookies           *string  `json:"cookies"`           // pointer to a string of one or more cookies
	DownloadDir       *string  `json:"download-dir"`      // path to download the torrent to
	Filename          *string  `json:"filename"`          // filename or URL of the .torrent file
	Labels            []string `json:"labels"`            // Labels for the torrent
	MetaInfo          *string  `json:"metainfo"`          // base64-encoded .torrent content
	Paused            *bool    `json:"paused"`            // if true, don't start the torrent
	PeerLimit         *int64   `json:"peer-limit"`        // maximum number of peers
	BandwidthPriority *int64   `json:"bandwidthPriority"` // torrent's bandwidth tr_priority_t
	FilesWanted       []int64  `json:"files-wanted"`      // indices of file(s) to download
	FilesUnwanted     []int64  `json:"files-unwanted"`    // indices of file(s) to not download
	PriorityHigh      []int64  `json:"priority-high"`     // indices of high-priority file(s)
	PriorityLow       []int64  `json:"priority-low"`      // indices of low-priority file(s)
	PriorityNormal    []int64  `json:"priority-normal"`   // indices of normal-priority file(s)
}

TorrentAddPayload represents the data to send in order to add a torrent.

func (TorrentAddPayload) MarshalJSON 

func (tap TorrentAddPayload) MarshalJSON() (data []byte, err error)

MarshalJSON allows to marshall into JSON only the non nil fields. It differs from 'omitempty' which also skip default values (as 0 or false which can be valid here).

type TorrentFile 

type TorrentFile struct {
	BytesCompleted int64  `json:"bytesCompleted"`
	Length         int64  `json:"length"`
	Name           string `json:"name"`
}

TorrentFile represent one file from a Torrent.

type TorrentFileStat 

type TorrentFileStat struct {
	BytesCompleted int64 `json:"bytesCompleted"`
	Wanted         bool  `json:"wanted"`
	Priority       int64 `json:"priority"`
}

TorrentFileStat represents the metadata of a torrent's file.

type TorrentPeersFrom 

type TorrentPeersFrom struct {
	FromCache    int64 `json:"fromCache"`
	FromDHT      int64 `json:"fromDht"`
	FromIncoming int64 `json:"fromIncoming"`
	FromLPD      int64 `json:"fromLpd"`
	FromLTEP     int64 `json:"fromLtep"`
	FromPEX      int64 `json:"fromPex"`
	FromTracker  int64 `json:"fromTracker"`
}

TorrentPeersFrom represents the peers statistics of a torrent.

type TorrentRemovePayload 

type TorrentRemovePayload struct {
	IDs             []int64 `json:"ids"`
	DeleteLocalData bool    `json:"delete-local-data"`
}

TorrentRemovePayload holds the torrent id(s) to delete with a data deletion flag.

type TorrentSetPayload 

type TorrentSetPayload struct {
	BandwidthPriority   *int64         `json:"bandwidthPriority"`   // this torrent's bandwidth tr_priority_t
	DownloadLimit       *int64         `json:"downloadLimit"`       // maximum download speed (KBps)
	DownloadLimited     *bool          `json:"downloadLimited"`     // true if "downloadLimit" is honored
	FilesWanted         []int64        `json:"files-wanted"`        // indices of file(s) to download
	FilesUnwanted       []int64        `json:"files-unwanted"`      // indices of file(s) to not download
	Group               *string        `json:"group"`               // bandwidth group to add torrent to
	HonorsSessionLimits *bool          `json:"honorsSessionLimits"` // true if session upload limits are honored
	IDs                 []int64        `json:"ids"`                 // torrent list
	Labels              []string       `json:"labels"`              // RPC v16: strings of user-defined labels
	Location            *string        `json:"location"`            // new location of the torrent's content
	PeerLimit           *int64         `json:"peer-limit"`          // maximum number of peers
	PriorityHigh        []int64        `json:"priority-high"`       // indices of high-priority file(s)
	PriorityLow         []int64        `json:"priority-low"`        // indices of low-priority file(s)
	PriorityNormal      []int64        `json:"priority-normal"`     // indices of normal-priority file(s)
	QueuePosition       *int64         `json:"queuePosition"`       // position of this torrent in its queue [0...n)
	SeedIdleLimit       *time.Duration `json:"-"`                   // torrent-level number of minutes of seeding inactivity
	SeedIdleMode        *int64         `json:"seedIdleMode"`        // which seeding inactivity to use
	SeedRatioLimit      *float64       `json:"seedRatioLimit"`      // torrent-level seeding ratio
	SeedRatioMode       *SeedRatioMode `json:"seedRatioMode"`       // which ratio mode to use
	TrackerList         []string       `json:"-"`                   // string of announce URLs, one per line, and a blank line between tiers
	UploadLimit         *int64         `json:"uploadLimit"`         // maximum upload speed (KBps)
	UploadLimited       *bool          `json:"uploadLimited"`       // true if "uploadLimit" is honored
}

TorrentSetPayload contains all the mutators appliable on one torrent.

func (TorrentSetPayload) MarshalJSON 

func (tsp TorrentSetPayload) MarshalJSON() (data []byte, err error)

MarshalJSON allows to marshall into JSON only the non nil fields. It differs from 'omitempty' which also skip default values (as 0 or false which can be valid here).

type TorrentStatus 

type TorrentStatus int64

TorrentStatus binds torrent status to a status code 

const (
	// TorrentStatusStopped represents a stopped torrent
	TorrentStatusStopped TorrentStatus = 0
	// TorrentStatusCheckWait represents a torrent queued for files checking
	TorrentStatusCheckWait TorrentStatus = 1
	// TorrentStatusCheck represents a torrent which files are currently checked
	TorrentStatusCheck TorrentStatus = 2
	// TorrentStatusDownloadWait represents a torrent queue to download
	TorrentStatusDownloadWait TorrentStatus = 3
	// TorrentStatusDownload represents a torrent currently downloading
	TorrentStatusDownload TorrentStatus = 4
	// TorrentStatusSeedWait represents a torrent queued to seed
	TorrentStatusSeedWait TorrentStatus = 5
	// TorrentStatusSeed represents a torrent currently seeding
	TorrentStatusSeed TorrentStatus = 6
	// TorrentStatusIsolated represents a torrent which can't find peers
	TorrentStatusIsolated TorrentStatus = 7
)

func (TorrentStatus) GoString 

func (status TorrentStatus) GoString() string

GoString implements the GoStringer interface from the stdlib fmt package

func (TorrentStatus) String 

func (status TorrentStatus) String() string

type Tracker 

type Tracker struct {
	Announce string `json:"announce"`
	ID       int64  `json:"id"`
	Scrape   string `json:"scrape"`
	SiteName string `json:"sitename"`
	Tier     int64  `json:"tier"`
}

Tracker represent the base data of a torrent's tracker.

type TrackerStats 

type TrackerStats struct {
	Announce              string    `json:"announce"`
	AnnounceState         int64     `json:"announceState"`
	DownloadCount         int64     `json:"downloadCount"`
	HasAnnounced          bool      `json:"hasAnnounced"`
	HasScraped            bool      `json:"hasScraped"`
	Host                  string    `json:"host"`
	ID                    int64     `json:"id"`
	IsBackup              bool      `json:"isBackup"`
	LastAnnouncePeerCount int64     `json:"lastAnnouncePeerCount"`
	LastAnnounceResult    string    `json:"lastAnnounceResult"`
	LastAnnounceStartTime time.Time `json:"-"`
	LastAnnounceSucceeded bool      `json:"lastAnnounceSucceeded"`
	LastAnnounceTime      time.Time `json:"-"`
	LastAnnounceTimedOut  bool      `json:"lastAnnounceTimedOut"`
	LastScrapeResult      string    `json:"lastScrapeResult"`
	LastScrapeStartTime   time.Time `json:"-"`
	LastScrapeSucceeded   bool      `json:"lastScrapeSucceeded"`
	LastScrapeTime        time.Time `json:"-"`
	LastScrapeTimedOut    bool      `json:"-"` // should be boolean but number. Will be converter in UnmarshalJSON
	LeecherCount          int64     `json:"leecherCount"`
	NextAnnounceTime      time.Time `json:"-"`
	NextScrapeTime        time.Time `json:"-"`
	Scrape                string    `json:"scrape"`
	ScrapeState           int64     `json:"scrapeState"`
	SiteName              string    `json:"sitename"`
	SeederCount           int64     `json:"seederCount"`
	Tier                  int64     `json:"tier"`
}

TrackerStats represent the extended data of a torrent's tracker.

func (TrackerStats) MarshalJSON 

func (ts TrackerStats) MarshalJSON() (data []byte, err error)

MarshalJSON allows to convert back golang values to original payload values.

func (*TrackerStats) UnmarshalJSON 

func (ts *TrackerStats) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON allows to convert timestamps to golang time.Time values.

type TransmissionFreeSpace 

type TransmissionFreeSpace struct {
	Path      string `json:"path"`
	Size      int64  `json:"size-bytes"`
	TotalSize int64  `json:"total_size"` // RPC v17
}

TransmissionFreeSpace represents the freespace available in bytes for a specific path.

type Units 

type Units struct {
	SpeedUnits  []string `json:"speed-units"`  // 4 strings: KB/s, MB/s, GB/s, TB/s
	SpeedBytes  int64    `json:"speed-bytes"`  // number of bytes in a KB (1000 for kB; 1024 for KiB)
	SizeUnits   []string `json:"size-units"`   // 4 strings: KB/s, MB/s, GB/s, TB/s
	SizeBytes   int64    `json:"size-bytes"`   // number of bytes in a KB (1000 for kB; 1024 for KiB)
	MemoryUnits []string `json:"memory-units"` // 4 strings: KB/s, MB/s, GB/s, TB/s
	MemoryBytes int64    `json:"memory-bytes"` // number of bytes in a KB (1000 for kB; 1024 for KiB)
}

Units is subset of SessionArguments.

func (*Units) GetMemory 

func (u *Units) GetMemory() (memory cunits.Bits)

GetMemory returns the memory in a handy format

func (*Units) GetSize 

func (u *Units) GetSize() (size cunits.Bits)

GetSize returns the size in a handy format

func (*Units) GetSpeed 

func (u *Units) GetSpeed() (speed cunits.Bits)

GetSpeed returns the speed in a handy format

Source Files

View all Source files

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.