coral_cloud 0.1.1

data/README.rdoc

@@ -0,0 +1,36 @@
+= coral_cloud
+
+This library provides the ability to define and manage servers.  These servers 
+can be local virtual machines (interfaced by Vagrant) or (in the near future)
+remote servers on various IAAS providers, such as Rackspace and Amazon.
+
+This library utilizes the Puppet provisioner to build servers and Vagrant
+to run them locally.  Eventually a cohesive API will be developed that will
+allow for easily switching and performing the same operations on different
+providers.  For now this library focuses on integration with Vagrant.
+
+More to come soon...
+       
+Note:  This library is still very early in development!
+
+== Contributing to coral_cloud
+ 
+* Check out the latest master to make sure the feature hasn't been implemented 
+  or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested 
+  it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a 
+  future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want 
+  to have your own version, or is otherwise necessary, that is fine, but 
+  please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Licensed under GPLv3.  See LICENSE.txt for further details.
+
+Copyright (c) 2013  Adrian Webb <adrian.webb@coraltech.net>
+Coral Technology Group LLC

data/Rakefile

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'jeweler'
+
+require './lib/coral_cloud.rb'
+
+#-------------------------------------------------------------------------------
+# Dependencies
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+#-------------------------------------------------------------------------------
+# Gem specification
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name                  = "coral_cloud"
+  gem.homepage              = "http://github.com/coraltech/ruby-coral_cloud"
+  gem.rubyforge_project     = 'coral_cloud'
+  gem.license               = "GPLv3"
+  gem.email                 = "adrian.webb@coraltech.net"
+  gem.authors               = ["Adrian Webb"]
+  gem.summary               = %Q{Provides the ability to define and manage clouds of local and remote servers}
+  gem.description           = File.read('README.rdoc')
+  gem.required_ruby_version = '>= 1.8.1'
+  gem.has_rdoc              = true
+  gem.rdoc_options << '--title' << 'Coral Cloud library' <<
+                      '--main' << 'README.rdoc' <<
+                      '--line-numbers' 
+  
+  # Dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+#-------------------------------------------------------------------------------
+# Testing
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+#-------------------------------------------------------------------------------
+# Documentation
+
+Rake::RDocTask.new do |rdoc|
+  version = Coral::Cloud::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "coral_cloud #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/coral_cloud/base.rb

@@ -0,0 +1,236 @@
+
+module Coral
+module Cloud
+class Base < Memory
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @@instances = {}
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.create(name, options = {})
+    options[:name]    = name unless options.has_key?(:name)
+    @@instances[name] = new(options) 
+    return @@instances[name]  
+  end
+  
+  #---
+  
+  def self.delete(name) 
+    if @@instances.has_key?(name) && @@instances[name]
+      @@instances.delete(name) 
+    end  
+  end
+  
+  #-----------------------------------------------------------------------------
+ 
+  def self.[](name)
+    if ! @@instances.has_key?(name) || ! @@instances[name]
+      @@instances[name] = new({ :name => name })
+    end  
+    return @@instances[name]  
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def initialize(options = {})
+    super(options)
+    
+    @repositories = {}
+    @shares       = {}
+    @servers      = {}
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+    
+  def repositories(reset = false)
+    if reset || @repositories.empty?
+      @repositories = {}
+      get('repositories', {}, :hash).each do |submodule, remote_dir|
+        @repositories[submodule] = Coral::Repository.new({
+          :name       => submodule,
+          :directory  => @directory,
+          :submodule  => submodule,
+          :remote_dir => remote_dir,
+        })
+      end
+    end
+    return @repositories
+  end
+    
+  #---
+    
+  def set_repositories(values = {})
+    return set('repositories', values)
+  end
+     
+  #---
+    
+  def repository(local_repo, default = '', format = false)
+    return get_group('repositories', local_repo, nil, default, format)
+  end
+    
+  #---
+    
+  def set_repository(local_repo, remote_repo)
+    return set_group('repositories', local_repo, nil, remote_repo)
+  end
+    
+  #---
+    
+  def delete_repository(local_repo)
+    return delete_group('repositories', local_repo, nil)
+  end
+     
+  #-----------------------------------------------------------------------------
+  
+  def settings(group)
+    return get_group('settings', group, nil, {}, :hash)
+  end
+    
+  #---
+
+  def set_settings(group, values = {})
+    return set_group('settings', group, nil, values)
+  end
+    
+  #---
+
+  def delete_settings(group)
+    return delete_group('settings', group, nil)
+  end
+    
+  #---
+   
+  def setting(group, key, default = '', format = false)
+    return get_group('settings', group, key, default, format)
+  end
+     
+  #---
+
+  def set_setting(group, key, value = '')
+    return set_group('settings', group, key, value)
+  end
+     
+  #---
+
+  def delete_setting(group, key)
+    return delete_group('settings', group, key)
+  end
+      
+  #-----------------------------------------------------------------------------
+    
+  def shares(reset = false)
+    if reset || @shares.empty?
+      @shares = {}
+      get('shares', {}, :hash).each do |name, share_info|
+        share_info = Coral::Util::Data.merge([ {
+          :name      => name,
+          :directory => File.join(@directory, share_info['local_dir']),
+        }, symbol_map(share_info) ])
+        
+        @shares[name] = Coral::Cloud::Share.new(share_info)
+      end
+    end
+    return @shares
+  end
+    
+  #---
+
+  def set_shares(values = {})
+    return set('shares', values)
+  end
+ 
+  #---
+    
+  def share(name, key = nil, default = {}, format = false)
+    return get_group('shares', name, key, default, format)
+  end
+    
+  #---
+
+  def set_share(name, key = nil, value = {})
+    return set_group('shares', name, key, value)
+  end
+    
+  #---
+
+  def delete_share(name, key = nil)
+    return delete_group('shares', name, key)
+  end
+    
+  #-----------------------------------------------------------------------------
+    
+  def servers(reset = false)
+    if reset || @servers.empty?
+      @servers = {}
+      get('servers', {}, :hash).each do |name, server_info|
+        server_info = Coral::Util::Data.merge([ {
+          :cloud   => self,
+          :machine => name,
+        }, symbol_map(server_info) ])
+        
+        @servers[name] = Coral::Cloud::Server.new(server_info)
+      end
+    end
+    return @servers
+  end
+    
+  #---
+
+  def set_servers(values = {})
+    return set('servers', values)
+  end
+
+  #---
+    
+  def server(name, key = nil, default = {}, format = false)
+    return get_group('servers', name, key, default, format)
+  end
+    
+  #---
+
+  def set_server(name, key = nil, value = {})
+    return set_group('servers', name, key, value)
+  end
+    
+  #---
+
+  def delete_server(name, key = nil)
+    return delete_group('servers', name, key)
+  end
+    
+  #-----------------------------------------------------------------------------
+     
+  def search(server, key, default = '', format = false)
+    value       = default
+    server_info = server(server)
+    
+    if server_info[key]
+      value = server_info[key]
+    else
+      settings = {}
+      if server_info.has_key?('settings')
+        array(server_info['settings']).each do |group|
+          settings = settings(group)
+        
+          if settings.has_key?(key)
+            if value.is_a?(Array) && settings[key].is_a?(Array)
+              value = value | settings[key]
+            else
+              value = settings[key]  
+            end            
+            break
+          end
+        end      
+      end
+    end
+    return filter(value, format)
+  end
+end
+end
+end

data/lib/coral_cloud/event/puppet_event.rb

@@ -0,0 +1,99 @@
+
+module Coral
+class PuppetEvent < Event
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  TYPE = :puppet
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    options[:type] = TYPE
+    
+    super(options)
+    
+    if options.has_key?(:string)
+      items          = options[:string].split(':')
+      self.element   = items[0]
+      self.operation = items[1]
+      self.message   = items[2]
+    end    
+  end  
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def element
+    return property(:element, '', :string)
+  end
+  
+  #---
+ 
+  def element=element
+    set_property(:element, string(element))
+  end
+  
+  #---
+  
+  def operation
+    return property(:operation, '', :string)
+  end
+  
+  #---
+   
+  def operation=operation
+    set_property(:operation, string(operation))
+  end
+  
+  #--
+  
+  def message
+    return property(:message, '', :string)
+  end
+  
+  #---
+   
+  def message=message
+    set_property(:message, string(message))
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return "#{type}:#{element}:#{operation}:#{message}"
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Event handling
+  
+  def check(source)
+    if source.match(/notice:\s+(.+?):\s+(.+)\s*/)
+      source_element   = $1
+      source_operation = ''
+      source_message   = $2
+                    
+      source_elements  = source_element.split('/')
+      source_operation = source_elements.pop.strip unless source_elements.last.match(/[\[\]]/)
+                    
+      if source_operation
+        source_element = source_elements.join('/').strip
+        
+        logger.debug("#{source_element} includes: #{element} -- " + ( source_element.include?(element) ? 'true' : 'false' ))
+        logger.debug("#{source_operation} is: #{operation} -- " + ( source_operation == operation ? 'true' : 'false' ))
+        logger.debug("#{source_message} includes: #{message} -- " + ( source_message.include?(message) ? 'true' : 'false' ))
+        
+        if source_element.include?(element) && source_operation == operation && source_message.include?(message)
+            logger.debug("MATCH! -> #{element} - #{operation} - #{message}") 
+            return true
+        end
+      end
+    end
+    logger.debug("nothing -> #{element} - #{operation} - #{message}") 
+    return false
+  end
+end
+end

data/lib/coral_cloud/server.rb

@@ -0,0 +1,254 @@
+
+module Coral
+module Cloud
+class Server < Core
+    
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    super(options)
+    
+    self.machine = ( options.has_key?(:machine) ? options[:machine] : '' )    
+    @cloud       = ( options.has_key?(:cloud) ? options[:cloud] : Coral.create_cloud(@name, options) )    
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_reader :machine, :name, :cloud
+
+  #---
+ 
+  def machine=machine
+    @name = ''
+    if machine.is_a?(String)
+      @machine = nil
+      @name    = machine
+    else
+      @machine = machine
+      @name    = @machine.name if @machine
+    end
+  end
+ 
+  #---
+  
+  def hostname
+    return @cloud.server(@name, 'hostname', '', :string)
+  end
+
+  #---
+   
+  def hostname=hostname
+    @cloud.set_server(@name, 'hostname', hostname)
+  end
+ 
+  #---
+  
+  def public_ip
+    return @cloud.server(@name, 'public_ip', '', :string)
+  end
+
+  #---
+   
+  def public_ip=public_ip
+    @cloud.set_server(@name, 'public_ip', public_ip)
+  end
+ 
+  #---
+  
+  def internal_ip
+    return @cloud.server(@name, 'internal_ip', '', :string)
+  end
+
+  #---
+   
+  def internal_ip=internal_ip
+    @cloud.set_server(@name, 'internal_ip', internal_ip)
+  end
+ 
+  #---
+  
+  def virtual_hostname
+    return @cloud.search(@name, 'virtual_hostname', '', :string)
+  end
+
+  #---
+   
+  def virtual_hostname=virtual_hostname
+    @cloud.set_server(@name, 'virtual_hostname', virtual_hostname)
+  end
+  
+  #---
+  
+  def virtual_ip
+    return @cloud.search(@name, 'virtual_ip', '', :string)
+  end
+
+  #---
+   
+  def virtual_ip=virtual_ip
+    @cloud.set_server(@name, 'virtual_ip', virtual_ip)
+  end
+  
+  #-----------------------------------------------------------------------------
+     
+  def repositories(options = {}, return_objects = true)
+    repositories = array(options[:repos], @cloud.repositories.keys, true)
+    results      = ( return_objects ? {} : [] )    
+    
+    return results unless repositories.is_a?(Array)
+    
+    repositories.each do |repo_name|
+      if @cloud.repositories.has_key?(repo_name)
+        if return_objects
+          results[repo_name] = @cloud.repositories[repo_name]
+        else
+          results << repo_name
+        end
+      end
+    end
+    return results
+  end
+  
+  #---
+  
+  def shares(options = {}, return_objects = true)
+    shares  = array(options[:shares], @cloud.shares.keys, true)
+    results = ( return_objects ? {} : [] )    
+    
+    return results unless shares.is_a?(Array)
+    
+    shares.each do |share_name|
+      if @cloud.shares.has_key?(share_name)
+        if return_objects
+          results[share_name] = @cloud.shares[share_name]
+        else
+          results << share_name
+        end
+      end
+    end
+    return results
+  end
+            
+  #-----------------------------------------------------------------------------
+  # Management 
+    
+  def start(options = {})
+    sync_remotes(options)
+        
+    return true if ! @machine
+    
+    options["provision.enabled"] = false
+    
+    if @machine.created?
+      @machine.start(options)
+    else
+      @machine.up(options)
+    end
+    return true
+  end
+    
+  #-----------------------------------------------------------------------------
+  
+  def update(options = {})
+    sync_remotes(options)
+    
+    success = true    
+    return success if ! @machine    
+    
+    if @machine.created?
+      if @machine.state == :running
+        success = Coral::Command.new("vagrant provision #{@name}").exec! do |line|
+          process_puppet_message(line)
+        end    
+      end
+    end
+    return success   
+  end
+    
+  #-----------------------------------------------------------------------------
+
+  def destroy(options = {})    
+    return true if ! @machine
+    
+    if @machine.created?
+      do_destroy = false
+
+      if options[:force]
+        do_destroy = true
+      else
+        choice = nil
+        begin
+          choice = ui.ask("Are you sure you want to remove: #{@name}?")
+        rescue Errors::UIExpectsTTY
+        end
+        do_destroy = choice.upcase == "Y"
+      end
+
+      if do_destroy
+        @machine.destroy
+      end
+    end
+    return true    
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Repository operations
+  
+  def sync_remotes(options = {})
+    repositories(options).each do |repo_name, repo|
+      if repo.can_persist?
+        if @name != 'all'
+          repo.set_remote(@name, public_ip, options)
+        end        
+        
+        server_ips = []      
+        @cloud.servers.each do |server_name, server|
+          server_ips << server.public_ip
+        end
+        
+        options[:add] = true
+        repo.set_remote('all', server_ips, options)
+      end
+    end
+    return true
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def commit(options = {})    
+    repositories(options).each do |name, repo|
+      if repo.can_persist?
+        repo.commit('.', options)
+      end      
+    end
+    return true    
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def push(options = {})  
+    sync_remotes(options)
+       
+    success = true
+    repositories(options).each do |name, repo|
+      if repo.can_persist?
+        success = repo.push!(@name, options) do |line|
+          process_puppet_message(line)  
+        end
+        break unless success
+      end
+    end
+    return success
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def process_puppet_message(line)
+    return line.match(/err:\s+/) ? { :success => false, :prefix => 'FAIL' } : true
+  end
+end
+end
+end