servitor 0.0.1

data/lib/provisioners/veewee_box.rb

@@ -0,0 +1,91 @@
+require 'veewee'
+
+module Servitor
+
+  class VeeweeBox
+
+    include ChildProcessHelper
+
+    class << self
+      def find(name)
+        definition = self.veewee.definitions[name]
+        VeeweeBox.new(name, nil, nil) if definition # we don't have the os name & version available
+      end
+
+      def veewee
+        @veewee ||= Veewee::Environment.new
+      end
+
+      def vagrant
+        VagrantBox.vagrant
+      end
+    end
+
+    attr_reader :name, :os_name, :os_version
+
+    def initialize(name, os_name, os_version, os_arch=nil)
+      raise InvalidNameError, name unless name =~ /^[a-zA-Z0-9\-]+$/
+      @name = name
+      @os_name = os_name
+      @os_version = os_version
+      @os_arch = os_arch || '64'
+    end
+
+    def define
+      execute_child_process('vagrant', 'basebox', 'define', @name, template_name)
+    end
+
+    def build(options={})
+      build_args = ['vagrant', 'basebox', 'build', @name, '--auto']
+      build_args << '--nogui' if options[:nogui]
+      execute_child_process(*build_args)
+    end
+
+    %w(up destroy).each do |method_name|
+      define_method(method_name) do
+        begin
+          execute_child_process('vagrant', 'basebox', method_name, @name)
+        rescue StandardError => e
+          raise e, "#{method_name}: #{e.message}", e.backtrace
+        end
+      end
+    end
+
+    %w(undefine validate export halt).each do |method_name|
+      define_method(method_name) do
+        begin
+          execute_child_process('vagrant', 'basebox', method_name, @name)
+        rescue StandardError => e
+          raise e, "#{method_name}: #{e.message}", e.backtrace
+        end
+      end
+    end
+
+    private
+
+    def template_name
+      @template_name ||= begin
+        # We try to find the best match from the available templates with some educated guessing.
+        os_templates = []
+        self.class.veewee.templates.each do |name, template|
+          os_templates << template if name =~ Regexp.new(@os_name)
+        end
+        raise UnsupportedOsRequirementError, "Unsupported OS: #{@os_name}" if os_templates.empty?
+
+        version_templates = os_templates.select { |t| t.name =~ Regexp.new(@os_version) }
+        raise UnsupportedOsRequirementError, "Unsupported OS version: #{@os_version}" if version_templates.empty?
+
+        cpu_templates = version_templates.select { |t| t.name =~ Regexp.new(@os_arch) }
+        raise UnsupportedOsRequirementError, "Unsupported OS version architecture: #{@os_arch}" if cpu_templates.empty?
+
+        # If there are still several templates, use the one with the shortest name because it's probably the simplest.
+        template = cpu_templates.map(&:name).sort_by(&:length).first
+      end
+    end
+  end
+
+  class UnsupportedOsRequirementError < StandardError; end
+  class InvalidNameError < StandardError; end
+  class VagrantBaseBoxError < StandardError; end
+
+end

data/lib/resource/mysql_resource.rb

@@ -0,0 +1,33 @@
+module Servitor
+  class MysqlResource
+
+    USERNAME = 'root'
+    PASSWORD = ''
+
+    def self.service_definition
+      @service_definition ||= begin
+        service_definition = ServiceDefinition.new
+        service_definition.name 'mysql'
+        service_definition.infrastructure_requirements do
+          os_name 'ubuntu'
+          os_version '10.04'
+          os_arch '64'
+          ruby_version '1.9.2-p290'
+        end
+        service_definition.deployment_stages do
+          build <<-BASH
+            which mysqld || sudo apt-get install mysql-server -y
+          BASH
+          release <<-BASH
+            SERVICE_IP = ifconfig eth1 | sed '/inet addr/!d;s/.*addr:\(.*\) Bcast.*$/\1/'
+            sudo sed -i '/^bind-address/s/127.0.0.1/$SERVICE_IP/g' /etc/mysql/my.cnf
+          BASH
+          run <<-BASH
+            sudo service mysql restart
+          BASH
+        end
+        service_definition
+      end
+    end
+  end
+end

data/lib/resource/resource.rb

@@ -0,0 +1 @@
+servitor_require 'mysql_resource'

data/lib/service/service.rb

@@ -0,0 +1,12 @@
+servitor_require 'service_definition/service_definition'
+servitor_require 'service_graph/service_graph'
+servitor_require 'service_file_parser'
+servitor_require 'service_locator'
+servitor_require 'service_linker'
+
+
+module Servitor
+  class Service
+    attr_accessor :name, :box, :ip_address, :root, :vm_root, :forwarded_ports, :service_node
+  end
+end

data/lib/service/service_definition/Servicefile.erb

@@ -0,0 +1,54 @@
+
+# The unique name of this service in the SOA
+name 'my-service'
+
+# This service may depend on any number of other services, identified by their
+# unique names in the SOA.  Some services may depend on multiple instances of
+# another service with different properties; this needs to be figured out.
+depends_on %w( service2 service3 )
+
+# Specify the infrastructure requirements for this service.  Anything that is
+# not specified will revert to some defaults.  There may be additional
+# infrastructure used in any given infrastructure provider implementation, but
+# this is the minimum set required by the app.
+infrastructure_requirements do
+  os_name 'ubuntu'
+  os_version '10.04'
+  os_arch '64'
+  ruby_version '1.9.2-p290'
+end
+
+# This should define the commands to use for the 12-factor build and release
+# steps (also aliased as configure and execute).  Any other services that this
+# service depends on will be started up first.  If there are mutual dependencies
+# then they should both be configured and then both started.  If the deployment
+# tools need to interact with the app in any other app-specific way, that should
+# also be defined here.  Note that these are explicitly deployment-related
+# operations; should we define any control tier operations here too?
+deployment_stages do
+  build 'echo "running build task"'
+  release  'echo "running release task"'
+  run 'rackup -p <%= '<%= @port %>' %>'
+end
+
+# Any configurable variables for this app are defined here.  If the app is to
+# receive configuration data then it *must* be included in this block.  This
+# includes details of any backing resources (databases, queues, etc.) that need
+# to be attached. If any of these are missing we can catch that problem without
+# even starting the app.  We can also automate the configuration details that
+# tell the app how to communicate with other services it depends on.
+configuration do
+  var 'config_var1'
+  var 'config_var2'
+  var 'config_var3', :default => 'some default'
+  var 'service2_url', :domain_for => 'service2', :format => 'https://<%= '<%= @value %>' %>'
+
+  # If the service depends on attached resources, each resource can be configured
+  # this way
+  resource 'database', :type => 'mysql' do
+    var 'database_host', :from => 'hostname'
+    var 'database_name', :from => 'database_name'
+    var 'database_username', :from => 'username'
+    var 'database_password', :from => 'password'
+  end
+end

data/lib/service/service_definition/deployment_stages.rb

@@ -0,0 +1,16 @@
+module Servitor
+
+  class DeploymentStages
+
+    %w(build release run).each do |attr|
+      define_method(attr) do |*args|
+        value = args.length > 0 ? args.first : nil
+        attr_sym = "@#{attr}".to_sym
+        instance_variable_set(attr_sym, value) unless value.nil?
+        instance_variable_get(attr_sym)
+      end
+    end
+
+  end
+
+end

data/lib/service/service_definition/resource_configuration.rb

@@ -0,0 +1,14 @@
+module Servitor
+
+  class ResourceConfiguration
+    include HasVariables
+
+    attr_reader :name, :options
+
+    def initialize(name, options=nil)
+      @name = name
+      @options = options || {}
+    end
+  end
+
+end

data/lib/service/service_definition/service_configuration.rb

@@ -0,0 +1,19 @@
+module Servitor
+
+  class ServiceConfiguration
+
+    include HasVariables
+
+    def resource(name, options=nil, &block)
+      resource_configuration = ResourceConfiguration.new(name, options)
+      resource_configuration.instance_exec(&block) if block_given?
+      resources << resource_configuration
+    end
+
+    def resources
+      @resources ||= []
+    end
+
+  end
+
+end

data/lib/service/service_definition/service_definition.rb

@@ -0,0 +1,49 @@
+servitor_require 'variable'
+servitor_require 'deployment_stages'
+servitor_require 'resource_configuration'
+servitor_require 'service_configuration'
+servitor_require 'service_definition'
+
+module Servitor
+
+  class ServiceDefinition
+
+    # these are part of the service configuration file
+    %w(name depends_on).each do |attr|
+      define_method(attr) do |*args|
+        value = args.length > 0 ? args.first : nil
+        attr_sym = "@#{attr}".to_sym
+        instance_variable_set(attr_sym, value) unless value.nil?
+        instance_variable_get(attr_sym)
+      end
+    end
+
+    # these are derived at load time
+    attr_reader :location, :service_root
+
+    def initialize(location=nil, service_root=nil)
+      @location = location
+      @service_root = service_root
+      @depends_on = []
+      @deployment_stages = DeploymentStages.new
+      @infrastructure_requirements = InfrastructureRequirements.new
+      @configuration = ServiceConfiguration.new
+    end
+
+    def deployment_stages(*args, &block)
+      @deployment_stages.instance_exec(&block) if block_given?
+      @deployment_stages
+    end
+
+    def infrastructure_requirements(&block)
+      @infrastructure_requirements.instance_exec(&block) if block_given?
+      @infrastructure_requirements
+    end
+
+    def configuration(&block)
+      @configuration.instance_exec(&block) if block_given?
+      @configuration
+    end
+  end
+
+end

data/lib/service/service_definition/variable.rb

@@ -0,0 +1,22 @@
+module Servitor
+
+  class Variable
+    attr_reader :name, :options
+
+    def initialize(name, options=nil)
+      @name = name
+      @options = options || {}
+    end
+  end
+
+  module HasVariables
+    def var(name, options=nil)
+      variables << Variable.new(name, options)
+    end
+
+    def variables
+      @variables ||= []
+    end
+  end
+
+end

data/lib/service/service_file_parser.rb

@@ -0,0 +1,21 @@
+module Servitor
+
+  class ServiceFileParser
+
+    # Parses the given service file, returning a service config
+    def self.parse(file, service_root)
+      begin
+      file_content = File.read(file)
+      ServiceDefinition.new(file, service_root).tap do |sc|
+        sc.instance_exec do
+          eval(file_content)
+        end
+      end
+      rescue StandardError => e
+        raise e, "Error parsing #{file}: #{e.message}", e.backtrace
+      end
+    end
+
+  end
+
+end

data/lib/service/service_graph/service_graph.rb

@@ -0,0 +1,58 @@
+servitor_require 'service_graph_node'
+servitor_require 'service_graph_flattener'
+
+module Servitor
+
+  class ServiceGraph
+
+    attr_reader :service_nodes, :root
+
+    def initialize
+      @service_nodes = { }
+    end
+
+    # Takes a service definition and builds a graph of service definitions,
+    # returning the root node for that graph
+    def self.build(root_service_definition)
+      new.tap { |g| g.send(:build, root_service_definition) }
+    end
+
+    private
+
+    def build(root_service_definition)
+      @root = find_or_build_node(root_service_definition)
+    end
+
+    def find_or_build_node(service_definition)
+      node = @service_nodes[service_definition.name]
+      return node if node
+      node = ServiceGraphNode.new(service_definition)
+      @service_nodes[service_definition.name] = node
+      add_dependent_nodes(node)
+      add_resource_nodes(node)
+      node
+    end
+
+    def add_dependent_nodes(node)
+      node.service_definition.depends_on.each do |dependency_name|
+        dependent_service_definition = ServiceLocator.locate(dependency_name)
+        add_dependent_service(node, dependent_service_definition)
+      end
+    end
+
+    def add_dependent_service(node, dependent_service_definition)
+      dependent_node = find_or_build_node(dependent_service_definition)
+      node.depends_on_nodes << dependent_node if dependent_node
+      dependent_node.depended_on_by_nodes << node
+    end
+
+    def add_resource_nodes(node)
+      node.service_definition.configuration.resources.each do |resource_configuration|
+        if resource_configuration.options[:type] == 'mysql'
+          add_dependent_service(node, MysqlResource.service_definition)
+        end
+      end
+    end
+  end
+
+end

data/lib/service/service_graph/service_graph_flattener.rb

@@ -0,0 +1,34 @@
+module Servitor
+
+  class ServiceGraphFlattener
+
+    class << self
+
+      # Takes a service graph and returns the service configs in service startup order.
+      # This means that services in the list depend only on other services
+      # that appear later in the list.
+      def flatten_to_startup_order(graph)
+        nodes = []
+        remaining_nodes = graph.service_nodes.values
+        while remaining_nodes.any?
+          found = false
+          remaining_nodes.dup.each do |node|
+            if node.depends_on_nodes.none? { |depends_on_node| remaining_nodes.include?(depends_on_node) }
+              found = true
+              nodes << node
+              remaining_nodes.delete(node)
+              break
+            end
+          end
+          raise CyclicDependencyError unless found
+        end
+        nodes
+      end
+
+    end
+
+  end
+
+  class CyclicDependencyError < StandardError; end
+
+end