servicy 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9048f3bb1f1521a29ceeb800dd7b3eb5149c9b7
-  data.tar.gz: 1c474e01e90d51469893fe19be368004cc4654d8
+  metadata.gz: 037bc07d1d2d5f3347fbe3502ef0b03d09286cc3
+  data.tar.gz: 804eb780db64765afe2902d4359e71b6c00637ed
 SHA512:
-  metadata.gz: 7eb75dfafdc14c501aeb551579d839991aa312b3d554cadcc1efb410f1c9636651f9d6a8516b88415fe0739b867f242c95fd5e0adec9c067941d95c094e54d9b
-  data.tar.gz: 4986b4d40c49b4bb5b78f427fb5ccb25da068cb22bb225c09ca4adc245a8805af3f6ce62acb1f5b44153599a5cb740064a01700a172e9c6796ac23a5a964b126
+  metadata.gz: 5255eb13f70e5a1ec8df4341040d0c04a8ff673f4d86c1ac67dd3b542ff44eb2c9053f41876bd04a0b154832995d136bf55e276e192bd6e567c505d3e67dca02
+  data.tar.gz: 457ec866aafbcc3ea6be1cb41de07553ea2d8e7c4a691b42be1cb54c6b6d2005ebdfd2e487369c7fc85debc9ccc381c12342b186c69f03d5edb039a466395d70

data/README.md

@@ -8,242 +8,101 @@ SOA application configuration to register themselves by name and/or API, and
 allow service consumers to find instances of services to use, and be relatively
 sure of up-time, routing, etc.
 
-Servicy could possibly used as a router as well, although that may be out of
-scope we will see.
+The second goal of Servicy is to build a framework that makes it easy to write
+services that are easy to write, use and test. In most cases, simply including
+Servicy in a class containing your business logic. It is my opinion that a
+programmer should focus on solving business problems, not architectural ones
+(where possible), and that code should be, above all else, easy to read and
+maintain.
 
-General architecture ideas
-==========================
+An example of Servicy can be found [here](https://github.com/thomasluce/servicy_example).
 
-Servicy would be broken into a few pieces:
+Configuring Servicy
+===================
 
-1. A daemon which can handle registration and query requests
-2. An in-memory database of services to facilitate queries
-3. A persistent cache of services to allow for fast restarts
-4. (possibly) A service/API router
-5. Reporting service to report on service health and usage.
-6. Client library for service discovery and connection
-7. Service library for registration, API discovery and building
+To configure Servicy for your project, there are a few options. The easiest,
+and recommended way, is to use code similar to the following:
 
-One big issue that will have to be resolved is version dependencies. If there
-are two versions of a service, each with a different public API, then Servicy
-should know about the differences and send back to a service requester the
-correct version based on their requirements. For this, Servicy should have a
-way of discovering and/or services defining their API to Servicy.
-
-Each service should also be able to define multiple instances, and Servicy
-should have multiple strategies for choosing instances of a given service. For
-example, round-robin, load-based (would require machine-level meta-data to be
-reported by the services), even requests, etc. To start with, a simple
-round-robin scheme will likely be the only implementation. Furthermore, Servicy
-should have knowledge of if a service is up or down, and automatically remove
-from its list of available providers, or add it back in as needed.
-
-Also, Servicy should maintain statistics on usage for services and be able to
-report that information back to a user. Stats should include number of
-discoveries, cache hits/misses, service up-times, provider failures, and, if it
-works as a router, request latency. In the event that I end up _not_ making it
-a router (seems likely at this point), it should still report latency for
-service discovery and query operations that require back-and-forth with the
-service.
-
-Protocol ideas
-==============
-
-Servicy is protocol agnostic, and the exact transport mechanism used to
-communicate between client and server doesn't matter. The data is sent as JSON
-underneath it all (for now; I may even change things to be format agnostic in
-the future). You can see examples of the JSON by looking in the
-Servicy::Transport::Message class.
-
-Service registration
---------------------
-
-Service registration allows for a service to declare that they exist, how to
-reach them, and what functionality they provide. Services are named using a
-Java-style, inverted domain name. For example:
-
-```
-com.mycompany.users.authentication
-```
-
-might be the name of a user authentication service provided internally. This
-allows for services to be broken up by what other services they interact with,
-as well as be easy to read for users browsing the registry.
-
-Beyond the name, a service must provide some other information for its
-registry. This includes:
-
-1. Host to connect to
-2. Port on the host to connect to
-3. Protocol used to communicate (HTTP, HTTPS, Thrift, etc.)
-4. Version number
-5. Heartbeat port
-
-The host can be either an IP address or a fully-qualified hostname. In either
-case it should be route-able in the context of the Servicy host. In other
-words, if Servicy cannot connect with it, it won't add it to the registry. The
-port should be an integer between 1 and 65535. The protocol can be anything,
-however some standards are:
-
-* HTTP - _Must_ use un-encrypted HTTP
-* HTTPS - _Must_ use TLS over HTTP
-* HTTP/S - Can use either HTTP or HTTPS
-* Thrift
-* TCP - Direct, telnet-like communication
-* UDP - Direct connection, but don't expect replies
-
-The protocol says nothing about what information needs to be sent or received
-by a client consuming the service. It is assumed that if the client is looking
-for the service, it knows how to use it once it is found, and will only use the
-protocol information to select between possible options provided by the
-consuming library. Protocols can also be provided as a list of possible
-options, ordered with most preferred first. At some point in the future, there
-may be a mechanism by which a service can describe itself in a more useful way,
-and client libraries can use that information to dynamically build an internal
-API.
-
-The version number must follow the format:
+Servicy global settings
+-----------------------
 
-```
-major.minor.revision-patch
-```
+```ruby
+Servicy.configure do |config|
+  config.server.host          = 'localhost'
+  config.server.transport     = Servicy::Transport.InMemory.new
+  config.server.load_balancer = Servicy::RoundRobinLoadBalancer.new
+  config.server.logger_stream = File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
+  config.server.config_file   = File.expand_path("~/.servicy.conf")
 
-The "-patch" part can be omitted. For example:
+  config.client.transport = Servicy::Transport.InMemory.new
+  config.transport.format = Servicy::Formats.JSON
 
+  config
+end
 ```
-1.0.2-p143
-```
-
-The heartbeat port is a port that Servicy can connect to to ensure that the
-service is still functioning. In many cases this will be the same port as the
-primary connection port; Servicy does not attempt to use the heartbeat
-connection for anything. It simply connects, and if successful, disconnects
-again. For this reason, your services should be resilliant to this type of
-traffic.
-
-Along with the required information already listed, a service can provide some
-optional information about the API that they provide. This information comes
-with some pieces of information for each API endpoint or action provided. The
-information is:
-
-1. Endpoint identifier
-2. Parameter information
-3. Return information
-4. (optional) Human-readable documentation.
 
-The endpoint identifier can be anything, and is just a string. For example, in
-an HTTP/S RESTful API, it may be something like:
-
-```
-/api/v1/user/login
+The available options are:
+* server.host
+   The host to connect to when registering or finding services.
+* server.transport
+   The transport protocol to use when speaking with the server
+* server.load_balancer
+   The load-balancing strategy to be used by the server when multiple providers
+   for the same service are available.
+* server.logger_stream
+   An IO object to write logs to
+* server.config_file
+   The path of the place to save and load configurations from.
+* client.transport
+   The transport protocol for a created service to use.
+* transport.format
+   The format to send over the wire, regardless of communication protocol.
+
+You can also set service-specific options. For example, if you have a service
+called "Hello", you could use:
+
+```ruby
+...
+config.Hello.language = "english"
+...
 ```
 
-The parameter information is information about each parameter that is expected
-by this endpoint. This data is structured, and requires information about name,
-data type, and weather or not the parameter is required.
-
-The return information is simply a description of the data that should be
-expected to return.
-
-The documentation is an arbitrary-length text string which can be used as
-documentation by a developer developing against the API.
-
-Multiple service providers can provide the same service. In that case, they are
-simply added to a pool of possible providers that is selected from using some
-load-balancing strategy such as round-robin or random selection.
-
-Any service provider that has registered will periodically get ICMP pinged by
-Servicy. If a response does not come back, it will be removed from the pool of
-providers. If a response does come back, Servicy will then attempt to connect
-to the heartbeat port to determine if the service is still functioning on the
-box. If it is not, the provider will be removed from the pool, otherwise it
-will be left in. This two-step process is to facilitate better logging and
-debugging of issues.
-
-Service de-registration
------------------------
-
-A service can remove itself from the pool voluntarily be simply sending the
-name, version, host, and port of the service to be removed. However, this is
-not strictly needed as the periodic heartbeat check will notice if a service
-goes away. These checks happen every second.
-
-A note on security
-++++++++++++++++++
-
-For the time-being, it is assumed that you will have Servicy and all the
-services it interacts with installed on internal, secured infrastructure. As
-such, Servicy takes a very trusting policy. However, that means that someone
-with malintent and access to your network could de-register services, or
-register a bunch of fake ones. Future versions of Servicy may attempt to
-resolve this issue. We'll see...
-
-Service discovery
------------------
+and then read the value in your service using `Servicy.config.Hello.language`.
+See the [example project](https://github.com/thomasluce/servicy_example) for
+more information.
 
-Once services are registered, a client needs to be able to discover them.
-Generally, they will discover a service and hold on to that information for the
-lifetime of their use, only requesting a new handle should the old one be lost.
-However, there is no reason why they couldn't request a new one every time.
-
-*NOTE* In the future, it may be possible for Servicy to act as a router by
-simply returning connection information for itself, and doing blind
-pass-through with some strategy to the other providers. In that case, the
-policy that a client uses to cache or not cache their connection information
-may have to change.
-
-A service consumer can query using one or both of two different dimensions:
-
-1. API name
-2. API functionality
-
-When using the name dimension, you can also query by version using either an
-exact match, a list of preferences, a range, a minimum, or a maximum.
-
-When querying using functionality, you query using one or more API method
-fingerprints. The fingerprints are in the following format:
+Per-service settings
+--------------------
 
-```
-method_name#arg-type,arg-type,...#return_type
-```
+If you are extracting an existing application into multiple services, you can
+also define constants on your service classes that will be used when
+automatically creating API's.
 
-where method_name is the name of the method you would like to call (or service
-end-point, or whatever. This is the same as the API endpoint in the service
-functionality registration information.), the `arg-type` pairs are the name of
-an argument (or an empty string in the case of un-named arguments), followed by
-a dash, followed by the argument type, and the return_type being the data-type
-for the return value.
+```ruby
+class MySuperAwesomeService
+  PORT = 1234
+  HEARTBEAT_PORT = 1235
+  VERSION = '1.2.6-p1098'
+  DOMAIN = 'com.mycompany'
 
-For example, a query could look something like this:
+  ...
 
-```
-user_create#username-string,password-string#User
+  include Servicy
+end
 ```
 
-Behind the scenes, Servicy will use this information to find all possible
-services that can fulfill this request. This will include any service that can
-perform this request but that may have more optional parameters. Type
-information can also be provided as a list of types, in the case of API's that
-can handle multiple types of information:
-
-```
-user_create#username-string,password-string|signed_string#User
-```
+Note that in all of these cases, we `include Servicy` at the end of the
+class/module so that the `.included` hook has maximum access to defined
+methods. It still will not catch any methods that are added on in code that is
+loaded after Servicy is included.
 
-The possible other types that the data can be are separated by a pipe, '|'.
+Other options
+-------------
 
-Finally, the service consumer can provide a boolean flag indicating weather or
-not they wish to receive API information about the returned providers, or if
-they simply want connection information. If the flag is set to true, they will
-get full API documentation and definitions along with connection information.
+Most settings are also changeable in creation of the objects themselves through
+argument hashes, in the case where you just want to use one small part of
+Servicy. See the full documentation and/or code for more information.
 
-The query system will either provide a successful "error"-code, along with a
-list of one or more service providers, a "not-found" error-code indicating that
-the query was valid, but that there are no available services which meet the
-requirements, or an "error" error-code that indicates that something was wrong
-with the provided query. In the last two queries, additional error information
-may be provided, but should be considered for human-use only; ie, showing an
-error message to a user.
 
 Notes on design of your objects
 ===============================
@@ -256,7 +115,7 @@ design.
 Servicy's goal is to make it simple for you to build microservices in Ruby that
 can either run locally or remotely without the developer having to worry about
 or care which. That said, as the developer of a service, it is _your_
-responsibility to make sure that you don't make services that suck (tm).
+responsibility to make sure that you don't make Services That Suck (tm).
 
 Don't build your objects to have iterators that require multiple-traversals
 over the wire. Don't build objects that lazy-evaluate things. Don't build
@@ -271,11 +130,10 @@ TODO
 
 Things left to do:
 
-1. In the command-line tool, there is some kind of bug where the registration
-   message never returns back to the client. This causes registration to hang
-   forever...
-1. I should sit down and really think out code structure and refactor where
-   needed. Things are getting a little difficult to follow if you are jumping
-   around between files a bunch.
-1. I need to cut down on the number of latency and heartbeat entries that are
-   saved. It gets a bit out of hand.
+1. More protocols and formatters
+1. Make service requests (optionally?) polling so that they can pick up on
+   services going up/down out of order.
+1. Optional service-to-local function reverting in the event of a remote
+   service failure.
+1. Work on code coverage.
+1. Fix all the default config options. transport.port?! WTF was I thinking?!

data/Servicy.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: servicy 0.0.5 ruby lib
+# stub: servicy 0.0.6 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "servicy"
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Thomas Luce"]
-  s.date = "2014-08-15"
+  s.date = "2014-08-19"
   s.description = "A service registration and discovery framework, as a server and client library."
   s.email = "thomas.luce@gmail.com"
   s.executables = ["servicy"]
@@ -25,7 +25,6 @@ Gem::Specification.new do |s|
     "bin/servicy",
     "lib/api.rb",
     "lib/client.rb",
-    "lib/configurable.rb",
     "lib/formats.rb",
     "lib/formats/json.rb",
     "lib/hash.rb",
@@ -37,6 +36,10 @@ Gem::Specification.new do |s|
     "lib/server/service_searcher.rb",
     "lib/service.rb",
     "lib/servicy.rb",
+    "lib/servicy/config.rb",
+    "lib/servicy/configurable.rb",
+    "lib/servicy/magic.rb",
+    "lib/servicy/servicy_logger.rb",
     "lib/transport/in_memory_transport.rb",
     "lib/transport/messages.rb",
     "lib/transport/null_transport.rb",

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/api.rb

@@ -121,7 +121,6 @@ module Servicy
       Object.const_set(class_name, magic_class)
     end
 
-    # TODO: API wrappers that create a server of some kind to serve things up
     # TODO: A gem/library generator based on the API
   end
 

data/lib/service.rb

@@ -28,7 +28,7 @@ module Servicy
       end
 
       if !args[:port].is_a?(Fixnum) || args[:port] < 1 || args[:port] > 65535
-        raise ArgumentError.new("Service port must be an integer betwee 1-65535")
+        raise ArgumentError.new("Service port must be an integer betwee 1-65535. Got: #{args[:port].inspect}")
       end
 
       args[:heartbeat_port] ||= args[:port]
@@ -118,7 +118,7 @@ module Servicy
       end
       record_heartbeat(1)
       return true
-    rescue
+    rescue => e
       record_heartbeat(0)
       return false
     ensure
@@ -181,12 +181,12 @@ module Servicy
       @transport.unformat(result)
     end
 
-    private
-
     def skip_heartbeat?
       !!no_heartbeat
     end
 
+    private
+
     def transport_from_class_or_string(transport)
       transport.is_a?(Servicy::Transport) ? transport : transport_from_string(transport)
     end
@@ -198,12 +198,12 @@ module Servicy
     # These are just to keep us from filling up memory.
     def record_latency(t1, t2)
       @latencies << t2.to_i - t1.to_i
-      @latencies = @latencies[0...10] if @latencies.length > 10
+      @latencies.slice!(2...10) if @latencies.length > 10
     end
 
     def record_heartbeat(h)
       @heartbeats << h
-      @heartbeats = @heartbeats[0...10] if @heartbeats.length > 10
+      @heartbeats.slice!(2...10) if @heartbeats.length > 10
     end
 
     # The api is broken into two kinds of methods; instance and class. Each can

data/lib/servicy.rb

@@ -5,159 +5,6 @@ require 'formats'
 require 'server'
 require 'client'
 require 'api'
-require 'configurable'
-require 'logger'
-
-module Servicy
-  # Get a logger instance that we can do something useful with.
-  def self.logger
-    @logger ||= begin
-                  stream = config.server.logger_stream
-                  stream = stream || File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
-                  Logger.new(stream)
-                end
-  end
-
-  # After this method gets done running, you either have the state of the world
-  # exactly the same as it was, or your object is replaced in the global Object
-  # scope with a new object that will proxy methods to a remote service
-  # provider.
-  #
-  # To define a service provider is a bit more work, and less auto-magic
-  # because the exact details of the infrastructure and architecture of your
-  # setup will be very different from others. So Servicy doesn't make
-  # assumptions about how you want to do things. That said, it's relatively
-  # simple:
-  #
-  #   # In some server class
-  #   Servicy::Server.new(...).go!
-  #
-  #   # In some service provider, possibly on a different box
-  #   api = Servicy::Client.create_api_for(MyServiceClass)
-  #   Servicy::Client.register_service(api)
-  # FIXME: @__api, and it's ilk, get overridden in the even that there is more
-  # than one.
-  def self.included(mod)
-    make_service_listener(mod)
-
-    # Attempt to find the service
-    client = Servicy::Client.new(config.server.transport)
-    raise 'go to bottom' unless client.connected?
-
-    # Create a new api object
-    @__api = Servicy::Client.create_api_for(mod)
-    port = Servicy.config.send(mod.to_s.to_sym).port
-    Servicy.logger.debug("Chose port, #{port} for service, #{mod.to_s}")
-    @__api.const_set("PORT", port) unless port.nil?
-    # TODO: for the other things as well
-
-    @__service = client.find_service(@__api.search_query)
-    raise 'go to bottom' unless @__service
-
-    # If all went well, then we can wrap the object to call to the remote
-    # service.
-    client = Servicy::Client.new(config.client.transport.class.new(port: port))
-    @__api.set_remote(client)
-
-    # ... and delegate that ish. We do it by killing off the original object,
-    # and replacing it with our own.
-    Object.send(:remove_const, mod.name.to_sym)
-    Object.const_set(mod.name.to_sym, @__api)
-  rescue => e
-    # Something went wrong, just give up silently, but don't do anything
-    # else; use this object as a regular-ass object. This is to allow you to
-    # use your API objects as normal objects in an environment where the
-    # object is bundled as part of a gem (,say, ) and there is no remote
-    # handler for it: use it locally
-  end
-
-  def self.make_service_listener(mod)
-    # If we didn't manage to connect to a remote client, then we are, by
-    # definition, the provider. We should start the transports api_server, and
-    # dispatch requests here.
-    mod.send(:define_singleton_method, :start_servicy_server) do
-      begin
-        Thread.new do
-          begin
-            port      = Servicy.config.send(self.to_s.to_sym).port    || Servicy.config.server.port
-            transport = Servicy.config.service.transport
-            transport = transport.nil? ? Servicy.config.server.transport : transport
-            client = Servicy::Client.new(transport.class.new(port: port))
-
-            client.transport.start_api do |request|
-              method = nil
-              begin
-                method = self.method(request.method_name.to_sym)
-              rescue
-                method = self.instance_method(request.method_name.to_sym)
-                method = method.bind(self.new)
-              end
-              things = transport.unformat(request.args)
-              args = method.parameters.map do |param|
-                things[param.last.to_s]
-              end
-
-              Servicy.logger.info "Calling #{method} with #{args.inspect}"
-              begin
-                result = method.call(*args)
-                Servicy::Transport::Message.api_response(result)
-              rescue => e
-                Servicy::Transport::Message.error(e.to_s + "\n" + e.backtrace.join("\n"))
-              end
-            end
-
-            client.transport.stop
-          rescue => e
-            Servicy::Transport::Message.error(e.to_s + "\n" + e.backtrace.join("\n"))
-          end
-        end
-
-        Servicy.logger.info "Creating #{self.to_s} api"
-        api = Servicy::Client.create_api_for(self)
-        port = Servicy.config.send(mod.to_s.to_sym).port
-        port = port.nil? ? Servicy.config.server.port : port
-        api.const_set 'PORT', port
-        # TODO: the other things, too
-        Servicy.logger.debug("Chose port, #{port} for service, #{mod.to_s}")
-
-        server_port = Servicy.config.server.port
-        transport = Servicy.config.server.transport
-        client    = Servicy::Client.new(transport.class.new(port: server_port))
-        Servicy.logger.info "Registering api, #{api.to_s}"
-        client.register_service api
-      rescue => e
-        Servicy.logger.error "An error occurred with the service: #{e.to_s}\n#{e.backtrace.join("\n")}"
-      end
-    end
-  rescue => e
-    # Again, just let it die silently. There is no reason to make things not
-    # work locally.
-    Servicy.logger.error(e)
-  end
-
-  # Use this method to configure Servicy for other services
-  def self.configure(&block)
-    conf = Configurable.new
-
-    # Give some reasonable defaults
-    conf.server.host          = 'localhost'
-    conf.server.transport     = Servicy::Transport.InMemory.new
-    conf.server.load_balancer = Servicy::RoundRobinLoadBalancer.new
-    conf.server.logger_stream = File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
-    conf.server.config_file   = File.expand_path("~/.servicy.conf")
-    # To set something for a given object, you would do something like:
-    # conf.transport.port = 1234
-
-    conf.client.transport = Servicy::Transport.InMemory.new
-    conf.transport.format = Servicy::Formats.JSON
-
-    conf = yield conf if block_given?
-
-    # Set the options
-    @_config = conf
-  end
-
-  def self.config
-    @_config ||= configure
-  end
-end
+require 'servicy/servicy_logger'
+require 'servicy/config'
+require 'servicy/magic'

data/lib/servicy/config.rb

@@ -0,0 +1,31 @@
+require 'servicy/configurable'
+
+module Servicy
+  # Use this method to configure Servicy for other services
+  def self.configure(&block)
+    conf = Configurable.new
+
+    # Give some reasonable defaults
+    conf.server.host          = 'localhost'
+    conf.server.transport     = Servicy::Transport.InMemory.new
+    conf.server.load_balancer = Servicy::RoundRobinLoadBalancer.new
+    conf.server.logger_stream = File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
+    conf.server.config_file   = File.expand_path("~/.servicy.conf")
+    # To set something for a given object, you would do something like:
+    # conf.transport.port = 1234
+
+    conf.client.transport = Servicy::Transport.InMemory.new
+    conf.transport.format = Servicy::Formats.JSON
+
+    conf = yield conf if block_given?
+    raise ArgumentError("Return the config object, please") unless conf.is_a?(Configurable)
+
+    # Set the options
+    @_config = conf
+  end
+
+  def self.config
+    @_config ||= configure
+  end
+end
+

data/lib/servicy/magic.rb

@@ -0,0 +1,120 @@
+module Servicy
+  # After this method gets done running, you either have the state of the world
+  # exactly the same as it was, or your object is replaced in the global Object
+  # scope with a new object that will proxy methods to a remote service
+  # provider.
+  #
+  # To define a service provider is a bit more work, and less auto-magic
+  # because the exact details of the infrastructure and architecture of your
+  # setup will be very different from others. So Servicy doesn't make
+  # assumptions about how you want to do things. That said, it's relatively
+  # simple:
+  #
+  #   # In some server class
+  #   Servicy::Server.new(...).go!
+  #
+  #   # In some service provider, possibly on a different box
+  #   api = Servicy::Client.create_api_for(MyServiceClass)
+  #   Servicy::Client.register_service(api)
+  # FIXME: @__api, and it's ilk, get overridden in the even that there is more
+  # than one.
+  def self.included(mod)
+    make_service_listener(mod)
+
+    # Attempt to find the service
+    client = Servicy::Client.new(config.server.transport)
+    raise 'go to bottom' unless client.connected?
+
+    # Create a new api object
+    @__api = Servicy::Client.create_api_for(mod)
+    port = Servicy.config.send(mod.to_s.to_sym).port
+    Servicy.logger.debug("Chose port, #{port} for service, #{mod.to_s}")
+    @__api.const_set("PORT", port) unless port.nil?
+    # TODO: for the other things as well
+
+    @__service = client.find_service(@__api.search_query)
+    raise 'go to bottom' unless @__service
+
+    # If all went well, then we can wrap the object to call to the remote
+    # service.
+    client = Servicy::Client.new(config.client.transport.class.new(port: port))
+    @__api.set_remote(client)
+
+    # ... and delegate that ish. We do it by killing off the original object,
+    # and replacing it with our own.
+    Object.send(:remove_const, mod.name.to_sym)
+    Object.const_set(mod.name.to_sym, @__api)
+  rescue => e
+    # Something went wrong, just give up silently, but don't do anything
+    # else; use this object as a regular-ass object. This is to allow you to
+    # use your API objects as normal objects in an environment where the
+    # object is bundled as part of a gem (,say, ) and there is no remote
+    # handler for it: use it locally
+  end
+
+  def self.make_service_listener(mod)
+    # If we didn't manage to connect to a remote client, then we are, by
+    # definition, the provider. We should start the transports api_server, and
+    # dispatch requests here.
+    mod.send(:define_singleton_method, :start_servicy_server) do
+      begin
+        Thread.new do
+          begin
+            port      = Servicy.config.send(self.to_s.to_sym).port    || Servicy.config.server.port
+            transport = Servicy.config.service.transport
+            transport = transport.nil? ? Servicy.config.server.transport : transport
+            client = Servicy::Client.new(transport.class.new(port: port))
+
+            client.transport.start_api do |request|
+              method = nil
+              begin
+                method = self.method(request.method_name.to_sym)
+              rescue
+                method = self.instance_method(request.method_name.to_sym)
+                method = method.bind(self.new)
+              end
+              things = transport.unformat(request.args)
+              args = method.parameters.map do |param|
+                things[param.last.to_s]
+              end
+
+              Servicy.logger.info "Calling #{method} with #{args.inspect}"
+              begin
+                result = method.call(*args)
+                Servicy::Transport::Message.api_response(result)
+              rescue => e
+                Servicy::Transport::Message.error(e.to_s + "\n" + e.backtrace.join("\n"))
+              end
+            end
+
+            client.transport.stop
+          rescue => e
+            Servicy::Transport::Message.error(e.to_s + "\n" + e.backtrace.join("\n"))
+          end
+        end
+
+        Servicy.logger.info "Creating #{self.to_s} api"
+        api = Servicy::Client.create_api_for(self)
+        port = Servicy.config.send(mod.to_s.to_sym).port
+        port = port.nil? ? Servicy.config.server.port : port
+        api.const_set 'PORT', port
+        # TODO: get port information from the class PORT stuff, too
+        # TODO: the other things, too
+        Servicy.logger.debug("Chose port, #{port} for service, #{mod.to_s}")
+
+        server_port = Servicy.config.server.port
+        server_port = server_port.nil? ? 1234 : server_port
+        transport = Servicy.config.server.transport
+        client    = Servicy::Client.new(transport.class.new(port: server_port))
+        Servicy.logger.info "Registering api, #{api.to_s}"
+        client.register_service api
+      rescue => e
+        Servicy.logger.error "An error occurred with the service: #{e.to_s}\n#{e.backtrace.join("\n")}"
+      end
+    end
+  rescue => e
+    # Again, just let it die silently. There is no reason to make things not
+    # work locally.
+    Servicy.logger.error(e)
+  end
+end

data/lib/servicy/servicy_logger.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+module Servicy
+  # Get a logger instance that we can do something useful with.
+  def self.logger
+    @logger ||= begin
+                  stream = config.server.logger_stream
+                  stream = stream || File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
+                  level = config.log_level
+                  level = level.nil? ? Logger::WARN : level
+                  l = Logger.new(stream)
+                  l.level = level
+                  l
+                end
+  end
+end

data/lib/transport/in_memory_transport.rb

@@ -28,12 +28,14 @@ module Servicy
     end
 
     def stop
-      @server && @server.close
+      @server && @server.close rescue nil
     end
 
     def socket_path
       @socket_path ||= begin
-                         file = Tempfile.new(@config[:path] || Servicy.config.transport.path || 'servicy-in-memory-transport')
+                         config_path = Servicy.config.transport.path
+                         config_path  = config_path.nil ? 'servicy-in-memory-transport' : config_path
+                         file = Tempfile.new(@config[:path] || config_path)
                          file.close
                          path = file.path
                          file.delete

data/lib/transport/tcp_transport.rb

@@ -65,7 +65,9 @@ module Servicy
     end
 
     def port
-      @config[:port] || Servicy.config.transport.port
+      config_port = Servicy.config.transport.port
+      config_port = config_port.nil? ? 1234 : config_port
+      @config[:port] || config_port
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servicy
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Thomas Luce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-15 00:00:00.000000000 Z
+date: 2014-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contraction
@@ -39,7 +39,6 @@ files:
 - bin/servicy
 - lib/api.rb
 - lib/client.rb
-- lib/configurable.rb
 - lib/formats.rb
 - lib/formats/json.rb
 - lib/hash.rb
@@ -51,6 +50,10 @@ files:
 - lib/server/service_searcher.rb
 - lib/service.rb
 - lib/servicy.rb
+- lib/servicy/config.rb
+- lib/servicy/configurable.rb
+- lib/servicy/magic.rb
+- lib/servicy/servicy_logger.rb
 - lib/transport/in_memory_transport.rb
 - lib/transport/messages.rb
 - lib/transport/null_transport.rb