renames pulse to snap

.travis.yml

@@ -13,16 +13,16 @@ before_install:
 - go get golang.org/x/tools/cmd/vet
 - go get golang.org/x/tools/cmd/goimports
 - go get github.com/smartystreets/goconvey/convey
-- if [ ! -d $PULSE_SOURCE ]; then mkdir -p $HOME/gopath/src/github.com/intelsdi-x; ln -s $TRAVIS_BUILD_DIR $PULSE_SOURCE; fi # CI for forks not from intelsdi-x
+- if [ ! -d $SNAP_SOURCE ]; then mkdir -p $HOME/gopath/src/github.com/intelsdi-x; ln -s $TRAVIS_BUILD_DIR $SNAP_SOURCE; fi # CI for forks not from intelsdi-x
 - go get golang.org/x/tools/cmd/cover
 env:
   global:
-    - PULSE_SOURCE=/home/travis/gopath/src/github.com/intelsdi-x/pulse
-    - PULSE_PATH=/home/travis/gopath/src/github.com/intelsdi-x/pulse/build
+    - SNAP_SOURCE=/home/travis/gopath/src/github.com/intelsdi-x/snap
+    - SNAP_PATH=/home/travis/gopath/src/github.com/intelsdi-x/snap/build
 install:
 - export TMPDIR=$HOME/tmp
 - mkdir -p $TMPDIR
-- cd $PULSE_SOURCE # change dir into source
+- cd $SNAP_SOURCE # change dir into source
 - make
 script:
 - make check 2>&1 # Run test suite

CONTRIBUTING.md

@@ -2,8 +2,8 @@
 
 ##Build and Test
 ###Build
-In the /pulse directory there's a `Makefile` that builds all dependencies and Pulse.
-To get dependencies and build Pulse just run:  
+In the /snap directory there's a `Makefile` that builds all dependencies and snap.
+To get dependencies and build snap just run:  
 ```
 make
 ```
@@ -20,23 +20,23 @@ deps:
 	#gets all dependencies using godeps
 	bash -c "./scripts/deps.sh"
 test:
-	#exports Pulse build path to env var PULSE_PATH and runs test files
-	export PULSE_PATH=`pwd`/build; bash -c "./scripts/test.sh"
+	#exports snap build path to env var SNAP_PATH and runs test files
+	export SNAP_PATH=`pwd`/build; bash -c "./scripts/test.sh"
 check:
 	#runs make test
 	$(MAKE) test
 all:
-	#builds Pulse daemon, CLI, and plugin binaries
+	#builds snap daemon, CLI, and plugin binaries
 	bash -c "./scripts/build.sh $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST)))) true"
-pulse:
-	#builds Pulse daemon and CLI binaries, but not plugin binaries
+snap:
+	#builds snap daemon and CLI binaries, but not plugin binaries
 	bash -c "./scripts/build.sh $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))"
 install:
-	#copies pulsed and pulsectl binaries into /usr/local/bin
-	cp build/bin/pulsed /usr/local/bin/
-	cp build/bin/pulsectl /usr/local/bin/
+	#copies snapd and snapctl binaries into /usr/local/bin
+	cp build/bin/snapd /usr/local/bin/
+	cp build/bin/snapctl /usr/local/bin/
 release:
-	#creates a Pulse release
+	#creates a snap release
 	bash -c "./scripts/release.sh $(TAG) $(COMMIT)"
 ```
 
@@ -81,13 +81,13 @@ There's a `Dockerfile` located at `./scripts/Dockerfile`:
 ```
 FROM golang:latest
 ENV GOPATH=$GOPATH:/app
-ENV PULSE_PATH=/go/src/github.com/intelsdi-x/pulse/build
+ENV SNAP_PATH=/go/src/github.com/intelsdi-x/snap/build
 RUN apt-get update && \
     apt-get -y install facter
 WORKDIR /go/src/github.com/intelsdi-x/
 RUN git clone https://<GIT_TOKEN>@github.com/intelsdi-x/gomit.git
-WORKDIR /go/src/github.com/intelsdi-x/pulse
-ADD . /go/src/github.com/intelsdi-x/pulse
+WORKDIR /go/src/github.com/intelsdi-x/snap
+ADD . /go/src/github.com/intelsdi-x/snap
 RUN go get github.com/tools/godep && \
     go get golang.org/x/tools/cmd/goimports && \
     go get golang.org/x/tools/cmd/vet && \
@@ -96,7 +96,7 @@ RUN go get github.com/tools/godep && \
 RUN scripts/deps.sh
 RUN make
 ```
-This is run in the pulse directory using `./scripts/run_tests_with_docker.sh`  
+This is run in the snap directory using `./scripts/run_tests_with_docker.sh`  
 First you need a [github personal access token](https://help.github.com/articles/creating-an-access-token-for-command-line-use/)  
 Then export the token using `export GIT_TOKEN=<tokenID>`.
 
@@ -117,7 +117,7 @@ if [ -z "${GIT_TOKEN}" ]; then
 fi
 
 sed s/\<GIT_TOKEN\>/${GIT_TOKEN}/ scripts/Dockerfile > scripts/Dockerfile.tmp
-docker build -t intelsdi-x/pulse-test -f scripts/Dockerfile.tmp .
+docker build -t intelsdi-x/snap-test -f scripts/Dockerfile.tmp .
 rm scripts/Dockerfile.tmp
-docker run -it intelsdi-x/pulse-test scripts/test.sh
-```
+docker run -it intelsdi-x/snap-test scripts/test.sh
+```

Makefile

@@ -21,15 +21,15 @@ default:
 deps:
 	bash -c "./scripts/deps.sh"
 test:
-	export PULSE_PATH=`pwd`/build; bash -c "./scripts/test.sh"
+	export SNAP_PATH=`pwd`/build; bash -c "./scripts/test.sh"
 check:
 	$(MAKE) test
 all:
 	bash -c "./scripts/build.sh $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST)))) true"
-pulse:
+snap:
 	bash -c "./scripts/build.sh $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))"
 install:
-	cp build/bin/pulsed /usr/local/bin/
-	cp build/bin/pulsectl /usr/local/bin/
+	cp build/bin/snapd /usr/local/bin/
+	cp build/bin/snapctl /usr/local/bin/
 release:
 	bash -c "./scripts/release.sh $(TAG) $(COMMIT)"

README.md

@@ -17,16 +17,16 @@ See the License for the specific language governing permissions and
 limitations under the License.
 -->
 
-# **Pulse** <sup><sub>_A powerful telemetry agent framework_</sub></sup>
-[![Build Status](https://magnum.travis-ci.com/intelsdi-x/pulse.svg?token=2ujsxEpZo1issFyVWX29&branch=master)](https://magnum.travis-ci.com/intelsdi-x/pulse)
+# **snap** <sup><sub>_A powerful telemetry agent framework_</sub></sup>
+[![Build Status](https://magnum.travis-ci.com/intelsdi-x/snap.svg?token=2ujsxEpZo1issFyVWX29&branch=master)](https://magnum.travis-ci.com/intelsdi-x/snap)
 
 - [ ] TODO: Consider branching note ([like this one](https://github.com/Netflix/genie#in-active-development))
 
 1. [Overview](#overview)
 2. [Getting Started](#getting-started)
   * [System Requirements](#system-requirements)
   * [Installation](#installation)
-  * [Running Pulse](#running-pulse)
+  * [Running snap](#running-snap)
   * [Load Plugins](#load-plugins)
   * [Running Tasks](#running-tasks)
   * [Building Tasks](#building-tasks)
@@ -43,80 +43,80 @@ limitations under the License.
 
 ## Overview
 
-**Pulse** is a framework for enabling the gathering of telemetry from systems. The goals of this project are to:
+**snap** is a framework for enabling the gathering of telemetry from systems. The goals of this project are to:
 
 * Empower systems to expose a consistent set of telemetry data
 * Simplify telemetry ingestion across ubiquitous storage system
 * Improve the deployment model, packaging and flexibility for collecting telemetry
 * Allow flexible processing of telemetry data on agent (e.g. machine learning)
 * Provide powerful clustered control of telemetry workflows across small or large clusters
 
-The key features of Pulse are:
+The key features of snap are:
 
-* **Plugin Architecture**: Pulse has a simple and smart modular design. The three types of plugins (collectors, processors, and publishers) allow Pulse to mix and match functionality based on user need. All plugins are designed with versioning, signing and deployment at scale in mind. The open plugin model allows for loading built-in, community, or proprietary plugins into Pulse.
+* **Plugin Architecture**: snap has a simple and smart modular design. The three types of plugins (collectors, processors, and publishers) allow snap to mix and match functionality based on user need. All plugins are designed with versioning, signing and deployment at scale in mind. The open plugin model allows for loading built-in, community, or proprietary plugins into snap.
   * **Collectors** - Collectors consume telemetry data. Collectors are built-in plugins for leveraging existing telemetry solutions (Facter, CollectD, Ohai) as well as specific plugins for consuming Intel telemetry (Node, DCM, NIC, Disk) and can reach into new architectures through additional plugins (see [Plugin Authoring below](#)). Telemetry data is organized into a dynamically generated catalog of available data points.
   * **Processors** - Extensible workflow injection. Convert telemetry into another data model for consumption by existing consumption systems (like OpenStack Ceilometer). Allows encryption of all or part of the telemetry payload before publishing. Inject remote queries into workflow for tokens, filtering, or other external calls. Implement filtering at an agent level reducing injection load on telemetry consumer.
-  * **Publishers** - Store telemetry into a wide array of systems. Pulse decouples the collection of telemetry from the implementation of where to send it. Pulse comes with a large library of publisher plugins that allow exposure to telemetry analytics systems both custom and common. This flexibility allows Pulse to be valuable to open source and commercial ecosystems alike by writing a publisher for their architectures.
+  * **Publishers** - Store telemetry into a wide array of systems. snap decouples the collection of telemetry from the implementation of where to send it. snap comes with a large library of publisher plugins that allow exposure to telemetry analytics systems both custom and common. This flexibility allows snap to be valuable to open source and commercial ecosystems alike by writing a publisher for their architectures.
 
 
-* **Dynamic Updates**: Pulse is designed to evolve. Each scheduled workflow automatically uses the most mature plugin for that step, unless the collection is pinned to a specific version (ex: get /intel/server/cpu/load/v1). Loading a new plugin automatically upgrades running workflows in tasks. Load plugins dynamically, without a restart to the service or server. This dynamically extends the metric catalog when loaded, giving access to new measurements immediately. Swapping a newer version plugin for an old one in a safe transaction. All of these behaviors allow for simple and secure bug fixes, security patching, and improving accuracy in production.
+* **Dynamic Updates**: snap is designed to evolve. Each scheduled workflow automatically uses the most mature plugin for that step, unless the collection is pinned to a specific version (ex: get /intel/server/cpu/load/v1). Loading a new plugin automatically upgrades running workflows in tasks. Load plugins dynamically, without a restart to the service or server. This dynamically extends the metric catalog when loaded, giving access to new measurements immediately. Swapping a newer version plugin for an old one in a safe transaction. All of these behaviors allow for simple and secure bug fixes, security patching, and improving accuracy in production.
 
-* **Pulse Tribe**: Pulse is designed for ease of administration. With Pulse Tribe, nodes work in groups (aka tribes). Requests are made through agreement- or task-based node groups, designed as a scalable gossip-based node-to-node communication process. Administrators can control all Pulse nodes in a tribe agreement by messaging just one of them. There is auto-discovery of new nodes and import of tasks & plugins from nodes within a given tribe. It is cluster configuration management made simple.
+* **snap Tribe**: snap is designed for ease of administration. With snap Tribe, nodes work in groups (aka tribes). Requests are made through agreement- or task-based node groups, designed as a scalable gossip-based node-to-node communication process. Administrators can control all snap nodes in a tribe agreement by messaging just one of them. There is auto-discovery of new nodes and import of tasks & plugins from nodes within a given tribe. It is cluster configuration management made simple.
 
-Some additionally important notes about how Pulse works:
+Some additionally important notes about how snap works:
 
 * Multiple management modules including: CLI, REST API, and Web Console (each of which can be turned on or off)
 * Secure validation occurs via plugin signing, SSL encryption for APIs and payload encryption for communication between components
 * CLI control from Linux or OS X
 
-**Pulse** is not intended to:
+**snap** is not intended to:
 
 * Operate as an analytics platform: the intention is to allow plugins for feeding those platforms
-* Compete with existing metric/monitoring/telemetry agents: Pulse is simply a new option to use or reference
+* Compete with existing metric/monitoring/telemetry agents: snap is simply a new option to use or reference
 
 ## Getting Started
 
 ### System Requirements
-Pulse deploys as a binary, which makes requirements quite simple. We've tested on the following versions of linux/os x
+snap deploys as a binary, which makes requirements quite simple. We've tested on the following versions of linux/os x
 
 {}
 
 ### Installation
 
-You can get the pre-built binaries for your OS and architecture at Pulse's [Github Releases](https://github.com/intelsdi-x/pulse/releases) page.  Right now, Pulse only supports Linux and OS X.
+You can get the pre-built binaries for your OS and architecture at snap's [Github Releases](https://github.com/intelsdi-x/snap/releases) page.  Right now, snap only supports Linux and OS X.
 
-If you're looking for the bleeding edge of Pulse, you can build it by cloning down the `master` branch.  To build Pulse from source, you will need [Golang >= 1.4](https://golang.org) and [GNU Make](https://www.gnu.org/software/make/).  More on building Pulse [here](./CONTRIBUTING.md).
+If you're looking for the bleeding edge of snap, you can build it by cloning down the `master` branch.  To build snap from source, you will need [Golang >= 1.4](https://golang.org) and [GNU Make](https://www.gnu.org/software/make/).  More on building snap [here](./CONTRIBUTING.md).
 
-### Running Pulse
+### Running snap
 
-Start a standalone Pulse agent:
+Start a standalone snap agent:
 
 ```sh
-$ ./bin/pulsed --plugin-trust 0 --log-level 1
+$ ./bin/snapd --plugin-trust 0 --log-level 1
 ```
 
-This will bring up a Pulse agent without requiring plugin signing and set the logging level to debug.  Pulse's REST API will be listening on port 8181.
+This will bring up a snap agent without requiring plugin signing and set the logging level to debug.  snap's REST API will be listening on port 8181.
 
 ## Load Plugins
-Pulse gets its power from the use of plugins. The [Plugin Catalog](#plugin-catalog) is a collection of all known plugins for Pulse.
+snap gets its power from the use of plugins. The [Plugin Catalog](#plugin-catalog) is a collection of all known plugins for snap.
 
-Next, lets load a few of the demo plugins.  You can do this via cURL, or `pulsectl`, Pulse's CLI:
+Next, lets load a few of the demo plugins.  You can do this via cURL, or `snapctl`, snap's CLI:
 
 ```sh
-curl -X POST -F plugin=@build/plugin/pulse-collector-mock1 http://localhost:8181/v1/plugins
+curl -X POST -F plugin=@build/plugin/snap-collector-mock1 http://localhost:8181/v1/plugins
 ```
 
 And:
 
 ```sh
-$ ./bin/pulsectl plugin load build/plugin/pulse-processor-passthru
-$ ./bin/pulsectl plugin load build/plugin/pulse-publisher-file
+$ ./bin/snapctl plugin load build/plugin/snap-processor-passthru
+$ ./bin/snapctl plugin load build/plugin/snap-publisher-file
 ```
 
 Let's look at what plugins we have loaded now:
 
 ```sh
-$ ./bin/pulsectl plugin list
+$ ./bin/snapctl plugin list
 NAME             VERSION         TYPE            SIGNED          STATUS          LOADED TIME
 mock1            1               collector       false           loaded          Tue, 17 Nov 2015 14:08:17 PST
 passthru         1               processor       false           loaded          Tue, 17 Nov 2015 14:16:12 PST
@@ -127,7 +127,7 @@ file             3               publisher       false           loaded
 Next, let's start one of the [example tasks](./examples/tasks/mock-file.json) from the `examples/` directory:
 
 ```
-$ ./bin/pulsectl task create -t examples/tasks/mock-file.json
+$ ./bin/snapctl task create -t examples/tasks/mock-file.json
 Using task manifest to create task
 Task created
 ID: 8b9babad-b3bc-4a16-9e06-1f35664a7679
@@ -142,9 +142,9 @@ See the data that is being published to the file:
 $ tail -f /tmp/published
 ```
 
-Or actually tap into the data that Pulse is collecting:
+Or actually tap into the data that snap is collecting:
 ```
-$ ./bin/pulsectl task watch 8b9babad-b3bc-4a16-9e06-1f35664a7679
+$ ./bin/snapctl task watch 8b9babad-b3bc-4a16-9e06-1f35664a7679
 ```
 
 ### Building Tasks
@@ -155,40 +155,40 @@ All known Plugins are tracked in the [Plugin Catalog](#()) and are tagged as con
 If you would like to write your own, read through [Authoring a Plugin](#). Let us know if you begin to write one by opening an Issue. When you finish, please open a Pull Request to add yours to the list!
 
 ## Documentation
-Documentation for Pulse will be kept in this repository for now. We would also like to link to external how-to blog posts as people write them. See our [Contributing](#contributing) for more details.
+Documentation for snap will be kept in this repository for now. We would also like to link to external how-to blog posts as people write them. See our [Contributing](#contributing) for more details.
 
-* [Pulsectl](cmd/pulsectl/README.md)
-* [Pulsed](docs/PULSED.md)
+* [snapctl](cmd/snapctl/README.md)
+* [snapd](docs/SNAPD.md)
 
 ### Examples
-There are interesting examples of using Pulse in every plugin repository:
+There are interesting examples of using snap in every plugin repository:
 
 < TODO -- move these to different repos.
 * [configs](examples/configs/) is a basic example of
-* [tasks](examples/tasks/) has JSON-encoded execution requests for Pulse plugins
+* [tasks](examples/tasks/) has JSON-encoded execution requests for snap plugins
 
 ### Roadmap
 
 
 ## Community Support
-This repository is one of **many** projects in the **Pulse Framework**. Discuss your questions about Pulse by reaching out to us on:
+This repository is one of **many** projects in the **snap Framework**. Discuss your questions about snap by reaching out to us on:
 
-* Pulse Gitter channel (TODO Link)
+* snap Gitter channel (TODO Link)
 * Our Google Group (TODO Link)
 
-The full project lives here, at http://github.com/intelsdi-x/pulse.
+The full project lives here, at http://github.com/intelsdi-x/snap.
 
 ## Contributing
-We encourage contribution from the community. **Pulse** needs:
+We encourage contribution from the community. **snap** needs:
 
 * _Feedback_: try it and tell us about it through issues, blog posts or Twitter
 * _Contributors_: We need plugins, schedules, testing, and more
-* _Integrations_: **Pulse** can feasibly publish to almost any destination. We need publishing plugins for [Ceilometer](https://wiki.openstack.org/wiki/Ceilometer), [vCOPs](http://www.vmware.com/products/vrealize-operations), and more. See [the Plugin Catalog](./docs/PLUGIN_CATALOG.md#wish-list) for the full list
+* _Integrations_: **snap** can feasibly publish to almost any destination. We need publishing plugins for [Ceilometer](https://wiki.openstack.org/wiki/Ceilometer), [vCOPs](http://www.vmware.com/products/vrealize-operations), and more. See [the Plugin Catalog](./docs/PLUGIN_CATALOG.md#wish-list) for the full list
 
-To contribute to the Pulse framework, see [our CONTRIBUTING file](CONTRIBUTING.md). To give back to a specific plugin, open an issue on its repository.
+To contribute to the snap framework, see [our CONTRIBUTING file](CONTRIBUTING.md). To give back to a specific plugin, open an issue on its repository.
 
 ## License
-Pulse is an Open Source software released under the Apache 2.0 [License](LICENSE).
+snap is an Open Source software released under the Apache 2.0 [License](LICENSE).
 
 ## Maintainers