dot_net_services 0.3.0 → 0.4.0

data/lib/dot_net_services/message_buffer.rb

@@ -1,283 +0,0 @@
-require 'date'
-
-module DotNetServices
-
-  # The MessageBuffer class is used for creating Volatile Message Buffer (VMB) endpoints on the .NET Services bus, and
-  # retrieving messages from them.
-  #
-  # A VMB is a temporary message buffer that can be used for asynchronous communications between senders and receivers
-  # of messages. A process may request creation of a VMB on any URL within a solution namespace. Any HTTP requests
-  # (other than GETs) to that URL are stored in the buffer, until some process retrieves them by sending an HTTP
-  # X-RETRIEVE request to the management endpoint.
-  #
-  # VMB can exist by itself, not tied to the lifecycle of a process that originally created it. Further information
-  # about VMBs can be found in .NET Services portal [http://go.microsoft.com/fwlink/?LinkID=129428].
-  #
-  # == Usage examples
-  #
-  # MessageBuffer instance represents a VMB endpoint. Typical usage looks as follows:
-  #
-  #  error_handler = lambda { |error| logger.error(error) }
-  #
-  #  buffer = DotNetServices::MessageBuffer.open_and_poll(
-  #          "MySolution/MyVMB",
-  #          {:username => 'MySolution', :password => 'my_password'},
-  #          error_handler) do
-  #    |message|
-  #    ... process the message
-  #  end
-  #
-  # This invocation does all of the following:
-  #
-  # * Creates a MessageBuffer instance associated with a specified endpoint (/MySolution/MyVMB)
-  # * obains a security token from trhe Identity service (see Session for details on that).
-  # * Creates a VMB on the .NET Services bus if it doesn't exist yet
-  # * immediately starts polling it
-  # * if it retrieves a message, it passes it to the block. The message is an instance of Net::HTTP::Request that
-  #   looks exactly the same as what the sender originally sent to the bus.
-  # * if an error occurs while polling, the error is passed to the error_handler block. Polling then continues.
-  #
-  # == Guidelines
-  #
-  # In cases where an application (which in this case means a process) needs to process multiple types of messages,
-  # Microsoft recommends to create a single VMB per application, route all message types through the same VMB, and
-  # route messages to appropriate processors within the application itself.
-  #
-  # In the current version of the API, we provide no explicit support for clustering message processors. If you use
-  # MessageBuffer#open_and_poll(), it's recommended that you only run one cipy of a message processor. If clustering
-  # is required (for high availability reasons), you can use lower-level MessageBuffer methods to do it.
-  #
-  # .NET Services VMBs provide pub-sub and multicast functionality which can be used even over plain HTTP. Which is
-  # amazing. However, we don't support this functionality in the current version of our library.
-  class MessageBuffer
-
-    attr_reader :session
-
-    class << self
-
-      # Creates a MessageBuffer instance, acquires a security token, registers a VMB if necessary.
-      # Unlike Session#open, +auth_data+ is mandatory here.
-      # If given a block, passes the MessageBuffer instance to the block, and closes it at the end of the block
-      # returns the result of the block (if called with a block), or the buffer instance opened
-      def open(name, auth_data, &block)
-        buffer = MessageBuffer.new(name, auth_data).open
-        if block_given?
-          begin
-            return yield(buffer)
-          ensure
-            # TODO gracefully close the buffer
-          end
-        else
-          return buffer
-        end
-      end
-
-      # Invoke MessageBuffer#open to create a MessageBuffer instance, subscribe the buffer to receive messages
-      # posted to the +subscription_endpoint+, then poll it until the containing thread or process is terminated.
-      #
-      # Whenever a message is retrieved from the buffer, this method passes it to the block. When an error occurs
-      # (while polling, or raised by the block), it is passed to +error_handler+, which should be a lambda, or an
-      # object with handle(error) public method. If no +error_handler+ is provided, the error is printed out
-      # to STDERR and then ignored.
-      def open_and_poll(name, subscription_endpoint, auth_data, error_handler=nil, &block)
-        MessageBuffer.new(name, auth_data).open_and_poll(subscription_endpoint, error_handler, &block)
-      end
-    end
-
-    # Initializes a new MessageBuffer instance.
-    # Does not create a VMB on the .NET Services bus (use #open for that)
-    def initialize(name, auth_data)
-      @name = name
-      @session = Session.new(name, auth_data)
-    end
-
-    # Register the message buffer (by sending X-CREATEMB to the management endpoint).
-    #
-    # Returns the buffer. Raises an exception if the creation is not successful.
-    def register
-      createmb_response = @session.createmb
-
-      unless createmb_response.is_a?(Net::HTTPCreated)
-        # the buffer may already be there
-        unless @session.get_from_relay.is_a?(Net::HTTPSuccess)
-          raise "Creating VMB failed. Service responded with #{createmb_response.class.name}"
-        end
-      end
-      self
-    end
-
-    # Initiates a VMB session by:
-    # * acquiring a security token
-    # * checks if there is already a VMB at the endpoint
-    # * creating a VMB if necessary
-    def open
-      register unless @session.get_from_relay.is_a?(Net::HTTPSuccess)
-      self
-    end
-
-    # Open the buffer (see #open), subscribe the buffer to receive messages
-    # posted to the +subscription_endpoint+, then poll it until the containing thread or
-    # process is terminated.
-    #
-    # Whenever a message is retrieved from the buffer, this method passes it to the block. When an error occurs
-    # (while polling, or raised by the block), it is passed to +error_handler+, which should be a lambda, or an
-    # object with handle(error) public method. If no +error_handler+ is provided, the error is printed out
-    # to STDERR and then ignored.
-    def open_and_poll(subscription_endpoint, error_handler=nil, &block)
-      raise "MessageBuffer#open_and_poll requires a block" unless block_given?
-
-      @subscription_endpoint = subscription_endpoint 
-
-      open
-      subscribe(@subscription_endpoint)
-
-      begin
-        loop do
-          begin
-            message = poll
-            block.call(message) if message
-          rescue Object => error
-            if error_handler
-              if error_handler.is_a?(Proc)
-                error_handler.call(error)
-              else
-                error_handler.handle(error)
-              end
-            else
-              STDERR.puts
-              STDERR.puts "Message Buffer Error"
-              STDERR.puts error.message
-              STDERR.puts error.backtrace.map { |line| "  #{line}"}
-              STDERR.puts
-            end
-          end
-        end
-      ensure
-        @subscription_endpoint = nil
-      end
-    end
-
-    # Poll VMB endpoint for new messages; return the message if one was retrieved, or nil if it wasn't.
-    #
-    # Raises an exception if the response from the bus contains an error code (which usually means that the VMB is
-    # not registered, but may mean other things, for example if the bus itself is not accessible for some reason).
-    #
-    # +timeout+ parameter regulates how long a polling request will be held by the bus if there are no messages.
-    #
-    # An HTTP server that holds HTTP connections because it has nothing to respond with is somewhat uncommon, so a
-    # more detailed explanation is due.
-    #
-    # Normally, any HTTP interaction begins by opening of a TCP socket from the client to the server. The client
-    # then writes the HTTP request into that socket and waits until the server responds back and closes the socket.
-    # If the server doesn't respond for a long time (a minute, usually), the client drops the socket
-    # and declares timeout.
-    #
-    # Many times, when you poll a VMB endpoint, it will have no messages. If the bus simply came back immediately with
-    # "No Content" response, this would cause a VMB subscriber needs to constantly poll the buffer, abusing the bus
-    # infrastructure.
-    #
-    # .NET Services gets around this problem by making the client connection hang for some time, either until there
-    # is a message, or a certain number of seconds has passed, and there is still no message. That number of seconds is
-    # what the +timeout+ parameter specifies. Microsoft suggested that 10-20 seconds is reasonable for
-    # production purposes. Default value is 15 seconds.
-    def poll(timeout=15)
-      response = @session.retrieve(:encoding => 'asreply', :timeout => timeout)
-      case response
-      when Net::HTTPNoContent
-        return nil
-      when Net::HTTPNotFound
-        register
-        subscribe(@subscription_endpoint) if @subscription_endpoint
-        return nil
-      when Net::HTTPSuccess
-        return response
-      else
-        raise "Retrieving messages failed. Response was #{response.class.name}" unless response.is_a?(Net::HTTPSuccess)
-      end
-    end
-
-    # Delete the message buffer.  This removes the buffer entirely
-    # from the bus, not just the local reference to it.
-    def delete
-      response = @session.delete
-
-      unless response.is_a?(Net::HTTPNoContent)
-        raise "Deleting VMB failed. Response was #{response.class.name}"
-      end
-      self
-    end
-
-    # Queries the VMB management endpoint for the VMB expiry time. With every #poll (HTTP X-RETRIEVE to the VMB management
-    # endpoint) the bus sets the expiry time of this VMB to 30 minutes later. If 30 minutes pass and there are no
-    # further polls, the bus automatically delets the buffer.
-    def expires
-      response = @session.get_from_relay
-
-      unless response.is_a?(Net::HTTPOK)
-        raise "Querying expiry status of VMB failed. Response was #{response.class}"
-      end
-      
-      expires_header = response["expires"]
-      raise "Querying expiry status of VMB failed. Response doesn't have expires: header" unless expires_header
-      DateTime.parse(expires_header)
-    end
-
-    # Performs an empty POST to the VMB management endpoint, which extends the VMB expiry time without retrieving any
-    # messages.
-    def keep_alive
-      # if we don't pass a linefeed as a body to the VMB management endpoint, it responds with HTTP 411 Length Required
-      response = @session.post_to_relay "\n"
-      case response
-      when Net::HTTPSuccess
-        self
-      else
-        raise "POST to the VMB management endpoint failed. Response was #{response.class}"
-      end
-    end
-
-    # Subscribe to an endpoint.
-    #
-    # HTTP messages sent to the +endpoint+ will be routed to this message buffer
-    def subscribe(target_path)
-      # Changes for .Net Services March 2009 CTP release (M5)
-      tmpurl = @session.authenticator.username + "." + DotNetServices.root_url + "/" + target_path
-
-      # Replace unwanted slashes
-      tmpurl = tmpurl.gsub("\/\/\/", "\/")
-      tmpurl = tmpurl.gsub("\/\/", "\/")
-      subscription_endpoint_url = "http://" + tmpurl
-
-      subscribe_response = @session.subscribe(:target => subscription_endpoint_url)
-      case subscribe_response
-      when Net::HTTPSuccess
-        return self
-      when Net::HTTPConflict
-        unsubscribe(target_path)
-        resubscribe_response = @session.subscribe(:target => subscription_endpoint_url)
-        unless resubscribe_response.is_a?(Net::HTTPSuccess)
-          raise "Second X-SUBSCRIBE to VMB management endpoint failed. Response was #{resubscribe_response.class}"
-        end
-      else
-        raise "X-SUBSCRIBE to VMB management endpoint failed. Response was #{subscribe_response.class}"
-      end
-    end
-
-    # Unsubscribe from an endpoint.
-    def unsubscribe(target_path)
-      # Changes for .Net Services March 2009 CTP release (M5)
-      tmpurl = @session.authenticator.username + "." + DotNetServices.root_url + "/" + target_path
-
-      # Replace unwanted slashes
-      tmpurl = tmpurl.gsub("\/\/\/", "\/")
-      tmpurl = tmpurl.gsub("\/\/", "\/")
-      subscription_endpoint_url = "http://" + tmpurl
-
-      unsubscribe_response = @session.unsubscribe(:target => subscription_endpoint_url)
-      unless unsubscribe_response.is_a?(Net::HTTPSuccess)
-        raise "X-UNSUBSCRIBE to VMB management endpoint failed. Response was #{subscribe_response.class}"
-      end
-      self
-    end
-
-  end
-end

data/lib/dot_net_services/session.rb

@@ -1,308 +0,0 @@
-require 'uri'
-require 'cgi'
-require 'net/http'
-require 'net/http/unsubscribe'
-
-module DotNetServices
-  
-  # The Session class is used for communicating with endpoints of .NET Services bus.
-  #
-  # == Usage examples
-  #
-  # A Session instance represents a .NET Services bus endpoint. Typically, you create it by calling Session#open
-  # and then exchange HTTP messages using methods like #get, #post, etc. It looks like this:
-  #
-  # Send a GET with no parameters:
-  # 
-  #   session = Session.open('/MySolution/MyService', :username => 'MySolution', :password => 'my_password')
-  #   get_response = session.get
-  #   # ... process response, which is a Net::HTTP::Response instance
-  #
-  # Send a GET with ?age=21&sex=Male query string:
-  # 
-  #   get_with_query_response = session.get :age => 21, :sex => "Male"
-  #
-  # Send a POST with name=Joe&email=joe@the_plumber.com (URL-encoded form) as a body:
-  #
-  #   post_response = session.post :name => 'Joe', :email => 'joe@the_plumber.com'
-  #
-  # So far, Session API is similar to Net::HTTP::Session. Which is the whole point of the REST style
-  # communication - it is all just HTTP! However, there is one small twist. HTTP::Session represents a server
-  # (host and port). DotNetServices::Session represents a service endpoint. Which is a <b>URL</b>, not a server. In
-  # fact, all .NET Services endpoints have the same server, servicebus.windows.net. So an endpoint address is really
-  # just a path on that server. 
-  #
-  # And sometimes you need to send requests to a path under the endpoint. For example, to update the name of customer
-  # #12345, you would do a POST to /MySolution/Customer/12345 with &name=Dave body. Creating a new Session for that is
-  # both counterintuitive and expensive (see the Details section below). For this reason, DotNetServices::Session has
-  # methods like post_to_url:
-  #
-  #   result = session.post_to_url(12345, :name => 'Dave')
-  #
-  # == Details
-  #
-  # When a session is created, it's given the URL of an endpoint (that looks like /SolutionName/path/to/service), and
-  # username / password. These are <b>solution's</b> username and password, needed to prove to the bus that
-  # your consumer is a part of this solution. If the solution allows anonymous access, username / password are not
-  # necessary.
-  #
-  # When a session is opened (or is asked to send a first request to the endpoint), the session authenticates itself
-  # to the .NET Services using Identity Service [http://accesscontrol.windows.net], and obtains a security token from it.
-  #
-  # Security token is a Base64-encoded string. Unless an endpoint allows unauthenticated access, any request that comes
-  # to the endpoint must have this security token attached to it (as X-MS-Identity-Token HTTP header).
-  # DotNetServices::Session takes care of this responsibility, as well as renewing stale tokens.
-  #
-  # Session also has methods get_from_relay and post_to_relay, that are used for communicating to the .NET Services
-  # bus management endpoint. These methods (createmb, retrieve, query) are used by MessageBuffer, an application normally
-  # shouldn't need to use them directly.
-  #
-  # == Guidelines
-  #
-  # Obtaining a security token is an expensive operation, so it is <b>not</b> recommended to create a new instance of
-  # a Session for every outgoing request to the endpoint. It's better to use one Session instance per endpoint.
-  # Session takes care of expiring security tokens autoimatically, so Session instances don't go stale even after long
-  # periods of inactivity.
-  class Session
-
-    attr_reader :authenticator
-
-    class << self
-      # Open a .Net Services session at the +endpoint+.
-      #
-      # If +auth_data+ is provided, authenticates the session with
-      # the identity service using it. In this version, +auth_data+ should be a hash containing +:username+ and
-      # +:password+ keys. Other authentication mechanisms (InformationCard, X.509 certificates etc) that the Identity
-      # service provides are not exposed via a REST interface, therefore are not available to this library.
-      #
-      # If #open is called with a block, it passes the session instance as an argument to the block and returns the
-      # result of the block. If there is no block, session instance is returned instead.
-      def open(endpoint, auth_data = nil, &block)
-        Session.new(endpoint, auth_data).open(&block)
-      end
-    end
-
-    # Initialize a new .NET Session at the +endpoint+.
-    #
-    # If +auth_data+ is provided, remember it. Acquiring
-    # authentication token is postponed until it's needed.
-    def initialize(endpoint, auth_data=nil)
-      @endpoint_uri = setup_endpoint(endpoint)
-      @authenticator = Authentication.setup(auth_data)
-    end
-
-    def initialize(endpoint, auth_data=nil)
-      # Changes for .Net Services March 2009 CTP release (M5)
-      username = String.new
-      if auth_data.nil?
-      	elsif !auth_data.is_a? Hash
-      else
-      	auth_data_copy = auth_data.dup
-      	username = auth_data_copy.delete(:username)
-      end
-      
-      @endpoint_uri = setup_endpoint(endpoint, username)
-      @authenticator = Authentication.setup(auth_data)
-    end
-
-    # See DotNetServices::Session.open.
-    def open
-      authenticate
-      block_given? ? yield(self) : self
-    end
-
-    # Acquire a security token from the Identity Service.
-    #
-    # This method will do nothing if:
-    # * this session already holds a security token and the token has not expired yet, or
-    # * the session was created without auth_data (anonymous session) 
-    def authenticate
-      @authenticator.authenticate
-    end
-
-    # Send a GET request to the .NET Services endpoint.
-    # 
-    # If query options are provided, they should be a hash, and they are converted to a query string and attached to
-    # the GET request target URL.
-    # Thus, session.get(:foo => 'bar') sends a GET to #{endpoint}?foo=bar
-    def get(query_options=nil)
-      get_from_url(nil, query_options)
-    end
-
-    
-    def get_from_url(url, query_options=nil)
-      uri = setup_query_string(url, query_options)
-      get_request = Net::HTTP::Get.new(uri.request_uri)
-      enhance_and_execute(get_request)
-    end
-
-    # Sends a GET to the service management endpoint.
-    #
-    # This is used by MessageBuffer for VMB management. Applications shouldn't need to use this method.
-    def get_from_relay(query_options=nil)
-      uri = setup_query_string(nil, query_options)
-      get_request = Net::HTTP::Get.new(uri.request_uri)
-      route_to_relay(get_request)
-      enhance_and_execute(get_request)
-    end
-
-    # Send a POST request to the .NET Services endpoint.
-    #
-    # If +data+ is a Hash it is converted to a URL-encoded form, otherwise it is placed in the post body without any
-    # conversion.
-    #
-    # +content_type+ by default is set to +application/x-www-form-urlencoded+, which is appropriate when +data+ is a
-    # Hash. In any other case, you should specify +content_type+ explicitly.
-    def post(data=nil, content_type='application/x-www-form-urlencoded')
-      post_to_url("", data, content_type)
-    end
-
-    # Sends a POST request to a path below .NET Services endpoint.
-    #
-    # If an application neeeds to send a POST to a service that uses URL to receive data, it should use this method
-    # instead of creating a new session for every new request. For example, if a service endpoint is called
-    # /Solution/Maps, and it's URL template is /Solution/Maps/*country*/*province*/*city*, a way to create a map of
-    # Calgary would be:
-    #
-    #  session.post_to_url('/Canada/Calgary', map_data, content_type=...)
-    def post_to_url(url, data=nil, content_type='application/x-www-form-urlencoded')
-      post_request = Net::HTTP::Post.new(@endpoint_uri.path + url.to_s)
-      if data
-        post_request.content_type = content_type
-        if content_type == 'application/x-www-form-urlencoded'
-          post_request.form_data = data
-        else
-          post_request.body = data
-        end
-      end
-      enhance_and_execute(post_request)
-    end
-
-
-    # Sends a POST to the service management endpoint.
-    #
-    # This is used by MessageBuffer for VMB management. Applications should use MessageBuffer#keep_alive.
-    def post_to_relay(data=nil, content_type='application/x-www-form-urlencoded')
-      post_request = Net::HTTP::Post.new(@endpoint_uri.path)
-
-      if data
-        post_request.content_type = content_type
-        if content_type == 'application/x-www-form-urlencoded'
-          post_request.form_data = data
-        else
-          post_request.body = data
-        end
-      end
-      route_to_relay(post_request)
-      enhance_and_execute(post_request)
-    end
-
-    # Create a new message buffer (sends an X-CREATEMB to the service management endpoint).
-    #
-    # This is used by MessageBuffer for VMB management. Applications should use MessageBuffer#open.
-    def createmb
-      request = Net::HTTP::CreateMB.new(@endpoint_uri.path)
-      route_to_relay(request)
-      enhance_and_execute(request)
-    end
-
-    # Subscribe a message buffer to a virtual endpoint (sends an X-SUBSCRIBE to the VMB management endpoint).
-    #
-    # This is used by MessageBuffer for VMB management. Applications should use MessageBuffer#open.
-    def subscribe(request_options)
-      uri = setup_query_string(nil, request_options)
-      request = Net::HTTP::Subscribe.new(uri.request_uri)
-      route_to_relay(request)
-      enhance_and_execute(request)
-    end
-
-    # Unsubscribe a message buffer from a virtual endpoint (sends an X-UNSUBSCRIBE to the VMB management endpoint).
-    #
-    # This is used by MessageBuffer for VMB management. Applications should use MessageBuffer#open.
-    def unsubscribe(request_options)
-      uri = setup_query_string(nil, request_options)
-      request = Net::HTTP::Unsubscribe.new(uri.request_uri)
-      route_to_relay(request)
-      enhance_and_execute(request)
-    end
-
-    # Retrieve the next message from the message buffer (sends an X-RETRIEVE to the service management endpoint).
-    #
-    # This is used by MessageBuffer for VMB management. Applications should use MessageBuffer#poll.
-    def retrieve(query_options={})
-      query_options = stringify_and_downcase_keys(query_options)
-      query_options['timeout'] ||= 15
-      uri = setup_query_string(nil, query_options)
-      request = Net::HTTP::Retrieve.new(uri.request_uri)
-      route_to_relay(request)
-      enhance_and_execute(request)
-    end
-
-
-    # Delete an endpoint (sends a DELETE to the service management endpoint).
-    #
-    # This is used by MessageBuffer for VMB management. Applications should use MessageBuffer#delete.
-    def delete
-      request = Net::HTTP::Delete.new(@endpoint_uri.path) 
-      route_to_relay(request)
-      enhance_and_execute(request)
-    end
-
-    # The URL of a .NET services endpoint this Session is connected to.
-    def endpoint
-      @endpoint_uri.to_s
-    end
-
-  private
-
-    def enhance_and_execute(request)
-      @authenticator.enhance(request)
-      DotNetServices.proxy.start(@endpoint_uri.host, @endpoint_uri.port) { |http| http.request(request) }
-    end
-
-    def route_to_relay(request)
-      request['X-Process-At'] = 'http://schemas.microsoft.com/netservices/2009/05/servicebus/connect/roles/relay'
-    end
-
-    def setup_endpoint(endpoint, username)
-      if endpoint !~ /^http(s?):\/\//
-        endpoint = '/' + endpoint unless endpoint[0] == ?/
-
-        # Changes for .Net Services March 2009 CTP release (M5)
-        if !username.empty?
-            tmpurl = username + "." + DotNetServices.root_url + "/" + endpoint
-
-            # Replace unnecessary slashes
-            tmpurl = tmpurl.gsub("\/\/\/", "\/")
-            tmpurl = tmpurl.gsub("\/\/", "\/")
-            endpoint = "http://" + tmpurl
-        else
-            raise "username must be provided to form the service bus endpoint."
-        end
-      end
-      endpoint += '/' unless endpoint[-1] == ?/
-      
-      URI.parse(endpoint)
-    end
-    def setup_query_string(url, query_options)
-      if url && !url.empty?
-        uri = @endpoint_uri + url.to_s
-      else
-        uri = @endpoint_uri.dup
-      end
-
-      if query_options
-        query = query_options.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
-        uri.query = query
-      end
-      uri
-    end
-
-    def stringify_and_downcase_keys(options)
-      new_options = {}
-      options.each { |key, value| new_options[key.to_s.downcase] = value unless value.nil? }
-      new_options
-    end
-    
-  end
-end

data/lib/net/http/create_mb.rb

@@ -1,14 +0,0 @@
-module Net  # :nodoc:
-  class HTTP # :nodoc:
-    # Custom request type X-CREATEMB for creating message buffers on
-    # the .NET Service Bus.
-    #
-    # This request should not be used directly.  Use
-    # DotNetServices::Session#createmb instead.
-    class CreateMB < HTTPRequest
-      METHOD = "X-CREATEMB"
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-  end
-end

data/lib/net/http/retrieve.rb

@@ -1,14 +0,0 @@
-module Net # :nodoc:
-  class HTTP # :nodoc:
-    # Custom X-RETRIEVE for retrieving messages from the .NET Services
-    # message buffer.
-    #
-    # This request should not be used directly.  Use
-    # DotNetServices::Session#retrieve instead.
-    class Retrieve < HTTPRequest
-      METHOD = "X-RETRIEVE"
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-  end
-end

data/lib/net/http/subscribe.rb

@@ -1,14 +0,0 @@
-module Net  # :nodoc:
-  class HTTP # :nodoc:
-    # Custom request type X-CREATEMB for creating message buffers on
-    # the .NET Service Bus.
-    #
-    # This request should not be used directly.  Use
-    # DotNetServices::Session#createmb instead.
-    class Subscribe < HTTPRequest
-      METHOD = "X-SUBSCRIBE"
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-  end
-end

data/lib/net/http/unsubscribe.rb

@@ -1,14 +0,0 @@
-module Net  # :nodoc:
-  class HTTP # :nodoc:
-    # Custom request type X-CREATEMB for creating message buffers on
-    # the .NET Service Bus.
-    #
-    # This request should not be used directly.  Use
-    # DotNetServices::Session#createmb instead.
-    class Unsubscribe < HTTPRequest
-      METHOD = "X-UNSUBSCRIBE"
-      REQUEST_HAS_BODY = false
-      RESPONSE_HAS_BODY = true
-    end
-  end
-end

data/spec/integration/TestService/Service/AnonymousResourceService.cs

@@ -1,9 +0,0 @@
-namespace DotNetServicesRuby
-{
-    using System.ServiceModel;
-
-    [ServiceBehavior(Name = "SyndicationService", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
-    class AnonymousResourceService : ResourceService
-    {
-    }
-}