dnapi 1.1.74.jruby192.c

data/lib/dnapi/extensions.rb

@@ -0,0 +1,32 @@
+class Array
+  def to_jexp
+    map {|v| JSON.jexp(v) }
+  end
+end
+
+class Hash
+  def to_jexp
+    inject(self::class.new) do |h, (key, value)|
+      h.update key.to_s => JSON.jexp(value)
+    end
+  end
+end
+
+class Integer
+  def to_jexp() self end
+end
+
+module JSON
+  def self.jexp(*a)
+    if a.size == 1 && RUBY_VERSION >= "1.9.0"
+      o = a.first
+      o.respond_to?(:to_jexp) ? o.to_jexp : JSON.parse(JSON.dump([o])).first
+    else
+      return *a.map{|o| o.respond_to?(:to_jexp) ? o.to_jexp : JSON.parse(JSON.dump([o])).first}
+    end
+  end
+end
+
+class String
+  def to_jexp() self end
+end

data/lib/dnapi/gem_dep.rb

@@ -0,0 +1,9 @@
+module DNApi
+  class GemDep < Struct.new(:name, :version, :source)
+    belongs_to :app
+
+    def to_legacy_hash
+      to_hash.reject {|k,v| v.nil? }
+    end
+  end
+end

data/lib/dnapi/instance.rb

@@ -0,0 +1,69 @@
+module DNApi
+  class Instance < Struct.new(
+    :id,
+    :name,
+    :reporting_url,
+    :role,
+    :enabled,
+    :public_hostname,
+    :private_hostname,
+    :awsm_token,
+    :stonith_config,
+    :instance_api_config)
+
+    include ComponentPossessor
+
+    component_group :volumes, :ephemeral_volume, :ebs_volume
+
+    attr_accessor :environment
+
+    def initialize(attributes)
+      #legacy - (awsm,cookbooks?) passed in 'provisioned' (<2010?) - paranoid of breaking our existing "api"
+      if provisioned = attributes.delete(:provisioned)
+        attributes[:id] = provisioned.id
+        attributes[:public_hostname] = provisioned.public_hostname
+        attributes[:private_hostname] = provisioned.private_hostname
+      end
+      super(attributes)
+    end
+
+    alias_method :enabled?, :enabled
+
+    def newrelic_seed
+      c = component(:newrelic)
+      c && c.seed
+    end
+
+    def newrelic_token
+      c = component(:newrelic)
+      c && c.token
+    end
+
+    def to_legacy_hash
+      environment.to_legacy_hash.merge(legacy_hash)
+    end
+
+    def engineyard_hash
+      { :environment => environment.to_hash,
+        :this => id }
+    end
+
+    def legacy_hash
+      { :engineyard => engineyard_hash,
+        :instance_role => role,
+        :reporting_url => reporting_url,
+        :name => name }.reject {|k,v| v.nil? }
+    end
+
+    def to_dna
+      to_legacy_hash
+    end
+
+    def to_s
+      "Instance #{id} @ #{public_hostname} as #{role}"
+    end
+
+    ## chef-ey selectors
+    def_delegators :environment, :apps, :recipes, :solo?, :ssh_username, :ssh_password
+  end
+end

data/lib/dnapi/monitoring.rb

@@ -0,0 +1,22 @@
+module DNApi
+  class Monitoring < Struct.new(:name, :label)
+    Monit = new(:name => "monit", :label => "Monit")
+    God   = new(:name => "god",   :label => "god")
+
+    def self.all
+      @all ||= [Monit, God]
+    end
+
+    def self.get(name)
+      all.detect { |m| m.name == name }
+    end
+
+    def monit?
+      name == "monit"
+    end
+
+    def god?
+      name == "god"
+    end
+  end
+end

data/lib/dnapi/recipe.rb

@@ -0,0 +1,27 @@
+module DNApi
+  class Recipe < Struct.new(:name)
+    Monit = new(:name => 'monit')
+    Memcached = new(:name => 'memcached')
+    Nginx = new(:name => 'nginx')
+    NginxPassenger = new(:name => 'nginx-passenger')
+    Passenger = new(:name => 'passenger')
+    ApachePassenger = new(:name => 'passenger::apache')
+    Mongrel = new(:name => 'mongrel')
+    Unicorn = new(:name => 'unicorn')
+    Mysql51 = new(:name => 'mysql5_1')
+    Mysql55 = new(:name => 'mysql5_5')
+    Nginxtcp = new(:name => 'nginxtcp')
+    Node = new(:name => 'node::component')
+    Trinidad = new(:name => 'trinidad')
+    Thin = new(:name => 'thin')
+
+    def self.defaults
+      [Memcached, Monit]
+    end
+
+    def self.all
+      [Monit, Memcached, Nginx, NginxPassenger, ApachePassenger,
+       Mongrel, Unicorn, Mysql51, Mysql55, Nginxtcp, Node, Trinidad,Thin]
+    end
+  end
+end

data/lib/dnapi/ssl_cert.rb

@@ -0,0 +1,13 @@
+module DNApi
+  class SSLCert < Struct.new(:certificate, :private_key, :certificate_chain)
+    belongs_to :vhost
+
+    def to_legacy_hash
+      {
+        :crt => certificate,
+        :key => private_key,
+        :chain => certificate_chain
+      }
+    end
+  end
+end

data/lib/dnapi/stack.rb

@@ -0,0 +1,111 @@
+module DNApi
+  class Stack < Struct.new(:name, :label, :web_server, :rack_server, :ruby_versions, :recipes)
+
+    def initialize(opts = {})
+      super(opts)
+    end
+
+    NginxMongrel    = new(:name          => 'nginx_mongrel',
+                          :label         => 'Mongrel',
+                          :web_server    => :nginx,
+                          :rack_server   => :mongrel,
+                          :ruby_versions => (DNApi::Components::RubyVersion.all - [DNApi::Components::Ruby193,
+                                                                                   DNApi::Components::Ruby192,
+                                                                                   DNApi::Components::JRuby187,
+                                                                                   DNApi::Components::JRuby192,
+                                                                                   DNApi::Components::Rubinius]),
+                          :recipes       => [Recipe::Nginx, Recipe::Mongrel])
+
+    NginxPassenger  = new(:name          => 'nginx_passenger',
+                          :label         => 'Passenger',
+                          :web_server    => :nginx,
+                          :rack_server   => :passenger,
+                          :ruby_versions => (DNApi::Components::RubyVersion.all - [DNApi::Components::JRuby187,
+                                                                                   DNApi::Components::JRuby192,
+                                                                                   DNApi::Components::Rubinius]),
+                          :recipes       => [Recipe::Nginx, Recipe::NginxPassenger])
+
+    NginxPassenger3 = new(:name          => 'nginx_passenger3',
+                          :label         => 'Passenger 3',
+                          :web_server    => :nginx,
+                          :rack_server   => :passenger,
+                          :ruby_versions => (DNApi::Components::RubyVersion.all - [DNApi::Components::JRuby187,
+                                                                                   DNApi::Components::JRuby192,
+                                                                                   DNApi::Components::Ruby186]),
+                          :recipes       => [Recipe::Nginx, Recipe::NginxPassenger])
+
+    #FIXME: Remove
+    ApachePassenger = new(:name          => 'apache_passenger',
+                          :label         => 'Apache + Passenger',
+                          :web_server    => :apache,
+                          :rack_server   => :passenger,
+                          :ruby_versions => [DNApi::Components::Ruby186],
+                          :recipes       => [Recipe::Passenger, Recipe::ApachePassenger])
+
+    NginxUnicorn    = new(:name          => 'nginx_unicorn',
+                          :label         => 'Unicorn',
+                          :web_server    => :nginx,
+                          :rack_server   => :unicorn,
+                          :ruby_versions => (DNApi::Components::RubyVersion.all - [DNApi::Components::JRuby187,
+                                                                                   DNApi::Components::JRuby192,
+                                                                                   DNApi::Components::Rubinius]),
+                          :recipes       => [Recipe::Nginx, Recipe::Unicorn])
+
+    Trinidad        = new(:name          => 'trinidad',
+                          :label         => 'Trinidad',
+                          :web_server    => :nginx,
+                          :rack_server   => :trinidad,
+                          :ruby_versions => [DNApi::Components::JRuby187, DNApi::Components::JRuby192],
+                          :recipes       => [Recipe::Nginx, Recipe::Trinidad])
+
+    Nginxtcp        = new(:name          => 'nginxtcp',
+                          :label         => 'NodeJS',
+                          :web_server    => :nginxtcp,
+                          :rack_server   => :nodejs,
+                          :ruby_versions => [DNApi::Components::NodeJS],
+                          :recipes       => [Recipe::Nginxtcp, Recipe::Node])
+
+    NginxThin       = new(:name          => 'thin',
+                          :label         => 'Thin',
+                          :web_server    => :nginx,
+                          :rack_server   => :thin,
+                          :ruby_versions => (DNApi::Components::RubyVersion.all - [DNApi::Components::JRuby187,
+                                                                                   DNApi::Components::JRuby192,
+                                                                                   DNApi::Components::Rubinius]),
+                          :recipes       => [Recipe::Nginx, Recipe::Thin])
+
+    def self.all
+      [NginxMongrel, NginxPassenger, NginxPassenger3, ApachePassenger, NginxUnicorn, Trinidad, Nginxtcp,NginxThin]
+    end
+
+    def self.get(name)
+      all.detect {|s| s.name == name }
+    end
+
+
+    # Legacy helper methods to inspect the stack.
+    #
+    # We should tend to not use them and install specific recipes for each stack rather than
+    # check this to run code inside more global recipes.
+    #
+    # DO NOT DO THIS:
+    # i.e: The nginx recipe checks whether the stack uses nginx.
+    # i.e 2: The nginx recipe installs passenger if the stack uses passenger if the middle of the nginx installation.
+    #
+    # DO THIS:
+    # i.e: The nginx recipe is only loaded for stacks that use nginx.
+    # i.e 2: The stack that needs nginx+passenger loads the nginx recipe and after that loads the passenger recipe for nginx.
+    #
+    [:nginx, :apache].each do |ws|
+      define_method :"#{ws}?" do
+        self.web_server == ws
+      end
+    end
+
+    [:passenger, :mongrel, :unicorn, :trinidad, :thin].each do |as|
+      define_method :"#{as}?" do
+        self.rack_server == as
+      end
+    end
+  end
+end

data/lib/dnapi/struct.rb

@@ -0,0 +1,149 @@
+module DNApi
+  class Struct < ::Struct
+    extend Forwardable
+
+    class_inheritable_accessor :_many, :_ones, :_umembers
+
+    def_delegator :to_hash, :to_jexp
+    def_delegator :to_jexp, :to_json
+
+    class << self
+      def _many() @_many ||= [] end
+      def _ones() @_ones ||= [] end
+      def _umembers() @_umembers ||= [] end
+    end
+    attr_accessor :parent
+
+    def self.map
+      {
+        :instances  => DNApi::Instance,
+        :apps       => DNApi::App,
+        :crons      => DNApi::Cron,
+        :gems       => DNApi::GemDep,
+        :ebuilds    => DNApi::EbuildDep,
+        :ssl_cert   => DNApi::SSLCert,
+        :vhosts     => DNApi::VHost,
+        :components => DNApi::Component,
+      }
+    end
+
+    def self.from(jexp)
+      _many.each do |assoc|
+        jexp[assoc.to_s] = jexp[assoc.to_s].map do |item|
+          if klass = map[assoc.to_sym]
+            klass.from(item)
+          else
+            raise "No class found for #{assoc.inspect}"
+          end
+        end
+      end
+
+      _ones.each do |assoc|
+        if jexp[assoc.to_s]
+          jexp[assoc.to_s] = begin
+            item = jexp[assoc.to_s]
+            if klass = map[assoc.to_sym]
+              klass.from(item)
+            else
+              raise "No class found for #{assoc.inspect}"
+            end
+          end
+        end
+      end
+      new(jexp)
+    end
+
+    def self.many(*names)
+      _many.push(*names)
+      attr_reader(*names)
+      names.each do |name|
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{name}=(values)
+            values.each do |value|
+              value.parent = self if value.is_a?(DNApi::Struct)
+            end
+            @#{name} = values
+          end
+        EOT
+      end
+    end
+
+    def self.one(*names)
+      _ones.push(*names)
+      attr_reader(*names)
+      names.each do |name|
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{name}=(value)
+            value.parent = self if value.is_a?(DNApi::Struct)
+            @#{name} = value
+          end
+        EOT
+      end
+    end
+
+    def self.belongs_to(name)
+      alias_method name, :parent
+      alias_method "#{name}=", :parent=
+    end
+
+    def self.unserialized_member(*names)
+      _umembers.push(*names)
+      attr_accessor(*names)
+    end
+
+    def initialize(attrs = {})
+      raise(ArgumentError, "#{attrs.inspect} is not a hash") unless attrs.is_a?(Hash)
+
+      mattrs = attrs.to_mash
+      super(*members.map {|m| mattrs.delete(m) })
+
+      self::class._many.each do |assoc|
+        send(:"#{assoc}=", mattrs.delete(assoc) || [])
+      end
+
+      self::class._ones.each do |assoc|
+        send(:"#{assoc}=", mattrs.delete(assoc) || nil)
+      end
+
+      mattrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def _many
+      self.class._many
+    end
+
+    def _ones
+      self.class._ones
+    end
+
+    def _many_values
+      _many.map {|assoc| send(assoc)}
+    end
+
+    def _ones_values
+      _ones.map {|assoc| send(assoc)}
+    end
+
+    def to_hash
+      data = members.zip(values)
+      association_data = _many.zip(_many_values) + _ones.zip(_ones_values)
+      (data + association_data).inject({}) {|h,(k,v)| h.update(k => v) } #.reject {|k,v| v.nil? }
+    end
+
+    def ==(other)
+      super && self.class._umembers.all? do |umember|
+        self.send(umember) == other.send(umember)
+      end
+    end
+
+    def inspect
+      super.gsub(/>$/, ' ' + umember_inspect + '>')
+    end
+
+    def umember_inspect
+      self.class._umembers.map {|u| u.to_s + '=' + send(u).inspect } * ' '
+    end
+  end
+end

data/lib/dnapi/test.rb

@@ -0,0 +1,114 @@
+require 'dnapi'
+
+%w( randexp ey_slater ).each do |dep|
+  begin
+    require dep
+  rescue LoadError => e
+    puts "**** Looks like you forgot to add #{dep} as a test dependency ****"
+    raise e
+  end
+end
+
+require 'dnapi/test/sweatshop'
+require 'dnapi/test/ext'
+
+DNApi::Struct.extend DNApi::Test::Ext
+
+module DNApi
+  def self.gen(cluster, stack_name, app_types, attributes = {}, &block)
+    stack = DNApi::Stack.get(stack_name) || abort("Could not find the stack called #{stack_name.inspect}")
+    apps = app_types.map do |app_type|
+      DNApi::App.gen(app_type.to_sym)
+    end
+    Environment.gen(cluster.to_sym, attributes.merge(:stack => stack, :apps => apps), &block)
+  end
+end
+
+BASE64 = (0..15).map {|i| i.to_s(16).upcase }
+
+DNApi::Environment.fix {{
+  :alert_email => /\w+@example\.org/.gen,
+  :aws_secret_id => "00000" + 15.of { BASE64.pick }.join,
+  :aws_secret_key => "00000" + 35.of { BASE64.pick }.join,
+  :backup_interval => (1..24).pick,
+  :backup_window => (1..10).pick,
+  :name => "testing",
+  :db_stack => DNApi::DbStack::Mysql,
+  :ssh_username => "awesome",
+  :admin_ssh_key => "ssh-dss admin",
+  :ssh_keys => ["ssh-dss foo"],
+  :framework_env => %w( staging production qa custom ).pick,
+  :mailserver => /\w+\.example\.org/.gen,
+  :crons => 2.of { DNApi::Cron.gen }
+}}
+
+DNApi::Environment.fix(:single) do
+  DNApi::Environment.gen_attrs.merge(
+    :instances => [DNApi::Instance.gen(:role => :solo)]
+  )
+end
+
+DNApi::Environment.fix(:cluster) do
+  DNApi::Environment.gen_attrs.merge(
+    :instances => %w( app_master db_master ).map {|role| DNApi::Instance.gen(:role => role)}
+  )
+end
+
+DNApi::Environment.fix(:cluster_with_db_slave) do
+  attrs = DNApi::Environment.gen_attrs(:cluster)
+  attrs[:instances] << DNApi::Instance.gen(:role => :db_slave)
+  attrs
+end
+
+DNApi::Environment.fix(:cluster_with_utils) do
+  attrs = DNApi::Environment.gen_attrs(:cluster)
+  attrs[:instances] << DNApi::Instance.gen(:role => :util, :name => "Marriott")
+  attrs[:instances] << DNApi::Instance.gen(:role => :util, :name => "Courtyard")
+  attrs
+end
+
+DNApi::Instance.fix do
+  id = "fake-" + 8.of { BASE64.pick }.join
+  {
+    :enabled => true,
+    :id => id,
+    :public_hostname => "public-#{id}",
+    :private_hostname => "private-#{id}",
+    :reporting_url => "http://example.org/reporting/#{id}"
+  }
+end
+
+DNApi::App.fix(:rack) {{
+  :name => "testing-rack", :type => 'rack', :repository_name => "git@example.com:test-rack.git",
+  :domain_name => "_",
+  :database_name => "db-for-rack-app",
+  :gems => [{:name => 'wirble', :version => '0.1.3'}, {:name => 'nokogiri', :version => '1.3.0'}],
+  :ebuilds => ['irssi', 'enlightenment']
+}}
+
+DNApi::App.fix(:rails) {{
+  :name => "testing-rails", :type => 'rails', :repository_name => "git@example.com:test-rails.git",
+  :domain_name => "_",
+  :database_name => "db-for-rails-app",
+  :gems => [{:name => 'rails', :version => '1.0.3'}, {:name => 'crack', :version => '3.7.0'}],
+  :ebuilds => ['dwm', 'cowsay']
+}}
+
+DNApi::App.fix(:nodejs) {{
+  :name => "testing-nodejs", :type => 'nodejs', :repository_name => "git@example.com:test-nodejs.git",
+  :domain_name => "_",
+  :database_name => "db-for-nodejs-app",
+  :gems => [],
+  :ebuilds => ['dwm', 'cowsay']
+}}
+
+DNApi::Cron.fix {{
+  :name => /crontastic \d{3}/.gen,
+  :day => '*',
+  :hour => '*',
+  :minute => '*',
+  :month => '*',
+  :weekday => '*',
+  :command => 'echo "hi"',
+  :user => 'suicidal_pink_pony'
+}}