docs: def set_cluster_info(self, aws_access_key_id=None,
                           aws_secret_access_key=None,
                           aws_region=None,
                           aws_availability_zone=None,
                           vpc_id=None,
                           subnet_id=None,
                           master_elastic_ip=None,
                           disallow_cluster_termination=None,
                           enable_ganglia_monitoring=None,
                           node_bootstrap_file=None,
                           master_instance_type=None,
                           slave_instance_type=None,
                           initial_nodes=None,
                           max_nodes=None,
                           slave_request_type=None,
                           fallback_to_ondemand=None,
                           node_base_cooldown_period=None,
                           node_spot_cooldown_period=None,
                           custom_config=None,
                           use_hbase=None,
                           custom_ec2_tags=None,
                           use_hadoop2=None,
                           use_spark=None,
                           use_qubole_placement_policy=None,
                           maximum_bid_price_percentage=None,
                           timeout_for_request=None,
                           maximum_spot_instance_percentage=None,
                           stable_maximum_bid_price_percentage=None,
                           stable_timeout_for_request=None,
                           stable_allow_fallback=True,
                           spot_block_duration=None,
                           ebs_volume_count=None,
                           ebs_volume_type=None,
                           ebs_volume_size=None,
                           root_volume_size=None,
                           fairscheduler_config_xml=None,
                           default_pool=None,
                           encrypted_ephemerals=None,
                           ssh_public_key=None,
                           persistent_security_group=None,
                           enable_presto=None,
                           bastion_node_public_dns=None,
                           role_instance_profile=None,
                           presto_custom_config=None,
                           is_ha=None,
                           env_name=None,
                           python_version=None,
                           r_version=None,
                           enable_rubix=None):
          """
          Kwargs:
  
          `aws_access_key_id`: The access key id for customer's aws account. This
              is required for creating the cluster.
  
          `aws_secret_access_key`: The secret access key for customer's aws
              account. This is required for creating the cluster.
  
          `aws_region`: AWS region to create the cluster in.
  
          `aws_availability_zone`: The availability zone to create the cluster
              in.
  
          `vpc_id`: The vpc to create the cluster in.
  
          `subnet_id`: The subnet to create the cluster in.
  
          `master_elastic_ip`: Elastic IP to attach to master node
  
          `disallow_cluster_termination`: Set this to True if you don't want
              qubole to auto-terminate idle clusters. Use this option with
              extreme caution.
  
          `enable_ganglia_monitoring`: Set this to True if you want to enable
              ganglia monitoring for the cluster.
  
          `node_bootstrap_file`: name of the node bootstrap file for this
              cluster. It should be in stored in S3 at
              <your-default-location>/scripts/hadoop/
  
          `master_instance_type`: The instance type to use for the Hadoop master
              node.
  
          `slave_instance_type`: The instance type to use for the Hadoop slave
              nodes.
  
          `initial_nodes`: Number of nodes to start the cluster with.
  
          `max_nodes`: Maximum number of nodes the cluster may be auto-scaled up
              to.
  
          `slave_request_type`: Purchasing option for slave instances.
              Valid values: "ondemand", "hybrid", "spot".
  
          `fallback_to_ondemand`: Fallback to on-demand nodes if spot nodes could not be
              obtained. Valid only if slave_request_type is 'spot'.
  
          `node_base_cooldown_period`: Time for which an on-demand node waits before termination (Unit: minutes)
  
          `node_spot_cooldown_period`: Time for which a spot node waits before termination (Unit: minutes)
  
          `custom_config`: Custom Hadoop configuration overrides.
  
          `use_hbase`: Start hbase daemons on the cluster. Uses Hadoop2
  
          `use_hadoop2`: Use hadoop2 in this cluster
  
          `use_spark`: Use spark in this cluster
  
          `use_qubole_placement_policy`: Use Qubole Block Placement policy for 
              clusters with spot nodes.
  
          `maximum_bid_price_percentage`: ( Valid only when `slave_request_type` 
              is hybrid or spot.) Maximum value to bid for spot
              instances, expressed as a percentage of the base price 
              for the slave node instance type.
  
          `timeout_for_request`: Timeout for a spot instance request (Unit:
              minutes)
  
          `maximum_spot_instance_percentage`: Maximum percentage of instances
              that may be purchased from the AWS Spot market. Valid only when
              slave_request_type is "hybrid".
  
          `stable_maximum_bid_price_percentage`: Maximum value to bid for stable node spot
              instances, expressed as a percentage of the base price
              (applies to both master and slave nodes).
  
          `stable_timeout_for_request`: Timeout for a stable node spot instance request (Unit:
              minutes)
  
          `stable_allow_fallback`: Whether to fallback to on-demand instances for
              stable nodes if spot instances are not available
  
          `spot_block_duration`: Time for which the spot block instance is provisioned (Unit:
              minutes)
  
          `ebs_volume_count`: Number of EBS volumes to attach 
              to each instance of the cluster.
  
          `ebs_volume_type`: Type of the EBS volume. Valid 
              values are 'standard' (magnetic) and 'ssd'.
  
          `ebs_volume_size`: Size of each EBS volume, in GB. 
  
          `root_volume_size`: Size of root volume, in GB.
  
          `fairscheduler_config_xml`: XML string with custom configuration
              parameters for the fair scheduler.
  
          `default_pool`: The default pool for the fair scheduler.
  
          `encrypted_ephemerals`: Encrypt the ephemeral drives on the instance.
  
          `ssh_public_key`: SSH key to use to login to the instances.
  
          `persistent_security_group`: Comma-separated list of persistent 
              security groups for the cluster.
  
          `enable_presto`: Enable Presto on the cluster.
  
          `presto_custom_config`: Custom Presto configuration overrides.
  
          `bastion_node_public_dns`: Public dns name of the bastion node. Required only if cluster is in private subnet.
  
          `is_ha`: Enabling HA config for cluster
  
          `env_name`: Name of python and R environment. (For Spark clusters)
  
          `python_version`: Version of Python for environment. (For Spark clusters)
  
          `r_version`: Version of R for environment. (For Spark clusters)
  
          `enable_rubix`: Enable rubix on the cluster (For Presto clusters)
          """
  
          self.disallow_cluster_termination = disallow_cluster_termination
          self.enable_ganglia_monitoring = enable_ganglia_monitoring
          self.node_bootstrap_file = node_bootstrap_file
          self.set_node_configuration(master_instance_type, slave_instance_type, initial_nodes, max_nodes,
                                      slave_request_type, fallback_to_ondemand, custom_ec2_tags,
                                      node_base_cooldown_period, node_spot_cooldown_period, root_volume_size)
          self.set_ec2_settings(aws_access_key_id, aws_secret_access_key, aws_region, aws_availability_zone, vpc_id, subnet_id,
                                master_elastic_ip, bastion_node_public_dns, role_instance_profile)
          self.set_hadoop_settings(custom_config, use_hbase, use_hadoop2, use_spark, use_qubole_placement_policy, is_ha, enable_rubix)
          self.set_spot_instance_settings(maximum_bid_price_percentage, timeout_for_request, maximum_spot_instance_percentage)
          self.set_stable_spot_instance_settings(stable_maximum_bid_price_percentage, stable_timeout_for_request, stable_allow_fallback)
          self.set_spot_block_settings(spot_block_duration)
          self.set_ebs_volume_settings(ebs_volume_count, ebs_volume_type, ebs_volume_size)
          self.set_fairscheduler_settings(fairscheduler_config_xml, default_pool)
          self.set_security_settings(encrypted_ephemerals, ssh_public_key, persistent_security_group)
          self.set_presto_settings(enable_presto, presto_custom_config)
          self.set_env_settings(env_name, python_version, r_version)