brightbox-cli 0.17.4 → 0.17.5

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_parameter_groups.rb

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_db_parameter_groups'
+
+        # This API returns a list of DBParameterGroup descriptions. If a DBParameterGroupName is specified, the list will contain only the descriptions of the specified DBParameterGroup
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBParameterGroups.html
+        # ==== Parameters
+        # * DBParameterGroupName <~String> - The name of a specific database parameter group to return details for.
+        # * Source <~String> - The parameter types to return. user | system | engine-default
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_parameter_groups(name=nil, opts={})
+          params={}
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if name
+            params['DBParameterGroupName'] = name
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+          
+          request({
+            'Action'  => 'DescribeDBParameterGroups',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBParameterGroups.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_db_parameter_groups(name=nil, opts={})
+          response = Excon::Response.new
+          parameter_set = []
+          if name
+            if server = self.data[:parameter_groups][name]
+              parameter_set << server
+            else
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{name} not found")
+            end
+          else
+            parameter_set = self.data[:parameter_groups].values
+          end
+          
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBParameterGroupsResult" => { "DBParameterGroups" => parameter_set }
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_parameters.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_db_parameters'
+
+        # Describe  parameters from a parameter group
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBParameters.html
+        # ==== Parameters
+        # * DBParameterGroupName <~String> - name of parameter group to retrieve parameters for
+        # * Source <~String> - The parameter types to return. user | system | engine-default
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_parameters(name, opts={})
+          params={}
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if opts[:source]
+            params['Source'] = opts[:source]
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+          
+          request({
+            'Action'  => 'DescribeDBParameters',
+            'DBParameterGroupName' => name,
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBParameters.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_db_parameters(name, opts={})
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_reserved_instances.rb

@@ -0,0 +1,42 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_db_reserved_instances'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. if absent information for all instances is returned
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_reserved_instances(identifier=nil, opts={})
+          params = {}
+          params['ReservedDBInstanceId'] = identifier if identifier
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+          
+          request({
+            'Action'  => 'DescribeReservedDBInstances',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBReservedInstances.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_db_reserved_instances(identifier=nil, opts={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_security_groups.rb

@@ -0,0 +1,85 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_db_security_groups'
+
+        # Describe all or specified db security groups
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_DescribeDBSecurityGroups.html
+        # ==== Parameters
+        # * DBSecurityGroupName <~String> - The name of the DB Security Group to return details for.
+        # * Marker               <~String> - An optional marker provided in the previous DescribeDBInstances request
+        # * MaxRecords           <~Integer> - Max number of records to return (between 20 and 100)
+        # Only one of DBInstanceIdentifier or DBSnapshotIdentifier can be specified
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_security_groups(opts={})
+          opts = {'DBSecurityGroupName' => opts} if opts.is_a?(String)
+
+          request({
+            'Action'  => 'DescribeDBSecurityGroups',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBSecurityGroups.new
+          }.merge(opts))
+        end
+
+      end
+
+      class Mock
+
+        def describe_db_security_groups(opts={})
+          response = Excon::Response.new
+          sec_group_set = []
+          if opts.is_a?(String)
+            sec_group_name = opts
+            if sec_group = self.data[:security_groups][sec_group_name]
+              sec_group_set << sec_group
+            else
+              raise Fog::AWS::RDS::NotFound.new("Security Group #{sec_group_name} not found")
+            end
+          else
+            sec_group_set = self.data[:security_groups].values
+          end
+
+          # TODO: refactor to not delete items that we're iterating over. Causes
+          # model tests to fail (currently pending)
+          sec_group_set.each do |sec_group|
+            sec_group["IPRanges"].each do |iprange|
+              if iprange["Status"] == "authorizing" || iprange["Status"] == "revoking"
+                iprange[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                if iprange[:tmp] <= Time.now
+                  iprange["Status"] = "authorized" if iprange["Status"] == "authorizing"
+                  iprange.delete(:tmp)
+                  sec_group["IPRanges"].delete(iprange) if iprange["Status"] == "revoking"
+                end
+              end
+            end
+
+            # TODO: refactor to not delete items that we're iterating over. Causes
+            # model tests to fail (currently pending)
+            sec_group["EC2SecurityGroups"].each do |ec2_secg|
+              if ec2_secg["Status"] == "authorizing" || iprange["Status"] == "revoking"
+                ec2_secg[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                if ec2_secg[:tmp] <= Time.now
+                  ec2_secg["Status"] = "authorized" if ec2_secg["Status"] == "authorizing"
+                  ec2_secg.delete(:tmp)
+                  sec_group["EC2SecurityGroups"].delete(ec2_secg) if ec2_secg["Status"] == "revoking"
+                end
+              end
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBSecurityGroupsResult" => { "DBSecurityGroups" => sec_group_set }
+          }
+          response
+        end
+
+      end
+    end
+  end
+end
+

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_snapshots.rb

@@ -0,0 +1,69 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_db_snapshots'
+
+        # Describe all or specified db snapshots
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBSnapshots.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. if absent information for all instances is returned
+        # * DBSnapshotIdentifier <~String> - ID of snapshot to retrieve information for. if absent information for all snapshots is returned
+        # * Marker               <~String> - An optional marker provided in the previous DescribeDBInstances request
+        # * MaxRecords           <~Integer> - Max number of records to return (between 20 and 100) 
+        # Only one of DBInstanceIdentifier or DBSnapshotIdentifier can be specified
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_snapshots(opts={})
+          params = {}
+          params['DBInstanceIdentifier'] = opts[:identifier] if opts[:identifier]
+          params['DBSnapshotIdentifier'] = opts[:snapshot_id] if opts[:snapshot_id]
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          request({
+            'Action'  => 'DescribeDBSnapshots',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBSnapshots.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_db_snapshots(opts={})
+          response = Excon::Response.new
+          snapshots = self.data[:snapshots].values
+          if opts[:identifier]
+            snapshots = snapshots.select{|snapshot| snapshot['DBInstanceIdentifier'] == opts[:identifier]}
+          end
+
+          if opts[:snapshot_id]
+            snapshots = snapshots.select{|snapshot| snapshot['DBSnapshotIdentifier'] == opts[:snapshot_id]}
+            raise Fog::AWS::RDS::NotFound.new("DBSnapshot #{opts[:snapshot_id]} not found") if snapshots.empty?
+          end
+
+          snapshots.each do |snapshot|
+            case snapshot['Status']
+            when 'creating'
+              if Time.now - snapshot['SnapshotCreateTime'] > Fog::Mock.delay
+                snapshot['Status'] = 'available'
+              end
+            end
+          end
+
+          # Build response
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBSnapshotsResult" => { "DBSnapshots" => snapshots }
+          }
+          response
+
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/modify_db_instance.rb

@@ -0,0 +1,79 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/modify_db_instance'
+
+        # modifies a database instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - name of the db instance to modify
+        # * ApplyImmediately <~Boolean> - whether to apply the changes immediately or wait for the next maintenance window
+        #                                     
+        # * AllocatedStorage  <~Integer> Storage space, in GB
+        # * AllowMajorVersionUpgrade <~Boolean> Must be set to true if EngineVersion specifies a different major version  
+        # * AutoMinorVersionUpgrade <~Boolean> Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window 
+        # * BackupRetentionPeriod  <~Integer> 0-8 The number of days to retain automated backups.
+        # * DBInstanceClass <~String> The new compute and memory capacity of the DB Instanc 
+        # * DBParameterGroupName <~String> The name of the DB Parameter Group to apply to this DB Instance  
+        # * DBSecurityGroups <~Array> A list of DB Security Groups to authorize on this DB Instance 
+        # * EngineVersion <~String> The version number of the database engine to upgrade to.
+        # * MasterUserPassword  <~String> The new password for the DB Instance master user
+        # * MultiAZ <~Boolean> Specifies if the DB Instance is a Multi-AZ deployment
+        # * PreferredBackupWindow <~String> The daily time range during which automated backups are created if automated backups are enabled
+        # * PreferredMaintenanceWindow <~String> The weekly time range (in UTC) during which system maintenance can occur, which may result in an outage
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def modify_db_instance(db_name, apply_immediately, options={})
+          
+          if security_groups = options.delete('DBSecurityGroups')
+            options.merge!(Fog::AWS.indexed_param('DBSecurityGroups.member.%d', [*security_groups]))
+          end
+    
+          request({
+            'Action'  => 'ModifyDBInstance',
+            'DBInstanceIdentifier' => db_name,
+            'ApplyImmediately' => apply_immediately,
+            :parser   => Fog::Parsers::AWS::RDS::ModifyDBInstance.new,
+          }.merge(options))
+        end
+
+      end
+
+      class Mock
+
+        def modify_db_instance(db_name, apply_immediately, options={})
+          response = Excon::Response.new
+          if self.data[:servers][db_name]
+            if self.data[:servers][db_name]["DBInstanceStatus"] != "available"
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
+            else
+              # TODO verify the params options
+              # if apply_immediately is false, all the options go to pending_modified_values and then apply and clear after either 
+              # a reboot or the maintainance window
+              #if apply_immediately
+              #  modified_server = server.merge(options)
+              #else
+              #  modified_server = server["PendingModifiedValues"].merge!(options) # it appends
+              #end
+              self.data[:servers][db_name]["PendingModifiedValues"].merge!(options) # it appends
+              #self.data[:servers][db_name]["DBInstanceStatus"] = "modifying"
+              response.status = 200
+              response.body = {
+                "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+                "ModifyDBInstanceResult" => { "DBInstance" => self.data[:servers][db_name] }
+              }
+              response
+              
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/modify_db_parameter_group.rb

@@ -0,0 +1,55 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/modify_db_parameter_group'
+
+        # modifies a database parameter group
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_ModifyDBParameterGroup.html
+        # ==== Parameters
+        # * DBParameterGroupName <~String> - name of the parameter group
+        # * Parameters<~Array> - Array of up to 20 Hashes describing parameters to set
+        #   * 'ParameterName'<~String> - parameter name.
+        #   * 'ParameterValue'<~String> - new paremeter value
+        #   * 'ApplyMethod'<~String> - immediate | pending-reboot whether to set the parameter immediately or not (may require an instance restart)
+        #                                     
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def modify_db_parameter_group(group_name, parameters)
+          
+          parameter_names = []
+          parameter_values = []
+          parameter_apply_methods = []
+          
+          parameters.each do |parameter|
+            parameter_names.push(parameter['ParameterName'])
+            parameter_values.push(parameter['ParameterValue'])
+            parameter_apply_methods.push(parameter['ApplyMethod'])
+          end
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('Parameters.member.%d.ParameterName', parameter_names))
+          params.merge!(Fog::AWS.indexed_param('Parameters.member.%d.ParameterValue', parameter_values))
+          params.merge!(Fog::AWS.indexed_param('Parameters.member.%d.ApplyMethod', parameter_apply_methods))
+          
+          request({
+            'Action'  => 'ModifyDBParameterGroup',
+            'DBParameterGroupName' => group_name,
+            
+            :parser   => Fog::Parsers::AWS::RDS::ModifyDbParameterGroup.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def modify_db_parameter_group(group_name, parameters)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end