spacebunny 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ec6a838a45e43d41f1af7b2b4689fb9cb239bbf
+  data.tar.gz: b45289c93365e82c60d325c7cf4a3d04787ac4bd
+SHA512:
+  metadata.gz: 79e6ae369230e1e92a791a159f4c935b28f621c11970167b60dfd1511d442393b010bb0be00570b8b1774c20cca05b9177ec925783eb24380447f9cac76fab41
+  data.tar.gz: 0321121e0d08d1440392080c26625bcb1abd363b443300f324add3a73e717fc84d5571385954a7bf8687b6d3887c390c4b10bda2c6ab62a0085dab5406228df5

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.idea
+*.orig
+private_examples/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Fancy Pixel S.r.l. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+<p align="center">
+  <img width="480" src="assets/logo.png"/>
+</p>
+
+[![Build Status](https://travis-ci.org/space-bunny/ruby_sdk.svg)](https://travis-ci.org/space-bunny/ruby_sdk)
+[![Gem Version](https://badge.fury.io/rb/spacebunny.svg)](https://badge.fury.io/rb/spacebunny)
+
+[SpaceBunny](http://spacebunny.io) is the IoT platform that makes it easy for you and your devices to send and
+exchange messages with a server or even with each other. You can store the data, receive timely event notifications,
+monitor live streams and remotely control your devices. Easy to use, and ready to scale at any time.
+
+This is the source code repository for Ruby SDK.
+Please feel free to contribute!
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spacebunny'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spacebunny
+
+After you have signed up for a [SpaceBunny](http://spacebunny.io)'s account, follow the
+[Getting Started](http://getting_started_link) guide for a one minute introduction to the platform concepts
+and a super rapid setup.
+
+This SDK provides Device and LiveStream clients and currently supports the AMQP protocol.
+
+### Device - Basic usage
+
+Pick a device, view its configurations and copy the Device Key. Instantiate a new `Spacebunny::Device` client,
+providing the Device Key:
+
+```ruby
+dev = Spacebunny::Device.new 'device_key'
+```
+
+the SDK will auto-configure, contacting [SpaceBunny APIs](http://doc.spacebunny.io/api) endpoint, retrieving the
+connection configurations and required parameters. Nothing remains but to connect:
+
+```ruby
+dev.connect
+```
+
+##### Publish
+
+Ok, all set up! Let's publish some message:
+
+```ruby
+# We're assuming you have created a 'data' channel and you have enabled it for your device
+
+# Let's publish, for instance, some JSON. Payload can be everything you want,
+# SpaceBunny does not impose any constraint on format or content.
+
+require 'json'  # to convert our payload to JSON
+
+# Publish one message every second for a minute.
+60.times do
+  # Generate some random data
+  payload = { greetings: 'Hello, World!', temp: rand(20.0..25.0), foo: rand(100..200) }.to_json
+    
+  # Publish
+  dev.publish :data, payload
+  
+  # Give feedback on what has been published
+  puts "Published: #{payload}"
+
+  # Take a nap...
+  sleep 1
+end
+```
+
+Let's check out that our data is really being sent by going to our web dashboard: navigate to devices, select the
+device and click on 'LIVE DATA'. Select the 'data' channel from the dropdown and click **Start**.
+Having published data as JSON allows SpaceBunny's web UI to parse them and visualize a nice
+realtime graph: On the **Chart** tab write `temp` in the input field and press enter.
+You'll see the graph of the `temp` parameter being rendered. If you want to plot more parameters,
+just use a comma as separator e.g: temp, pressure, voltage
+On the **Messages** tab you'll see raw messages' payloads received on this channel.
+
+##### Inbox
+
+Waiting for and reading messages from the device's Inbox is trivial:
+
+```ruby
+dev.inbox(wait: true, ack: :auto) do |message|
+  puts "Received: #{message.payload}"
+end
+```
+
+`wait` option (default false) causes the script to wait forever on the receive block
+
+`ack` option can have two values: `:manual` (default) or `:auto`. When `:manual` you are responsible to ack the messages,
+for instance:
+
+```ruby
+dev.inbox(block: true, ack: :manual) do |message|
+  puts "Received: #{message.payload}"
+  # Manually ack the message
+  message.ack
+end
+```
+This permits to handle errors or other critical situations
+
+### Live Stream - Basic usage
+
+For accessing a Live Stream a Live Stream Key's is required. On SpaceBunny's Web UI, go to the Streams section,
+click on "Live Stream Keys" and pick or create one.
+
+```ruby
+live = Spacebunny::LiveStream.new client: 'live_stream_key_client', secret: 'live_stream_key_secret'
+```
+
+Similarly to the Device client, the SDK will auto-configure itself, contacting [SpaceBunny APIs](http://doc.spacebunny.io/api)
+endpoint, retrieving the connection configurations and required parameters. Nothing remains but to connect:
+
+```ruby
+live.connect
+```
+
+##### Reading live messages
+
+Each LiveStream has its own cache that will keep always last 100 messages (FIFO, when there are more than 100 messages,
+the oldest ones get discarded). If you want to consume messages in a parallel way, you shoul use the cache and connect
+ as many LiveStream clients as you need: this way messages will be equally distributed to clients.
+
+```ruby
+live.message_from_cache :some_live_stream, wait: true, ack: :auto do |message|
+  puts "Received from cache: #{message.payload}"
+end
+
+# An equivalent method is:
+# live.message_from :some_live_stream, from_cache: true, wait: true, ack: :auto do |message|
+#   puts "Received from cache: #{message.payload}"
+# end
+```
+
+Conversely, if you want that each client will receive a copy of each message, don't use the cache:
+
+```ruby
+live.message_from :some_live_stream, wait: true, ack: :auto do |message|
+  puts "Received a copy of: #{message.payload}"
+end
+```
+
+Every client subscribed to the LiveStream in this way will receive a copy of the message.
+
+### TLS
+
+Instantiating a TLS-secured connection is trivial:
+
+```ruby
+# For a Device
+
+dev = Spacebunny::Device.new key, tls: true
+
+# Similarly, for a Live Stream
+
+live = Spacebunny::LiveStream.new client, secret, tls: true
+```
+
+## More examples and options
+
+Take a look at the ```examples``` directory for more code samples and further details about available options.
+
+
+### Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/FancyPixel/spacebunny_ruby.
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere
+to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+### Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'spacebunny'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/device/auto_config_publish.rb

@@ -0,0 +1,87 @@
+require 'spacebunny'
+require 'json'
+
+# Prerequisites: you have created a device through the SpaceBunny's web interface. You also have a 'data' channel (name
+# is not mandatory, but we'll use this for our example). You have also enabled 'data' channel for the device. See our
+# Getting Started [link] for a quick introduction to SpaceBunny's base concepts.
+
+# Once everything is set up get your device's API key from SpaceBunny's web application: on the web interface,
+# go to devices section and create or pick an existing device. Click on the 'SHOW CONFIGURATION' link, copy the API key
+# and substitute it here:
+
+device_key = 'your_awesome_device_key'
+
+# Let's instantiate a SpaceBunny client, providing the device's API key, that's the fastest and simplest method
+# to create a new client. If, for some reason, you need to customize the settings, take a look at
+# examples/manual_config.rb for an example of connection settings customization.
+
+dev = Spacebunny::Device.new device_key
+
+# An equivalent method for providing the API key is through options: Spacebunny::Device.new(key: key)
+
+# We need to call 'connect' in order to open the communication with SpaceBunny platform
+
+dev.connect
+
+# At this point the SDK is auto-configured and ready to use.
+# Configurations are automatically lazy-fetched by the SDK itself when calling 'connect'.
+
+# PUBLISHING MESSAGES
+
+# As said in the prerequisites, we'll assume that 'data' channel is enabled for your device.
+# If you're in doubt, please check that this is true through SpaceBunny's web interface, by clicking on the device
+# 'edit' (pencil icon) and verifying that 'data' channel is present and enabled for this device. Take a look at Getting
+# Started [link] for a quick introduction to SpaceBunny's base concepts.
+
+# Let's publish, for instance, some JSON. Payload can be everything you want, SpaceBunny does not impose any constraint
+# on format or content of payload.
+
+# Publish one message every second for a minute.
+count = 0
+60.times do
+  # Generate some random data
+  payload = {
+      count: count,
+      greetings: "Hello from #{dev.name}!",
+      temp: rand(20.0..25.0),
+      foo: rand(100..200)
+  }.to_json
+
+  # Hint: the channel name can also be a string e.g: 'data'
+  dev.publish :data, payload
+
+  # 'publish' takes two mandatory arguments (channel's name and payload) and a variety of options: one of these options is
+  # the 'with_confirm' flag: when set to true this requires SpaceBunny's platform to confirm the receipt of the message.
+  # This is useful when message delivery assurance is mandatory for your use case.
+  # Take a look at SDK's documentation for further details.
+
+  # Give some feedback on what has been published
+  puts "Published #{payload}"
+
+  # Take a nap...
+  sleep 1
+  # Update counter
+  count += 1
+end
+
+# Let's check out that our data is really being sent by going to our web dashboard: navigate to devices, select the
+# device and click on 'LIVE DATA'. Select 'data' channel from the dropdown and click 'START'.
+# Having published data as JSON it's possible for SpaceBunny to parse them and visualize a nice
+# realtime graph: On the 'Graphic' tab write 'temp' in the input field and press enter.
+# You'll see the graph of the 'temp' going on. If you want to graph more params, just use a comma as separator
+# e.g: temp, pressure, voltage
+# On the 'Messages' you'll see raw messages' payloads received on this channel.
+# On the 'Logs' tab are present various log messages useful for debugging purposes.
+
+# Bonus points:
+#
+# SpaceBunny AMQP SDK uses "Bunny" [link] under the hoods so it supports all the features and attributes provided
+# by the AMQP protocol. For instance, providing 'headers' or a 'timestamp' attribute is just a matter of adding it
+# as options after the payload:
+
+# dev.publish :data, payload,
+#                    timestamp: Time.now.to_i,
+#                    headers: { my_custom_header: 'value' }
+#
+# 'timestamp' property or 'Timestamp' header can be used to provide a 'captured at' timestamp to data persisted
+# by 'Persistence' plugin. Learn more [link].

data/examples/device/manual_config.rb

@@ -0,0 +1,83 @@
+require 'spacebunny'
+require 'json'
+
+# Prerequisites: you have created a device through the SpaceBunny's web interface. You also have a 'data' channel (name
+# is not mandatory, but we'll use this for our example). You have also enabled 'data' channel for the device. See our
+# Getting Started [link] for a quick introduction to SpaceBunny's base concepts.
+
+# If for some reason or use case it's not possible or desirable to use auto-configuration, SpaceBunny's Ruby SDK
+# permits to manually configure the connection with various methods.
+
+# First of all go to SpaceBunny's web interface, go to the devices section and create or pick an existing device.
+# Click on the 'SHOW CONFIGURATION' link and, from the 'Full configuration' section, copy the configuration from the
+# "Ruby" section and customize it to your needs.
+
+# Replace with device's Ruby configs hash copied from web inteface
+configs = {
+    :connection => {
+        :host        => "api.demo.spacebunny.io",
+        :protocols   => {
+            :amqp      => {
+                :port => 5672
+            },
+            :mqtt      => {
+                :port => 1883
+            },
+            :stomp     => {
+                :port => 61613
+            },
+            :web_stomp => {
+                :port => 15674
+            }
+        },
+        :device_name => "device_1",
+        :device_id   => "your_dev_id",
+        :secret      => "your_dev_secret",
+        :vhost       => "your_vhost"
+    },
+    :channels   => [
+        {
+            :id         => "one_channel_id",
+            :name       => "channel_name"
+        }
+    ]
+}
+
+dev = Spacebunny::Device.new configs
+
+# An alternative method is to create an 'empty' client instance and then fill connection params
+# before calling 'connect':
+#
+# dev = Spacebunny::Device.new
+# dev.connection_options = {
+#     connection: {
+#         device_id: '9999aa99-9999-9aaa-aa99-aa9a999a9999',
+#         secret: 'top_secret',
+#         host: 'spacebunny.io',
+#         protocols: {
+#             amqp: { port: 5672}
+#         },
+#         vhost: '11111bb1-1111-1bbb-bb11-11bb11bbbbbb'
+#     }
+# }
+#
+# Set the channels at a later time
+# dev.channels = [:data]
+
+dev.connect
+
+# At this point the client is ready to operate.
+# Publish one message every second for a minute.
+
+60.times do
+  # Generate some random data
+  payload = { greetings: 'Hello, World!', temp: rand(20.0..25.0), foo: rand(100..200) }.to_json
+
+  dev.publish :data, payload
+
+  # Give some feedback on what has been published
+  puts "Published #{payload}"
+
+  # Take a nap...
+  sleep 1
+end