docs: def set_cluster_info(self,
                           disallow_cluster_termination=None,
                           enable_ganglia_monitoring=None,
                           datadog_api_token=None,
                           datadog_app_token=None,
                           node_bootstrap=None,
                           master_instance_type=None,
                           slave_instance_type=None,
                           min_nodes=None,
                           max_nodes=None,
                           slave_request_type=None,
                           fallback_to_ondemand=None,
                           node_base_cooldown_period=None,
                           node_spot_cooldown_period=None,
                           custom_tags=None,
                           heterogeneous_config=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_spot_fallback=None,
                           spot_block_duration=None,
                           idle_cluster_timeout=None,
                           disk_count=None,
                           disk_type=None,
                           disk_size=None,
                           root_disk_size=None,
                           upscaling_config=None,
                           enable_encryption=None,
                           customer_ssh_key=None,
                           cluster_name=None,
                           force_tunnel=None,
                           image_uri_overrides=None,
                           env_name=None,
                           python_version=None,
                           r_version=None,
                           disable_cluster_pause=None,
                           paused_cluster_timeout_mins=None,
                           disable_autoscale_node_pause=None,
                           paused_autoscale_node_timeout_mins=None):
          """
          Args:
  
                  `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`: 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.
  
                  `min_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)
  
                  `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_spot_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)
  
                  `disk_count`: Number of EBS volumes to attach
                      to each instance of the cluster.
  
                  `disk_type`: Type of the EBS volume. Valid
                      values are 'standard' (magnetic) and 'ssd'.
  
                  `disk_size`: Size of each EBS volume, in GB.
  
                  `root_disk_size`: Size of root volume, in GB.
  
                  `enable_encryption`: Encrypt the ephemeral drives on the instance.
  
                  `customer_ssh_key`: SSH key to use to login to the instances.
  
                  `idle_cluster_timeout`: The buffer time (range in 0-6 hrs) after a cluster goes idle
                      and gets terminated,  given cluster auto termination is on and no cluster specific
                      timeout has been set (default is 2 hrs)
  
                  `heterogeneous_config` : Configuring heterogeneous nodes in Hadoop 2 and Spark clusters.
                      It implies that slave nodes can be of different instance types
  
                  `custom_tags` : Custom tags to be set on all instances
                      of the cluster. Specified as JSON object (key-value pairs)
  
                  `datadog_api_token` : Specify the Datadog API token to use the Datadog monitoring service
  
                  `datadog_app_token` : Specify the Datadog APP token to use the Datadog monitoring service
  
                  `image_uri_overrides` : Override the image name provided
  
                  `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)
  
                  `disable_cluster_pause`: Disable cluster pause
  
                  `paused_cluster_timeout_mins`: Paused cluster timeout in mins
  
                  `disable_autoscale_node_pause`: Disable autoscale node pause
  
                  `paused_autoscale_node_timeout_mins`: Paused autoscale node timeout in mins
  
          Doc: For getting details about arguments
          http://docs.qubole.com/en/latest/rest-api/cluster_api/create-new-cluster.html#parameters
  
          """
          self.cluster_info['master_instance_type'] = master_instance_type
          self.cluster_info['slave_instance_type'] = slave_instance_type
          self.cluster_info['min_nodes'] = min_nodes
          self.cluster_info['max_nodes'] = max_nodes
          self.cluster_info['cluster_name'] = cluster_name
          self.cluster_info['node_bootstrap'] = node_bootstrap
          self.cluster_info['disallow_cluster_termination'] = disallow_cluster_termination
          self.cluster_info['force_tunnel'] = force_tunnel
          self.cluster_info['fallback_to_ondemand'] = fallback_to_ondemand
          self.cluster_info['node_base_cooldown_period'] = node_base_cooldown_period
          self.cluster_info['node_spot_cooldown_period'] = node_spot_cooldown_period
          self.cluster_info['customer_ssh_key'] = customer_ssh_key
          if custom_tags and custom_tags.strip():
              try:
                  self.cluster_info['custom_tags'] = json.loads(custom_tags.strip())
              except Exception as e:
                  raise Exception("Invalid JSON string for custom ec2 tags: %s" % e.message)
  
          self.cluster_info['heterogeneous_config'] = heterogeneous_config
          self.cluster_info['slave_request_type'] = slave_request_type
          self.cluster_info['idle_cluster_timeout'] = idle_cluster_timeout
          self.cluster_info['spot_settings'] = {}
  
          self.cluster_info['rootdisk'] = {}
          self.cluster_info['rootdisk']['size'] = root_disk_size
  
          self.set_spot_instance_settings(maximum_bid_price_percentage, timeout_for_request, maximum_spot_instance_percentage)
          self.set_stable_spot_bid_settings(stable_maximum_bid_price_percentage, stable_timeout_for_request, stable_spot_fallback)
          self.set_spot_block_settings(spot_block_duration)
          self.set_data_disk(disk_size, disk_count, disk_type, upscaling_config, enable_encryption)
          self.set_monitoring(enable_ganglia_monitoring, datadog_api_token, datadog_app_token)
          self.set_internal(image_uri_overrides)
          self.set_env_settings(env_name, python_version, r_version)
          self.set_start_stop_settings(disable_cluster_pause, paused_cluster_timeout_mins,
                                       disable_autoscale_node_pause, paused_autoscale_node_timeout_mins)