foreman_templates 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3bd9ea7c7b68c51790a87d66ab47d73f8c8a732
-  data.tar.gz: 9a9a5b69cbe4c1a1c46c9657eec4c25bdf7d03c8
+  metadata.gz: ab073792fefeb26fbe23885b712a9baa467753f0
+  data.tar.gz: c9b1d817144bd1fb43b7667a9e453000a4e047e0
 SHA512:
-  metadata.gz: c00161195df295c0366d2eeb1d82526f50402e7d9bb01e7f1a149976dc297b12395df399e5b8233a5f428a81e61c41f5c4807dccc7f8f1dbee4c8066203c01d9
-  data.tar.gz: 3a9876e223051b8ed1f3e1f5389558da85e0ab8ea389f10827d77ad3cee24d2bb6c413312fc191e42e1b37882bb0794966652c8b749618c31defb6d8ba4a2ab2
+  metadata.gz: 8d746a74ce4346d98e062cd6df27c163d411474925d52ee6e54594fc68f16ccf9776fb849a701c0ef137e8136c8faf2d1ff6d915e39e8214e7dea3c004bea478
+  data.tar.gz: 7ee0097bbc39da25acd264c7932db97c789edc1e8e042ffd7af0f984ebbe20ba7dd1cab8281390bc9022b729e1c6686ef73d81be835bb1abfb8a6035a6986223

data/README.md

@@ -21,10 +21,12 @@ You can get the develop branch of the plugin by specifying your Gemfile in this
 
 ## Configuration
 
-There is UI no configuration at this time.
+There is no UI configuration at this time.
 
 ## Usage
 
+### Import
+
 The plugin provides a Rake task to import the templates. To use it, simply do
 
     foreman-rake templates:sync
@@ -37,7 +39,7 @@ The importer will attempt to figure out the OS and Release the template refers t
 this is a new template being created, and we can find a matching OS in Foreman, the
 template will be automatically associated with the OS
 
-# Rake options
+#### Rake options
 
 * verbose   => Print extra information during the run [false]
 * repo      => Sync templates from a different Git repo [https://github.com/theforeman/community-templates]
@@ -51,9 +53,9 @@ The `branch` default will use *develop* if you're on Foreman-nightly; or the
 matching *1.X-stable* branch for your version of Foreman (if it exists); or
 finally it will remain on the default branch as a fallback.
 
-## Examples
+#### Examples
 
-Just import all the templates in from the default repo
+Just import all the templates from the default repo
 
     foreman-rake templates:sync
 
@@ -65,14 +67,69 @@ Import templates matching the name "Fedora"
 
     foreman-rake templates:sync filter='fedora'
 
-Import templates from a subsection of a git repo:
+Import templates from a subdirectory of a git repo:
 
     foreman-rake templates:sync repo="http://github.com/GregSutcliffe/community-templates" dirname='/subdir'
 
+### Purge
+
+This task deletes matching templates from the Foreman DB
+
+#### Rake options
+
+* prefix    => The string all templates to be purged should begin with [Community ]
+* negate    => Negate the search [false]
+* verbose   => Print extra information during the run [false]
+
+#### Examples
+
+Just purge all the templates the begin with 'Community '
+
+    foreman-rake templates:purge
+
+Purge all templates that begin with 'Oops '
+
+    foreman-rake templates:purge prefix='Oops '
+
+Purge all templates that do not begin with 'Community '
+
+    foreman-rake templates:purge negate=true
+
+## Integration with other Foreman Plugins
+
+`templates` will start processing a template by looking for a metadata entry of
+`model`. If this is found, `templates` will call `import!` on this model.
+
+That means it's possible for a plugin to define it's own handling of text and
+metadata, relevant to the plugins own interests. The `import!` method will be
+sent 3 arguments - the `name` of the template, the `text` of the template, and
+a complete copy of the `metadata`.
+
+As a trivial example for a random plugin, suppose `foreman_nosuchplugin` has
+this code:
+
+```
+module ForemanNosuchplugin
+  class SomeTemplate
+    def self.import!(name, text, metadata)
+      File.open("/tmp/#{name}",'w') {|f| f.write text }
+    end
+  end
+end
+```
+
+Assuming a template had "model: SomeTemplate" in it's metadata, this would then
+get written to a file in `/tmp`.
+
+`templates` will expect the `import!` method to return a Hash, containing:
+
+* `:status` (boolean),
+* `:diff` (text, may be nil), or
+  * `:old` and `:new` (in which case this plugin will calculate the diff)
+* :result` (text, may be nil).
+
 ## TODO
 
-* Allow user to filter to a specific subset of templates
-* Add associations by template family
 * Add a button to the UI with Deface to run the rake task
 
 ## Copyright

data/app/models/concerns/foreman_templates/provisioning_template_import.rb

@@ -0,0 +1,62 @@
+module ForemanTemplates::ProvisioningTemplateImport
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def import!(name, text, metadata)
+      # Check for snippet type
+      return import_snippet!(name, text) if metadata['snippet'] || metadata['kind'] == 'snippet'
+
+      # Get template type
+      kind = TemplateKind.find_by_name(metadata['kind'])
+      raise NoKindError unless kind
+
+      # Data
+      template = ProvisioningTemplate.where(:name => name).first_or_initialize
+      data = {
+        :template         => text,
+        :snippet          => false,
+        :template_kind_id => kind.id
+      }
+      oses = map_oses(metadata)
+
+      # Printout helpers
+      c_or_u = template.new_record? ? 'Created' : 'Updated'
+      id_string = ('id' + template.id) rescue ''
+
+      if (metadata['associate'] == 'new' && template.new_record?) || (metadata['associate'] == 'always')
+        data[:operatingsystem_ids] = oses.map(&:id)
+      end
+
+      if data[:template] != template.template
+        diff = Diffy::Diff.new(
+          template.template,
+          data[:template],
+          :include_diff_info => true
+        ).to_s(:color)
+        status  = template.update_attributes(data)
+        result  = "  #{c_or_u} Template #{id_string}:#{name}"
+        result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
+      elsif data[:operatingsystem_ids]
+        diff    = nil
+        status  = template.update_attributes(data)
+        result  = "  #{c_or_u} Template Associations #{id_string}:#{name}"
+        result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
+      else
+        diff    = nil
+        status  = true
+        result  = "  No change to Template #{id_string}:#{name}"
+      end
+      { :diff => diff, :status => status, :result => result }
+    end
+
+    def map_oses(metadata)
+      if metadata['oses']
+        metadata['oses'].map do |os|
+          Operatingsystem.all.map { |db| db.to_label =~ /^#{os}/ ? db : nil }
+        end.flatten.compact
+      else
+        []
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_templates/ptable_import.rb

@@ -0,0 +1,54 @@
+module ForemanTemplates::PtableImport
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def import!(name, text, metadata)
+      # Check for snippet type
+      return import_snippet!(name, text) if metadata['snippet']
+
+      # Data
+      ptable = Ptable.where(:name => name).first_or_initialize
+      data = { :layout => text }
+      oses = map_oses(metadata)
+
+      # Printout helpers
+      c_or_u = ptable.new_record? ? 'Created' : 'Updated'
+      id_string = ('id' + ptable.id) rescue ''
+
+      if (metadata['associate'] == 'new' && ptable.new_record?) || (metadata['associate'] == 'always')
+        data[:os_family] = oses.map(&:family).uniq.first
+      end
+
+      if data[:layout] != ptable.layout
+        diff = Diffy::Diff.new(
+          ptable.layout,
+          data[:layout],
+          :include_diff_info => true
+        ).to_s(:color)
+        status  = ptable.update_attributes(data)
+        result  = "  #{c_or_u} Ptable #{id_string}:#{name}"
+      elsif data[:os_family]
+        diff    = nil
+        status  = ptable.update_attributes(data)
+        result  = "  #{c_or_u} Ptable Associations #{id_string}:#{name}"
+        result += "\n    Operatingsystem Family:\n    - #{oses.map(&:family).uniq.first}" unless oses.empty?
+      else
+        diff    = nil
+        status  = true
+        result  = "  No change to Ptable #{id_string}:#{name}"
+      end
+      { :diff => diff, :status => status, :result => result }
+    end
+
+    # TODO: DRY this, it's copied from ProvisioningTemplateImport
+    def map_oses(metadata)
+      if metadata['oses']
+        metadata['oses'].map do |os|
+          Operatingsystem.all.map { |db| db.to_label =~ /^#{os}/ ? db : nil }
+        end.flatten.compact
+      else
+        []
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_templates/template_import.rb

@@ -0,0 +1,33 @@
+module ForemanTemplates::TemplateImport
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def import_snippet!(name, text)
+      # Data
+      snippet = self.where(:name => name).first_or_initialize
+      data = {
+        :template => text,
+        :snippet  => true
+      }
+
+      # Printout helpers
+      c_or_u = snippet.new_record? ? 'Created' : 'Updated'
+      id_string = ('id' + snippet.id) rescue ''
+
+      if data[:template] != snippet.template
+        diff = Diffy::Diff.new(
+          snippet.template,
+          data[:template],
+          :include_diff_info => true
+        ).to_s(:color)
+        status  = snippet.update_attributes(data)
+        result  = "  #{c_or_u} Snippet #{id_string}:#{name}"
+      else
+        diff    = nil
+        status  = true
+        result  = "  No change to Snippet #{id_string}:#{name}"
+      end
+      { :diff => diff, :status => status, :result => result }
+    end
+  end
+end

data/app/services/foreman_templates/template_importer.rb

@@ -0,0 +1,167 @@
+class NoKindError < Exception; end
+class MissingKindError < Exception; end
+
+module ForemanTemplates
+  class TemplateImporter
+    delegate :logger, :to => :Rails
+    attr_accessor :metadata, :name, :text
+
+    def initialize(args = {})
+      @verbose   = args[:verbose] || false
+      @associate = args[:associate] || 'new'
+      @prefix    = args[:prefix] || 'Community '
+      @dirname   = args[:dirname] || '/'
+      @filter    = args[:filter] || nil
+      @repo      = args[:repo] || 'https://github.com/theforeman/community-templates.git'
+      @negate    = args[:negate] || false
+      @branch    = args[:branch] || false
+
+      # Rake hands off strings, not booleans, and "false" is true...
+      if @verbose.is_a?(String)
+        @verbose = if @verbose == 'false'
+                     false
+                   else
+                     true
+                   end
+      end
+    end
+
+    def import!
+      # Check out the community templates to a temp location
+      @dir = Dir.mktmpdir
+
+      begin
+        gitrepo = Git.clone(@repo, @dir)
+        branch = @branch ? @branch : get_default_branch(gitrepo)
+        gitrepo.checkout(branch) if branch
+
+        return parse_files!
+      ensure
+        FileUtils.remove_entry_secure(@dir) if File.exist?(@dir)
+      end
+    end
+
+    def parse_files!
+      result_lines = []
+
+      # Build a list of ERB files to parse
+      Dir["#{@dir}#{@dirname}/**/*.erb"].each do |template|
+        text = File.read(template)
+        result_lines << 'Parsing: ' + template.gsub(/#{@dir}#{@dirname}/, '') if @verbose
+
+        metadata = parse_metadata(text)
+        metadata['associate'] = @associate
+
+        # Get the name and filter
+        filename = template.split('/').last
+        title    = filename.split('.').first
+        name     = metadata['name'] || title
+        name     = [@prefix, name].compact.join
+        next if @filter && !name.match(/#{@filter}/i)
+
+        raise MissingKindError unless metadata['kind']
+
+        begin
+          # Expects a return of { :diff, :status, :result }
+          data = if metadata['model'].present?
+                   metadata['model'].constantize.import!(name, text, metadata)
+                 else
+                   # For backwards-compat before "model" metadata was added
+                   case metadata['kind']
+                   when 'ptable'
+                     Ptable.import!(name, text, metadata)
+                   when 'job_template'
+                     # TODO: update REX templates to have `model` and delete this
+                     update_job_template(name, text)
+                   else
+                     ProvisioningTemplate.import!(name, text, metadata)
+                   end
+                 end
+
+          if data[:diff].nil? && data[:old].present? && data[:new].present?
+            data[:diff] = calculate_diff(data[:old], data[:new])
+          end
+
+          if data[:status] == true && @verbose
+            result_lines << data[:result]
+            result_lines << data[:diff] unless data[:diff].nil?
+          elsif data[:status] == false
+            result_lines << "Template \"#{name}\": #{data[:result]}"
+          end
+        rescue MissingKindError
+          result_lines << "  Skipping: '#{name}' - No template kind or model detected"
+          next
+        rescue NoKindError
+          result_lines << "  Skipping: '#{name}' - Unknown template kind '#{metadata['kind']}'"
+          next
+        rescue NameError
+          result_lines << "  Skipping: '#{name}' - Unknown template model '#{metadata['model']}'"
+          next
+        end
+      end
+      result_lines
+    end
+
+    def calculate_diff(old, new)
+      if old != new
+        Diffy::Diff.new(old, new, :include_diff_info => true).to_s(:color)
+      else
+        nil
+      end
+    end
+
+    def get_default_branch(repo)
+      branch_names = repo.branches.map(&:name).uniq
+
+      # Always use develop on Foreman-nightly, if present, or else relevant stable branch
+      target = SETTINGS[:version].tag == 'develop' ? 'develop' : "#{SETTINGS[:version].short}-stable"
+      return target if branch_names.include?(target)
+
+      # stay on default branch as fallback
+      nil
+    end
+
+    def parse_metadata(text)
+      # Pull out the first erb comment only - /m is for a multiline regex
+      extracted = text.match(/<%\#[\t a-z0-9=:]*(.+?).-?%>/m)
+      extracted.nil? ? {} : YAML.load(extracted[1])
+    end
+
+    def update_job_template(name, text)
+      file = name.gsub(/^#{@prefix}/, '')
+      puts 'Deprecation warning: JobTemplate support is moving to the Remote Execution plugin'
+      puts "- please add 'model: JobTemplate' to the metadata in '#{file}' to call the right method"
+
+      return {
+        :status => false,
+        :result => 'Skipping job template import, remote execution plugin is not installed.'
+      } unless defined?(JobTemplate)
+      template = JobTemplate.import(
+        text.sub(/^name: .*$/, "name: #{name}"),
+        :update => true
+      )
+
+      c_or_u = template.new_record? ? 'Created' : 'Updated'
+      id_string = ('id' + template.id) rescue ''
+
+      if template.template != template.template_was
+        diff = Diffy::Diff.new(
+          template.template_was,
+          template.template,
+          :include_diff_info => true
+        ).to_s(:color)
+      end
+
+      result = "  #{c_or_u} Template #{id_string}:#{name}"
+      { :diff => diff, :status => template.save, :result => result }
+    end
+
+    def purge!
+      clause = "name #{@negate ? 'NOT ' : ''}LIKE ?"
+      ProvisioningTemplate.where(clause, "#{@prefix}%").each do |template|
+        puts template if @verbose
+        template.destroy
+      end
+    end # :purge
+  end
+end

data/lib/foreman_templates/engine.rb

@@ -1,20 +1,28 @@
+require 'fileutils'
+require 'yaml'
 require 'diffy'
 require 'git'
 
 module ForemanTemplates
-  #Inherit from the Rails module of the parent app (Foreman), not the plugin.
-  #Thus, inhereits from ::Rails::Engine and not from Rails::Engine
+  # Inherit from the Rails module of the parent app (Foreman), not the plugin.
+  # Thus, inhereits from ::Rails::Engine and not from Rails::Engine
   class Engine < ::Rails::Engine
+    engine_name 'foreman_templates'
 
-    initializer 'foreman_templates.register_plugin', :after=> :finisher_hook do |app|
+    initializer 'foreman_templates.register_plugin', :before => :finisher_hook do
       Foreman::Plugin.register :foreman_templates do
-        requires_foreman '>= 1.9'
+        requires_foreman '>= 1.12'
       end
     end
 
-    rake_tasks do
-      load "templates.rake"
+    config.to_prepare do
+      begin
+        Template.send(:include, ForemanTemplates::TemplateImport)
+        Ptable.send(:include, ForemanTemplates::PtableImport)
+        ProvisioningTemplate.send(:include, ForemanTemplates::ProvisioningTemplateImport)
+      rescue => e
+        puts "#{ForemanTemplates::ENGINE_NAME}: skipping engine hook (#{e})"
+      end
     end
-
   end
 end

data/lib/foreman_templates/version.rb

@@ -1,3 +1,3 @@
 module ForemanTemplates
-    VERSION = "2.1.0"
+  VERSION = '3.0.0'.freeze
 end

data/lib/tasks/foreman_templates_tasks.rake

@@ -0,0 +1,75 @@
+# Tasks
+namespace :templates do
+  desc 'Synchronize templates from a git repo'
+  task :sync => :environment do
+    # Available options:
+    #* verbose   => Print extra information during the run [false]
+    #* repo      => Sync templates from a different Git repo [https://github.com/theforeman/community-templates]
+    #* branch    => Branch in Git repo [default branch]
+    #* prefix    => The string all imported templates should begin with [Community ]
+    #* dirname   => The directory within the git tree containing the templates [/]
+    #* filter    => Import names matching this regex (case-insensitive; snippets are not filtered)
+    #* associate => Associate to OS, always, new or never  [new]
+
+    results = ForemanTemplates::TemplateImporter.new({
+      verbose:   ENV['verbose'],
+      repo:      ENV['repo'],
+      branch:    ENV['branch'],
+      prefix:    ENV['prefix'],
+      dirname:   ENV['dirname'],
+      filter:    ENV['filter'],
+      associate: ENV['associate'],
+    }).import!
+
+    puts results.join("\n")
+  end
+
+  desc 'Purge unwanted templates from foreman'
+  task :purge => :environment do
+    ForemanTemplates::TemplateImporter.new({
+      #* negate  => negate query [false]
+      #* prefix  => The string all templates to purge should ( or not ) begin with [Community ]
+      #* verbose => Print extra information during the run [false]
+      negate:  ENV['negate'],
+      prefix:  ENV['prefix'],
+      verbose: ENV['verbose'],
+    }).purge!
+  end
+
+end
+
+# Tests
+namespace :test do
+  desc "Test ForemanTemplates"
+  Rake::TestTask.new(:foreman_templates) do |t|
+    test_dir = File.join(File.dirname(__FILE__), '../..', 'test')
+    t.libs << ['test', test_dir]
+    t.pattern = "#{test_dir}/**/*_test.rb"
+    t.verbose = true
+    t.warning = false
+  end
+end
+
+namespace :foreman_templates do
+  task :rubocop do
+    begin
+      require 'rubocop/rake_task'
+      RuboCop::RakeTask.new(:rubocop_foreman_templates) do |task|
+        task.patterns = ["#{ForemanTemplates::Engine.root}/app/**/*.rb",
+                         "#{ForemanTemplates::Engine.root}/lib/**/*.rb",
+                         "#{ForemanTemplates::Engine.root}/test/**/*.rb"]
+      end
+    rescue
+      puts 'Rubocop not loaded.'
+    end
+
+    Rake::Task['rubocop_foreman_templates'].invoke
+  end
+end
+
+Rake::Task[:test].enhance ['test:foreman_templates']
+
+load 'tasks/jenkins.rake'
+if Rake::Task.task_defined?(:'jenkins:unit')
+  Rake::Task['jenkins:unit'].enhance ['test:foreman_templates', 'foreman_templates:rubocop']
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_templates
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Greg Sutcliffe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diffy
@@ -49,10 +49,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/models/concerns/foreman_templates/provisioning_template_import.rb
+- app/models/concerns/foreman_templates/ptable_import.rb
+- app/models/concerns/foreman_templates/template_import.rb
+- app/services/foreman_templates/template_importer.rb
 - lib/foreman_templates.rb
 - lib/foreman_templates/engine.rb
 - lib/foreman_templates/version.rb
-- lib/templates.rake
+- lib/tasks/foreman_templates_tasks.rake
 homepage: http://github.com/theforeman/foreman_templates
 licenses:
 - GPL-3

data/lib/templates.rake

@@ -1,234 +0,0 @@
-require 'fileutils'
-require 'yaml'
-require 'diffy'
-require 'git'
-
-class NoKindError < Exception ; end
-
-def db_oses
-  @db_oses || Operatingsystem.all
-end
-
-def metadata(text)
-  # Pull out the first erb comment only - /m is for a multiline regex
-  extracted = text.match(/<%\#(.+?).-?%>/m)
-  extracted == nil ? {} : YAML.load(extracted[1])
-end
-
-def map_oses
-  oses = if @metadata['oses']
-           @metadata['oses'].map do |os|
-             db_oses.map { |db| db.to_label =~ /^#{os}/ ? db : nil}
-           end.flatten.compact
-         else
-           []
-         end
-  return oses
-end
-
-def update_job_template
-  return {:status => false, :result => 'Skipping job template import, remote execution plugin is not installed.'} unless defined?(JobTemplate)
-  template = JobTemplate.import(@text.sub(/^name: .*$/, "name: #{@name}"), :update => true)
-
-  string = template.new_record? ? 'Created' : 'Updated'
-
-  if template.template != template.template_was
-    diff = Diffy::Diff.new(template.template_was, template.template, :include_diff_info => true).to_s(:color)
-  end
-
-  result = "  #{string} Template #{ 'id' + template.id rescue ''}:#{@name}"
-
-  {:diff => diff, :status => template.save, :result => result}
-end
-
-def update_template
-  # Get template type
-  unless kind = TemplateKind.find_by_name(@metadata['kind'])
-    raise NoKindError
-  end
-
-  db_template = ProvisioningTemplate.where(:name => @name).first_or_initialize
-  data = {
-    :template         => @text,
-    :snippet          => false,
-    :template_kind_id => kind.id
-  }
-  string = db_template.new_record? ? "Created" : "Updated"
-
-  oses = map_oses
-  if (@associate == 'new' and db_template.new_record?) or (@associate == 'always')
-    data[:operatingsystem_ids] = oses.map(&:id)
-  end
-
-  if @text != db_template.template
-    diff    = Diffy::Diff.new(db_template.template, @text, :include_diff_info => true).to_s(:color)
-    status  = db_template.update_attributes(data)
-    result  = "  #{string} Template #{ 'id' + db_template.id rescue ''}:#{@name}"
-    result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" if !oses.empty?
-  elsif data[:operatingsystem_ids]
-    diff    = nil
-    status  = db_template.update_attributes(data)
-    result  = "  #{string} Template Associations #{ 'id' + db_template.id rescue ''}:#{@name}"
-    result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" if !oses.empty?
-  else
-    diff    = nil
-    status  = true
-    result  = "  No change to Template #{ ( 'id' + db_template.id ) rescue ''}:#{@name}"
-  end
-  { :diff => diff, :status => status, :result => result }
-end
-
-def update_ptable
-  db_ptable = Ptable.where(:name => @name).first_or_initialize
-  data = { :layout => @text }
-  string = db_ptable.new_record? ? "Created" : "Updated"
-
-  oses = map_oses
-  if (@associate == 'new' and db_ptable.new_record?) or (@associate == 'always')
-    data[:os_family] = oses.map(&:family).uniq.first
-  end
-
-  if @text != db_ptable.layout
-    diff    = Diffy::Diff.new(db_ptable.layout, @text, :include_diff_info => true).to_s(:color)
-    status  = db_ptable.update_attributes(data)
-    result  = "  #{string} Ptable #{ ( 'id' + db_ptable.id ) rescue ''}:#{@name}"
-  elsif data[:os_family]
-    diff    = nil
-    status  = db_ptable.update_attributes(data)
-    result  = "  #{string} Ptable Associations #{ ( 'id' + db_ptable.id ) rescue ''}:#{@name}"
-    result += "\n    Operatingsystem Family:\n    - #{oses.map(&:family).uniq.first}" if !oses.empty?
-  else
-    diff    = nil
-    status  = true
-    result  = "  No change to Ptable #{ ( 'id' + db_ptable.id ) rescue ''}:#{@name}"
-  end
-  { :diff => diff, :status => status, :result => result }
-end
-
-def update_snippet
-  db_snippet = ProvisioningTemplate.where(:name => @name).first_or_initialize
-  data = {
-    :template => @text,
-    :snippet => true
-  }
-  string = db_snippet.new_record? ? "Created" : "Updated"
-
-  if @text != db_snippet.template
-    diff    = Diffy::Diff.new(db_snippet.template, @text, :include_diff_info => true).to_s(:color)
-    status  = db_snippet.update_attributes(data)
-    result  = "  #{string} Snippet #{ ('id' + db_snippet.id) rescue ''}:#{@name}"
-  else
-    diff    = nil
-    status  = true
-    result  = "  No change to Snippet #{ 'id' + db_snippet.id rescue ''}:#{@name}"
-  end
-  { :diff => diff, :status => status, :result => result }
-end
-
-def get_default_branch(repo)
-  branch_names = repo.branches.map(&:name).uniq
-
-  # Always use develop on Foreman-nightly, if present, or else relevant stable branch
-  target = SETTINGS[:version].tag == 'develop' ? 'develop' : "#{SETTINGS[:version].short}-stable"
-  return target if branch_names.include?(target)
-
-  # stay on default branch as fallback
-  return nil
-end
-
-desc <<-END_DESC
-Synchronize templates from a git repo
-END_DESC
-namespace :templates do
-  task :sync => :environment do
-    # Available options:
-    #* verbose   => Print extra information during the run [false]
-    #* repo      => Sync templates from a different Git repo [https://github.com/theforeman/community-templates]
-    #* branch    => Branch in Git repo [default branch]
-    #* prefix    => The string all imported templates should begin with [Community ]
-    #* dirname   => The directory within the git tree containing the templates [/]
-    #* filter    => Import names matching this regex (case-insensitive; snippets are not filtered)
-    #* associate => Associate to OS, always, new or never  [new]
-
-    @verbose   = ( ENV['verbose'] and ENV['verbose'] != 'false' ) ? true : false
-    @associate = ENV['associate'] ? ENV['associate'] : 'new'
-    prefix     = ENV['prefix'] ? ENV['prefix'] : 'Community '
-    dirname    = ENV['dirname'] ? ENV['dirname'] : '/'
-    filter     = ENV['filter'] ? ENV['filter'] : nil
-    repo       = ENV['repo'] ? ENV['repo'] : "https://github.com/theforeman/community-templates.git"
-
-    # Check out the community templates to a temp location
-    dir = Dir.mktmpdir
-    begin
-      gitrepo = Git.clone(repo, dir)
-      branch = ENV['branch'] ? ENV['branch'] : get_default_branch(gitrepo)
-      gitrepo.checkout(branch) if branch
-
-      # Build a list of ERB files to parse
-      Dir["#{dir}#{dirname}/**/*.erb"].each do |template|
-        @text = File.read(template)
-        puts "Parsing: " + template.gsub(/#{dir}#{dirname}/,'') if @verbose
-
-        @metadata = metadata(@text)
-
-        # Get the name and filter
-        filename = template.split('/').last
-        title    = filename.split('.').first
-        @name    = @metadata['name'] || title
-        @name    = [prefix, @name].compact.join()
-        next if filter and not @name.match(/#{filter}/i)
-
-        unless @metadata['kind']
-          puts "  Error: Must specify template kind"
-          next
-        end
-
-        begin
-          case @metadata['kind']
-          when 'ptable'
-            data = update_ptable
-          when 'snippet'
-            data = update_snippet
-          when 'job_template'
-            data = update_job_template
-          else
-            data = update_template
-          end
-
-          if data[:status] == true && @verbose
-            puts data[:result]
-            puts data[:diff]
-          elsif data[:status] == false
-            puts "Error with #{@name}"
-            puts data[:result]
-          end
-        rescue NoKindError
-          puts "  Error: Unknown template type '#{@metadata['kind']}'"
-          next
-        end
-      end
-    ensure
-      FileUtils.remove_entry_secure(dir) if File.exist?(dir)
-    end
-
-  end
-end
-
-# Setup Tests
-namespace :test do
-  desc "Test ForemanTemplates plugin"
-  Rake::TestTask.new(:templates) do |t|
-    test_dir = File.join(File.dirname(__FILE__), '..', 'test')
-    t.libs << ["test",test_dir]
-    t.pattern = "#{test_dir}/**/*_test.rb"
-  end
-end
-Rake::Task[:test].enhance do
-  Rake::Task['test:templates'].invoke
-end
-load 'tasks/jenkins.rake'
-if Rake::Task.task_defined?('jenkins:unit')
-  Rake::Task["jenkins:unit"].enhance do
-    Rake::Task['test:templates'].invoke
-  end
-end