classify_cluster 0.1.0 → 0.1.1

data/examples/cluster.rb

@@ -1,25 +1,97 @@
+# classify_cluster v.0.0.3a
 cluster_common = %w{ ntp conary sysstat }
-onpremise_common = %w{ sudo cron monit::disabled }
+onpremise_common = %w{ sudo::onpremise cron::onpremise monit::onpremise logrotate::onpremise }
 
 cluster :"appliance-cluster" do |cluster|
   (cluster_common + onpremise_common).each do |common_class|
     cluster.klass common_class
   end
-  {}.each_pair do |key, value|
+  {  
+    
+    # Cluster-wide configuration variables
+    
+    :socialcast_domain => "localhost.localdomain",
+    :database_username => 'socialcast',
+    :database_password => '',
+    
+    :database_root_password => '',
+    
+    :flickr_key => '',
+    :flickr_secret => '',
+    
+    :email_dropbox_account => '',
+    :email_dropbox_password => '',
+    
+    :jabber_account => '',
+    :jabber_password => '',
+    
+    :smtp_gateway_address => "foobar.local",
+    :smtp_gateway_port => '493',
+    :smtp_gateway_tls_enabled => 'true',
+    :smtp_gateway_anonymous_access_enabled => 'true',
+    :smtp_gateway_username => 'foo@bar',
+    :smtp_gateway_password => 'bazquux',
+    
+    :email_dropbox_server => '',
+    :email_dropbox_port => '993',
+    :innodb_buffer_pool_size => '100M',
+    :number_of_rails => '3',
+    :number_of_worklings => '2',
+    
+    
+    # Defaults
+    'socialcast_mode' => 'appliance',
+    'socialcast_filestore' => 'secure_file_system',
+    'cluster_name' => 'appliance-cluster',
+    'deployment_root' => '/var/www/socialcast',
+    'app_root' =>  '/var/www/socialcast',
+    'app_shared_root' => '/var/www/socialcast',
+    'app_user' => 'socialcast',
+    'ssl_pem_path' => '/etc/ssl/pem',
+    'app_pem_file' => 'raa.pem',
+    'cdn_disabled' => 'true',
+    'solr_jvm_options' => '-server -d32 -Xmx500M -Xms64M', # Needs more granular configuration
+    'rails_env' => 'production',
+    'scheduler_env' => 'production',
+    
+    # Variables that don't directly apply to the appliance 
+    :backup_s3_app_name => "appliance",
+    :solr_newrelic_app_name => "appliance",
+    :newrelic_app_name => 'appliance',
+    :database_database => 'centurion_production',
+    
+    :aws_access_key_id => '',
+    :aws_secret_access_key => '',
+    :s3_bucket => '',
+    :backup_s3_bucket => '',
+    
+    :cloudkick_oauth_key => '',
+    :cloudkick_oauth_secret => ''
+        
+  }.each_pair do |key, value|
     cluster.variable key, value
   end
-  {}.each_pair do |key, value|
-    cluster.resource do |resource|
-      resource.type value[:type]
-      resource.name key
-      resource.options value[:options]
-    end
+  
+  cluster.node 'node1.fqdn', '10.11.11.321' do |node|
+    
+    node.role :db, :primary => true
+    node.role :queue
+    node.role :cron, :primary => true, :backup => true
+    node.role :app
+    node.role :worker
+    node.role :munin, :node => true
+    
+    node.variable 'serverid', 1
+    
   end
-  cluster.node :"example.com" do |node|
-    node.klass "webserver"
-    node.variable :appservers, ['123.456.28.1']
-    node.role do |role|
-      role.type :web
-    end
+  
+  cluster.node 'node2.fqdn', '10.11.11.123' do |node|
+    
+    node.role :web
+    node.role :app
+    node.role :puppet_master
+    node.role :munin, :master => true, :node => true
+    node.role :search
+    
   end
-end
+end

data/lib/classify_cluster/configurator/cluster.rb

@@ -1,21 +1,48 @@
 module ClassifyCluster
   module Configurator
     class Cluster
-      attr_reader :nodes, :name, :classes, :variables, :resources
+      ROLE_2_VARIABLE_MAP = {
+        'app' => ['app_servers', []],
+        'db' => ['database_server', ''],
+        'queue' => ['queue_server', ''],
+        'push' => ['blow_server', ''],
+        'search' => ['solr_host', '']
+      }
+      attr_reader :nodes, :name, :classes, :variables, :resources, :hostnames
       def initialize(*args, &block)
         @nodes = {}
         @variables = {}
         @resources = []
         @classes = []
         @name = args.first
-        block.call self
+        @hostnames = {}
+        returned = block.call(self)
+        @nodes.each_pair do |fqdn, node|
+          @variables['hostnames'] = [] unless @variables['hostnames']
+          @variables['hostnames'] << "#{fqdn}/#{node.private_ip}"
+          node.roles.each do |role|
+            next unless ROLE_2_VARIABLE_MAP.has_key?(role.type.to_s)
+            
+            variable_name = ROLE_2_VARIABLE_MAP[role.type.to_s].first
+            variable_initial_value = ROLE_2_VARIABLE_MAP[role.type.to_s][1]
+            @variables[variable_name] = variable_initial_value unless @variables.has_key?(variable_name)
+            
+            if @variables[variable_name].is_a?(Array)
+              @variables[variable_name] << node.private_ip
+            else
+              @variables[variable_name] = node.private_ip
+            end
+          end
+        end
+        returned
       end
       def name(value=nil)
         return @name unless value
         @name = value
       end
-      def node(node_name, &block)
-        @nodes[node_name] = ClassifyCluster::Configurator::Node.new(node_name, &block)
+      def node(node_name, private_ip, &block)
+        @hostnames[node_name] = private_ip
+        @nodes[node_name] = ClassifyCluster::Configurator::Node.new(node_name, private_ip, &block)
       end
       def variable(name, value)
         @variables[name] = value

data/lib/classify_cluster/configurator/node.rb

@@ -1,15 +1,39 @@
 module ClassifyCluster
   module Configurator
     class Node
-      attr_reader :fqdn, :variables, :resources, :classes, :public_ip, :private_ip, :roles, :default
+      ROLE_2_KLASS_MAP = {
+        'db' => { 'primary' => 'databaseserver::onpremise', 'backup' => 'databasereplicationserver::onpremise'},
+        'queue' => 'queueserver::onpremise',
+        'app' => 'appserver::onpremise',
+        'worker' => 'workerserver::onpremise',
+        'web' => 'webserver::onpremise',
+        'puppet_master' => 'puppetmaster::onpremise',
+        'munin' => { 'master' => 'munin::master::onpremise', 'node' => 'munin::node::onpremise' },
+        'push' => 'pushserver::onpremise',
+        'cache' => 'memcached',
+        'search' => 'searchserver::onpremise'
+      }
+      attr_reader :fqdn, :variables, :resources, :classes, :private_ip, :public_ip, :roles, :default
       def initialize(*args, &block)
         @variables = {}
         @resources = []
         @classes = []
         @roles = []
         @fqdn = (args.first.to_s == 'default' ? '' : args.first)
+        @private_ip = (args[1].to_s == 'default' ? '' : args[1])
         @default = args.first.to_s == 'default'
-        block.call self
+        returned = block.call(self)
+        @roles.each do |role|
+          if ROLE_2_KLASS_MAP.has_key?(role.type.to_s)
+            if role.options.size > 0
+              role.options.each_pair do |key, value|
+                @classes << ROLE_2_KLASS_MAP[role.type.to_s][key.to_s]
+              end
+            else
+              @classes << ROLE_2_KLASS_MAP[role.type.to_s]
+            end
+          end
+        end
       end
       def default?
         return @default
@@ -18,16 +42,16 @@ module ClassifyCluster
         return @fqdn unless value
         @fqdn = value
       end
-      def public_ip(value = nil)
-        return @public_ip unless value
-        @public_ip = value
-      end
       def private_ip(value = nil)
         return @private_ip unless value
         @private_ip = value
       end
-      def role(&block)
-        @roles << ClassifyCluster::Configurator::Role.new(&block)
+      def public_ip(value = nil)
+        return (@public_ip || @private_ip) unless value
+        @public_ip = value
+      end
+      def role(type, options={})
+        @roles << ClassifyCluster::Configurator::Role.new(type, options)
       end
       def variable(name, value)
         @variables[name] = value

data/lib/classify_cluster/configurator/role.rb

@@ -2,9 +2,9 @@ module ClassifyCluster
   module Configurator
     class Role
       attr_reader :type, :options
-      def initialize(*args, &block)
-        @options = {}
-        block.call self
+      def initialize(type, options={})
+        @type = type
+        @options = options
       end
       def type(value = nil)
         return @type unless value

data/lib/classify_cluster/version.rb

@@ -1,3 +1,3 @@
 module ClassifyCluster
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/classify_cluster/writers/capistrano.rb

@@ -10,7 +10,11 @@ module ClassifyCluster
           roles = node.roles
           next if roles.empty?
           roles.each do |role|
-            capistrano_configurator.role(role.type, node.public_ip, role.options)
+            if role.type == 'queue'
+              capistrano_configurator.role('rabbitmq', node.public_ip, role.options)
+            else
+              capistrano_configurator.role(role.type, node.public_ip, role.options)
+            end
           end
         end
       end

data/lib/classify_cluster/writers/puppet.rb

@@ -35,7 +35,8 @@ module ClassifyCluster
               node.classes.each do |klass|
                 file.write(output("include #{klass}", :indent => 1))
               end
-              file.write(output("}"))
+              file.write(output("include socialcast::onpremise", :indent => 1))
+              file.write(output("}\n"))
             end
           end
         end; nil

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: classify_cluster
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Sean Cashin