org.apache.flink.runtime.jobmaster.SlotOwner Java Examples

@Nonnull
static SingleLogicalSlot createSingleLogicalSlot(SlotOwner slotOwner, TaskManagerGateway taskManagerGateway, SlotRequestId slotRequestId) {
	TaskManagerLocation location = new TaskManagerLocation(
		ResourceID.generate(), InetAddress.getLoopbackAddress(), 12345);

	SimpleSlotContext slotContext = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		taskManagerGateway);

	return new SingleLogicalSlot(
		slotRequestId,
		slotContext,
		null,
		Locality.LOCAL,
		slotOwner);
}
 

@Nonnull
private ProgrammedSlotProvider createProgrammedSlotProvider(
	int parallelism,
	Collection<JobVertexID> jobVertexIds,
	SlotOwner slotOwner) {
	final ProgrammedSlotProvider slotProvider = new ProgrammedSlotProvider(parallelism);

	for (JobVertexID jobVertexId : jobVertexIds) {
		for (int i = 0; i < parallelism; i++) {
			final LogicalSlot slot = createTestingLogicalSlot(slotOwner);

			slotProvider.addSlot(jobVertexId, 0, CompletableFuture.completedFuture(slot));
		}
	}

	return slotProvider;
}
 

@Nonnull
static SingleLogicalSlot createSingleLogicalSlot(SlotOwner slotOwner, TaskManagerGateway taskManagerGateway, SlotRequestId slotRequestId) {
	TaskManagerLocation location = new TaskManagerLocation(
		ResourceID.generate(), InetAddress.getLoopbackAddress(), 12345);

	SimpleSlotContext slotContext = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		taskManagerGateway);

	return new SingleLogicalSlot(
		slotRequestId,
		slotContext,
		null,
		Locality.LOCAL,
		slotOwner);
}
 

private void initializeLocation(ExecutionVertex vertex, TaskManagerLocation location) throws Exception {
	// we need a bit of reflection magic to initialize the location without going through
	// scheduling paths. we choose to do that, rather than the alternatives:
	//  - mocking the scheduler created fragile tests that break whenever the scheduler is adjusted
	//  - exposing test methods in the ExecutionVertex leads to undesirable setters 

	SlotContext slotContext = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		mock(TaskManagerGateway.class));



	LogicalSlot slot = new SingleLogicalSlot(
		new SlotRequestId(),
		slotContext,
		null,
		Locality.LOCAL,
		mock(SlotOwner.class));

	if (!vertex.getCurrentExecutionAttempt().tryAssignResource(slot)) {
		throw new FlinkException("Could not assign resource.");
	}
}
 

public static SingleLogicalSlot allocateFromPhysicalSlot(
		final SlotRequestId slotRequestId,
		final PhysicalSlot physicalSlot,
		final Locality locality,
		final SlotOwner slotOwner,
		final boolean slotWillBeOccupiedIndefinitely) {

	final SingleLogicalSlot singleTaskSlot = new SingleLogicalSlot(
		slotRequestId,
		physicalSlot,
		null,
		locality,
		slotOwner,
		slotWillBeOccupiedIndefinitely);

	if (physicalSlot.tryAssignPayload(singleTaskSlot)) {
		return singleTaskSlot;
	} else {
		throw new IllegalStateException("BUG: Unexpected physical slot payload assignment failure!");
	}
}
 

public SingleLogicalSlot(
		SlotRequestId slotRequestId,
		SlotContext slotContext,
		@Nullable SlotSharingGroupId slotSharingGroupId,
		Locality locality,
		SlotOwner slotOwner,
		boolean willBeOccupiedIndefinitely) {
	this.slotRequestId = Preconditions.checkNotNull(slotRequestId);
	this.slotContext = Preconditions.checkNotNull(slotContext);
	this.slotSharingGroupId = slotSharingGroupId;
	this.locality = Preconditions.checkNotNull(locality);
	this.slotOwner = Preconditions.checkNotNull(slotOwner);
	this.willBeOccupiedIndefinitely = willBeOccupiedIndefinitely;
	this.releaseFuture = new CompletableFuture<>();

	this.state = State.ALIVE;
	this.payload = null;
}
 

@Nonnull
private ProgrammedSlotProvider createProgrammedSlotProvider(
	int parallelism,
	Collection<JobVertexID> jobVertexIds,
	SlotOwner slotOwner) {
	final ProgrammedSlotProvider slotProvider = new ProgrammedSlotProvider(parallelism);

	for (JobVertexID jobVertexId : jobVertexIds) {
		for (int i = 0; i < parallelism; i++) {
			final LogicalSlot slot = createTestingLogicalSlot(slotOwner);

			slotProvider.addSlot(jobVertexId, 0, CompletableFuture.completedFuture(slot));
		}
	}

	return slotProvider;
}
 

@Nonnull
static SingleLogicalSlot createSingleLogicalSlot(SlotOwner slotOwner, TaskManagerGateway taskManagerGateway, SlotRequestId slotRequestId) {
	TaskManagerLocation location = new TaskManagerLocation(
		ResourceID.generate(), InetAddress.getLoopbackAddress(), 12345);

	SimpleSlotContext slotContext = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		taskManagerGateway);

	return new SingleLogicalSlot(
		slotRequestId,
		slotContext,
		null,
		Locality.LOCAL,
		slotOwner);
}
 

private void initializeLocation(ExecutionVertex vertex, TaskManagerLocation location) throws Exception {
	// we need a bit of reflection magic to initialize the location without going through
	// scheduling paths. we choose to do that, rather than the alternatives:
	//  - mocking the scheduler created fragile tests that break whenever the scheduler is adjusted
	//  - exposing test methods in the ExecutionVertex leads to undesirable setters 

	SlotContext slotContext = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		mock(TaskManagerGateway.class));



	LogicalSlot slot = new SingleLogicalSlot(
		new SlotRequestId(),
		slotContext,
		null,
		Locality.LOCAL,
		mock(SlotOwner.class));

	if (!vertex.getCurrentExecutionAttempt().tryAssignResource(slot)) {
		throw new FlinkException("Could not assign resource.");
	}
}
 

public SingleLogicalSlot(
		SlotRequestId slotRequestId,
		SlotContext slotContext,
		@Nullable SlotSharingGroupId slotSharingGroupId,
		Locality locality,
		SlotOwner slotOwner) {
	this.slotRequestId = Preconditions.checkNotNull(slotRequestId);
	this.slotContext = Preconditions.checkNotNull(slotContext);
	this.slotSharingGroupId = slotSharingGroupId;
	this.locality = Preconditions.checkNotNull(locality);
	this.slotOwner = Preconditions.checkNotNull(slotOwner);
	this.releaseFuture = new CompletableFuture<>();

	this.state = State.ALIVE;
	this.payload = null;
}
 

@Nonnull
private ProgrammedSlotProvider createProgrammedSlotProvider(
	int parallelism,
	Collection<JobVertexID> jobVertexIds,
	SlotOwner slotOwner) {
	final ProgrammedSlotProvider slotProvider = new ProgrammedSlotProvider(parallelism);

	for (JobVertexID jobVertexId : jobVertexIds) {
		for (int i = 0; i < parallelism; i++) {
			final SimpleSlot slot = new SimpleSlot(
				slotOwner,
				new LocalTaskManagerLocation(),
				0,
				new SimpleAckingTaskManagerGateway(),
				null,
				null);

			slotProvider.addSlot(jobVertexId, 0, CompletableFuture.completedFuture(slot));
		}
	}

	return slotProvider;
}
 

public SingleLogicalSlot(
		SlotRequestId slotRequestId,
		SlotContext slotContext,
		@Nullable SlotSharingGroupId slotSharingGroupId,
		Locality locality,
		SlotOwner slotOwner) {
	this.slotRequestId = Preconditions.checkNotNull(slotRequestId);
	this.slotContext = Preconditions.checkNotNull(slotContext);
	this.slotSharingGroupId = slotSharingGroupId;
	this.locality = Preconditions.checkNotNull(locality);
	this.slotOwner = Preconditions.checkNotNull(slotOwner);
	this.releaseFuture = new CompletableFuture<>();

	this.state = State.ALIVE;
	this.payload = null;
}
 

private void initializeLocation(ExecutionVertex vertex, TaskManagerLocation location) throws Exception {
	// we need a bit of reflection magic to initialize the location without going through
	// scheduling paths. we choose to do that, rather than the alternatives:
	//  - mocking the scheduler created fragile tests that break whenever the scheduler is adjusted
	//  - exposing test methods in the ExecutionVertex leads to undesirable setters 

	SlotContext slot = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		mock(TaskManagerGateway.class));

	SimpleSlot simpleSlot = new SimpleSlot(slot, mock(SlotOwner.class), 0);

	if (!vertex.getCurrentExecutionAttempt().tryAssignResource(simpleSlot)) {
		throw new FlinkException("Could not assign resource.");
	}
}
 

/**
 * Creates a new simple slot that belongs to the given shared slot and
 * is identified by the given ID.
 *
 * @param owner The component from which this slot is allocated.
 * @param location The location info of the TaskManager where the slot was allocated from
 * @param slotNumber The number of the simple slot in its parent shared slot.
 * @param taskManagerGateway to communicate with the associated task manager.
 * @param parent The parent shared slot.
 * @param groupID The ID that identifies the group that the slot belongs to.
 */
public SimpleSlot(
		SlotOwner owner,
		TaskManagerLocation location,
		int slotNumber,
		TaskManagerGateway taskManagerGateway,
		@Nullable SharedSlot parent,
		@Nullable AbstractID groupID) {

	super(
		parent != null ?
			parent.getSlotContext() :
			new SimpleSlotContext(
				NO_ALLOCATION_ID,
				location,
				slotNumber,
				taskManagerGateway),
		owner,
		slotNumber,
		parent,
		groupID);
}
 

/**
 * Base constructor for slots.
 * 
 * <p>This is the old way of constructing slots by the legacy code
 * 
 * @param owner The component from which this slot is allocated.
 * @param location The location info of the TaskManager where the slot was allocated from
 * @param slotNumber The number of this slot.
 * @param taskManagerGateway The actor gateway to communicate with the TaskManager
 * @param parent The parent slot that contains this slot. May be null, if this slot is the root.
 * @param groupID The ID that identifies the task group for which this slot is allocated. May be null
 *                if the slot does not belong to any task group.   
 */
protected Slot(
		SlotOwner owner,
		TaskManagerLocation location,
		int slotNumber,
		TaskManagerGateway taskManagerGateway,
		@Nullable SharedSlot parent,
		@Nullable AbstractID groupID) {

	checkArgument(slotNumber >= 0);

	// create a simple slot context
	this.slotContext = new SimpleSlotContext(
		NO_ALLOCATION_ID,
		location,
		slotNumber,
		taskManagerGateway);

	this.owner = checkNotNull(owner);
	this.parent = parent; // may be null
	this.groupID = groupID; // may be null
	this.slotNumber = slotNumber;
}
 

SlotSharingManager(
		SlotSharingGroupId slotSharingGroupId,
		AllocatedSlotActions allocatedSlotActions,
		SlotOwner slotOwner) {
	this.slotSharingGroupId = Preconditions.checkNotNull(slotSharingGroupId);
	this.allocatedSlotActions = Preconditions.checkNotNull(allocatedSlotActions);
	this.slotOwner = Preconditions.checkNotNull(slotOwner);

	allTaskSlots = new HashMap<>(16);
	unresolvedRootSlots = new HashMap<>(16);
	resolvedRootSlots = new HashMap<>(16);
}
 

private SharedSlot(
		SlotContext slotInformation,
		SlotOwner owner,
		int slotNumber,
		SlotSharingGroupAssignment assignmentGroup,
		@Nullable SharedSlot parent,
		@Nullable AbstractID groupId) {

	super(slotInformation, owner, slotNumber, parent, groupId);

	this.assignmentGroup = checkNotNull(assignmentGroup);
	this.subSlots = new HashSet<Slot>();
}
 

private SingleLogicalSlot createSingleLogicalSlot(SlotOwner slotOwner) {
	return new SingleLogicalSlot(
		new SlotRequestId(),
		createSlotContext(),
		null,
		Locality.LOCAL,
		slotOwner);
}
 

SlotSharingManager(
		SlotSharingGroupId slotSharingGroupId,
		AllocatedSlotActions allocatedSlotActions,
		SlotOwner slotOwner) {
	this.slotSharingGroupId = Preconditions.checkNotNull(slotSharingGroupId);
	this.allocatedSlotActions = Preconditions.checkNotNull(allocatedSlotActions);
	this.slotOwner = Preconditions.checkNotNull(slotOwner);

	allTaskSlots = new HashMap<>(16);
	unresolvedRootSlots = new HashMap<>(16);
	resolvedRootSlots = new HashMap<>(16);
}
 

@VisibleForTesting
public SingleLogicalSlot(
	SlotRequestId slotRequestId,
	SlotContext slotContext,
	@Nullable SlotSharingGroupId slotSharingGroupId,
	Locality locality,
	SlotOwner slotOwner) {

	this(slotRequestId, slotContext, slotSharingGroupId, locality, slotOwner, true);
}
 

/**
 * Base constructor for slots.
 *
 * @param slotContext The slot context of this slot.
 * @param owner The component from which this slot is allocated.
 * @param slotNumber The number of this slot.
 * @param parent The parent slot that contains this slot. May be null, if this slot is the root.
 * @param groupID The ID that identifies the task group for which this slot is allocated. May be null
 *                if the slot does not belong to any task group.   
 */
protected Slot(
		SlotContext slotContext,
		SlotOwner owner,
		int slotNumber,
		@Nullable SharedSlot parent,
		@Nullable AbstractID groupID) {

	this.slotContext = checkNotNull(slotContext);
	this.owner = checkNotNull(owner);
	this.parent = parent; // may be null
	this.groupID = groupID; // may be null
	this.slotNumber = slotNumber;
}
 

private SingleLogicalSlot createSingleLogicalSlot(SlotOwner slotOwner) {
	return new SingleLogicalSlot(
		new SlotRequestId(),
		createSlotContext(),
		null,
		Locality.LOCAL,
		slotOwner);
}
 

SlotSharingManager(
		SlotSharingGroupId slotSharingGroupId,
		AllocatedSlotActions allocatedSlotActions,
		SlotOwner slotOwner) {
	this.slotSharingGroupId = Preconditions.checkNotNull(slotSharingGroupId);
	this.allocatedSlotActions = Preconditions.checkNotNull(allocatedSlotActions);
	this.slotOwner = Preconditions.checkNotNull(slotOwner);

	allTaskSlots = new HashMap<>(16);
	unresolvedRootSlots = new HashMap<>(16);
	resolvedRootSlots = new HashMap<>(16);
}
 

public static SimpleSlot createMockSimpleSlot(TaskManagerGateway gateway) {
	final TaskManagerLocation location = new TaskManagerLocation(
			ResourceID.generate(), InetAddress.getLoopbackAddress(), 6572);

	final SimpleSlotContext allocatedSlot = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		gateway);

	return new SimpleSlot(
		allocatedSlot,
		mock(SlotOwner.class),
		0);
}
 

private SimpleSlot createSlot(TaskManagerGateway taskManager, JobID jobId, SlotOwner slotOwner) {
	TaskManagerLocation location = new TaskManagerLocation(
			ResourceID.generate(), InetAddress.getLoopbackAddress(), 12345);

	SimpleSlotContext slot = new SimpleSlotContext(
		new AllocationID(),
		location,
		0,
		taskManager);

	return new SimpleSlot(slot, slotOwner, 0);
}
 

private SimpleSlot createSlot(TaskManagerLocation taskManagerLocation, int index) {
	return new SimpleSlot(
		mock(SlotOwner.class),
		taskManagerLocation,
		index,
		new SimpleAckingTaskManagerGateway());
}
 

private SingleLogicalSlot createSingleLogicalSlot(SlotOwner slotOwner) {
	return new SingleLogicalSlot(
		new SlotRequestId(),
		new DummySlotContext(),
		null,
		Locality.LOCAL,
		slotOwner);
}
 

private TestingLogicalSlot createTestingLogicalSlot(SlotOwner slotOwner) {
	return new TestingLogicalSlotBuilder()
		.setSlotOwner(slotOwner)
		.createTestingLogicalSlot();
}
 

/**
 * Creates a new shared slot that has is a sub-slot of the given parent shared slot, and that belongs
 * to the given task group.
 *
 * @param owner The component from which this slot is allocated.
 * @param location The location info of the TaskManager where the slot was allocated from
 * @param slotNumber The number of the slot.
 * @param taskManagerGateway The gateway to communicate with the TaskManager
 * @param assignmentGroup The assignment group that this shared slot belongs to.
 * @param parent The parent slot of this slot.
 * @param groupId The assignment group of this slot.
 */
public SharedSlot(
		SlotOwner owner,
		TaskManagerLocation location,
		int slotNumber,
		TaskManagerGateway taskManagerGateway,
		SlotSharingGroupAssignment assignmentGroup,
		@Nullable SharedSlot parent,
		@Nullable AbstractID groupId) {

	super(owner, location, slotNumber, taskManagerGateway, parent, groupId);

	this.assignmentGroup = checkNotNull(assignmentGroup);
	this.subSlots = new HashSet<Slot>();
}
 

private TestingLogicalSlot createTestingLogicalSlot(SlotOwner slotOwner) {
	return new TestingLogicalSlotBuilder()
		.setSlotOwner(slotOwner)
		.createTestingLogicalSlot();
}