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
019package org.apache.hadoop.hdfs.protocolPB;
020
021import java.io.IOException;
022import java.util.List;
023
024import org.apache.hadoop.hdfs.protocol.DatanodeID;
025import org.apache.hadoop.hdfs.protocol.LocatedBlock;
026import org.apache.hadoop.hdfs.protocol.RollingUpgradeStatus;
027import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReceivedAndDeletedRequestProto;
028import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReceivedAndDeletedResponseProto;
029import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReportRequestProto;
030import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockReportResponseProto;
031import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.CacheReportRequestProto;
032import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.CacheReportResponseProto;
033import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.CommitBlockSynchronizationRequestProto;
034import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.CommitBlockSynchronizationResponseProto;
035import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ErrorReportRequestProto;
036import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ErrorReportResponseProto;
037import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.HeartbeatRequestProto;
038import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.HeartbeatResponseProto;
039import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReceivedDeletedBlockInfoProto;
040import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.RegisterDatanodeRequestProto;
041import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.RegisterDatanodeResponseProto;
042import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReportBadBlocksRequestProto;
043import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReportBadBlocksResponseProto;
044import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageBlockReportProto;
045import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto;
046import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeIDProto;
047import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlockProto;
048import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.VersionRequestProto;
049import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.VersionResponseProto;
050import org.apache.hadoop.hdfs.server.protocol.DatanodeCommand;
051import org.apache.hadoop.hdfs.server.protocol.DatanodeProtocol;
052import org.apache.hadoop.hdfs.server.protocol.DatanodeRegistration;
053import org.apache.hadoop.hdfs.server.protocol.HeartbeatResponse;
054import org.apache.hadoop.hdfs.server.protocol.NamespaceInfo;
055import org.apache.hadoop.hdfs.server.protocol.ReceivedDeletedBlockInfo;
056import org.apache.hadoop.hdfs.server.protocol.StorageBlockReport;
057import org.apache.hadoop.hdfs.server.protocol.StorageReceivedDeletedBlocks;
058import org.apache.hadoop.hdfs.server.protocol.StorageReport;
059
060import com.google.protobuf.RpcController;
061import com.google.protobuf.ServiceException;
062
063public class DatanodeProtocolServerSideTranslatorPB implements
064    DatanodeProtocolPB {
065
066  private final DatanodeProtocol impl;
067  private static final ErrorReportResponseProto
068      VOID_ERROR_REPORT_RESPONSE_PROTO = 
069          ErrorReportResponseProto.newBuilder().build();
070  private static final BlockReceivedAndDeletedResponseProto 
071      VOID_BLOCK_RECEIVED_AND_DELETE_RESPONSE = 
072          BlockReceivedAndDeletedResponseProto.newBuilder().build();
073  private static final ReportBadBlocksResponseProto
074      VOID_REPORT_BAD_BLOCK_RESPONSE = 
075          ReportBadBlocksResponseProto.newBuilder().build();
076  private static final CommitBlockSynchronizationResponseProto 
077      VOID_COMMIT_BLOCK_SYNCHRONIZATION_RESPONSE_PROTO =
078          CommitBlockSynchronizationResponseProto.newBuilder().build();
079
080  public DatanodeProtocolServerSideTranslatorPB(DatanodeProtocol impl) {
081    this.impl = impl;
082  }
083
084  @Override
085  public RegisterDatanodeResponseProto registerDatanode(
086      RpcController controller, RegisterDatanodeRequestProto request)
087      throws ServiceException {
088    DatanodeRegistration registration = PBHelper.convert(request
089        .getRegistration());
090    DatanodeRegistration registrationResp;
091    try {
092      registrationResp = impl.registerDatanode(registration);
093    } catch (IOException e) {
094      throw new ServiceException(e);
095    }
096    return RegisterDatanodeResponseProto.newBuilder()
097        .setRegistration(PBHelper.convert(registrationResp)).build();
098  }
099
100  @Override
101  public HeartbeatResponseProto sendHeartbeat(RpcController controller,
102      HeartbeatRequestProto request) throws ServiceException {
103    HeartbeatResponse response;
104    try {
105      final StorageReport[] report = PBHelper.convertStorageReports(
106          request.getReportsList());
107      response = impl.sendHeartbeat(PBHelper.convert(request.getRegistration()),
108          report, request.getCacheCapacity(), request.getCacheUsed(),
109          request.getXmitsInProgress(),
110          request.getXceiverCount(), request.getFailedVolumes());
111    } catch (IOException e) {
112      throw new ServiceException(e);
113    }
114    HeartbeatResponseProto.Builder builder = HeartbeatResponseProto
115        .newBuilder();
116    DatanodeCommand[] cmds = response.getCommands();
117    if (cmds != null) {
118      for (int i = 0; i < cmds.length; i++) {
119        if (cmds[i] != null) {
120          builder.addCmds(PBHelper.convert(cmds[i]));
121        }
122      }
123    }
124    builder.setHaStatus(PBHelper.convert(response.getNameNodeHaState()));
125    RollingUpgradeStatus rollingUpdateStatus = response
126        .getRollingUpdateStatus();
127    if (rollingUpdateStatus != null) {
128      builder.setRollingUpgradeStatus(PBHelper
129          .convertRollingUpgradeStatus(rollingUpdateStatus));
130    }
131    return builder.build();
132  }
133
134  @Override
135  public BlockReportResponseProto blockReport(RpcController controller,
136      BlockReportRequestProto request) throws ServiceException {
137    DatanodeCommand cmd = null;
138    StorageBlockReport[] report = 
139        new StorageBlockReport[request.getReportsCount()];
140    
141    int index = 0;
142    for (StorageBlockReportProto s : request.getReportsList()) {
143      List<Long> blockIds = s.getBlocksList();
144      long[] blocks = new long[blockIds.size()];
145      for (int i = 0; i < blockIds.size(); i++) {
146        blocks[i] = blockIds.get(i);
147      }
148      report[index++] = new StorageBlockReport(PBHelper.convert(s.getStorage()),
149          blocks);
150    }
151    try {
152      cmd = impl.blockReport(PBHelper.convert(request.getRegistration()),
153          request.getBlockPoolId(), report,
154          request.hasContext() ?
155              PBHelper.convert(request.getContext()) : null);
156    } catch (IOException e) {
157      throw new ServiceException(e);
158    }
159    BlockReportResponseProto.Builder builder = 
160        BlockReportResponseProto.newBuilder();
161    if (cmd != null) {
162      builder.setCmd(PBHelper.convert(cmd));
163    }
164    return builder.build();
165  }
166
167  @Override
168  public CacheReportResponseProto cacheReport(RpcController controller,
169      CacheReportRequestProto request) throws ServiceException {
170    DatanodeCommand cmd = null;
171    try {
172      cmd = impl.cacheReport(
173          PBHelper.convert(request.getRegistration()),
174          request.getBlockPoolId(),
175          request.getBlocksList());
176    } catch (IOException e) {
177      throw new ServiceException(e);
178    }
179    CacheReportResponseProto.Builder builder =
180        CacheReportResponseProto.newBuilder();
181    if (cmd != null) {
182      builder.setCmd(PBHelper.convert(cmd));
183    }
184    return builder.build();
185  }
186
187
188  @Override
189  public BlockReceivedAndDeletedResponseProto blockReceivedAndDeleted(
190      RpcController controller, BlockReceivedAndDeletedRequestProto request)
191      throws ServiceException {
192    List<StorageReceivedDeletedBlocksProto> sBlocks = request.getBlocksList();
193    StorageReceivedDeletedBlocks[] info = 
194        new StorageReceivedDeletedBlocks[sBlocks.size()];
195    for (int i = 0; i < sBlocks.size(); i++) {
196      StorageReceivedDeletedBlocksProto sBlock = sBlocks.get(i);
197      List<ReceivedDeletedBlockInfoProto> list = sBlock.getBlocksList();
198      ReceivedDeletedBlockInfo[] rdBlocks = 
199          new ReceivedDeletedBlockInfo[list.size()];
200      for (int j = 0; j < list.size(); j++) {
201        rdBlocks[j] = PBHelper.convert(list.get(j));
202      }
203      if (sBlock.hasStorage()) {
204        info[i] = new StorageReceivedDeletedBlocks(
205            PBHelper.convert(sBlock.getStorage()), rdBlocks);
206      } else {
207        info[i] = new StorageReceivedDeletedBlocks(sBlock.getStorageUuid(), rdBlocks);
208      }
209    }
210    try {
211      impl.blockReceivedAndDeleted(PBHelper.convert(request.getRegistration()),
212          request.getBlockPoolId(), info);
213    } catch (IOException e) {
214      throw new ServiceException(e);
215    }
216    return VOID_BLOCK_RECEIVED_AND_DELETE_RESPONSE;
217  }
218
219  @Override
220  public ErrorReportResponseProto errorReport(RpcController controller,
221      ErrorReportRequestProto request) throws ServiceException {
222    try {
223      impl.errorReport(PBHelper.convert(request.getRegistartion()),
224          request.getErrorCode(), request.getMsg());
225    } catch (IOException e) {
226      throw new ServiceException(e);
227    }
228    return VOID_ERROR_REPORT_RESPONSE_PROTO;
229  }
230
231  @Override
232  public VersionResponseProto versionRequest(RpcController controller,
233      VersionRequestProto request) throws ServiceException {
234    NamespaceInfo info;
235    try {
236      info = impl.versionRequest();
237    } catch (IOException e) {
238      throw new ServiceException(e);
239    }
240    return VersionResponseProto.newBuilder()
241        .setInfo(PBHelper.convert(info)).build();
242  }
243
244  @Override
245  public ReportBadBlocksResponseProto reportBadBlocks(RpcController controller,
246      ReportBadBlocksRequestProto request) throws ServiceException {
247    List<LocatedBlockProto> lbps = request.getBlocksList();
248    LocatedBlock [] blocks = new LocatedBlock [lbps.size()];
249    for(int i=0; i<lbps.size(); i++) {
250      blocks[i] = PBHelper.convert(lbps.get(i));
251    }
252    try {
253      impl.reportBadBlocks(blocks);
254    } catch (IOException e) {
255      throw new ServiceException(e);
256    }
257    return VOID_REPORT_BAD_BLOCK_RESPONSE;
258  }
259
260  @Override
261  public CommitBlockSynchronizationResponseProto commitBlockSynchronization(
262      RpcController controller, CommitBlockSynchronizationRequestProto request)
263      throws ServiceException {
264    List<DatanodeIDProto> dnprotos = request.getNewTaragetsList();
265    DatanodeID[] dns = new DatanodeID[dnprotos.size()];
266    for (int i = 0; i < dnprotos.size(); i++) {
267      dns[i] = PBHelper.convert(dnprotos.get(i));
268    }
269    final List<String> sidprotos = request.getNewTargetStoragesList();
270    final String[] storageIDs = sidprotos.toArray(new String[sidprotos.size()]);
271    try {
272      impl.commitBlockSynchronization(PBHelper.convert(request.getBlock()),
273          request.getNewGenStamp(), request.getNewLength(),
274          request.getCloseFile(), request.getDeleteBlock(), dns, storageIDs);
275    } catch (IOException e) {
276      throw new ServiceException(e);
277    }
278    return VOID_COMMIT_BLOCK_SYNCHRONIZATION_RESPONSE_PROTO;
279  }
280}