001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018
019 package org.apache.hadoop.hdfs.protocolPB;
020
021 import java.io.IOException;
022 import java.util.List;
023
024 import org.apache.hadoop.hdfs.protocol.DatanodeID;
025 import org.apache.hadoop.hdfs.protocol.LocatedBlock;
026 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReceivedAndDeletedRequestProto;
027 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReceivedAndDeletedResponseProto;
028 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReportRequestProto;
029 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReportResponseProto;
030 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.CommitBlockSynchronizationRequestProto;
031 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.CommitBlockSynchronizationResponseProto;
032 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ErrorReportRequestProto;
033 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ErrorReportResponseProto;
034 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.HeartbeatRequestProto;
035 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.HeartbeatResponseProto;
036 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ProcessUpgradeRequestProto;
037 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ProcessUpgradeResponseProto;
038 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReceivedDeletedBlockInfoProto;
039 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.RegisterDatanodeRequestProto;
040 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.RegisterDatanodeResponseProto;
041 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReportBadBlocksRequestProto;
042 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReportBadBlocksResponseProto;
043 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageBlockReportProto;
044 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto;
045 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageReportProto;
046 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeIDProto;
047 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlockProto;
048 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.VersionRequestProto;
049 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.VersionResponseProto;
050 import org.apache.hadoop.hdfs.server.protocol.DatanodeCommand;
051 import org.apache.hadoop.hdfs.server.protocol.DatanodeProtocol;
052 import org.apache.hadoop.hdfs.server.protocol.DatanodeRegistration;
053 import org.apache.hadoop.hdfs.server.protocol.HeartbeatResponse;
054 import org.apache.hadoop.hdfs.server.protocol.NamespaceInfo;
055 import org.apache.hadoop.hdfs.server.protocol.ReceivedDeletedBlockInfo;
056 import org.apache.hadoop.hdfs.server.protocol.StorageBlockReport;
057 import org.apache.hadoop.hdfs.server.protocol.StorageReceivedDeletedBlocks;
058 import org.apache.hadoop.hdfs.server.protocol.StorageReport;
059 import org.apache.hadoop.hdfs.server.protocol.UpgradeCommand;
060
061 import com.google.protobuf.RpcController;
062 import com.google.protobuf.ServiceException;
063
064 public class DatanodeProtocolServerSideTranslatorPB implements
065 DatanodeProtocolPB {
066
067 private final DatanodeProtocol impl;
068 private static final ErrorReportResponseProto ERROR_REPORT_RESPONSE_PROTO =
069 ErrorReportResponseProto.newBuilder().build();
070 private static final BlockReceivedAndDeletedResponseProto
071 BLOCK_RECEIVED_AND_DELETE_RESPONSE =
072 BlockReceivedAndDeletedResponseProto.newBuilder().build();
073 private static final ReportBadBlocksResponseProto REPORT_BAD_BLOCK_RESPONSE =
074 ReportBadBlocksResponseProto.newBuilder().build();
075 private static final CommitBlockSynchronizationResponseProto
076 COMMIT_BLOCK_SYNCHRONIZATION_RESPONSE_PROTO =
077 CommitBlockSynchronizationResponseProto.newBuilder().build();
078
079 public DatanodeProtocolServerSideTranslatorPB(DatanodeProtocol impl) {
080 this.impl = impl;
081 }
082
083 @Override
084 public RegisterDatanodeResponseProto registerDatanode(
085 RpcController controller, RegisterDatanodeRequestProto request)
086 throws ServiceException {
087 DatanodeRegistration registration = PBHelper.convert(request
088 .getRegistration());
089 DatanodeRegistration registrationResp;
090 try {
091 registrationResp = impl.registerDatanode(registration);
092 } catch (IOException e) {
093 throw new ServiceException(e);
094 }
095 return RegisterDatanodeResponseProto.newBuilder()
096 .setRegistration(PBHelper.convert(registrationResp)).build();
097 }
098
099 @Override
100 public HeartbeatResponseProto sendHeartbeat(RpcController controller,
101 HeartbeatRequestProto request) throws ServiceException {
102 HeartbeatResponse response;
103 try {
104 List<StorageReportProto> list = request.getReportsList();
105 StorageReport[] report = new StorageReport[list.size()];
106 int i = 0;
107 for (StorageReportProto p : list) {
108 report[i++] = new StorageReport(p.getStorageID(), p.getFailed(),
109 p.getCapacity(), p.getDfsUsed(), p.getRemaining(),
110 p.getBlockPoolUsed());
111 }
112 response = impl.sendHeartbeat(PBHelper.convert(request.getRegistration()),
113 report, request.getXmitsInProgress(), request.getXceiverCount(),
114 request.getFailedVolumes());
115 } catch (IOException e) {
116 throw new ServiceException(e);
117 }
118 HeartbeatResponseProto.Builder builder = HeartbeatResponseProto
119 .newBuilder();
120 DatanodeCommand[] cmds = response.getCommands();
121 if (cmds != null) {
122 for (int i = 0; i < cmds.length; i++) {
123 if (cmds[i] != null) {
124 builder.addCmds(PBHelper.convert(cmds[i]));
125 }
126 }
127 }
128 builder.setHaStatus(PBHelper.convert(response.getNameNodeHaState()));
129 return builder.build();
130 }
131
132 @Override
133 public BlockReportResponseProto blockReport(RpcController controller,
134 BlockReportRequestProto request) throws ServiceException {
135 DatanodeCommand cmd = null;
136 StorageBlockReport[] report =
137 new StorageBlockReport[request.getReportsCount()];
138
139 int index = 0;
140 for (StorageBlockReportProto s : request.getReportsList()) {
141 List<Long> blockIds = s.getBlocksList();
142 long[] blocks = new long[blockIds.size()];
143 for (int i = 0; i < blockIds.size(); i++) {
144 blocks[i] = blockIds.get(i);
145 }
146 report[index++] = new StorageBlockReport(PBHelper.convert(s.getStorage()),
147 blocks);
148 }
149 try {
150 cmd = impl.blockReport(PBHelper.convert(request.getRegistration()),
151 request.getBlockPoolId(), report);
152 } catch (IOException e) {
153 throw new ServiceException(e);
154 }
155 BlockReportResponseProto.Builder builder =
156 BlockReportResponseProto.newBuilder();
157 if (cmd != null) {
158 builder.setCmd(PBHelper.convert(cmd));
159 }
160 return builder.build();
161 }
162
163 @Override
164 public BlockReceivedAndDeletedResponseProto blockReceivedAndDeleted(
165 RpcController controller, BlockReceivedAndDeletedRequestProto request)
166 throws ServiceException {
167 List<StorageReceivedDeletedBlocksProto> sBlocks = request.getBlocksList();
168 StorageReceivedDeletedBlocks[] info =
169 new StorageReceivedDeletedBlocks[sBlocks.size()];
170 for (int i = 0; i < sBlocks.size(); i++) {
171 StorageReceivedDeletedBlocksProto sBlock = sBlocks.get(i);
172 List<ReceivedDeletedBlockInfoProto> list = sBlock.getBlocksList();
173 ReceivedDeletedBlockInfo[] rdBlocks =
174 new ReceivedDeletedBlockInfo[list.size()];
175 for (int j = 0; j < list.size(); j++) {
176 rdBlocks[j] = PBHelper.convert(list.get(j));
177 }
178 info[i] = new StorageReceivedDeletedBlocks(sBlock.getStorageID(), rdBlocks);
179 }
180 try {
181 impl.blockReceivedAndDeleted(PBHelper.convert(request.getRegistration()),
182 request.getBlockPoolId(), info);
183 } catch (IOException e) {
184 throw new ServiceException(e);
185 }
186 return BLOCK_RECEIVED_AND_DELETE_RESPONSE;
187 }
188
189 @Override
190 public ErrorReportResponseProto errorReport(RpcController controller,
191 ErrorReportRequestProto request) throws ServiceException {
192 try {
193 impl.errorReport(PBHelper.convert(request.getRegistartion()),
194 request.getErrorCode(), request.getMsg());
195 } catch (IOException e) {
196 throw new ServiceException(e);
197 }
198 return ERROR_REPORT_RESPONSE_PROTO;
199 }
200
201 @Override
202 public VersionResponseProto versionRequest(RpcController controller,
203 VersionRequestProto request) throws ServiceException {
204 NamespaceInfo info;
205 try {
206 info = impl.versionRequest();
207 } catch (IOException e) {
208 throw new ServiceException(e);
209 }
210 return VersionResponseProto.newBuilder()
211 .setInfo(PBHelper.convert(info)).build();
212 }
213
214 @Override
215 public ProcessUpgradeResponseProto processUpgrade(RpcController controller,
216 ProcessUpgradeRequestProto request) throws ServiceException {
217 UpgradeCommand ret;
218 try {
219 UpgradeCommand cmd = request.hasCmd() ? PBHelper
220 .convert(request.getCmd()) : null;
221 ret = impl.processUpgradeCommand(cmd);
222 } catch (IOException e) {
223 throw new ServiceException(e);
224 }
225 ProcessUpgradeResponseProto.Builder builder =
226 ProcessUpgradeResponseProto.newBuilder();
227 if (ret != null) {
228 builder.setCmd(PBHelper.convert(ret));
229 }
230 return builder.build();
231 }
232
233 @Override
234 public ReportBadBlocksResponseProto reportBadBlocks(RpcController controller,
235 ReportBadBlocksRequestProto request) throws ServiceException {
236 List<LocatedBlockProto> lbps = request.getBlocksList();
237 LocatedBlock [] blocks = new LocatedBlock [lbps.size()];
238 for(int i=0; i<lbps.size(); i++) {
239 blocks[i] = PBHelper.convert(lbps.get(i));
240 }
241 try {
242 impl.reportBadBlocks(blocks);
243 } catch (IOException e) {
244 throw new ServiceException(e);
245 }
246 return REPORT_BAD_BLOCK_RESPONSE;
247 }
248
249 @Override
250 public CommitBlockSynchronizationResponseProto commitBlockSynchronization(
251 RpcController controller, CommitBlockSynchronizationRequestProto request)
252 throws ServiceException {
253 List<DatanodeIDProto> dnprotos = request.getNewTaragetsList();
254 DatanodeID[] dns = new DatanodeID[dnprotos.size()];
255 for (int i = 0; i < dnprotos.size(); i++) {
256 dns[i] = PBHelper.convert(dnprotos.get(i));
257 }
258 final List<String> sidprotos = request.getNewTargetStoragesList();
259 final String[] storageIDs = sidprotos.toArray(new String[sidprotos.size()]);
260 try {
261 impl.commitBlockSynchronization(PBHelper.convert(request.getBlock()),
262 request.getNewGenStamp(), request.getNewLength(),
263 request.getCloseFile(), request.getDeleteBlock(), dns, storageIDs);
264 } catch (IOException e) {
265 throw new ServiceException(e);
266 }
267 return COMMIT_BLOCK_SYNCHRONIZATION_RESPONSE_PROTO;
268 }
269 }