cfhighlander 0.2.1 → 0.3.0.alpha.1528936037

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2db06592f56122df80f8ad27fb1bc67f8920b47a623dbd8f6343f265998efa60
-  data.tar.gz: fcf86ec795983ec1a73d565e49685314b88dd0bc2cc22174fa1bb41841dfbaa2
+  metadata.gz: 16a118e3b352f9d1a3c87f8f2703a990a362c3a46d419f9c8c3a6db2bb6c8ded
+  data.tar.gz: 98ce45d749072b5614d9541a43474ffc98eca86983a0d4bb3a38f0967f8b7701
 SHA512:
-  metadata.gz: 6a138171e3a15cee57f1ac71a55f8c5bce7d1db15560fe5ee4c11810c0e496e81e838350754375b377f9ffca562fb75abe5b897e1a3ae4ae36af7f5ec518ecea
-  data.tar.gz: 8a2c7a47987d4500a074346835c65093b3e1dbbdcfbb1d7800ea3fe7d749c3ba0c3fb6e95d0fd4d89b8fe5b530d00fc9f6f57ded2b0fe863ff721319bd51f623
+  metadata.gz: efc14c3f56f84ff302a049a82e3e619a150c1bc5825345ed859899412ad06fa8bc7edc385d908fc11a381e197eaf65451ff6ba6156c99fabc49f2f8f3bf52153
+  data.tar.gz: e139dab1ac33468f77380ff9fec1e8646fa526db0e48bee5b2be4181db2d09edebdc59e05c1bfec48ff79a4bb56aa0d61cbd690b1fb9283f2f9a58f5f45349c8

data/README.md

@@ -1,24 +1,27 @@
 [![Build Status](https://travis-ci.com/theonestack/cfhighlander.svg?branch=develop)](https://travis-ci.com/theonestack/cfhighlander)
 
-# Highlander
+# Cfhighlander
 
-Highlander is DSL processor that enables composition and orchestration of Amazon CloudFormation templates 
+Cfhighlander is DSL processor that enables composition and orchestration of Amazon CloudFormation templates 
 written using [CfnDsl](https://github.com/cfndsl/cfndsl) in an abstract way. It tries to tackle problem of merging multiple templates into master
 template in an elegant way, so higher degree of template reuse can be achieved. It does so by formalising commonly
-used patterns via DSL statements. For an example, passing output of one stack into other stack is achieved using 
-`OutputParam` highlander DSL statement, rather than wiring this parameters manually in cfndsl templates. For this example to 
+used cfndsl template composition patterns via DSL statements. For an example, passing output of one stack into other stack is done
+automatically if parameter and output names are the same, 
+rather than wiring them manually in 'master' cfndsl template. For this example to 
 work, parent component will have to pull in both component rendering output values, and component pulling them in
-as parameters. It also enables it's user to build component library, where components can be distributed to s3, and 
-consequentially references to them resolved. 
+as parameters. Cfhighlander allows for greater reuse of component templates by allowing references to templates
+via git urls, and s3 urls. [Theonestack](https://github.com/theonestack) has several prebuilt component templates to use,
+with repositories from this org being one of the default sources for searching component templates.
 
-Highlander DSL produces CloudFormation templates in 3 phases
+Highlander DSL produces CloudFormation templates in 4 phases
 
 - Processing referenced component's configuration and resolving configuration exports
+- Wiring parameters from components to their inner components
 - Producing [CfnDsl](https://github.com/cfndsl/cfndsl) templates for all components and subcomponents as intermediary
   step
 - Producing resulting CloudFormation templates using configuration and templates generated in two previous phases.
 
-Each phase above is executable as stand-alone through CLI, making development of Highlander templates easier by enabling
+Each phase (aside from parameter wiring) above is executable as stand-alone through CLI, making development of Highlander templates easier by enabling
 debugging of produced configuration and cfndsl templates. 
 
 
@@ -41,14 +44,14 @@ this file defines map used within component itself
 **Component** is basic building block of highlander systems. Components have following roles
 
 - Define (include) other components
-- Define how their parameters are wired with other components (sibling and outer components)
+- Provide values for their inner component parameters
 - Define how their configuration affects other components
 - Define sources of their inner components
 - Define publish location for both component source code and compiled CloudFormation templates
 - Define cfndsl template used for building CloudFormation resources
 
 
-**Outer component** is component that defines other component via higlander dsl `Component` statement. Defined component
+**Outer component** is component that defines other component via cfhighlander dsl `Component` statement. Defined component
 is called **inner component**. Components defined under same outer component are **sibling components**
 
 ## Usage
@@ -58,30 +61,30 @@ For both ways, highlander is distributed as ruby gem
 
 
 ```bash
-$ gem install highlander
-$ highlander help
-highlander commands:
-  highlander cfcompile component[@version] -f, --format=FORMAT   # Compile Highlander component to CloudFormation templates
-  highlander cfpublish component[@version] -f, --format=FORMAT   # Publish CloudFormation template for component, and it' referenced subcomponents
-  highlander configcompile component[@version]                   # Compile Highlander components configuration
-  highlander dslcompile component[@version] -f, --format=FORMAT  # Compile Highlander component configuration and create cfndsl templates
-  highlander help [COMMAND]                                      # Describe available commands or one specific command
-  highlander publish component[@version] [-v published_version]  # Publish CloudFormation template for component, and it' referenced subcomponents
+$ gem install cfhighlander
+$ cfhighlander help
+cfhighlander commands:
+  cfhighlander cfcompile component[@version] -f, --format=FORMAT   # Compile Highlander component to CloudFormation templates
+  cfhighlander cfpublish component[@version] -f, --format=FORMAT   # Publish CloudFormation template for component, and it' referenced subcomponents
+  cfhighlander configcompile component[@version]                   # Compile Highlander components configuration
+  cfhighlander dslcompile component[@version] -f, --format=FORMAT  # Compile Highlander component configuration and create cfndsl templates
+  cfhighlander help [COMMAND]                                      # Describe available commands or one specific command
+  cfhighlander publish component[@version] [-v published_version]  # Publish CloudFormation template for component, and it' referenced subcomponents
 
 ```
 ### Working directory
 
 All templates and configuration generated are placed in `$WORKDIR/out` directory. Optionally, you can alter working directory
-via `HIGHLANDER_WORKDIR` environment variable. 
+via `CFHIGHLANDER_WORKDIR` environment variable. 
 
 ### Commands
 
 To get full list of options for any of cli commands use `highlander help command_name` syntax
 
 ```bash
-$ highlander help publish
+$ cfhighlander help publish
 Usage:
-  highlander publish component[@version] [-v published_version]
+  cfhighlander publish component[@version] [-v published_version]
 
 Options:
       [--dstbucket=DSTBUCKET]  # Distribution S3 bucket
@@ -89,13 +92,13 @@ Options:
   -v, [--version=VERSION]      # Distribution component version, defaults to latest
 
 Publish CloudFormation template for component,
-            and it' referenced subcomponents
+            and it's referenced subcomponents
 
 ```
 
 #### Silent mode
 
-Highlander DSL processor has built-in support for packaging and deploying AWS Lambda functions. Some of these lambda
+Cfhighlander DSL processor has built-in support for packaging and deploying AWS Lambda functions. Some of these lambda
 functions may require shell command to be executed (e.g. pulling library dependencies) prior their packaging in ZIP archive format.
 Such commands are potential security risk, as they allow execution of arbitrary code, so for this reason user agreement is required
 e.g:
@@ -136,15 +139,14 @@ cfndsl templates. Check component configuration section for more details.
 
 #### dslcompile
 
-*dslcompile* will produce intermediary cfndsl templates. This is useful for debugging highlander components
+*dslcompile* will produce intermediary cfndsl templates. This is useful for debugging cfhighlander components
 
 #### publish
 
-*publish* command publishes highlander components source code to s3 location (compared to *cfpublish* which is publishing
+*publish* command publishes cfhighlander components source code to s3 location (compared to *cfpublish* which is publishing
 compiled cloudformation templates). Same CLI / DSL options apply as for *cfpublish* command. Version defaults to `latest`
 
 
-
 ## Component configuration
 
 There are 4 levels of component configuration
@@ -169,7 +171,7 @@ This configuration level overrides component's own config file.
 - Outer component explicit configuration. You can pass `config` named parameter to `Component` statement, such as
 
 ```ruby
-HighlanderComponent do
+CfhighlanderTemplate do
 
 # ...
 # some dsl code
@@ -250,6 +252,47 @@ included via Ruby `require` function in compiled Cfndsl template.
 
 ## Component DSL
 
+### Inner components or subcomponents
+
+Inner components or subcomponents are defined via `Component` DSL statement
+
+```ruby
+CfhighlanderTemplate do
+  
+  # Example1 : Include component by template name only
+  Component 'vpc' 
+  
+  # Example2 : Include component by template name, version and give it a name
+  Component template: 'ecs@master.snapshot'
+  
+end
+
+```
+
+**Conditional components** - If you want to add top level paramater as feature toggle for one of the inner
+components, just mark it as conditional, using `conditional:` named parameter. In addition to this, default
+value for feature toggle can be supplied using `enabled:` named parameter
+
+
+```ruby
+
+# Include vpc and 2 ecs clusters with feature flags
+CfhighlanderTemplate do
+  
+  # vpc component
+  Component 'vpc' 
+  
+  # Ecs Cluster 1 has feature toggle, enabled by default
+  Component name: 'ecs1', template: 'ecs', conditional: true
+  
+  # Ecs Cluster 2 has feature toggle, and is explicitly disabled by default
+  Component name: 'ec2', template: 'ecs', conditional: true, enabled: false
+   
+end
+
+```
+
+
 
 ### Parameters
 
@@ -257,7 +300,7 @@ Parameters block is used to define CloudFormation template parameters, and metad
 are wired with outer or sibling components. 
 
 ```ruby
-HighlanderComponent do
+CfhighlanderTemplate do
   Parameters do
     ##
     ##  parameter definitions here
@@ -270,81 +313,117 @@ Parameter block supports following parameters
 
 #### ComponentParam
 
-`ComponentParam` - Component parameter takes name and default value. It defines component parameter
-that is not auto-wired in any way with outer component. This parameter will either use default value, or value
-explicitly passed from outer component. 
+`ComponentParam` - Component parameter exposes parameter to be wired from outer component. Cfhighlander's
+autowiring mechanism will try and find any stack outputs from other components defined by outer components with name 
+matching. If there is no explicit value provided, or autowired from outputs, parameter will be propagated to outer component.
+
+Propagated parameter will be prefixed with component name **if it is not defined as global parameter**. Otherwise, 
+parameter name is kept in full. 
+
+Example below demonstrates 3 different ways of providing parameter values from outer to inner component. 
+
+- Provide value explicitly
+- Provide value explicitly as output of another component     
+- Autowire value from output of another component with the same name
+- Propagate parameter to outer component 
 
 ```ruby
 
-# Inner Component
-HighlanderComponent do
+# Inner Component 1
+CfhighlanderTemplate do
   Name 's3'
   Parameters do
      ComponentParam 'BucketName','highlander.example.com.au'
+     ComponentParam 'BucketName2',''
+     ComponentParam 'BucketName3',''
+     ComponentParam 'BucketName4','', isGlobal: false # default value is false
+     ComponentParam 'BucketName5','', isGlobal: true
   end
+
 end
+
 ```
 
 ```ruby
-# Outer component
-HighlanderComponent do
-  # instantiate inner component with name and template
-  Component template:'s3',
-            name:'s3', 
-            parameters:{'BucketName' => 'outer.example.com.au'}
+# Inner Component 2
+CfhighlanderTemplate do
+  Name 'nameproducer'
+
+  # has output 'bucket name defined in cfdnsl
 end
-```
 
-#### StackParam
 
-`StackParam` - Stack parameter bubbles up to it's outer component. Outer component will either define top level parameter
-with same name as inner component parameter (if parameter is defined as global), or it will be prefixed with inner component name.
+# -- contents of cfndsl 
+CloudFormation do
 
+    Condition 'AlwaysFalse', FnEquals('true','false')
+    S3_Bucket :resourcetovalidateproperly do
+      Condition 'AlwaysFalse'
+    end
 
-```ruby
-# Outer component
-HighlanderComponent do
-  Component template:'s3',name:'s3' 
+    Output('BucketName') do
+        Value('highlanderbucketautowired.example.com.au')
+    end
 end
+
+
 ```
 
 ```ruby
-# Inner component
-HighlanderComponent do
-  Name 's3'
-  Parameters do
-    StackParam 'EnvironmentName','dev', isGlobal:true
-    StackParam 'BucketName','highlander.example.com.au', isGlobal:false
-  end
+# Outer component
+CfhighlanderTemplate do
+    Component 'nameproducer'
+    Component 's3' do
+      parameter name: 'BucketName2', value: 'nameproducer.BucketName'
+      parameter name: 'BucketName3', value: 'mybucket.example.cfhighlander.org'
+    end
 end
+
 ```
 
 
-Example above translates to following cfndsl template in outer component
+Example above translates to following wiring of parameters in cfndsl template
 ```ruby
 CloudFormation do
 
-    Parameter('EnvironmentName') do
-    Type 'String'
-    Default ''
-    end
-
-    Parameter('s3BucketName') do
-    Type 'String'
-    Default 'highlander.example.com.au'
+     # Parameter that was propagated
+    Parameter('s3BucketName4') do
+      Type 'String'
+      Default ''
+      NoEcho false
     end
-  
-    CloudFormation_Stack('s3') do
-      TemplateURL 'https://distributionbucket/dist/latest/s3.yaml'
-      Parameters ({
-      
-        'EnvironmentName' => Ref('EnvironmentName'),
-      
-        'BucketName' => Ref('s3BucketName'),
-      
-      })
+    
+    Parameter('BucketName5') do
+      Type 'String'
+      Default ''
+      NoEcho false
     end
+
+   CloudFormation_Stack('s3') do
+       TemplateURL './s3.compiled.yaml'
+       Parameters ({
+       
+          # Paramater that was auto-wired
+           'BucketName' => {"Fn::GetAtt":["nameproducer","Outputs.BucketName"]},
+       
+          # Parameter that was explicitly wired as output param from another component
+           'BucketName2' => {"Fn::GetAtt":["nameproducer","Outputs.BucketName"]},
+       
+          # Paramater that was explicitly provided
+           'BucketName3' => 'mybucket.example.cfhighlander.org',
+       
+          # Reference to parameter that was propagated. isGlobal: false when defining
+          # parameter, so parameter name is prefixed with component name 
+           'BucketName4' => {"Ref":"s3BucketName4"},
+          
+          # Reference to parameter that was propagated. isGlobal: true when defining
+          # parameter, so parameter name is not prefixed, but rather propagated as-is
+          'BucketName5' => {"Ref":"BucketName5"},
+       
+       })
+   end
 end
+
 ```
 
 
@@ -358,7 +437,7 @@ This DSL statements takes a full body, as Mapping name, Map key, and value key n
  
  ```ruby
 # Inner component
-HighlanderComponent do
+CfhighlanderTemplate do
   Name 's3'
   Parameters do
     MappingParam 'BucketName' do
@@ -370,17 +449,13 @@ end
  ```
 
 
-#### OutputParam
-
-TBD
-
 ### DependsOn
 
 `DependsOn` - this will include any globally exported libraries from given 
 template. E.g.
 
  ```ruby
-HighlanderComponent do
+CfhighlanderTemplate do
   Name 's3'
   DependsOn 'vpc@1.0.3'
 end
@@ -398,14 +473,56 @@ so extension methods can be consumed within cfndsl template.
 #### Referencing
 
 
-## Finding and loading components
+## Finding templates and creating components
+
+
+Templates are located by default in following locations
+
+- `$WD`
+- `$WD/$componentname`
+- `$WD/components/$componentname`
+- `~/.cfhighlander/components/componentname/componentversion`
+- `https://github.com/cfhighlander/theonestack/hl-component-$componentname` on `master` branch
+
+Location of component templates can be given as git/github repo:
+
+```ruby
+
+CfhighlanderTemplate do
+
+      # pulls directly from master branch of https://github.com/theonestack/hl-component-vpc
+      Component name: 'vpc0', template: 'vpc'
+    
+      # specify branch github.com: or github: work. You specify branch with hash
+      Component name: 'vpc1', template: 'github:theonestack/hl-component-vpc#master'
+    
+      # you can use git over ssh
+      # Component name: 'vpc2', template: 'git:git@github.com:theonestack/hl-component-vpc.git'
+    
+      # use git over https
+      Component name: 'vpc3', template: 'git:https://github.com/theonestack/hl-component-sns.git'
+    
+      # specify .snapshot to always clone fresh copy
+      Component name: 'vpc4', template: 'git:https://github.com/theonestack/hl-component-sns.git#master.snapshot'
+    
+      # by default, if not found locally, highlander will search for https://github.com/theonestack/component-$componentname
+      # in v${version} branch (or tag for that matter)
+      Component name: 'vpc5', template: 'vpc@1.0.4'
+
+end
+
+```
+
 
 ## Rendering CloudFormation templates
 
 
+```bash
+$ cfhighlander cfcompile [component] [-v distributedversion]
+```
 
 ## Global Extensions
 
 Any extensions placed within `cfndsl_ext` folder will be 
 available in cfndsl templates of all components. Any extensions placed within `hl_ext` folder are 
-available in highlander templates of all components. 
+available in cfhighlander templates of all components. 

data/bin/cfhighlander

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
 
-require_relative('./highlander')
+require_relative('./cfhighlander')

data/bin/{highlander.rb → cfhighlander.rb}

@@ -9,10 +9,10 @@
 
 require 'thor'
 require 'rubygems'
-require_relative '../lib//highlander.compiler'
-require_relative '../lib/highlander.factory'
-require_relative '../lib/highlander.publisher'
-require_relative '../lib/highlander.validator'
+require_relative '../lib/cfhighlander.compiler'
+require_relative '../lib/cfhighlander.factory'
+require_relative '../lib/cfhighlander.publisher'
+require_relative '../lib/cfhighlander.validator'
 
 class HighlanderCli < Thor
 
@@ -22,15 +22,15 @@ class HighlanderCli < Thor
 
   desc 'configcompile component[@version]', 'Compile Highlander components configuration'
 
-  def configcompile(component_name)
+  def configcompile(template_name)
 
     # find and load component
-    component_loader = Highlander::Factory::ComponentFactory.new
-    component = component_loader.findComponent(component_name)
+    component_loader = Cfhighlander::Factory::ComponentFactory.new
+    component = component_loader.loadComponentFromTemplate(template_name)
     component.load
 
     # compile cfndsl template
-    component_compiler = Highlander::Compiler::ComponentCompiler.new(component)
+    component_compiler = Cfhighlander::Compiler::ComponentCompiler.new(component)
     component_compiler.writeConfig(true)
   end
 
@@ -50,7 +50,7 @@ class HighlanderCli < Thor
     component = build_component(options, component_name)
 
     # compile cfndsl template
-    component_compiler = Highlander::Compiler::ComponentCompiler.new(component)
+    component_compiler = Cfhighlander::Compiler::ComponentCompiler.new(component)
     component_compiler.silent_mode = options[:quiet]
     out_format = options[:format]
     component_compiler.compileCfnDsl out_format
@@ -71,16 +71,27 @@ class HighlanderCli < Thor
   method_option :quiet, :type => :boolean, :default => false, :aliases => '-q',
       :desc => 'Silently agree on user prompts (e.g. Package lambda command)'
 
-  def cfcompile(component_name)
+  def cfcompile(component_name = nil)
+
+    if component_name.nil?
+      candidates = Dir["*.cfhighlander.rb"]
+      if candidates.size == 0
+        self.help('cfcompile')
+        exit -1
+      else
+        component_name = candidates[0].gsub('.cfhighlander.rb','')
+      end
+    end
+
     component = build_component(options, component_name)
 
     # compile cloud formation
-    component_compiler = Highlander::Compiler::ComponentCompiler.new(component)
+    component_compiler = Cfhighlander::Compiler::ComponentCompiler.new(component)
     component_compiler.silent_mode = options[:quiet]
     out_format = options[:format]
     component_compiler.compileCloudFormation out_format
     if options[:validate]
-      component_validator = Highlander::Cloudformation::Validator.new(component)
+      component_validator = Cfhighlander::Cloudformation::Validator.new(component)
       component_validator.validate(component_compiler.cfn_template_paths, out_format)
     end
     component_compiler
@@ -103,7 +114,7 @@ class HighlanderCli < Thor
 
   def cfpublish(component_name)
     compiler = cfcompile(component_name)
-    publisher = Highlander::Publisher::Component.new(compiler.component, false)
+    publisher = Cfhighlander::Publisher::ComponentPublisher.new(compiler.component, false)
     publisher.publishFiles(compiler.cfn_template_paths + compiler.lambda_src_paths)
   end
 
@@ -117,37 +128,35 @@ class HighlanderCli < Thor
   method_option :version, :type => :string, :required => false, :default => nil, :aliases => '-v',
       :desc => 'Distribution component version, defaults to latest'
 
-  def publish(component_name)
+  def publish(template_name)
     component_version = options[:version]
     distribution_bucket = options[:dstbucket]
     distribution_prefix = options[:dstprefix]
 
     # find and load component
-    component_loader = Highlander::Factory::ComponentFactory.new
-    component = component_loader.findComponent(component_name)
+    component_loader = Cfhighlander::Factory::ComponentFactory.new
+    component = component_loader.loadComponentFromTemplate(template_name)
     component.version = component_version
     component.distribution_bucket = distribution_bucket unless distribution_bucket.nil?
     component.distribution_prefix = distribution_prefix unless distribution_prefix.nil?
     component.load
 
-    publisher = Highlander::Publisher::Component.new(component, true)
+    publisher = Cfhighlander::Publisher::ComponentPublisher.new(component, true)
     publisher.publishComponent
   end
 
 end
 
 # build component from passed cli options
-def build_component(options, component_name)
-  if ENV['HIGHLANDER_WORKDIR'].nil?
-    ENV['HIGHLANDER_WORKDIR'] = Dir.pwd
-  end
+def build_component(options, template_name)
+
   component_version = options[:version]
   distribution_bucket = options[:dstbucket]
   distribution_prefix = options[:dstprefix]
 
   # find and load component
-  component_loader = Highlander::Factory::ComponentFactory.new
-  component = component_loader.findComponent(component_name)
+  component_loader = Cfhighlander::Factory::ComponentFactory.new
+  component = component_loader.loadComponentFromTemplate(template_name)
   component.version = component_version unless component_version.nil?
   component.distribution_bucket = distribution_bucket unless distribution_bucket.nil?
   component.distribution_prefix = distribution_prefix unless distribution_prefix.nil?
@@ -155,4 +164,11 @@ def build_component(options, component_name)
   component
 end
 
+if ENV['CFHIGHLANDER_WORKDIR'].nil?
+  ENV['CFHIGHLANDER_WORKDIR'] = Dir.pwd
+end
+if ENV['HIGHLANDER_WORKDIR'].nil?
+  ENV['HIGHLANDER_WORKDIR'] = Dir.pwd
+end
+
 HighlanderCli.start

data/cfndsl_ext/sg.rb

@@ -1,3 +1,4 @@
+require 'netaddr'
 
 def sg_create_rules (x, ip_blocks={})
   rules = []
@@ -15,12 +16,38 @@ end
 
 
 def lookup_ips_for_sg (ips, ip_block_name={})
+  cidr = []
   if ip_block_name == 'stack'
     cidr = [FnJoin( "", [ "10.", Ref('StackOctet'), ".", "0.0/16" ] )]
   elsif ips.has_key? ip_block_name
-    cidr = ips[ip_block_name]
+    ips[ip_block_name].each do |ip|
+      if (ips.include?(ip) || ip_block_name == 'stack')
+        cidr += lookup_ips_for_sg(ips, ip) unless ip == ip_block_name
+      else
+        if ip == 'stack'
+          cidr << [FnJoin( "", [ "10.", Ref('StackOctet'), ".", "0.0/16" ] )]
+        elsif(isCidr(ip))
+          cidr << ip
+        else
+          STDERR.puts("WARN: ip #{ip} is not a valid CIDR. Ignoring IP")
+        end
+      end
+    end
   else
-    cidr = [ip_block_name]
+    if isCidr(ip_block_name)
+      cidr = [ip_block_name]
+    else
+      STDERR.puts("WARN: ip #{ip_block_name} is not a valid CIDR. Ignoring IP")
+    end
   end
   cidr
 end
+
+def isCidr(block)
+  begin
+    NetAddr::CIDR.create(block)
+    return block.include?('/')
+  rescue NetAddr::ValidationError
+    return false
+  end
+end

data/hl_ext/mapping_helper.rb

@@ -1,14 +1,16 @@
-require_relative '../lib/highlander.mapproviders'
+require_relative '../lib/cfhighlander.mapproviders'
 
 # Return mapping provider as class
-def mappings_provider(provider_name)
+def mappings_provider(provider_name, is_legacy = false)
   return nil if provider_name.nil?
   provider = nil
-  providers = Object.const_get('Highlander').const_get('MapProviders')
+  module_name = is_legacy ? 'Highlander': 'Cfhighlander'
+  providers = Object.const_get(module_name).const_get('MapProviders')
   begin
     providers.const_get(provider_name)
   rescue NameError => e
-    if e.to_s.include? 'uninitialized constant Highlander::MapProviders::'
+    if e.to_s.include? "uninitialized constant #{module_name}::MapProviders::"
+      return mappings_provider(provider_name, true) unless is_legacy
       return nil
     end
     STDERR.puts(e.to_s)