utils

package
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Feb 15, 2021 License: Apache-2.0 Imports: 19 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// DefaultFilePermissions specifies that the user can
	// read and write the file.
	DefaultFilePermissions = 0600

	// AllFilePermissions specifies anyone can do anything
	// to the file.
	AllFilePermissions = 0777

	// NanosecondsInMillisecond is the number
	// of nanoseconds in a millisecond.
	NanosecondsInMillisecond = 1000000

	// MillisecondsInSecond is the number
	// of milliseconds in a second.
	MillisecondsInSecond = 1000

	// OneHundred is the number 100.
	OneHundred = 100
)
View Source 
const (
	// DefaultShards is the default number of shards
	// to use in ShardedMap.
	DefaultShards = 256
)

Variables

View Source 
var (
	// ErrNetworkNotSupported is returned when the network
	// you are attempting to connect to is not supported.
	ErrNetworkNotSupported = errors.New("network not supported")

	// OneHundredInt is a big.Int of value 100.
	OneHundredInt = big.NewInt(OneHundred)

	// ZeroInt is a big.Int of value 0.
	ZeroInt = big.NewInt(0)
)

Functions

func AtTip 

func AtTip(
	tipDelay int64,
	blockTimestamp int64,
) bool

AtTip returns a boolean indicating if a block timestamp is within tipDelay from the current time.

func BigPow10 

func BigPow10(e int32) *big.Float

BigPow10 computes the value of 10^e. Inspired by: https://steemit.com/tutorial/@gopher23/power-and-root-functions-using-big-float-in-golang

func BtoMb 

func BtoMb(b float64) float64

BtoMb converts B to MB.

func CheckAtTip 

func CheckAtTip(
	ctx context.Context,
	networkIdentifier *types.NetworkIdentifier,
	helper FetcherHelper,
	tipDelay int64,
) (bool, error)

CheckAtTip returns a boolean indicating if a Rosetta implementation is at tip.

func CheckNetworkSupported 

func CheckNetworkSupported(
	ctx context.Context,
	networkIdentifier *types.NetworkIdentifier,
	helper FetcherHelper,
) (*types.NetworkStatusResponse, error)

CheckNetworkSupported checks if a Rosetta implementation supports a given *types.NetworkIdentifier. If it does, the current network status is returned.

func ContainsAccountIdentifier 

func ContainsAccountIdentifier(arr []*types.AccountIdentifier, s *types.AccountIdentifier) bool

ContainsAccountIdentifier returns a boolean indicating whether the struct s is in arr.

func ContainsString 

func ContainsString(arr []string, s string) bool

ContainsString returns a boolean indicating whether the string s is in arr.

func ContextSleep 

func ContextSleep(ctx context.Context, duration time.Duration) error

ContextSleep sleeps for the provided duration and returns an error if context is canceled.

func CreateCommandPath 

func CreateCommandPath(
	dataDirectory string,
	cmd string,
	network *types.NetworkIdentifier,
) (string, error)

CreateCommandPath creates a unique path for a command and network within a data directory. This is used to avoid collision when using multiple commands on multiple networks when the same storage resources are used. If the derived path does not exist, we run os.MkdirAll on the path.

func CreateTempDir 

func CreateTempDir() (string, error)

CreateTempDir creates a directory in /tmp for usage within testing.

func CurrencyBalance 

func CurrencyBalance(
	ctx context.Context,
	network *types.NetworkIdentifier,
	helper FetcherHelper,
	account *types.AccountIdentifier,
	currency *types.Currency,
	index int64,
) (*types.Amount, *types.BlockIdentifier, error)

CurrencyBalance returns the balance of an account for a particular currency at a particular height. It is up to the caller to determine if the retrieved block has the expected hash for the requested index.

func EnsurePathExists 

func EnsurePathExists(path string) error

EnsurePathExists creates directories along a path if they do not exist.

func Equal 

func Equal(a interface{}, b interface{}) bool

Equal returns a boolean indicating if two interfaces are equal.

func LoadAndParse 

func LoadAndParse(filePath string, output interface{}) error

LoadAndParse reads the file at the provided path and attempts to unmarshal it into output.

func Milliseconds 

func Milliseconds() int64

Milliseconds gets the current time in milliseconds.

func PrettyAmount 

func PrettyAmount(amount *big.Int, currency *types.Currency) string

PrettyAmount returns a currency amount in native format with its symbol.

func RandomNumber 

func RandomNumber(minimum *big.Int, maximum *big.Int) *big.Int

RandomNumber returns some number in the range [minimum, maximum). Source: https://golang.org/pkg/crypto/rand/#Int

func RemoveTempDir 

func RemoveTempDir(dir string)

RemoveTempDir deletes a directory at a provided path for usage within testing.

func SerializeAndWrite 

func SerializeAndWrite(filePath string, object interface{}) error

SerializeAndWrite attempts to serialize the provided object into a file at filePath.

func SizeOf 

func SizeOf(v interface{}) int

SizeOf returns the size of 'v' in bytes. If there is an error during calculation, Of returns -1.

func TimeToTip 

func TimeToTip(
	blocksPerSecond float64,
	lastSyncedIndex int64,
	tipIndex int64,
) time.Duration

TimeToTip returns the estimate time to tip given the current sync speed.

func Zero 

func Zero() *big.Float

Zero returns a float with 256 bit precision.

Types

type AccountBalance 

type AccountBalance struct {
	Account *types.AccountIdentifier
	Amount  *types.Amount
	Coins   []*types.Coin
	Block   *types.BlockIdentifier
}

AccountBalance defines an account's balance, including either balance or coins, as well as the block which this balance was fetched at.

func GetAccountBalances 

func GetAccountBalances(
	ctx context.Context,
	fetcher FetcherHelper,
	balanceRequests []*AccountBalanceRequest,
) ([]*AccountBalance, error)

GetAccountBalances returns an array of AccountBalances for an array of AccountBalanceRequests

type AccountBalanceRequest 

type AccountBalanceRequest struct {
	Account  *types.AccountIdentifier
	Network  *types.NetworkIdentifier
	Currency *types.Currency
}

AccountBalanceRequest defines the required information to get an account's balance.

type BST 

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

BST is an implementation of a binary search tree.

func (*BST) Delete 

func (t *BST) Delete(key int64)

Delete removes the key from the BST.

func (*BST) Empty 

func (t *BST) Empty() bool

Empty returns a boolean indicating if there are any nodes in the BST.

func (*BST) Get 

func (t *BST) Get(key int64) *Node

Get gets the key in the BST and returns its representative node (so that modifications can be done in constant time).

func (*BST) Min 

func (t *BST) Min() *Node

Min returns the smallest node in the BST.

func (*BST) Set 

func (t *BST) Set(key int64, value int)

Set stores the key and value in the BST

type FetcherHelper 

type FetcherHelper interface {
	NetworkList(
		ctx context.Context,
		metadata map[string]interface{},
	) (*types.NetworkListResponse, *fetcher.Error)

	NetworkStatusRetry(
		ctx context.Context,
		network *types.NetworkIdentifier,
		metadata map[string]interface{},
	) (*types.NetworkStatusResponse, *fetcher.Error)

	AccountBalanceRetry(
		ctx context.Context,
		network *types.NetworkIdentifier,
		account *types.AccountIdentifier,
		block *types.PartialBlockIdentifier,
		currencies []*types.Currency,
	) (*types.BlockIdentifier, []*types.Amount, map[string]interface{}, *fetcher.Error)
}

FetcherHelper is used by util functions to mock Fetcher

type MemoryUsage 

type MemoryUsage struct {
	Heap               float64 `json:"heap"`
	Stack              float64 `json:"stack"`
	OtherSystem        float64 `json:"other_system"`
	System             float64 `json:"system"`
	GarbageCollections uint32  `json:"garbage_collections"`
}

MemoryUsage contains memory usage stats converted to MBs.

func MonitorMemoryUsage 

func MonitorMemoryUsage(
	ctx context.Context,
	maxHeapUsage int,
) *MemoryUsage

MonitorMemoryUsage returns a collection of memory usage stats in MB. It will also run garbage collection if the heap is greater than maxHeapUsage in MB.

type MutexMap 

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

MutexMap is a struct that allows for acquiring a *PriorityMutex via a string identifier or for acquiring a global mutex that blocks the acquisition of any identifier mutexes.

This is useful for coordinating concurrent, non-overlapping writes in the storage package.

func NewMutexMap 

func NewMutexMap(shards int) *MutexMap

NewMutexMap returns a new *MutexMap.

func (*MutexMap) GLock 

func (m *MutexMap) GLock()

GLock acquires an exclusive lock across an entire *MutexMap.

func (*MutexMap) GUnlock 

func (m *MutexMap) GUnlock()

GUnlock releases an exclusive lock held for an entire *MutexMap.

func (*MutexMap) Lock 

func (m *MutexMap) Lock(identifier string, priority bool)

Lock acquires a lock for a particular identifier, as long as no other caller has the global mutex or a lock by the same identifier.

func (*MutexMap) Unlock 

func (m *MutexMap) Unlock(identifier string)

Unlock releases a lock held for a particular identifier.

type Node 

type Node struct {
	Key   int64
	Value int
	// contains filtered or unexported fields
}

Node is a Node in a BST

type PriorityMutex 

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

PriorityMutex is a special type of mutex that allows callers to request priority over other callers. This can be useful if there is a "hot path" in an application that requires lock access.

WARNING: It is possible to cause lock starvation if not careful (i.e. only high priority callers ever do work).

func (*PriorityMutex) Lock 

func (m *PriorityMutex) Lock(priority bool)

Lock attempts to acquire either a high or low priority mutex. When priority is true, a lock will be granted before other low priority callers.

func (*PriorityMutex) Unlock 

func (m *PriorityMutex) Unlock()

Unlock selects the next highest priority lock to grant. If there are no locks to grant, it sets the value of m.lock to false.

type ShardedMap 

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

ShardedMap allows concurrent writes to a map by sharding the map into some number of independently locked subsections.

func NewShardedMap 

func NewShardedMap(shards int) *ShardedMap

NewShardedMap creates a new *ShardedMap with some number of shards. The larger the number provided for shards, the less lock contention there will be.

As a rule of thumb, shards should usually be set to the concurrency of the caller.

func (*ShardedMap) Lock 

func (m *ShardedMap) Lock(key string, priority bool) map[string]interface{}

Lock acquires the lock for a shard that could contain the key. This syntax allows the caller to perform multiple operations while holding the lock for a single shard.

func (*ShardedMap) Unlock 

func (m *ShardedMap) Unlock(key string)

Unlock releases the lock for a shard that could contain the key.

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.