topo-provision 0.0.1

data/lib/topo/provision/cli.rb

@@ -0,0 +1,95 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'mixlib/cli'
+require 'topo/provision'
+
+module Topo
+  module Provision
+    class CLI
+      include Mixlib::CLI
+ 
+      banner('Usage: topo-provision topofile [option]')
+  
+      option :format,
+             long: '--format topo|cloudformation',
+             description: 'Specifies format of the input topology file'
+
+      option :output_topo,
+             long: '--output-topo filename',
+             description: 'Specifies file to output topology JSON'
+
+      option :output,
+             long: '--output filename',
+             description: 'Specifies file to output generated recipe to'
+
+      option :action,
+             long: '--action deploy|undeploy|stop',
+             description: 'Specifies action to generate - defaults to deploy',
+             default: "deploy"
+                                                                    
+      attr_accessor :topology
+      
+      def initialize(argv=[])
+        super()
+        parse_and_validate_args
+      end
+      
+      def parse_and_validate_args
+        begin
+          parse_options
+          @input_file = cli_arguments()[0]
+        rescue OptionParser::InvalidOption => e
+          STDERR.puts e.message
+          puts opt_parser
+          exit(-1)
+        end
+        
+        if !@input_file
+          STDERR.puts opt_parser
+          exit(-1)
+        end
+      end
+      
+      def redirect_stdout(file)
+        begin
+          $stdout.reopen(file, "w")    
+        rescue => e
+          STDERR.puts "ERROR: Cannot open provisioning output file #{file} - #{e.message}"
+        end 
+      end
+       
+      def run        
+        @topology = Topo::Loader.from_file(@input_file,  @config[:format] || "default")
+
+        # output topo file
+        @topology.to_file(@config[:output_topo]) if(@config[:output_topo])         
+          
+        # redirect generated recipe to file
+        redirect_stdout(@config[:output]) if(@config[:output])
+          
+        # run generator
+        @generator = Topo::Provision::Generator.new(@topology)
+        action = @config[:action].to_sym
+        @generator.generate_provisioning_recipe(action)
+        
+      end
+      
+    end
+  end
+end

data/lib/topo/provision/generator.rb

@@ -0,0 +1,185 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'topo/utils/parsegen'
+require 'topo/provision/topology_generator'
+
+# load the resource generators
+%w[context machine  machine_image chef_node load_balancer node_group].each do |gen|
+  require_relative 'generators/' + gen
+end
+  
+#require 'topo/provision/generators/machine_image'
+
+#
+# The Generator class invokes driver-specific or base generators to generate
+# elements of the provisioning recipe. 
+#
+
+module Topo
+  module Provision
+    class Generator
+
+      include Topo::ParseGen
+
+      attr_accessor :topology
+      
+      # Generators for each driver (root driver)      
+      @@generator_classes = {}
+      @driver_name = "default"
+        
+      def self.register_generator(driver, class_name)
+         @@generator_classes[driver] = class_name
+      end  
+       
+      self.register_generator(@driver_name, self.name)
+      
+      def initialize(topo=nil)
+        @topology = topo
+        @generators = { @driver_name => self }
+      end
+      
+      # Get the right generator for the driver in place (e.g. vagrant, fog)
+      def generator(driver)
+        unless @generators.key?(driver)
+          
+          generator_class = @@generator_classes[driver] 
+          
+          unless generator_class          
+            begin
+             require "topo/provision/#{driver}/generator"
+             generator_class = @@generator_classes[driver]
+             rescue LoadError => e
+              STDERR.puts e.message
+              STDERR.puts("#{driver} driver cannot be loaded - using default generator instead")
+              generator_class = @@generator_classes["default"]              
+            end
+          end
+                  
+          @generators[driver] = Object::const_get(generator_class).new(@topology)
+        end
+        
+        @generators[driver]
+      end
+      
+      # Add resources & their generators to the topology generator, then 
+      # call them in dependency order to generate the overall recipe
+      # TODO: Driver-specific generation of dependencies other than through topo refs, e.g. autoscaling depend on loadbalancer
+      def generate_provisioning_recipe(action=:deploy)
+        
+        topology_generator = Topo::Provision::TopologyGenerator.new()
+        generator(@topology.driver).generate_context(action)
+         
+        @topology.services.each do |service|
+          depends_on = topo_refs(service).to_a
+          process_lazy_attrs(service) if depends_on.length > 0
+          topology_generator.add(service, depends_on,
+          { :resource_generator => resource_generator(service['type'], service) })
+        end
+        
+        @topology.nodes.each do |node|
+          depends_on = topo_refs(node).to_a
+          process_lazy_attrs(node) if depends_on.length > 0
+          topology_generator.add(node, depends_on, 
+          { :resource_generator => resource_generator("node", node) })
+        end
+        
+        if [:undeploy, :stop].include?(action)
+          topology_generator.reverse_generate(action)
+        else
+          topology_generator.generate(action)
+        end
+
+      end
+
+      
+      
+      def driver(resource)
+        if resource['provisioning'] && resource['provisioning']['driver']
+          resource_driver = resource['provisioning']['driver'].split(":",2)[0]
+        else
+        resource_driver = @topology.driver
+        end
+        resource_driver        
+      end
+      
+      # Convert attributes with references to lazy attributes, and return array of resource names
+      # that this resource depends on
+      def process_lazy_attrs(resource)
+        depends_on = Set.new
+        if resource['attributes']
+          resource['attributes'].each do |key, value|
+            deps = topo_refs(value)
+            if deps.size > 0
+              depends_on.merge(deps)
+              resource['lazy_attributes'][key] = lazy_attribute_to_s(value)
+              resource['attributes'].delete(key)
+            end
+          end
+        end
+        depends_on.to_a
+      end
+
+      # BASE DRIVER GENERATORS
+      
+
+      def generate_context(action)
+        cxt_gen = context
+        if (cxt_gen.respond_to? action)
+          cxt_gen.send(action)
+        else
+          cxt_gen.send("default_action", action)
+        end
+      end
+      
+      def resource_generator(resource_type, data) 
+        generator = nil
+        driver_generator = generator(driver(data))
+        if driver_generator.respond_to?(resource_type)
+         generator = driver_generator.send(resource_type, data)
+        else
+          STDERR.puts "Driver #{@topology.driver} does not support resource type #{resource_type}"
+        end
+        generator
+      end
+      
+      # Functions to return the resource generators
+      
+      def node(data)
+        if (data['provisioning'])
+          if(data['provisioning']['node_group'] && data['provisioning']['node_group']['size'])
+            Topo::Provision::NodeGroupGenerator.new(data)
+          else 
+            Topo::Provision::MachineGenerator.new(data)
+          end
+        else
+          Topo::Provision::ChefNodeGenerator.new(data)
+        end        
+      end
+      
+      def load_balancer(data)
+        Topo::Provision::LoadBalancerGenerator.new(data)
+      end
+
+      def context()
+        @context ||= Topo::Provision::ContextGenerator.new(@topology.provisioning,  @topology.driver)
+      end
+
+    end
+  end
+end

data/lib/topo/provision/generators/chef_node.rb

@@ -0,0 +1,35 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative 'resource'
+
+module Topo
+  module Provision
+    class ChefNodeGenerator < Topo::Provision::ResourceGenerator
+            
+      def initialize(data)
+        @resource_type ||= "chef_node"
+        super
+        %w[run_list chef_environment tags attributes].each do |key|
+          @resource_attributes[key] = data[key] if data.key? key
+        end
+      end
+     
+    end
+  end
+end

data/lib/topo/provision/generators/context.rb

@@ -0,0 +1,70 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'erb'
+require 'topo/utils/parsegen'
+
+#
+# The ContextGenerator class generates the recipe context  
+#
+
+module Topo
+  module Provision
+
+    class ContextGenerator   
+      include Topo::ParseGen
+
+      @@driver_files = {
+        'default' =>'chef/provisioning',
+        'aws' =>'chef/provisioning/aws_driver',
+        # 'fog' => 'chef/provisoning/fog_driver/driver', - not currently supported
+        'vagrant' => 'chef/provisioning/vagrant_driver/driver'
+      }
+      @@template = nil
+      
+
+      def initialize(data, default_driver)
+        @driver = data['driver'].split(':', 2).first if data['driver'] 
+        @driver ||= default_driver
+        @require_driver = @@driver_files['default']
+        if @driver && @@driver_files.key?(@driver)
+          @require_driver = @@driver_files[@driver]
+        end
+        @machine_options = convert_keys_to_sym(data['machine_options']) if data['machine_options']
+        @driver = data['driver']
+      end
+
+      def deploy()
+        puts(template.result(binding))
+      end
+      
+      def default_action(action)
+        puts(template.result(binding))
+      end
+      
+      def template()
+        unless @@template
+          path = File.expand_path("../templates/context.erb", __FILE__)
+          @@template = ERB.new(File.new(path).read, nil, '>')
+        end
+        @@template
+      end
+    
+    end
+  end
+end

data/lib/topo/provision/generators/load_balancer.rb

@@ -0,0 +1,40 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'topo/provision/generators/resource'
+
+module Topo
+  module Provision
+    
+    class LoadBalancerGenerator < Topo::Provision::ResourceGenerator
+      include Topo::ParseGen
+           
+      def initialize(data)
+        @resource_type ||= "load_balancer"
+        super
+        @undeploy_action = "destroy"
+        %w[machines load_balancer_options].each do |key|
+          @resource_attributes[key] = data['provisioning'][key] if data['provisioning'].key? key
+        end
+        
+        # Note: driver-specific classes may need to convert load_balancer_options into symbols
+      end
+     
+    end
+  end
+end

data/lib/topo/provision/generators/machine.rb

@@ -0,0 +1,50 @@
+#
+# Author:: Christine Draper (<christine_draper@thirdwaveinsights.com>)
+# Copyright:: Copyright (c) 2015 ThirdWave Insights LLC
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'topo/provision/generators/resource'
+
+#
+# The ResourceGenerator class generates the recipe resources  
+#
+
+module Topo
+  module Provision
+    class MachineGenerator < Topo::Provision::ResourceGenerator
+      
+      attr_reader :machine_options, :normal_attributes, :lazy_attributes
+      
+      def initialize(data)
+        @resource_type ||= "machine"
+        super
+        @undeploy_action = "destroy"
+        @normal_attributes =  data['attributes']||{}
+        @lazy_attributes = data['lazy_attributes']||{}
+        %w[run_list chef_environment tags ].each do |key|
+          @resource_attributes[key] = data[key] if data.key? key
+        end
+        opts = data['provisioning']['machine_options']
+        @machine_options = convert_keys_to_sym(opts) if opts
+      end
+      
+      def stop()
+        puts(template("stop").result(binding))
+      end
+     
+    end
+  end
+end