- If anything bad happens, feel free to delete the project you created and retry (you may need to apply `Synchronization disabled` before deleting it).  
    
If no errors, your new pipeline will be displayed on TeamCity web UI:

```
Gradle
|------ Master
|        |--------- ...
|
|------ Release
|        |--------- ...
|                

			expectedLabels: namespace2Labels,
		},
		{
			name:           "request is for deleting namespace, the labels should be from the cache",

        try (Stream<Path> walk = Files.walk(dir, FileVisitOption.FOLLOW_LINKS)) {
            walk.sorted(Comparator.reverseOrder()).forEach(f -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("Deleting {}", f);
                }
                try {
                    Files.delete(f);
                } catch (final IOException e) {
                    logger.warn("Failed to delete {}", f, e);
                }

=== Removing the local module source

With module artifacts available in a repository, we can now remove the module sources from the build. Since the composite is configured to automatically load available modules, this is as easy as deleting one or more module directories.

```
rm -r modules/string-utils
gradle run
```

 * Watching the build root directories is better since they are less likely to be deleted and
 * nearly no changes to the watched directories are necessary when running builds on the same project.
 *
 * To allow deleting the build root directories, we need to stop watching a build root directory if there are no more snapshots in the VFS inside,
 * since watched directories can't be deleted on Windows.
 *

        when:
        invalidateBuildOutputCleanupState()
        waitForChangesToBePickedUp()
        withWatchFs().run ":producer", "--info"
        then:
        output.contains("Deleting stale output file: ${outputFile.absolutePath}")
        executedAndNotSkipped(":producer")
        outputFile.assertExists()
    }

    def "detects non-incremental cleanup of incremental tasks"() {

	defer func() {
		e := ctx.ConfigKube(cluster).YAML("", dummyValidationVirtualService).Delete()
		if e != nil {
			scopes.Framework.Warnf("error deleting dummy virtual service for waiting the validation webhook: %v", e)
		}
	}()

	scopes.Framework.Info("Creating dummy virtual service to check for validation webhook readiness")
	return retry.UntilSuccess(func() error {

								err := cluster.Kube().CoreV1().Services(echos.Namespace.Name()).Delete(
									context.TODO(), common.ServiceB, metav1.DeleteOptions{})
								if err != nil {
									ctx.Fatalf("failed deleting service %s/%s in cluster %s: %v",
										echos.Namespace, common.ServiceB, cluster.Name(), err)
								}
								retry.UntilSuccessOrFail(t, func() error {

	}
	defer c.policyQueue.Done(key)

	err := func() error {
		policy, err := c.policyInformer.Lister().Get(key)
		if err != nil {
			if kerrors.IsNotFound(err) {
				// If not found, the policy is being deleting, do nothing.
				return nil
			}
			return err
		}
		return c.reconcile(ctx, policy)
	}()

	if err == nil {
		c.policyQueue.Forget(key)
		return true
	}

	// If the request itself is creating or updating a namespace, then get the
	// labels from attr.Object, because namespaceLister doesn't have the latest
	// namespace yet.
	//
	// However, if the request is deleting a namespace, then get the label from
	// the namespace in the namespaceLister, because a delete request is not
	// going to change the object, and attr.Object will be a DeleteOptions
	// rather than a namespace object.