[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 <[email protected]>
Signed-off-by: Christopher Ferris <[email protected]>

.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)
+	}
+}