dot_net_services 0.0.1

data/lib/dot_net_services/session.rb

@@ -0,0 +1,282 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+
+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
+
+    # 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/ws/2007/08/connect/roles/relay'
+    end
+
+    def setup_endpoint(endpoint)
+      if endpoint !~ /^http(s?):\/\//
+        endpoint = '/' + endpoint unless endpoint[0] == ?/
+        endpoint = DotNetServices.root_url + endpoint
+      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/dot_net_services.rb

@@ -0,0 +1,143 @@
+require 'dot_net_services/session'
+require 'dot_net_services/authentication'
+require 'dot_net_services/error'
+require 'dot_net_services/message_buffer'
+require 'net/http/create_mb'
+require 'net/http/retrieve'
+require 'net/http/subscribe'
+
+# DotNetServices is the top-level namespace of <b>.NET Services for Ruby</b>, Ruby interoperability layer for
+# .NET Services plain HTTP (REST) API.
+#
+# == .NET Services
+#
+# Since you are reading this, you probably already know that .NET Services is a Microsoft product, described as the
+# "Internet Services Bus", a messaging bus in the cloud. Like any other messaging bus, it helps services and consumers
+# to communicate with each other. Further information on .NET Services can be found on MSDN:
+# http://go.microsoft.com/fwlink/?LinkID=129428.
+#
+# While .NET Services primarily target .NET platform, non-Microsoft software is also catered for,
+# by providing open protocols for most of the bus functionality, in both SOAP/WS-* and plain HTTP style. The latter
+# is structured in a way that makes it easy to implement REST interactions over the bus, including both
+# synchronous and asynchronous semantics. .NET Services bus doesn't force an application to use REST, any
+# other kind of plain HTTP protocol can be routed through it, too.
+#
+#
+# == Functionality
+#
+# This library is a simple Ruby wrapper for .NET Services plain HTPP (REST) APIs. Current version allows Ruby
+# developers to build consumers of synchronous RESTful services (implemented as .NET WCF services, using
+# webHttpRelayBinding, provided by the .NET Services SDK). You can also exchange messages between Ruby processes via
+# Volatile Message Buffers (VMBs), which are .NET Services mechanism for asynchronous communications.
+#
+# .NET Services for Ruby looks like Net::HTTP API from the standard library, but deals with authentication,
+# VMB management and message retrieval.
+#
+# Since this is a 0.1.0 version of an interoperability layer for a PDC version of a bus, a few things are missing.
+#
+# Most notably, with this version you still can not:
+# * communicate with WCF services bound by anything other than webHttpRelayBinding.
+# * communicate with the bus via WS-* protocols.
+# * communicate with a WCF-based service via a VMB. At least, not until .NET Services SDK adds a WCF binding for
+# REST via VMB. Once it's available, we should be able to work with it.
+# * use VMB pub-sub and multicast functionality
+# * use Workflow Services
+# * use Identity Service as a dfederated identity provider for end-users
+#
+# == Usage examples
+#
+# Say, you are a cellphone dealer. You have a Point of Sale web application, written in Rails. It sells cellphones.
+# The phones you sell are operated by a phone company, which offers a .NET Services solution (group of services in
+# the .NET Services world), called Dealership. It includes two services, Customer and Provisioning.
+#
+# Customer service is a RESTful service endpoint, implemented by WCF service with a webHttpRelayBinding. It's listening
+# on /Customer URL, and provides the usual CRUD functionality for managing customers.
+#
+# Provisioning service endpoint is a VMB. Coincidentally, it's also written in Ruby! :) When a customer buys a new phone,
+# provisioning application should activate the phohe on the network, so that the customer can actually make calls with it.
+# Activation can take several minutes, even hours, and we don't want the point of sale terminal to hang until it's over.
+# Hence the use of a VMB as an asynchronous communication device.
+#
+# To create a customer, point of sale app needs to post a URL-encoded form to a webHttpRelayBinding endpoint. That's
+# where you need to use a DotNetServices::Session class:
+#
+#   require 'dotnetservices'
+#   session = DotNetServices::Session.open("/Dealership/Customer", :username => 'Dealership', :password => '_password')
+#   session.post :first_name => 'John', :last_name => 'Doe'
+#
+# Posting a message to a Provisioning endpoint would actually look the same:
+#
+#   session = DotNetServices::Session.open("/Dealership/Provisioning", :username => 'Dealership', :password => '_password')
+#   session.post :phone_number => '555 888-8888'
+#
+# DotNetServices::MessageBuffer is needed by the Provisioning *service* (and not the client), to register the VMB and
+# retrieve messages from it. Usage typically looks like this:
+#
+#   buffer = DotNetServices::MessageBuffer.new("/Dealership/Provisioning",
+#                                              :username => 'Dealership', :password => '_password')
+#   buffer.open_and_poll do |message|
+#     ... process incoming messages ...
+#   end
+#
+# This code will check that the VMB exists, create one if necessary, and continuously poll it for new messages. Whenever
+# a new message is sent to VMB, MessageBuffer#open_and_poll retrieves it and invokesthe block, passing it a
+# Net::HTTP::Request instance that looks exactly like what the sender originally sent to the VMB. Nice and easy.
+#
+# To understand and use .NET Services for Ruby, you should probably also read the documentation for the two classes
+# mentioned above: DotNetServices::Session and DotNetServices::MessageBuffer.
+#
+# Happy bussing!
+module DotNetServices
+
+  class << self
+
+    # The name of the host providing DotNetServices relay services.
+    def relay_host
+      "servicebus.windows.net"
+    end
+
+    # The name of the host providing DotNetServices identity services.
+    def identity_host
+      'accesscontrol.windows.net'
+    end
+
+    # The root URL used for exposing services.
+    def root_url
+      "http://#{relay_host}/services"
+    end
+
+    # Host and port of the bus endpoint.
+    def host_port
+      return @host_port if @host_port
+      uri = URI.parse(root_url) 
+      @host_port = [uri.host, uri.port]
+      @host_port
+    end
+
+    # Use an HTTP proxy to connect to .NET Services
+    #
+    # If you call this method, all subsequent communications with .NET Services will use an HTTP proxy.
+    # You must given hostname and password #use proxy 
+    #   DotNetServices.use_proxy()
+    def use_proxy(proxy_host, proxy_port, proxy_user = nil, proxy_password = nil)
+      @proxy = Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_password)
+    end
+
+    # An HTTP proxy to connect through.
+    #
+    # Defaults to Net::HTTP (direct connection without proxy). To set a proxy, see #use_proxy.
+    def proxy
+      @proxy || Net::HTTP
+    end
+
+    # TODO implement!
+    def logger
+      if RAILS_ENV
+        nil
+      else
+        @logger ||= nil
+      end
+    end
+
+  end
+end

data/lib/net/http/create_mb.rb

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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

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

data/spec/integration/TestService/Service/App.config

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <system.serviceModel>
+
+    <bindings>
+      <!-- Application Binding -->
+      <webHttpRelayBinding>
+        <binding name="default" />
+      </webHttpRelayBinding>
+    </bindings>
+
+    <services>
+      <!-- Application Service -->
+      <service name="DotNetServicesRuby.ResourceService"                   
+               behaviorConfiguration="default">
+        <endpoint contract="DotNetServicesRuby.ResourceContract"
+                  binding="webHttpRelayBinding"
+                  bindingConfiguration="default" 
+                  address="" />
+      </service>
+    </services>
+
+    <behaviors>
+      <serviceBehaviors>
+        <behavior name="default">
+          <serviceDebug httpHelpPageEnabled="false" httpsHelpPageEnabled="false" />
+        </behavior>
+      </serviceBehaviors>
+    </behaviors>
+
+  </system.serviceModel>
+</configuration>

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

@@ -0,0 +1,37 @@
+namespace DotNetServicesRuby
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.ServiceModel;
+    using System.ServiceModel.Web;
+    using System.ServiceModel.Channels;
+
+    [ServiceContract]
+    [ServiceBehavior]
+    class PlainTextService
+    {
+        [OperationContract(Action="*", ReplyAction="*")]
+        [WebInvoke(BodyStyle=WebMessageBodyStyle.Bare)]
+        //public string Process(string foo)
+        //{
+        //    return "hi mom";
+        //}
+
+        public Message Process(Message message)
+        {
+            var httpRequest = (HttpRequestMessageProperty)(message.Properties["httpRequest"]);
+
+            var query = httpRequest.QueryString;
+            var verb = httpRequest.Method;
+            var body = "";
+
+            Message response = Message.CreateMessage(MessageVersion.None, "GETRESPONSE", "hi, mom");
+
+            HttpResponseMessageProperty responseProperty = new HttpResponseMessageProperty();
+            responseProperty.Headers.Add("Content-Type", "text/plain");
+            response.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);
+            return response;
+        }
+
+    }
+}

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

@@ -0,0 +1,49 @@
+namespace DotNetServicesRuby
+{
+    using System;
+    using System.ServiceModel;
+    using System.ServiceModel.Web;
+    using System.ServiceModel.Description;
+    using Microsoft.ServiceBus;
+
+    class Program
+   {
+        static void Main(string[] args)
+        {
+
+            System.Console.WriteLine("Enter solution name: ");
+            var solutionName = System.Console.ReadLine();
+            System.Console.WriteLine("Enter password for " + solutionName + " solution:");
+            var password = System.Console.ReadLine();
+
+            var behavior = new TransportClientEndpointBehavior();
+            behavior.CredentialType = TransportClientCredentialType.UserNamePassword;
+            behavior.Credentials.UserName.UserName = solutionName;
+            behavior.Credentials.UserName.Password = password;
+
+            var address = new Uri(String.Format("http://{0}/services/{1}/TestService/", ServiceBusEnvironment.DefaultRelayHostName, solutionName));
+            var host = new ServiceHost(typeof(ResourceService), address);
+            host.Description.Endpoints[0].Behaviors.Add(behavior);
+            host.Open();
+
+            //var anonymousAddress = new Uri(String.Format("http://{0}/services/{1}/AnonymousTestService/", ServiceBusEnvironment.DefaultRelayHostName, solutionName));
+            //var anonymousHost = new ServiceHost(typeof(AnonymousResourceService), anonymousAddress);
+            //anonymousHost.Description.Endpoints[0].Behaviors.Add(behavior);
+            //anonymousHost.Open();
+
+            //var plainTextAddress = new Uri(String.Format("http://{0}/services/{1}/PlainTextTestService/", ServiceBusEnvironment.DefaultRelayHostName, solutionName));
+            //var plainTextHost = new WebServiceHost(typeof(PlainTextService), plainTextAddress);
+            //plainTextHost.Description.Endpoints[0].Behaviors.Add(behavior);
+            //plainTextHost.Open();
+
+            Console.WriteLine("Service address: " + address);
+            Console.WriteLine("Press [Enter] to exit");
+            Console.ReadLine();
+
+            host.Close();
+            //anonymousHost.Close();
+            //plainTextHost.Close();
+        }
+
+    }
+}

data/spec/integration/TestService/Service/Properties/AssemblyInfo.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Service")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Service")]
+[assembly: AssemblyCopyright("Copyright ©  2006")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("23fce5dd-8bf8-403c-b748-d24504e7c5c1")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

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

@@ -0,0 +1,17 @@
+namespace DotNetServicesRuby
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.ServiceModel;
+    using System.ServiceModel.Web;
+    using System.ServiceModel.Channels;
+
+    [ServiceContract(Name = "ResourceContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
+    public interface ResourceContract
+    {
+        [OperationContract(Action = "*", ReplyAction = "*")]
+        Message Process(Message message);
+    }
+
+    public interface ResourceChannel : ResourceContract, IClientChannel { }
+}