toAllocate := []int{
		10000,
		10030,
		10030,
		10040,
	}
	expectedErrors := []error{
		ErrAllocated,
		nil,
		ErrAllocated,
		nil,
	}
	op := StartOperation(r, true)
	for i, port := range toAllocate {
		err := op.Allocate(port)
		if err != expectedErrors[i] {
			t.Errorf("%v: expected error %v but got %v", i, expectedErrors[i], err)
		}
	}

        synchronized (lock) {
            DefaultResourceLockState resourceLockState = new DefaultResourceLockState();
            DefaultResourceLockState previous = startOperation(resourceLockState);
            try {
                while (true) {
                    ResourceLockState.Disposition disposition;
                    disposition = stateLockAction.transform(resourceLockState);

	shouldRollback  bool
	dryRun          bool
}

// Creates a portAllocationOperation, tracking a set of allocations & releases
// If dryRun is specified, never actually allocate or release anything
func StartOperation(pa Interface, dryRun bool) *PortAllocationOperation {
	op := &PortAllocationOperation{}
	op.pa = pa
	op.allocated = []int{}
	op.releaseDeferred = []int{}
	op.shouldRollback = true
	op.dryRun = dryRun
	return op

	}

	return released, nil
}

func (al *Allocators) txnAllocNodePorts(service *api.Service, dryRun bool) (transaction, error) {
	// The allocator tracks dry-run-ness internally.
	nodePortOp := portallocator.StartOperation(al.serviceNodePorts, dryRun)

	txn := callbackTransaction{
		commit: func() {
			nodePortOp.Commit()
			// We don't NEED to call Finish() here, but for that package says
			// to, so for future-safety, we will.