azure 0.1.1 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58379e3390000bfc95e09ef03af2bd8d7f87789e
+  data.tar.gz: 06cfc38fdaffc3aad57bd7fe5bd93c1ec881a57e
+SHA512:
+  metadata.gz: c1409401b9b1932adc8a2b4c5736807de92d0711fa1ca79376e8a0771d2027d468965b2dd52dbba5d185862d1670a89bb91f27da57b3144b13eab0dd0d3a7692
+  data.tar.gz: db6148b118e844731a13488e584ea6541ea68aae3c4304d10039c4a579ccf660a74a9007f036cb9f6971745f62e1306df18d944a35a1a512f00ebf0e4af287f5

data/.gitignore

@@ -0,0 +1,6 @@
+.rvmrc
+tags
+/pkg
+/doc
+Gemfile.lock
+.DS_Store

data/ChangeLog.txt

@@ -0,0 +1,5 @@
+2012.04.25 - version 0.5.0
+* First release
+* Ruby 1.9.3 and 2.0 support
+* Storage support: Blob, Table and Queue
+* Service Bus support: Queue, Topic/Subscription

data/Gemfile

@@ -1,3 +1,16 @@
-source 'http://rubygems.org'
-
-gemspec
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -1,3 +1,345 @@
-Run "rake" to run all tests.
+# Windows Azure SDK for Ruby
 
-Run "gem build azure.gemspec" to build gem.
+This project provides a Ruby package that makes it easy to access Windows Azure Services like Storage and Service Bus. 
+
+# Library Features
+
+* Storage
+    * Blobs
+        * create, list, and delete containers, work with container metadata and permissions, list blobs in container
+        * create block and page blobs (from a stream, a file, or a string), work with blob blocks and pages, delete blobs
+        * work with blob properties, metadata, leases, snapshot a blob
+    * Tables
+        * create and delete tables
+        * create, query, insert, update, merge, and delete entities
+    * Queues
+        * create, list, and delete queues, and work with queue metadata
+        * create, get, peek, update, delete messages
+* Service Bus
+    * Queues
+        * create, list and delete queues
+        * send, receive, unlock and delete messages
+    * Topics
+        * create, list, and delete topics
+        * send, receive, unlock and delete messages
+        * create, list, and delete subscriptions
+        * create, list, and delete rules
+
+# Supported Ruby Versions
+
+* Ruby 1.9.3
+* Ruby 2.0
+
+**Notice** that Ruby 2.0 x64 on Windows is not supported due to the [lack of nokogiri](https://github.com/sparklemotion/nokogiri/issues/864).
+
+# Getting Started
+
+## Install the rubygem package
+
+You can install the azure rubygem package directly.
+
+```bash
+gem install azure
+```
+
+## Download Source Code
+
+To get the source code of the SDK via **git** just type:
+
+```bash
+git clone https://github.com/WindowsAzure/azure-sdk-for-ruby.git
+cd ./azure-sdk-for-ruby
+```
+Then, run bundler to install all the gem dependencies:
+
+```bash
+bundle install
+```
+
+## Generate Documentation
+
+Running the this command ``rdoc`` will generate the API documentation in the `./doc` directory.
+
+## Setup Connection
+
+You can use this SDK against the Windows Azure Services in the cloud, or against the local Storage Emulator if you are on Windows. Service Bus emulator is not supported. Of course, to use the Windows Azure Services in the cloud, you need to first [create a Windows Azure account](http://www.windowsazure.com/en-us/pricing/free-trial/). After that, you can get the information you need to configure Storage and Service Bus from the [Windows Azure Portal](https://manage.windowsazure.com).
+
+There are two ways you can set up the connections:
+
+1. [via code](#via-code)
+2. [via environment variables](#via-environment-variables)
+
+### Via Code
+
+* Against Windows Azure Services in the cloud
+
+  ```ruby
+  require "azure"
+
+  Azure.configure do |config|
+      # Configure these 2 properties to use Storage
+      config.storage_account_name = "<your azure storage account name>"
+      config.storage_access_key   = "<your azure storage access key>"
+      # Configure these 3 properties to use Service Bus
+      config.sb_namespace         = "<your azure service bus namespace>"
+      config.sb_access_key        = "<your azure service bus access key>"
+      config.sb_issuer            = "<your azure service bus issuer>"
+  end
+  ```
+
+* Against local Emulator (Windows Only)
+
+  ```ruby
+  require "azure"
+
+  Azure.configure do |config|
+      # Configure these 2 properties to use local Storage Emulator
+      config.storage_account_name = "devstoreaccount1"
+      config.storage_access_key   = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="
+      config.storage_blob_host    = "http://127.0.0.1:10000/devstoreaccount1"
+      config.storage_queue_host   = "http://127.0.0.1:10001/devstoreaccount1"
+      config.storage_table_host   = "http://127.0.0.1:10002/devstoreaccount1"
+      # Local Service Bus Emulator is not supported
+  end
+  ```
+
+### Via Environment Variables
+
+* Against Windows Azure Services in the cloud
+
+  * Storage
+
+    ```bash
+    AZURE_STORAGE_ACCOUNT = <your azure storage account name>
+    AZURE_STORAGE_ACCESS_KEY = <your azure storage access key>
+    ```
+
+  * Service Bus
+
+    ```bash
+    AZURE_SERVICEBUS_NAMESPACE = <your azure service bus namespace>
+    AZURE_SERVICEBUS_ACCESS_KEY = <your azure service bus access key>
+    AZURE_SERVICEBUS_ISSUER = <your azure service bus issuer>
+    ```
+
+* Against local Emulator (Windows Only)
+
+  * Storage
+
+    ```bash
+    AZURE_STORAGE_ACCOUNT = devstoreaccount1
+    AZURE_STORAGE_ACCESS_KEY = Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
+    AZURE_STORAGE_BLOB_HOST = http://127.0.0.1:10000/devstoreaccount1
+    AZURE_STORAGE_QUEUE_HOST = http://127.0.0.1:10001/devstoreaccount1
+    AZURE_STORAGE_TABLE_HOST = http://127.0.0.1:10002/devstoreaccount1
+    ```
+
+  * Service Bus: not supported
+
+## Run Test
+
+You can use the following commands to run:
+* all the tests: ``rake test``
+* a specific suite of tests: ``rake test:integration:blob``
+* one particular test file: ``ruby -I"lib:test" "<path of the test file>"``
+
+# Usage
+
+**For more examples, please see the [Windows Azure Ruby Developer Center](http://www.windowsazure.com/en-us/develop/ruby)**
+
+## Storage
+
+### Blobs
+
+```ruby
+# Require the azure rubygem
+require "azure"
+
+# Create an azure storage blob service object
+azure_blob_service = Azure::BlobService.new
+
+# Create a container
+container = azure_blob_service.create_container("test-container")
+
+# Upload a Blob
+content = File.open('test.jpg', 'rb') { |file| file.read }
+azure_blob_service.create_block_blob(container.name, "image-blob", content)
+
+# List containers
+azure_blob_service.list_containers()
+
+# List Blobs
+azure_blob_service.list_blobs(container.name)
+
+# Download a Blob
+blob, content = azure_blob_service.get_blob(container.name, "image-blob")
+File.open("download.png", "wb") {|f| f.write(content)}
+
+# Delete a Blob
+azure_blob_service.delete_blob(container.name, "image-blob")
+```
+
+### Tables
+
+```ruby
+# Require the azure rubygem
+require "azure"
+
+# Create an azure storage table service object
+azure_table_service = Azure::TableService.new
+
+# Create a table
+azure_table_service.create_table("testtable")
+
+# Insert an entity
+entity = { "content" => "test entity", :partition_key => "test-partition-key", :row_key => "1" }
+azure_table_service.insert_entity("testtable", entity)
+
+# Get an entity
+result = azure_table_service.get_entity("testtable", "test-partition-key", "1")
+
+# Update an entity
+result.properties["content"] = "test entity with updated content"
+azure_table_service.update_entity(result.table, result.properties)
+
+# Query entities
+query = { :filter => "content eq 'test entity'" }
+result, token = azure_table_service.query_entities("testtable", query)
+
+# Delete an entity
+azure_table_service.delete_entity("testtable", "test-partition-key", "1")
+
+# delete a table
+azure_table_service.delete_table("testtable")
+```
+
+### Queues
+
+```ruby
+# Require the azure rubygem
+require "azure"
+
+# Create an azure storage queue service object
+azure_queue_service = Azure::QueueService.new
+
+# Create a queue
+azure_queue_service.create_queue("test-queue")
+
+# Create a message
+azure_queue_service.create_message("test-queue", "test message")
+
+# Get one or more messages with setting the visibility timeout
+result = azure_queue_service.list_messages("test-queue", 30, {:number_of_messages => 10})
+
+# Get one or more messages without setting the visibility timeout
+result = azure_queue_service.peek_messages("test-queue", {:number_of_messages => 10})
+
+# Update a message
+message = azure_queue_service.list_messages("test-queue", 30)
+pop_receipt, time_next_visible = azure_queue_service.update_message("test-queue", message.id, message.pop_receipt, "updated test message", 30)
+
+# Delete a message
+message = azure_queue_service.list_messages("test-queue", 30)
+azure_queue_service.delete_message("test-queue", message.id, message.pop_receipt)
+
+# Delete a queue
+azure_queue_service.delete_queue("test-queue")
+```
+
+## Service Bus
+
+### Queues
+
+```ruby
+# Require the azure rubygem
+require "azure"
+
+# Create an azure service bus object
+azure_service_bus = Azure::ServiceBus::ServiceBus.new
+
+# Create a queue with just the queue name
+queue1 = azure_service_bus.create_queue("test-queue-1")
+
+# Create a queue with a queue object
+queue2 = Azure::ServiceBus::Queue.new("test-queue-2")
+queue2.max_size_in_megabytes = 2048
+queue2 = azure_service_bus.create_queue(queue2)
+
+# Send a queue message with just the message body
+azure_service_bus.send_queue_message("test-queue-1", "test queue message")
+
+# Send a queue message with a brokered message object
+message = Azure::ServiceBus::BrokeredMessage.new("another test queue message")
+message.correlation_id = "test-correlation-id-1"
+azure_service_bus.send_queue_message("test-queue-1", message)
+
+# Receive a queue message
+message = azure_service_bus.receive_queue_message("test-queue-1")
+
+# Delete a queue message
+azure_service_bus.delete_queue_message(message)
+
+# Delete a queue
+azure_service_bus.delete_queue("test-queue-1")
+```
+
+### Topics
+
+```ruby
+# Require the azure rubygem
+require "azure"
+
+# Create an azure service bus object
+azure_service_bus = Azure::ServiceBus::ServiceBus.new
+
+# Create a topic with just the topic name
+topic1 = azure_service_bus.create_topic("test-topic-1")
+
+# Create a topic with a topic object
+topic2 = Azure::ServiceBus::Topic.new("test-topic-2")
+topic2.max_size_in_megabytes = 2048
+topic2 = azure_service_bus.create_topic(topic2)
+
+# Create a subscription
+subscription = Azure::ServiceBus::Subscription.new("test-subscription-1")
+subscription.topic = topic1.name
+subscription = azure_service_bus.create_subscription(subscription)
+
+# Send a topic message with just the message body
+azure_service_bus.send_topic_message(topic1, "test topic message")
+
+# Send a topic message with a brokered message object
+message = Azure::ServiceBus::BrokeredMessage.new("another test topic message")
+message.correlation_id = "test-correlation-id-1"
+azure_service_bus.send_topic_message(topic1, message)
+
+# Receive a subscription message
+message = azure_service_bus.receive_subscription_message(topic1.name, subscription.name)
+
+# Delete a subscription message
+azure_service_bus.delete_subscription_message(message)
+
+# Delete a subscription
+azure_service_bus.delete_subscription(subscription)
+
+# Delete a topic
+azure_service_bus.delete_topic(topic1)
+```
+
+# Need Help?
+
+Be sure to check out the Windows Azure [Developer Forums on Stack Overflow and MSDN](http://go.microsoft.com/fwlink/?LinkId=234489) if you have trouble with the provided code.
+
+# Contribute Code or Provide Feedback
+
+If you would like to become an active contributor to this project please follow the instructions provided in [Windows Azure Projects Contribution Guidelines](http://windowsazure.github.com/guidelines.html).
+
+If you encounter any bugs with the library please file an issue in the [Issues](https://github.com/WindowsAzure/azure-sdk-for-ruby/issues) section of the project.
+
+# Learn More
+
+For documentation on how to host Ruby applications on Windows Azure, please see the [Windows Azure Ruby Developer Center](http://www.windowsazure.com/en-us/develop/ruby/).
+
+For documentation on Azure PowerShell CLI tool for Windows, please see our readme [here](http://github.com/windowsazure/azure-sdk-tools).
+
+For documentation on the Azure cross platform CLI tool for Windows, Mac and Linux, please see our readme [here](http://github.com/windowsazure/azure-sdk-tools-xplat).

data/Rakefile

@@ -1,3 +1,17 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
 require "rake/testtask"
 require "rubygems/package_task"
 
@@ -8,11 +22,45 @@ Gem::PackageTask.new(gem_spec) do |pkg|
 end
 
 namespace :test do
+  task :require_environment do
+    unset_environment = [
+      ENV.fetch("AZURE_STORAGE_ACCOUNT",  nil),
+      ENV.fetch("AZURE_STORAGE_ACCESS_KEY",    nil),
+      # ENV.fetch("AZURE_TABLE_HOST",    nil),
+      # ENV.fetch("AZURE_BLOB_HOST",     nil),
+      # ENV.fetch("AZURE_QUEUE_HOST",    nil),
+      ENV.fetch("AZURE_SERVICEBUS_NAMESPACE", nil),
+      ENV.fetch("AZURE_SERVICEBUS_ACCESS_KEY", nil),
+      # ENV.fetch("AZURE_SERVICEBUS_ISSUER",     nil)
+    ].include?(nil)
+
+    abort "[ABORTING] Configure your environment to run the integration tests" if unset_environment
+  end
+
   Rake::TestTask.new :unit do |t|
     t.pattern = "test/unit/**/*_test.rb"
     t.verbose = true
     t.libs = ["lib", "test"]
   end
+  
+  namespace :unit do
+    def component_task(component)
+      Rake::TestTask.new component do |t|
+        t.pattern = "test/unit/#{component}/**/*_test.rb"
+        t.verbose = true
+        t.libs = ["lib", "test"]
+      end
+      
+      task component => "test:require_environment"
+    end
+
+    component_task :core
+    component_task :blob
+    component_task :queue
+    component_task :service
+    component_task :table
+    component_task :service_bus
+  end
 
   Rake::TestTask.new :integration do |t|
     t.pattern = "test/integration/**/*_test.rb"
@@ -20,6 +68,8 @@ namespace :test do
     t.libs = ["lib", "test"]
   end
 
+  task :integration => :require_environment
+
   namespace :integration do
     def component_task(component)
       Rake::TestTask.new component do |t|
@@ -27,55 +77,34 @@ namespace :test do
         t.verbose = true
         t.libs = ["lib", "test"]
       end
+
+      task component => "test:require_environment"
     end
 
-    component_task :tables
-    component_task :blobs
-    component_task :queues
     component_task :service_bus
-
-    task :conditionally do
-      name          = ENV.fetch("AZURE_ACCOUNT_NAME",  nil)
-      key           = ENV.fetch("AZURE_ACCESS_KEY",    nil)
-      t_host        = ENV.fetch("AZURE_TABLE_HOST",    nil)
-      b_host        = ENV.fetch("AZURE_BLOB_HOST",     nil)
-      q_host        = ENV.fetch("AZURE_QUEUE_HOST",    nil)
-      acs_namespace = ENV.fetch("AZURE_ACS_NAMESPACE", nil)
-      sb_access_key = ENV.fetch("AZURE_SB_ACCESS_KEY", nil)
-      sb_issuer     = ENV.fetch("AZURE_SB_ISSUER",     nil)
-
-      if name && key && t_host && b_host && q_host && acs_namespace && sb_access_key && sb_issuer
-        Rake::Task["test:integration"].invoke
-      else
-        warn "[WARNING] Configure your environment to run the integration tests"
-      end
-    end
+    component_task :blob
+    component_task :queue
+    component_task :table
   end
 
-  Rake::TestTask.new :cleanup do |t|
+  task :cleanup => :require_environment do
     $:.unshift "lib"
     require 'azure'
 
     Azure.configure do |config|
-      config.access_key     = ENV.fetch("AZURE_ACCESS_KEY")
-      config.account_name   = ENV.fetch("AZURE_ACCOUNT_NAME")
-      config.table_host     = ENV.fetch("AZURE_TABLE_HOST")
-      config.blob_host      = ENV.fetch("AZURE_BLOB_HOST")
-      config.queue_host     = ENV.fetch("AZURE_QUEUE_HOST")
+      config.access_key     = ENV.fetch("AZURE_STORAGE_ACCESS_KEY")
+      config.account_name   = ENV.fetch("AZURE_STORAGE_ACCOUNT")
+      # config.table_host     = ENV.fetch("AZURE_TABLE_HOST")
+      # config.blob_host      = ENV.fetch("AZURE_BLOB_HOST")
+      # config.queue_host     = ENV.fetch("AZURE_QUEUE_HOST")
 
-      config.acs_namespace  = ENV.fetch("AZURE_ACS_NAMESPACE")
-      config.sb_access_key  = ENV.fetch("AZURE_SB_ACCESS_KEY")
-      config.sb_issuer      = ENV.fetch("AZURE_SB_ISSUER")
+      config.acs_namespace  = ENV.fetch("AZURE_SERVICEBUS_NAMESPACE")
+      config.sb_access_key  = ENV.fetch("AZURE_SERVICEBUS_ACCESS_KEY")
+      # config.sb_issuer      = ENV.fetch("AZURE_SERVICEBUS_ISSUER")
     end
-
-    Azure::Tables.all.map(&:delete)
-    Azure::Blobs.containers.map(&:delete)
-    Azure::Queues.all.map(&:delete)
-    Azure::ServiceBus::Queues.list.map(&:delete)
-    Azure::ServiceBus::Topics.list.map(&:delete)
   end
 end
 
-task :test => ["test:unit", "test:integration:conditionally"]
+task :test => ["test:unit", "test:integration"]
 
-task default: :test
+task :default => :test