diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ResourceChangeContext.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ResourceChangeContext.java new file mode 100644 index 0000000..38d5ef3 --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ResourceChangeContext.java @@ -0,0 +1,56 @@ +package org.apache.hadoop.yarn.api.records; + +import org.apache.hadoop.classification.InterfaceAudience.Public; +import org.apache.hadoop.yarn.util.Records; + +@Public +public abstract class ResourceChangeContext { + @Public + public static ResourceChangeContext newInstance( + ContainerId existingContainerId, Resource targetCapability) { + ResourceChangeContext context = Records + .newRecord(ResourceChangeContext.class); + context.setExistingContainerId(existingContainerId); + context.setTargetCapability(targetCapability); + return context; + } + + @Public + public abstract ContainerId getExistingContainerId(); + + @Public + public abstract void setExistingContainerId(ContainerId existingContainerId); + + @Public + public abstract Resource getTargetCapability(); + + @Public + public abstract void setTargetCapability(Resource targetCapability); + + @Override + public boolean equals(Object other) { + if (other instanceof ResourceChangeContext) { + ResourceChangeContext ctx = (ResourceChangeContext)other; + + if ((getExistingContainerId() == null) ^ (ctx.getExistingContainerId() == null)) { + return false; + } else if (ctx.getExistingContainerId() != null) { + if (!getExistingContainerId().equals(ctx.getExistingContainerId())) { + return false; + } + } + + if ((getTargetCapability() == null) ^ (ctx.getTargetCapability() == null)) { + return false; + } else if (ctx.getTargetCapability() != null) { + if (!getTargetCapability().equals(ctx.getTargetCapability())) { + return false; + } + } + + return true; + } else { + return false; + } + } +} diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ResourceIncreaseContext.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ResourceIncreaseContext.java new file mode 100644 index 0000000..98d602d --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ResourceIncreaseContext.java @@ -0,0 +1,46 @@ +package org.apache.hadoop.yarn.api.records; + +import org.apache.hadoop.classification.InterfaceAudience.Public; +import org.apache.hadoop.yarn.util.Records; + +@Public +public abstract class ResourceIncreaseContext { + @Public + public static ResourceIncreaseContext newInstance( + ResourceChangeContext changeContext, Token containerToken) { + ResourceIncreaseContext context = Records + .newRecord(ResourceIncreaseContext.class); + context.setResourceChangeContext(changeContext); + context.setContainerToken(containerToken); + return context; + } + + @Public + public abstract ResourceChangeContext getResourceChangeContext(); + + @Public + public abstract void setResourceChangeContext(ResourceChangeContext context); + + @Public + public abstract Token getContainerToken(); + + @Public + public abstract void setContainerToken(Token token); + + @Override + public boolean equals(Object other) { + if (other instanceof ResourceIncreaseContext) { + ResourceIncreaseContext ctx = (ResourceIncreaseContext)other; + if ((getResourceChangeContext() == null) ^ (ctx == null)) { + return false; + } else { + if (getResourceChangeContext() != null) { + return getResourceChangeContext().equals(ctx.getResourceChangeContext()); + } + } + return true; + } else { + return false; + } + } +} diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/proto/yarn_protos.proto b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/proto/yarn_protos.proto index 9d4d59e..b70e79b 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/proto/yarn_protos.proto +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/proto/yarn_protos.proto @@ -311,6 +311,16 @@ enum ContainerExitStatusProto { DISKS_FAILED = -101; } +message ResourceChangeContextProto { + optional ContainerIdProto container_id = 1; + optional ResourceProto target_capability = 2; +} + +message ResourceIncreaseContextProto { + optional ResourceChangeContextProto context = 1; + optional hadoop.common.TokenProto container_token = 2; +} + //////////////////////////////////////////////////////////////////////// ////// From common////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ResourceChangeContextPBImpl.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ResourceChangeContextPBImpl.java new file mode 100644 index 0000000..cb67372 --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ResourceChangeContextPBImpl.java @@ -0,0 +1,118 @@ +package org.apache.hadoop.yarn.api.records.impl.pb; + +import org.apache.hadoop.yarn.api.records.ContainerId; +import org.apache.hadoop.yarn.api.records.Resource; +import org.apache.hadoop.yarn.api.records.ResourceChangeContext; +import org.apache.hadoop.yarn.proto.YarnProtos.ContainerIdProto; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceChangeContextProto; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceChangeContextProtoOrBuilder; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceProto; + +public class ResourceChangeContextPBImpl extends ResourceChangeContext { + ResourceChangeContextProto proto = ResourceChangeContextProto + .getDefaultInstance(); + ResourceChangeContextProto.Builder builder = null; + boolean viaProto = false; + + private ContainerId existingContainerId = null; + private Resource targetCapability = null; + + public ResourceChangeContextPBImpl() { + builder = ResourceChangeContextProto.newBuilder(); + } + + public ResourceChangeContextPBImpl(ResourceChangeContextProto proto) { + this.proto = proto; + viaProto = true; + } + + public ResourceChangeContextProto getProto() { + mergeLocalToProto(); + proto = viaProto ? proto : builder.build(); + viaProto = true; + return proto; + } + + @Override + public ContainerId getExistingContainerId() { + ResourceChangeContextProtoOrBuilder p = viaProto ? proto : builder; + if (this.existingContainerId != null) { + return this.existingContainerId; + } + if (p.hasContainerId()) { + this.existingContainerId = convertFromProtoFormat(p.getContainerId()); + } + return this.existingContainerId; + } + + @Override + public void setExistingContainerId(ContainerId existingContainerId) { + maybeInitBuilder(); + if (existingContainerId == null) { + builder.clearContainerId(); + } + this.existingContainerId = existingContainerId; + } + + @Override + public Resource getTargetCapability() { + ResourceChangeContextProtoOrBuilder p = viaProto ? proto : builder; + if (this.targetCapability != null) { + return this.targetCapability; + } + if (p.hasTargetCapability()) { + this.targetCapability = convertFromProtoFormat(p.getTargetCapability()); + } + return this.targetCapability; + } + + @Override + public void setTargetCapability(Resource targetCapability) { + maybeInitBuilder(); + if (targetCapability == null) { + builder.clearTargetCapability(); + } + this.targetCapability = targetCapability; + } + + private ContainerIdPBImpl convertFromProtoFormat(ContainerIdProto p) { + return new ContainerIdPBImpl(p); + } + + private ContainerIdProto convertToProtoFormat(ContainerId t) { + return ((ContainerIdPBImpl) t).getProto(); + } + + private Resource convertFromProtoFormat(ResourceProto p) { + return new ResourcePBImpl(p); + } + + private ResourceProto convertToProtoFormat(Resource t) { + return ((ResourcePBImpl) t).getProto(); + } + + private void mergeLocalToProto() { + if (viaProto) { + maybeInitBuilder(); + } + mergeLocalToBuilder(); + proto = builder.build(); + viaProto = true; + } + + private void maybeInitBuilder() { + if (viaProto || builder == null) { + builder = ResourceChangeContextProto.newBuilder(proto); + } + viaProto = false; + } + + private void mergeLocalToBuilder() { + if (this.existingContainerId != null) { + builder.setContainerId(convertToProtoFormat(this.existingContainerId)); + } + if (this.targetCapability != null) { + builder.setTargetCapability(convertToProtoFormat(this.targetCapability)); + } + } +} diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ResourceIncreaseContextPBImpl.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ResourceIncreaseContextPBImpl.java new file mode 100644 index 0000000..15fbc9d --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ResourceIncreaseContextPBImpl.java @@ -0,0 +1,121 @@ +package org.apache.hadoop.yarn.api.records.impl.pb; + +import org.apache.hadoop.security.proto.SecurityProtos.TokenProto; +import org.apache.hadoop.yarn.api.records.ResourceChangeContext; +import org.apache.hadoop.yarn.api.records.ResourceIncreaseContext; +import org.apache.hadoop.yarn.api.records.Token; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceChangeContextProto; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceIncreaseContextProto; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceIncreaseContextProtoOrBuilder; + +public class ResourceIncreaseContextPBImpl extends ResourceIncreaseContext { + ResourceIncreaseContextProto proto = ResourceIncreaseContextProto + .getDefaultInstance(); + ResourceIncreaseContextProto.Builder builder = null; + boolean viaProto = false; + + private ResourceChangeContext context = null; + private Token token = null; + + public ResourceIncreaseContextPBImpl() { + builder = ResourceIncreaseContextProto.newBuilder(); + viaProto = true; + } + + public ResourceIncreaseContextPBImpl(ResourceIncreaseContextProto proto) { + this.proto = proto; + viaProto = true; + } + + public ResourceIncreaseContextProto getProto() { + mergeLocalToProto(); + proto = viaProto ? proto : builder.build(); + viaProto = true; + return proto; + } + + @Override + public ResourceChangeContext getResourceChangeContext() { + ResourceIncreaseContextProtoOrBuilder p = viaProto ? proto : builder; + if (this.context != null) { + return this.context; + } + if (p.hasContext()) { + this.context = convertFromProtoFormat(p.getContext()); + } + return context; + } + + @Override + public void setResourceChangeContext(ResourceChangeContext context) { + maybeInitBuilder(); + if (context == null) { + builder.clearContext(); + } + this.context = context; + } + + @Override + public Token getContainerToken() { + ResourceIncreaseContextProtoOrBuilder p = viaProto ? proto : builder; + if (this.token != null) { + return this.token; + } + if (p.hasContainerToken()) { + this.token = convertFromProtoFormat(p.getContainerToken()); + } + return token; + } + + @Override + public void setContainerToken(Token token) { + maybeInitBuilder(); + if (token == null) { + builder.clearContainerToken(); + } + this.token = token; + } + + private ResourceChangeContext convertFromProtoFormat( + ResourceChangeContextProto p) { + return new ResourceChangeContextPBImpl(p); + } + + private ResourceChangeContextProto convertToProtoFormat( + ResourceChangeContext t) { + return ((ResourceChangeContextPBImpl) t).getProto(); + } + + private Token convertFromProtoFormat(TokenProto p) { + return new TokenPBImpl(p); + } + + private TokenProto convertToProtoFormat(Token t) { + return ((TokenPBImpl) t).getProto(); + } + + private void mergeLocalToProto() { + if (viaProto) { + maybeInitBuilder(); + } + mergeLocalToBuilder(); + proto = builder.build(); + viaProto = true; + } + + private void maybeInitBuilder() { + if (viaProto || builder == null) { + builder = ResourceIncreaseContextProto.newBuilder(proto); + } + viaProto = false; + } + + private void mergeLocalToBuilder() { + if (this.context != null) { + builder.setContext(convertToProtoFormat(this.context)); + } + if (this.token != null) { + builder.setContainerToken(convertToProtoFormat(this.token)); + } + } +} diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/api/TestResourceChangeContext.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/api/TestResourceChangeContext.java new file mode 100644 index 0000000..f179a86 --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/api/TestResourceChangeContext.java @@ -0,0 +1,45 @@ +package org.apache.hadoop.yarn.api; + +import junit.framework.Assert; + +import org.apache.hadoop.yarn.api.records.ApplicationAttemptId; +import org.apache.hadoop.yarn.api.records.ApplicationId; +import org.apache.hadoop.yarn.api.records.ContainerId; +import org.apache.hadoop.yarn.api.records.Resource; +import org.apache.hadoop.yarn.api.records.ResourceChangeContext; +import org.apache.hadoop.yarn.api.records.impl.pb.ResourceChangeContextPBImpl; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceChangeContextProto; +import org.junit.Test; + +public class TestResourceChangeContext { + @Test + public void testResourceChangeContext() { + ContainerId containerId = ContainerId + .newInstance(ApplicationAttemptId.newInstance( + ApplicationId.newInstance(1234, 3), 3), 7); + Resource resource = Resource.newInstance(1023, 3); + ResourceChangeContext context = ResourceChangeContext.newInstance( + containerId, resource); + + // to proto and get it back + ResourceChangeContextProto proto = ((ResourceChangeContextPBImpl)context).getProto(); + ResourceChangeContext contextRecover = new ResourceChangeContextPBImpl(proto); + + // check value + Assert.assertTrue(contextRecover.getExistingContainerId().equals(containerId)); + Assert.assertTrue(contextRecover.getTargetCapability().equals(resource)); + } + + @Test + public void testResourceChangeContextWithNullField() { + ResourceChangeContext context = ResourceChangeContext.newInstance(null, null); + + // to proto and get it back + ResourceChangeContextProto proto = ((ResourceChangeContextPBImpl)context).getProto(); + ResourceChangeContext contextRecover = new ResourceChangeContextPBImpl(proto); + + // check value + Assert.assertNull(contextRecover.getExistingContainerId()); + Assert.assertNull(contextRecover.getTargetCapability()); + } +} diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/api/TestResourceIncreaseContext.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/api/TestResourceIncreaseContext.java new file mode 100644 index 0000000..4ee241f --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/api/TestResourceIncreaseContext.java @@ -0,0 +1,56 @@ +package org.apache.hadoop.yarn.api; + +import java.util.Arrays; + +import junit.framework.Assert; + +import org.apache.hadoop.yarn.api.records.ApplicationAttemptId; +import org.apache.hadoop.yarn.api.records.ApplicationId; +import org.apache.hadoop.yarn.api.records.ContainerId; +import org.apache.hadoop.yarn.api.records.Resource; +import org.apache.hadoop.yarn.api.records.ResourceChangeContext; +import org.apache.hadoop.yarn.api.records.ResourceIncreaseContext; +import org.apache.hadoop.yarn.api.records.Token; +import org.apache.hadoop.yarn.api.records.impl.pb.ResourceIncreaseContextPBImpl; +import org.apache.hadoop.yarn.proto.YarnProtos.ResourceIncreaseContextProto; +import org.junit.Test; + +public class TestResourceIncreaseContext { + @Test + public void testResourceIncreaseContext() { + byte[] identifier = new byte[] { 1, 2, 3, 4 }; + Token token = Token.newInstance(identifier, "", "".getBytes(), ""); + ContainerId containerId = ContainerId + .newInstance(ApplicationAttemptId.newInstance( + ApplicationId.newInstance(1234, 3), 3), 7); + Resource resource = Resource.newInstance(1023, 3); + ResourceChangeContext rcContext = ResourceChangeContext.newInstance( + containerId, resource); + ResourceIncreaseContext ctx = ResourceIncreaseContext.newInstance( + rcContext, token); + + // get proto and recover to ctx + ResourceIncreaseContextProto proto = ((ResourceIncreaseContextPBImpl) ctx) + .getProto(); + ctx = new ResourceIncreaseContextPBImpl(proto); + + // check values + Assert.assertTrue(Arrays.equals(ctx.getContainerToken().getIdentifier() + .array(), identifier)); + Assert.assertTrue(ctx.getResourceChangeContext().equals(rcContext)); + } + + @Test + public void testResourceIncreaseContextWithNull() { + ResourceIncreaseContext ctx = ResourceIncreaseContext.newInstance(null, null); + + // get proto and recover to ctx; + ResourceIncreaseContextProto proto = ((ResourceIncreaseContextPBImpl) ctx) + .getProto(); + ctx = new ResourceIncreaseContextPBImpl(proto); + + // check values + Assert.assertNull(ctx.getContainerToken()); + Assert.assertNull(ctx.getResourceChangeContext()); + } +}