swarm/storage/mru: Renamed rest of MRU references

cmd/swarm/main.go

@@ -207,25 +207,25 @@ var (
 		Name:  "compressed",
 		Usage: "Prints encryption keys in compressed form",
 	}
-	SwarmResourceNameFlag = cli.StringFlag{
+	SwarmFeedNameFlag = cli.StringFlag{
 		Name:  "name",
-		Usage: "User-defined name for the new resource, limited to 32 characters. If combined with topic, the resource will be a subtopic with this name",
+		Usage: "User-defined name for the new feed, limited to 32 characters. If combined with topic, it will refer to a subtopic with this name",
 	}
-	SwarmResourceTopicFlag = cli.StringFlag{
+	SwarmFeedTopicFlag = cli.StringFlag{
 		Name:  "topic",
-		Usage: "User-defined topic this resource is tracking, hex encoded. Limited to 64 hexadecimal characters",
+		Usage: "User-defined topic this feed is tracking, hex encoded. Limited to 64 hexadecimal characters",
 	}
-	SwarmResourceDataOnCreateFlag = cli.StringFlag{
+	SwarmFeedDataOnCreateFlag = cli.StringFlag{
 		Name:  "data",
-		Usage: "Initializes the resource with the given hex-encoded data. Data must be prefixed by 0x",
+		Usage: "Initializes the feed with the given hex-encoded data. Data must be prefixed by 0x",
 	}
-	SwarmResourceManifestFlag = cli.StringFlag{
+	SwarmFeedManifestFlag = cli.StringFlag{
 		Name:  "manifest",
-		Usage: "Refers to the resource through a manifest",
+		Usage: "Refers to the feed through a manifest",
 	}
-	SwarmResourceUserFlag = cli.StringFlag{
+	SwarmFeedUserFlag = cli.StringFlag{
 		Name:  "user",
-		Usage: "Indicates the user who updates the resource",
+		Usage: "Indicates the user who updates the feed",
 	}
 )
 
@@ -346,62 +346,62 @@ func init() {
 		},
 		{
 			CustomHelpTemplate: helpTemplate,
-			Name:               "resource",
-			Usage:              "(Advanced) Create and update Mutable Resources",
+			Name:               "feed",
+			Usage:              "(Advanced) Create and update Swarm Feeds",
 			ArgsUsage:          "<create|update|info>",
-			Description:        "Works with Mutable Resource Updates",
+			Description:        "Works with Swarm Feeds",
 			Subcommands: []cli.Command{
 				{
-					Action:             resourceCreate,
+					Action:             feedCreateManifest,
 					CustomHelpTemplate: helpTemplate,
 					Name:               "create",
-					Usage:              "creates and publishes a new Mutable Resource manifest",
-					Description: `creates and publishes a new Mutable Resource manifest pointing to a specified user's updates about a particular topic.
-					The resource topic can be built in the following ways:
+					Usage:              "creates and publishes a new Feed manifest",
+					Description: `creates and publishes a new Feed manifest pointing to a specified user's updates about a particular topic.
+					The feed topic can be built in the following ways:
 					* use --topic to set the topic to an arbitrary binary hex string.
 					* use --name to set the topic to a human-readable name.
-					    For example --name could be set to "profile-picture", meaning this Mutable Resource allows to get this user's current profile picture.
+					    For example --name could be set to "profile-picture", meaning this feed allows to get this user's current profile picture.
 					* use both --topic and --name to create named subtopics. 
 						For example, --topic could be set to an Ethereum contract address and --name could be set to "comments", meaning
-						the Mutable Resource tracks a discussion about that contract.
+						this feed tracks a discussion about that contract.
 					The --user flag allows to have this manifest refer to a user other than yourself. If not specified,
 					it will then default to your local account (--bzzaccount)`,
-					Flags: []cli.Flag{SwarmResourceNameFlag, SwarmResourceTopicFlag, SwarmResourceUserFlag},
+					Flags: []cli.Flag{SwarmFeedNameFlag, SwarmFeedTopicFlag, SwarmFeedUserFlag},
 				},
 				{
-					Action:             resourceUpdate,
+					Action:             feedUpdate,
 					CustomHelpTemplate: helpTemplate,
 					Name:               "update",
-					Usage:              "updates the content of an existing Mutable Resource",
+					Usage:              "updates the content of an existing Swarm Feed",
 					ArgsUsage:          "<0x Hex data>",
 					Description: `publishes a new update on the specified topic
-					The resource topic can be built in the following ways:
+					The feed topic can be built in the following ways:
 					* use --topic to set the topic to an arbitrary binary hex string.
 					* use --name to set the topic to a human-readable name.
-					    For example --name could be set to "profile-picture", meaning this Mutable Resource allows to get this user's current profile picture.
+					    For example --name could be set to "profile-picture", meaning this feed allows to get this user's current profile picture.
 					* use both --topic and --name to create named subtopics. 
 						For example, --topic could be set to an Ethereum contract address and --name could be set to "comments", meaning
-						the Mutable Resource tracks a discussion about that contract.
+						this feed tracks a discussion about that contract.
 					
-					If you have a manifest, you can specify it with --manifest to refer to the resource,
+					If you have a manifest, you can specify it with --manifest to refer to the feed,
 					instead of using --topic / --name
 					`,
-					Flags: []cli.Flag{SwarmResourceManifestFlag, SwarmResourceNameFlag, SwarmResourceTopicFlag},
+					Flags: []cli.Flag{SwarmFeedManifestFlag, SwarmFeedNameFlag, SwarmFeedTopicFlag},
 				},
 				{
-					Action:             resourceInfo,
+					Action:             feedInfo,
 					CustomHelpTemplate: helpTemplate,
 					Name:               "info",
-					Usage:              "obtains information about an existing Mutable Resource",
-					Description: `obtains information about an existing Mutable Resource
+					Usage:              "obtains information about an existing Swarm Feed",
+					Description: `obtains information about an existing Swarm Feed
 					The topic can be specified directly with the --topic flag as an hex string
 					If no topic is specified, the default topic (zero) will be used
 					The --name flag can be used to specify subtopics with a specific name.
 					The --user flag allows to refer to a user other than yourself. If not specified,
 					it will then default to your local account (--bzzaccount)
 					If you have a manifest, you can specify it with --manifest instead of --topic / --name / ---user
-					to refer to the resource`,
-					Flags: []cli.Flag{SwarmResourceManifestFlag, SwarmResourceNameFlag, SwarmResourceTopicFlag, SwarmResourceUserFlag},
+					to refer to the feed`,
+					Flags: []cli.Flag{SwarmFeedManifestFlag, SwarmFeedNameFlag, SwarmFeedTopicFlag, SwarmFeedUserFlag},
 				},
 			},
 		},
@@ -738,7 +738,7 @@ func getAccount(bzzaccount string, ctx *cli.Context, stack *node.Node) *ecdsa.Pr
 }
 
 // getPrivKey returns the private key of the specified bzzaccount
-// Used only by client commands, such as `resource`
+// Used only by client commands, such as `feed`
 func getPrivKey(ctx *cli.Context) *ecdsa.PrivateKey {
 	// booting up the swarm node just as we do in bzzd action
 	bzzconfig, err := buildConfig(ctx)

cmd/swarm/mru.go

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
 
-// Command resource allows the user to create and update signed Swarm Feeds
+// Command feed allows the user to create and update signed Swarm Feeds
 package main
 
 import (
@@ -36,8 +36,8 @@ func NewGenericSigner(ctx *cli.Context) mru.Signer {
 }
 
 func getTopic(ctx *cli.Context) (topic mru.Topic) {
-	var name = ctx.String(SwarmResourceNameFlag.Name)
-	var relatedTopic = ctx.String(SwarmResourceTopicFlag.Name)
+	var name = ctx.String(SwarmFeedNameFlag.Name)
+	var relatedTopic = ctx.String(SwarmFeedTopicFlag.Name)
 	var relatedTopicBytes []byte
 	var err error
 
@@ -55,35 +55,35 @@ func getTopic(ctx *cli.Context) (topic mru.Topic) {
 	return topic
 }
 
-// swarm resource create <frequency> [--name <name>] [--data <0x Hexdata> [--multihash=false]]
-// swarm resource update <Manifest Address or ENS domain> <0x Hexdata> [--multihash=false]
-// swarm resource info <Manifest Address or ENS domain>
+// swarm feed create <frequency> [--name <name>] [--data <0x Hexdata> [--multihash=false]]
+// swarm feed update <Manifest Address or ENS domain> <0x Hexdata> [--multihash=false]
+// swarm feed info <Manifest Address or ENS domain>
 
-func resourceCreate(ctx *cli.Context) {
+func feedCreateManifest(ctx *cli.Context) {
 	var (
 		bzzapi = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
 		client = swarm.NewClient(bzzapi)
 	)
 
-	newResourceRequest := mru.NewFirstRequest(getTopic(ctx))
-	newResourceRequest.Feed.User = resourceGetUser(ctx)
+	newFeedUpdateRequest := mru.NewFirstRequest(getTopic(ctx))
+	newFeedUpdateRequest.Feed.User = feedGetUser(ctx)
 
-	manifestAddress, err := client.CreateResource(newResourceRequest)
+	manifestAddress, err := client.CreateFeedWithManifest(newFeedUpdateRequest)
 	if err != nil {
-		utils.Fatalf("Error creating resource: %s", err.Error())
+		utils.Fatalf("Error creating feed manifest: %s", err.Error())
 		return
 	}
 	fmt.Println(manifestAddress) // output manifest address to the user in a single line (useful for other commands to pick up)
 
 }
 
-func resourceUpdate(ctx *cli.Context) {
+func feedUpdate(ctx *cli.Context) {
 	args := ctx.Args()
 
 	var (
 		bzzapi                  = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
 		client                  = swarm.NewClient(bzzapi)
-		manifestAddressOrDomain = ctx.String(SwarmResourceManifestFlag.Name)
+		manifestAddressOrDomain = ctx.String(SwarmFeedManifestFlag.Name)
 	)
 
 	if len(args) < 1 {
@@ -110,10 +110,10 @@ func resourceUpdate(ctx *cli.Context) {
 
 	}
 
-	// Retrieve resource status and metadata out of the manifest
-	updateRequest, err = client.GetResourceMetadata(query, manifestAddressOrDomain)
+	// Retrieve feed status and metadata out of the manifest
+	updateRequest, err = client.GetFeedMetadata(query, manifestAddressOrDomain)
 	if err != nil {
-		utils.Fatalf("Error retrieving resource status: %s", err.Error())
+		utils.Fatalf("Error retrieving feed status: %s", err.Error())
 	}
 
 	// set the new data
@@ -121,34 +121,34 @@ func resourceUpdate(ctx *cli.Context) {
 
 	// sign update
 	if err = updateRequest.Sign(signer); err != nil {
-		utils.Fatalf("Error signing resource update: %s", err.Error())
+		utils.Fatalf("Error signing feed update: %s", err.Error())
 	}
 
 	// post update
-	err = client.UpdateResource(updateRequest)
+	err = client.UpdateFeed(updateRequest)
 	if err != nil {
-		utils.Fatalf("Error updating resource: %s", err.Error())
+		utils.Fatalf("Error updating feed: %s", err.Error())
 		return
 	}
 }
 
-func resourceInfo(ctx *cli.Context) {
+func feedInfo(ctx *cli.Context) {
 	var (
 		bzzapi                  = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
 		client                  = swarm.NewClient(bzzapi)
-		manifestAddressOrDomain = ctx.String(SwarmResourceManifestFlag.Name)
+		manifestAddressOrDomain = ctx.String(SwarmFeedManifestFlag.Name)
 	)
 
 	var query *mru.Query
 	if manifestAddressOrDomain == "" {
 		query = new(mru.Query)
 		query.Topic = getTopic(ctx)
-		query.User = resourceGetUser(ctx)
+		query.User = feedGetUser(ctx)
 	}
 
-	metadata, err := client.GetResourceMetadata(query, manifestAddressOrDomain)
+	metadata, err := client.GetFeedMetadata(query, manifestAddressOrDomain)
 	if err != nil {
-		utils.Fatalf("Error retrieving resource metadata: %s", err.Error())
+		utils.Fatalf("Error retrieving feed metadata: %s", err.Error())
 		return
 	}
 	encodedMetadata, err := metadata.MarshalJSON()
@@ -158,8 +158,8 @@ func resourceInfo(ctx *cli.Context) {
 	fmt.Println(string(encodedMetadata))
 }
 
-func resourceGetUser(ctx *cli.Context) common.Address {
-	var user = ctx.String(SwarmResourceUserFlag.Name)
+func feedGetUser(ctx *cli.Context) common.Address {
+	var user = ctx.String(SwarmFeedUserFlag.Name)
 	if user != "" {
 		return common.HexToAddress(user)
 	}

cmd/swarm/mru_test.go

@@ -38,12 +38,12 @@ import (
 	swarmhttp "github.com/ethereum/go-ethereum/swarm/api/http"
 )
 
-func TestCLIResourceUpdate(t *testing.T) {
+func TestCLIFeedUpdate(t *testing.T) {
 
 	srv := testutil.NewTestSwarmServer(t, func(api *api.API) testutil.TestServer {
 		return swarmhttp.NewServer(api, "")
 	}, nil)
-	log.Info("starting 1 node cluster")
+	log.Info("starting a test swarm server")
 	defer srv.Close()
 
 	// create a private key file for signing
@@ -77,13 +77,13 @@ func TestCLIResourceUpdate(t *testing.T) {
 	flags := []string{
 		"--bzzapi", srv.URL,
 		"--bzzaccount", pkfile.Name(),
-		"resource", "update",
+		"feed", "update",
 		"--topic", topic.Hex(),
 		"--name", name,
 		hexData}
 
 	// create an update and expect an exit without errors
-	log.Info(fmt.Sprintf("updating a resource with 'swarm resource update'"))
+	log.Info(fmt.Sprintf("updating a feed with 'swarm feed update'"))
 	cmd := runSwarm(t, flags...)
 	cmd.ExpectExit()
 
@@ -100,17 +100,17 @@ func TestCLIResourceUpdate(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	// View configures whose updates we will be looking up.
-	view := mru.Feed{
+	// Feed configures whose updates we will be looking up.
+	feed := mru.Feed{
 		Topic: topic,
 		User:  address,
 	}
 
 	// Build a query to get the latest update
-	query := mru.NewQueryLatest(&view, lookup.NoClue)
+	query := mru.NewQueryLatest(&feed, lookup.NoClue)
 
 	// retrieve content!
-	reader, err := client.GetResource(query, "")
+	reader, err := client.QueryFeed(query, "")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -128,12 +128,12 @@ func TestCLIResourceUpdate(t *testing.T) {
 	// Now retrieve info for the next update
 	flags = []string{
 		"--bzzapi", srv.URL,
-		"resource", "info",
+		"feed", "info",
 		"--topic", topic.Hex(),
 		"--user", address.Hex(),
 	}
 
-	log.Info(fmt.Sprintf("getting resource info with 'swarm resource info'"))
+	log.Info(fmt.Sprintf("getting feed info with 'swarm feed info'"))
 	cmd = runSwarm(t, flags...)
 	_, matches := cmd.ExpectRegexp(`.*`) // regex hack to extract stdout
 	cmd.ExpectExit()
@@ -145,28 +145,28 @@ func TestCLIResourceUpdate(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	// make sure the retrieved view is the same
-	if request.Feed != view {
-		t.Fatalf("Expected view to be: %s, got %s", view, request.Feed)
+	// make sure the retrieved Feed is the same
+	if request.Feed != feed {
+		t.Fatalf("Expected feed to be: %s, got %s", feed, request.Feed)
 	}
 
 	// test publishing a manifest
 	flags = []string{
 		"--bzzapi", srv.URL,
 		"--bzzaccount", pkfile.Name(),
-		"resource", "create",
+		"feed", "create",
 		"--topic", topic.Hex(),
 	}
 
-	log.Info(fmt.Sprintf("Publishing manifest with 'swarm resource create'"))
+	log.Info(fmt.Sprintf("Publishing manifest with 'swarm feed create'"))
 	cmd = runSwarm(t, flags...)
 	_, matches = cmd.ExpectRegexp(`[a-f\d]{64}`) // regex hack to extract stdout
 	cmd.ExpectExit()
 
-	manifestAddress := matches[0] // read the received resource manifest
+	manifestAddress := matches[0] // read the received feed manifest
 
 	// now attempt to lookup the latest update using a manifest instead
-	reader, err = client.GetResource(nil, manifestAddress)
+	reader, err = client.QueryFeed(nil, manifestAddress)
 	if err != nil {
 		t.Fatal(err)
 	}

swarm/api/client/client.go

@@ -601,16 +601,15 @@ func (c *Client) MultipartUpload(hash string, uploader Uploader) (string, error)
 	return string(data), nil
 }
 
-// ErrNoResourceUpdatesFound is returned when Swarm cannot find updates of the given resource
-var ErrNoResourceUpdatesFound = errors.New("No updates found for this resource")
+// ErrNoFeedUpdatesFound is returned when Swarm cannot find updates of the given feed
+var ErrNoFeedUpdatesFound = errors.New("No updates found for this feed")
 
-// CreateResource creates a Mutable Resource with the given name and frequency, initializing it with the provided
-// data. Data is interpreted as multihash or not depending on the multihash parameter.
-// startTime=0 means "now"
-// Returns the resulting Mutable Resource manifest address that you can use to include in an ENS Resolver (setContent)
-// or reference future updates (Client.UpdateResource)
-func (c *Client) CreateResource(request *mru.Request) (string, error) {
-	responseStream, err := c.updateResource(request, true)
+// CreateFeedWithManifest creates a Feed Manifest, initializing it with the provided
+// data
+// Returns the resulting Feed Manifest address that you can use to include in an ENS Resolver (setContent)
+// or reference future updates (Client.UpdateFeed)
+func (c *Client) CreateFeedWithManifest(request *mru.Request) (string, error) {
+	responseStream, err := c.updateFeed(request, true)
 	if err != nil {
 		return "", err
 	}
@@ -628,18 +627,18 @@ func (c *Client) CreateResource(request *mru.Request) (string, error) {
 	return manifestAddress, nil
 }
 
-// UpdateResource allows you to set a new version of your content
-func (c *Client) UpdateResource(request *mru.Request) error {
-	_, err := c.updateResource(request, false)
+// UpdateFeed allows you to set a new version of your content
+func (c *Client) UpdateFeed(request *mru.Request) error {
+	_, err := c.updateFeed(request, false)
 	return err
 }
 
-func (c *Client) updateResource(request *mru.Request, createManifest bool) (io.ReadCloser, error) {
+func (c *Client) updateFeed(request *mru.Request, createManifest bool) (io.ReadCloser, error) {
 	URL, err := url.Parse(c.Gateway)
 	if err != nil {
 		return nil, err
 	}
-	URL.Path = "/bzz-resource:/"
+	URL.Path = "/bzz-feed:/"
 	values := URL.Query()
 	body := request.AppendValues(values)
 	if createManifest {
@@ -660,23 +659,23 @@ func (c *Client) updateResource(request *mru.Request, createManifest bool) (io.R
 	return res.Body, nil
 }
 
-// GetResource returns a byte stream with the raw content of the resource
-// manifestAddressOrDomain is the address you obtained in CreateResource or an ENS domain whose Resolver
+// QueryFeed returns a byte stream with the raw content of the feed update
+// manifestAddressOrDomain is the address you obtained in CreateFeedWithManifest or an ENS domain whose Resolver
 // points to that address
-func (c *Client) GetResource(query *mru.Query, manifestAddressOrDomain string) (io.ReadCloser, error) {
-	return c.getResource(query, manifestAddressOrDomain, false)
+func (c *Client) QueryFeed(query *mru.Query, manifestAddressOrDomain string) (io.ReadCloser, error) {
+	return c.queryFeed(query, manifestAddressOrDomain, false)
 }
 
-// getResource returns a byte stream with the raw content of the resource
-// manifestAddressOrDomain is the address you obtained in CreateResource or an ENS domain whose Resolver
+// queryFeed returns a byte stream with the raw content of the feed update
+// manifestAddressOrDomain is the address you obtained in CreateFeedWithManifest or an ENS domain whose Resolver
 // points to that address
-// meta set to true will instruct the node return resource metainformation instead
-func (c *Client) getResource(query *mru.Query, manifestAddressOrDomain string, meta bool) (io.ReadCloser, error) {
+// meta set to true will instruct the node return Feed metainformation instead
+func (c *Client) queryFeed(query *mru.Query, manifestAddressOrDomain string, meta bool) (io.ReadCloser, error) {
 	URL, err := url.Parse(c.Gateway)
 	if err != nil {
 		return nil, err
 	}
-	URL.Path = "/bzz-resource:/" + manifestAddressOrDomain
+	URL.Path = "/bzz-feed:/" + manifestAddressOrDomain
 	values := URL.Query()
 	if query != nil {
 		query.AppendValues(values) //adds query parameters
@@ -692,7 +691,7 @@ func (c *Client) getResource(query *mru.Query, manifestAddressOrDomain string, m
 
 	if res.StatusCode != http.StatusOK {
 		if res.StatusCode == http.StatusNotFound {
-			return nil, ErrNoResourceUpdatesFound
+			return nil, ErrNoFeedUpdatesFound
 		}
 		errorMessageBytes, err := ioutil.ReadAll(res.Body)
 		var errorMessage string
@@ -701,18 +700,18 @@ func (c *Client) getResource(query *mru.Query, manifestAddressOrDomain string, m
 		} else {
 			errorMessage = string(errorMessageBytes)
 		}
-		return nil, fmt.Errorf("Error retrieving resource: %s", errorMessage)
+		return nil, fmt.Errorf("Error retrieving feed updates: %s", errorMessage)
 	}
 
 	return res.Body, nil
 }
 
-// GetResourceMetadata returns a structure that describes the Mutable Resource
-// manifestAddressOrDomain is the address you obtained in CreateResource or an ENS domain whose Resolver
+// GetFeedMetadata returns a structure that describes the referenced Feed status
+// manifestAddressOrDomain is the address you obtained in CreateFeedWithManifest or an ENS domain whose Resolver
 // points to that address
-func (c *Client) GetResourceMetadata(query *mru.Query, manifestAddressOrDomain string) (*mru.Request, error) {
+func (c *Client) GetFeedMetadata(query *mru.Query, manifestAddressOrDomain string) (*mru.Request, error) {
 
-	responseStream, err := c.getResource(query, manifestAddressOrDomain, true)
+	responseStream, err := c.queryFeed(query, manifestAddressOrDomain, true)
 	if err != nil {
 		return nil, err
 	}

swarm/api/client/client_test.go

@@ -369,12 +369,12 @@ func newTestSigner() (*mru.GenericSigner, error) {
 	return mru.NewGenericSigner(privKey), nil
 }
 
-// test the transparent resolving of multihash resource types with bzz:// scheme
+// test the transparent resolving of multihash feed updates with bzz:// scheme
 //
-// first upload data, and store the multihash to the resulting manifest in a resource update
+// first upload data, and store the multihash to the resulting manifest in a feed update
 // retrieving the update with the multihash should return the manifest pointing directly to the data
 // and raw retrieve of that hash should return the data
-func TestClientCreateResourceMultihash(t *testing.T) {
+func TestClientCreateFeedMultihash(t *testing.T) {
 
 	signer, _ := newTestSigner()
 
@@ -393,7 +393,7 @@ func TestClientCreateResourceMultihash(t *testing.T) {
 	s := common.FromHex(swarmHash)
 	mh := multihash.ToMultihash(s)
 
-	// our mutable resource topic
+	// our feed topic
 	topic, _ := mru.NewTopic("foo.eth", nil)
 
 	createRequest := mru.NewFirstRequest(topic)
@@ -403,26 +403,26 @@ func TestClientCreateResourceMultihash(t *testing.T) {
 		t.Fatalf("Error signing update: %s", err)
 	}
 
-	resourceManifestHash, err := client.CreateResource(createRequest)
+	feedManifestHash, err := client.CreateFeedWithManifest(createRequest)
 
 	if err != nil {
-		t.Fatalf("Error creating resource: %s", err)
+		t.Fatalf("Error creating feed manifest: %s", err)
 	}
 
-	correctManifestAddrHex := "6ef40ba1492cf2a029dc9a8b5896c822cf689d3cd010842f4f1744e6db8824bd"
-	if resourceManifestHash != correctManifestAddrHex {
-		t.Fatalf("Response resource manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, resourceManifestHash)
+	correctManifestAddrHex := "bb056a5264c295c2b0f613c8409b9c87ce9d71576ace02458160df4cc894210b"
+	if feedManifestHash != correctManifestAddrHex {
+		t.Fatalf("Response feed manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, feedManifestHash)
 	}
 
-	// Check we get a not found error when trying to get the resource with a made-up manifest
-	_, err = client.GetResource(nil, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
-	if err != ErrNoResourceUpdatesFound {
-		t.Fatalf("Expected to receive ErrNoResourceUpdatesFound error. Got: %s", err)
+	// Check we get a not found error when trying to get feed updates with a made-up manifest
+	_, err = client.QueryFeed(nil, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+	if err != ErrNoFeedUpdatesFound {
+		t.Fatalf("Expected to receive ErrNoFeedUpdatesFound error. Got: %s", err)
 	}
 
-	reader, err := client.GetResource(nil, correctManifestAddrHex)
+	reader, err := client.QueryFeed(nil, correctManifestAddrHex)
 	if err != nil {
-		t.Fatalf("Error retrieving resource: %s", err)
+		t.Fatalf("Error retrieving feed updates: %s", err)
 	}
 	defer reader.Close()
 	gotData, err := ioutil.ReadAll(reader)
@@ -435,8 +435,8 @@ func TestClientCreateResourceMultihash(t *testing.T) {
 
 }
 
-// TestClientCreateUpdateResource will check that mutable resources can be created and updated via the HTTP client.
-func TestClientCreateUpdateResource(t *testing.T) {
+// TestClientCreateUpdateFeed will check that feeds can be created and updated via the HTTP client.
+func TestClientCreateUpdateFeed(t *testing.T) {
 
 	signer, _ := newTestSigner()
 
@@ -444,10 +444,10 @@ func TestClientCreateUpdateResource(t *testing.T) {
 	client := NewClient(srv.URL)
 	defer srv.Close()
 
-	// set raw data for the resource
+	// set raw data for the feed update
 	databytes := []byte("En un lugar de La Mancha, de cuyo nombre no quiero acordarme...")
 
-	// our mutable resource name
+	// our feed topic name
 	topic, _ := mru.NewTopic("El Quijote", nil)
 	createRequest := mru.NewFirstRequest(topic)
 
@@ -456,16 +456,16 @@ func TestClientCreateUpdateResource(t *testing.T) {
 		t.Fatalf("Error signing update: %s", err)
 	}
 
-	resourceManifestHash, err := client.CreateResource(createRequest)
+	feedManifestHash, err := client.CreateFeedWithManifest(createRequest)
 
-	correctManifestAddrHex := "fcb8e75f53e480e197c083ad1976d265674d0ce776f2bf359c09c413fb5230b8"
-	if resourceManifestHash != correctManifestAddrHex {
-		t.Fatalf("Response resource manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, resourceManifestHash)
+	correctManifestAddrHex := "0e9b645ebc3da167b1d56399adc3276f7a08229301b72a03336be0e7d4b71882"
+	if feedManifestHash != correctManifestAddrHex {
+		t.Fatalf("Response feed manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, feedManifestHash)
 	}
 
-	reader, err := client.GetResource(nil, correctManifestAddrHex)
+	reader, err := client.QueryFeed(nil, correctManifestAddrHex)
 	if err != nil {
-		t.Fatalf("Error retrieving resource: %s", err)
+		t.Fatalf("Error retrieving feed updates: %s", err)
 	}
 	defer reader.Close()
 	gotData, err := ioutil.ReadAll(reader)
@@ -479,7 +479,7 @@ func TestClientCreateUpdateResource(t *testing.T) {
 	// define different data
 	databytes = []byte("... no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero ...")
 
-	updateRequest, err := client.GetResourceMetadata(nil, correctManifestAddrHex)
+	updateRequest, err := client.GetFeedMetadata(nil, correctManifestAddrHex)
 	if err != nil {
 		t.Fatalf("Error retrieving update request template: %s", err)
 	}
@@ -489,13 +489,13 @@ func TestClientCreateUpdateResource(t *testing.T) {
 		t.Fatalf("Error signing update: %s", err)
 	}
 
-	if err = client.UpdateResource(updateRequest); err != nil {
-		t.Fatalf("Error updating resource: %s", err)
+	if err = client.UpdateFeed(updateRequest); err != nil {
+		t.Fatalf("Error updating feed: %s", err)
 	}
 
-	reader, err = client.GetResource(nil, correctManifestAddrHex)
+	reader, err = client.QueryFeed(nil, correctManifestAddrHex)
 	if err != nil {
-		t.Fatalf("Error retrieving resource: %s", err)
+		t.Fatalf("Error retrieving feed updates: %s", err)
 	}
 	defer reader.Close()
 	gotData, err = ioutil.ReadAll(reader)
@@ -506,17 +506,17 @@ func TestClientCreateUpdateResource(t *testing.T) {
 		t.Fatalf("Expected: %v, got %v", databytes, gotData)
 	}
 
-	// now try retrieving resource without a manifest
+	// now try retrieving feed updates without a manifest
 
-	view := &mru.Feed{
+	feed := &mru.Feed{
 		Topic: topic,
 		User:  signer.Address(),
 	}
 
-	lookupParams := mru.NewQueryLatest(view, lookup.NoClue)
-	reader, err = client.GetResource(lookupParams, "")
+	lookupParams := mru.NewQueryLatest(feed, lookup.NoClue)
+	reader, err = client.QueryFeed(lookupParams, "")
 	if err != nil {
-		t.Fatalf("Error retrieving resource: %s", err)
+		t.Fatalf("Error retrieving feed updates: %s", err)
 	}
 	defer reader.Close()
 	gotData, err = ioutil.ReadAll(reader)

swarm/api/http/server_test.go

@@ -58,47 +58,6 @@ func init() {
 	log.Root().SetHandler(log.CallerFileHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(os.Stderr, log.TerminalFormat(true)))))
 }
 
-func TestResourcePostMode(t *testing.T) {
-	path := ""
-	errstr := "resourcePostMode for '%s' should be raw %v frequency %d, was raw %v, frequency %d"
-	r, f, err := resourcePostMode(path)
-	if err != nil {
-		t.Fatal(err)
-	} else if r || f != 0 {
-		t.Fatalf(errstr, path, false, 0, r, f)
-	}
-
-	path = "raw"
-	r, f, err = resourcePostMode(path)
-	if err != nil {
-		t.Fatal(err)
-	} else if !r || f != 0 {
-		t.Fatalf(errstr, path, true, 0, r, f)
-	}
-
-	path = "13"
-	r, f, err = resourcePostMode(path)
-	if err != nil {
-		t.Fatal(err)
-	} else if r || f == 0 {
-		t.Fatalf(errstr, path, false, 13, r, f)
-	}
-
-	path = "raw/13"
-	r, f, err = resourcePostMode(path)
-	if err != nil {
-		t.Fatal(err)
-	} else if !r || f == 0 {
-		t.Fatalf(errstr, path, true, 13, r, f)
-	}
-
-	path = "foo/13"
-	r, f, err = resourcePostMode(path)
-	if err == nil {
-		t.Fatal("resourcePostMode for 'foo/13' should fail, returned error nil")
-	}
-}
-
 func serverFunc(api *api.API) testutil.TestServer {
 	return NewServer(api, "")
 }
@@ -111,12 +70,12 @@ func newTestSigner() (*mru.GenericSigner, error) {
 	return mru.NewGenericSigner(privKey), nil
 }
 
-// test the transparent resolving of multihash resource types with bzz:// scheme
+// test the transparent resolving of multihash-containing feed updates with bzz:// scheme
 //
-// first upload data, and store the multihash to the resulting manifest in a resource update
+// first upload data, and store the multihash to the resulting manifest in a feed update
 // retrieving the update with the multihash should return the manifest pointing directly to the data
 // and raw retrieve of that hash should return the data
-func TestBzzResourceMultihash(t *testing.T) {
+func TestBzzFeedMultihash(t *testing.T) {
 
 	signer, _ := newTestSigner()
 
@@ -154,7 +113,7 @@ func TestBzzResourceMultihash(t *testing.T) {
 	}
 	log.Info("added data", "manifest", string(b), "data", common.ToHex(mh))
 
-	testUrl, err := url.Parse(fmt.Sprintf("%s/bzz-resource:/", srv.URL))
+	testUrl, err := url.Parse(fmt.Sprintf("%s/bzz-feed:/", srv.URL))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -182,12 +141,12 @@ func TestBzzResourceMultihash(t *testing.T) {
 		t.Fatalf("data %s could not be unmarshaled: %v", b, err)
 	}
 
-	correctManifestAddrHex := "6ef40ba1492cf2a029dc9a8b5896c822cf689d3cd010842f4f1744e6db8824bd"
+	correctManifestAddrHex := "bb056a5264c295c2b0f613c8409b9c87ce9d71576ace02458160df4cc894210b"
 	if rsrcResp.Hex() != correctManifestAddrHex {
-		t.Fatalf("Response resource key mismatch, expected '%s', got '%s'", correctManifestAddrHex, rsrcResp.Hex())
+		t.Fatalf("Response feed manifest address mismatch, expected '%s', got '%s'", correctManifestAddrHex, rsrcResp.Hex())
 	}
 
-	// get bzz manifest transparent resource resolve
+	// get bzz manifest transparent feed update resolve
 	testBzzUrl = fmt.Sprintf("%s/bzz:/%s", srv.URL, rsrcResp)
 	resp, err = http.Get(testBzzUrl)
 	if err != nil {
@@ -207,7 +166,7 @@ func TestBzzResourceMultihash(t *testing.T) {
 }
 
 // Test Swarm Feeds using the raw update methods
-func TestBzzResource(t *testing.T) {
+func TestBzzFeed(t *testing.T) {
 	srv := testutil.NewTestSwarmServer(t, serverFunc, nil)
 	signer, _ := newTestSigner()
 
@@ -234,8 +193,8 @@ func TestBzzResource(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	// creates resource and sets update 1
-	testUrl, err := url.Parse(fmt.Sprintf("%s/bzz-resource:/", srv.URL))
+	// creates feed and sets update 1
+	testUrl, err := url.Parse(fmt.Sprintf("%s/bzz-feed:/", srv.URL))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -262,9 +221,9 @@ func TestBzzResource(t *testing.T) {
 		t.Fatalf("data %s could not be unmarshaled: %v", b, err)
 	}
 
-	correctManifestAddrHex := "6ef40ba1492cf2a029dc9a8b5896c822cf689d3cd010842f4f1744e6db8824bd"
+	correctManifestAddrHex := "bb056a5264c295c2b0f613c8409b9c87ce9d71576ace02458160df4cc894210b"
 	if rsrcResp.Hex() != correctManifestAddrHex {
-		t.Fatalf("Response resource manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, rsrcResp.Hex())
+		t.Fatalf("Response feed manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, rsrcResp.Hex())
 	}
 
 	// get the manifest
@@ -289,12 +248,12 @@ func TestBzzResource(t *testing.T) {
 	if len(manifest.Entries) != 1 {
 		t.Fatalf("Manifest has %d entries", len(manifest.Entries))
 	}
-	correctViewHex := "0x666f6f2e65746800000000000000000000000000000000000000000000000000c96aaa54e2d44c299564da76e1cd3184a2386b8d"
-	if manifest.Entries[0].ResourceView.Hex() != correctViewHex {
-		t.Fatalf("Expected manifest Resource View '%s', got '%s'", correctViewHex, manifest.Entries[0].ResourceView.Hex())
+	correctFeedHex := "0x666f6f2e65746800000000000000000000000000000000000000000000000000c96aaa54e2d44c299564da76e1cd3184a2386b8d"
+	if manifest.Entries[0].Feed.Hex() != correctFeedHex {
+		t.Fatalf("Expected manifest Feed '%s', got '%s'", correctFeedHex, manifest.Entries[0].Feed.Hex())
 	}
 
-	// get bzz manifest transparent resource resolve
+	// get bzz manifest transparent feed update resolve
 	testBzzUrl := fmt.Sprintf("%s/bzz:/%s", srv.URL, rsrcResp)
 	resp, err = http.Get(testBzzUrl)
 	if err != nil {
@@ -302,7 +261,7 @@ func TestBzzResource(t *testing.T) {
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode == http.StatusOK {
-		t.Fatal("Expected error status since resource is not multihash. Received 200 OK")
+		t.Fatal("Expected error status since feed update does not contain multihash. Received 200 OK")
 	}
 	b, err = ioutil.ReadAll(resp.Body)
 	if err != nil {
@@ -310,21 +269,21 @@ func TestBzzResource(t *testing.T) {
 	}
 
 	// get non-existent name, should fail
-	testBzzResUrl := fmt.Sprintf("%s/bzz-resource:/bar", srv.URL)
+	testBzzResUrl := fmt.Sprintf("%s/bzz-feed:/bar", srv.URL)
 	resp, err = http.Get(testBzzResUrl)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	if resp.StatusCode != http.StatusNotFound {
-		t.Fatalf("Expected get non-existent resource to fail with StatusNotFound (404), got %d", resp.StatusCode)
+		t.Fatalf("Expected get non-existent feed manifest to fail with StatusNotFound (404), got %d", resp.StatusCode)
 	}
 
 	resp.Body.Close()
 
-	// get latest update (1.1) through resource directly
+	// get latest update through bzz-feed directly
 	log.Info("get update latest = 1.1", "addr", correctManifestAddrHex)
-	testBzzResUrl = fmt.Sprintf("%s/bzz-resource:/%s", srv.URL, correctManifestAddrHex)
+	testBzzResUrl = fmt.Sprintf("%s/bzz-feed:/%s", srv.URL, correctManifestAddrHex)
 	resp, err = http.Get(testBzzResUrl)
 	if err != nil {
 		t.Fatal(err)
@@ -346,15 +305,15 @@ func TestBzzResource(t *testing.T) {
 	srv.CurrentTime++
 	log.Info("update 2")
 
-	// 1.- get metadata about this resource
-	testBzzResUrl = fmt.Sprintf("%s/bzz-resource:/%s/", srv.URL, correctManifestAddrHex)
+	// 1.- get metadata about this Feed
+	testBzzResUrl = fmt.Sprintf("%s/bzz-feed:/%s/", srv.URL, correctManifestAddrHex)
 	resp, err = http.Get(testBzzResUrl + "?meta=1")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("Get resource metadata returned %s", resp.Status)
+		t.Fatalf("Get feed metadata returned %s", resp.Status)
 	}
 	b, err = ioutil.ReadAll(resp.Body)
 	if err != nil {
@@ -362,13 +321,13 @@ func TestBzzResource(t *testing.T) {
 	}
 	updateRequest = &mru.Request{}
 	if err = updateRequest.UnmarshalJSON(b); err != nil {
-		t.Fatalf("Error decoding resource metadata: %s", err)
+		t.Fatalf("Error decoding feed metadata: %s", err)
 	}
 	updateRequest.SetData(update2Data)
 	if err = updateRequest.Sign(signer); err != nil {
 		t.Fatal(err)
 	}
-	testUrl, err = url.Parse(fmt.Sprintf("%s/bzz-resource:/", srv.URL))
+	testUrl, err = url.Parse(fmt.Sprintf("%s/bzz-feed:/", srv.URL))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -385,9 +344,9 @@ func TestBzzResource(t *testing.T) {
 		t.Fatalf("Update returned %s", resp.Status)
 	}
 
-	// get latest update (1.2) through resource directly
+	// get latest update through bzz-feed directly
 	log.Info("get update 1.2")
-	testBzzResUrl = fmt.Sprintf("%s/bzz-resource:/%s", srv.URL, correctManifestAddrHex)
+	testBzzResUrl = fmt.Sprintf("%s/bzz-feed:/%s", srv.URL, correctManifestAddrHex)
 	resp, err = http.Get(testBzzResUrl)
 	if err != nil {
 		t.Fatal(err)
@@ -408,13 +367,13 @@ func TestBzzResource(t *testing.T) {
 	log.Info("get first update in update1Timestamp via direct query")
 	query := mru.NewQuery(&updateRequest.Feed, update1Timestamp, lookup.NoClue)
 
-	urlq, err := url.Parse(fmt.Sprintf("%s/bzz-resource:/", srv.URL))
+	urlq, err := url.Parse(fmt.Sprintf("%s/bzz-feed:/", srv.URL))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	values := urlq.Query()
-	query.AppendValues(values) // this adds view query parameters
+	query.AppendValues(values) // this adds feed query parameters
 	urlq.RawQuery = values.Encode()
 	resp, err = http.Get(urlq.String())
 	if err != nil {

swarm/api/manifest.go

@@ -36,7 +36,7 @@ import (
 
 const (
 	ManifestType    = "application/bzz-manifest+json"
-	ResourceContentType = "application/bzz-resource"
+	FeedContentType = "application/bzz-feed"
 
 	manifestSizeLimit = 5 * 1024 * 1024
 )
@@ -56,7 +56,7 @@ type ManifestEntry struct {
 	ModTime     time.Time    `json:"mod_time,omitempty"`
 	Status      int          `json:"status,omitempty"`
 	Access      *AccessEntry `json:"access,omitempty"`
-	ResourceView *mru.Feed    `json:"resourceView,omitempty"`
+	Feed        *mru.Feed    `json:"feed,omitempty"`
 }
 
 // ManifestList represents the result of listing files in a manifest
@@ -80,13 +80,13 @@ func (a *API) NewManifest(ctx context.Context, toEncrypt bool) (storage.Address,
 	return addr, err
 }
 
-// Manifest hack for supporting Mutable Resource Updates from the bzz: scheme
+// Manifest hack for supporting Feeds from the bzz: scheme
 // see swarm/api/api.go:API.Get() for more information
-func (a *API) NewResourceManifest(ctx context.Context, view *mru.Feed) (storage.Address, error) {
+func (a *API) NewFeedManifest(ctx context.Context, feed *mru.Feed) (storage.Address, error) {
 	var manifest Manifest
 	entry := ManifestEntry{
-		ResourceView: view,
-		ContentType:  ResourceContentType,
+		Feed:        feed,
+		ContentType: FeedContentType,
 	}
 	manifest.Entries = append(manifest.Entries, entry)
 	data, err := json.Marshal(&manifest)

swarm/api/uri.go

@@ -86,7 +86,7 @@ func Parse(rawuri string) (*URI, error) {
 
 	// check the scheme is valid
 	switch uri.Scheme {
-	case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzz-resource":
+	case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzz-feed":
 	default:
 		return nil, fmt.Errorf("unknown scheme %q", u.Scheme)
 	}
@@ -108,8 +108,8 @@ func Parse(rawuri string) (*URI, error) {
 	}
 	return uri, nil
 }
-func (u *URI) Resource() bool {
-	return u.Scheme == "bzz-resource"
+func (u *URI) Feed() bool {
+	return u.Scheme == "bzz-feed"
 }
 
 func (u *URI) Raw() bool {

swarm/network/README.md

@@ -57,7 +57,7 @@ receipts for a deleted chunk easily to refute their challenge.
 - syncing should be resilient to cut connections, metadata should be persisted that
 keep track of syncing state across sessions, historical syncing state should survive restart
 - extra data structures to support syncing should be kept at minimum
-- syncing is organized separately for chunk types (resource update v content chunk)
+- syncing is organized separately for chunk types (Swarm Feed Updates v regular content chunk)
 - various types of streams should have common logic abstracted
 
 Syncing is now entirely mediated by the localstore, ie., no processes or memory leaks due to network contention.

swarm/storage/localstore_test.go

@@ -30,8 +30,8 @@ var (
 )
 
 // tests that the content address validator correctly checks the data
-// tests that resource update chunks are passed through content address validator
-// the test checking the resouce update validator internal correctness is found in resource_test.go
+// tests that Feed update chunks are passed through content address validator
+// the test checking the resouce update validator internal correctness is found in storage/feeds/handler_test.go
 func TestValidator(t *testing.T) {
 	// set up localstore
 	datadir, err := ioutil.TempDir("", "storage-testvalidator")

swarm/storage/mru/doc.go

@@ -26,7 +26,7 @@ The Feed Update data is:
 updatedata = Feed|Epoch|data
 
 The full update data that goes in the chunk payload is:
-resourcedata|sign(resourcedata)
+updatedata|sign(updatedata)
 
 Structure Summary:
 

swarm/storage/mru/error.go

@@ -35,7 +35,7 @@ const (
 	ErrCnt
 )
 
-// Error is a the typed error object used for Mutable Resources
+// Error is a the typed error object used for Swarm Feeds
 type Error struct {
 	code int
 	err  string

swarm/storage/mru/handler.go

@@ -14,8 +14,8 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-// Handler is the API for Mutable Resources
-// It enables creating, updating, syncing and retrieving resources and their update data
+// Handler is the API for Feeds
+// It enables creating, updating, syncing and retrieving feed updates and their data
 package mru
 
 import (
@@ -265,7 +265,7 @@ func (h *Handler) Update(ctx context.Context, r *Request) (updateAddr storage.Ad
 	// send the chunk
 	h.chunkStore.Put(ctx, chunk)
 	log.Trace("feed update", "updateAddr", r.idAddr, "epoch time", r.Epoch.Time, "epoch level", r.Epoch.Level, "data", chunk.Data())
-	// update our resources map cache entry if the new update is older than the one we have, if we have it.
+	// update our feed updates map cache entry if the new update is older than the one we have, if we have it.
 	if feedUpdate != nil && r.Epoch.After(feedUpdate.Epoch) {
 		feedUpdate.Epoch = r.Epoch
 		feedUpdate.data = make([]byte, len(r.data))

swarm/storage/mru/handler_test.go

@@ -396,7 +396,7 @@ func TestValidatorInStore(t *testing.T) {
 	signer := newAliceSigner()
 
 	// set up localstore
-	datadir, err := ioutil.TempDir("", "storage-testresourcevalidator")
+	datadir, err := ioutil.TempDir("", "storage-testfeedsvalidator")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -463,7 +463,7 @@ func TestValidatorInStore(t *testing.T) {
 	}
 }
 
-// create rpc and resourcehandler
+// create rpc and Feeds Handler
 func setupTest(timeProvider timestampProvider, signer Signer) (fh *TestHandler, datadir string, teardown func(), err error) {
 
 	var fsClean func()

swarm/storage/mru/request_test.go

@@ -228,7 +228,7 @@ func TestUpdateChunkSerializationErrorChecking(t *testing.T) {
 	var recovered Request
 	recovered.fromChunk(chunk.Address(), chunk.Data())
 	if !reflect.DeepEqual(recovered, r) {
-		t.Fatal("Expected recovered SignedResource update to equal the original one")
+		t.Fatal("Expected recovered Request update to equal the original one")
 	}
 }
 
@@ -248,7 +248,7 @@ func TestReverse(t *testing.T) {
 	// signer containing private key
 	signer := newAliceSigner()
 
-	// set up rpc and create resourcehandler
+	// set up rpc and create Feeds handler
 	_, _, teardownTest, err := setupTest(timeProvider, signer)
 	if err != nil {
 		t.Fatal(err)

swarm/swarm.go

@@ -186,15 +186,15 @@ func NewSwarm(config *api.Config, mockStore *mock.NodeStore) (self *Swarm, err e
 	// Swarm Hash Merklised Chunking for Arbitrary-length Document/File storage
 	self.fileStore = storage.NewFileStore(self.netStore, self.config.FileStoreParams)
 
-	var resourceHandler *mru.Handler
-	rhparams := &mru.HandlerParams{}
+	var feedsHandler *mru.Handler
+	fhParams := &mru.HandlerParams{}
 
-	resourceHandler = mru.NewHandler(rhparams)
-	resourceHandler.SetStore(self.netStore)
+	feedsHandler = mru.NewHandler(fhParams)
+	feedsHandler.SetStore(self.netStore)
 
 	lstore.Validators = []storage.ChunkValidator{
 		storage.NewContentAddressValidator(storage.MakeHashFunc(storage.DefaultHash)),
-		resourceHandler,
+		feedsHandler,
 	}
 
 	log.Debug("Setup local storage")
@@ -210,7 +210,7 @@ func NewSwarm(config *api.Config, mockStore *mock.NodeStore) (self *Swarm, err e
 		pss.SetHandshakeController(self.ps, pss.NewHandshakeParams())
 	}
 
-	self.api = api.NewAPI(self.fileStore, self.dns, resourceHandler, self.privateKey)
+	self.api = api.NewAPI(self.fileStore, self.dns, feedsHandler, self.privateKey)
 
 	self.sfs = fuse.NewSwarmFS(self.api)
 	log.Debug("Initialized FUSE filesystem")

swarm/testutil/http.go

@@ -48,14 +48,14 @@ func NewTestSwarmServer(t *testing.T, serverFunc func(*api.API) TestServer, reso
 	}
 	fileStore := storage.NewFileStore(localStore, storage.NewFileStoreParams())
 
-	// mutable resources test setup
-	resourceDir, err := ioutil.TempDir("", "swarm-resource-test")
+	// Swarm Feeds test setup
+	feedsDir, err := ioutil.TempDir("", "swarm-feeds-test")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	rhparams := &mru.HandlerParams{}
-	rh, err := mru.NewTestHandler(resourceDir, rhparams)
+	rh, err := mru.NewTestHandler(feedsDir, rhparams)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -71,7 +71,7 @@ func NewTestSwarmServer(t *testing.T, serverFunc func(*api.API) TestServer, reso
 			srv.Close()
 			rh.Close()
 			os.RemoveAll(dir)
-			os.RemoveAll(resourceDir)
+			os.RemoveAll(feedsDir)
 		},
 		CurrentTime: 42,
 	}