biosphere 0.0.14 → 0.1.0

data/lib/biosphere/kube.rb

@@ -114,7 +114,7 @@ class Biosphere
 
             end
 
-        end
+        end # end of class Client
 
         def kube_test(str)
             return str
@@ -182,6 +182,29 @@ class Biosphere
             end
         end
 
+        #
+        # Applies seleted properties from the current resource (as fetched from apiserver) to the new_version (as read from manifest file)
+        #
+        #
+        def self.kube_merge_resource_for_put!(current, new_version)
+            if current[:metadata]
+                new_version[:metadata][:selfLink] = current[:metadata][:selfLink] if current[:metadata][:selfLink]
+                new_version[:metadata][:uid] = current[:metadata][:uid] if current[:metadata][:uid]
+                new_version[:metadata][:resourceVersion] = current[:metadata][:resourceVersion] if current[:metadata][:resourceVersion]
+            end
+
+            if current[:spec]
+                new_version[:spec] = {} if !new_version[:spec]
+
+                # handle spec.clusterIP
+                if new_version[:spec][:clusterIP] && new_version[:spec][:clusterIP] != current[:spec][:clusterIP]
+                    raise ArgumentError, "Tried to modify spec.clusterIP from #{current[:spec][:clusterIP]} to #{new_version[:spec][:clusterIP]} but the field is immutable"
+                end
+                new_version[:spec][:clusterIP] = current[:spec][:clusterIP] if current[:spec][:clusterIP]
+
+            end
+            return new_version
+        end
 
         def kube_apply_resource(client, resource)
             name = resource[:metadata][:name]
@@ -206,15 +229,10 @@ class Biosphere
                 puts "Updating resource #{response[:resource]}"
 
                 # Get the current full resource from apiserver
-                update_resource = response[:body]
+                current_resource = response[:body]
 
-                # Merge the updates on top of it
-                # TODO: this doesn't remove fields from the update_resource which have been removed from the to-be-updated resource
-                update_resource.merge(resource)
+                update_resource = Kube.kube_merge_resource_for_put!(current_resource, resource)
 
-                # Remove fields which apiserver refuses to accept in PUT requests
-                update_resource.delete(:apiVersion)
-                
                 begin
                     responses << client.put(update_resource)
                 rescue RestClient::Exception => e

data/lib/biosphere/node.rb

@@ -2,34 +2,77 @@ require 'pp'
 require 'awesome_print'
 
 class Biosphere
+
     class Node
+
+        class Attribute < Hash
+            def deep_set(*args)
+                #puts "deep_set: #{args}"
+                raise ArgumentError, "must pass at least one key, and a value" if args.length < 2
+                value = args.pop
+                args = args.first if args.length == 1 && args.first.kind_of?(Array)
+
+                key = args.first
+                raise ArgumentError, "must be a number" if self.kind_of?(Array) && !key.kind_of?(Numeric)
+
+                if args.length == 1
+                    self[key] = value
+                else
+                    child = self[key]
+                    unless child.respond_to?(:store_path)
+                        self[key] = self.class.new
+                        child = self[key]
+                    end
+                    child.deep_set(args[1..-1].push, value)
+                end
+            end
+        end
+
         attr_reader :data
-        def initialize(from_string = nil)
-            if from_string
-                blob = Marshal.load(from_string)
-                @data = blob.data
+        def initialize(from = nil)
+            if from && from.is_a?(String)
+                blob = Marshal.load(from)
+                if blob.class == Biosphere::Node
+                    raise "Tried to load old state format. Unfortunately we are not backwards compatible"
+                end
+                @data = blob
+            elsif from
+                @data = from
             else
-                @data = {}
+                @data = Attribute.new
             end
         end
 
+        def data
+            return @data
+        end
+
+        def data=(s)
+            @data = s
+        end
+
         def include?(symbol)
             @data.include?(symbol)
         end
 
+        def deep_set(*args)
+            @data.deep_set(*args)
+        end
+
         def []=(symbol, *args)
             @data[symbol] = args[0]
         end
 
         def [](symbol, *args)
-            if !@data[symbol]
-                @data[symbol] = Node.new
-            end
             return @data[symbol]
         end
 
+        def merge!(obj)
+            @data.deep_merge!(obj)
+        end
+
         def save()
-            return Marshal.dump(self)
+            return Marshal.dump(@data)
         end
 
         def values

data/lib/biosphere/s3.rb

@@ -8,13 +8,14 @@ class S3
     end
 
     def save(path_to_file)
-        puts "\nSaving #{path_to_file} to S3"
         filename = path_to_file.split('/')[-1]
+        key = "#{@main_key}/#{filename}"
+        puts "Saving #{path_to_file} to S3 #{key}"
         begin
             File.open(path_to_file, 'rb') do |file|
                 @client.put_object({
                     :bucket => @bucket_name,
-                    :key => "#{@main_key}/#{filename}",
+                    :key => key,
                     :body => file
                 })
             end
@@ -27,17 +28,18 @@ class S3
 
     def retrieve(path_to_file)
         filename = path_to_file.split('/')[-1]
-        puts "\nFetching #{filename} from S3"
+        key = "#{@main_key}/#{filename}"
+        puts "Fetching #{filename} from S3 from #{key}"
         begin
             resp = @client.get_object({
                 :bucket => @bucket_name,
-                :key => "#{@main_key}/#{filename}"
+                :key => key
             })
             File.open(path_to_file, 'w') do |f|
                 f.puts(resp.body.read)
             end
         rescue Aws::S3::Errors::NoSuchKey
-            puts "\nCouldn't find remote file #{filename} from S3."
+            puts "Couldn't find remote file #{filename} from S3 at #{key}"
         rescue
             puts "\nError occurred while fetching the remote state, can't continue."
             puts "Error: #{$!}"

data/lib/biosphere/settings.rb

@@ -0,0 +1,72 @@
+require 'set'
+require 'deep_dup'
+
+class Biosphere
+
+    class Settings
+
+        class << self
+            def class_attribute(*attrs)
+                singleton_class.class_eval do
+                    attr_accessor(*attrs)
+                end
+
+                class_attributes.merge(attrs)
+            end
+
+            def class_attributes
+                @class_attributes ||= ::Set.new
+            end
+
+            def inherited(subclass)
+                class_attributes.each do |attr|
+                    value = send(attr)
+                    value = DeepDup.deep_dup(value) # rescue value
+                    subclass.class_attribute attr
+                    subclass.send("#{attr}=", value)
+
+                    p = path
+                    if p != ""
+                        p = p + "/"
+                    end
+                    subclass.send("path=", p + subclass.name.split('::').last)
+                end
+            end
+
+            def settings(settings=nil)
+                if settings
+                    c = @settings_hash ||= ::Hash.new
+                    c = DeepDup.deep_dup(c)
+                    c.deep_merge!(settings)
+                    @settings_hash = c
+                end
+                return @settings_hash
+            end
+
+            def path()
+                return @path
+            end            
+        end
+
+        class_attribute :settings_hash, :path
+
+        attr_accessor :settings, :path
+
+        def initialize(settings = {})
+            @settings = DeepDup.deep_dup(self.class.settings_hash)
+            @path = self.class.path
+            if settings
+                @settings.deep_merge!(settings)
+            end
+        end
+
+        def [](key)
+            return @settings[key]
+        end
+
+        settings({})
+
+        self.path = ""
+
+    end
+end

data/lib/biosphere/state.rb

@@ -0,0 +1,60 @@
+require 'pp'
+require 'ipaddress'
+require 'biosphere/node'
+require 'deep_merge'
+
+class Biosphere
+    class State
+        attr_accessor :filename, :node
+        
+        def initialize(filename = nil)
+            if filename
+                load(filename)
+            else
+                self.reset()
+            end
+        end
+
+        def reset()
+            @node = Node.new
+        end
+
+        def load(filename=nil)
+            if filename
+                @filename = filename
+            end
+            data = Marshal.load(File.read(@filename))
+            puts "Loading data from file #{@filename}: #{data}"
+            load_from_structure!(data)
+        end
+
+        def node(name=nil)
+            if name
+                return @node[name]
+            else
+                return @node
+            end
+        end
+
+        def merge!(settings)
+            @node.merge!(settings)
+        end
+
+        def save(filename=nil)
+            if !filename && @filename
+                filename = @filename
+            end
+            str = Marshal.dump(@node)
+            File.write(filename, str)
+            puts "Saving state to #{filename}"
+        end
+
+        def load_from_structure!(structure)
+            if @node
+                @node.data.deep_merge(structure.data)
+            else
+                @node = structure
+            end
+        end
+    end
+end

data/lib/biosphere/suite.rb

@@ -3,105 +3,103 @@ require 'ipaddress'
 require 'biosphere/node'
 
 class Biosphere
-	class Suite
-
-		attr_accessor :files
-		attr_accessor :actions
-
-		def initialize(directory)
-
-			@files = {}
-			@actions = {}
-			@directory = directory
-
-			files = Dir::glob("#{directory}/*.rb")
-
-			@plan_proxy = PlanProxy.new
-
-			for file in files
-				proxy = Biosphere::TerraformProxy.new(file, @plan_proxy)
-
-				@files[file[directory.length+1..-1]] = proxy
-			end
-
-			if File.exists?(directory + "/state.node")
-				@plan_proxy.node = Marshal.load(File.read(directory + "/state.node"))
-			end
-		end
-
-		def node(name=nil)
-			if name
-				return @plan_proxy.node[name]
-			else
-				return @plan_proxy.node
-			end
-		end
-
-
-		def evaluate_resources()
-			@files.each do |file_name, proxy|
-				proxy.evaluate_resources()
-			end
-
-		end
-
-		def load_all()
-			@files.each do |file_name, proxy|
-				proxy.load_from_file()
-
-				proxy.actions.each do |key, value|
-
-					if @actions[key]
-						raise "Action '#{key}' already defined at #{value[:location]}"
-					end
-					@actions[key] = value
-				end
-			end
-
-			return @files.length
-		end
-
-		def save_node(filename = "state.node")
-			str = Marshal.dump(@plan_proxy.node)
-			File.write(@directory + "/" + filename, str)
-		end
-
-
-		def evaluate_plans()
-			@files.each do |file_name, proxy|
-				puts "evaluating plans for #{file_name}"
-				
-				proxy.evaluate_plans()
-			end
-		end
-
-		def call_action(name, context)
-			found = false
-			@files.each do |file_name, proxy|
-				if proxy.actions[name]
-					found = true
-					proxy.call_action(name, context)
-				end
-			end
-
-			return found
-		end
-
-		def write_json_to(destination_dir)
-			if !File.directory?(destination_dir)
-				Dir.mkdir(destination_dir)
-			end
-
-			@files.each do |file_name, proxy|
-				json_name = file_name[0..-4] + ".json.tf"
-				str = proxy.to_json(true) + "\n"
-				destination_name = destination_dir + "/" + json_name
-				File.write(destination_name, str)
-
-				yield file_name, destination_name, str, proxy if block_given?
-			end
-
-		end
-
-	end
+    class Suite
+
+        attr_accessor :files
+        attr_accessor :actions
+        attr_reader :deployments, :biosphere_settings, :state
+        
+        def initialize(state)
+
+            @files = {}
+            @actions = {}
+            @state = state
+            @deployments = {}
+            @biosphere_settings = {}
+            @biosphere_path = ""
+        end
+
+        def register(deployment)
+            if @deployments[deployment.name]
+                raise RuntimeException.new("Deployment #{deployment.name} already registered")
+            end
+            @deployments[deployment.name] = deployment
+            if !@state.node[:deployments]
+                @state.node[:deployments] = Node::Attribute.new
+            end
+            @state.node[:deployments][deployment.name] = Node::Attribute.new
+            deployment.node = Node.new(@state.node[:deployments][deployment.name])
+            #@state.node.deep_set(:deployments, deployment.name, deployment.node.data)
+            deployment.state = @state
+
+            if deployment._settings[:biosphere]
+                @biosphere_settings.deep_merge!(deployment._settings[:biosphere])
+            end
+            
+        end
+
+        def evaluate_resources()
+            @deployments.each do |name, deployment|
+                deployment.evaluate_resources()
+            end
+        end
+
+        def node
+            @state.node
+        end
+
+        def load_all(directory)
+            @directory = directory
+            files = Dir::glob("#{directory}/*.rb")
+
+            for file in files
+                proxy = Biosphere::TerraformProxy.new(file, self)
+
+                @files[file[directory.length+1..-1]] = proxy
+            end
+            
+            @files.each do |file_name, proxy|
+                proxy.load_from_file()
+
+                proxy.actions.each do |key, value|
+
+                    if @actions[key]
+                        raise "Action '#{key}' already defined at #{value[:location]}"
+                    end
+                    @actions[key] = value
+                end
+            end
+
+            return @files.length
+        end
+
+        def call_action(name, context)
+            found = false
+            @files.each do |file_name, proxy|
+                if proxy.actions[name]
+                    found = true
+                    proxy.call_action(name, context)
+                end
+            end
+
+            return found
+        end
+
+        def write_json_to(destination_dir)
+            if !File.directory?(destination_dir)
+                Dir.mkdir(destination_dir)
+            end
+
+            @deployments.each do |name, deployment|
+                json_name = deployment.name + ".json.tf"
+                str = deployment.to_json(true) + "\n"
+                destination_name = destination_dir + "/" + json_name
+                File.write(destination_name, str)
+
+                yield deployment.name, destination_name, str, deployment if block_given?
+            end
+
+        end
+
+    end
 end