| /* |
| * Copyright 2018, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package ext.maps.booking.partner.v2; |
| |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.AvailabilityUpdate; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.Booking; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.BookingStatus; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.CheckAvailabilityRequest; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.CheckAvailabilityResponse; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.CheckAvailabilityResponse.DurationRequirement; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.CreateBookingRequest; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.CreateBookingResponse; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.GetBookingStatusRequest; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.GetBookingStatusResponse; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.ListBookingsRequest; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.ListBookingsResponse; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.PrepaymentStatus; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.Slot; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.UpdateBookingRequest; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.UpdateBookingResponse; |
| import ext.maps.booking.partner.v2.ApitemplateV2BookingService.UserPaymentOption; |
| import grpc.health.v1.Health.HealthImpl; |
| import io.grpc.Grpc; |
| import io.grpc.Metadata; |
| import io.grpc.Server; |
| import io.grpc.ServerCall; |
| import io.grpc.ServerCallHandler; |
| import io.grpc.ServerInterceptor; |
| import io.grpc.ServerInterceptors; |
| import io.grpc.Status; |
| import io.grpc.netty.GrpcSslContexts; |
| import io.grpc.netty.NettyServerBuilder; |
| import io.grpc.stub.StreamObserver; |
| import io.netty.handler.ssl.ClientAuth; |
| import io.netty.handler.ssl.SslContextBuilder; |
| import io.netty.handler.ssl.SslProvider; |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.InetSocketAddress; |
| import java.security.cert.Certificate; |
| import java.security.cert.CertificateEncodingException; |
| import java.security.cert.X509Certificate; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.logging.Logger; |
| import javax.net.ssl.SSLPeerUnverifiedException; |
| import javax.net.ssl.SSLSession; |
| import org.bouncycastle.asn1.x500.RDN; |
| import org.bouncycastle.asn1.x500.X500Name; |
| import org.bouncycastle.asn1.x500.style.BCStyle; |
| import org.bouncycastle.asn1.x500.style.IETFUtils; |
| import org.bouncycastle.cert.jcajce.JcaX509CertificateHolder; |
| |
| /** Booking Server with TLS enabled */ |
| public class BookingService { |
| private static final Logger logger = Logger.getLogger(BookingService.class.getName()); |
| |
| private Server server; |
| |
| private final String host; |
| private final int port; |
| private final String certChainFilePath; |
| private final String privateKeyFilePath; |
| private final String trustedrootsFilePath; |
| private final Set<String> acceptedCNs; |
| |
| public BookingService( |
| String host, |
| int port, |
| String certChainFilePath, |
| String privateKeyFilePath, |
| String trustedrootsFilePath, |
| Set<String> acceptedCNs) { |
| this.host = host; |
| this.port = port; |
| this.certChainFilePath = certChainFilePath; |
| this.privateKeyFilePath = privateKeyFilePath; |
| this.trustedrootsFilePath = trustedrootsFilePath; |
| this.acceptedCNs = acceptedCNs; |
| } |
| |
| private SslContextBuilder getSslContextBuilder() { |
| SslContextBuilder sslClientContextBuilder = |
| SslContextBuilder.forServer(new File(certChainFilePath), new File(privateKeyFilePath)); |
| if (trustedrootsFilePath != null) { |
| sslClientContextBuilder.trustManager(new File(trustedrootsFilePath)); |
| sslClientContextBuilder.clientAuth(ClientAuth.OPTIONAL); |
| } |
| return GrpcSslContexts.configure(sslClientContextBuilder, SslProvider.OPENSSL); |
| } |
| |
| private void start() throws IOException { |
| |
| server = |
| NettyServerBuilder.forAddress(new InetSocketAddress(host, port)) |
| .addService(ServerInterceptors.intercept(new BookingServiceImpl(), new MyInterceptor())) |
| .addService(new HealthImpl()) |
| .sslContext(getSslContextBuilder().build()) |
| .build() |
| .start(); |
| |
| logger.info("Booking Server started, listening on " + port); |
| Runtime.getRuntime() |
| .addShutdownHook( |
| new Thread() { |
| @Override |
| public void run() { |
| // Use stderr here since the logger may have been reset by its JVM shutdown hook. |
| System.err.println("*** shutting down gRPC server since JVM is shutting down"); |
| BookingService.this.stop(); |
| System.err.println("*** server shut down"); |
| } |
| }); |
| } |
| |
| private void stop() { |
| if (server != null) { |
| server.shutdown(); |
| } |
| } |
| |
| /** Await termination on the main thread since the grpc library uses daemon threads. */ |
| private void blockUntilShutdown() throws InterruptedException { |
| if (server != null) { |
| server.awaitTermination(); |
| } |
| } |
| |
| /** Main launches the server. */ |
| public static void main(String[] args) throws IOException, InterruptedException { |
| // Set the accepted cns of the server |
| Set<String> acceptedCNs = new HashSet<String>(); |
| acceptedCNs.add("mapsbooking.businesslink-3.net"); |
| |
| // TODO(partner): override your host name, port, server_cert_chain file path, |
| // private_key file path and trusted_client_roots file path here to build the server |
| final BookingService server = |
| new BookingService( |
| "localhost", |
| 8443, |
| "src/main/certificates/server_cert_chain.pem", |
| "src/main/certificates/server_private_key.pem", |
| "src/main/certificates/trusted_client_roots.pem", |
| acceptedCNs); |
| server.start(); |
| server.blockUntilShutdown(); |
| } |
| |
| /** |
| * Implement the server interceptor to do peer certificate validation that checks for a specific |
| * CN in the subject name, if the CN check fails, the connection will be closed with |
| * "PERMISSION_DENIED" status message. |
| */ |
| private class MyInterceptor implements ServerInterceptor { |
| @Override |
| public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall( |
| ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { |
| SSLSession sslSession = call.getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION); |
| try { |
| Certificate[] peerCerts = sslSession.getPeerCertificates(); |
| if (peerCerts[0] instanceof java.security.cert.X509Certificate) { |
| X509Certificate peerCert = (X509Certificate) peerCerts[0]; |
| X500Name x500Name = new JcaX509CertificateHolder(peerCert).getSubject(); |
| RDN cn = x500Name.getRDNs(BCStyle.CN)[0]; |
| String peerCN = IETFUtils.valueToString(cn.getFirst().getValue()); |
| if (!acceptedCNs.contains(peerCN)) { |
| throw new SSLPeerUnverifiedException("Invalid CN"); |
| } |
| } else { |
| throw new SSLPeerUnverifiedException("Invalid certificate type"); |
| } |
| } catch (SSLPeerUnverifiedException se) { |
| System.err.println(se.getMessage()); |
| call.close(Status.PERMISSION_DENIED, headers); |
| return new ServerCall.Listener<ReqT>() {}; |
| } catch (CertificateEncodingException ce) { |
| System.err.println(ce.getMessage()); |
| call.close(Status.PERMISSION_DENIED, headers); |
| return new ServerCall.Listener<ReqT>() {}; |
| } |
| return next.startCall(call, headers); |
| } |
| } |
| |
| /** The implementation of Booking Service. */ |
| static class BookingServiceImpl extends BookingServiceGrpc.BookingServiceImplBase { |
| @Override |
| public void checkAvailability( |
| CheckAvailabilityRequest request, |
| StreamObserver<CheckAvailabilityResponse> responseObserver) { |
| |
| Slot requestedSlot = request.getSlot(); |
| |
| // TODO(partner): perform availability check |
| // |
| // Error conditions: response with corresponding canonical gRPC error code |
| // example: |
| // responseObserver.onError( |
| // new StatusException( |
| // io.grpc.Status.INVALID_ARGUMENT.withDescription("Invalid merchant id") |
| // ) |
| // ); |
| // |
| // Happy path: implement the helper functions, populate the response |
| |
| CheckAvailabilityResponse response = |
| CheckAvailabilityResponse.newBuilder() |
| .setSlot(requestedSlot) |
| .setCountAvailable(getAvailableSpots(requestedSlot)) |
| .setDurationRequirement(getDurationRequirement(requestedSlot)) // optional |
| .setAvailabilityUpdate(getAvailabilityUpdate(requestedSlot)) // optional |
| .build(); |
| |
| responseObserver.onNext(response); |
| responseObserver.onCompleted(); |
| } |
| |
| private int getAvailableSpots(Slot slot) { |
| // TODO(partner): get the available spots for the given slot |
| // |
| // int available_spots = ... |
| // return available_spots; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| private DurationRequirement getDurationRequirement(Slot slot) { |
| // TODO(partner): optional, get the duration requirment for the given slot |
| // |
| // DurationRequirement durationRequirement = ... |
| // return durationRequirement; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| private AvailabilityUpdate getAvailabilityUpdate(Slot slot) { |
| // TODO(partner): optional, get the availability update for the given slot |
| // |
| // AvailabilityUpdate availabilityUpdate = ... |
| // return availabilityUpdate; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| @Override |
| public void createBooking( |
| CreateBookingRequest request, StreamObserver<CreateBookingResponse> responseObserver) { |
| |
| // TODO(partner): create a booking based on the request |
| // |
| // Error conditions: |
| // unexpected error -> response with corresponding canonical gRPC error code |
| // example: |
| // responseObserver.onError( |
| // new StatusException( |
| // io.grpc.Status.INVALID_ARGUMENT.withDescription("Invalid merchant id") |
| // ) |
| // ); |
| // business logic error -> set the BookingFailure in the response |
| // example: |
| // BookingFailure bookingFailure = BookingFailure.newBuilder() |
| // .setCause(Cause.SLOT_UNAVAILABLE) |
| // .setDescription("slot is not available now") |
| // .build(); |
| // CreateBookingResponse response = CreateBookingResponse.newBuilder() |
| // .setBookingFailure(bookingFailure)... |
| // |
| // Happy path: implement the helper functions, populate the response |
| |
| Booking booking = createSuccessfulBooking(request); |
| |
| CreateBookingResponse response = |
| CreateBookingResponse.newBuilder() |
| .setBooking(booking) |
| .setUserPaymentOption(getUserPaymentOption(booking)) // optional |
| .build(); |
| |
| responseObserver.onNext(response); |
| responseObserver.onCompleted(); |
| } |
| |
| private Booking createSuccessfulBooking(CreateBookingRequest request) { |
| // TODO(partner): create a booking based on the create booking request and return the |
| // created booking instance |
| // |
| // Booking created = ...(e.g. |
| // Booking.newBuilder() |
| // .setBookingId("sampleBooking1") |
| // .setSlot(request.getSlot()) |
| // .setUserInformation(request.getUserInformation()) |
| // .setStatus(BookingStatus.CONFIRMED) |
| // .setPaymentInformation(request.getPaymentInformation()) |
| // .build() |
| // ) |
| // return created; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| private UserPaymentOption getUserPaymentOption(Booking booking) { |
| // TODO(partner): optional, get the user payment option for the given booking |
| // |
| // UserPaymentOption paymentOption = ... |
| // return paymentOption; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| @Override |
| public void updateBooking( |
| UpdateBookingRequest request, StreamObserver<UpdateBookingResponse> responseObserver) { |
| |
| // TODO(partner): update the booking based on the request |
| // |
| // Error conditions: |
| // unexpected error -> response with corresponding canonical gRPC error code |
| // example: |
| // responseObserver.onError( |
| // new StatusException( |
| // io.grpc.Status.NOT_FOUND.withDescription("Unknown booking id") |
| // ) |
| // ); |
| // business logic error -> set the BookingFailure in the response |
| // example: |
| // BookingFailure bookingFailure = BookingFailure.newBuilder() |
| // .setCause(Cause.SLOT_UNAVAILABLE) |
| // .setDescription("slot is not available now") |
| // .build(); |
| // CreateBookingResponse response = CreateBookingResponse.newBuilder() |
| // .setBookingFailure(bookingFailure)... |
| // |
| // Happy path: implement the helper functions, populate the response |
| |
| Booking booking = updateSuccessfulBooking(request); |
| |
| UpdateBookingResponse response = |
| UpdateBookingResponse.newBuilder() |
| .setBooking(booking) |
| .setUserPaymentOption(getUserPaymentOption(booking)) // option |
| .build(); |
| |
| responseObserver.onNext(response); |
| responseObserver.onCompleted(); |
| } |
| |
| private Booking updateSuccessfulBooking(UpdateBookingRequest request) { |
| // TODO(partner): look up the booking with bookingId, update fields according to |
| // updateMask and return the updated booking instance |
| // |
| // String bookingId = request.getBooking().getBookingId(); |
| // FieldMask updateMask = request.getUpdateMask(); |
| // Booking updated = ... |
| // return updated; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| @Override |
| public void getBookingStatus( |
| GetBookingStatusRequest request, |
| StreamObserver<GetBookingStatusResponse> responseObserver) { |
| |
| String bookingId = request.getBookingId(); |
| |
| // TODO(partner): look up the booking status and prepayment status with bookingId |
| // |
| // Error conditions: |
| // unexpected error -> response with corresponding canonical gRPC error code |
| // example: |
| // responseObserver.onError( |
| // new StatusException( |
| // io.grpc.Status.NOT_FOUND.withDescription("Unknown booking id") |
| // ) |
| // ); |
| // |
| // Happy path: implement the helper functions, populate the response |
| |
| GetBookingStatusResponse response = |
| GetBookingStatusResponse.newBuilder() |
| .setBookingId(bookingId) |
| .setBookingStatus(getBookingStatus(bookingId)) |
| .setPrepaymentStatus(getPrepaymentStatus(bookingId)) |
| .build(); |
| |
| responseObserver.onNext(response); |
| responseObserver.onCompleted(); |
| } |
| |
| private BookingStatus getBookingStatus(String bookingId) { |
| // TODO(partner): get the booking status for the given bookingId |
| // |
| // BookingStatus bookingStatus = ... |
| // return bookingStatus; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| private PrepaymentStatus getPrepaymentStatus(String bookingId) { |
| // TODO(partner): get the prepayment status for the given bookingId |
| // |
| // Prepayment prepaymentStatus = ... |
| // return prepaymentStatus; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| |
| @Override |
| public void listBookings( |
| ListBookingsRequest request, StreamObserver<ListBookingsResponse> responseObserver) { |
| |
| String userId = request.getUserId(); |
| |
| // TODO(partner): look up all bookings with the given userId |
| // |
| // Error conditions: |
| // unexpected error -> response with corresponding canonical gRPC error code |
| // example: |
| // responseObserver.onError( |
| // new StatusException( |
| // io.grpc.Status.NOT_FOUND.withDescription("Unknown user id") |
| // ) |
| // ); |
| // |
| // Happy path: implement the helper function, populate the response |
| |
| ListBookingsResponse response = |
| ListBookingsResponse.newBuilder().addAllBookings(getListBooking(userId)).build(); |
| |
| responseObserver.onNext(response); |
| responseObserver.onCompleted(); |
| } |
| |
| private List<Booking> getListBooking(String userId) { |
| // TODO(partner): get the bookings list for the given userId |
| // |
| // List<Booking> bookings = ... |
| // return bookings; |
| |
| throw new UnsupportedOperationException("Not implemented yet"); |
| } |
| } |
| } |
