guard-bosh 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab9503fc851cdf19034ac1606debeacb0f2f085c
+  data.tar.gz: 533de1a40a7b769549221eac66627419d1782f41
+SHA512:
+  metadata.gz: c4e0d898885f104008bf467c695667211e986e8d787a167bba61f1c0d555ae23e700da025c920c5962620aa219ad5127b94beacc0541054d482c15edc0d38c1b
+  data.tar.gz: edabe6e92e3c1cebec6cb08739eca1bb149c512fed9d4b288bc19a34139bb6549cdd6654cd2f006f1691b0fe89b0c6ed9a3221ed59cda6e176cc3c9c2e92fb2e

data/lib/guard/bosh.rb

@@ -0,0 +1,94 @@
+require 'guard/compat/plugin'
+
+module Guard
+  class Bosh < Plugin
+    require 'pathname'
+
+    require 'guard/bosh/apply_specification'
+    require 'guard/bosh/change_assessor'
+    require 'guard/bosh/effective_properties_calculator'
+    require 'guard/bosh/global_properties_loader'
+    require 'guard/bosh/job_default_properties_loader'
+    require 'guard/bosh/job_properties_loader'
+    require 'guard/bosh/job_repository'
+    require 'guard/bosh/notifier'
+    require 'guard/bosh/package_resolver'
+    require 'guard/bosh/template_checker'
+    require 'guard/bosh/template_renderer'
+
+    def initialize(options = {})
+      super
+
+      unless options.key?(:deployment_manifest)
+        fail 'Please specify the deployment_manifest in your Guardfile'
+      end
+
+      @deployment_manifest = Pathname.new(options[:deployment_manifest])
+      @change_assessor = options[:change_assessor]
+      @job_repository = options[:job_repository]
+      @template_checker = options[:template_checker]
+      @notifier = options[:notifier]
+    end
+
+    def start
+      reload_deployment_manifest
+      @notifier = Notifier.new
+    end
+
+    def run_all
+      errors = render_all_job_templates
+      notify_errors(errors)
+    end
+
+    def run_on_modifications(paths)
+      change_scope, job_name = @change_assessor.determine_scope(paths)
+      errors = case change_scope
+               when :all
+                 reload_deployment_manifest
+                 render_all_job_templates
+               when :all_templates_for_job
+                 render_templates_for_job(
+                   job_name, @job_repository.template_paths(job_name))
+               when :single_template
+                 render_templates_for_job(job_name, paths)
+               end
+      notify_errors(errors)
+    end
+
+    private
+
+    def reload_deployment_manifest
+      manifest = YAML.load_file(@deployment_manifest)
+      @change_assessor = ChangeAssessor.new(@deployment_manifest)
+      @job_repository = JobRepository.new(manifest)
+      @template_checker = TemplateChecker.build(
+        deployment_manifest: manifest,
+        release_dir: Pathname.new('.')
+      )
+    end
+
+    def notify_errors(errors)
+      @notifier.notify(errors)
+      throw :task_has_failed unless errors.empty?
+    end
+
+    def render_all_job_templates
+      @job_repository.job_templates.flat_map do |job_name|
+        render_templates_for_job(job_name,
+                                 @job_repository.template_paths(job_name))
+      end
+    end
+
+    def render_templates_for_job(job_name, templates)
+      manifest_jobs = @job_repository.find_by_template(job_name)
+      template_results = manifest_jobs.product(
+        templates).flat_map do |manifest_job, template|
+        @template_checker.check(
+          manifest_job_name: manifest_job,
+          job_name: job_name,
+          template: template)
+      end
+      template_results.select { |tr| tr[:status] == :failure }
+    end
+  end
+end

data/lib/guard/bosh/apply_specification.rb

@@ -0,0 +1,145 @@
+require 'ipaddr'
+
+module Guard
+  class Bosh
+    class ApplySpecification
+      def initialize(deployment_manifest:, package_resolver:)
+        @manifest = deployment_manifest
+        @package_resolver = package_resolver
+      end
+
+      def generate(properties:, job_name:)
+        {
+          'deployment' => @manifest['name'],
+          'configuration_hash' => '24292bab7264f00ada207768efa7018e2a2226fc',
+          'job' => job(job_name),
+          'packages' => packages(job_name),
+          'resource_pool' => resource_pool(job_name),
+          'networks' => network(job_name),
+          'index' => 0,
+          'properties' => properties,
+          'persistent_disk' => persistent_disk(job_name),
+          'rendered_templates_archive' => rendered_templates_archive
+        }
+      end
+
+      private
+
+      def job(job_name)
+        manifest_job = manifest_job_with_name(job_name)
+        {
+          'name' => job_name,
+          'template' => manifest_job['template'] ||
+            manifest_job['templates'].first['name'],
+          'version' => '1',
+          'sha1' => 'c7f277de5b283e5ceffe55674dc56fad2257ecab',
+          'blobstore_id' => '8a66ab45-4831-4ce3-aa8f-313fe33a9891',
+          'templates' => templates(manifest_job)
+        }
+      end
+
+      def packages(job_name)
+        manifest_job = manifest_job_with_name(job_name)
+        all_packages = template_names(manifest_job).flat_map do |template|
+          @package_resolver.resolve(template)
+        end
+        all_packages.inject({}) do |result, package|
+          result.merge(
+
+              package => {
+                'name' => package,
+                'version' => '1.0',
+                'sha1' => 'b945ce51b3635bb0ebfb2207323514381bcee824',
+                'blobstore_id' => '608c41bc-d491-4773-9812-8f24276eace1'
+              }
+
+          )
+        end
+      end
+
+      def templates(manifest_job)
+        template_names(manifest_job).map { |t| template(t) }
+      end
+
+      def template_names(manifest_job)
+        if manifest_job.key?('template')
+          Array(manifest_job['template'])
+        else
+          manifest_job['templates'].map { |t| t['name'] }
+        end
+      end
+
+      def template(name)
+        {
+          'name' => name,
+          'version' => '1',
+          'sha1' => '88d6ea417857efda58916f9cb9bd5dd3a0f76f00',
+          'blobstore_id' => '2356dff1-18fd-4314-a9bd-199b9d6c5c45'
+        }
+      end
+
+      def network(job_name)
+        manifest_job = manifest_job_with_name(job_name)
+        job_network = manifest_job['networks'].first
+        network_definition = @manifest['networks'].find do |n|
+          n['name'] == job_network['name']
+        end
+        {
+          job_network['name'] => {
+            'cloud_properties' => network_definition['subnets'].first['cloud_properties'],
+            'dns_record_name' => dns_record_name(
+              job_name, job_network['name'], @manifest['name']),
+            'ip' => ip_address(job_network, network_definition),
+            'netmask' => netmask(network_definition['subnets'].first['range']),
+            'default' => %w(dns gateway)
+          }
+        }
+      end
+
+      def ip_address(job_network, network_definition)
+        if job_network.key?('static_ips') &&
+           Array(job_network['static_ips']).any?
+          job_network['static_ips'].first
+        else
+          # We could be better here and calculate the dynamic address properly
+          network_definition['subnets'].first['range'].split('/').first
+        end
+      end
+
+      def dns_record_name(job, network, deployment)
+        "0.#{job}.#{network}.#{deployment}.bosh".gsub('_', '-')
+      end
+
+      def netmask(range)
+        cidr = range.split('/').last
+        IPAddr.new('255.255.255.255').mask(cidr).to_s
+      end
+
+      def resource_pool(job_name)
+        manifest_job = manifest_job_with_name(job_name)
+        job_pool = @manifest['resource_pools'].find do |pool|
+          pool['name'] == manifest_job['resource_pool']
+        end
+        job_pool.delete_if do |k, _|
+          ! %w(cloud_properties name stemcell).include?(k)
+        end
+      end
+
+      def persistent_disk(job_name)
+        manifest_job = manifest_job_with_name(job_name)
+        manifest_job['persistent_disk']
+      end
+
+      def rendered_templates_archive
+        {
+          'sha1' => 'c299ead74faf9ee9b47b3548e5df427e3e9a2c70',
+          'blobstore_id' => '72fb06ef-0f40-4280-85e8-b5930e672308'
+        }
+      end
+
+      def manifest_job_with_name(name)
+        @manifest['jobs'].find { |j| j['name'] == name }
+      end
+    end
+  end
+end

data/lib/guard/bosh/change_assessor.rb

@@ -0,0 +1,53 @@
+module Guard
+  class Bosh
+    class ChangeAssessor
+      def initialize(deployment_manifest)
+        @deployment_manifest = deployment_manifest
+      end
+
+      def determine_scope(raw_paths)
+        paths = raw_paths.map { |p| Pathname.new(p) }
+        return :all if paths.include?(@deployment_manifest)
+
+        jobs = paths.select { |p| spec_path?(p) }.map do |p|
+          p.dirname.basename.to_s
+        end
+
+        spec_scope = scope(jobs, :all_templates_for_job)
+        return spec_scope if spec_scope
+
+        jobs = paths.select { |p| template_path?(p) }.map do |t|
+          template_job(t)
+        end
+        template_scope = scope(jobs, :single_template)
+        return template_scope if template_scope
+
+        :none
+      end
+
+      private
+
+      def spec_path?(path)
+        path.basename.to_s == 'spec'
+      end
+
+      def template_path?(path)
+        path.descend { |p| break true if p.basename.to_s == 'templates' }
+      end
+
+      def template_job(template_path)
+        template_path.ascend do |p|
+          break p.dirname.basename.to_s if p.basename.to_s == 'templates'
+        end
+      end
+
+      def scope(jobs, value)
+        if jobs.size > 1
+          :all
+        elsif jobs.any?
+          [value, jobs.first]
+        end
+      end
+    end
+  end
+end

data/lib/guard/bosh/effective_properties_calculator.rb

@@ -0,0 +1,17 @@
+require 'deep_merge'
+
+module Guard
+  class Bosh
+    class EffectivePropertiesCalculator
+      def initialize(loaders:)
+        @loaders = loaders
+      end
+
+      def calculate_effective_properties(job)
+        @loaders.inject({}) do |result, loader|
+          result.deep_merge!(loader.load_properties(job))
+        end
+      end
+    end
+  end
+end

data/lib/guard/bosh/global_properties_loader.rb

@@ -0,0 +1,18 @@
+module Guard
+  class Bosh
+    class GlobalPropertiesLoader
+      def initialize(deployment_manifest:)
+        @deployment_manifest = deployment_manifest
+      end
+
+      def load_properties(_)
+        global_properties = @deployment_manifest['properties']
+        if global_properties.nil?
+          {}
+        else
+          global_properties
+        end
+      end
+    end
+  end
+end

data/lib/guard/bosh/job_default_properties_loader.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module Guard
+  class Bosh
+    class JobDefaultPropertiesLoader
+      def initialize(release_dir:)
+        @release_dir = release_dir
+      end
+
+      def load_properties(job)
+        properties = job_spec(job[:job_name]).fetch('properties')
+        expand(
+          intermediate_properties(properties).merge(
+            default_properties(properties)
+          )
+        )
+      end
+
+      private
+
+      def default_properties(properties)
+        defaults_only = properties.map do |property, config|
+          [property, config['default']]
+        end
+        Hash[defaults_only].reject { |_k, v| v.nil? }
+      end
+
+      def intermediate_properties(properties)
+        intermediates = properties.keys.map do |key|
+          key.split('.')[0..-2].join('.')
+        end.sort.uniq
+        Hash[intermediates.zip(intermediates.map { |_t| {} })]
+      end
+
+      def job_spec(job_name)
+        YAML.load_file(@release_dir + 'jobs' + job_name + 'spec')
+      end
+
+      def expand(properties)
+        properties.each_with_object({}) do |property, expanded|
+          key, value = property
+          current = expanded
+          each_parent(key) do |parent|
+            current[parent] = {} unless current.key?(parent)
+            current = current[parent]
+          end
+          current[leaf(key)] = value
+        end
+      end
+
+      def each_parent(key)
+        path = key.split('.')
+        path[0...-1].each do |parent|
+          yield parent
+        end
+      end
+
+      def leaf(key)
+        key.split('.').last
+      end
+    end
+  end
+end

data/lib/guard/bosh/job_properties_loader.rb

@@ -0,0 +1,20 @@
+module Guard
+  class Bosh
+    class JobPropertiesLoader
+      def initialize(deployment_manifest:)
+        @manifest = deployment_manifest
+      end
+
+      def load_properties(job)
+        manifest_job = @manifest['jobs'].find do |j|
+          j['name'] == job[:manifest_job_name]
+        end
+        if manifest_job
+          manifest_job['properties']
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/guard/bosh/job_repository.rb

@@ -0,0 +1,39 @@
+require 'pathname'
+
+module Guard
+  class Bosh
+    class JobRepository
+      def initialize(deployment_manifest)
+        @manifest = deployment_manifest
+      end
+
+      def job_templates
+        @manifest['jobs'].flat_map { |j| template_names(j) }.sort.uniq
+      end
+
+      def find_by_template(job)
+        jobs_using_template = @manifest['jobs'].select do |manifest_job|
+          template_names(manifest_job).include?(job)
+        end
+        jobs_using_template.map { |j| j['name'] }
+      end
+
+      def template_paths(job)
+        job_dir = Pathname.new('jobs') + job
+        YAML.load_file(job_dir + 'spec')['templates'].keys.map do |template|
+          job_dir + 'templates' + template
+        end
+      end
+
+      private
+
+      def template_names(manifest_job)
+        if manifest_job.key?('templates')
+          manifest_job['templates'].map { |t| t['name'] }
+        else
+          Array(manifest_job['template'])
+        end
+      end
+    end
+  end
+end