Skip to content

Commit 9b3e483

Browse files
shanshanptshanshanpt
authored
[Serving] Skip invalid request and return error msg to client. (#729)
1 parent 70a5f52 commit 9b3e483

3 files changed

Lines changed: 124 additions & 65 deletions

File tree

‎serving/processor/serving/message_coding.cc‎

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,9 +18,13 @@ Status ProtoBufParser::ParseRequest(
1818
LOG(FATAL) << "Request contain invalid input key : " << input.first;
1919
}
2020
int idx = signature_info->input_key_idx.at(input.first);
21+
auto pb_to_tensor = util::Proto2Tensor(input.first, input.second);
22+
if (!pb_to_tensor.status.ok()) {
23+
return pb_to_tensor.status;
24+
}
2125
call.request.inputs.emplace_back(
2226
signature_info->input_value_name[idx],
23-
util::Proto2Tensor(input.second));
27+
std::move(pb_to_tensor.tensor));
2428
}
2529

2630
if (request.output_filter().size() > 0) {
@@ -87,9 +91,13 @@ Status ProtoBufParser::ParseBatchRequestFromBuf(
8791
LOG(FATAL) << "Request contain invalid input key : " << input.first;
8892
}
8993
int idx = signature_info->input_key_idx.at(input.first);
94+
auto pb_to_tensor = util::Proto2Tensor(input.first, input.second);
95+
if (!pb_to_tensor.status.ok()) {
96+
return pb_to_tensor.status;
97+
}
9098
call.request[i].inputs.emplace_back(
9199
signature_info->input_value_name[idx],
92-
util::Proto2Tensor(input.second));
100+
std::move(pb_to_tensor.tensor));
93101
}
94102

95103
if (i == 0) {

‎serving/processor/serving/util.cc‎

Lines changed: 107 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -375,254 +375,299 @@ Status ValidateSavedTensors(const GraphDef& graph_def) {
375375
return Status::OK();
376376
}
377377

378-
Tensor Proto2Tensor(const eas::ArrayProto& input) {
378+
TensorWithStatus Proto2Tensor(const std::string& key,
379+
const eas::ArrayProto& input) {
379380
TensorShape tensor_shape;
380381
int64 total_size = 1;
381382
for (int i = 0; i < input.array_shape().dim_size(); ++i) {
382383
tensor_shape.AddDim(input.array_shape().dim(i));
383384
total_size *= input.array_shape().dim(i);
384385
}
385386

387+
TensorWithStatus ret;
388+
ret.status = Status::OK();
386389
switch (input.dtype()) {
387390
case tensorflow::eas::DT_FLOAT: {
388391
if (total_size != input.float_val_size()) {
389-
// TODO: should skip current request
390-
LOG(FATAL) << "Invalid input.";
392+
ret.status = errors::InvalidArgument(
393+
"Invalid input: ", key, " . shape size VS input size = ",
394+
std::to_string(total_size), " VS ", std::to_string(input.float_val_size()));
395+
break;
391396
}
392397
Tensor tensor(DT_FLOAT, tensor_shape);
393398
auto flat = tensor.flat<float>();
394399
memcpy(flat.data(), input.float_val().data(),
395400
input.float_val_size() * sizeof(float));
396401

397-
return tensor;
402+
ret.tensor = std::move(tensor);
398403
}
399404
case tensorflow::eas::DT_DOUBLE: {
400405
if (total_size != input.double_val_size()) {
401-
// TODO: should skip current request
402-
LOG(FATAL) << "Invalid input.";
406+
ret.status = errors::InvalidArgument(
407+
"Invalid input: ", key, " . shape size VS input size = ",
408+
std::to_string(total_size), " VS ", std::to_string(input.double_val_size()));
409+
break;
403410
}
404411
Tensor tensor(DT_DOUBLE, tensor_shape);
405412
auto flat = tensor.flat<double>();
406413
memcpy(flat.data(), input.double_val().data(),
407414
input.double_val_size() * sizeof(double));
408-
return tensor;
415+
ret.tensor = std::move(tensor);
409416
}
410417
case tensorflow::eas::DT_INT32: {
411418
if (total_size != input.int_val_size()) {
412-
// TODO: should skip current request
413-
LOG(FATAL) << "Invalid input.";
419+
ret.status = errors::InvalidArgument(
420+
"Invalid input: ", key, " . shape size VS input size = ",
421+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
422+
break;
414423
}
415424
Tensor tensor(DT_INT32, tensor_shape);
416425
auto flat = tensor.flat<int>();
417426
memcpy(flat.data(), input.int_val().data(),
418427
input.int_val_size() * sizeof(int));
419-
return tensor;
428+
ret.tensor = std::move(tensor);
420429
}
421430
case tensorflow::eas::DT_UINT8: {
422431
if (total_size != input.int_val_size()) {
423-
// TODO: should skip current request
424-
LOG(FATAL) << "Invalid input.";
432+
ret.status = errors::InvalidArgument(
433+
"Invalid input: ", key, " . shape size VS input size = ",
434+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
435+
break;
425436
}
426437
Tensor tensor(tensorflow::DT_UINT8, tensor_shape);
427438
auto flat = tensor.flat<uint8>();
428439
for (int i = 0; i < input.int_val_size(); i++) {
429440
flat(i) = (uint8)input.int_val(i);
430441
}
431-
return tensor;
442+
ret.tensor = std::move(tensor);
432443
}
433444
case tensorflow::eas::DT_INT16: {
434445
if (total_size != input.int_val_size()) {
435-
// TODO: should skip current request
436-
LOG(FATAL) << "Invalid input.";
446+
ret.status = errors::InvalidArgument(
447+
"Invalid input: ", key, " . shape size VS input size = ",
448+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
449+
break;
437450
}
438451
Tensor tensor(tensorflow::DT_INT16, tensor_shape);
439452
auto flat = tensor.flat<int16>();
440453
for (int i = 0; i < input.int_val_size(); i++) {
441454
flat(i) = (int16)input.int_val(i);
442455
}
443-
return tensor;
456+
ret.tensor = std::move(tensor);
444457
}
445458
case tensorflow::eas::DT_UINT16: {
446459
if (total_size != input.int_val_size()) {
447-
// TODO: should skip current request
448-
LOG(FATAL) << "Invalid input.";
460+
ret.status = errors::InvalidArgument(
461+
"Invalid input: ", key, " . shape size VS input size = ",
462+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
463+
break;
449464
}
450465
Tensor tensor(tensorflow::DT_UINT16, tensor_shape);
451466
auto flat = tensor.flat<uint16>();
452467
for (int i = 0; i < input.int_val_size(); i++) {
453468
flat(i) = (uint16)input.int_val(i);
454469
}
455-
return tensor;
470+
ret.tensor = std::move(tensor);
456471
}
457472
case tensorflow::eas::DT_INT8: {
458473
if (total_size != input.int_val_size()) {
459-
// TODO: should skip current request
460-
LOG(FATAL) << "Invalid input.";
474+
ret.status = errors::InvalidArgument(
475+
"Invalid input: ", key, " . shape size VS input size = ",
476+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
477+
break;
461478
}
462479
Tensor tensor(tensorflow::DT_INT8, tensor_shape);
463480
auto flat = tensor.flat<int8>();
464481
for (int i = 0; i < input.int_val_size(); i++) {
465482
flat(i) = (int8)input.int_val(i);
466483
}
467-
return tensor;
484+
ret.tensor = std::move(tensor);
468485
}
469486
case tensorflow::eas::DT_STRING: {
470487
if (total_size != input.string_val_size()) {
471-
// TODO: should skip current request
472-
LOG(FATAL) << "Invalid input.";
488+
ret.status = errors::InvalidArgument(
489+
"Invalid input: ", key, " . shape size VS input size = ",
490+
std::to_string(total_size), " VS ", std::to_string(input.string_val_size()));
491+
break;
473492
}
474493
Tensor tensor(tensorflow::DT_STRING, tensor_shape);
475494
auto flat = tensor.flat<std::string>();
476495
for (int i = 0; i < input.string_val_size(); i++) {
477496
flat(i) = input.string_val(i);
478497
}
479-
return tensor;
498+
ret.tensor = std::move(tensor);
480499
}
481500
case tensorflow::eas::DT_COMPLEX64: {
482501
if (total_size != input.float_val_size() / 2) {
483-
// TODO: should skip current request
484-
LOG(FATAL) << "Invalid input.";
502+
ret.status = errors::InvalidArgument(
503+
"Invalid input: ", key, " . shape size VS input size = ",
504+
std::to_string(total_size), " VS ", std::to_string(input.float_val_size()));
505+
break;
485506
}
486507
Tensor tensor(tensorflow::DT_COMPLEX64, tensor_shape);
487508
auto flat = tensor.flat<complex64>();
488509
for (int i = 0; i < input.float_val_size(); i += 2) {
489510
flat(i) = complex64(input.float_val(i), input.float_val(i + 1));
490511
}
491-
return tensor;
512+
ret.tensor = std::move(tensor);
492513
}
493514
case tensorflow::eas::DT_COMPLEX128: {
494515
if (total_size != input.double_val_size() / 2) {
495-
// TODO: should skip current request
496-
LOG(FATAL) << "Invalid input.";
516+
ret.status = errors::InvalidArgument(
517+
"Invalid input: ", key, " . shape size VS input size = ",
518+
std::to_string(total_size), " VS ", std::to_string(input.double_val_size()));
519+
break;
497520
}
498521
Tensor tensor(tensorflow::DT_COMPLEX128, tensor_shape);
499522
auto flat = tensor.flat<complex128>();
500523
for (int i = 0; i < input.double_val_size(); i += 2) {
501524
flat(i) = complex64(input.double_val(i), input.double_val(i + 1));
502525
}
503-
return tensor;
526+
ret.tensor = std::move(tensor);
504527
}
505528
case tensorflow::eas::DT_INT64: {
506529
if (total_size != input.int64_val_size()) {
507-
// TODO: should skip current request
508-
LOG(FATAL) << "Invalid input.";
530+
ret.status = errors::InvalidArgument(
531+
"Invalid input: ", key, " . shape size VS input size = ",
532+
std::to_string(total_size), " VS ", std::to_string(input.int64_val_size()));
533+
break;
509534
}
510535
Tensor tensor(DT_INT64, tensor_shape);
511536
auto flat = tensor.flat<int64>();
512537
memcpy(flat.data(), input.int64_val().data(),
513538
input.int64_val_size() * sizeof(int64));
514-
return tensor;
539+
ret.tensor = std::move(tensor);
515540
}
516541
case tensorflow::eas::DT_BOOL: {
517542
if (total_size != input.bool_val_size()) {
518-
// TODO: should skip current request
519-
LOG(FATAL) << "Invalid input.";
543+
ret.status = errors::InvalidArgument(
544+
"Invalid input: ", key, " . shape size VS input size = ",
545+
std::to_string(total_size), " VS ", std::to_string(input.bool_val_size()));
546+
break;
520547
}
521548
Tensor tensor(DT_BOOL, tensor_shape);
522549
auto flat = tensor.flat<bool>();
523550
for (int i = 0; i < input.bool_val_size(); ++i) {
524551
flat(i) = input.bool_val(i);
525552
}
526-
return tensor;
553+
ret.tensor = std::move(tensor);
527554
}
528555
case tensorflow::eas::DT_QINT8: {
529556
if (total_size != input.int_val_size()) {
530-
// TODO: should skip current request
531-
LOG(FATAL) << "Invalid input.";
557+
ret.status = errors::InvalidArgument(
558+
"Invalid input: ", key, " . shape size VS input size = ",
559+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
560+
break;
532561
}
533562
Tensor tensor(DT_QINT8, tensor_shape);
534563
auto flat = tensor.flat<qint8>();
535564
for (int i = 0; i < input.int_val_size(); ++i) {
536565
flat(i) = qint8(input.int_val(i));
537566
}
538-
return tensor;
567+
ret.tensor = std::move(tensor);
539568
}
540569
case tensorflow::eas::DT_QUINT8: {
541570
if (total_size != input.int_val_size()) {
542-
// TODO: should skip current request
543-
LOG(FATAL) << "Invalid input.";
571+
ret.status = errors::InvalidArgument(
572+
"Invalid input: ", key, " . shape size VS input size = ",
573+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
574+
break;
544575
}
545576
Tensor tensor(DT_QUINT8, tensor_shape);
546577
auto flat = tensor.flat<quint8>();
547578
for (int i = 0; i < input.int_val_size(); ++i) {
548579
flat(i) = quint8(input.int_val(i));
549580
}
550-
return tensor;
581+
ret.tensor = std::move(tensor);
551582
}
552583
case tensorflow::eas::DT_QINT32: {
553584
if (total_size != input.int_val_size()) {
554-
// TODO: should skip current request
555-
LOG(FATAL) << "Invalid input.";
585+
ret.status = errors::InvalidArgument(
586+
"Invalid input: ", key, " . shape size VS input size = ",
587+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
588+
break;
556589
}
557590
Tensor tensor(DT_QINT32, tensor_shape);
558591
auto flat = tensor.flat<qint32>();
559592
for (int i = 0; i < input.int_val_size(); ++i) {
560593
flat(i) = qint32(input.int_val(i));
561594
}
562-
return tensor;
595+
ret.tensor = std::move(tensor);
563596
}
564597
case tensorflow::eas::DT_QINT16: {
565598
if (total_size != input.int_val_size()) {
566-
// TODO: should skip current request
567-
LOG(FATAL) << "Invalid input.";
599+
ret.status = errors::InvalidArgument(
600+
"Invalid input: ", key, " . shape size VS input size = ",
601+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
602+
break;
568603
}
569604
Tensor tensor(DT_QINT16, tensor_shape);
570605
auto flat = tensor.flat<qint16>();
571606
for (int i = 0; i < input.int_val_size(); ++i) {
572607
flat(i) = qint16(input.int_val(i));
573608
}
574-
return tensor;
609+
ret.tensor = std::move(tensor);
575610
}
576611
case tensorflow::eas::DT_QUINT16: {
577612
if (total_size != input.int_val_size()) {
578-
// TODO: should skip current request
579-
LOG(FATAL) << "Invalid input.";
613+
ret.status = errors::InvalidArgument(
614+
"Invalid input: ", key, " . shape size VS input size = ",
615+
std::to_string(total_size), " VS ", std::to_string(input.int_val_size()));
616+
break;
580617
}
581618
Tensor tensor(DT_QUINT16, tensor_shape);
582619
auto flat = tensor.flat<quint16>();
583620
for (int i = 0; i < input.int_val_size(); ++i) {
584621
flat(i) = quint16(input.int_val(i));
585622
}
586-
return tensor;
623+
ret.tensor = std::move(tensor);
587624
}
588625
case tensorflow::eas::DT_BFLOAT16: {
589626
if (total_size != input.float_val_size()) {
590-
// TODO: should skip current request
591-
LOG(FATAL) << "Invalid input.";
627+
ret.status = errors::InvalidArgument(
628+
"Invalid input: ", key, " . shape size VS input size = ",
629+
std::to_string(total_size), " VS ", std::to_string(input.float_val_size()));
630+
break;
592631
}
593632
Tensor tensor(DT_BFLOAT16, tensor_shape);
594633
auto flat = tensor.flat<bfloat16>();
595634
tensorflow::FloatToBFloat16(input.float_val().data(),
596635
flat.data(),
597636
input.float_val_size());
598-
return tensor;
637+
ret.tensor = std::move(tensor);
599638
}
600639
case tensorflow::eas::DT_HALF: {
601640
if (total_size != input.float_val_size()) {
602-
// TODO: should skip current request
603-
LOG(FATAL) << "Invalid input.";
641+
ret.status = errors::InvalidArgument(
642+
"Invalid input: ", key, " . shape size VS input size = ",
643+
std::to_string(total_size), " VS ", std::to_string(input.float_val_size()));
644+
break;
604645
}
605646
Tensor tensor(DT_HALF, tensor_shape);
606647
auto flat = tensor.flat<Eigen::half>();
607648
for (int i = 0; i < input.float_val_size(); ++i) {
608649
flat(i) = Eigen::half(input.float_val(i));
609650
}
610-
return tensor;
651+
ret.tensor = std::move(tensor);
611652
}
612653
case tensorflow::eas::DT_RESOURCE: {
613-
LOG(FATAL) << "Input Tensor Not Support this DataType: DT_RESOURCE";
654+
ret.status = errors::InvalidArgument(
655+
"Input Tensor: ", key, ", Not Support this DataType: DT_RESOURCE");
614656
break;
615657
}
616658
case tensorflow::eas::DT_VARIANT: {
617-
LOG(FATAL) << "Input Tensor Not Support this DataType: DT_VARIANT";
659+
ret.status = errors::InvalidArgument(
660+
"Input Tensor: ", key, ", Not Support this DataType: DT_VARIANT");
618661
break;
619662
}
620663
default: {
621-
LOG(FATAL) << "Input Tensor Not Support this DataType";
664+
ret.status = errors::InvalidArgument(
665+
"Input Tensor: ", key, ", Not Support this DataType");
622666
break;
623667
}
624668
}
625-
return Tensor();
669+
670+
return ret;
626671
}
627672

628673
eas::PredictResponse Tensor2Response(

0 commit comments

Comments
 (0)