cloud-mu 3.1.2 → 3.2.0

data/modules/mu/{clouds → providers}/azure/vpc.rb

@@ -53,7 +53,6 @@ module MU
         def groom
 
           if @config['peers']
-            count = 0
             @config['peers'].each { |peer|
               if peer['vpc']['name']
                 peer_obj = @deploy.findLitterMate(name: peer['vpc']['name'], type: "vpcs", habitat: peer['vpc']['project'])
@@ -113,17 +112,16 @@ module MU
         # Describe this VPC
         # @return [Hash]
         def notify
-          base = {}
           base = MU.structToHash(cloud_desc)
           base["cloud_id"] = @cloud_id.name
           base.merge!(@config.to_h)
           base
         end
-#
+
         # Describe this VPC from the cloud platform's perspective
         # @return [Hash]
-        def cloud_desc
-          if @cloud_desc_cache
+        def cloud_desc(use_cache: true)
+          if @cloud_desc_cache and use_cache
             return @cloud_desc_cache
           end
           @cloud_desc_cache = MU::Cloud::Azure::VPC.find(cloud_id: @cloud_id, resource_group: @resource_group).values.first
@@ -192,10 +190,9 @@ module MU
         # @param use_cache [Boolean]: If available, use saved deployment metadata to describe subnets, instead of querying the cloud API
         # @return [Array<Hash>]: A list of cloud provider identifiers of subnets associated with this VPC.
         def loadSubnets(use_cache: false)
-          desc = cloud_desc
           @subnets = []
 
-          MU::Cloud::Azure.network(credentials: @credentials).subnets.list(@resource_group, cloud_desc.name).each { |subnet|
+          MU::Cloud::Azure.network(credentials: @credentials).subnets.list(@resource_group, cloud_desc(use_cache: use_cache).name).each { |subnet|
             subnet_cfg = {
               "cloud_id" => subnet.name,
               "mu_name" => subnet.name,
@@ -334,21 +331,23 @@ module MU
         # We assume that any values we have in +@config+ are placeholders, and
         # calculate our own accordingly based on what's live in the cloud.
         # XXX add flag to return the diff between @config and live cloud
-        def toKitten(rootparent: nil, billing: nil)
+        def toKitten(**_args)
           return nil if cloud_desc.name == "default" # parent project builds these
           bok = {
             "cloud" => "Azure",
+            "name" => cloud_desc.name,
             "project" => @config['project'],
-            "credentials" => @config['credentials']
+            "credentials" => @config['credentials'],
+            "cloud_id" => @cloud_id.to_s
           }
 
           bok
         end
 
         # Cloud-specific configuration properties.
-        # @param config [MU::Config]: The calling MU::Config object
+        # @param _config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
-        def self.schema(config = nil)
+        def self.schema(_config = nil)
           toplevel_required = []
           schema = {
             "peers" => {
@@ -427,11 +426,7 @@ module MU
               }
             ]
           }
-          vpc["dependencies"] ||= []
-          vpc["dependencies"] << {
-            "type" => "firewall_rule",
-            "name" => vpc['name']+"-defaultfw"
-          }
+          MU::Config.addDependency(vpc, vpc['name']+"-defaultfw", "firewall_rule")
 
           if !configurator.insertKitten(default_acl, "firewall_rules", true)
             ok = false
@@ -522,7 +517,6 @@ MU.structToHash(ext_vpc).diff(MU.structToHash(vpc_obj))
           # this is slow, so maybe thread it
           rtb_map = {}
           routethreads = []
-          create_nat_gateway = false
           @config['route_tables'].each { |rtb_cfg|
             routethreads << Thread.new(rtb_cfg) { |rtb|
               rtb_name = @mu_name+"-"+rtb['name'].upcase
@@ -573,6 +567,9 @@ MU.structToHash(ext_vpc).diff(MU.structToHash(vpc_obj))
                 routename = rtb_name+"-"+route['destination_network'].gsub(/[^a-z0-9]/i, "_")
                 route_obj.next_hop_type = if route['gateway'] == "#NAT" and @config['bastion']
                   routename = rtb_name+"-NAT"
+                  if @config['bastion'].is_a?(Hash) and !@config['bastion']['id'] and !@config['bastion']['deploy_id']
+                    @config['bastion']['deploy_id'] = @deploy.deploy_id
+                  end
                   bastion_ref = MU::Config::Ref.get(@config['bastion'])
                   if bastion_ref.kitten and bastion_ref.kitten.cloud_desc
                     iface_id = Id.new(bastion_ref.kitten.cloud_desc.network_profile.network_interfaces.first.id)
@@ -718,8 +715,6 @@ MU.structToHash(ext_subnet).diff(MU.structToHash(subnet_obj))
           loadSubnets
         end
 
-        protected
-
         # Subnets are almost a first-class resource. So let's kinda sorta treat
         # them like one. This should only be invoked on objects that already
         # exists in the cloud layer.
@@ -772,8 +767,8 @@ MU.structToHash(ext_subnet).diff(MU.structToHash(subnet_obj))
           end
 
           # Describe this VPC Subnet from the cloud platform's perspective
-          def cloud_desc
-            return @cloud_desc_cache if !@cloud_desc_cache.nil?
+          def cloud_desc(use_cache: true)
+            return @cloud_desc_cache if @cloud_desc_cache and use_cache
             @cloud_desc_cache = MU::Cloud::Azure.network(credentials: @parent.credentials).subnets.get(@parent.resource_group, @parent.cloud_desc.name, @cloud_id.to_s)
             @cloud_desc_cache
           end

data/modules/mu/{clouds → providers}/cloudformation.rb

@@ -28,6 +28,16 @@ module MU
 
       @@cloudformation_mode = false
 
+      # Is this a "real" cloud provider, or a stub like CloudFormation?
+      def self.virtual?
+        true
+      end
+
+      # List all AWS projects available to our credentials
+      def self.listHabitats(credentials = nil, use_cache: true)
+        MU::Cloud::AWS.listHabitats(credentials)
+      end
+
       # Return what we think of as a cloud object's habitat. In AWS, this means
       # the +account_number+ in which it's resident. If this is not applicable,
       # such as for a {Habitat} or {Folder}, returns nil.
@@ -73,8 +83,8 @@ module MU
       # Stub method- there's no such thing as being "hosted" in a CloudFormation
       # environment. Calls {MU::Cloud::AWS.listAZs} to return sensible
       # values, if we happen to have AWS credentials configured.
-      def self.listAZs(region: MU.curRegion, account: nil, credentials: nil)
-        MU::Cloud::AWS.listAZs(region: region, account: account, credentials: credentials)
+      def self.listAZs(region: MU.curRegion, credentials: nil)
+        MU::Cloud::AWS.listAZs(region: region, credentials: credentials)
       end
 
       # Stub method- there's no such thing as being "hosted" in a CloudFormation
@@ -466,7 +476,7 @@ module MU
         desc["DependsOn"] = []
         if !cloudobj.nil? and cloudobj.respond_to?(:dependencies) and type != "subnet"
           cloudobj.dependencies(use_cache: true).first.each_pair { |resource_classname, resources|
-            resources.each_pair { |sibling_name, sibling_obj|
+            resources.each_pair { |_sibling_name, sibling_obj|
               next if sibling_obj == cloudobj
 #              desc["DependsOn"] << (resource_classname+sibling_obj.cloudobj.mu_name).gsub!(/[^a-z0-9]/i, "")
               desc["DependsOn"] << sibling_obj.cloudobj.cfm_name
@@ -498,7 +508,6 @@ module MU
       # @param name [String]: The name of key we're creating/appending
       # @param value [MU::Config::Tail|String]: The value to set. If it's a {MU::Config::Tail} object, we'll treat it as a reference to a parameter.
       def self.setCloudFormationProp(resource, name, value)
-        realvalue = value
         is_list_element = false
 
         # Recursively resolve MU::Config::Tail references
@@ -508,9 +517,11 @@ module MU
               tree[key] = self.resolveTails(val)
             }
           elsif tree.is_a?(Array)
+            newtree = []
             tree.each { |elt|
-              elt = self.resolveTails(elt)
+              newtree << self.resolveTails(elt)
             }
+            tree = newtree
           elsif tree.class.to_s == "MU::Config::Tail"
             if tree.is_list_element
               return { "Fn::Select" => [tree.index, { "Ref" => "#{tree.getPrettyName}" }] }
@@ -584,7 +595,7 @@ module MU
             cfm_template["Conditions"][cond['name']] = JSON.parse(cond['cloudcode'])
           }
         end
-        tails.each_pair { |param, data|
+        tails.each_pair { |_param, data|
           tail = data
           next if tail.is_a?(MU::Config::Tail) and (tail.pseudo or !tail.runtimecode.nil?)
           default = ""
@@ -638,7 +649,7 @@ module MU
             }
           end
         }
-        MU::Cloud.resource_types.each { |cloudclass, data|
+        MU::Cloud.resource_types.values.each { |data|
           if !config[data[:cfg_plural]].nil? and
               config[data[:cfg_plural]].size > 0
             config[data[:cfg_plural]].each { |resource|

data/modules/mu/{clouds → providers}/cloudformation/alarm.rb

@@ -129,7 +129,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::Alarm.schema(config)
+          MU::Cloud.resourceClass("AWS", "Alarm").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -137,14 +137,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::Alarm.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "Alarm").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::Alarm.isGlobal?
+          MU::Cloud.resourceClass("AWS", "Alarm").isGlobal?
         end
 
 

data/modules/mu/{clouds → providers}/cloudformation/cache_cluster.rb

@@ -150,7 +150,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::CacheCluster.schema(config)
+          MU::Cloud.resourceClass("AWS", "CacheCluster").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -158,14 +158,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::CacheCluster.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "CacheCluster").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::CacheCluster.isGlobal?
+          MU::Cloud.resourceClass("AWS", "CacheCluster").isGlobal?
         end
 
       end

data/modules/mu/{clouds → providers}/cloudformation/collection.rb

@@ -100,7 +100,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::Collection.schema(config)
+          MU::Cloud.resourceClass("AWS", "Collection").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -108,14 +108,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::Collection.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "Collection").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::Collection.isGlobal?
+          MU::Cloud.resourceClass("AWS", "Collection").isGlobal?
         end
 
       end

data/modules/mu/{clouds → providers}/cloudformation/database.rb

@@ -64,8 +64,8 @@ module MU
           basename = @config["name"].to_s
           basename = basename+@deploy.timestamp+MU.seed.downcase if !@config['scrub_mu_isms']
           basename.gsub!(/[^a-z0-9]/i, "")
-          @config["db_name"] = MU::Cloud::AWS::Database.getName(basename, type: "dbname", config: @config)
-          @config['master_user'] = MU::Cloud::AWS::Database.getName(basename, type: "dbuser", config: @config)
+          @config["db_name"] = MU::Cloud.resourceClass("AWS", "Database").getName(basename, type: "dbname", config: @config)
+          @config['master_user'] = MU::Cloud.resourceClass("AWS", "Database").getName(basename, type: "dbuser", config: @config)
 
           if @config["create_cluster"]
             @cfm_name, @cfm_template = MU::Cloud::CloudFormation.cloudFormationBase("dbcluster", self, tags: @config['tags'], scrub_mu_isms: @config['scrub_mu_isms']) if @cfm_template.nil?
@@ -214,18 +214,7 @@ module MU
             elsif @config['db_name']
               MU::Cloud::CloudFormation.setCloudFormationProp(@cfm_template[@cfm_name], "DBName", @config['db_name'])
             end
-            if @config['password'].nil?
-              if @config['auth_vault'] && !@config['auth_vault'].empty?
-                @config['password'] = @groomclass.getSecret(
-                  vault: @config['auth_vault']['vault'],
-                  item: @config['auth_vault']['item'],
-                  field: @config['auth_vault']['password_field']
-                )
-              else
-                # Should we use random instead?
-                @config['password'] = Password.pronounceable(10..12)
-              end
-            end
+            getPassword
             MU::Cloud::CloudFormation.setCloudFormationProp(@cfm_template[@cfm_name], "MasterUserPassword", @config['password'])
           end
         end
@@ -260,7 +249,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::Database.schema(config)
+          MU::Cloud.resourceClass("AWS", "Database").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -268,14 +257,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::Database.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "Database").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::Database.isGlobal?
+          MU::Cloud.resourceClass("AWS", "Database").isGlobal?
         end
 
 

data/modules/mu/{clouds → providers}/cloudformation/dnszone.rb

@@ -257,7 +257,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::DNSZone.schema(config)
+          MU::Cloud.resourceClass("AWS", "DNSZone").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -265,14 +265,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::DNSZone.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "DNSZone").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::DNSZone.isGlobal?
+          MU::Cloud.resourceClass("AWS", "DNSZone").isGlobal?
         end
 
       end

data/modules/mu/{clouds → providers}/cloudformation/firewall_rule.rb

@@ -137,7 +137,7 @@ module MU
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(acl, config)
           # Just use the AWS implemention
-          MU::Cloud::AWS::FirewallRule.validateConfig(acl, config)
+          MU::Cloud.resourceClass("AWS", "FirewallRule").validateConfig(acl, config)
         end
 
         private
@@ -291,14 +291,14 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::FirewallRule.schema(config)
+          MU::Cloud.resourceClass("AWS", "FirewallRule").schema(config)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::FirewallRule.isGlobal?
+          MU::Cloud.resourceClass("AWS", "FirewallRule").isGlobal?
         end
 
       end #class

data/modules/mu/{clouds → providers}/cloudformation/loadbalancer.rb

@@ -176,7 +176,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::LoadBalancer.schema(config)
+          MU::Cloud.resourceClass("AWS", "LoadBalancer").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -184,14 +184,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::LoadBalancer.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "LoadBalancer").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::LoadBalancer.isGlobal?
+          MU::Cloud.resourceClass("AWS", "LoadBalancer").isGlobal?
         end
 
       end

data/modules/mu/{clouds → providers}/cloudformation/log.rb

@@ -153,7 +153,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::Log.schema(config)
+          MU::Cloud.resourceClass("AWS", "Log").schema(config)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -161,14 +161,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::Log.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "Log").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::Log.isGlobal?
+          MU::Cloud.resourceClass("AWS", "Log").isGlobal?
         end
 
       end

data/modules/mu/{clouds → providers}/cloudformation/server.rb

@@ -55,8 +55,8 @@ module MU
             scrub_mu_isms: @config['scrub_mu_isms']
           )
 
-          @disk_devices = MU::Cloud::AWS::Server.disk_devices
-          @ephemeral_mappings = MU::Cloud::AWS::Server.ephemeral_mappings
+          @disk_devices = MU::Cloud.resourceClass("AWS", "Server").disk_devices
+          @ephemeral_mappings = MU::Cloud.resourceClass("AWS", "Server").ephemeral_mappings
 
           if !mu_name.nil?
             @mu_name = mu_name
@@ -190,7 +190,7 @@ module MU
           cfm_volume_map = {}
           if @config["storage"]
             @config["storage"].each { |vol|
-              mapping, cfm_mapping = MU::Cloud::AWS::Server.convertBlockDeviceMapping(vol)
+              mapping, cfm_mapping = MU::Cloud.resourceClass("AWS", "Server").convertBlockDeviceMapping(vol)
               configured_storage << mapping
 #                vol_name, vol_template = MU::Cloud::CloudFormation.cloudFormationBase("volume", name: "volume"+@cfm_name+mapping[:device_name])
 #                MU::Cloud::CloudFormation.setCloudFormationProp(vol_template[vol_name], "Size", mapping[:ebs][:volume_size].to_s)
@@ -353,7 +353,7 @@ module MU
         # @param config [MU::Config]: The calling MU::Config object
         # @return [Array<Array,Hash>]: List of required fields, and json-schema Hash of cloud-specific configuration parameters for this resource
         def self.schema(config)
-          MU::Cloud::AWS::Server.schema(config)
+          MU::Cloud.resourceClass("AWS", "Server").schema(config)
         end
 
         # Confirm that the given instance size is valid for the given region.
@@ -362,7 +362,7 @@ module MU
         # @param region [String]: Region to check against
         # @return [String,nil]
         def self.validateInstanceType(size, region)
-          MU::Cloud::AWS::Server.validateInstanceType(size, region)
+          MU::Cloud.resourceClass("AWS", "Server").validateInstanceType(size, region)
         end
 
         # Cloud-specific pre-processing of {MU::Config::BasketofKittens::servers}, bare and unvalidated.
@@ -370,14 +370,14 @@ module MU
         # @param configurator [MU::Config]: The overall deployment configurator of which this resource is a member
         # @return [Boolean]: True if validation succeeded, False otherwise
         def self.validateConfig(server, configurator)
-          MU::Cloud::AWS::Server.validateConfig(server, configurator)
+          MU::Cloud.resourceClass("AWS", "Server").validateConfig(server, configurator)
         end
 
         # Does this resource type exist as a global (cloud-wide) artifact, or
         # is it localized to a region/zone?
         # @return [Boolean]
         def self.isGlobal?
-          MU::Cloud::AWS::Server.isGlobal?
+          MU::Cloud.resourceClass("AWS", "Server").isGlobal?
         end
 
       end #class