dnapi 1.1.74.jruby192.c

data/lib/dnapi/components/ssmtp.rb

@@ -0,0 +1,10 @@
+module DNApi
+  module Components
+    class Ssmtp < Struct.new(:key)
+      include Component
+
+      key :ssmtp
+      belongs_to Instance
+    end
+  end
+end

data/lib/dnapi/components/stunneled.rb

@@ -0,0 +1,13 @@
+module DNApi
+  module Components
+    class Stunneled < Struct.new(:key)
+      include Component
+
+      desc "A way to tunnel SSL traffic so that x-forwarded-for headers make their way to the app"
+
+      key :stunneled
+
+      belongs_to Environment
+    end
+  end
+end

data/lib/dnapi/components/volume.rb

@@ -0,0 +1,32 @@
+module DNApi
+  module Components
+    class Volume < Struct.new(:mountpoint, :size, :warn_at_percent, :fail_at_percent)
+      def warn_at
+        (self.size * (self.warn_at_percent.to_f / 100)).to_i
+      end
+
+      def fail_at
+        (self.size * (self.fail_at_percent.to_f / 100)).to_i
+      end
+    end
+
+    class EphemeralVolume < Volume
+      include Component
+      desc "The local, non persistant volumes for EC2."
+
+      key :ephemeral_volume
+
+      belongs_to Instance
+    end
+
+    class EBSVolume < Volume
+      include Component
+      desc "Snapshotable, persistant volumes for EC2."
+
+      key :ebs_volume
+
+      belongs_to Instance
+    end
+
+  end
+end

data/lib/dnapi/cron.rb

@@ -0,0 +1,5 @@
+module DNApi
+  class Cron < Struct.new(:command, :day, :hour, :minute, :month, :name, :user, :weekday)
+    attr_accessor :environment
+  end
+end

data/lib/dnapi/db_stack.rb

@@ -0,0 +1,92 @@
+module DNApi
+  class DbStack < Struct.new(:name, :label, :supports_replication, :backup_command, :adapter)
+    Mysql = new(
+      :name => 'mysql',
+      :label => 'MySQL 5.0.x',
+      :supports_replication => true,
+      :backup_command => 'eybackup --quiet',
+      :adapter => 'mysql'
+    )
+    Mysql5_1 = new(
+      :name => 'mysql5_1',
+      :label => 'MySQL 5.1.x',
+      :supports_replication => true,
+      :backup_command => 'eybackup -e mysql --quiet',
+      :adapter => 'mysql'
+    )
+    Mysql5_5 = new(
+      :name => 'mysql5_5',
+      :label => 'MySQL 5.5.x',
+      :supports_replication => true,
+      :backup_command => 'eybackup -e mysql --quiet',
+      :adapter => 'mysql'
+    )
+    Postgres = new(
+      :name => 'postgres',
+      :label => 'PostgreSQL 8.3.x',
+      :supports_replication => false,
+      :backup_command => 'eybackup -e postgresql --quiet',
+      :adapter => 'postgresql'
+    )
+
+    Postgres9 = new(
+      :name => 'postgres9',
+      :label => 'PostgreSQL 9.0.x',
+      :supports_replication => true,
+      :backup_command => 'eybackup -e postgresql --quiet',
+      :adapter => 'postgresql'
+    )
+
+    Postgres91 = new(
+      :name => 'postgres9_1',
+      :label => 'PostgreSQL 9.1.x',
+      :supports_replication => true,
+      :backup_command => 'eybackup -e postgresql --quiet',
+      :adapter => 'postgersql'
+    )
+
+    def self.all
+      [Mysql, Mysql5_1, Mysql5_5, Postgres, Postgres9,Postgres91]
+    end
+
+    def self.get(name)
+      all.detect {|s| s.name == name }
+    end
+
+    def supports_replication?
+      supports_replication
+    end
+
+    def postgres?
+      name == 'postgres'
+    end
+
+    def postgres9?
+      name == 'postgres9'
+    end
+
+    def postgres9_1?
+      name == 'postgres9_1'
+    end
+
+    def mysql5_1?
+      name == 'mysql5_1'
+    end
+
+    def mysql5_5?
+      name == 'mysql5_5'
+    end
+
+    def mysql?
+      name == 'mysql'
+    end
+
+    def adapter_for(component)
+      if adapter == 'mysql' && DNApi::Components::RubyVersion.encoding_aware.include?(component.class)
+        'mysql2'
+      else
+        adapter
+      end
+    end
+  end
+end

data/lib/dnapi/ebuild_dep.rb

@@ -0,0 +1,5 @@
+module DNApi
+  class EbuildDep < Struct.new(:name)
+    belongs_to :app
+  end
+end

data/lib/dnapi/environment.rb

@@ -0,0 +1,327 @@
+module DNApi
+  class Environment < Struct.new(:alert_email,
+                                 :aws_secret_key, :aws_secret_id,
+                                 :backup_interval, :backup_window,
+                                 :admin_ssh_key, :mailserver, :stonith_endpoint,
+                                 :internal_ssh_public_key,
+                                 :internal_ssh_private_key,
+                                 :newrelic_key,
+                                 :ruby_version,
+                                 :stack_name, :name, :framework_env,
+                                 :stats_password, :ssh_username, :ssh_password,
+                                 :ssh_keys, :db_stack_name,
+                                 :monitoring, :region, :backup_bucket)
+
+    include ComponentPossessor
+
+    many :instances, :apps, :crons
+
+    def initialize(attributes = {})
+      if stack = attributes[:stack]
+        attributes[:stack_name] = stack.name
+      end
+
+      super(attributes)
+
+      self.backup_window ||= 14
+      self.monitoring    ||= "monit"
+    end
+
+
+    def stack=(stack)
+      self.stack_name = stack.name
+    end
+
+    def monitoring
+      Monitoring.get(super)
+    end
+
+    def ruby_component
+      component(:ruby_186) || component(:ruby_187) ||
+        component(:ree) || component(:ruby_192) ||
+        component(:jruby_187) || component(:jruby_192) ||
+        component(:rubinius) || component(:ruby_193) ||
+        component(:nodejs)
+    end
+
+    def stack
+      Stack.get(stack_name)
+    end
+
+    def db_stack=(db_stack)
+      self.db_stack_name = db_stack.name
+    end
+
+    def db_stack
+      DbStack.get(db_stack_name)
+    end
+
+    def build_app(attributes = {})
+      app = App.new(attributes)
+      app.environment = self
+      apps << app
+      app
+    end
+
+    def build_instance(attributes = {})
+      instance = Instance.new(attributes)
+      instance.environment = self
+      instances << instance
+      instance
+    end
+
+    alias_method :_instances=, :instances=
+
+    def instances=(array)
+      array.each do |item|
+        item.environment = self
+      end
+      self._instances = array
+    end
+
+    def build_cron(attributes = {})
+      cron = Cron.new(attributes)
+      cron.environment = self
+      crons << cron
+      cron
+    end
+
+    alias_method :_apps=, :apps=
+
+    def apps=(array)
+      array.each do |item|
+        item.environment = self
+      end
+      self._apps = array
+    end
+
+    def db_host
+      if db_master
+        db_master.public_hostname
+      else
+        solo.public_hostname
+      end
+    end
+
+    def solo?
+      instances.any? {|i| i.role.to_s == 'solo' }
+    end
+
+    def solo
+      instances.detect {|i| i.role.to_s == 'solo' }
+    end
+
+    def db_slaves
+      instances.select {|i| i.role.to_s == 'db_slave' }
+    end
+
+    def app_slaves
+      instances.select {|i| i.role.to_s == 'app' }
+    end
+
+    def db_master
+      instances.detect {|i| i.role.to_s == 'db_master' }
+    end
+
+    def app_master
+      instances.detect {|i| i.role.to_s == 'app_master' }
+    end
+
+    def app_servers
+      (app_slaves << app_master).compact
+    end
+
+    def utility_instances
+      instances.select {|i| i.role.to_s == 'util' }
+    end
+
+    def solo_cluster?
+      instances.size == 1 && instances.first.role.to_s == 'solo'
+    end
+
+    def environment_hash
+      {:name => name, :framework_env => framework_env, :stack => stack.name}
+    end
+
+    def haproxy_hash
+      {:username => ssh_username, :password => stats_password}
+    end
+
+    def app_master_hash
+      if app_master
+        {:master_app_server => {
+          :public_ip => app_master.public_hostname,
+          :private_dns_name => app_master.private_hostname
+        }}
+      else
+        {}
+      end
+    end
+
+    def enabled_app_servers_hash
+      unless app_servers.empty?
+        {:members => enabled_app_servers_hostnames}
+      else
+        {}
+      end
+    end
+
+    def db_slaves_hostnames
+      db_slaves.map {|i| i.private_hostname }
+    end
+
+    def utility_instances_hostnames
+      utility_instances.map {|i| {:hostname => i.private_hostname, :name => i.name } }
+    end
+
+    def app_slaves_hostnames
+      unless app_slaves.empty?
+        app_slaves.map {|i| i.private_hostname }
+      end
+    end
+
+    def enabled_app_servers
+      app_servers.select {|i| i.enabled?}
+    end
+
+    def enabled_app_servers_hostnames
+      enabled_app_servers.map {|i| i.private_hostname }
+    end
+
+    def users
+      [{
+        :username => ssh_username,
+        :password => ssh_password,
+        :gid      => '1000',
+        :uid      => '1000',
+        :comment  => ''
+      }]
+    end
+
+    def applications
+      apps.inject({}) do |h, app|
+        h.update(app.name => app.to_legacy_hash)
+      end
+    end
+
+    def ebuilds
+      apps.map {|app| app.ebuilds }.flatten
+    end
+
+    def gems
+      apps.map {|app| app.gems_hash }.flatten
+    end
+
+    def applications_hash
+      apps.inject({}) do |h, app|
+        h.update(app.name => app.to_legacy_hash)
+      end
+    end
+
+    def to_legacy_hash
+      shared = %w( alert_email aws_secret_key aws_secret_id
+        backup_interval backup_window
+        admin_ssh_key mailserver
+        internal_ssh_public_key
+        internal_ssh_private_key
+        ruby_version
+        newrelic_key)
+      data = to_hash.select {|k,v| shared.include?(k.to_s)}
+      Hash[*data.flatten].merge(
+        :db_host             => db_host,
+        :db_slaves           => db_slaves_hostnames,
+        :user_ssh_key        => ssh_keys,
+        :utility_instances   => utility_instances_hostnames,
+        :environment         => environment_hash,
+        :haproxy             => haproxy_hash,
+        :users               => users,
+        :packages_to_install => ebuilds,
+        :gems_to_install     => gems,
+        :applications        => applications_hash,
+        :crons               => crons,
+        :ruby_version        => ruby_version
+      ).merge(app_master_hash).
+        merge(enabled_app_servers_hash).reject {|k,v| v.nil? }
+    end
+
+    def dna_for_instance(instance)
+      dna_for_instance_id(instance.id)
+    end
+
+    def dna_for_instance_id(amazon_id)
+      if instance = instance_for(amazon_id)
+        instance.to_legacy_hash
+      else
+        raise InstanceNotFound, "Unknown instance #{amazon_id.inspect} in environment #{name.inspect}"
+      end
+    end
+
+    def instance_ids
+      instances.map {|instance| instance.id}
+    end
+
+    def instance_for(instance_id)
+      instances.find { |instance| instance.id == instance_id }
+    end
+
+    def backups?
+      backup_window && backup_window.to_s != '0'
+    end
+
+    def snapshot_cron
+      if backups?
+        cron = backup_cron
+        cron.name = 'ey-snapshots'
+        cron.command = 'ey-snapshots --snapshot --quiet'
+        cron.minute = "0/#{rand(30) + 30}"
+        cron
+      end
+    end
+
+    def mysql_backup_cron
+      if backups?
+        cron = backup_cron
+        cron.name = 'eybackup'
+        cron.command = db_stack.backup_command
+        cron.minute = '10'
+        cron
+      end
+    end
+
+    def postgres_backup_cron
+      if backups? && (db_stack == DbStack::Postgres || db_stack == DbStack::Postgres9 || db_stack == DbStack::Postgres91)
+        cron = backup_cron
+        cron.name = 'eybackup postgres'
+        cron.command = db_stack.backup_command
+        cron.minute = '20'
+        cron
+      end
+    end
+
+    def backup_cron
+      Cron.new(
+        :hour     => backup_hour,
+        :day      => '*',
+        :month    => '*',
+        :weekday  => '*',
+        :user     => 'root'
+      ) if backups?
+    end
+
+    def backup_hour
+      backup_interval.to_s == '24' ? '1' : "*/#{backup_interval}"
+    end
+
+    ## chef-ey selectors
+    def recipes
+      apps.map {|a| a.recipes }.flatten.uniq
+    end
+
+    private
+
+    def ruby_version
+      rc = ruby_component
+      rc && rc.label
+    end
+  end
+end