}
	defer c.queue.Done(pvKey)

	pvName := pvKey

	err := c.processPV(ctx, pvName)
	if err == nil {
		c.queue.Forget(pvKey)
		return true
	}

	utilruntime.HandleError(fmt.Errorf("PV %v failed with : %v", pvKey, err))
	c.queue.AddRateLimited(pvKey)

	return true
}

func (c *Controller) processPV(ctx context.Context, pvName string) error {
	logger := klog.FromContext(ctx)

        };
    };

    ModuleComponentResolveMetadata processMetadata(ModuleComponentResolveMetadata metadata);

    /**
     * Processes "shallow" metadata, only for selecting a version. This metadata is typically
     * provided by a custom metadata processor.
     * @param metadata the metadata to be processed
     * @return updated metadata, if any component metadata rule applies.
     */

    JsonOutput.toJson(sorted)
}

private File findProcessedDirectory() {
    int cpt = 0
    File processedDir
    while (processedDir == null) {
        processedDir = new File("processed-${cpt++}")
        if (processedDir.exists()) {
            processedDir = null
        }
    }
    processedDir.mkdirs()
    return processedDir

process-ram.svg...

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

publishing-process.png...

                    <mxGeometry relative="1" as="geometry"/>
                </mxCell>

        then:
        skipped(':compileJava')
        executedAndNotSkipped(':compileScala')
        new File(testDirectory, 'generated.txt').exists()
    }

    def "processes annotation for Java class with processor option if annotation processor is available on processor path"() {
        when:
        AnnotationProcessorPublisher annotationProcessorPublisher = new AnnotationProcessorPublisher()
        annotationProcessorPublisher.writeSourceFiles()

import org.gradle.internal.time.Clock;
import org.gradle.process.internal.worker.WorkerProcessContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.security.AccessControlException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**

        when:
        handler.executeScripts(gradle)

        then:
        1 * processor.process({ TextResourceScriptSource source -> source.resource.file == script1 }, gradle)
        1 * processor.process({ TextResourceScriptSource source -> source.resource.file == script2 }, gradle)
        0 * executor._
        0 * processor._
    }