@CompileStatic
class ConfigurationSpec extends MultiSectionHandler {
    private final String name
    private final Supplier<Boolean> isCreate

    ConfigurationSpec(String name, Supplier<Boolean> isCreate) {
        this.name = name
        this.isCreate = isCreate
    }

    @Override
    String getSectionName() {
        name
    }

    void extendsFrom(String... superConfs) {

func parseKV(kv *mvccpb.KeyValue) *event {
	return &event{
		key:       string(kv.Key),
		value:     kv.Value,
		prevValue: nil,
		rev:       kv.ModRevision,
		isDeleted: false,
		isCreated: true,
	}
}

func parseEvent(e *clientv3.Event) (*event, error) {
	if !e.IsCreate() && e.PrevKv == nil {

						isCreateEvent := event.IsModify() || event.IsCreate()
						isDeleteEvent := event.Type == etcd.EventTypeDelete

						switch {
						case isCreateEvent:
							ch <- iamWatchEvent{
								isCreated: true,
								keyPath:   string(event.Kv.Key),
							}
						case isDeleteEvent:
							ch <- iamWatchEvent{
								isCreated: false,
								keyPath:   string(event.Kv.Key),
							}

		case event, ok := <-sc.certWatcher.Events:
			// Channel is closed.
			if !ok {
				return
			}
			// We only care about updates that change the file content
			if !(isWrite(event) || isRemove(event) || isCreate(event)) {
				continue
			}
			sc.certMutex.RLock()
			resources := make(map[FileCert]struct{})
			for k, v := range sc.fileCerts {
				resources[k] = v
			}
			sc.certMutex.RUnlock()

					Value:          []byte("value"),
				},
			},
			expectedEvent: &event{
				key:       "key",
				value:     []byte("value"),
				prevValue: nil,
				rev:       1,
				isDeleted: false,
				isCreated: true,
			},
			expectedErr: "",
		},
		{
			name: "unsuccessful delete",
			etcdEvent: &clientv3.Event{
				Type:   mvccpb.DELETE,
				PrevKv: nil,
				Kv: &mvccpb.KeyValue{

        this.buildServices = buildServices;
        controller = factory.newController(displayName, State.NotCreated);
    }

    public boolean isCreated() {
        return project != null;
    }

    public void createMutableModel(
        DefaultProjectDescriptor descriptor,
        BuildState build,
        ProjectState owner,

        BuildProjectRegistry projectsForThisBuild = getProjectStateRegistry().findProjectsFor(getBuildIdentifier());
        return projectsForThisBuild != null && projectsForThisBuild.getRootProject().isCreated();
    }

    @Override
    public void ensureProjectsConfigured() {
        getBuildController().configureProjects();
    }

    @Override
    public GradleInternal getMutableModel() {

     */
    boolean isProjectsLoaded();

    /**
     * Has the mutable model for projects been created yet?
     *
     * @see ProjectState#isCreated()
     */
    boolean isProjectsCreated();

    /**
     * Ensures all projects in this build are configured, if not already done.
     */
    void ensureProjectsConfigured();

    /**

        }

        @Override
        public int getDepth() {
            return depth.get();
        }

        @Override
        public boolean isCreated() {
            return controller.isCreated();
        }

        @Override
        public void createMutableModel(ClassLoaderScope selfClassLoaderScope, ClassLoaderScope baseClassLoaderScope) {

     */
    ProjectComponentIdentifier getComponentIdentifier();

    /**
     * Is the mutable model for this project available?
     */
    boolean isCreated();

    /**
     * Creates the mutable model for this project.
     */
    void createMutableModel(ClassLoaderScope selfClassLoaderScope, ClassLoaderScope baseClassLoaderScope);

    /**