[FAB-4371] - Chaincode Dev Mode

Adds a docker environment for running peer in dev mode
pre-baked crypto and orderer/channel artifacts
README still needs an updated curl command to bundle
these scripts.
simplified some of the paths
add sacc from write your first chaincode
remove binary

Change-Id: Ic1537987c819f0350ae6dbf740fd00e1571045e5
Signed-off-by: Nick Gaski <ngaski@us.ibm.com>
Signed-off-by: Christopher Ferris <chrisfer@us.ibm.com>

.gitignore

@@ -11,3 +11,6 @@ first-network/channel-artifacts/*.tx
 first-network/channel-artifacts/*.block
 first-network/crypto-config/*
 
+chaincode-docker-devmode/myc.block
+chaincode-docker-devmode/chaincode/sacc/sacc
+chaincode-docker-devmode/chaincode/chaincode_example02/chaincode_example02

chaincode-docker-devmode/README.rst

@@ -0,0 +1,140 @@
+Using dev mode
+==============
+
+Normally chaincodes are started and maintained by peer. However in “dev
+mode", chaincode is built and started by the user. This mode is useful
+during chaincode development phase for rapid code/build/run/debug cycle
+turnaround.
+
+We start "dev mode" by leveraging pre-generated orderer and channel artifacts for
+a sample dev network. As such, the user can immediately jump into the process
+of compiling chaincode and driving calls.
+
+Install Fabric Samples
+----------------------
+
+If you haven't already done so, please install the :doc:`samples`.
+
+Navigate to the ``chaincode-docker-devmode`` directory of the ``fabric-samples``
+clone:
+
+.. code:: bash
+
+ cd chaincode-docker-devmode
+
+Download docker images
+^^^^^^^^^^^^^^^^^^^^^^
+
+We need four docker images in order for "dev mode" to run against the supplied
+docker compose script. If you installed the ``fabric-samples`` repo clone and
+followed the instructions to :ref:`download-platform-specific-binaries`, then
+you should have the necessary Docker images installed locally.
+
+.. note:: If you choose to manually pull the images then you must retag them as
+ ``latest``.
+
+Issue a ``docker images`` command to reveal your local Docker Registry. You
+should see something similar to following:
+
+.. code:: bash
+
+ docker images
+ REPOSITORY TAG IMAGE ID CREATED SIZE
+ hyperledger/fabric-tools latest e09f38f8928d 4 hours ago 1.32 GB
+ hyperledger/fabric-tools x86_64-1.0.0-rc1-snapshot-f20846c6 e09f38f8928d 4 hours ago 1.32 GB
+ hyperledger/fabric-orderer latest 0df93ba35a25 4 hours ago 179 MB
+ hyperledger/fabric-orderer x86_64-1.0.0-rc1-snapshot-f20846c6 0df93ba35a25 4 hours ago 179 MB
+ hyperledger/fabric-peer latest 533aec3f5a01 4 hours ago 182 MB
+ hyperledger/fabric-peer x86_64-1.0.0-rc1-snapshot-f20846c6 533aec3f5a01 4 hours ago 182 MB
+ hyperledger/fabric-ccenv latest 4b70698a71d3 4 hours ago 1.29 GB
+ hyperledger/fabric-ccenv x86_64-1.0.0-rc1-snapshot-f20846c6 4b70698a71d3 4 hours ago 1.29 GB
+
+.. note:: If you retrieved the images through the :ref:`download-platform-specific-binaries`,
+ then you will see additional images listed. However, we are only concerned with
+ these four.
+
+Now open three terminals and navigate to your ``chaincode-docker-devmode``
+directory in each.
+
+Terminal 1 - Start the network
+------------------------------
+
+.. code:: bash
+
+ docker-compose -f docker-compose-simple.yaml up
+
+The above starts the network with the ``SingleSampleMSPSolo`` orderer profile and
+launches the peer in "dev mode". It also launches two additional containers -
+one for the chaincode environment and a CLI to interact with the chaincode. The
+commands for create and join channel are embedded in the CLI container, so we
+can jump immediately to the chaincode calls.
+
+Terminal 2 - Build & start the chaincode
+----------------------------------------
+
+.. code:: bash
+
+ docker exec -it chaincode bash
+
+You should see the following:
+
+.. code:: bash
+
+ root@d2629980e76b:/opt/gopath/src/chaincode#
+
+Now, compile your chaincode:
+
+.. code:: bash
+
+ cd chaincode_example02
+ go build
+
+Now run the chaincode:
+
+.. code:: bash
+
+ CORE_PEER_ADDRESS=peer:7051 CORE_CHAINCODE_ID_NAME=mycc:0 ./chaincode_example02
+
+The chaincode is started with peer and chaincode logs indicating successful registration with the peer.
+Note that at this stage the chaincode is not associated with any channel. This is done in subsequent steps
+using the ``instantiate`` command.
+
+Terminal 3 - Use the chaincode
+------------------------------
+
+Even though you are in ``--peer-chaincodedev`` mode, you still have to install the
+chaincode so the life-cycle system chaincode can go through its checks normally.
+This requirement may be removed in future when in ``--peer-chaincodedev`` mode.
+
+We'll leverage the CLI container to drive these calls.
+
+.. code:: bash
+
+ docker exec -it cli bash
+
+.. code:: bash
+
+ peer chaincode install -p chaincodedev/chaincode/chaincode_example02 -n mycc -v 0
+ peer chaincode instantiate -n mycc -v 0 -c '{"Args":["init","a","100","b","200"]}' -C myc
+
+Now issue an invoke to move ``10`` from ``a`` to ``b``.
+
+.. code:: bash
+
+ peer chaincode invoke -n mycc -c '{"Args":["invoke","a","b","10"]}' -C myc
+
+Finally, query ``a``. We should see a value of ``90``.
+
+.. code:: bash
+
+ peer chaincode query -n mycc -c '{"Args":["query","a"]}' -C myc
+
+Testing new chaincode
+---------------------
+
+By default, we mount only ``chaincode_example02``. However, you can easily test different
+chaincodes by adding them to the ``chaincode`` subdirectory and relaunching
+your network. At this point they will be accessible in your ``chaincode`` container.
+
+.. Licensed under Creative Commons Attribution 4.0 International License
+ https://creativecommons.org/licenses/by/4.0/

chaincode-docker-devmode/chaincode/chaincode_example02/chaincode_example02.go

@@ -0,0 +1,199 @@
+/*
+Copyright IBM Corp. 2016 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+//WARNING - this chaincode's ID is hard-coded in chaincode_example04 to illustrate one way of
+//calling chaincode from a chaincode. If this example is modified, chaincode_example04.go has
+//to be modified as well with the new ID of chaincode_example02.
+//chaincode_example05 show's how chaincode ID can be passed in as a parameter instead of
+//hard-coding.
+
+import (
+ "fmt"
+ "strconv"
+
+ "github.com/hyperledger/fabric/core/chaincode/shim"
+ pb "github.com/hyperledger/fabric/protos/peer"
+)
+
+// SimpleChaincode example simple Chaincode implementation
+type SimpleChaincode struct {
+}
+
+func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
+ fmt.Println("ex02 Init")
+ _, args := stub.GetFunctionAndParameters()
+ var A, B string // Entities
+ var Aval, Bval int // Asset holdings
+ var err error
+
+ if len(args) != 4 {
+ return shim.Error("Incorrect number of arguments. Expecting 4")
+ }
+
+ // Initialize the chaincode
+ A = args[0]
+ Aval, err = strconv.Atoi(args[1])
+ if err != nil {
+ return shim.Error("Expecting integer value for asset holding")
+ }
+ B = args[2]
+ Bval, err = strconv.Atoi(args[3])
+ if err != nil {
+ return shim.Error("Expecting integer value for asset holding")
+ }
+ fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)
+
+ // Write the state to the ledger
+ err = stub.PutState(A, []byte(strconv.Itoa(Aval)))
+ if err != nil {
+ return shim.Error(err.Error())
+ }
+
+ err = stub.PutState(B, []byte(strconv.Itoa(Bval)))
+ if err != nil {
+ return shim.Error(err.Error())
+ }
+
+ return shim.Success(nil)
+}
+
+func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
+ fmt.Println("ex02 Invoke")
+ function, args := stub.GetFunctionAndParameters()
+ if function == "invoke" {
+ // Make payment of X units from A to B
+ return t.invoke(stub, args)
+ } else if function == "delete" {
+ // Deletes an entity from its state
+ return t.delete(stub, args)
+ } else if function == "query" {
+ // the old "Query" is now implemtned in invoke
+ return t.query(stub, args)
+ }
+
+ return shim.Error("Invalid invoke function name. Expecting \"invoke\" \"delete\" \"query\"")
+}
+
+// Transaction makes payment of X units from A to B
+func (t *SimpleChaincode) invoke(stub shim.ChaincodeStubInterface, args []string) pb.Response {
+ var A, B string // Entities
+ var Aval, Bval int // Asset holdings
+ var X int // Transaction value
+ var err error
+
+ if len(args) != 3 {
+ return shim.Error("Incorrect number of arguments. Expecting 3")
+ }
+
+ A = args[0]
+ B = args[1]
+
+ // Get the state from the ledger
+ // TODO: will be nice to have a GetAllState call to ledger
+ Avalbytes, err := stub.GetState(A)
+ if err != nil {
+ return shim.Error("Failed to get state")
+ }
+ if Avalbytes == nil {
+ return shim.Error("Entity not found")
+ }
+ Aval, _ = strconv.Atoi(string(Avalbytes))
+
+ Bvalbytes, err := stub.GetState(B)
+ if err != nil {
+ return shim.Error("Failed to get state")
+ }
+ if Bvalbytes == nil {
+ return shim.Error("Entity not found")
+ }
+ Bval, _ = strconv.Atoi(string(Bvalbytes))
+
+ // Perform the execution
+ X, err = strconv.Atoi(args[2])
+ if err != nil {
+ return shim.Error("Invalid transaction amount, expecting a integer value")
+ }
+ Aval = Aval - X
+ Bval = Bval + X
+ fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)
+
+ // Write the state back to the ledger
+ err = stub.PutState(A, []byte(strconv.Itoa(Aval)))
+ if err != nil {
+ return shim.Error(err.Error())
+ }
+
+ err = stub.PutState(B, []byte(strconv.Itoa(Bval)))
+ if err != nil {
+ return shim.Error(err.Error())
+ }
+
+ return shim.Success(nil)
+}
+
+// Deletes an entity from state
+func (t *SimpleChaincode) delete(stub shim.ChaincodeStubInterface, args []string) pb.Response {
+ if len(args) != 1 {
+ return shim.Error("Incorrect number of arguments. Expecting 1")
+ }
+
+ A := args[0]
+
+ // Delete the key from the state in ledger
+ err := stub.DelState(A)
+ if err != nil {
+ return shim.Error("Failed to delete state")
+ }
+
+ return shim.Success(nil)
+}
+
+// query callback representing the query of a chaincode
+func (t *SimpleChaincode) query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
+ var A string // Entities
+ var err error
+
+ if len(args) != 1 {
+ return shim.Error("Incorrect number of arguments. Expecting name of the person to query")
+ }
+
+ A = args[0]
+
+ // Get the state from the ledger
+ Avalbytes, err := stub.GetState(A)
+ if err != nil {
+ jsonResp := "{\"Error\":\"Failed to get state for " + A + "\"}"
+ return shim.Error(jsonResp)
+ }
+
+ if Avalbytes == nil {
+ jsonResp := "{\"Error\":\"Nil amount for " + A + "\"}"
+ return shim.Error(jsonResp)
+ }
+
+ jsonResp := "{\"Name\":\"" + A + "\",\"Amount\":\"" + string(Avalbytes) + "\"}"
+ fmt.Printf("Query Response:%s\n", jsonResp)
+ return shim.Success(Avalbytes)
+}
+
+func main() {
+ err := shim.Start(new(SimpleChaincode))
+ if err != nil {
+ fmt.Printf("Error starting Simple chaincode: %s", err)
+ }
+}