Update docs to point to new repositories

sykesm · sykesm · commit fc3a97cba746 · 2019-08-29T18:28:12.000-04:00
- fabric/core/chaincode -&gt; fabric-chaincode-go
- fabric/protos -&gt; fabric-protos-go
- stronger language in the vendoring topic

FAB-16446 #done

Change-Id: Iaa0f316eb3846f2e6651a114663f0c635e33695b
Signed-off-by: Matthew Sykes &lt;sykesmat@us.ibm.com&gt;
diff --git a/docs/source/chaincode4ade.rst b/docs/source/chaincode4ade.rst
@@ -29,7 +29,7 @@ Every chaincode program must implement the ``Chaincode`` interface whose methods
 are called in response to received transactions. You can find the reference
 documentation of the Chaincode Shim API for different languages below:
 
-  - `Go <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#Chaincode>`__
+  - `Go <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#Chaincode>`__
   - `node.js <https://fabric-shim.github.io/ChaincodeInterface.html>`__
   - `Java <https://fabric-chaincode-java.github.io/org/hyperledger/fabric/shim/Chaincode.html>`_
 
@@ -53,7 +53,7 @@ function by using the `peer chaincode invoke` command and passing the
 
 The other interface in the chaincode "shim" APIs is the ``ChaincodeStubInterface``:
 
-  - `Go <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStubInterface>`__
+  - `Go <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStubInterface>`__
   - `node.js <https://fabric-shim.github.io/ChaincodeStub.html>`__
   - `Java <https://fabric-chaincode-java.github.io/org/hyperledger/fabric/shim/ChaincodeStub.html>`_
 
@@ -95,7 +95,7 @@ Housekeeping
 ^^^^^^^^^^^^
 
 First, let's start with some housekeeping. As with every chaincode, it implements the
-`Chaincode interface <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#Chaincode>`_
+`Chaincode interface <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#Chaincode>`_
 in particular, ``Init`` and ``Invoke`` functions. So, let's add the Go import
 statements for the necessary dependencies for our chaincode. We'll import the
 chaincode shim package and the
@@ -109,8 +109,8 @@ Next, let's add a struct ``SimpleAsset`` as a receiver for Chaincode shim functi
     import (
     	"fmt"
 
-    	"github.com/hyperledger/fabric/core/chaincode/shim"
-    	"github.com/hyperledger/fabric/protos/peer"
+    	"github.com/hyperledger/fabric-chaincode-go/shim"
+    	"github.com/hyperledger/fabric-protos-go/peer"
     )
 
     // SimpleAsset implements a simple chaincode to manage an asset
@@ -135,7 +135,7 @@ Next, we'll implement the ``Init`` function.
           no "migration" or nothing to be initialized as part of the upgrade.
 
 Next, we'll retrieve the arguments to the ``Init`` call using the
-`ChaincodeStubInterface.GetStringArgs <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStub.GetStringArgs>`_
+`ChaincodeStubInterface.GetStringArgs <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.GetStringArgs>`_
 function and check for validity. In our case, we are expecting a key-value pair.
 
   .. code:: go
@@ -154,7 +154,7 @@ function and check for validity. In our case, we are expecting a key-value pair.
 
 Next, now that we have established that the call is valid, we'll store the
 initial state in the ledger. To do this, we will call
-`ChaincodeStubInterface.PutState <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStub.PutState>`_
+`ChaincodeStubInterface.PutState <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.PutState>`_
 with the key and value passed in as the arguments. Assuming all went well,
 return a peer.Response object that indicates the initialization was a success.
 
@@ -200,7 +200,7 @@ As with the ``Init`` function above, we need to extract the arguments from the
 name of the chaincode application function to invoke. In our case, our application
 will simply have two functions: ``set`` and ``get``, that allow the value of an
 asset to be set or its current state to be retrieved. We first call
-`ChaincodeStubInterface.GetFunctionAndParameters <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStub.GetFunctionAndParameters>`_
+`ChaincodeStubInterface.GetFunctionAndParameters <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.GetFunctionAndParameters>`_
 to extract the function name and the parameters to that chaincode application
 function.
 
@@ -250,8 +250,8 @@ Implementing the Chaincode Application
 As noted, our chaincode application implements two functions that can be
 invoked via the ``Invoke`` function. Let's implement those functions now.
 Note that as we mentioned above, to access the ledger's state, we will leverage
-the `ChaincodeStubInterface.PutState <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStub.PutState>`_
-and `ChaincodeStubInterface.GetState <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStub.GetState>`_
+the `ChaincodeStubInterface.PutState <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.PutState>`_
+and `ChaincodeStubInterface.GetState <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.GetState>`_
 functions of the chaincode shim API.
 
 .. code:: go
@@ -292,7 +292,7 @@ Pulling it All Together
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 Finally, we need to add the ``main`` function, which will call the
-`shim.Start <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#Start>`_
+`shim.Start <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#Start>`_
 function. Here's the whole chaincode program source.
 
 .. code:: go
@@ -302,8 +302,8 @@ function. Here's the whole chaincode program source.
     import (
     	"fmt"
 
-    	"github.com/hyperledger/fabric/core/chaincode/shim"
-    	"github.com/hyperledger/fabric/protos/peer"
+    	"github.com/hyperledger/fabric-chaincode-go/shim"
+    	"github.com/hyperledger/fabric-protos-go/peer"
     )
 
     // SimpleAsset implements a simple chaincode to manage an asset
@@ -396,7 +396,7 @@ Now let's compile your chaincode.
 
 .. code:: bash
 
-  go get -u github.com/hyperledger/fabric/core/chaincode/shim
+  go get -u github.com/hyperledger/fabric-chaincode-go
   go build
 
 Assuming there are no errors, now we can proceed to the next step, testing
@@ -526,7 +526,7 @@ to make updates to the key/value in the future. The client identity
 library extension APIs can be used within chaincode to retrieve this
 submitter information to make such access control decisions.
 
-See the `client identity (CID) library documentation <https://github.com/hyperledger/fabric/blob/master/core/chaincode/shim/ext/cid/README.md>`_
+See the `client identity (CID) library documentation <https://github.com/hyperledger/fabric-chaincode-go/blob/master/pkg/cid/README.md>`_
 for more details.
 
 To add the client identity shim extension to your chaincode as a dependency, see :ref:`vendoring`.
@@ -535,10 +535,9 @@ To add the client identity shim extension to your chaincode as a dependency, see
 
 Managing external dependencies for chaincode written in Go
 ----------------------------------------------------------
-If your chaincode requires packages not provided by the Go standard library,
-you will need to include those packages with your chaincode. It is also a
-good practice to add the shim and any extension libraries to your chaincode
-as a dependency.
+Your Go chaincode requires packages (like the chaincode shim) that are not part
+of the Go standard library. These packages must be included in your chaincode
+package.
 
 There are `many tools available <https://github.com/golang/go/wiki/PackageManagementTools>`__
 for managing (or "vendoring") these dependencies.  The following demonstrates how to use
diff --git a/docs/source/couchdb_as_state_database.rst b/docs/source/couchdb_as_state_database.rst
@@ -53,7 +53,7 @@ Using CouchDB from Chaincode
 Chaincode queries
 ~~~~~~~~~~~~~~~~~
 
-Most of the `chaincode shim APIs <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStubInterface>`__
+Most of the `chaincode shim APIs <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStubInterface>`__
 can be utilized with either LevelDB or CouchDB state database, e.g. ``GetState``, ``PutState``,
 ``GetStateByRange``, ``GetStateByPartialCompositeKey``. Additionally when you utilize CouchDB as
 the state database and model assets as JSON in chaincode, you can perform rich queries against
diff --git a/docs/source/couchdb_tutorial.rst b/docs/source/couchdb_tutorial.rst
@@ -584,7 +584,7 @@ Delving into the query command above, there are three arguments of interest:
 
 *  ``queryMarbles``
 
-  Name of the function in the Marbles chaincode. Notice a `shim <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim>`__
+  Name of the function in the Marbles chaincode. Notice a `shim <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim>`__
   ``shim.ChaincodeStubInterface`` is used to access and modify the ledger. The
   ``getQueryResultForQueryString()`` passes the queryString to the shim API ``getQueryResult()``.
 
@@ -793,7 +793,7 @@ a unique bookmark.)
 
 *  ``queryMarblesWithPagination``
 
-  Name of the function in the Marbles chaincode. Notice a `shim <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim>`__
+  Name of the function in the Marbles chaincode. Notice a `shim <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim>`__
   ``shim.ChaincodeStubInterface`` is used to access and modify the ledger. The
   ``getQueryResultForQueryStringWithPagination()`` passes the queryString along
   with the pagesize and bookmark to the shim API ``GetQueryResultWithPagination()``.
diff --git a/docs/source/developapps/analysis.md b/docs/source/developapps/analysis.md
@@ -75,7 +75,7 @@ The value of `Owner` of a paper can be used to perform access control on the
 **redeem** transaction, by comparing the `Owner` against the identity of the
 transaction creator. Fabric supports this through the
 [`getCreator()` chaincode API](https://github.com/hyperledger/fabric-chaincode-node/blob/master/fabric-shim/lib/stub.js#L293).
-If golang is used as a chaincode language, the [client identity chaincode library](https://github.com/hyperledger/fabric/blob/master/core/chaincode/shim/ext/cid/README.md)
+If golang is used as a chaincode language, the [client identity chaincode library](https://github.com/hyperledger/fabric-chaincode-go/blob/master/pkg/cid/README.md)
 can be used to retrieve additional attributes of the transaction creator.
 
 ## Transactions
diff --git a/docs/source/enable_tls.rst b/docs/source/enable_tls.rst
@@ -139,9 +139,7 @@ of the CA certificates trusted by the peer or orderer node.
 
 If you see the error message ``remote error: tls: bad certificate`` in your chaincode logs,
 ensure that your chaincode has been built using the chaincode shim provided with Fabric v1.1
-or newer. If your chaincode does not contain a vendored copy of the shim, deleting the
-chaincode container and restarting its peer will rebuild the chaincode container using the
-current shim version.
+or newer.
 
 .. Licensed under Creative Commons Attribution 4.0 International License
    https://creativecommons.org/licenses/by/4.0/
diff --git a/docs/source/endorsement-policies.rst b/docs/source/endorsement-policies.rst
@@ -200,7 +200,7 @@ following functions apply:
 To help set endorsement policies and marshal them into validation
 parameter byte arrays, the Go shim provides an extension with convenience
 functions that allow the chaincode developer to deal with endorsement policies
-in terms of the MSP identifiers of organizations, see `KeyEndorsementPolicy <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim/ext/statebased#KeyEndorsementPolicy>`_:
+in terms of the MSP identifiers of organizations, see `KeyEndorsementPolicy <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/pkg/statebased#KeyEndorsementPolicy>`_:
 
 .. code-block:: Go
 
diff --git a/docs/source/idemix.rst b/docs/source/idemix.rst
@@ -137,7 +137,7 @@ Idemix and chaincode
 From a verifier perspective, there is one more actor to consider: chaincode.
 What can chaincode learn about the transactor when an Idemix credential is used?
 
-The `cid (Client Identity) library <https://github.com/hyperledger/fabric/tree/master/core/chaincode/shim/ext/cid>`_
+The `cid (Client Identity) library <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/pkg/cid>`_
 (for golang only) has been extended to support the ``GetAttributeValue`` function
 when an Idemix credential is used. However, as mentioned in the "Current
 limitations" section below, there are only two attributes which are disclosed in
diff --git a/docs/source/private-data-arch.rst b/docs/source/private-data-arch.rst
@@ -173,7 +173,7 @@ properties will have ensured the private data is available on other peers.
 Referencing collections from chaincode
 --------------------------------------
 
-A set of `shim APIs <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim>`_
+A set of `shim APIs <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim>`_
 are available for setting and retrieving private data.
 
 The same chaincode data operations can be applied to channel state data and
@@ -191,7 +191,7 @@ not to include private data in the main part of the chaincode proposal. A specia
 field in the chaincode proposal called the ``transient`` field can be used to pass
 private data from the client (or data that chaincode will use to generate private
 data), to chaincode invocation on the peer.  The chaincode can retrieve the
-``transient`` field by calling the `GetTransient() API <https://github.com/hyperledger/fabric/blob/8b3cbda97e58d1a4ff664219244ffd1d89d7fba8/core/chaincode/shim/interfaces.go#L315-L321>`_.
+``transient`` field by calling the `GetTransient() API <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.GetTransient>`_.
 This ``transient`` field gets excluded from the channel transaction.
 
 Access control for private data
@@ -210,7 +210,7 @@ configuration definitions and how to set them, refer back to the
           ``memberOnlyRead`` to false. You can then apply your own access
           control logic in chaincode, for example by calling the GetCreator()
           chaincode API or using the client identity
-          `chaincode library <https://github.com/hyperledger/fabric/tree/master/core/chaincode/shim/ext/cid>`__ .
+          `chaincode library <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub.GetCreator>`__ .
 
 Querying Private Data
 ~~~~~~~~~~~~~~~~~~~~~
diff --git a/docs/source/private_data_tutorial.rst b/docs/source/private_data_tutorial.rst
@@ -157,7 +157,7 @@ Thus two different sets of private data are defined in the marbles private data
 sample. The mapping of this data to the collection policy which restricts its
 access is controlled by chaincode APIs. Specifically, reading and writing
 private data using a collection definition is performed by calling ``GetPrivateData()``
-and ``PutPrivateData()``, which can be found `here <https://github.com/hyperledger/fabric/blob/master/core/chaincode/shim/interfaces.go#L179>`_.
+and ``PutPrivateData()``, which can be found `here <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStub>`_.
 
 The following diagrams illustrate the private data model used by the marbles
 private data sample.
diff --git a/docs/source/understand_fabcar_network.rst b/docs/source/understand_fabcar_network.rst
@@ -72,7 +72,7 @@ Query
 
 Queries are the simplest kind of invocation: a call and response.  The most common query
 will interrogate the state database for the current value associated
-with a key (``GetState``).  However, the `chaincode shim interface <https://godoc.org/github.com/hyperledger/fabric/core/chaincode/shim#ChaincodeStub>`__
+with a key (``GetState``).  However, the `chaincode shim interface <https://godoc.org/github.com/hyperledger/fabric-chaincode-go/shim#ChaincodeStubInterface>`__
 also allows for different types of ``Get`` calls (e.g. ``GetHistoryForKey`` or ``GetCreator``).
 
 In our example, the peer holds a hash chain of all transactions and maintains
diff --git a/docs/source/upgrading_your_network_tutorial.rst b/docs/source/upgrading_your_network_tutorial.rst
@@ -477,15 +477,13 @@ Upgrade Chaincodes with vendored shim
           of the peer.
 
 A number of third party tools exist that will allow you to vendor a chaincode
-shim. If you used one of these tools, use the same one to update your vendoring
-and re-package your chaincode.
+shim. If you used one of these tools, use the same one to update your vendored
+chaincode shim and re-package your chaincode.
 
 If your chaincode vendors the shim, after updating the shim version, you must install
 it to all peers which already have the chaincode. Install it with the same name, but
 a newer version. Then you should execute a chaincode upgrade on each channel where
 this chaincode has been deployed to move to the new version.
 
-If you did not vendor your chaincode, you can skip this step entirely.
-
 .. Licensed under Creative Commons Attribution 4.0 International License
    https://creativecommons.org/licenses/by/4.0/
