fog-maestrodev 1.15.0.20130829165835 → 1.15.0.20130927082724

data/lib/fog/aws/requests/compute/run_instances.rb

@@ -28,6 +28,8 @@ module Fog
         #     * 'Ebs.SnapshotId'<~String> - id of snapshot to boot volume from
         #     * 'Ebs.VolumeSize'<~String> - size of volume in GiBs required unless snapshot is specified
         #     * 'Ebs.DeleteOnTermination'<~String> - specifies whether or not to delete the volume on instance termination
+        #     * 'Ebs.VolumeType'<~String> - Type of EBS volue. Valid options in ['standard', 'io1'] default is 'standard'.
+        #     * 'Ebs.Iops'<~String> - The number of I/O operations per second (IOPS) that the volume supports. Required when VolumeType is 'io1'
         #   * 'ClientToken'<~String> - unique case-sensitive token for ensuring idempotency
         #   * 'DisableApiTermination'<~Boolean> - specifies whether or not to allow termination of the instance from the api
         #   * 'SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances (not supported for VPC)

data/lib/fog/aws/requests/data_pipeline/delete_pipeline.rb

@@ -9,8 +9,7 @@ module Fog
         # ==== Parameters
         # * PipelineId <~String> - The id of the pipeline to delete
         # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
+        # * success<~Boolean> - Whether the delete was successful
         def delete_pipeline(id)
           params = { 'pipelineId' => id }
 
@@ -19,7 +18,7 @@ module Fog
             :headers => { 'X-Amz-Target' => 'DataPipeline.DeletePipeline' },
           })
 
-          Fog::JSON.decode(response.body)
+          200 == response.status
         end
 
       end

data/lib/fog/aws/requests/data_pipeline/describe_objects.rb

@@ -0,0 +1,41 @@
+module Fog
+  module AWS
+    class DataPipeline
+
+      class Real
+
+        # Queries a pipeline for the names of objects that match a specified set of conditions.
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_DescribeObjects.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline
+        # * ObjectIds <~Array> - Identifiers of the pipeline objects that contain the definitions
+        #                        to be described. You can pass as many as 25 identifiers in a
+        #                        single call to DescribeObjects.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_objects(id, objectIds)
+          params = {
+            'pipelineId' => id,
+            'objectIds' => objectIds,
+          }
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.DescribeObjects' },
+          })
+
+          Fog::JSON.decode(response.body)
+        end
+
+      end
+
+      class Mock
+        def describe_objects(id, objects)
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/data_pipeline/get_pipeline_definition.rb

@@ -0,0 +1,37 @@
+module Fog
+  module AWS
+    class DataPipeline
+
+      class Real
+
+        # Get pipeline definition JSON
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_GetPipelineDefinition.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def get_pipeline_definition(id)
+          params = {
+            'pipelineId' => id,
+          }
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.GetPipelineDefinition' },
+          })
+
+          Fog::JSON.decode(response.body)
+        end
+
+      end
+
+      class Mock
+        def get_pipeline_definition(id, objects)
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/data_pipeline/query_objects.rb

@@ -0,0 +1,41 @@
+module Fog
+  module AWS
+    class DataPipeline
+
+      class Real
+
+        # Queries a pipeline for the names of objects that match a specified set of conditions.
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_QueryObjects.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline
+        # * Sphere <~String> - Specifies whether the query applies to components or instances.
+        #                      Allowable values: COMPONENT, INSTANCE, ATTEMPT.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def query_objects(id, sphere)
+          params = {
+            'pipelineId' => id,
+            'sphere' => sphere,
+          }
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.QueryObjects' },
+          })
+
+          Fog::JSON.decode(response.body)
+        end
+
+      end
+
+      class Mock
+        def query_objects(id, objects)
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end
+

data/lib/fog/aws/requests/elasticache/authorize_cache_security_group_ingress.rb

@@ -27,8 +27,33 @@ module Fog
       end
 
       class Mock
-        def authorize_cache_security_group_ingress
-          Fog::Mock.not_implemented
+
+        def authorize_cache_security_group_ingress(name, ec2_name, ec2_owner_id)
+          opts = {
+            'EC2SecurityGroupName' => ec2_name,
+            'EC2SecurityGroupOwnerId' => ec2_owner_id
+          }
+
+          if sec_group = self.data[:security_groups][name]
+
+            if sec_group['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
+              raise Fog::AWS::Elasticache::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
+            end
+            sec_group['EC2SecurityGroups'] << opts.merge({'Status' => 'authorizing'})
+
+            Excon::Response.new(
+                {
+                    :status => 200,
+                    :body => {
+                        'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
+                        'CacheSecurityGroup' => sec_group
+                    }
+                }
+            )
+          else
+            raise Fog::AWS::Elasticache::NotFound.new("CacheSecurityGroupNotFound => #{name} not found")
+          end
+
         end
       end
     end

data/lib/fog/aws/requests/elasticache/create_cache_security_group.rb

@@ -24,8 +24,29 @@ module Fog
       end
 
       class Mock
-        def create_cache_security_group(name, desciption=name)
-          Fog::Mock.not_implemented
+        def create_cache_security_group(name, description = name)
+
+          if self.data[:security_groups][name]
+            raise Fog::AWS::Elasticache::IdentifierTaken.new("CacheClusterAlreadyExists => The security group '#{name}' already exists")
+          end
+
+          data = {
+            'CacheSecurityGroupName' => name,
+            'Description' => description,
+            'EC2SecurityGroups' => [],
+            'OwnerId' => '0123456789'
+          }
+          self.data[:security_groups][name] = data
+
+          Excon::Response.new(
+              {
+                  :body => {
+                      'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
+                      'CacheSecurityGroup' => data
+                  }
+              }
+          )
+
         end
       end
     end

data/lib/fog/aws/requests/elasticache/delete_cache_security_group.rb

@@ -23,7 +23,16 @@ module Fog
 
       class Mock
         def delete_cache_security_group(name)
-          Fog::Mock.not_implemented
+          if self.data[:security_groups].delete(name)
+            Excon::Response.new(
+                {
+                    :status => 200,
+                    :body =>   { 'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id } }
+                }
+            )
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
+          end
         end
       end
     end

data/lib/fog/aws/requests/elasticache/describe_cache_security_groups.rb

@@ -25,8 +25,42 @@ module Fog
       end
 
       class Mock
-        def describe_cache_security_groups(name = nil, options = {})
-          Fog::Mock.not_implemented
+        def describe_cache_security_groups(name = nil, opts={})
+
+          if name
+            sec_group_set = [self.data[:security_groups][name]].compact
+            raise Fog::AWS::Elasticache::NotFound.new("Security Group #{name} not found") if sec_group_set.empty?
+          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|
+            # 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" || ec2_secg["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
+
+          Excon::Response.new(
+              {
+                  :status => 200,
+                  :body => {
+                      "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+                      "CacheSecurityGroups" => sec_group_set
+                  }
+              }
+          )
+
         end
       end
     end

data/lib/fog/aws/requests/redshift/authorize_cluster_security_group_ingress.rb

@@ -0,0 +1,56 @@
+module Fog
+  module AWS
+    class Redshift
+      class Real
+        require 'fog/aws/parsers/redshift/revoke_cluster_security_group_ingress'
+
+        # ==== Parameters
+        # 
+        # @param [Hash] options
+    		# * :cluster_security_group_name - required - (String) 
+    		#    The name of the security Group from which to revoke the ingress rule.
+    		# * :cidrip - (String) 
+    		#    The IP range for which to revoke access. This range must be a valid Classless 
+    		#    Inter-Domain Routing (CIDR) block of IP addresses. If CIDRIP is specified, 
+    		#    EC2SecurityGroupName and EC2SecurityGroupOwnerId cannot be provided.
+    		# * :ec2_security_group_name - (String) 
+    		#    The name of the EC2 Security Group whose access is to be revoked. If 
+    		#    EC2SecurityGroupName is specified, EC2SecurityGroupOwnerId must also be 
+    		#    provided and CIDRIP cannot be provided.
+    		# * :ec2_security_group_owner_id - (String) 
+    		#    The AWS account number of the owner of the security group specified in the 
+    		#    EC2SecurityGroupName parameter. The AWS access key ID is not an acceptable 
+    		#    value. If EC2SecurityGroupOwnerId is specified, EC2SecurityGroupName must 
+    		#    also be provided. and CIDRIP cannot be provided. Example: 111122223333    
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_AuthorizeClusterSecurityGroupIngress.html  
+        def authorize_cluster_security_group_ingress(options = {})
+          cluster_security_group_name = options[:cluster_security_group_name]
+          cidrip                      = options[:cidrip]
+          ec2_security_group_name     = options[:ec2_security_group_name]
+          ec2_security_group_owner_id = options[:ec2_security_group_owner_id]
+
+          path = "/"
+          params = {
+            :headers    => {},
+            :path       => path,
+            :method     => :put,
+            :query      => {},
+      			:parser     => Fog::Parsers::Redshift::AWS::RevokeClusterSecurityGroupIngress.new
+          }
+
+          params[:query]['Action']                   = 'AuthorizeClusterSecurityGroupIngress'
+          params[:query]['ClusterSecurityGroupName'] = cluster_security_group_name if cluster_security_group_name
+          params[:query]['CIDRIP']					         = cidrip if cidrip
+          params[:query]['EC2SecurityGroupName']     = ec2_security_group_name if ec2_security_group_name
+          params[:query]['EC2SecurityGroupOwnerId']  = ec2_security_group_owner_id if ec2_security_group_owner_id
+
+          request(params)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/fog/aws/requests/redshift/authorize_snapshot_access.rb

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    class Redshift
+      class Real
+        require 'fog/aws/parsers/redshift/cluster_snapshot'
+
+        # ==== Parameters
+        #
+        # @param [Hash] options
+        # * :snapshot_identifier - required - (String) 
+        #    The identifier of the snapshot the account is authorized to restore.
+        # * :snapshot_cluster_identifier - (String)
+        # * :account_with_restore_access - required - (String) 
+        #    The identifier of the AWS customer account authorized to restore the specified snapshot.       # 
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_CopyClusterSnapshot.html  
+        def authorize_snapshot_access(options = {})
+          snapshot_identifier         = options[:snapshot_identifier]
+          snapshot_cluster_identifier = options[:snapshot_cluster_identifier]
+          account_with_restore_access = options[:account_with_restore_access]
+
+          path = "/"
+          params = {
+            :headers    => {},
+            :path       => path,
+            :method     => :put,
+            :query      => {},
+            :parser     => Fog::Parsers::Redshift::AWS::ClusterSnapshot.new
+          }
+
+          params[:query]['Action']                    = 'AuthorizeSnapshotAccess'
+          params[:query]['SnapshotIdentifier']        = snapshot_identifier if snapshot_identifier
+          params[:query]['SnapshotClusterIdentifier'] = snapshot_cluster_identifier if snapshot_cluster_identifier
+          params[:query]['AccountWithRestoreAccess']  = account_with_restore_access if account_with_restore_access
+
+          request(params)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/redshift/copy_cluster_snapshot.rb

@@ -0,0 +1,48 @@
+module Fog
+  module AWS
+    class Redshift
+      class Real
+        require 'fog/aws/parsers/redshift/cluster_snapshot'
+
+        # ==== Parameters
+        # 
+        # @param [Hash] options
+        # * :source_snapshot_identifier - required - (String) 
+        #    The identifier for the source snapshot. Constraints: Must be the identifier for
+        #    a valid automated snapshot whose state is "available".
+        # * :source_snapshot_cluster_identifier - (String)
+        # * :target_snapshot_identifier - required - (String) 
+        #    The identifier given to the new manual snapshot. Constraints: Cannot be null, 
+        #    empty, or blank. Must contain from 1 to 255 alphanumeric characters or hyphens.
+        #    First character must be a letter. Cannot end with a hyphen or contain two 
+        #    consecutive hyphens. Must be unique for the AWS account that is making the request.
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_CopyClusterSnapshot.html  
+        def copy_cluster_snapshot(options = {})
+          source_snapshot_identifier         = options[:source_snapshot_identifier]
+          source_snapshot_cluster_identifier = options[:source_snapshot_cluster_identifier]
+          target_snapshot_identifier         = options[:target_snapshot_identifier]
+
+          path = "/"
+          params = {
+            :headers    => {},
+            :path       => path,
+            :method     => :put,
+            :query      => {},
+            :parser     => Fog::Parsers::Redshift::AWS::ClusterSnapshot.new
+          }
+
+          params[:query]['Action']                          = 'CopyClusterSnapshot'
+          params[:query]['SourceSnapshotIdentifier']        = source_snapshot_identifier if source_snapshot_identifier
+          params[:query]['SourceSnapshotClusterIdentifier'] = source_snapshot_cluster_identifier if source_snapshot_cluster_identifier
+          params[:query]['TargetSnapshotIdentifier']        = target_snapshot_identifier if target_snapshot_identifier
+
+          request(params)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/fog/aws/requests/redshift/create_cluster.rb

@@ -0,0 +1,151 @@
+module Fog
+  module AWS
+    class Redshift
+      class Real
+        require 'fog/aws/parsers/redshift/cluster'
+
+        # ==== Parameters
+        # 
+        # @param [Hash] options
+        # * :db_name - (String) 
+        #    The name of the first database to be created when the cluster is created. To create 
+        #    additional databases after the cluster is created, connect to the cluster with a SQL 
+        #    client and use SQL commands to create a database. Default: dev Constraints: Must 
+        #    contain 1 to 64 alphanumeric characters. Must contain only lowercase letters.
+        # * :cluster_identifier - required - (String) 
+        #    A unique identifier for the cluster. You use this identifier to refer to the cluster 
+        #    for any subsequent cluster operations such as deleting or modifying. Must be unique
+        #    for all clusters within an AWS account. Example: myexamplecluster
+        # * :cluster_type - (String) 
+        #    Type of the cluster. When cluster type is specified as single-node, the NumberOfNodes 
+        #    parameter is not required. multi-node, the NumberOfNodes parameter is required. Valid 
+        #    Values: multi-node | single-node Default: multi-node
+        # * :node_type - required - (String) 
+        #    The node type to be provisioned. Valid Values: dw.hs1.xlarge | dw.hs1.8xlarge.
+        # * :master_username - required - (String) 
+        #    The user name associated with the master user account for the cluster that is being 
+        #    created. Constraints: Must be 1 - 128 alphanumeric characters. First character must 
+        #    be a letter. Cannot be a reserved word.
+        # * :master_user_password - required - (String) 
+        #    The password associated with the master user account for the cluster that is being 
+        #    created. Constraints: Must be between 8 and 64 characters in length. Must contain at
+        #    least one uppercase letter. Must contain at least one lowercase letter. Must contain
+        #    one number.
+        # * :cluster_security_groups - (Array<String>)
+        #    A list of security groups to be associated with this cluster. Default: The default
+        #    cluster security group for Amazon Redshift.
+        # * :vpc_security_group_ids - (Array<String>)
+        #    A list of Virtual Private Cloud (VPC) security groups to be associated with the
+        #    cluster. Default: The default VPC security group is associated with the cluster.
+        # * :cluster_subnet_group_name - (String) 
+        #    The name of a cluster subnet group to be associated with this cluster. If this 
+        #    parameter is not provided the resulting cluster will be deployed outside virtual
+        #    private cloud (VPC).
+        # * :availability_zone - (String) 
+        #    The EC2 Availability Zone (AZ) in which you want Amazon Redshift to provision the
+        #    cluster. Default: A random, system-chosen Availability Zone in the region that is
+        #    specified by the endpoint. Example: us-east-1d Constraint: The specified 
+        #    Availability Zone must be in the same region as the current endpoint.
+        # * :preferred_maintenance_window - (String) 
+        #    The weekly time range (in UTC) during which automated cluster maintenance can occur. 
+        #    Format: ddd:hh24:mi-ddd:hh24:mi Default: A 30-minute window selected at random from 
+        #    an 8-hour block of time per region, occurring on a random day of the week. 
+        #    Constraints: Minimum 30-minute window.
+        # * :cluster_parameter_group_name - (String) 
+        #    The name of the parameter group to be associated with this cluster. Default: The
+        #    default Amazon Redshift cluster parameter group. Constraints: Must be 1 to 255 
+        #    alphanumeric characters or hyphens. First character must be a letter. Cannot end 
+        #    with a hyphen or contain two consecutive hyphens.
+        # * :automated_snapshot_retention_period - (Integer)
+        #    Number of days that automated snapshots are retained. If the value is 0, automated
+        #    snapshots are disabled.  Default: 1 Constraints: Must be a value from 0 to 35.
+        # * :port - (Integer) 
+        #    The port number on which the cluster accepts incoming connections. Default: 5439
+        #    Valid Values: 1150-65535
+        # * :cluster_version - (String) 
+        #    The version of the Amazon Redshift engine software that you want to deploy on the
+        #    cluster. The version selected runs on all the nodes in the cluster. Constraints: 
+        #    Only version 1.0 is currently available. Example: 1.0
+        # * :allow_version_upgrade - (Boolean) 
+        #    If `true` , upgrades can be applied during the maintenance window to the Amazon 
+        #    Redshift engine that is running on the cluster. Default:  `true`
+        # * :number_of_nodes - (Integer)
+        #    The number of compute nodes in the cluster. This parameter is required when the 
+        #    ClusterType parameter is specified as multi-node. If you don't specify this parameter,
+        #    you get a single-node cluster. When requesting a multi-node cluster, you must specify
+        #    the number of nodes that you want in the cluster. Default: 1 Constraints: Value must 
+        #    be at least 1 and no more than 100.
+        # * :publicly_accessible - (Boolean)
+        #    If `true` , the cluster can be accessed from a public network.
+        # * :encrypted - (Boolean) 
+        #    If `true` , the data in cluster is encrypted at rest. Default:  `false`
+
+        # ==== See Also
+        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster.html             
+        def create_cluster(options = {})
+          db_name                             = options[:db_name]
+          cluster_identifier                  = options[:cluster_identifier]
+          cluster_type                        = options[:cluster_type]
+          node_type                           = options[:node_type]
+          master_username                     = options[:master_username]
+          master_user_password                = options[:master_user_password]
+          cluster_subnet_group_name           = options[:cluster_subnet_group_name]
+          availability_zone                   = options[:availability_zone]
+          preferred_maintenance_window        = options[:preferred_maintenance_window]
+          cluster_parameter_group_name        = options[:cluster_parameter_group_name]
+          automated_snapshot_retention_period = options[:automated_snapshot_retention_period]
+          port                                = options[:port]
+          cluster_version                     = options[:cluster_version]
+          allow_version_upgrade               = options[:allow_version_upgrade]
+          number_of_nodes                     = options[:number_of_nodes]
+          publicly_accessible                 = options[:publicly_accessible] 
+          encrypted                           = options[:encrypted]
+
+          path = "/"
+          params = {
+            :idempotent => true,
+            :headers    => {},
+            :path       => path,
+            :method     => :put,
+            :query      => {},
+            :parser     => Fog::Parsers::Redshift::AWS::Cluster.new
+          }
+
+          if cluster_security_groups = options.delete(:ClusterSecurityGroups)
+            params[:query].merge!(Fog::AWS.indexed_param('ClusterSecurityGroups.member.%d', [*cluster_security_groups]))
+          end
+   
+          if vpc_security_group_ids = options.delete(:VpcSecurityGroupIds)
+            params[:query].merge!(Fog::AWS.indexed_param('VpcSecurityGroupIds.member.%d', [*vpc_security_group_ids]))
+          end
+
+
+          params[:query]['Action']                           = 'CreateCluster'
+          params[:query]['DBName']                           = db_name if db_name
+          params[:query]['ClusterIdentifier']                = cluster_identifier if cluster_identifier
+          params[:query]['ClusterType']                      = cluster_type if cluster_type
+          params[:query]['NodeType']                         = node_type if node_type
+          params[:query]['MasterUsername']                   = master_username if master_username
+          params[:query]['MasterUserPassword']               = master_user_password if master_user_password
+          params[:query]['ClusterSecurityGroups']            = cluster_security_groups if cluster_security_groups
+          params[:query]['VpcSecurityGroupIds']              = vpc_security_group_ids if vpc_security_group_ids
+          params[:query]['ClusterSubnetGroupName']           = cluster_subnet_group_name if cluster_subnet_group_name
+          params[:query]['AvailabilityZone']                 = availability_zone if availability_zone
+          params[:query]['PreferredMaintenanceWindow']       = preferred_maintenance_window if preferred_maintenance_window
+          params[:query]['ClusterParameterGroupName']        = cluster_parameter_group_name if cluster_parameter_group_name
+          params[:query]['AutomatedSnapshotRetentionPeriod'] = automated_snapshot_retention_period if automated_snapshot_retention_period
+          params[:query]['Port']                             = port if port
+          params[:query]['ClusterVersion']                   = cluster_version if cluster_version
+          params[:query]['AllowVersionUpgrade']              = allow_version_upgrade if allow_version_upgrade
+          params[:query]['NumberOfNodes']                    = number_of_nodes if number_of_nodes
+          params[:query]['PubliclyAccessible']               = publicly_accessible if publicly_accessible
+          params[:query]['Encrypted']                        = encrypted if encrypted
+
+
+          request(params)
+        end
+      end
+
+    end
+  end
+end