holochain

package module
v0.1.0-alpha-26 Latest Latest
Warning

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

 Go to latest Published: Jun 13, 2018 License: GPL-3.0 Imports: 61 Imported by: 9

README

Holochain

Code Status Travis Codecov Go Report Card In Progress Twitter Follow

Holographic storage for distributed applications. A holochain is a monotonic distributed hash table (DHT) where every node enforces validation rules on data before publishing that data against the signed chains where the data originated.

In other words, a holochain functions very much like a blockchain without bottlenecks when it comes to enforcing validation rules, but is designed to be fully distributed with each node only needing to hold a small portion of the data instead of everything needing a full copy of a global ledger. This makes it feasible to run blockchain-like applications on devices as lightweight as mobile phones.

Code Status: Alpha. Not for production use. The code has not yet undergone a security audit. We expect to destructively restructure code APIs and data chains until Beta. Proof-of-concept was unveiled at our first hackathon (March 2017). Alpha 0 was released October 2017. Alpha 1 was released May 2018.

Holochain Links: FAQ Developer Wiki White Paper GoDocs

Table of Contents

Installation

Developers Only: At this stage, holochain is only for use by developers (either developers of applications to run on holochains, or developers of the holochain software itself). App developers should bundle their app in an installer as either approach below is not for non-technical folks.

There are two approaches to installing holochain:

  1. as a standard Go language application for direct execution on your machine
  2. using docker for execution in a container.

Which you choose depends on your preference and your purpose. If you intend to develop holochain applications, then you should almost certainly use the docker approach as we provide a testing harness for running multiple holochain instances in a docker cluster. If you will be developing in Go on holochain itself then you will probably end up doing both.

Go Based Install
Unix

(Unix includes macOS and Linux.)

  1. Download Go. Download the "Archive" or "Installer" for version 1.8 or later for your CPU and OS. The "Source" download does not contain an executable and step 3 will fail.

  2. Install Go on your system. See platform specific instructions and hints below for making this work.

  3. Setup your path (Almost all installation problems that have been reported stem from skipping this step.)

    • Export the $GOPATH variable in your shell profile.
    • Add $GOPATH/bin to your $PATH in your shell profile.

    For example, add the following to the end of your shell profile (usually ~/.bashrc or ~/.bash_profile):

        export GOPATH="$HOME/go"
        export PATH="$GOPATH/bin:$PATH"
  1. Install the command line tool suite with:
$ go get -d -v github.com/holochain/holochain-proto
$ cd $GOPATH/src/github.com/holochain/holochain-proto
$ make
  1. Test that it works (should look something like this):
$ hcadmin -v
hcadmin version 0.0.x (holochain y)
Windows

First you'll need to install some necessary programs if you don't already have them.

  • Download Go. Download the "Archive" or "Installer" for version 1.8 or later for Windows and your CPU. The "Source" download does not contain an executable.
  • Install Windows git. Be sure to select the appropriate options so that git is accessible from the Windows command line.
  • Optional: Install GnuWin32 make.

Next, in your Control Panel, select System>Advanced system settings>Environment Variables... and under System Variables do the following:

  1. Add a new entry with the name GOPATH and the value %USERPROFILE%\go (Or your Go workspace folder).
  2. Double-click Path, and in the window that pops up add the following entries:
    • %GOPATH%\bin
    • C:\Go\bin (Or wherever you installed Go to+\bin).
    • C:\Program Files (x86)\GnuWin32\bin (Or wherever you installed GnuWin32 make to+\bin).
Docker Based Install

Using docker, you don't have to install Go first. Our docker scripts manage installation of Go, holochain dependencies and holochain. The docker installation can run alongside Local ("Go") installation of holochain, sharing config directories. See docker usage on our wiki for more on how this works.

  1. Install the latest version of Docker on your machine

    1. Docker Installation. The Community edition; stable is sufficient.
    2. See Docker Getting Started for help.
    3. It is recommended to add your user to the docker group as in: Post Installation Steps, rather than use sudo before all script commands. Holochain Apps cannot exploit the kinds of security concerns mentioned in the Post Installation Steps document.  

  2. Confirm that docker installation and permissions are working by running:

    	$ docker info

  3. Pull our holochain image from docker hub:

    	$ docker pull holochain/holochain-proto:develop

  4. To run holochain in your new environment, suitable to continue the walkthrough below in usage

    	$ docker run --rm -it --name clutter -p 3141:3141 holochain/holochain-proto:develop

  5. This will put you into an new command shell that may behave differently than what you're used to. To exit this holochain (Alpine) shell, press Ctrl-D or type exit

Usage

These instructions are for using the holochain command line tool suite: hcadmin, hcdev and hcd. They should work equally well for Go based or docker based installation.

(Note that since Holochain is intended to be used behind distributed applications, end users should not have to do much through the command or may not have it installed at all, as the application will probably have wrapped up the holochain library internally.)

Each of the tools includes a help command, e.g., run hcadmin help or for sub-commands run hcadmin <COMMAND> help. For more detailed information, see the wiki page

The tool suite include these commands:

  • hcadmin for administering your installed holochain applications
  • hcd for running and serving a holochain application
  • hcdev for developing and testing holochain applications
Getting Started

The instructions below walk you through the basic steps necessary to run a holochain application.

Initializing the Holochain environment
	$ hcadmin init 'your@emailaddress.here'

This command creates a ~/.holochain directory for storing all chain data, along with initial public/private key pairs based on the identity string provided as the second argument.

Joining a Holochain

You can use the hcadmin tool to join a pre-existing Holochain application by running the following command (replacing SOURCE_PATH with a path to an application's DNA and CHAIN_NAME with the name you'd like it to be stored as).

For example: hcadmin join ./examples/chat chat

Note: this command will be replaced by a package management command still in development.

Running a Holochain

Holochains run and serve their UI via local web sockets. This allows interface developers lots of freedom to build HTML/JavaScript files and drop them in that chain's UI directory. You start a holochain and activate it's UI with the hcd command:

$ hcd <CHAIN_NAME> [PORT]
Developing a Holochain

The hcdev tool allows you to:

  1. generate new holochain application source files by cloning from an existing application, from a package file, or a simple empty template.
  2. run stand-alone or multi-node scenario tests
  3. run a holochain and serve it's UI for testing purposes
  4. dump out chain and dht data for inspection

Please see the docs for more detailed documentation.

Note that the hcdev command creates a separate ~/.holochaindev directory for serving and managing chains, so your dev work won't interfere with any running holochain apps you may be using.

Test-driven Application Development

We have designed Holochain around test-driven development, so the DNA should contain tests to confirm that the rest of the DNA is functional. Our testing harness includes two types of testing, stand-alone and multi-instance scenarios. Stand-alone tests allow you to tests the functions you create in your application. However, testing a distributed application requires being able to spin up many instances of it and have them interact. Our docker cluster testing harness automates that process, and enables app developers to specify scenarios and roles and test instructions to run on multiple docker containers.

Please see the App Testing documentation for details.

File Locations

By default holochain data and configuration files are assumed to be stored in the ~/.holochain directory. You can override this with the -path flag or by setting the HOLOPATH environment variable, e.g.:

$ hcadmin -path ~/mychains init '<my@other.identity>'
$ HOLOPATH=~/mychains hcadmin

You can use the form: hcadmin -path=/your/path/here but you must use the absolute path, as shell substitutions will not happen.

Logging

All the commands take a --debug flag which will turn on a number of different kinds of debugging. For running chains, you can also control exactly which of these logging types you wish to see in the chain's config.json file. You can also set the HCDEBUG environment variable to 0 or 1 to temporarily override your settings to turn everything on or off. See also the Environment Variable documentation for more granular logging control.

Architecture Overview and Documentation

Architecture information and application developer documentation is in our developer.holochain.org.

You can also look through auto-generated reference API on GoDocs

Holochain Core Development

We accept Pull Requests and welcome your participation. Please make sure to include the issue number your branch names and use descriptive commit messages.

In Progress

Some helpful links:

Current Throughput graph:

Throughput Graph

Contribute

Contributors to this project are expected to follow our development protocols & practices.

Getting started

Once you have followed the basic "getting started" guide above you will have the CLI tools installed locally.

All the commands (hcadmin, hcd, hcdev, etc.) are built from the same repo:

$ cd $GOPATH/src/github.com/holochain/holochain-proto

Go will throw errors complaining about not being on the $GOPATH if you try to run make from a separate copy of the holochain-proto repository. If you want to contribute to Holochain core you must work in the repository created by Go.

The Makefile contains all the build commands for Holochain. If you make an update to a command you will need to rebuild it before the changes take effect at the command line.

E.g. After making an update to cmd/hcdev/hcdev.go run $ make hcdev then run $ hcdev as normal.

Dependencies

This project depends on various parts of libp2p, which uses the gx package manager. All of which will be automatically installed by make by following the setup instructions above.

The package manager rewrites files that are tracked by git to configure imports. Be careful not to commit the generated imports to git!

make work adds the imports to the repository and make pub reverts them.

Every make command should automatically add and remove imports for you. If a make command is leaving mess behind in the repo, please open a bug report.

If you want to use go commands directly (e.g. go test) then you need to run make work manually first and remember to make pub before committing any changes.

Tests

To compile and run all the tests:

$ cd $GOPATH/src/github.com/holochain/holochain-proto
$ make test

go test can be used instead of make test, but only after make work.

The docker setup runs tests automatically during builds.

License

Copyright (C) 2017, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.)

This program is free software: you can redistribute it and/or modify it under the terms of the license provided in the LICENSE file (GPLv3). This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Note: We are considering other 'looser' licensing options (like MIT license) but at this stage are using GPL while we're getting the matter sorted out.

Acknowledgements

  • MetaCurrency & Ceptr: Holochains are a sub-project of Ceptr which is a semantic, distributed computing platform under development by the MetaCurrency Project.  
  • Ian Grigg: Some of our initial plans for this architecture were inspired in 2006 by his paper about Triple Entry Accounting and his work on Ricardian Contracts.  
  • Juan Benet & the IPFS team: For all their work on IPFS, libp2p, and various cool tools like multihash, multiaddress, etc. We use libP2P library for our transport layer and kademlia dht.  
  • Crypto Pioneers And of course the people who paved the road before us by writing good crypto libraries and preaching the blockchain gospel. Back in 2008, nobody understood what we were talking about when we started sharing our designs. The main reason people want it now, is because blockchains have opened their eyes to the power of decentralized architectures.

Documentation

Overview

Copyright (C) 2013-2018, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.) Use of this source code is governed by GPLv3 found in the LICENSE file ----------------------------------------------------------------------------------------

Copyright (C) 2013-2018, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.) Use of this source code is governed by GPLv3 found in the LICENSE file ----------------------------------------------------------------------------------------

Copyright (C) 2013-2018, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.) Use of this source code is governed by GPLv3 found in the LICENSE file ----------------------------------------------------------------------------------------

Copyright (C) 2013-2018, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.) Use of this source code is governed by GPLv3 found in the LICENSE file ----------------------------------------------------------------------------------------

package holochain should be imported by go packages intending to create a UI for this holochain implementation.

An example of a package which imports holochain is https://github.com/holochain/holochain-proto/tree/master/cmd/hc

For information not found here see the wiki:

https://github.com/holochain/holochain-proto/wiki

or the repo:

https://github.com/holochain/holochain-proto

If you are here because you intend to develop an application built on holochain take a look at the App Developer sections of the wiki.

If you would like a description of the architecture/technical aspects of holochain look at those sections of the wiki.

Data integrity engine for distributed applications -- a validating monotonic DHT "backed" by authoritative hashchains for data provenance.

Copyright (C) 2013-2017, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.) Use of this source code is governed by GPLv3 found in the LICENSE file ----------------------------------------------------------------------------------------

This code is adapted from the libp2p project, specifically: https://github.com/libp2p/go-libp2p-kad-dht/notif.go

The ipfs use of kademlia is substantially different than that needed by holochain so we remove parts we don't need and add others.

Index

Constants

View Source 
const (
	HashArg = iota
	StringArg
	EntryArg // special arg type for entries, can be a string or a hash
	IntArg
	BoolArg
	MapArg
	ToStrArg // special arg type that converts anything to a string, used for the debug action
	ArgsArg  // special arg type for arguments passed to the call action
)

these constants define the argument types for actions, i.e. system functions callable from within nuclei

View Source 
const (
	DHTChangeOK = iota
	DHTChangeUnknownHashQueuedForRetry
)
View Source 
const (
	ValidationFailureBadPublicKeyFormat  = "bad public key format"
	ValidationFailureBadRevocationFormat = "bad revocation format"
)
View Source 
const (
	ChainMarshalFlagsNone            = 0x00
	ChainMarshalFlagsNoHeaders       = 0x01
	ChainMarshalFlagsNoEntries       = 0x02
	ChainMarshalFlagsOmitDNA         = 0x04
	ChainMarshalFlagsNoPrivate       = 0x08
	ChainMarshalPrivateEntryRedacted = "%%PRIVATE ENTRY REDACTED%%"
)
View Source 
const (
	GossipWithQueueSize = 10
	GossipPutQueueSize  = 1000
)
View Source 
const (
	SysEntryTypePrefix     = "%"
	VirtualEntryTypePrefix = "%%"

	DataFormatJSON    = "json"
	DataFormatString  = "string"
	DataFormatRawJS   = "js"
	DataFormatRawZygo = "zygo"

	Public  = "public"
	Partial = "partial"
	Private = "private"
)
View Source 
const (
	AgentEntryType   = SysEntryTypePrefix + "agent"
	AgentEntrySchema = `` /* 651-byte string literal not displayed */

)
View Source 
const (
	DelEntryType   = SysEntryTypePrefix + "del"
	DelEntrySchema = `` /* 466-byte string literal not displayed */

)
View Source 
const (
	DNAEntryType     = SysEntryTypePrefix + "dna"
	DataFormatSysDNA = "_DNA"
)
View Source 
const (
	// virtual entry type, not actually on the chain
	KeyEntryType = VirtualEntryTypePrefix + "key"

	DataFormatSysKey = "_key"
)
View Source 
const (
	MigrateEntryType = SysEntryTypePrefix + "migrate"
	// currently both to/from have the same schema
	MigrateEntrySchema = `` /* 731-byte string literal not displayed */

	// Type can only be one of two things... open or close
	MigrateEntryTypeClose = "close"
	MigrateEntryTypeOpen  = "open"
)
View Source 
const (
	// Version is the numeric version number of the holochain library
	Version int = 26

	// VersionStr is the textual version number of the holochain library
	VersionStr string = "26"

	// DefaultSendTimeout a time.Duration to wait by default for send to complete
	DefaultSendTimeout = 3000 * time.Millisecond
)
View Source 
const (
	AddLinkAction = ""
	DelLinkAction = "d"

	StatusDefault  = 0x00
	StatusLive     = 0x01
	StatusRejected = 0x02
	StatusDeleted  = 0x04
	StatusModified = 0x08
	StatusAny      = 0xFF

	StatusLiveVal     = "1"
	StatusRejectedVal = "2"
	StatusDeletedVal  = "4"
	StatusModifiedVal = "8"
	StatusAnyVal      = "255"

	SysTagReplacedBy = "__replacedBy"

	GetMaskDefault   = 0x00
	GetMaskEntry     = 0x01
	GetMaskEntryType = 0x02
	GetMaskSources   = 0x04
	GetMaskAll       = 0xFF

	GetMaskDefaultStr   = "0"
	GetMaskEntryStr     = "1"
	GetMaskEntryTypeStr = "2"
	GetMaskSourcesStr   = "4"
	GetMaskAllStr       = "255"
)
View Source 
const (
	ReceiptOK = iota
	ReceiptRejected
)
View Source 
const (
	JSRibosomeType = "js"

	ErrHandlingReturnErrorsStr = "returnErrorValue"
	ErrHandlingThrowErrorsStr  = "throwErrors"
)
View Source 
const (
	RetryingStopper = iota
	GossipingStopper
	BootstrappingStopper
	RefreshingStopper
	HoldingStopper
)
View Source 
const (
	ActionProtocol = iota
	ValidateProtocol
	GossipProtocol
	KademliaProtocol
)
View Source 
const (
	PeerTTL                       = time.Minute * 10
	DefaultRoutingRefreshInterval = time.Minute
	DefaultGossipInterval         = time.Second * 2
	DefaultHoldingCheckInterval   = time.Second * 30
)
View Source 
const (
	ErrUnknownCode = iota
	ErrHashNotFoundCode
	ErrHashDeletedCode
	ErrHashModifiedCode
	ErrHashRejectedCode
	ErrLinkNotFoundCode
	ErrEntryTypeMismatchCode
	ErrBlockedListedCode
)
View Source 
const (
	STRING_CALLING = "string"
	JSON_CALLING   = "json"

	// ZOME_EXPOSURE is the default and means the function is only exposed for use by other zomes in the app
	ZOME_EXPOSURE = ""
	// AUTHENTICATED_EXPOSURE means that the function is only available after authentication (TODO)
	AUTHENTICATED_EXPOSURE = "auth"
	// PUBLIC_EXPOSURE means that the function is callable by anyone
	PUBLIC_EXPOSURE = "public"

	ID_PROPERTY         = "_id"
	AGENT_ID_PROPERTY   = "_agent_id"
	AGENT_NAME_PROPERTY = "_agent_name"

	BridgeCaller    = 0
	BridgeCallee    = 1
	BridgeCallerStr = "0"
	BridgeCalleeStr = "1"

	BundleCancelReasonUserCancel = "userCancel"
	BundleCancelReasonTimeout    = "timeout"

	BundleCancelResponseOK     = ""
	BundleCancelResponseCommit = "commit"

	ValidationFailedErrMsg = "Validation Failed"
)
View Source 
const (
	DefaultDirectoryName string = ".holochain"  // Directory for storing config data
	ChainDataDir         string = "db"          // Sub-directory for all chain content files
	ChainDNADir          string = "dna"         // Sub-directory for all chain definition files
	ChainUIDir           string = "ui"          // Sub-directory for all chain user interface files
	ChainTestDir         string = "test"        // Sub-directory for all chain test files
	DNAFileName          string = "dna"         // Definition of the Holochain
	ConfigFileName       string = "config"      // Settings of the Holochain
	SysFileName          string = "system.conf" // Server & System settings
	AgentFileName        string = "agent.txt"   // User ID info
	PrivKeyFileName      string = "priv.key"    // Signing key - private
	StoreFileName        string = "chain.db"    // Filename for local data store
	DNAHashFileName      string = "dna.hash"    // Filename for storing the hash of the holochain
	DHTStoreFileName     string = "dht.db"      // Filname for storing the dht
	BridgeDBFileName     string = "bridge.db"   // Filname for storing bridge keys

	TestConfigFileName string = "_config.json"

	DefaultDHTPort         = 6283
	DefaultBootstrapServer = "bootstrap.holochain.net:10000"

	DefaultHashType HashType = HashType("sha2-256") // default hashing algo if not provided in DNA

	CloneWithNewUUID  = true
	CloneWithSameUUID = false
	InitializeDB      = true
	SkipInitializeDB  = false
)

System settings, directory, and file names

View Source 
const (
	SampleHTML = `` /* 821-byte string literal not displayed */

	SampleJS = `` /* 440-byte string literal not displayed */

	SampleBinary = `` /* 3713-byte string literal not displayed */

)
View Source 
const (
	OS_READ        = 04
	OS_WRITE       = 02
	OS_EX          = 01
	OS_USER_SHIFT  = 6
	OS_GROUP_SHIFT = 3
	OS_OTH_SHIFT   = 0

	OS_USER_R   = OS_READ << OS_USER_SHIFT
	OS_USER_W   = OS_WRITE << OS_USER_SHIFT
	OS_USER_X   = OS_EX << OS_USER_SHIFT
	OS_USER_RW  = OS_USER_R | OS_USER_W
	OS_USER_RWX = OS_USER_RW | OS_USER_X

	OS_GROUP_R   = OS_READ << OS_GROUP_SHIFT
	OS_GROUP_W   = OS_WRITE << OS_GROUP_SHIFT
	OS_GROUP_X   = OS_EX << OS_GROUP_SHIFT
	OS_GROUP_RW  = OS_GROUP_R | OS_GROUP_W
	OS_GROUP_RWX = OS_GROUP_RW | OS_GROUP_X

	OS_OTH_R   = OS_READ << OS_OTH_SHIFT
	OS_OTH_W   = OS_WRITE << OS_OTH_SHIFT
	OS_OTH_X   = OS_EX << OS_OTH_SHIFT
	OS_OTH_RW  = OS_OTH_R | OS_OTH_W
	OS_OTH_RWX = OS_OTH_RW | OS_OTH_X

	OS_ALL_R   = OS_USER_R | OS_GROUP_R | OS_OTH_R
	OS_ALL_W   = OS_USER_W | OS_GROUP_W | OS_OTH_W
	OS_ALL_X   = OS_USER_X | OS_GROUP_X | OS_OTH_X
	OS_ALL_RW  = OS_ALL_R | OS_ALL_W
	OS_ALL_RWX = OS_ALL_RW | OS_GROUP_X
)
View Source 
const (

	// PkgReqChain is the key who value is one of the PkgReqChainOptX masks
	PkgReqChain = "chain"

	// PkgReqEntryTypes is the key who value is an array of entry types to limit
	// the chain to
	PkgReqEntryTypes = "types"

	PkgReqChainOptNone       = 0x00
	PkgReqChainOptHeaders    = 0x01
	PkgReqChainOptEntries    = 0x02
	PkgReqChainOptFull       = 0x03
	PkgReqChainOptNoneStr    = "0"
	PkgReqChainOptHeadersStr = "1"
	PkgReqChainOptEntriesStr = "2"
	PkgReqChainOptFullStr    = "3"
)
View Source 
const (
	AppPackageVersion = "0.0.1"
)
View Source 
const (
	BasicTemplateAppPackageFormat = "yml"
)
View Source 
const (
	BlockedList = "blockedlist"
)
View Source 
const (
	BootstrapTTL = time.Minute * 5
)
View Source 
const (
	DataFormatLinks = "links"
)
View Source 
const (
	DefaultBundleTimeout = 5000
)
View Source 
const (
	DefaultRetryInterval = time.Millisecond * 500
)
View Source 
const (
	GossipBackPutDelay = 100 * time.Millisecond
)
View Source 
const (
	HeadersEntrySchema = `` /* 2953-byte string literal not displayed */

)
View Source 
const (
	HeadersEntryType = SysEntryTypePrefix + "header"
)
View Source 
const (
	HolochainErrorPrefix = "HolochainError"
)
View Source 
const (
	JSLibrary = `var HC={Version:` + `"` + VersionStr + "\"" +
		`SysEntryType:{` +
		`DNA:"` + DNAEntryType + `",` +
		`Agent:"` + AgentEntryType + `",` +
		`Key:"` + KeyEntryType + `",` +
		`Headers:"` + HeadersEntryType + `"` +
		`Del:"` + DelEntryType + `"` +
		`Migrate:"` + MigrateEntryType + `"` +
		`}` +
		`HashNotFound:null` +
		`,Status:{Live:` + StatusLiveVal +
		`,Rejected:` + StatusRejectedVal +
		`,Deleted:` + StatusDeletedVal +
		`,Modified:` + StatusModifiedVal +
		`,Any:` + StatusAnyVal +
		"}" +
		`,GetMask:{Default:` + GetMaskDefaultStr +
		`,Entry:` + GetMaskEntryStr +
		`,EntryType:` + GetMaskEntryTypeStr +
		`,Sources:` + GetMaskSourcesStr +
		`,All:` + GetMaskAllStr +
		"}" +
		`,LinkAction:{Add:"` + AddLinkAction + `",Del:"` + DelLinkAction + `"}` +
		`,PkgReq:{Chain:"` + PkgReqChain + `"` +
		`,ChainOpt:{None:` + PkgReqChainOptNoneStr +
		`,Headers:` + PkgReqChainOptHeadersStr +
		`,Entries:` + PkgReqChainOptEntriesStr +
		`,Full:` + PkgReqChainOptFullStr +
		"}" +
		"}" +
		`,Bridge:{Caller:` + BridgeCallerStr +
		`,Callee:` + BridgeCalleeStr +
		"}" +
		`,BundleCancel:{` +
		`Reason:{UserCancel:"` + BundleCancelReasonUserCancel +
		`",Timeout:"` + BundleCancelReasonTimeout +
		`"},Response:{OK:"` + BundleCancelResponseOK +
		`",Commit:"` + BundleCancelResponseCommit +
		`"}}` +
		`Migrate:{Close:"` + MigrateEntryTypeClose + `",Open:"` + MigrateEntryTypeOpen + `"}` +
		`};`
)
View Source 
const (
	LibP2P = iota
)
View Source 
const (
	MaxRetries = 10
)
View Source 
const (
	SelfRevocationType = iota
)
View Source 
const (
	TestingAppDecodingFormat = "json"
)
View Source 
const (
	ZygoLibrary = `(def HC_Version "` + VersionStr + `")` +
		`(def HC_HashNotFound nil)` +
		`(def HC_Status_Live ` + StatusLiveVal + ")" +
		`(def HC_Status_Rejected ` + StatusRejectedVal + ")" +
		`(def HC_Status_Deleted ` + StatusDeletedVal + ")" +
		`(def HC_Status_Modified ` + StatusModifiedVal + ")" +
		`(def HC_Status_Any ` + StatusAnyVal + ")" +
		`(def HC_GetMask_Default ` + GetMaskDefaultStr + ")" +
		`(def HC_GetMask_Entry ` + GetMaskEntryStr + ")" +
		`(def HC_GetMask_EntryType ` + GetMaskEntryTypeStr + ")" +
		`(def HC_GetMask_Sources ` + GetMaskSourcesStr + ")" +
		`(def HC_GetMask_All ` + GetMaskAllStr + ")" +

		`(def HC_Bridge_Caller ` + BridgeCallerStr + ")" +
		`(def HC_Bridge_Callee ` + BridgeCalleeStr + ")" +

		`(def HC_LinkAction_Add "` + AddLinkAction + "\")" +
		`(def HC_LinkAction_Del "` + DelLinkAction + "\")" +
		`(def HC_PkgReq_Chain "` + PkgReqChain + "\")" +
		`(def HC_PkgReq_ChainOpt_None "` + PkgReqChainOptNoneStr + "\")" +
		`(def HC_PkgReq_ChainOpt_Headers "` + PkgReqChainOptHeadersStr + "\")" +
		`(def HC_PkgReq_ChainOpt_Entries "` + PkgReqChainOptEntriesStr + "\")" +
		`(def HC_PkgReq_ChainOpt_Full "` + PkgReqChainOptFullStr + "\")" +

		`(def HC_Migrate_Close "` + MigrateEntryTypeClose + `")` +
		`(def HC_Migrate_Open "` + MigrateEntryTypeOpen + `")`
)

These are the zygo implementations of the library functions that must available in all Ribosome implementations.

View Source 
const (
	ZygoRibosomeType = "zygo"
)

Variables

View Source 
var AgentEntryDef = &EntryDef{Name: AgentEntryType, DataFormat: DataFormatJSON, Sharing: Public, Schema: AgentEntrySchema}
View Source 
var AlphaValue int = 3
View Source 
var BasicTemplateAppPackage string = `{
 # AppPackage Version
 # The app package schema version of this file.
"Version": "` + AppPackageVersion + `",
"Generator": "holochain",

"DNA": {
  # This is a holochain application package yaml definition. http://ceptr.org/projects/holochain

  # DNA File Version
  # Version indicator for changes to DNA
  "Version": 1,

  # DNA Unique ID
  # This ID differentiates your app from others. For example, to tell one Slack team from another with same code, so change it!
  "UUID": "00000000-0000-0000-0000-000000000000",

  # Application Name
  # What would you like to call your holochain app?
  "Name": "templateApp",

  # Requires Holochain Version
  # Version indicator for which minimal version of holochain is required by this DNA
  "RequiresVersion": ` + VersionStr + `,

  # Properties
  # Properties that you want available across all Zomes.
  "Properties": {

    # Application Description
    # Briefly describe your holochain app.
    "description": "provides an application template",

    # Language
    # The base (human) language of this holochain app.
    "language": "en"
  },

  # Properties Schema File
  # Describes the entries in the Properties section of your dna file.
  "PropertiesSchemaFile": "properties_schema.json",

  # DHT Settings
  # Configure the properties of your Distributed Hash Table (e.g. hash algorithm, neighborhood size, etc.).
  "DHTConfig": {
    "HashType": "sha2-256"
  },

  # Zomes
  # List the Zomes your application will support.
  "Zomes": [
    {

      # Zome Name
      # The name of this code module.
      "Name": "sampleZome",

      # Zome Description
      # What is the purpose of this module?
      "Description": "provide a sample zome",

      # Ribosome Type
      # What scripting language will you code in?
      "RibosomeType": "js",

      # Zome Entries
      # Data stored and tracked by your Zome.
      "Entries": [
        {
          "Name": "sampleEntry", # The name of this entry.
          "Required": true, # Is this entry required?
          "DataFormat": "json", # What type of data should this entry store?
          "Sharing": "public", # Should this entry be publicly accessible?
          "Schema": "{\n	\"title\": \"sampleEntry Schema\",\n	\"type\": \"object\",\n	\"properties\": {\n		\"content\": {\n			\"type\": \"string\"\n		},\n		\"timestamp\": {\n			\"type\": \"integer\"\n		}\n	},\n    \"required\": [\"content\", \"timestamp\"]\n}"
        }
      ],

      # Zome Functions
      # Functions which can be called in your Zome's API.
      "Functions": [
        {
          "Name": "sampleEntryCreate", # The name of this function.
          "CallingType": "json", # Data format for parameters passed to this function.
          "Exposure": "public" # Level to which is this function exposed.
        },
        {
          "Name": "sampleEntryRead", # The name of this function.
          "CallingType": "json", # Data format for parameters passed to this function.
          "Exposure": "public" # Level to which is this function exposed.
        },
        {
          "Name": "doSampleAction", # The name of this function.
          "CallingType": "json", # Data format for parameters passed to this function.
          "Exposure": "public" # Level to which is this function exposed.
        }
      ],

      # Zome Source Code
      # The logic that will control Zome behavior
      "Code": "/*******************************************************************************\n * Utility functions\n ******************************************************************************/\n\n/**\n * Is this a valid entry type?\n *\n * @param {any} entryType The data to validate as an expected entryType.\n * @return {boolean} true if the passed argument is a valid entryType.\n */\nfunction isValidEntryType (entryType) {\n  // Add additonal entry types here as they are added to dna.json.\n  return [\"sampleEntry\"].includes(entryType);\n}\n\n/**\n * Returns the creator of an entity, given an entity hash.\n *\n * @param  {string} hash The entity hash.\n * @return {string} The agent hash of the entity creator.\n */\nfunction getCreator (hash) {\n  return get(hash, { GetMask: HC.GetMask.Sources })[0];\n}\n\n/*******************************************************************************\n * Required callbacks\n ******************************************************************************/\n\n/**\n * System genesis callback: Can the app start?\n *\n * Executes just after the initial genesis entries are committed to your chain\n * (1st - DNA entry, 2nd Identity entry). Enables you specify any additional\n * operations you want performed when a node joins your holochain.\n *\n * @return {boolean} true if genesis is successful and so the app may start.\n *\n * @see https://developer.holochain.org/API#genesis\n */\nfunction genesis () {\n  return true;\n}\n\n/**\n * Validation callback: Can this entry be committed to a source chain?\n *\n * @param  {string} entryType Type of the entry as per DNA config for this zome.\n * @param  {string|object} entry Data with type as per DNA config for this zome.\n * @param  {Header-object} header Header object for this entry.\n * @param  {Package-object|null} pkg Package object for this entry, if exists.\n * @param  {string[]} sources Array of agent hashes involved in this commit.\n * @return {boolean} true if this entry may be committed to a source chain.\n *\n * @see https://developer.holochain.org/API#validateCommit_entryType_entry_header_package_sources\n * @see https://developer.holochain.org/Validation_Functions\n */\nfunction validateCommit (entryType, entry, header, pkg, sources) {\n  return isValidEntryType(entryType);\n}\n\n/**\n * Validation callback: Can this entry be committed to the DHT on any node?\n *\n * It is very likely that this validation routine should check the same data\n * integrity as validateCommit, but, as it happens during a different part of\n * the data life-cycle, it may require additional validation steps.\n *\n * This function will only get called on entry types with \"public\" sharing, as\n * they are the only types that get put to the DHT by the system.\n *\n * @param  {string} entryType Type of the entry as per DNA config for this zome.\n * @param  {string|object} entry Data with type as per DNA config for this zome.\n * @param  {Header-object} header Header object for this entry.\n * @param  {Package-object|null} pkg Package object for this entry, if exists.\n * @param  {string[]} sources Array of agent hashes involved in this commit.\n * @return {boolean} true if this entry may be committed to the DHT.\n *\n * @see https://developer.holochain.org/API#validatePut_entryType_entry_header_package_sources\n * @see https://developer.holochain.org/Validation_Functions\n */\nfunction validatePut (entryType, entry, header, pkg, sources) {\n  return validateCommit(entryType, entry, header, pkg, sources);\n}\n\n/**\n * Validation callback: Can this entry be modified?\n *\n * Validate that this entry can replace 'replaces' due to 'mod'.\n *\n * @param  {string} entryType Type of the entry as per DNA config for this zome.\n * @param  {string|object} entry Data with type as per DNA config for this zome.\n * @param  {Header-object} header Header object for this entry.\n * @param  {string} replaces The hash string of the entry being replaced.\n * @param  {Package-object|null} pkg Package object for this entry, if exists.\n * @param  {string[]} sources Array of agent hashes involved in this mod.\n * @return {boolean} true if this entry may replace 'replaces'.\n *\n * @see https://developer.holochain.org/API#validateMod_entryType_entry_header_replaces_package_sources\n * @see https://developer.holochain.org/Validation_Functions\n */\nfunction validateMod (entryType, entry, header, replaces, pkg, sources) {\n  return validateCommit(entryType, entry, header, pkg, sources)\n    // Only allow the creator of the entity to modify it.\n    && getCreator(header.EntryLink) === getCreator(replaces);\n}\n\n/**\n * Validation callback: Can this entry be deleted?\n *\n * @param  {string} entryType Name of the entry as per DNA config for this zome.\n * @param  {string} hash The hash of the entry to be deleted.\n * @param  {Package-object|null} pkg Package object for this entry, if exists.\n * @param  {string[]} sources Array of agent hashes involved in this delete.\n * @return {boolean} true if this entry can be deleted.\n *\n * @see https://developer.holochain.org/API#validateDel_entryType_hash_package_sources\n * @see https://developer.holochain.org/Validation_Functions\n */\nfunction validateDel (entryType, hash, pkg, sources) {\n  return isValidEntryType(entryType)\n    // Only allow the creator of the entity to delete it.\n    && getCreator(hash) === sources[0];\n}\n\n/**\n * Package callback: The package request for validateCommit() and valdiatePut().\n *\n * Both 'commit' and 'put' trigger 'validatePutPkg' as 'validateCommit' and\n * 'validatePut' must both have the same data.\n *\n * @param  {string} entryType Name of the entry as per DNA config for this zome.\n * @return {PkgReq-object|null}\n *   null if the data required is the Entry and Header.\n *   Otherwise a \"Package Request\" object, which specifies what data to be sent\n *   to the validating node.\n *\n * @see https://developer.holochain.org/API#validatePutPkg_entryType\n * @see https://developer.holochain.org/Validation_Packaging\n */\nfunction validatePutPkg (entryType) {\n  return null;\n}\n\n/**\n * Package callback: The package request for validateMod().\n *\n * @param  {string} entryType Name of the entry as per DNA config for this zome.\n * @return {PkgReq-object|null}\n *   null if the data required is the Entry and Header.\n *   Otherwise a \"Package Request\" object, which specifies what data to be sent\n *   to the validating node.\n *\n * @see https://developer.holochain.org/API#validateModPkg_entryType\n * @see https://developer.holochain.org/Validation_Packaging\n */\nfunction validateModPkg (entryType) {\n  return null;\n}\n\n/**\n * Package callback: The package request for validateDel().\n *\n * @param  {string} entryType Name of the entry as per DNA config for this zome.\n * @return {PkgReq-object|null}\n *   null if the data required is the Entry and Header.\n *   Otherwise a \"Package Request\" object, which specifies what data to be sent\n *   to the validating node.\n *\n * @see https://developer.holochain.org/API#validateDelPkg_entryType\n * @see https://developer.holochain.org/Validation_Packaging\n */\nfunction validateDelPkg (entryType) {\n  return null;\n}"
    }
  ]},
"TestSets":[{
  "Name":"sample",
  "TestSet":{"Tests":[{"Convey":"Example: (which fails because we haven't actually implemented a sampleEntryCreate function) We can create a new sampleEntry","Zome":"sampleZome","FnName": "sampleEntryCreate","Input": {"content": "this is the entry body","stamp":12345},"Output":"\"%h1%\"","Exposure":"public"}]}}
   ],
"UI":[
{"FileName":"index.html",
 "Data":"<html><body>Your UI here!</body></html>"
},
{"FileName":"hc.js",
 "Data":"function yourApp(){alert('your UI code here!')}"
}],
"Scenarios":[
        {"Name":"sampleScenario",
         "Roles":[
             {"Name":"listener",
              "TestSet":{"Tests":[
                  {"Convey":"add listener test here"}]}},
             {"Name":"speaker",
              "TestSet":{"Tests":[
                  {"Convey":"add speaker test here"}]}}],
         "Config":{"Duration":5,"GossipInterval":100}}]
}
`
View Source 
var BridgeAppNotFoundErr = errors.New("bridge app not found")
View Source 
var BytesSentChan chan BytesSent
View Source 
var CapabilityInvalidErr = errors.New("invalid capability")
View Source 
var ChangeAppProperty = Change{
	Type:    Warning,
	Message: "Getting special properties via property() is deprecated as of %d. Returning nil values.  Use App* instead",
	AsOf:    3,
}
View Source 
var CloserPeerCount = KValue

The number of closer peers to send on requests.

View Source 
var Crash bool
View Source 
var DNAEntryDef = &EntryDef{Name: DNAEntryType, DataFormat: DataFormatSysDNA}
View Source 
var DelEntryDef = &EntryDef{Name: DelEntryType, DataFormat: DataFormatJSON, Sharing: Public, Schema: DelEntrySchema}
View Source 
var EnableAllLoggersEnv string = "HC_ENABLE_ALL_LOGS"
View Source 
var ErrActionMissingHeader error = errors.New("Action is missing header")
View Source 
var ErrActionReceiveInvalid error = errors.New("Action receive is invalid")
View Source 
var ErrBlockedListed = errors.New("node blockedlisted")
View Source 
var ErrBundleNotStarted = errors.New("bundle not started")
View Source 
var ErrChainLockedForBundle = errors.New("chain locked for bundle")
View Source 
var ErrDHTErrNoGossipersAvailable error = errors.New("no gossipers available")
View Source 
var ErrDHTExpectedGossipReqInBody error = errors.New("expected gossip request")
View Source 
var ErrDHTUnexpectedTypeInBody error = errors.New("unexpected type in message body")
View Source 
var ErrEmptyRoutingTable = errors.New("routing table empty")
View Source 
var ErrEntryDefInvalid = errors.New("Invalid Entry Defintion")
View Source 
var ErrEntryTypeMismatch = errors.New("entry type mismatch")
View Source 
var ErrHashDeleted = errors.New("hash deleted")
View Source 
var ErrHashModified = errors.New("hash modified")
View Source 
var ErrHashNotFound = errors.New("hash not found")
View Source 
var ErrHashRejected = errors.New("hash rejected")
View Source 
var ErrIncompleteChain = errors.New("operation not allowed on incomplete chain")
View Source 
var ErrLinkNotFound = errors.New("link not found")
View Source 
var ErrModInvalidForLinks error = errors.New("mod: invalid for Links entry")
View Source 
var ErrModMissingHeader error = errors.New("mod: missing header")
View Source 
var ErrModReplacesHashNotDifferent error = errors.New("mod: replaces must be different from original hash")
View Source 
var ErrNilEntryInvalid error = errors.New("nil entry invalid")
View Source 
var ErrNoSuchIdx error = errors.New("no such change index")
View Source 
var ErrNodeNotFound = errors.New("node not found")
View Source 
var ErrNotAcceptedByAnyRemoteNode = errors.New("Change not accepted by any remote node")
View Source 
var ErrNotValidForAgentType error = errors.New("Invalid action for Agent type")
View Source 
var ErrNotValidForDNAType error = errors.New("Invalid action for DNA type")
View Source 
var ErrNotValidForDelType error = errors.New("Invalid action for Del type")
View Source 
var ErrNotValidForHeadersType error = errors.New("Invalid action for Headers type")
View Source 
var ErrNotValidForKeyType error = errors.New("Invalid action for Key type")
View Source 
var ErrPutLinkOverDeleted = errors.New("putlink over deleted link")
View Source 
var ErrWrongNargs = errors.New("wrong number of arguments")
View Source 
var HeadersEntryDef = &EntryDef{Name: HeadersEntryType, DataFormat: DataFormatJSON, Sharing: Public, Schema: HeadersEntrySchema}
View Source 
var KValue int = 10
View Source 
var KeyEntryDef = &EntryDef{Name: KeyEntryType, DataFormat: DataFormatSysKey}
View Source 
var MigrateEntryDef = &EntryDef{Name: MigrateEntryType, DataFormat: DataFormatJSON, Sharing: Public, Schema: MigrateEntrySchema}
View Source 
var NonDHTAction error = errors.New("Not a DHT action")
View Source 
var SelfRevocationDoesNotVerify = errors.New("self revocation does not verify")
View Source 
var SendTimeoutErr = errors.New("send timeout")
View Source 
var UnknownWarrantTypeErr = errors.New("unknown warrant type")
View Source 
var ValidationFailedErr = errors.New(ValidationFailedErrMsg)
View Source 
var WarrantPropertyNotFoundErr = errors.New("warrant property not found")

Functions

func ActionReceiver 

func ActionReceiver(h *Holochain, msg *Message) (response interface{}, err error)

ActionReceiver handles messages on the action protocol

func BootstrapRefreshTask 

func BootstrapRefreshTask(h *Holochain)

BootstrapRefreshTask refreshes our node and gets nodes from the bootstrap server

func ByteDecoder 

func ByteDecoder(b []byte, to interface{}) (err error)

ByteDecoder decodes data encoded by ByteEncoder

func ByteEncoder 

func ByteEncoder(data interface{}) (b []byte, err error)

ByteEncoder encodes anything using gob

func CleanupTestChain 

func CleanupTestChain(h *Holochain, d string)

func CleanupTestDir 

func CleanupTestDir(path string)

func CopyDir 

func CopyDir(source string, dest string) (err error)

CopyDir recursively copies a directory tree, attempting to preserve permissions. Source directory must exist, destination directory must *not* exist.

func CopyFile 

func CopyFile(source string, dest string) (err error)

CopyFile copies file source to destination dest.

func DNAHashofUngenedChain 

func DNAHashofUngenedChain(h *Holochain) (DNAHash Hash, err error)

func Debug 

func Debug(m string)

Debug sends a string to the standard debug log

func Debugf 

func Debugf(m string, args ...interface{})

Debugf sends a formatted string to the global debug log

func DebuggingRequestedViaEnv 

func DebuggingRequestedViaEnv() (val, yes bool)

DebuggingRequestedViaEnv determines whether an environment var was set to enable or disable debugging

func Decode 

func Decode(reader io.Reader, format string, data interface{}) (err error)

Decode extracts data from the reader according to the type

func DecodeFile 

func DecodeFile(data interface{}, pathParts ...string) (err error)

DecodeFile decodes a file based on the extension and the data type

func DecodePubKey 

func DecodePubKey(b58pk string) (pubKey ic.PubKey, err error)

func DirExists 

func DirExists(pathParts ...string) bool

func Encode 

func Encode(writer io.Writer, format string, data interface{}) (err error)

Encode encodes data to the writer according to the given format

func EncodingFormat 

func EncodingFormat(file string) (f string)

EncodingFormat returns the files format if supported otherwise ""

func EscapeJSONValue 

func EscapeJSONValue(json string) string

EscapeJSONValue removed characters from a JSON value to avoid parsing issues.

func FileExists 

func FileExists(pathParts ...string) bool

func FileSize 

func FileSize(pathParts ...string) int64

func GetAllTestRoles 

func GetAllTestRoles(path string) (roleNameList []string, err error)

GetAllTestRoles retuns a list of the roles in a scenario

func GetTestScenarioRoles 

func GetTestScenarioRoles(h *Holochain, scenarioName string) (roleNameList []string, err error)

GetTestScenarioRoles returns a list of scenario roles

func GetTestScenarios 

func GetTestScenarios(h *Holochain) (scenarios map[string]*os.FileInfo, err error)

TestScenarioList returns a list of paths to scenario directories

func GossipReceiver 

func GossipReceiver(h *Holochain, m *Message) (response interface{}, err error)

GossipReceiver implements the handler for the gossip protocol

func GossipTask 

func GossipTask(h *Holochain)

GossipTask runs a gossip and logs any errors

func HoldingTask 

func HoldingTask(h *Holochain)

func Info 

func Info(m string)

Info sends a string to the global info log

func Infof 

func Infof(m string, args ...interface{})

Infof sends a formatted string to the standard info log

func InitializeHolochain 

func InitializeHolochain()

InitializeHolochain setup function that must be called once at startup by the application that uses this holochain library

func IsInitialized 

func IsInitialized(root string) bool

IsInitialized checks a path for a correctly set up .holochain directory

func IsValidationFailedErr 

func IsValidationFailedErr(err error) bool

func KademliaReceiver 

func KademliaReceiver(h *Holochain, m *Message) (response interface{}, err error)

KademliaReceiver implements the handler for the kademlia RPC protocol messages

func LoadTestFiles 

func LoadTestFiles(path string) (map[string]TestSet, error)

LoadTestFiles searches a path for .json test files and loads them into an array

func MakeDirs 

func MakeDirs(devPath string) error

MakeDirs creates the directory structure of an application

func MakeReceiptData 

func MakeReceiptData(msg *Message, code int) (reciept []byte, err error)

MakeReceiptData converts a message and a code into signable data

func MakeTestDirName 

func MakeTestDirName() string

func MakeTestSeed 

func MakeTestSeed(id string) io.Reader

func MarshalEntry 

func MarshalEntry(writer io.Writer, e Entry) (err error)

MarshalEntry serializes an entry to a writer

func MarshalHeader 

func MarshalHeader(writer io.Writer, hd *Header) (err error)

MarshalHeader writes a header to a binary stream

func MarshalSignature 

func MarshalSignature(writer io.Writer, s *Signature) (err error)

MarshalSignature writes a signature to a binary stream

func NormaliseJSON 

func NormaliseJSON(json string) string

func Panix 

func Panix(on string)

func PrepareTestChain 

func PrepareTestChain(n string) (d string, s *Service, h *Holochain)

func PrettyPrintJSON 

func PrettyPrintJSON(b []byte) (string, error)

PrettyPrintJSON for human reability.

func ReadFile 

func ReadFile(pathParts ...string) (data []byte, err error)

func RegisterBultinRibosomes 

func RegisterBultinRibosomes()

RegisterBultinRibosomes adds the built in ribosome types to the factory hash

func RegisterRibosome 

func RegisterRibosome(name string, factory RibosomeFactory)

RegisterRibosome sets up a Ribosome to be used by the CreateRibosome function

func RetryTask 

func RetryTask(h *Holochain)

RetryTask checks to see if there are any received puts that need retrying and does one if so

func RoutingRefreshTask 

func RoutingRefreshTask(h *Holochain)

RoutingRefreshTask fills the routing table by searching for a random node

func RunValidationPhase 

func RunValidationPhase(h *Holochain, source peer.ID, msgType MsgType, query Hash, handler func(resp ValidateResponse) error) (err error)

func SaveAgent 

func SaveAgent(path string, agent Agent) (err error)

SaveAgent saves out the keys and agent name to the given directory

func SetAgentIdentity 

func SetAgentIdentity(agent Agent, identity AgentIdentity)

func SetIdentity 

func SetIdentity(h *Holochain, identity AgentIdentity)

func SetupTestChain 

func SetupTestChain(n string) (d string, s *Service, h *Holochain)

func SetupTestDir 

func SetupTestDir() string

func ShouldLog 

func ShouldLog(log *Logger, fn func(), messages ...string)

func SortClosestPeers 

func SortClosestPeers(peers []peer.ID, target Hash) []peer.ID

func TestingAppAppPackage 

func TestingAppAppPackage() string

func Ticker 

func Ticker(interval time.Duration, fn func()) (stopper chan bool)

Ticker runs a function on an interval that can be stopped with the returned bool channel

func UnmarshalHeader 

func UnmarshalHeader(reader io.Reader, hd *Header, hashSize int) (err error)

UnmarshalHeader reads a Header from a binary stream

func UnmarshalSignature 

func UnmarshalSignature(reader io.Reader, s *Signature) (err error)

UnmarshalSignature reads a Signature from a binary stream

func ValidateReceiver 

func ValidateReceiver(h *Holochain, msg *Message) (response interface{}, err error)

ValidateReceiver handles messages on the Validate protocol

func ValidationFailed 

func ValidationFailed(msgs ...string) error

ValidationFailed creates a validation failed error message

func WriteFile 

func WriteFile(data []byte, pathParts ...string) error

Types

type APIFnBridge 

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

func (*APIFnBridge) Args 

func (fn *APIFnBridge) Args() []Arg

func (*APIFnBridge) Call 

func (fn *APIFnBridge) Call(h *Holochain) (response interface{}, err error)

func (*APIFnBridge) Name 

func (fn *APIFnBridge) Name() string

type APIFnCall 

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

func (*APIFnCall) Args 

func (fn *APIFnCall) Args() []Arg

func (*APIFnCall) Call 

func (fn *APIFnCall) Call(h *Holochain) (response interface{}, err error)

func (*APIFnCall) Name 

func (fn *APIFnCall) Name() string

type APIFnCloseBundle 

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

func (*APIFnCloseBundle) Args 

func (a *APIFnCloseBundle) Args() []Arg

func (*APIFnCloseBundle) Call 

func (a *APIFnCloseBundle) Call(h *Holochain) (response interface{}, err error)

func (*APIFnCloseBundle) Name 

func (a *APIFnCloseBundle) Name() string

type APIFnCommit 

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

func (*APIFnCommit) Args 

func (fn *APIFnCommit) Args() []Arg

func (*APIFnCommit) Call 

func (fn *APIFnCommit) Call(h *Holochain) (response interface{}, err error)

func (*APIFnCommit) Name 

func (fn *APIFnCommit) Name() string

func (*APIFnCommit) SetAction 

func (fn *APIFnCommit) SetAction(a *ActionCommit)

type APIFnDebug 

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

func (*APIFnDebug) Args 

func (a *APIFnDebug) Args() []Arg

func (*APIFnDebug) Call 

func (a *APIFnDebug) Call(h *Holochain) (response interface{}, err error)

func (*APIFnDebug) Name 

func (a *APIFnDebug) Name() string

type APIFnDel 

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

func (*APIFnDel) Args 

func (fn *APIFnDel) Args() []Arg

func (*APIFnDel) Call 

func (fn *APIFnDel) Call(h *Holochain) (response interface{}, err error)

func (*APIFnDel) Name 

func (fn *APIFnDel) Name() string

type APIFnGet 

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

func (*APIFnGet) Args 

func (fn *APIFnGet) Args() []Arg

func (*APIFnGet) Call 

func (fn *APIFnGet) Call(h *Holochain) (response interface{}, err error)

func (*APIFnGet) Name 

func (fn *APIFnGet) Name() string

type APIFnGetBridges 

type APIFnGetBridges struct {
}

func (*APIFnGetBridges) Args 

func (a *APIFnGetBridges) Args() []Arg

func (*APIFnGetBridges) Call 

func (a *APIFnGetBridges) Call(h *Holochain) (response interface{}, err error)

func (*APIFnGetBridges) Name 

func (a *APIFnGetBridges) Name() string
type APIFnGetLinks struct {
	// contains filtered or unexported fields
}

func (*APIFnGetLinks) Args 

func (fn *APIFnGetLinks) Args() []Arg

func (*APIFnGetLinks) Call 

func (fn *APIFnGetLinks) Call(h *Holochain) (response interface{}, err error)

func (*APIFnGetLinks) Name 

func (fn *APIFnGetLinks) Name() string

type APIFnMakeHash 

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

func (*APIFnMakeHash) Args 

func (a *APIFnMakeHash) Args() []Arg

func (*APIFnMakeHash) Call 

func (a *APIFnMakeHash) Call(h *Holochain) (response interface{}, err error)

func (*APIFnMakeHash) Name 

func (a *APIFnMakeHash) Name() string

type APIFnMigrate 

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

func (*APIFnMigrate) Args 

func (fn *APIFnMigrate) Args() []Arg

func (*APIFnMigrate) Call 

func (fn *APIFnMigrate) Call(h *Holochain) (response interface{}, err error)

func (*APIFnMigrate) Name 

func (fn *APIFnMigrate) Name() string

type APIFnMod 

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

func (*APIFnMod) Args 

func (fn *APIFnMod) Args() []Arg

func (*APIFnMod) Call 

func (fn *APIFnMod) Call(h *Holochain) (response interface{}, err error)

func (*APIFnMod) Name 

func (fn *APIFnMod) Name() string

type APIFnModAgent 

type APIFnModAgent struct {
	Identity   AgentIdentity
	Revocation string
}

func (*APIFnModAgent) Args 

func (fn *APIFnModAgent) Args() []Arg

func (*APIFnModAgent) Call 

func (fn *APIFnModAgent) Call(h *Holochain) (response interface{}, err error)

func (*APIFnModAgent) Name 

func (fn *APIFnModAgent) Name() string

type APIFnProperty 

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

func (*APIFnProperty) Args 

func (a *APIFnProperty) Args() []Arg

func (*APIFnProperty) Call 

func (a *APIFnProperty) Call(h *Holochain) (response interface{}, err error)

func (*APIFnProperty) Name 

func (a *APIFnProperty) Name() string

type APIFnQuery 

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

func (*APIFnQuery) Args 

func (a *APIFnQuery) Args() []Arg

func (*APIFnQuery) Call 

func (a *APIFnQuery) Call(h *Holochain) (response interface{}, err error)

func (*APIFnQuery) Name 

func (a *APIFnQuery) Name() string

type APIFnSend 

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

func (*APIFnSend) Args 

func (fn *APIFnSend) Args() []Arg

func (*APIFnSend) Call 

func (fn *APIFnSend) Call(h *Holochain) (response interface{}, err error)

func (*APIFnSend) Name 

func (fn *APIFnSend) Name() string

type APIFnSign 

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

func (*APIFnSign) Args 

func (a *APIFnSign) Args() []Arg

func (*APIFnSign) Call 

func (a *APIFnSign) Call(h *Holochain) (response interface{}, err error)

func (*APIFnSign) Name 

func (a *APIFnSign) Name() string

type APIFnStartBundle 

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

func NewStartBundleAction 

func NewStartBundleAction(timeout int, userParam string) *APIFnStartBundle

func (*APIFnStartBundle) Args 

func (a *APIFnStartBundle) Args() []Arg

func (*APIFnStartBundle) Call 

func (a *APIFnStartBundle) Call(h *Holochain) (response interface{}, err error)

func (*APIFnStartBundle) Name 

func (a *APIFnStartBundle) Name() string

type APIFnVerifySignature 

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

func (*APIFnVerifySignature) Args 

func (a *APIFnVerifySignature) Args() []Arg

func (*APIFnVerifySignature) Call 

func (a *APIFnVerifySignature) Call(h *Holochain) (response interface{}, err error)

func (*APIFnVerifySignature) Name 

func (a *APIFnVerifySignature) Name() string

type APIFunction 

type APIFunction interface {
	Name() string
	Args() []Arg
	Call(h *Holochain) (response interface{}, err error)
}

APIFunction abstracts the argument structure and the calling of an api function

type Action 

type Action interface {
	Name() string
	Receive(dht *DHT, msg *Message) (response interface{}, err error)
}

Action provides an abstraction for handling node interaction

func MakeActionFromMessage 

func MakeActionFromMessage(msg *Message) (a Action, err error)

MakeActionFromMessage generates an action from an action protocol messsage

type ActionCommit 

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

func NewCommitAction 

func NewCommitAction(entryType string, entry Entry) *ActionCommit

func (*ActionCommit) CheckValidationRequest 

func (a *ActionCommit) CheckValidationRequest(def *EntryDef) (err error)

func (*ActionCommit) Entry 

func (a *ActionCommit) Entry() Entry

func (*ActionCommit) EntryType 

func (a *ActionCommit) EntryType() string

func (*ActionCommit) GetHeader 

func (a *ActionCommit) GetHeader() (header *Header)

func (*ActionCommit) Name 

func (a *ActionCommit) Name() string

func (*ActionCommit) Receive 

func (a *ActionCommit) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionCommit) SetHeader 

func (a *ActionCommit) SetHeader(header *Header)

func (*ActionCommit) Share 

func (a *ActionCommit) Share(h *Holochain, def *EntryDef) (err error)

func (*ActionCommit) SysValidation 

func (a *ActionCommit) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)

type ActionDel 

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

func NewDelAction 

func NewDelAction(entry DelEntry) *ActionDel

func (*ActionDel) CheckValidationRequest 

func (a *ActionDel) CheckValidationRequest(def *EntryDef) (err error)

func (*ActionDel) Entry 

func (a *ActionDel) Entry() Entry

func (*ActionDel) EntryType 

func (a *ActionDel) EntryType() string

func (*ActionDel) GetHeader 

func (a *ActionDel) GetHeader() (header *Header)

func (*ActionDel) Name 

func (a *ActionDel) Name() string

func (*ActionDel) Receive 

func (a *ActionDel) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionDel) SetHeader 

func (a *ActionDel) SetHeader(header *Header)

func (*ActionDel) Share 

func (a *ActionDel) Share(h *Holochain, def *EntryDef) (err error)

func (*ActionDel) SysValidation 

func (a *ActionDel) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)

type ActionGet 

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

func (*ActionGet) Name 

func (a *ActionGet) Name() string

func (*ActionGet) Receive 

func (a *ActionGet) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionGet) SysValidation 

func (a *ActionGet) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)
type ActionGetLinks struct {
	// contains filtered or unexported fields
}

func NewGetLinksAction 

func NewGetLinksAction(linkQuery *LinkQuery, options *GetLinksOptions) *ActionGetLinks

func (*ActionGetLinks) Name 

func (a *ActionGetLinks) Name() string

func (*ActionGetLinks) Receive 

func (a *ActionGetLinks) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionGetLinks) SysValidation 

func (a *ActionGetLinks) SysValidation(h *Holochain, d *EntryDef, pkg *Package, sources []peer.ID) (err error)
type ActionLink struct {
	// contains filtered or unexported fields
}

func NewLinkAction 

func NewLinkAction(entryType string, links []Link) *ActionLink

func (*ActionLink) CheckValidationRequest 

func (a *ActionLink) CheckValidationRequest(def *EntryDef) (err error)

func (*ActionLink) Name 

func (a *ActionLink) Name() string

func (*ActionLink) Receive 

func (a *ActionLink) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionLink) SysValidation 

func (a *ActionLink) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)

type ActionListAdd 

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

func NewListAddAction 

func NewListAddAction(peerList PeerList) *ActionListAdd

func (*ActionListAdd) Name 

func (a *ActionListAdd) Name() string

func (*ActionListAdd) Receive 

func (a *ActionListAdd) Receive(dht *DHT, msg *Message) (response interface{}, err error)

type ActionMigrate 

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

func (*ActionMigrate) CheckValidationRequest 

func (a *ActionMigrate) CheckValidationRequest(def *EntryDef) (err error)

func (*ActionMigrate) Entry 

func (a *ActionMigrate) Entry() Entry

func (*ActionMigrate) EntryType 

func (a *ActionMigrate) EntryType() string

func (*ActionMigrate) GetHeader 

func (a *ActionMigrate) GetHeader() (header *Header)

func (*ActionMigrate) Name 

func (a *ActionMigrate) Name() string

func (*ActionMigrate) Receive 

func (a *ActionMigrate) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionMigrate) SetHeader 

func (a *ActionMigrate) SetHeader(header *Header)

func (*ActionMigrate) Share 

func (action *ActionMigrate) Share(h *Holochain, def *EntryDef) (err error)

func (*ActionMigrate) SysValidation 

func (action *ActionMigrate) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)

type ActionMod 

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

func NewModAction 

func NewModAction(entryType string, entry Entry, replaces Hash) *ActionMod

func (*ActionMod) CheckValidationRequest 

func (a *ActionMod) CheckValidationRequest(def *EntryDef) (err error)

func (*ActionMod) Entry 

func (a *ActionMod) Entry() Entry

func (*ActionMod) EntryType 

func (a *ActionMod) EntryType() string

func (*ActionMod) GetHeader 

func (a *ActionMod) GetHeader() (header *Header)

func (*ActionMod) Name 

func (a *ActionMod) Name() string

func (*ActionMod) Receive 

func (a *ActionMod) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionMod) SetHeader 

func (a *ActionMod) SetHeader(header *Header)

func (*ActionMod) Share 

func (a *ActionMod) Share(h *Holochain, def *EntryDef) (err error)

func (*ActionMod) SysValidation 

func (a *ActionMod) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)

type ActionPut 

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

func NewPutAction 

func NewPutAction(entryType string, entry Entry, header *Header) *ActionPut

func (*ActionPut) CheckValidationRequest 

func (a *ActionPut) CheckValidationRequest(def *EntryDef) (err error)

func (*ActionPut) Name 

func (a *ActionPut) Name() string

func (*ActionPut) Receive 

func (a *ActionPut) Receive(dht *DHT, msg *Message) (response interface{}, err error)

func (*ActionPut) SysValidation 

func (a *ActionPut) SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)

type ActionSend 

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

func (*ActionSend) Name 

func (a *ActionSend) Name() string

func (*ActionSend) Receive 

func (a *ActionSend) Receive(dht *DHT, msg *Message) (response interface{}, err error)

type Agent 

type Agent interface {
	Identity() AgentIdentity
	SetIdentity(id AgentIdentity)
	AgentType() AgentType
	GenKeys(seed io.Reader) error
	PrivKey() ic.PrivKey
	PubKey() ic.PubKey
	EncodePubKey() (string, error)
	NodeID() (peer.ID, string, error)
	AgentEntry(revocation Revocation) (AgentEntry, error)
}

Agent abstracts the key behaviors and connection to a holochain node address Note that this is currently only a partial abstraction because the NodeID is always a libp2p peer.ID to complete the abstraction so we could use other libraries for p2p2 network transaction we would need to also abstract a matching NodeID type

func LoadAgent 

func LoadAgent(path string) (agent Agent, err error)

LoadAgent gets the agent identity and private key from the specified directory TODO confirm against chain?

func NewAgent 

func NewAgent(agentType AgentType, identity AgentIdentity, seed io.Reader) (agent Agent, err error)

NewAgent creates an agent structure of the given type Note: currently only IPFS agents are implemented

type AgentEntry 

type AgentEntry struct {
	Identity   AgentIdentity
	Revocation string // marshaled revocation
	PublicKey  string // marshaled public key
}

AgentEntry structure for building AgentEntryType entries

func AgentEntryFromJSON 

func AgentEntryFromJSON(j string) (entry AgentEntry, err error)

func (*AgentEntry) ToJSON 

func (ae *AgentEntry) ToJSON() (encodedEntry string, err error)

type AgentFixture 

type AgentFixture struct {
	Hash     string
	Identity string
}

AgentFixture defines an agent for the purposes of tests

type AgentIdentity 

type AgentIdentity string

AgentIdentity is the user's unique identity information in context of this holochain. it follows AgentIdentitySchema in DNA

type AgentType 

type AgentType int

type AppMsg 

type AppMsg struct {
	ZomeType string
	Body     string
}

type AppPackage 

type AppPackage struct {
	Version   string
	Generator string
	DNA       DNA
	TestSets  []AppPackageTests
	UI        []AppPackageUIFile
	Scenarios []AppPackageScenario
}

func LoadAppPackage 

func LoadAppPackage(reader io.Reader, encodingFormat string) (appPackageP *AppPackage, err error)

LoadAppPackage decodes DNA and other appPackage data from appPackage file (via an io.reader)

type AppPackageScenario 

type AppPackageScenario struct {
	Name   string
	Roles  []AppPackageTests
	Config TestConfig
}

type AppPackageTests 

type AppPackageTests struct {
	Name    string
	TestSet TestSet
}

type AppPackageUIFile 

type AppPackageUIFile struct {
	FileName string
	Data     string
	Encoding string
}

type Arg 

type Arg struct {
	Name     string
	Type     ArgType
	Optional bool
	MapType  reflect.Type
	// contains filtered or unexported fields
}

Arg holds the definition of an API function argument

type ArgType 

type ArgType int8

type BSReq 

type BSReq struct {
	Version  int
	NodeID   string
	NodeAddr string
}

type BSResp 

type BSResp struct {
	Req      BSReq
	Remote   string
	LastSeen time.Time
}

type Bridge 

type Bridge struct {
	CalleeApp  Hash
	CalleeName string
	Token      string
	Side       int
}

Bridge holds data returned by GetBridges

type BridgeApp 

type BridgeApp struct {
	Name                    string //Name of other side
	DNA                     Hash   // DNA of other side
	Side                    int
	BridgeGenesisCallerData string
	BridgeGenesisCalleeData string
	Port                    string // only used if side == BridgeCallee
	BridgeZome              string // only used if side == BridgeCaller
}

BridgeApp describes a data necessary for bridging

type BridgeSpec 

type BridgeSpec map[string]map[string]bool

type Bucket 

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

Bucket holds a list of peers.

func (*Bucket) Has 

func (b *Bucket) Has(id peer.ID) bool

func (*Bucket) Len 

func (b *Bucket) Len() int

func (*Bucket) MoveToFront 

func (b *Bucket) MoveToFront(id peer.ID)

func (*Bucket) Peers 

func (b *Bucket) Peers() []peer.ID

func (*Bucket) PopBack 

func (b *Bucket) PopBack() peer.ID

func (*Bucket) PushFront 

func (b *Bucket) PushFront(p peer.ID)

func (*Bucket) Remove 

func (b *Bucket) Remove(id peer.ID)

func (*Bucket) Split 

func (b *Bucket) Split(cpl int, target peer.ID) *Bucket

Split splits a buckets peers into two buckets, the methods receiver will have peers with CPL equal to cpl, the returned bucket will have peers with CPL greater than cpl (returned bucket has closer peers)

type Bundle 

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

type BuntHT 

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

func (*BuntHT) Close 

func (ht *BuntHT) Close()

Close cleans up any resources used by the table

func (*BuntHT) Del 

func (ht *BuntHT) Del(m *Message, key Hash) (err error)

Del moves the given hash to the StatusDeleted status N.B. this functions assumes that the validity of this action has been confirmed 

func (ht *BuntHT) DelLink(m *Message, base string, link string, tag string) (err error)

DelLink removes a link and tag associated with a stored hash N.B. this function assumes that the action has been properly validated

func (*BuntHT) Exists 

func (ht *BuntHT) Exists(key Hash, statusMask int) (err error)

Exists checks for the existence of the hash in the store

func (*BuntHT) Get 

func (ht *BuntHT) Get(key Hash, statusMask int, getMask int) (data []byte, entryType string, sources []string, status int, err error)

Get retrieves a value from the DHT store

func (*BuntHT) GetIdx 

func (ht *BuntHT) GetIdx() (idx int, err error)

GetIdx returns the current index of changes to the HashTable

func (*BuntHT) GetIdxMessage 

func (ht *BuntHT) GetIdxMessage(idx int) (msg Message, err error)

GetIdxMessage returns the messages that causes the change at a given index 

func (ht *BuntHT) GetLinks(base Hash, tag string, statusMask int) (results []TaggedHash, err error)

GetLinks retrieves meta value associated with a base

func (*BuntHT) Iterate 

func (ht *BuntHT) Iterate(fn HashTableIterateFn)

func (*BuntHT) JSON 

func (ht *BuntHT) JSON() (result string, err error)

JSON converts the table into a JSON string representation.

func (*BuntHT) Mod 

func (ht *BuntHT) Mod(m *Message, key Hash, newkey Hash) (err error)

Mod moves the given hash to the StatusModified status N.B. this functions assumes that the validity of this action has been confirmed

func (*BuntHT) Open 

func (ht *BuntHT) Open(options interface{}) (err error)

func (*BuntHT) Put 

func (ht *BuntHT) Put(m *Message, entryType string, key Hash, src peer.ID, value []byte, status int) (err error)

Put stores a value to the DHT store N.B. This call assumes that the value has already been validated 

func (ht *BuntHT) PutLink(m *Message, base string, link string, tag string) (err error)

PutLink associates a link with a stored hash N.B. this function assumes that the data associated has been properly retrieved and validated from the cource chain

func (*BuntHT) Source 

func (ht *BuntHT) Source(key Hash) (id peer.ID, err error)

Source returns the source node address of a given hash

func (*BuntHT) String 

func (ht *BuntHT) String() (result string)

String converts the table into a human readable string

type BytesSent 

type BytesSent struct {
	Bytes   int64
	MsgType MsgType
}

type Callback 

type Callback struct {
	Function string
	ID       string
	// contains filtered or unexported fields
}

type Capability 

type Capability struct {
	Token string
	// contains filtered or unexported fields
}

func NewCapability 

func NewCapability(db *buntdb.DB, capability string, who interface{}) (c *Capability, err error)

NewCapability returns and registers a capability of a type, for a specific or anyone if who is nil

func (*Capability) Revoke 

func (c *Capability) Revoke(who interface{}) (err error)

Revoke unregisters the capability for a peer

func (*Capability) Validate 

func (c *Capability) Validate(who interface{}) (capability string, err error)

Validate checks to see if the token has been registered and returns the capability it represent

type Chain 

type Chain struct {
	Hashes   []Hash
	Headers  []*Header
	Entries  []Entry
	TypeTops map[string]int // pointer to index of top of a given type
	Hmap     map[Hash]int   // map header hashes to index number
	Emap     map[Hash]int   // map entry hashes to index number
	// contains filtered or unexported fields
}

Chain structure for providing in-memory access to chain data, entries headers and hashes

func NewChain 

func NewChain(hashSpec HashSpec) (chain *Chain)

NewChain creates and empty chain

func NewChainFromFile 

func NewChainFromFile(spec HashSpec, path string) (c *Chain, err error)

NewChainFromFile creates a chain from a file, loading any data there, and setting it to be persisted to. If no file exists it will be created.

func UnmarshalChain 

func UnmarshalChain(hashSpec HashSpec, reader io.Reader) (flags int64, c *Chain, err error)

UnmarshalChain unserializes a chain from a reader

func (*Chain) AddEntry 

func (c *Chain) AddEntry(now time.Time, entryType string, e Entry, privKey ic.PrivKey) (hash Hash, err error)

AddEntry creates a new header and adds it to a chain

func (*Chain) BundleStarted 

func (c *Chain) BundleStarted() *Bundle

BundleStarted returns the index of the chain item before the bundle or 0 if no bundle is active

func (*Chain) Close 

func (c *Chain) Close()

Close the chain's file

func (*Chain) CloseBundle 

func (c *Chain) CloseBundle(commit bool) (err error)

CloseBundle closes a started bundle and if commit copies entries from the bundle onto the chain

func (*Chain) Dot 

func (c *Chain) Dot(start int) (dump string, err error)

Dot converts a chain to a GraphViz 'dot' format dump of the headers and entries

func (*Chain) Dump 

func (c *Chain) Dump(start int) string

Dump converts a chain to a textual dump of the headers and entries from a starting index

func (*Chain) Get 

func (c *Chain) Get(h Hash) (header *Header, err error)

Get returns the header of a given hash

func (*Chain) GetEntry 

func (c *Chain) GetEntry(h Hash) (entry Entry, entryType string, err error)

GetEntry returns the entry of a given entry hash

func (*Chain) GetEntryHeader 

func (c *Chain) GetEntryHeader(h Hash) (header *Header, err error)

GetEntryHeader returns the header of a given entry hash

func (*Chain) JSON 

func (c *Chain) JSON(start int) (string, error)

JSON converts a chain to a json string dump of the headers and entries

func (*Chain) Length 

func (c *Chain) Length() int

Length returns the number of entries in the chain

func (*Chain) MarshalChain 

func (c *Chain) MarshalChain(writer io.Writer, flags int64, whitelistTypes []string, privateTypes []string) (err error)

MarshalChain serializes a chain data to a writer

func (*Chain) Nth 

func (c *Chain) Nth(n int) (header *Header)

Nth returns the nth latest header

func (*Chain) StartBundle 

func (c *Chain) StartBundle(userParam interface{}) (err error)

StartBundle marks a bundle start point and returns an error if already started

func (*Chain) String 

func (c *Chain) String() string

String converts a chain to a textual dump of the headers and entries

func (*Chain) Top 

func (c *Chain) Top() (header *Header)

Top returns the latest header

func (*Chain) TopType 

func (c *Chain) TopType(entryType string) (hash *Hash, header *Header)

TopType returns the latest header of a given type

func (*Chain) Validate 

func (c *Chain) Validate(skipEntries bool) (err error)

Validate traverses chain confirming the hashes @TODO confirm that TypeLinks are also correct @TODO confirm signatures

func (*Chain) Walk 

func (c *Chain) Walk(fn WalkerFn) (err error)

Walk traverses chain from most recent to first entry calling fn on each one

type ChainPair 

type ChainPair struct {
	Header *Header
	Entry  Entry
}

type Change 

type Change struct {
	Type    ChangeType
	Message string
	AsOf    int
}

Change represents a semantic change that needs to be reported

func (*Change) Log 

func (c *Change) Log()

type ChangeType 

type ChangeType int8
const (
	Deprecation ChangeType = iota
	Warning
)

type Channel 

type Channel chan interface{}

type CloneSpec 

type CloneSpec struct {
	Role   string
	Number int
}

type CloserPeersResp 

type CloserPeersResp struct {
	CloserPeers []PeerInfo // note this is not a pstore.PeerInfo which can't be serialized by gob.
}

type CommittingAction 

type CommittingAction interface {
	Name() string
	// Performs all validation logic, including sysValidation (must be called explicitly)
	SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)
	Receive(dht *DHT, msg *Message) (response interface{}, err error)
	CheckValidationRequest(def *EntryDef) (err error)
	EntryType() string
	// returns a GobEntry containing the action's entry in a serialized format
	Entry() Entry
	SetHeader(header *Header)
	GetHeader() (header *Header)
	// Low level implementation of putting to DHT (assumes validation has been done)
	Share(h *Holochain, def *EntryDef) (err error)
}

CommittingAction provides an abstraction for grouping actions which carry Entry data

type Config 

type Config struct {
	DHTPort          int
	EnableMDNS       bool
	PeerModeAuthor   bool
	PeerModeDHTNode  bool
	EnableNATUPnP    bool
	EnableWorldModel bool
	BootstrapServer  string
	Loggers          Loggers
	// contains filtered or unexported fields
}

Config holds the non-DNA configuration for a holo-chain, from config file or environment variables

func (*Config) SetGossipInterval 

func (config *Config) SetGossipInterval(interval time.Duration)

func (*Config) Setup 

func (config *Config) Setup() (err error)

func (*Config) SetupLogging 

func (config *Config) SetupLogging() (err error)

SetupLogging initializes loggers as configured by the config file and environment variables

type DHT 

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

DHT struct holds the data necessary to run the distributed hash table

func NewDHT 

func NewDHT(h *Holochain) *DHT

NewDHT creates a new DHT structure

func (*DHT) AddGossiper 

func (dht *DHT) AddGossiper(id peer.ID) (err error)

AddGossiper adds a new gossiper to the gossiper store

func (*DHT) Change 

func (dht *DHT) Change(key Hash, msgType MsgType, body interface{}) (err error)

Change sends DHT change messages to the closest peers to the hash in question

func (*DHT) Close 

func (dht *DHT) Close()

Close cleans up the DHT

func (*DHT) Del 

func (dht *DHT) Del(m *Message, key Hash) (err error)

Del moves the given hash to the StatusDeleted status N.B. this functions assumes that the validity of this action has been confirmed 

func (dht *DHT) DelLink(m *Message, base string, link string, tag string) (err error)

DelLink removes a link and tag associated with a stored hash N.B. this function assumes that the action has been properly validated

func (*DHT) DeleteGossiper 

func (dht *DHT) DeleteGossiper(id peer.ID) (err error)

DeleteGossiper removes a gossiper from the database

func (*DHT) Exists 

func (dht *DHT) Exists(key Hash, statusMask int) (err error)

Exists checks for the existence of the hash in the store

func (*DHT) FindGossiper 

func (dht *DHT) FindGossiper() (g peer.ID, err error)

FindGossiper picks a random DHT node to gossip with

func (*DHT) Get 

func (dht *DHT) Get(key Hash, statusMask int, getMask int) (data []byte, entryType string, sources []string, status int, err error)

Get retrieves a value from the DHT store

func (*DHT) GetFingerprint 

func (dht *DHT) GetFingerprint(f Hash) (index int, err error)

GetFingerprint returns the index that of the message that made a change or -1 if we don't have it

func (*DHT) GetGossiper 

func (dht *DHT) GetGossiper(id peer.ID) (idx int, err error)

GetGossiper loads returns last known index of the gossiper, and adds them if not didn't exist before

func (*DHT) GetGossipers 

func (dht *DHT) GetGossipers() (gossipers []GossiperData, err error)

func (*DHT) GetIdx 

func (dht *DHT) GetIdx() (idx int, err error)

GetIdx returns the current index of changes to the HashTable

func (*DHT) GetIdxMessage 

func (dht *DHT) GetIdxMessage(idx int) (msg Message, err error)

GetIdxMessage returns the messages that causes the change at a given index 

func (dht *DHT) GetLinks(base Hash, tag string, statusMask int) (results []TaggedHash, err error)

GetLinks retrieves meta value associated with a base

func (*DHT) GetPuts 

func (dht *DHT) GetPuts(since int) (puts []Put, err error)

GetPuts returns a list of puts after the given index

func (*DHT) HandleChangeRequests 

func (dht *DHT) HandleChangeRequests() (err error)

HandleChangeRequests waits on a channel for dht change requests

func (*DHT) HandleGossipPuts 

func (dht *DHT) HandleGossipPuts() (err error)

HandleGossipPuts waits on a channel for gossip changes

func (*DHT) HandleGossipWiths 

func (dht *DHT) HandleGossipWiths() (err error)

HandleGossipWiths waits on a channel for gossipWith requests

func (*DHT) HaveFingerprint 

func (dht *DHT) HaveFingerprint(f Hash) (result bool, err error)

HaveFingerprint returns true if we have seen the given fingerprint

func (*DHT) Iterate 

func (dht *DHT) Iterate(fn HashTableIterateFn)

func (*DHT) JSON 

func (dht *DHT) JSON() (result string, err error)

JSON converts a DHT into a JSON string representation.

func (*DHT) MakeHoldResp 

func (dht *DHT) MakeHoldResp(msg *Message, status int) (holdResp *HoldResp, err error)

MakeHoldResp creates fill the HoldResp struct with a the holding status and signature

func (*DHT) MakeReceiptSignature 

func (dht *DHT) MakeReceiptSignature(msg *Message, code int) (sig Signature, err error)

MakeReceipt creates a signature of a message together with the receipt code

func (*DHT) Mod 

func (dht *DHT) Mod(m *Message, key Hash, newkey Hash) (err error)

Mod moves the given hash to the StatusModified status N.B. this functions assumes that the validity of this action has been confirmed

func (*DHT) Open 

func (dht *DHT) Open(options interface{}) (err error)

Open sets up the DHTs data structures and store

func (*DHT) Put 

func (dht *DHT) Put(m *Message, entryType string, key Hash, src peer.ID, value []byte, status int) (err error)

Put stores a value to the DHT store N.B. This call assumes that the value has already been validated 

func (dht *DHT) PutLink(m *Message, base string, link string, tag string) (err error)

PutLink associates a link with a stored hash N.B. this function assumes that the data associated has been properly retrieved and validated from the cource chain

func (*DHT) Query 

func (dht *DHT) Query(key Hash, msgType MsgType, body interface{}) (response interface{}, err error)

Query sends DHT query messages recursively to peers until one is able to respond.

func (*DHT) SetupDHT 

func (dht *DHT) SetupDHT() (err error)

SetupDHT prepares a DHT for use by putting the genesis entries that are added by GenChain

func (*DHT) Source 

func (dht *DHT) Source(key Hash) (id peer.ID, err error)

Source returns the source node address of a given hash

func (*DHT) Start 

func (dht *DHT) Start() (err error)

Start initiates listening for DHT & Gossip protocol messages on the node

func (*DHT) String 

func (dht *DHT) String() (result string)

String converts a DHT into a human readable string

func (*DHT) UpdateGossiper 

func (dht *DHT) UpdateGossiper(id peer.ID, newIdx int) (err error)

UpdateGossiper updates a gossiper

type DHTConfig 

type DHTConfig struct {
	// HashType : (string) Identifies hash type to be used for this application. Should be from the list of hash types from the multihash library
	HashType HashType

	//RedundancyFactor(integer) Establishes minimum online redundancy targets for data, and size of peer sets for sync gossip. A redundancy factor ZERO means no sharding (every node syncs all data with every other node). ONE means you are running this as a centralized application and gossip is turned OFF. For most applications we recommend neighborhoods no smaller than 8 for nearness or 32 for hashmask sharding.
	RedundancyFactor int
}

Holds the dht configuration options

type DNA 

type DNA struct {
	Version              int
	UUID                 uuid.UUID
	Name                 string
	Properties           map[string]string
	PropertiesSchema     string
	PropertiesSchemaFile string
	AgentIdentitySchema  string // defines what must go in the Indentity field of a key/agent entry
	BasedOn              Hash   // references hash of another holochain that these schemas and code are derived from
	RequiresVersion      int
	DHTConfig            DHTConfig
	Progenitor           Progenitor
	Zomes                []Zome
	// contains filtered or unexported fields
}

func (*DNA) NewUUID 

func (dna *DNA) NewUUID() (err error)

NewUUID generates a new UUID for the DNA

type DNAFile 

type DNAFile struct {
	Version              int
	UUID                 uuid.UUID
	Name                 string
	Properties           map[string]string
	PropertiesSchemaFile string
	BasedOn              Hash // references hash of another holochain that these schemas and code are derived from
	RequiresVersion      int
	DHTConfig            DHTConfig
	Progenitor           Progenitor
	Zomes                []ZomeFile
}

type DelEntry 

type DelEntry struct {
	Hash    Hash
	Message string
}

DelEntry struct holds the record of an entry's deletion

func DelEntryFromJSON 

func DelEntryFromJSON(j string) (entry DelEntry, err error)

func (*DelEntry) ToJSON 

func (e *DelEntry) ToJSON() (encodedEntry string, err error)

type Entry 

type Entry interface {
	Marshal() ([]byte, error)
	Unmarshal([]byte) error
	Content() interface{}
	Sum(s HashSpec) (hash Hash, err error)
}

Entry describes serialization and deserialziation of entry data

func UnmarshalEntry 

func UnmarshalEntry(reader io.Reader) (e Entry, err error)

UnmarshalEntry unserializes an entry from a reader

type EntryDef 

type EntryDef struct {
	Name       string
	DataFormat string
	Sharing    string
	Schema     string
	// contains filtered or unexported fields
}

EntryDef struct holds an entry definition

func (*EntryDef) BuildJSONSchemaValidator 

func (d *EntryDef) BuildJSONSchemaValidator(path string) (err error)

BuildJSONSchemaValidator builds a validator in an EntryDef

func (*EntryDef) BuildJSONSchemaValidatorFromString 

func (d *EntryDef) BuildJSONSchemaValidatorFromString(schema string) (err error)

func (*EntryDef) IsSysEntry 

func (def *EntryDef) IsSysEntry() bool

IsSysEntry returns true if the entry type is system defined

func (*EntryDef) IsVirtualEntry 

func (def *EntryDef) IsVirtualEntry() bool

IsVirtualEntry returns true if the entry type is virtual

type EntryDefFile 

type EntryDefFile struct {
	Name       string
	DataFormat string
	Schema     string
	SchemaFile string // file name of schema or language schema directive
	Sharing    string
}

type ErrorResponse 

type ErrorResponse struct {
	Code    int
	Message string
	Payload interface{}
}

func NewErrorResponse 

func NewErrorResponse(err error) (errResp ErrorResponse)

NewErrorResponse encodes standard errors for transmitting

func (ErrorResponse) DecodeResponseError 

func (errResp ErrorResponse) DecodeResponseError() (err error)

DecodeResponseError creates a go error object from the ErrorResponse data

type FindNodeReq 

type FindNodeReq struct {
	H Hash
}

type FunctionDef 

type FunctionDef struct {
	Name        string
	CallingType string
	Exposure    string
}

FunctionDef holds the name and calling type of an DNA exposed function

func (*FunctionDef) ValidExposure 

func (f *FunctionDef) ValidExposure(context string) bool

ValidExposure verifies that the function can be called in the given context

type GetLinksOptions 

type GetLinksOptions struct {
	Load       bool // indicates whether GetLinks should retrieve the entries of all links
	StatusMask int  // mask of which status of links to return
}

GetLinksOptions options to holochain level GetLinks functions

type GetOptions 

type GetOptions struct {
	StatusMask int  // mask of which status of entries to return
	GetMask    int  // mask of what to include in the response
	Local      bool // bool if get should happen from chain not DHT
	Bundle     bool // bool if get should happen from bundle not DHT
}

GetOptions options to holochain level Get functions

type GetReq 

type GetReq struct {
	H          Hash
	StatusMask int
	GetMask    int
}

GetReq holds the data of a get request

type GetResp 

type GetResp struct {
	Entry      GobEntry
	EntryType  string
	Sources    []string
	FollowHash string // hash of new entry if the entry was modified and needs following
}

GetResp holds the data of a get response

type GobEntry 

type GobEntry struct {
	C interface{}
}

GobEntry is a structure for implementing Gob encoding of Entry content

func (*GobEntry) Content 

func (e *GobEntry) Content() interface{}

func (*GobEntry) Marshal 

func (e *GobEntry) Marshal() (b []byte, err error)

func (*GobEntry) Sum 

func (e *GobEntry) Sum(s HashSpec) (h Hash, err error)

func (*GobEntry) Unmarshal 

func (e *GobEntry) Unmarshal(b []byte) (err error)

type Gossip 

type Gossip struct {
	Puts []Put
}

Gossip holds a gossip message

type GossipReq 

type GossipReq struct {
	MyIdx   int
	YourIdx int
}

GossipReq holds a gossip request

type GossiperData 

type GossiperData struct {
	ID     peer.ID
	PutIdx int
}

type HashTable 

type HashTable interface {

	// Open initializes the table
	Open(options interface{}) (err error)

	// Close cleans up any resources used by the table
	Close()

	// Put stores a value to the DHT store
	Put(msg *Message, entryType string, key Hash, src peer.ID, value []byte, status int) (err error)

	// Del moves the given hash to the StatusDeleted status
	Del(msg *Message, key Hash) (err error)

	// Mod moves the given hash to the StatusModified status
	Mod(msg *Message, key Hash, newkey Hash) (err error)

	// Exists checks for the existence of the hash in the table
	Exists(key Hash, statusMask int) (err error)

	// Source returns the source node address of a given hash
	Source(key Hash) (id peer.ID, err error)

	// Get retrieves a value from the DHT store
	Get(key Hash, statusMask int, getMask int) (data []byte, entryType string, sources []string, status int, err error)

	// PutLink associates a link with a stored hash
	PutLink(m *Message, base string, link string, tag string) (err error)

	// DelLink removes a link and tag associated with a stored hash
	DelLink(m *Message, base string, link string, tag string) (err error)

	// GetLinks retrieves meta value associated with a base
	GetLinks(base Hash, tag string, statusMask int) (results []TaggedHash, err error)

	// GetIdx returns the current index of changes to the HashTable
	GetIdx() (idx int, err error)

	// GetIdxMessage returns the messages that causes the change at a given index
	GetIdxMessage(idx int) (msg Message, err error)

	// String converts the table into a human readable string
	String() string

	// JSON converts a DHT into a JSON string representation.
	JSON() (result string, err error)

	// Iterate call fn on all the hashes in the table
	Iterate(fn HashTableIterateFn)
}

HashTable provides an abstraction for storing the necessary DHT data

type HashTableIterateFn 

type HashTableIterateFn func(hash Hash) (stop bool)

type HashType 

type HashType string
type Header struct {
	Type       string
	Time       time.Time
	HeaderLink Hash // link to previous header
	EntryLink  Hash // link to entry
	TypeLink   Hash // link to header of previous header of this type
	Sig        Signature
	Change     Hash
}

Header holds chain links, type, timestamp and signature

func (*Header) Marshal 

func (hd *Header) Marshal() (b []byte, err error)

Marshal writes a header to bytes

func (*Header) Sum 

func (hd *Header) Sum(spec HashSpec) (hash Hash, b []byte, err error)

Sum encodes and creates a hash digest of the header

func (*Header) ToJSON 

func (hd *Header) ToJSON() (result string, err error)

ToJSON serializes a header to JSON

func (*Header) Unmarshal 

func (hd *Header) Unmarshal(b []byte, hashSize int) (err error)

Unmarshal reads a header from bytes

type HoldReq 

type HoldReq struct {
	EntryHash   Hash // hash of the entry responsible for the change
	RelatedHash Hash // hash of the related entry (link=base,del=deleted, mod=modified by)
}

HoldReq holds the data of a change

type HoldResp 

type HoldResp struct {
	Code      int
	Signature Signature
}

HoldResp holds the signature and code of how a hold request was treated

type Holochain 

type Holochain struct {
	Config Config
	// contains filtered or unexported fields
}

Holochain struct holds the full "DNA" of the holochain (all your app code for managing distributed data integrity)

func NewHolochain 

func NewHolochain(agent Agent, root string, format string, zomes ...Zome) Holochain

NewHolochain creates a new holochain structure with a randomly generated ID and default values

func (*Holochain) Activate 

func (h *Holochain) Activate() (err error)

Activate fires up the holochain node, starting node discovery and protocols

func (*Holochain) AddAgentEntry 

func (h *Holochain) AddAgentEntry(revocation Revocation) (headerHash, agentHash Hash, err error)

AddAgentEntry adds a new sys entry type setting the current agent data (identity and key)

func (*Holochain) AddBridgeAsCallee 

func (h *Holochain) AddBridgeAsCallee(fromDNA Hash, appData string) (token string, err error)

AddBridgeAsCallee registers a token for allowing bridged calls from some other app and calls bridgeGenesis in any zomes with bridge functions

func (*Holochain) AddBridgeAsCaller 

func (h *Holochain) AddBridgeAsCaller(bridgeZome string, calleeDNA Hash, calleeName string, token string, url string, appData string) (err error)

AddBridgeAsCaller associates a token with an application DNA hash and url for accessing it it also runs BridgeGenesis in the bridgeZome

func (*Holochain) AddPeer 

func (h *Holochain) AddPeer(pi pstore.PeerInfo) (err error)

AddPeer adds a peer to the peerstore if it passes various checks

func (*Holochain) Agent 

func (h *Holochain) Agent() Agent

Agent exposes the agent element

func (*Holochain) AgentHash 

func (h *Holochain) AgentHash() (id Hash)

AgentHash returns the hash of the Agent entry

func (*Holochain) AgentTopHash 

func (h *Holochain) AgentTopHash() (id Hash)

AgentHash returns the hash of the Agent entry

func (*Holochain) BSget 

func (h *Holochain) BSget() (err error)

func (*Holochain) BSpost 

func (h *Holochain) BSpost() (err error)

func (*Holochain) BridgeCall 

func (h *Holochain) BridgeCall(zomeType string, function string, arguments interface{}, token string) (result interface{}, err error)

BridgeCall executes a function exposed through a bridge

func (*Holochain) BuildBridgeToCallee 

func (h *Holochain) BuildBridgeToCallee(app *BridgeApp) (err error)

BuildBridgeToCallee connects h to a running app specified by BridgeApp that will be the Callee, i.e. the the BridgeCallee

func (*Holochain) BuildBridgeToCaller 

func (h *Holochain) BuildBridgeToCaller(app *BridgeApp, port string) (err error)

BuildBridgeToCaller connects h to a running app specified by BridgeApp that will be the Caller, i.e. the the BridgeCaller

func (*Holochain) Call 

func (h *Holochain) Call(zomeType string, function string, arguments interface{}, exposureContext string) (result interface{}, err error)

Call executes an exposed function

func (*Holochain) Chain 

func (h *Holochain) Chain() (n *Chain)

func (*Holochain) Close 

func (h *Holochain) Close()

Close releases the resources associated with a holochain

func (*Holochain) DBPath 

func (h *Holochain) DBPath() string

DBPath returns a holochain DB path

func (*Holochain) DHT 

func (h *Holochain) DHT() *DHT

DHT exposes the DHT structure

func (*Holochain) DNAHash 

func (h *Holochain) DNAHash() (id Hash)

DNAHash returns the hash of the DNA entry which is also the holochain ID

func (*Holochain) DNAPath 

func (h *Holochain) DNAPath() string

DNAPath returns a holochain DNA path

func (*Holochain) Debug 

func (h *Holochain) Debug(m string)

func (*Holochain) Debugf 

func (h *Holochain) Debugf(m string, args ...interface{})

Debugf sends a formatted string to the debug log

func (*Holochain) EncodeDNA 

func (h *Holochain) EncodeDNA(writer io.Writer) (err error)

EncodeDNA encodes a holochain's DNA to an io.Writer

func (*Holochain) GenChain 

func (h *Holochain) GenChain() (headerHash Hash, err error)

GenChain establishes a holochain instance by creating the initial genesis entries in the chain It assumes a properly set up .holochain sub-directory with a config file and keys for signing.

func (*Holochain) GetBridgeToken 

func (h *Holochain) GetBridgeToken(hash Hash) (token string, url string, err error)

GetBridgeToken returns a token given the a hash

func (*Holochain) GetBridges 

func (h *Holochain) GetBridges() (bridges []Bridge, err error)

GetBridges returns a list of the active bridges on the holochain

func (*Holochain) GetEntryDef 

func (h *Holochain) GetEntryDef(t string) (zome *Zome, d *EntryDef, err error)

GetEntryDef returns an EntryDef of the given name @TODO this makes the incorrect assumption that entry type strings are unique across zomes @see https://github.com/holochain/holochain-proto/issues/730

func (*Holochain) GetPrivateEntryDefs 

func (h *Holochain) GetPrivateEntryDefs() (privateDefs []EntryDef)

func (*Holochain) GetProperty 

func (h *Holochain) GetProperty(prop string) (property string, err error)

GetProperty returns the value of a DNA property

func (*Holochain) GetValidationResponse 

func (h *Holochain) GetValidationResponse(a ValidatingAction, hash Hash) (resp ValidateResponse, err error)

GetValidationResponse check the validation request and builds the validation package based on the app's requirements

func (*Holochain) GetZome 

func (h *Holochain) GetZome(zName string) (z *Zome, err error)

GetZome returns a zome structure given its name

func (*Holochain) HandleAsyncSends 

func (h *Holochain) HandleAsyncSends() (err error)

HandleAsyncSends waits on a channel for asyncronous sends

func (*Holochain) HandlePeerFound 

func (h *Holochain) HandlePeerFound(pi pstore.PeerInfo)

implement peer found function for mdns discovery

func (*Holochain) HashSpec 

func (h *Holochain) HashSpec() HashSpec

HashSpec exposes the hashSpec structure

func (*Holochain) MakeRibosome 

func (h *Holochain) MakeRibosome(t string) (r Ribosome, z *Zome, err error)

MakeRibosome creates a Ribosome object based on the zome type

func (*Holochain) Name 

func (h *Holochain) Name() string

func (*Holochain) NewEntry 

func (h *Holochain) NewEntry(now time.Time, entryType string, entry Entry) (hash Hash, header *Header, err error)

NewEntry adds an entry and it's header to the chain and returns the header and it's hash

func (*Holochain) Node 

func (h *Holochain) Node() *Node

DHT exposes the Node structure

func (*Holochain) NodeIDStr 

func (h *Holochain) NodeIDStr() string

NodeIDStr exposes the agent element

func (*Holochain) Nucleus 

func (h *Holochain) Nucleus() (n *Nucleus)

func (*Holochain) Overlap 

func (h *Holochain) Overlap(hash Hash) (overlap []peer.ID, err error)

Overlap returns a list of all the nodes that overlap for a given hash

func (*Holochain) Prepare 

func (h *Holochain) Prepare() (err error)

Prepare sets up a holochain to run by: loading the schema validators, setting up a Network node and setting up the DHT

func (*Holochain) PrepareHashType 

func (h *Holochain) PrepareHashType() (err error)

PrepareHashType makes sure the given string is a correct multi-hash and stores the code and length to the Holochain struct

func (*Holochain) Query 

func (h *Holochain) Query(options *QueryOptions) (results []QueryResult, err error)

Query scans the local chain and returns a collection of results based on the options specified

func (*Holochain) RedundancyFactor 

func (h *Holochain) RedundancyFactor() int

RedundancyFactor returns the redundancy that was set in the DNA

func (*Holochain) Reset 

func (h *Holochain) Reset() (err error)

Reset deletes all chain and dht data and resets data structures

func (*Holochain) RootPath 

func (h *Holochain) RootPath() string

RootPath returns a holochain root path

func (*Holochain) Send 

func (h *Holochain) Send(basectx context.Context, proto int, to peer.ID, message *Message, timeout time.Duration) (response interface{}, err error)

Send builds a message and either delivers it locally or over the network via node.Send

func (*Holochain) SendAsync 

func (h *Holochain) SendAsync(proto int, to peer.ID, msg *Message, callback *Callback, timeout time.Duration) (err error)

SendAsync builds a message and either delivers it locally or over the network via node.Send but registers a function for asyncronous call back

func (*Holochain) Sign 

func (h *Holochain) Sign(data []byte) (signature Signature, err error)

Sign uses the agent's private key to sign the contents of data

func (*Holochain) StartBackgroundTasks 

func (h *Holochain) StartBackgroundTasks()

StartBackgroundTasks sets the various background processes in motion

func (*Holochain) Started 

func (h *Holochain) Started() bool

Started returns true if the chain has been gened

func (*Holochain) TaskTicker 

func (h *Holochain) TaskTicker(interval time.Duration, fn func(h *Holochain)) chan bool

TaskTicker creates a closure for a holochain task

func (*Holochain) TestPath 

func (h *Holochain) TestPath() string

TestPath returns the path to a holochain's test directory

func (*Holochain) Top 

func (h *Holochain) Top() (top Hash, err error)

Top returns a hash of top header or err if not yet defined

func (*Holochain) UIPath 

func (h *Holochain) UIPath() string

UIPath returns a holochain UI path

func (*Holochain) ValidateAction 

func (h *Holochain) ValidateAction(a ValidatingAction, entryType string, pkg *Package, sources []peer.ID) (def *EntryDef, err error)

ValidateAction runs the different phases of validating an action

func (*Holochain) VerifySignature 

func (h *Holochain) VerifySignature(signature Signature, data string, pubKey ic.PubKey) (matches bool, err error)

VerifySignature uses the signature, data and the given public key to Verify the data was signed by holder of that key

func (*Holochain) Walk 

func (h *Holochain) Walk(fn WalkerFn, entriesToo bool) (err error)

Walk takes the argument fn which must be WalkerFn Every WalkerFn is of the form: func(key *Hash, h *Header, entry interface{}) error

func (*Holochain) World 

func (h *Holochain) World() *World

func (*Holochain) ZomePath 

func (h *Holochain) ZomePath(z *Zome) string

ZomePath returns the path to the zome dna data @todo sanitize the name value

type JSONEntry 

type JSONEntry struct {
	C interface{}
}

JSONEntry is a structure for implementing JSON encoding of Entry content

func (*JSONEntry) Content 

func (e *JSONEntry) Content() interface{}

func (*JSONEntry) Marshal 

func (e *JSONEntry) Marshal() (b []byte, err error)

func (*JSONEntry) Unmarshal 

func (e *JSONEntry) Unmarshal(b []byte) (err error)

type JSONSchemaValidator 

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

func BuildJSONSchemaValidatorFromFile 

func BuildJSONSchemaValidatorFromFile(path string) (validator *JSONSchemaValidator, err error)

func BuildJSONSchemaValidatorFromString 

func BuildJSONSchemaValidatorFromString(input string) (validator *JSONSchemaValidator, err error)

func (*JSONSchemaValidator) Validate 

func (v *JSONSchemaValidator) Validate(entry interface{}) (err error)

type JSRibosome 

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

JSRibosome holds data needed for the Javascript VM

func (*JSRibosome) BridgeGenesis 

func (jsr *JSRibosome) BridgeGenesis(side int, dnaHash Hash, data string) (err error)

BridgeGenesis runs the bridging genesis function this function gets called on both sides of the bridging

func (*JSRibosome) BundleCanceled 

func (jsr *JSRibosome) BundleCanceled(reason string) (response string, err error)

BundleCancel calls the app bundleCanceled function

func (*JSRibosome) Call 

func (jsr *JSRibosome) Call(fn *FunctionDef, params interface{}) (result interface{}, err error)

Call calls the zygo function that was registered with expose

func (*JSRibosome) ChainGenesis 

func (jsr *JSRibosome) ChainGenesis() (err error)

ChainGenesis runs the application genesis function this function gets called after the genesis entries are added to the chain

func (*JSRibosome) Receive 

func (jsr *JSRibosome) Receive(from string, msg string) (response string, err error)

Receive calls the app receive function for node-to-node messages

func (*JSRibosome) Run 

func (jsr *JSRibosome) Run(code string) (result interface{}, err error)

Run executes javascript code

func (*JSRibosome) RunAsyncSendResponse 

func (jsr *JSRibosome) RunAsyncSendResponse(response AppMsg, callback string, callbackID string) (result interface{}, err error)

func (*JSRibosome) Type 

func (jsr *JSRibosome) Type() string

Type returns the string value under which this ribosome is registered

func (*JSRibosome) ValidateAction 

func (jsr *JSRibosome) ValidateAction(action Action, def *EntryDef, pkg *ValidationPackage, sources []string) (err error)

ValidateAction builds the correct validation function based on the action an calls it

func (*JSRibosome) ValidatePackagingRequest 

func (jsr *JSRibosome) ValidatePackagingRequest(action ValidatingAction, def *EntryDef) (req PackagingReq, err error)

ValidatePackagingRequest calls the app for a validation packaging request for an action

type LibP2PAgent 

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

func (*LibP2PAgent) AgentEntry 

func (a *LibP2PAgent) AgentEntry(revocation Revocation) (entry AgentEntry, err error)

func (*LibP2PAgent) AgentType 

func (a *LibP2PAgent) AgentType() AgentType

func (*LibP2PAgent) EncodePubKey 

func (a *LibP2PAgent) EncodePubKey() (b58pk string, err error)

func (*LibP2PAgent) GenKeys 

func (a *LibP2PAgent) GenKeys(seed io.Reader) (err error)

func (*LibP2PAgent) Identity 

func (a *LibP2PAgent) Identity() AgentIdentity

func (*LibP2PAgent) NodeID 

func (a *LibP2PAgent) NodeID() (nodeID peer.ID, nodeIDStr string, err error)

func (*LibP2PAgent) PrivKey 

func (a *LibP2PAgent) PrivKey() ic.PrivKey

func (*LibP2PAgent) PubKey 

func (a *LibP2PAgent) PubKey() ic.PubKey

func (*LibP2PAgent) SetIdentity 

func (a *LibP2PAgent) SetIdentity(id AgentIdentity)
type Link struct {
	LinkAction string // StatusAction (either AddAction or DelAction)
	Base       string // hash of entry (perhaps elsewhere) to which we are attaching the link
	Link       string // hash of entry being linked to
	Tag        string // tag
}

Link structure for holding meta tagging of linking entry

type LinkQuery 

type LinkQuery struct {
	Base       Hash
	T          string
	StatusMask int
}

LinkQuery holds a getLinks query

type LinkQueryResp 

type LinkQueryResp struct {
	Links []TaggedHash
}

LinkQueryResp holds response to getLinks query

type LinksEntry 

type LinksEntry struct {
	Links []Link
}

LinksEntry holds one or more links

func LinksEntryFromJSON 

func LinksEntryFromJSON(j string) (entry LinksEntry, err error)

func (*LinksEntry) ToJSON 

func (ae *LinksEntry) ToJSON() (encodedEntry string, err error)

type ListAddReq 

type ListAddReq struct {
	ListType    string
	Peers       []string
	WarrantType int
	Warrant     []byte
}

type Logger 

type Logger struct {
	Name    string
	Enabled bool
	Format  string

	Prefix      string
	PrefixColor *color.Color
	// contains filtered or unexported fields
}

Logger holds logger configuration

func (*Logger) GetColor 

func (h *Logger) GetColor(colorName string) *color.Color

func (*Logger) Log 

func (l *Logger) Log(m interface{})

func (*Logger) Logf 

func (l *Logger) Logf(m string, args ...interface{})

func (*Logger) New 

func (l *Logger) New(w io.Writer) (err error)

func (*Logger) SetPrefix 

func (l *Logger) SetPrefix(prefixFormat string)

type Loggers 

type Loggers struct {
	App        Logger
	Debug      Logger
	DHT        Logger
	World      Logger
	Gossip     Logger
	TestPassed Logger
	TestFailed Logger
	TestInfo   Logger
}

Loggers holds the logging structures for the different parts of the system

type Message 

type Message struct {
	Type MsgType
	Time time.Time
	From peer.ID
	Body interface{}
}

Message represents data that can be sent to node in the network

func (*Message) Decode 

func (m *Message) Decode(r io.Reader) (err error)

Decode converts a message from gob format @TODO generalize for other message encoding formats

func (*Message) Encode 

func (m *Message) Encode() (data []byte, err error)

Encode codes a message to gob format @TODO generalize for other message encoding formats

func (*Message) Fingerprint 

func (m *Message) Fingerprint() (f Hash, err error)

Fingerprint creates a hash of a message

func (Message) String 

func (m Message) String() string

String converts a message to a nice string

type MigrateEntry 

type MigrateEntry struct {
	Type    string
	DNAHash Hash
	Key     Hash
	Data    string
}

MigrateEntry struct is the record of a chain opening or closing

func MigrateEntryFromJSON 

func MigrateEntryFromJSON(j string) (entry MigrateEntry, err error)

func (*MigrateEntry) Def 

func (e *MigrateEntry) Def() *EntryDef

@see https://github.com/holochain/holochain-proto/issues/731

func (*MigrateEntry) ToJSON 

func (e *MigrateEntry) ToJSON() (encodedEntry string, err error)

type ModAgentOptions 

type ModAgentOptions struct {
	Identity   string
	Revocation string
}

type MsgType 

type MsgType int8
const (
	ERROR_RESPONSE MsgType = iota
	OK_RESPONSE

	PUT_REQUEST
	DEL_REQUEST
	MOD_REQUEST
	GET_REQUEST
	LINK_REQUEST
	GETLINK_REQUEST
	DELETELINK_REQUEST

	GOSSIP_REQUEST

	VALIDATE_PUT_REQUEST
	VALIDATE_LINK_REQUEST
	VALIDATE_DEL_REQUEST
	VALIDATE_MOD_REQUEST

	APP_MESSAGE

	LISTADD_REQUEST

	FIND_NODE_REQUEST
)

@TODO don't have order dependant constants https://github.com/holochain/holochain-proto/issues/713

func (MsgType) String 

func (msgType MsgType) String() string

type Node 

type Node struct {
	HashAddr peer.ID
	NetAddr  ma.Multiaddr
	// contains filtered or unexported fields
}

Node represents a node in the network

func NewNode 

func NewNode(listenAddr string, protoMux string, agent *LibP2PAgent, enableNATUPnP bool, log *Logger) (node *Node, err error)

NewNode creates a new node with given multiAddress listener string and identity

func (*Node) Block 

func (node *Node) Block(addr peer.ID)

Block adds a peer to the blocklist

func (*Node) Close 

func (node *Node) Close() error

Close shuts down the node

func (*Node) Context 

func (node *Node) Context() context.Context

Context return node's context

func (*Node) Distance 

func (node *Node) Distance(id peer.ID) *big.Int

Distance returns the nodes peer distance to another node for purposes of gossip

func (*Node) EnableMDNSDiscovery 

func (n *Node) EnableMDNSDiscovery(h *Holochain, interval time.Duration) (err error)

func (*Node) ExternalAddr 

func (n *Node) ExternalAddr() ma.Multiaddr

func (*Node) FindLocal 

func (node *Node) FindLocal(id peer.ID) pstore.PeerInfo

FindLocal looks for a peer with a given ID connected to this node and returns its peer info

func (*Node) FindPeer 

func (node *Node) FindPeer(ctx context.Context, id peer.ID) (pstore.PeerInfo, error)

FindPeer searches for a peer with given ID. it is also an implementation the FindPeer() method of the RoutedHost interface in go-libp2p/p2p/host/routed and makes the Node object the "Router"

func (*Node) GetClosestPeers 

func (node *Node) GetClosestPeers(ctx context.Context, key Hash) (<-chan peer.ID, error)

Kademlia 'node lookup' operation. Returns a channel of the K closest peers to the given key

func (*Node) InitBlockedList 

func (node *Node) InitBlockedList(list PeerList)

InitBlockedList sets up the blockedlist from a PeerList

func (*Node) IsBlocked 

func (node *Node) IsBlocked(addr peer.ID) (ok bool)

IsBlockedListed checks to see if a node is on the blockedlist

func (*Node) NewMessage 

func (node *Node) NewMessage(t MsgType, body interface{}) (msg *Message)

NewMessage creates a message from the node with a new current timestamp

func (*Node) Process 

func (node *Node) Process() goprocess.Process

Process return node's process

func (*Node) Send 

func (node *Node) Send(ctx context.Context, proto int, addr peer.ID, m *Message) (response Message, err error)

Send delivers a message to a node via the given protocol

func (*Node) StartProtocol 

func (node *Node) StartProtocol(h *Holochain, proto int) (err error)

StartProtocol initiates listening for a protocol on the node

func (*Node) Unblock 

func (node *Node) Unblock(addr peer.ID)

Unblock removes a peer from the blocklist

type NodeRecord 

type NodeRecord struct {
	PeerInfo  pstore.PeerInfo
	PubKey    ic.PubKey
	IsHolding map[Hash]bool
}

NodeRecord stores the necessary information about other nodes in the world model

type Nucleus 

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

Nucleus encapsulates Application parts: Ribosomes to run code in Zomes, plus application validation and direct message passing protocols

func NewNucleus 

func NewNucleus(h *Holochain, dna *DNA) *Nucleus

NewNucleus creates a new Nucleus structure

func (*Nucleus) DNA 

func (n *Nucleus) DNA() (dna *DNA)

func (*Nucleus) RunGenesis 

func (n *Nucleus) RunGenesis() (err error)

func (*Nucleus) Start 

func (n *Nucleus) Start() (err error)

type Package 

type Package struct {
	Chain []byte
}

Package holds app specified data needed for validation (wire package)

func MakePackage 

func MakePackage(h *Holochain, req PackagingReq) (pkg Package, err error)

MakePackage converts a package request into a package, loading chain data as necessary this is the package that gets sent over the wire. Chain DNA is omitted in this package because it can be added at the destination and the chain will still validate.

type PackagingReq 

type PackagingReq map[string]interface{}

PackagingReq holds a request from an app for data to be included in the validation response

type PeerInfo 

type PeerInfo struct {
	ID    []byte   // byte version peer.ID
	Addrs [][]byte // byte version of multiaddrs
}

an encodable version of pstore.PeerInfo which gob doesn't like also libp2p encodes other stuff like connection type into this which we may have to do too.

type PeerList 

type PeerList struct {
	Type    PeerListType
	Records []PeerRecord
}

type PeerListType 

type PeerListType string

we also gossip about peers too, keeping lists of different peers e.g. blockedlist etc

type PeerRecord 

type PeerRecord struct {
	ID      peer.ID
	Warrant string // evidence, reasons, documentation of why peer is in this list
}

type Progenitor 

type Progenitor struct {
	Identity string
	PubKey   []byte
}

Progenitor holds data on the creator of the DNA

type Protocol 

type Protocol struct {
	ID       protocol.ID
	Receiver ReceiverFn
}

Protocol encapsulates data for our different protocols

type Put 

type Put struct {
	Idx int
	M   Message
}

Put holds a put or link for gossiping

type QueryConstrain 

type QueryConstrain struct {
	EntryTypes []string
	Contains   string
	Equals     string
	Matches    string
	Count      int
	Page       int
}

type QueryOptions 

type QueryOptions struct {
	Return    QueryReturn
	Constrain QueryConstrain
	Order     QueryOrder
	Bundle    bool
}

type QueryOrder 

type QueryOrder struct {
	Ascending bool
}

type QueryResult 

type QueryResult struct {
	Header *Header
	Entry  Entry
}

type QueryReturn 

type QueryReturn struct {
	Hashes  bool
	Entries bool
	Headers bool
}

type ReceiverFn 

type ReceiverFn func(h *Holochain, m *Message) (response interface{}, err error)

type Revocation 

type Revocation interface {
	Verify() error
	Marshal() (string, error)
	Unmarshal(string) error
}

type Ribosome 

type Ribosome interface {
	Type() string
	ValidateAction(action Action, def *EntryDef, pkg *ValidationPackage, sources []string) (err error)
	ValidatePackagingRequest(action ValidatingAction, def *EntryDef) (req PackagingReq, err error)
	ChainGenesis() error
	BridgeGenesis(side int, dnaHash Hash, data string) error
	Receive(from string, msg string) (response string, err error)
	Call(fn *FunctionDef, params interface{}) (interface{}, error)
	Run(code string) (result interface{}, err error)
	RunAsyncSendResponse(response AppMsg, callback string, callbackID string) (result interface{}, err error)
	BundleCanceled(reason string) (response string, err error)
}

Ribosome type abstracts the functions of code execution environments

func CreateRibosome 

func CreateRibosome(h *Holochain, zome *Zome) (Ribosome, error)

CreateRibosome returns a new Ribosome of the given type

func NewJSRibosome 

func NewJSRibosome(h *Holochain, zome *Zome) (n Ribosome, err error)

NewJSRibosome factory function to build a javascript execution environment for a zome

func NewZygoRibosome 

func NewZygoRibosome(h *Holochain, zome *Zome) (n Ribosome, err error)

NewZygoRibosome factory function to build a zygo execution environment for a zome

type RibosomeFactory 

type RibosomeFactory func(h *Holochain, zome *Zome) (Ribosome, error)

type RoutingTable 

type RoutingTable struct {

	// kBuckets define all the fingers to other nodes.
	Buckets []*Bucket

	// notification functions
	PeerRemoved func(peer.ID)
	PeerAdded   func(peer.ID)
	// contains filtered or unexported fields
}

RoutingTable defines the routing table.

func NewRoutingTable 

func NewRoutingTable(bucketsize int, localID peer.ID, latency time.Duration, m pstore.Metrics) *RoutingTable

NewRoutingTable creates a new routing table with a given bucketsize, local ID, and latency tolerance.

func (*RoutingTable) Find 

func (rt *RoutingTable) Find(id peer.ID) peer.ID

Find a specific peer by ID or return nil

func (*RoutingTable) IsEmpty 

func (rt *RoutingTable) IsEmpty() (empty bool)

IsEmpty returns bool

func (*RoutingTable) ListPeers 

func (rt *RoutingTable) ListPeers() []peer.ID

ListPeers takes a RoutingTable and returns a list of all peers from all buckets in the table. NOTE: This is potentially unsafe... use at your own risk

func (*RoutingTable) NearestPeer 

func (rt *RoutingTable) NearestPeer(hash Hash) peer.ID

NearestPeer returns a single peer that is nearest to the given Hash

func (*RoutingTable) NearestPeers 

func (rt *RoutingTable) NearestPeers(hash Hash, count int) []peer.ID

NearestPeers returns a list of the 'count' closest peers to the given ID

func (*RoutingTable) Print 

func (rt *RoutingTable) Print()

Print prints a descriptive statement about the provided RoutingTable

func (*RoutingTable) Remove 

func (rt *RoutingTable) Remove(p peer.ID)

Remove deletes a peer from the routing table. This is to be used when we are sure a node has disconnected completely.

func (*RoutingTable) Size 

func (rt *RoutingTable) Size() int

Size returns the total number of peers in the routing table

func (*RoutingTable) Update 

func (rt *RoutingTable) Update(p peer.ID)

Update adds or moves the given peer to the front of its respective bucket If a peer gets removed from a bucket, it is returned

type SchemaValidator 

type SchemaValidator interface {
	Validate(interface{}) error
}

SchemaValidator interface for schema validation

type SelfRevocation 

type SelfRevocation struct {
	Data   []byte // concatination of key length, two marshaled keys, and revocation properties
	OldSig []byte // signature of oldnew by old key
	NewSig []byte // signature by oldnew new key
}

SelfRevocation holds the old key being revoked and the new key, other revocation data and the two cryptographic signatures of that data by the two keys to confirm the revocation

func NewSelfRevocation 

func NewSelfRevocation(old, new ic.PrivKey, payload []byte) (rP *SelfRevocation, err error)

func (*SelfRevocation) Marshal 

func (r *SelfRevocation) Marshal() (data string, err error)

func (*SelfRevocation) Unmarshal 

func (r *SelfRevocation) Unmarshal(data string) (err error)

func (*SelfRevocation) Verify 

func (r *SelfRevocation) Verify() (err error)

Verify confirms that a self-revocation is properly signed

type SelfRevocationWarrant 

type SelfRevocationWarrant struct {
	Revocation SelfRevocation
}

SelfRevocationWarrant warrants that the first party revoked its own key in favor of the second

func NewSelfRevocationWarrant 

func NewSelfRevocationWarrant(revocation *SelfRevocation) (wP *SelfRevocationWarrant, err error)

func (*SelfRevocationWarrant) Decode 

func (w *SelfRevocationWarrant) Decode(data []byte) (err error)

func (*SelfRevocationWarrant) Encode 

func (w *SelfRevocationWarrant) Encode() (data []byte, err error)

func (*SelfRevocationWarrant) Parties 

func (w *SelfRevocationWarrant) Parties() (parties []Hash, err error)

func (*SelfRevocationWarrant) Property 

func (w *SelfRevocationWarrant) Property(key string) (value interface{}, err error)

func (*SelfRevocationWarrant) Type 

func (w *SelfRevocationWarrant) Type() int

func (*SelfRevocationWarrant) Verify 

func (w *SelfRevocationWarrant) Verify(h *Holochain) (err error)

type SendOptions 

type SendOptions struct {
	Callback *Callback
	Timeout  int
}

type Service 

type Service struct {
	Settings     ServiceConfig
	DefaultAgent Agent
	Path         string
}

A Service is a Holochain service data structure

func Init 

func Init(root string, identity AgentIdentity, seed io.Reader) (service *Service, err error)

Init initializes service defaults including a signing key pair for an agent and writes them out to configuration files in the root path (making the directory if necessary)

func LoadService 

func LoadService(path string) (service *Service, err error)

LoadService creates a service object from a configuration file

func SetupTestService 

func SetupTestService() (d string, s *Service)

func (*Service) Clone 

func (s *Service) Clone(srcPath string, root string, agent Agent, new bool, initDB bool) (hP *Holochain, err error)

Clone copies DNA files from a source directory bool new indicates if this clone should create a new DNA (when true) or act as a Join

func (*Service) ConfiguredChains 

func (s *Service) ConfiguredChains() (chains map[string]*Holochain, err error)

ConfiguredChains returns a list of the configured chains for the given service

func (*Service) GenChain 

func (s *Service) GenChain(name string) (h *Holochain, err error)

GenChain adds the genesis entries to a newly cloned or joined chain

func (*Service) InitAppDir 

func (service *Service) InitAppDir(root string, encodingFormat string) (err error)

func (*Service) IsConfigured 

func (s *Service) IsConfigured(name string) (f string, err error)

IsConfigured checks a directory for correctly set up holochain configuration file

func (*Service) ListChains 

func (s *Service) ListChains() (list string)

List chains produces a textual representation of the chains in the .holochain directory

func (*Service) Load 

func (s *Service) Load(name string) (h *Holochain, err error)

Load instantiates a Holochain instance from disk

func (*Service) MakeAppPackage 

func (service *Service) MakeAppPackage(h *Holochain) (data []byte, err error)

MakeAppPackage creates a package blob from a given holochain

func (*Service) MakeTestingApp 

func (s *Service) MakeTestingApp(root string, encodingFormat string, initDB bool, newUUID bool, agent Agent) (h *Holochain, err error)

MakeTestingApp generates a holochain used for testing purposes

func (*Service) SaveFromAppPackage 

func (service *Service) SaveFromAppPackage(reader io.Reader, path string, name string, agent Agent, decodingFormat string, encodingFormat string, newUUID bool) (appPackage *AppPackage, err error)

SaveFromAppPackage writes out a holochain application based on appPackage file to path

type ServiceConfig 

type ServiceConfig struct {
	DefaultPeerModeAuthor  bool
	DefaultPeerModeDHTNode bool
	DefaultBootstrapServer string
	DefaultEnableMDNS      bool
	DefaultEnableNATUPnP   bool
}

ServiceConfig holds the service settings

func (*ServiceConfig) Validate 

func (c *ServiceConfig) Validate() (err error)

Validate validates settings values

type Signature 

type Signature struct {
	S []byte
}

func SignatureFromB58String 

func SignatureFromB58String(encoded string) (sig Signature)

SignatureFromB58String encodes a signature as a b58string

func (Signature) B58String 

func (sig Signature) B58String() (result string)

B58String encodes a signature as a b58string

func (Signature) Equal 

func (sig1 Signature) Equal(sig2 Signature) bool

Equal tests signature equality

type TaggedHash 

type TaggedHash struct {
	H         string // the hash of the link; gets filled by dht base node when answering get link request
	E         string // the value of link, gets filled if options set Load to true
	EntryType string // the entry type of the link, gets filled if options set Load to true
	T         string // the tag of the link, gets filled only if a tag wasn't specified and all tags are being returns
	Source    string // the statuses on the link, gets filled if options set Load to true
}

TaggedHash holds associated entries for the LinkQueryResponse

type TestConfig 

type TestConfig struct {
	GossipInterval int // interval in milliseconds between gossips
	Duration       int // if non-zero number of seconds to keep all nodes alive
	Clone          []CloneSpec
}

TestConfig holds the configuration options for a test

func LoadTestConfig 

func LoadTestConfig(dir string) (config *TestConfig, err error)

LoadTestConfig unmarshals test json data

type TestData 

type TestData struct {
	Convey    string        // a human readable description of the tests intent
	Zome      string        // the zome in which to find the function
	FnName    string        // the function to call
	Input     interface{}   // the function's input
	Output    interface{}   // the expected output to match against (full match)
	Err       interface{}   // the expected error to match against
	ErrMsg    string        // the expected error message to match against
	Regexp    string        // the expected out to match again (regular expression)
	Time      time.Duration // offset in milliseconds from the start of the test at which to run this test.
	Wait      time.Duration // time in milliseconds to wait before running this test from when the previous ran
	Exposure  string        // the exposure context for the test call (defaults to ZOME_EXPOSURE)
	Raw       bool          // set to true if we should ignore fnName and just call input as raw code in the zome, useful for testing helper functions and validation functions
	Repeat    int           // number of times to repeat this test, useful for scenario testing
	Benchmark bool          // activate benchmarking for this test
}

TestData holds a test entry for a chain

type TestFixtures 

type TestFixtures struct {
	Agents []AgentFixture
}

TestFixtures defines data needed to run tests

type TestSet 

type TestSet struct {
	Tests     []TestData
	Identity  string
	Fixtures  TestFixtures
	Benchmark bool // activate benchmarking for all tests
}

TestSet holds a set of tests plus configuration and fixture data for those tests

func LoadTestFile 

func LoadTestFile(dir string, file string) (tests TestSet, err error)

LoadTestFile unmarshals test json data

type ValidateQuery 

type ValidateQuery struct {
	H Hash
}

ValidateQuery holds the data from a validation query on the Source protocol

type ValidateResponse 

type ValidateResponse struct {
	Type    string
	Header  Header
	Entry   GobEntry
	Package Package
}

ValidateResponse holds the response to committing validates (PUT/MOD/DEL)

type ValidatingAction 

type ValidatingAction interface {
	Name() string
	SysValidation(h *Holochain, def *EntryDef, pkg *Package, sources []peer.ID) (err error)
	Receive(dht *DHT, msg *Message) (response interface{}, err error)
	CheckValidationRequest(def *EntryDef) (err error)
}

ValidatingAction provides an abstraction for grouping all the actions that participate in validation loop

type ValidationPackage 

type ValidationPackage struct {
	Chain *Chain
}

ValidationPackage holds app specified data needed for validation. This version holds the package with any chain data un-marshaled after validation for passing into the app for app level validation

func MakeValidationPackage 

func MakeValidationPackage(h *Holochain, pkg *Package) (vpkg *ValidationPackage, err error)

MakeValidationPackage converts a received Package into a ValidationPackage and validates any chain data that was included

type WalkerFn 

type WalkerFn func(key *Hash, header *Header, entry Entry) error

WalkerFn a function type for call Walk

type Warrant 

type Warrant interface {

	// Int returns the warrant type
	Type() int

	// Parties returns the hashes of the public keys of the signers of the warrant
	Parties() ([]Hash, error)

	// Verify confirms that the content of a warrant is valid and has been signed by the
	// the parties in it.  Requires a Holochain object for context, returns nil if it
	// verfies or an error
	Verify(h *Holochain) error

	// Property returns a value of a property attested to by the warrant
	// returns a WarrantPropertyNotFoundErr if the warrant doesn't have that property
	Property(key string) (value interface{}, err error)

	// Encode marshals the warrant into bytes for sending over the wire
	Encode() (data []byte, err error)

	// Decode unmarshals a warrant from bytes
	Decode(data []byte) (err error)
}

Warrant abstracts the notion of a multi-party cryptographically verifiable signed claim the meaning of the warrant is understood by the warrant name an/or by properties contained in it

func DecodeWarrant 

func DecodeWarrant(warrantType int, data []byte) (w Warrant, err error)

type World 

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

World holds the data of a nodes' world model

func NewWorld 

func NewWorld(me peer.ID, ht HashTable, logger *Logger) *World

NewWorld creates and empty world model

func (*World) AddNode 

func (world *World) AddNode(pi pstore.PeerInfo, pubKey ic.PubKey) (err error)

AddNode adds a node to the world model

func (*World) AllNodes 

func (world *World) AllNodes() (nodes []peer.ID, err error)

AllNodes returns a list of all the nodes in the world model.

func (*World) GetNodeRecord 

func (world *World) GetNodeRecord(ID peer.ID) (record *NodeRecord)

GetNodeRecord returns the peer's node record NOTE: do not modify the contents of the returned record! not thread safe

func (*World) IsHolding 

func (world *World) IsHolding(ID peer.ID, hash Hash) (holding bool, err error)

IsHolding returns whether a node is holding a particular hash

func (*World) Responsible 

func (world *World) Responsible() (entries []Hash, err error)

Responsible returns a list of all the entries I'm responsible for holding

func (*World) SetNodeHolding 

func (world *World) SetNodeHolding(ID peer.ID, hash Hash) (err error)

SetNodeHolding marks a node as holding a particular hash

func (*World) UpdateResponsible 

func (world *World) UpdateResponsible(hash Hash, redundancy int) (responsible bool, err error)

UpdateResponsible calculates the list of nodes believed to be responsible for a given hash note that if redundancy is 0 the assumption is that all nodes are responsible

type Zome 

type Zome struct {
	Name         string
	Description  string
	Code         string
	Entries      []EntryDef
	RibosomeType string
	Functions    []FunctionDef
	BridgeFuncs  []string // functions in zome that can be bridged to by callerApp
	//	BridgeCallee Hash     // dna Hash of provider App that this zome will call
	Config map[string]interface{}
}

Zome struct encapsulates logically related code, from a "chromosome"

func (*Zome) CodeFileName 

func (zome *Zome) CodeFileName() string

func (*Zome) GetEntryDef 

func (z *Zome) GetEntryDef(entryName string) (e *EntryDef, err error)

GetEntryDef returns the entry def structure

func (*Zome) GetFunctionDef 

func (zome *Zome) GetFunctionDef(fnName string) (fn *FunctionDef, err error)

GetFunctionDef returns the exposed function spec for the given zome and function

func (*Zome) GetPrivateEntryDefs 

func (z *Zome) GetPrivateEntryDefs() (privateDefs []EntryDef)

func (*Zome) MakeRibosome 

func (zome *Zome) MakeRibosome(h *Holochain) (r Ribosome, err error)

type ZomeFile 

type ZomeFile struct {
	Name         string
	Description  string
	CodeFile     string
	RibosomeType string
	BridgeFuncs  []string // functions in zome that can be bridged to by fromApp
	Config       map[string]interface{}
	Entries      []EntryDefFile
	Functions    []FunctionDef
}

type ZygoRibosome 

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

ZygoRibosome holds data needed for the Zygo VM

func (*ZygoRibosome) BridgeGenesis 

func (z *ZygoRibosome) BridgeGenesis(side int, dnaHash Hash, data string) (err error)

BridgeGenesis runs the bridging genesis function this function gets called on both sides of the bridging

func (*ZygoRibosome) BundleCanceled 

func (z *ZygoRibosome) BundleCanceled(reason string) (response string, err error)

BundleCancel calls the app bundleCanceled function

func (*ZygoRibosome) Call 

func (z *ZygoRibosome) Call(fn *FunctionDef, params interface{}) (result interface{}, err error)

Call calls the zygo function that was registered with expose

func (*ZygoRibosome) ChainGenesis 

func (z *ZygoRibosome) ChainGenesis() (err error)

ChainGenesis runs the application genesis function this function gets called after the genesis entries are added to the chain

func (*ZygoRibosome) Receive 

func (z *ZygoRibosome) Receive(from string, msg string) (response string, err error)

Receive calls the app receive function for node-to-node messages

func (*ZygoRibosome) Run 

func (z *ZygoRibosome) Run(code string) (result interface{}, err error)

Run executes zygo code

func (*ZygoRibosome) RunAsyncSendResponse 

func (z *ZygoRibosome) RunAsyncSendResponse(response AppMsg, callback string, callbackID string) (result interface{}, err error)

func (*ZygoRibosome) Type 

func (z *ZygoRibosome) Type() string

Type returns the string value under which this ribosome is registered

func (*ZygoRibosome) ValidateAction 

func (z *ZygoRibosome) ValidateAction(action Action, def *EntryDef, pkg *ValidationPackage, sources []string) (err error)

ValidateAction builds the correct validation function based on the action an calls it

func (*ZygoRibosome) ValidatePackagingRequest 

func (z *ZygoRibosome) ValidatePackagingRequest(action ValidatingAction, def *EntryDef) (req PackagingReq, err error)

ValidatePackagingRequest calls the app for a validation packaging request for an action

Source Files

View all Source files

Directories

Path Synopsis
cmd
bs
hcadmin
hcd
hcdev

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.