text:
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/glue/model/ExecutionProperty.h>
#include <aws/glue/model/JobCommand.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/glue/model/ConnectionsList.h>
#include <aws/glue/model/WorkerType.h>
#include <aws/glue/model/NotificationProperty.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Glue
{
namespace Model
{

  /**
   *
Specifies information used to update an existing job definition. The previous
   * job definition is completely overwritten by this information.

See
   * Also:
   AWS API
   * Reference

   */
  class AWS_GLUE_API JobUpdate
  {
  public:
    JobUpdate();
    JobUpdate(Aws::Utils::Json::JsonView jsonValue);
    JobUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    /**
     *
Description of the job being defined.

     */
    inline const Aws::String& GetDescription() const{ return m_description; }

    /**
     *
Description of the job being defined.

     */
    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }

    /**
     *
Description of the job being defined.

     */
    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }

    /**
     *
Description of the job being defined.

     */
    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }

    /**
     *
Description of the job being defined.

     */
    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }

    /**
     *
Description of the job being defined.

     */
    inline JobUpdate& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}

    /**
     *
Description of the job being defined.

     */
    inline JobUpdate& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}

    /**
     *
Description of the job being defined.

     */
    inline JobUpdate& WithDescription(const char* value) { SetDescription(value); return *this;}

    /**
     *
This field is reserved for future use.

     */
    inline const Aws::String& GetLogUri() const{ return m_logUri; }

    /**
     *
This field is reserved for future use.

     */
    inline bool LogUriHasBeenSet() const { return m_logUriHasBeenSet; }

    /**
     *
This field is reserved for future use.

     */
    inline void SetLogUri(const Aws::String& value) { m_logUriHasBeenSet = true; m_logUri = value; }

    /**
     *
This field is reserved for future use.

     */
    inline void SetLogUri(Aws::String&& value) { m_logUriHasBeenSet = true; m_logUri = std::move(value); }

    /**
     *
This field is reserved for future use.

     */
    inline void SetLogUri(const char* value) { m_logUriHasBeenSet = true; m_logUri.assign(value); }

    /**
     *
This field is reserved for future use.

     */
    inline JobUpdate& WithLogUri(const Aws::String& value) { SetLogUri(value); return *this;}

    /**
     *
This field is reserved for future use.

     */
    inline JobUpdate& WithLogUri(Aws::String&& value) { SetLogUri(std::move(value)); return *this;}

    /**
     *
This field is reserved for future use.

     */
    inline JobUpdate& WithLogUri(const char* value) { SetLogUri(value); return *this;}

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline const Aws::String& GetRole() const{ return m_role; }

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline bool RoleHasBeenSet() const { return m_roleHasBeenSet; }

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline void SetRole(const Aws::String& value) { m_roleHasBeenSet = true; m_role = value; }

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline void SetRole(Aws::String&& value) { m_roleHasBeenSet = true; m_role = std::move(value); }

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline void SetRole(const char* value) { m_roleHasBeenSet = true; m_role.assign(value); }

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline JobUpdate& WithRole(const Aws::String& value) { SetRole(value); return *this;}

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline JobUpdate& WithRole(Aws::String&& value) { SetRole(std::move(value)); return *this;}

    /**
     *
The name or Amazon Resource Name (ARN) of the IAM role associated with this
     * job (required).

     */
    inline JobUpdate& WithRole(const char* value) { SetRole(value); return *this;}

    /**
     *
An ExecutionProperty specifying the maximum number of concurrent
     * runs allowed for this job.

     */
    inline const ExecutionProperty& GetExecutionProperty() const{ return m_executionProperty; }

    /**
     *
An ExecutionProperty specifying the maximum number of concurrent
     * runs allowed for this job.

     */
    inline bool ExecutionPropertyHasBeenSet() const { return m_executionPropertyHasBeenSet; }

    /**
     *
An ExecutionProperty specifying the maximum number of concurrent
     * runs allowed for this job.

     */
    inline void SetExecutionProperty(const ExecutionProperty& value) { m_executionPropertyHasBeenSet = true; m_executionProperty = value; }

    /**
     *
An ExecutionProperty specifying the maximum number of concurrent
     * runs allowed for this job.

     */
    inline void SetExecutionProperty(ExecutionProperty&& value) { m_executionPropertyHasBeenSet = true; m_executionProperty = std::move(value); }

    /**
     *
An ExecutionProperty specifying the maximum number of concurrent
     * runs allowed for this job.

     */
    inline JobUpdate& WithExecutionProperty(const ExecutionProperty& value) { SetExecutionProperty(value); return *this;}

    /**
     *
An ExecutionProperty specifying the maximum number of concurrent
     * runs allowed for this job.

     */
    inline JobUpdate& WithExecutionProperty(ExecutionProperty&& value) { SetExecutionProperty(std::move(value)); return *this;}

    /**
     *
The JobCommand that executes this job (required).

     */
    inline const JobCommand& GetCommand() const{ return m_command; }

    /**
     *
The JobCommand that executes this job (required).

     */
    inline bool CommandHasBeenSet() const { return m_commandHasBeenSet; }

    /**
     *
The JobCommand that executes this job (required).

     */
    inline void SetCommand(const JobCommand& value) { m_commandHasBeenSet = true; m_command = value; }

    /**
     *
The JobCommand that executes this job (required).

     */
    inline void SetCommand(JobCommand&& value) { m_commandHasBeenSet = true; m_command = std::move(value); }

    /**
     *
The JobCommand that executes this job (required).

     */
    inline JobUpdate& WithCommand(const JobCommand& value) { SetCommand(value); return *this;}

    /**
     *
The JobCommand that executes this job (required).

     */
    inline JobUpdate& WithCommand(JobCommand&& value) { SetCommand(std::move(value)); return *this;}

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline const Aws::Map<Aws::String, Aws::String>& GetDefaultArguments() const{ return m_defaultArguments; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline bool DefaultArgumentsHasBeenSet() const { return m_defaultArgumentsHasBeenSet; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline void SetDefaultArguments(const Aws::Map<Aws::String, Aws::String>& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments = value; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline void SetDefaultArguments(Aws::Map<Aws::String, Aws::String>&& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments = std::move(value); }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& WithDefaultArguments(const Aws::Map<Aws::String, Aws::String>& value) { SetDefaultArguments(value); return *this;}

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& WithDefaultArguments(Aws::Map<Aws::String, Aws::String>&& value) { SetDefaultArguments(std::move(value)); return *this;}

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(const Aws::String& key, const Aws::String& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(key, value); return *this; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(Aws::String&& key, const Aws::String& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(std::move(key), value); return *this; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(const Aws::String& key, Aws::String&& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(key, std::move(value)); return *this; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(Aws::String&& key, Aws::String&& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(std::move(key), std::move(value)); return *this; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(const char* key, Aws::String&& value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(key, std::move(value)); return *this; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(Aws::String&& key, const char* value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(std::move(key), value); return *this; }

    /**
     *
The default arguments for this job.

You can specify arguments here
     * that your own job-execution script consumes, as well as arguments that AWS Glue
     * itself consumes.

For information about how to specify and consume your
     * own Job arguments, see the Calling
     * AWS Glue APIs in Python topic in the developer guide.

For information
     * about the key-value pairs that AWS Glue consumes to set up your job, see the Special
     * Parameters Used by AWS Glue topic in the developer guide.

     */
    inline JobUpdate& AddDefaultArguments(const char* key, const char* value) { m_defaultArgumentsHasBeenSet = true; m_defaultArguments.emplace(key, value); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline const Aws::Map<Aws::String, Aws::String>& GetNonOverridableArguments() const{ return m_nonOverridableArguments; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline bool NonOverridableArgumentsHasBeenSet() const { return m_nonOverridableArgumentsHasBeenSet; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline void SetNonOverridableArguments(const Aws::Map<Aws::String, Aws::String>& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments = value; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline void SetNonOverridableArguments(Aws::Map<Aws::String, Aws::String>&& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments = std::move(value); }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& WithNonOverridableArguments(const Aws::Map<Aws::String, Aws::String>& value) { SetNonOverridableArguments(value); return *this;}

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& WithNonOverridableArguments(Aws::Map<Aws::String, Aws::String>&& value) { SetNonOverridableArguments(std::move(value)); return *this;}

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(const Aws::String& key, const Aws::String& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(key, value); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(Aws::String&& key, const Aws::String& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(std::move(key), value); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(const Aws::String& key, Aws::String&& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(key, std::move(value)); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(Aws::String&& key, Aws::String&& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(std::move(key), std::move(value)); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(const char* key, Aws::String&& value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(key, std::move(value)); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(Aws::String&& key, const char* value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(std::move(key), value); return *this; }

    /**
     *
Non-overridable arguments for this job, specified as name-value pairs.

     */
    inline JobUpdate& AddNonOverridableArguments(const char* key, const char* value) { m_nonOverridableArgumentsHasBeenSet = true; m_nonOverridableArguments.emplace(key, value); return *this; }

    /**
     *
The connections used for this job.

     */
    inline const ConnectionsList& GetConnections() const{ return m_connections; }

    /**
     *
The connections used for this job.

     */
    inline bool ConnectionsHasBeenSet() const { return m_connectionsHasBeenSet; }

    /**
     *
The connections used for this job.

     */
    inline void SetConnections(const ConnectionsList& value) { m_connectionsHasBeenSet = true; m_connections = value; }

    /**
     *
The connections used for this job.

     */
    inline void SetConnections(ConnectionsList&& value) { m_connectionsHasBeenSet = true; m_connections = std::move(value); }

    /**
     *
The connections used for this job.

     */
    inline JobUpdate& WithConnections(const ConnectionsList& value) { SetConnections(value); return *this;}

    /**
     *
The connections used for this job.

     */
    inline JobUpdate& WithConnections(ConnectionsList&& value) { SetConnections(std::move(value)); return *this;}

    /**
     *
The maximum number of times to retry this job if it fails.

     */
    inline int GetMaxRetries() const{ return m_maxRetries; }

    /**
     *
The maximum number of times to retry this job if it fails.

     */
    inline bool MaxRetriesHasBeenSet() const { return m_maxRetriesHasBeenSet; }

    /**
     *
The maximum number of times to retry this job if it fails.

     */
    inline void SetMaxRetries(int value) { m_maxRetriesHasBeenSet = true; m_maxRetries = value; }

    /**
     *
The maximum number of times to retry this job if it fails.

     */
    inline JobUpdate& WithMaxRetries(int value) { SetMaxRetries(value); return *this;}

    /**
     *
The job timeout in minutes. This is the maximum time that a job run can
     * consume resources before it is terminated and enters TIMEOUT
     * status. The default is 2,880 minutes (48 hours).

     */
    inline int GetTimeout() const{ return m_timeout; }

    /**
     *
The job timeout in minutes. This is the maximum time that a job run can
     * consume resources before it is terminated and enters TIMEOUT
     * status. The default is 2,880 minutes (48 hours).

     */
    inline bool TimeoutHasBeenSet() const { return m_timeoutHasBeenSet; }

    /**
     *
The job timeout in minutes. This is the maximum time that a job run can
     * consume resources before it is terminated and enters TIMEOUT
     * status. The default is 2,880 minutes (48 hours).

     */
    inline void SetTimeout(int value) { m_timeoutHasBeenSet = true; m_timeout = value; }

    /**
     *
The job timeout in minutes. This is the maximum time that a job run can
     * consume resources before it is terminated and enters TIMEOUT
     * status. The default is 2,880 minutes (48 hours).

     */
    inline JobUpdate& WithTimeout(int value) { SetTimeout(value); return *this;}

    /**
     *
The number of AWS Glue data processing units (DPUs) that can be allocated
     * when this job runs. A DPU is a relative measure of processing power that
     * consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
     * information, see the AWS Glue
     * pricing page.

Do not set Max Capacity if using
     * WorkerType and NumberOfWorkers.

The value that
     * can be allocated for MaxCapacity depends on whether you are running
     * a Python shell job or an Apache Spark ETL job:

When you specify
     * a Python shell job (JobCommand.Name="pythonshell"), you can
     * allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.

     *
When you specify an Apache Spark ETL job
     * (JobCommand.Name="glueetl") or Apache Spark streaming ETL job
     * (JobCommand.Name="gluestreaming"), you can allocate from 2 to 100
     * DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU
     * allocation.

     */
    inline double GetMaxCapacity() const{ return m_maxCapacity; }

    /**
     *
The number of AWS Glue data processing units (DPUs) that can be allocated
     * when this job runs. A DPU is a relative measure of processing power that
     * consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
     * information, see the AWS Glue
     * pricing page.

Do not set Max Capacity if using
     * WorkerType and NumberOfWorkers.

The value that
     * can be allocated for MaxCapacity depends on whether you are running
     * a Python shell job or an Apache Spark ETL job:

When you specify
     * a Python shell job (JobCommand.Name="pythonshell"), you can
     * allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.

     *
When you specify an Apache Spark ETL job
     * (JobCommand.Name="glueetl") or Apache Spark streaming ETL job
     * (JobCommand.Name="gluestreaming"), you can allocate from 2 to 100
     * DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU
     * allocation.

     */
    inline bool MaxCapacityHasBeenSet() const { return m_maxCapacityHasBeenSet; }

    /**
     *
The number of AWS Glue data processing units (DPUs) that can be allocated
     * when this job runs. A DPU is a relative measure of processing power that
     * consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
     * information, see the AWS Glue
     * pricing page.

Do not set Max Capacity if using
     * WorkerType and NumberOfWorkers.

The value that
     * can be allocated for MaxCapacity depends on whether you are running
     * a Python shell job or an Apache Spark ETL job:

When you specify
     * a Python shell job (JobCommand.Name="pythonshell"), you can
     * allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.

     *
When you specify an Apache Spark ETL job
     * (JobCommand.Name="glueetl") or Apache Spark streaming ETL job
     * (JobCommand.Name="gluestreaming"), you can allocate from 2 to 100
     * DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU
     * allocation.

     */
    inline void SetMaxCapacity(double value) { m_maxCapacityHasBeenSet = true; m_maxCapacity = value; }

    /**
     *
The number of AWS Glue data processing units (DPUs) that can be allocated
     * when this job runs. A DPU is a relative measure of processing power that
     * consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
     * information, see the AWS Glue
     * pricing page.

Do not set Max Capacity if using
     * WorkerType and NumberOfWorkers.

The value that
     * can be allocated for MaxCapacity depends on whether you are running
     * a Python shell job or an Apache Spark ETL job:

When you specify
     * a Python shell job (JobCommand.Name="pythonshell"), you can
     * allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.

     *
When you specify an Apache Spark ETL job
     * (JobCommand.Name="glueetl") or Apache Spark streaming ETL job
     * (JobCommand.Name="gluestreaming"), you can allocate from 2 to 100
     * DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU
     * allocation.

     */
    inline JobUpdate& WithMaxCapacity(double value) { SetMaxCapacity(value); return *this;}

    /**
     *
The type of predefined worker that is allocated when a job runs. Accepts a
     * value of Standard, G.1X, or G.2X.

For the Standard
     * worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
     * executors per worker.

For the G.1X worker type,
     * each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1
     * executor per worker. We recommend this worker type for memory-intensive
     * jobs.

For the G.2X worker type, each worker maps
     * to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per
     * worker. We recommend this worker type for memory-intensive jobs.

     */
    inline const WorkerType& GetWorkerType() const{ return m_workerType; }

    /**
     *
The type of predefined worker that is allocated when a job runs. Accepts a
     * value of Standard, G.1X, or G.2X.

For the Standard
     * worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
     * executors per worker.

For the G.1X worker type,
     * each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1
     * executor per worker. We recommend this worker type for memory-intensive
     * jobs.

For the G.2X worker type, each worker maps
     * to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per
     * worker. We recommend this worker type for memory-intensive jobs.

     */
    inline bool WorkerTypeHasBeenSet() const { return m_workerTypeHasBeenSet; }

    /**
     *
The type of predefined worker that is allocated when a job runs. Accepts a
     * value of Standard, G.1X, or G.2X.

For the Standard
     * worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
     * executors per worker.

For the G.1X worker type,
     * each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1
     * executor per worker. We recommend this worker type for memory-intensive
     * jobs.

For the G.2X worker type, each worker maps
     * to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per
     * worker. We recommend this worker type for memory-intensive jobs.

     */
    inline void SetWorkerType(const WorkerType& value) { m_workerTypeHasBeenSet = true; m_workerType = value; }

    /**
     *
The type of predefined worker that is allocated when a job runs. Accepts a
     * value of Standard, G.1X, or G.2X.

For the Standard
     * worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
     * executors per worker.

For the G.1X worker type,
     * each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1
     * executor per worker. We recommend this worker type for memory-intensive
     * jobs.

For the G.2X worker type, each worker maps
     * to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per
     * worker. We recommend this worker type for memory-intensive jobs.

     */
    inline void SetWorkerType(WorkerType&& value) { m_workerTypeHasBeenSet = true; m_workerType = std::move(value); }

    /**
     *
The type of predefined worker that is allocated when a job runs. Accepts a
     * value of Standard, G.1X, or G.2X.

For the Standard
     * worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
     * executors per worker.

For the G.1X worker type,
     * each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1
     * executor per worker. We recommend this worker type for memory-intensive
     * jobs.

For the G.2X worker type, each worker maps
     * to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per
     * worker. We recommend this worker type for memory-intensive jobs.

     */
    inline JobUpdate& WithWorkerType(const WorkerType& value) { SetWorkerType(value); return *this;}

    /**
     *
The type of predefined worker that is allocated when a job runs. Accepts a
     * value of Standard, G.1X, or G.2X.

For the Standard
     * worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
     * executors per worker.

For the G.1X worker type,
     * each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1
     * executor per worker. We recommend this worker type for memory-intensive
     * jobs.

For the G.2X worker type, each worker maps
     * to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per
     * worker. We recommend this worker type for memory-intensive jobs.

     */
    inline JobUpdate& WithWorkerType(WorkerType&& value) { SetWorkerType(std::move(value)); return *this;}

    /**
     *
The number of workers of a defined workerType that are allocated
     * when a job runs.

The maximum number of workers you can define are 299 for
     * G.1X, and 149 for G.2X.

     */
    inline int GetNumberOfWorkers() const{ return m_numberOfWorkers; }

    /**
     *
The number of workers of a defined workerType that are allocated
     * when a job runs.

The maximum number of workers you can define are 299 for
     * G.1X, and 149 for G.2X.

     */
    inline bool NumberOfWorkersHasBeenSet() const { return m_numberOfWorkersHasBeenSet; }

    /**
     *
The number of workers of a defined workerType that are allocated
     * when a job runs.

The maximum number of workers you can define are 299 for
     * G.1X, and 149 for G.2X.

     */
    inline void SetNumberOfWorkers(int value) { m_numberOfWorkersHasBeenSet = true; m_numberOfWorkers = value; }

    /**
     *
The number of workers of a defined workerType that are allocated
     * when a job runs.

The maximum number of workers you can define are 299 for
     * G.1X, and 149 for G.2X.

     */
    inline JobUpdate& WithNumberOfWorkers(int value) { SetNumberOfWorkers(value); return *this;}

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline const Aws::String& GetSecurityConfiguration() const{ return m_securityConfiguration; }

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline bool SecurityConfigurationHasBeenSet() const { return m_securityConfigurationHasBeenSet; }

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline void SetSecurityConfiguration(const Aws::String& value) { m_securityConfigurationHasBeenSet = true; m_securityConfiguration = value; }

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline void SetSecurityConfiguration(Aws::String&& value) { m_securityConfigurationHasBeenSet = true; m_securityConfiguration = std::move(value); }

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline void SetSecurityConfiguration(const char* value) { m_securityConfigurationHasBeenSet = true; m_securityConfiguration.assign(value); }

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline JobUpdate& WithSecurityConfiguration(const Aws::String& value) { SetSecurityConfiguration(value); return *this;}

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline JobUpdate& WithSecurityConfiguration(Aws::String&& value) { SetSecurityConfiguration(std::move(value)); return *this;}

    /**
     *
The name of the SecurityConfiguration structure to be used with
     * this job.

     */
    inline JobUpdate& WithSecurityConfiguration(const char* value) { SetSecurityConfiguration(value); return *this;}

    /**
     *
Specifies the configuration properties of a job notification.

     */
    inline const NotificationProperty& GetNotificationProperty() const{ return m_notificationProperty; }

    /**
     *
Specifies the configuration properties of a job notification.

     */
    inline bool NotificationPropertyHasBeenSet() const { return m_notificationPropertyHasBeenSet; }

    /**
     *
Specifies the configuration properties of a job notification.

     */
    inline void SetNotificationProperty(const NotificationProperty& value) { m_notificationPropertyHasBeenSet = true; m_notificationProperty = value; }

    /**
     *
Specifies the configuration properties of a job notification.

     */
    inline void SetNotificationProperty(NotificationProperty&& value) { m_notificationPropertyHasBeenSet = true; m_notificationProperty = std::move(value); }

    /**
     *
Specifies the configuration properties of a job notification.

     */
    inline JobUpdate& WithNotificationProperty(const NotificationProperty& value) { SetNotificationProperty(value); return *this;}

    /**
     *
Specifies the configuration properties of a job notification.

     */
    inline JobUpdate& WithNotificationProperty(NotificationProperty&& value) { SetNotificationProperty(std::move(value)); return *this;}

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline const Aws::String& GetGlueVersion() const{ return m_glueVersion; }

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline bool GlueVersionHasBeenSet() const { return m_glueVersionHasBeenSet; }

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline void SetGlueVersion(const Aws::String& value) { m_glueVersionHasBeenSet = true; m_glueVersion = value; }

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline void SetGlueVersion(Aws::String&& value) { m_glueVersionHasBeenSet = true; m_glueVersion = std::move(value); }

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline void SetGlueVersion(const char* value) { m_glueVersionHasBeenSet = true; m_glueVersion.assign(value); }

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline JobUpdate& WithGlueVersion(const Aws::String& value) { SetGlueVersion(value); return *this;}

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline JobUpdate& WithGlueVersion(Aws::String&& value) { SetGlueVersion(std::move(value)); return *this;}

    /**
     *
Glue version determines the versions of Apache Spark and Python that AWS Glue
     * supports. The Python version indicates the version supported for jobs of type
     * Spark.

For more information about the available AWS Glue versions and
     * corresponding Spark and Python versions, see Glue version
     * in the developer guide.

     */
    inline JobUpdate& WithGlueVersion(const char* value) { SetGlueVersion(value); return *this;}

  private:

    Aws::String m_description;
    bool m_descriptionHasBeenSet;

    Aws::String m_logUri;
    bool m_logUriHasBeenSet;

    Aws::String m_role;
    bool m_roleHasBeenSet;

    ExecutionProperty m_executionProperty;
    bool m_executionPropertyHasBeenSet;

    JobCommand m_command;
    bool m_commandHasBeenSet;

    Aws::Map<Aws::String, Aws::String> m_defaultArguments;
    bool m_defaultArgumentsHasBeenSet;

    Aws::Map<Aws::String, Aws::String> m_nonOverridableArguments;
    bool m_nonOverridableArgumentsHasBeenSet;

    ConnectionsList m_connections;
    bool m_connectionsHasBeenSet;

    int m_maxRetries;
    bool m_maxRetriesHasBeenSet;

    int m_timeout;
    bool m_timeoutHasBeenSet;

    double m_maxCapacity;
    bool m_maxCapacityHasBeenSet;

    WorkerType m_workerType;
    bool m_workerTypeHasBeenSet;

    int m_numberOfWorkers;
    bool m_numberOfWorkersHasBeenSet;

    Aws::String m_securityConfiguration;
    bool m_securityConfigurationHasBeenSet;

    NotificationProperty m_notificationProperty;
    bool m_notificationPropertyHasBeenSet;

    Aws::String m_glueVersion;
    bool m_glueVersionHasBeenSet;
  };

} // namespace Model
} // namespace Glue
} // namespace Aws


text:
import {
  getHotSingerListRequest,
  getSingerListRequest,
} from "../../../api/request";
import {
  CHANGE_SINGER_LIST,
  CHANGE_CATOGORY,
  CHANGE_ALPHA,
  CHANGE_PAGE_COUNT,
  CHANGE_PULLUP_LOADING,
  CHANGE_PULLDOWN_LOADING,
  CHANGE_ENTER_LOADING,
} from "./action-types";
import { fromJS } from "immutable";

const changeSingerList = (data) => ({
  type: CHANGE_SINGER_LIST,
  data: fromJS(data),
});

export const changePageCount = (data) => ({
  type: CHANGE_PAGE_COUNT,
  data,
});

//进场loading
export const changeEnterLoading = (data) => ({
  type: CHANGE_ENTER_LOADING,
  data,
});

//滑动最底部loading
export const changePullUpLoading = (data) => ({
  type: CHANGE_PULLUP_LOADING,
  data,
});

//顶部下拉刷新loading
export const changePullDownLoading = (data) => ({
  type: CHANGE_PULLDOWN_LOADING,
  data,
});

// 第一次加载热门歌手
export const getHotSingerList = () => {
  return (dispatch) => {
    getHotSingerListRequest(0)
      .then((res) => {
        const data = res.artists;
        dispatch(changeSingerList(data));
        dispatch(changeEnterLoading(false));
        dispatch(changePullDownLoading(false));
      })
      .catch(() => {
        console.log("热门歌手数据获取失败");
      });
  };
};

// 加载更多热门歌手
export const refreshMoreHotSingerList = () => {
  return (dispatch, getState) => {
    const pageCount = getState().getIn(["singers", "pageCount"]);
    const singerList = getState().getIn(["singers", "singerList"]).toJS();
    getHotSingerListRequest(pageCount)
      .then((res) => {
        const data = [...singerList, ...res.artists];
        dispatch(changeSingerList(data));
        dispatch(changePullUpLoading(false));
      })
      .catch(() => {
        console.log("热门歌手数据获取失败");
      });
  };
};

// 第一次加载对应类别的歌手
export const getSingerList = (category, alpha) => {
  return (dispatch, getState) => {
    getSingerListRequest(category, alpha, 0).then((res) => {
      const data = res.artists;
      dispatch(changeSingerList(data));
      dispatch(changeEnterLoading(false));
      dispatch(changePullUpLoading(false));
    }).catch(() => {
      console.log('歌手数据获取失败');
    });
  };
};

//加载更多歌手
export const refreshMoreSingerList = (category, alpha) => {
  return (dispatch, getState) => {
    const pageCount = getState().getIn(['singers', 'pageCount']);
    const singerList = getState().getIn(['singers', 'singerList']).toJS();
    getSingerListRequest(category, alpha, pageCount).then(res => {
      const data = [...singerList, ...res.artists];
      dispatch(changeSingerList(data));
      dispatch(changePullUpLoading(false));
    }).catch(() => {
      console.log('歌手数据获取失败');
    });
  }
};

redpajama_set_name: RedPajamaGithub


text:
package com.intellij.lang.properties;

import javax.annotation.Nonnull;

import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiReference;
import com.intellij.psi.PsiReferenceProvider;
import com.intellij.util.ProcessingContext;

/**
 * @author yole
 */
public class ResourceBundleReferenceProvider extends PsiReferenceProvider {

  protected boolean mySoft;

  public ResourceBundleReferenceProvider() {
    this(false);
  }

  public ResourceBundleReferenceProvider(boolean soft) {
    mySoft = soft;
  }

  @Nonnull
  public PsiReference[] getReferencesByElement(@Nonnull PsiElement element, @Nonnull final ProcessingContext context) {
        ResourceBundleReference reference = new ResourceBundleReference(element, mySoft);
        return new PsiReference[] { reference };
  }

}


text:
/*
 * GetApplicationReportRequest.cpp
 *
 *  Created on: Jul 14, 2014
 *      Author: bwang
 */

#include "GetApplicationReportRequest.h"

namespace libyarn {

GetApplicationReportRequest::GetApplicationReportRequest() {
	requestProto = GetApplicationReportRequestProto::default_instance();
}

GetApplicationReportRequest::GetApplicationReportRequest(
		const GetApplicationReportRequestProto &proto) :
		requestProto(proto) {
}

GetApplicationReportRequest::~GetApplicationReportRequest() {
}

GetApplicationReportRequestProto& GetApplicationReportRequest::getProto() {
	return requestProto;
}

void GetApplicationReportRequest::setApplicationId(ApplicationID &appId) {
	ApplicationIdProto* proto = new ApplicationIdProto();
	proto->CopyFrom(appId.getProto());
	requestProto.set_allocated_application_id(proto);
}

ApplicationID GetApplicationReportRequest::getApplicationId() {
	return ApplicationID(requestProto.application_id());
}

} /* namespace libyarn */


text:
if (!global.__NIGHTINGALE_CONFIG) {
  global.__NIGHTINGALE_CONFIG = [];
  global.__NIGHTINGALE_LOGGER_MAP_CACHE = new Map();
  global.__NIGHTINGALE_CONFIG_DEFAULT = { handlers: [], processors: [] };
}

function clearCache() {
  global.__NIGHTINGALE_LOGGER_MAP_CACHE.clear();
}

function handleConfig(config) {
  if (config.keys) {
    if (config.pattern) {
      throw new Error('Cannot have key and pattern for the same config');
    }
    if (config.key) {
      throw new Error('Cannot have key and keys for the same config');
    }
  } else if (config.key) {
    if (config.pattern) {
      throw new Error('Cannot have key and pattern for the same config');
    }
    config.keys = [config.key];
    delete config.key;
  }

  if (config.patterns) {
    throw new Error('config.patterns is no longer supported, use pattern');
  }

  if (config.handler) {
    if (config.handlers) {
      throw new Error('Cannot have handler and handlers for the same config');
    }
    config.handlers = [config.handler];
    delete config.handler;
  }

  if (config.processor) {
    if (config.processors) {
      throw new Error('Cannot have processors and processors for the same config');
    }
    config.processors = [config.processor];
    delete config.processor;
  }

  return config;
}

export function configure(config) {
  if (global.__NIGHTINGALE_CONFIG.length !== 0) {
    // eslint-disable-next-line no-console
    console.log('nightingale: warning: config overridden');
  }

  clearCache();
  global.__NIGHTINGALE_CONFIG = config.map(handleConfig);
}

export function addConfig(config, unshift = false) {
  config = handleConfig(config);
  global.__NIGHTINGALE_CONFIG[unshift ? 'unshift' : 'push'](config);
  clearCache();
}

const configIsForKey = key => config => {
  if (config.keys) return config.keys.includes(key);
  if (config.pattern) return config.pattern.test(key);
  return true;
};

global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER = function getConfigForLogger(key) {
  const globalCache = global.__NIGHTINGALE_LOGGER_MAP_CACHE;

  if (globalCache.has(key)) {
    return globalCache.get(key);
  }

  const loggerConfig = {
    handlers: [],
    processors: []
  };

  global.__NIGHTINGALE_CONFIG.filter(configIsForKey(key)).some(config => {
    if (config.handlers) loggerConfig.handlers.push(...config.handlers);
    if (config.processors) loggerConfig.processors.push(...config.processors);
    return config.stop;
  });

  globalCache.set(key, loggerConfig);
  return loggerConfig;
};

global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD = function getConfigForLoggerRecord(key, level) {
  const { handlers, processors } = global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(key);

  return {
    handlers: handlers.filter(handler => level >= handler.minLevel && (!handler.isHandling || handler.isHandling(level, key))),
    processors
  };
};
//# sourceMappingURL=config.js.map


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Syll. fung. (Abellini) 8: 794 (1889)

#### Original name
Patellaria clavispora (Peck) Sacc., 1889

### Remarks
null


text:
SYNONYM

#### According to
GRIN Taxonomy for Plants

#### Published in
Züchter 21(1/2):49. 1951

#### Original name
null

### Remarks
null


text:
package storage

import (
	"fmt"
	"time"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	utilerrors "k8s.io/apimachinery/pkg/util/errors"
	clientset "k8s.io/client-go/kubernetes"
	"k8s.io/kubernetes/test/e2e/framework"
	"k8s.io/kubernetes/test/e2e/storage/utils"
)

type testBody func(c clientset.Interface, f *framework.Framework, clientPod *v1.Pod, pvc *v1.PersistentVolumeClaim)
type disruptiveTest struct {
	testItStmt string
	runTest    testBody
}

const (
	MinNodes = 2
)

var _ = utils.SIGDescribe("NFSPersistentVolumes[Disruptive][Flaky]", func() {

	f := framework.NewDefaultFramework("disruptive-pv")
	var (
		c                         clientset.Interface
		ns                        string
		nfsServerPod              *v1.Pod
		nfsPVconfig               framework.PersistentVolumeConfig
		pvcConfig                 framework.PersistentVolumeClaimConfig
		nfsServerIP, clientNodeIP string
		clientNode                *v1.Node
		volLabel                  labels.Set
		selector                  *metav1.LabelSelector
	)

	BeforeEach(func() {
		// To protect the NFS volume pod from the kubelet restart, we isolate it on its own node.
		framework.SkipUnlessNodeCountIsAtLeast(MinNodes)
		framework.SkipIfProviderIs("local")

		c = f.ClientSet
		ns = f.Namespace.Name
		volLabel = labels.Set{framework.VolumeSelectorKey: ns}
		selector = metav1.SetAsLabelSelector(volLabel)
		// Start the NFS server pod.
		_, nfsServerPod, nfsServerIP = framework.NewNFSServer(c, ns, []string{"-G", "777", "/exports"})
		nfsPVconfig = framework.PersistentVolumeConfig{
			NamePrefix: "nfs-",
			Labels:     volLabel,
			PVSource: v1.PersistentVolumeSource{
				NFS: &v1.NFSVolumeSource{
					Server:   nfsServerIP,
					Path:     "/exports",
					ReadOnly: false,
				},
			},
		}
		emptyStorageClass := ""
		pvcConfig = framework.PersistentVolumeClaimConfig{
			Selector:         selector,
			StorageClassName: &emptyStorageClass,
		}
		// Get the first ready node IP that is not hosting the NFS pod.
		if clientNodeIP == "" {
			framework.Logf("Designating test node")
			nodes := framework.GetReadySchedulableNodesOrDie(c)
			for _, node := range nodes.Items {
				if node.Name != nfsServerPod.Spec.NodeName {
					clientNode = &node
					clientNodeIP = framework.GetNodeExternalIP(clientNode)
					break
				}
			}
			Expect(clientNodeIP).NotTo(BeEmpty())
		}
	})

	AfterEach(func() {
		framework.DeletePodWithWait(f, c, nfsServerPod)
	})

	Context("when kube-controller-manager restarts", func() {
		var (
			diskName1, diskName2 string
			err                  error
			pvConfig1, pvConfig2 framework.PersistentVolumeConfig
			pv1, pv2             *v1.PersistentVolume
			pvSource1, pvSource2 *v1.PersistentVolumeSource
			pvc1, pvc2           *v1.PersistentVolumeClaim
			clientPod            *v1.Pod
		)

		BeforeEach(func() {
			framework.SkipUnlessProviderIs("gce")
			framework.SkipUnlessSSHKeyPresent()

			By("Initializing first PD with PVPVC binding")
			pvSource1, diskName1 = framework.CreateGCEVolume()
			Expect(err).NotTo(HaveOccurred())
			pvConfig1 = framework.PersistentVolumeConfig{
				NamePrefix: "gce-",
				Labels:     volLabel,
				PVSource:   *pvSource1,
				Prebind:    nil,
			}
			pv1, pvc1, err = framework.CreatePVPVC(c, pvConfig1, pvcConfig, ns, false)
			Expect(err).NotTo(HaveOccurred())
			framework.ExpectNoError(framework.WaitOnPVandPVC(c, ns, pv1, pvc1))

			By("Initializing second PD with PVPVC binding")
			pvSource2, diskName2 = framework.CreateGCEVolume()
			Expect(err).NotTo(HaveOccurred())
			pvConfig2 = framework.PersistentVolumeConfig{
				NamePrefix: "gce-",
				Labels:     volLabel,
				PVSource:   *pvSource2,
				Prebind:    nil,
			}
			pv2, pvc2, err = framework.CreatePVPVC(c, pvConfig2, pvcConfig, ns, false)
			Expect(err).NotTo(HaveOccurred())
			framework.ExpectNoError(framework.WaitOnPVandPVC(c, ns, pv2, pvc2))

			By("Attaching both PVC's to a single pod")
			clientPod, err = framework.CreatePod(c, ns, nil, []*v1.PersistentVolumeClaim{pvc1, pvc2}, true, "")
			Expect(err).NotTo(HaveOccurred())
		})

		AfterEach(func() {
			// Delete client/user pod first
			framework.ExpectNoError(framework.DeletePodWithWait(f, c, clientPod))

			// Delete PV and PVCs
			if errs := framework.PVPVCCleanup(c, ns, pv1, pvc1); len(errs) > 0 {
				framework.Failf("AfterEach: Failed to delete PVC and/or PV. Errors: %v", utilerrors.NewAggregate(errs))
			}
			pv1, pvc1 = nil, nil
			if errs := framework.PVPVCCleanup(c, ns, pv2, pvc2); len(errs) > 0 {
				framework.Failf("AfterEach: Failed to delete PVC and/or PV. Errors: %v", utilerrors.NewAggregate(errs))
			}
			pv2, pvc2 = nil, nil

			// Delete the actual disks
			if diskName1 != "" {
				framework.ExpectNoError(framework.DeletePDWithRetry(diskName1))
			}
			if diskName2 != "" {
				framework.ExpectNoError(framework.DeletePDWithRetry(diskName2))
			}
		})

		It("should delete a bound PVC from a clientPod, restart the kube-control-manager, and ensure the kube-controller-manager does not crash", func() {
			By("Deleting PVC for volume 2")
			err = framework.DeletePersistentVolumeClaim(c, pvc2.Name, ns)
			Expect(err).NotTo(HaveOccurred())
			pvc2 = nil

			By("Restarting the kube-controller-manager")
			err = framework.RestartControllerManager()
			Expect(err).NotTo(HaveOccurred())
			err = framework.WaitForControllerManagerUp()
			Expect(err).NotTo(HaveOccurred())
			framework.Logf("kube-controller-manager restarted")

			By("Observing the kube-controller-manager healthy for at least 2 minutes")
			// Continue checking for 2 minutes to make sure kube-controller-manager is healthy
			err = framework.CheckForControllerManagerHealthy(2 * time.Minute)
			Expect(err).NotTo(HaveOccurred())
		})

	})

	Context("when kubelet restarts", func() {
		var (
			clientPod *v1.Pod
			pv        *v1.PersistentVolume
			pvc       *v1.PersistentVolumeClaim
		)

		BeforeEach(func() {
			framework.Logf("Initializing test spec")
			clientPod, pv, pvc = initTestCase(f, c, nfsPVconfig, pvcConfig, ns, clientNode.Name)
		})

		AfterEach(func() {
			framework.Logf("Tearing down test spec")
			tearDownTestCase(c, f, ns, clientPod, pvc, pv)
			pv, pvc, clientPod = nil, nil, nil
		})

		// Test table housing the It() title string and test spec.  runTest is type testBody, defined at
		// the start of this file.  To add tests, define a function mirroring the testBody signature and assign
		// to runTest.
		disruptiveTestTable := []disruptiveTest{
			{
				testItStmt: "Should test that a file written to the mount before kubelet restart is readable after restart.",
				runTest:    utils.TestKubeletRestartsAndRestoresMount,
			},
			{
				testItStmt: "Should test that a volume mounted to a pod that is deleted while the kubelet is down unmounts when the kubelet returns.",
				runTest:    utils.TestVolumeUnmountsFromDeletedPod,
			},
			{
				testItStmt: "Should test that a volume mounted to a pod that is force deleted while the kubelet is down unmounts when the kubelet returns.",
				runTest:    utils.TestVolumeUnmountsFromForceDeletedPod,
			},
		}

		// Test loop executes each disruptiveTest iteratively.
		for _, test := range disruptiveTestTable {
			func(t disruptiveTest) {
				It(t.testItStmt, func() {
					By("Executing Spec")
					t.runTest(c, f, clientPod, pvc)
				})
			}(test)
		}
	})
})

// initTestCase initializes spec resources (pv, pvc, and pod) and returns pointers to be consumed
// by the test.
func initTestCase(f *framework.Framework, c clientset.Interface, pvConfig framework.PersistentVolumeConfig, pvcConfig framework.PersistentVolumeClaimConfig, ns, nodeName string) (*v1.Pod, *v1.PersistentVolume, *v1.PersistentVolumeClaim) {
	pv, pvc, err := framework.CreatePVPVC(c, pvConfig, pvcConfig, ns, false)
	defer func() {
		if err != nil {
			framework.DeletePersistentVolumeClaim(c, pvc.Name, ns)
			framework.DeletePersistentVolume(c, pv.Name)
		}
	}()
	Expect(err).NotTo(HaveOccurred())
	pod := framework.MakePod(ns, nil, []*v1.PersistentVolumeClaim{pvc}, true, "")
	pod.Spec.NodeName = nodeName
	framework.Logf("Creating NFS client pod.")
	pod, err = c.CoreV1().Pods(ns).Create(pod)
	framework.Logf("NFS client Pod %q created on Node %q", pod.Name, nodeName)
	Expect(err).NotTo(HaveOccurred())
	defer func() {
		if err != nil {
			framework.DeletePodWithWait(f, c, pod)
		}
	}()
	err = framework.WaitForPodRunningInNamespace(c, pod)
	Expect(err).NotTo(HaveOccurred(), fmt.Sprintf("Pod %q timed out waiting for phase: Running", pod.Name))
	// Return created api objects
	pod, err = c.CoreV1().Pods(ns).Get(pod.Name, metav1.GetOptions{})
	Expect(err).NotTo(HaveOccurred())
	pvc, err = c.CoreV1().PersistentVolumeClaims(ns).Get(pvc.Name, metav1.GetOptions{})
	Expect(err).NotTo(HaveOccurred())
	pv, err = c.CoreV1().PersistentVolumes().Get(pv.Name, metav1.GetOptions{})
	Expect(err).NotTo(HaveOccurred())
	return pod, pv, pvc
}

// tearDownTestCase destroy resources created by initTestCase.
func tearDownTestCase(c clientset.Interface, f *framework.Framework, ns string, client *v1.Pod, pvc *v1.PersistentVolumeClaim, pv *v1.PersistentVolume) {
	// Ignore deletion errors.  Failing on them will interrupt test cleanup.
	framework.DeletePodWithWait(f, c, client)
	framework.DeletePersistentVolumeClaim(c, pvc.Name, ns)
	if pv != nil {
		framework.DeletePersistentVolume(c, pv.Name)
	}
}


text:
#include <stdlib.h>
#include <string.h>
#include <glib/gstdio.h>

#include "build.h"
#include "parser.h"
#include "writer.h"
#include "scope.h"
#include "options.h"
#include "log.h"

char** ref_build_make_argv(const ref_options* opts, const char* file)
{
	char** cflags = NULL;
	if (opts->cflags)
		cflags = g_strsplit(opts->cflags, " ", 0);

	int argc = 0;
	if (cflags)
		for(; cflags[argc]; argc++);

	char** argv = malloc(sizeof *argv * (argc + 4));
	argv[0] = g_strdup(opts->cc);
	argv[argc + 1] = g_strdup("-xc");
	argv[argc + 2] = g_strdup(file);
	argv[argc + 3] = NULL;
	if (cflags)
	{
		for (; argc != 0; argc--)
			argv[argc] = cflags[argc - 1];
	}

	g_free(cflags);
	return (argv);
}

int ref_build(ref_options* opts, const char* file)
{
	ref_pid pid = ref_pid_invalid;
	ref_pipe(pipe) = ref_pipe_invalid;

	if ((opts->pipe || strcmp(opts->output_file, "-") == 0) && !opts->nobuild)
		pid = ref_build_make_pipe(opts, pipe);

	ref_parse_ctx ctx;
	if (!ref_parse_ctx_init(&ctx, opts))
	{
		ref_build_close_pipe(pipe);
		return (EXIT_FAILURE);
	}

	int status = ref_parse_file(&ctx, file);
	if (status == EXIT_FAILURE)
	{
		if (ctx.scopes)
			ref_scope_free(ctx.scopes->data);
		ref_parse_ctx_free(&ctx);
		ref_build_close_pipe(pipe);
		return (EXIT_FAILURE);
	}

	ref_parse_scope* result = ctx.scopes->data;
	ref_parse_ctx_free(&ctx);

	if (opts->pipe)
		status = ref_write_source("-", result);
	else
		status = ref_write_source(opts->output_file, result);

	if (result)
		ref_scope_free(result);
	ref_build_close_pipe(pipe);

	if (status == EXIT_SUCCESS)
	{
		if (!opts->nobuild && pid == ref_pid_invalid)
			pid = ref_build_run_compiler(opts, opts->output_file, NULL);
		if (ref_build_wait_for_compiler(pid) != EXIT_SUCCESS)
			status = EXIT_FAILURE;
	}
	if (!opts->pipe && strcmp(opts->output_file, "-") != 0 &&
		(status != EXIT_SUCCESS || !opts->keep_tmp)
	)
		g_unlink(opts->output_file);

	return (status);
}


text:
module CC
  module Engine
    module Analyzers
      class ParserBase
        private

        def parse_json(text)
          JSON.parse(text, max_nesting: false)
        end
      end
    end
  end
end