token-server: Fix panic when generating machine token for unrecognized machine.

tokenserver/appengine/impl/machinetoken/rpc_mint_machine_token.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package machinetoken
 
 import (
         "crypto/x509"
         "fmt"
         "strings"
@@ skipping 122 matching lines @@
         // At this point we trust what's in MachineTokenRequest, proceed with
         // generating the token.
         args := mintTokenArgs{
                 Config:  ca.ParsedConfig,
                 Cert:    cert,
                 Request: &tokenReq,
         }
         switch tokenReq.TokenType {
         case tokenserver.MachineTokenType_LUCI_MACHINE_TOKEN:
                 resp, body, err := r.mintLuciMachineToken(c, args)
-                if err != nil {
+                switch {
+                case err != nil: // grpc-level error
                         return nil, err
+                case resp == nil: // should not happen
+                        panic("both resp and err can't be nil")
+                case resp.ErrorCode != 0: // logic-level error

[Vadim Sh., 2017/06/20 03:49:50]

this is the actual fix: don't try to log the token if ErrorCode != 0 (there's
nothing to log)

+                        if resp.TokenResponse != nil {
+                                panic("TokenResponse must be nil if ErrorCode != 0")
+                        }
+                        return resp, nil
+                }
+                if resp.TokenResponse == nil {
+                        panic("TokenResponse must not be nil if ErrorCode == 0")
                 }
                 if r.LogToken != nil {
                         // Errors during logging are considered not fatal. bqlog library has
                         // a monitoring counter that tracks number of errors, so they are not
                         // totally invisible.
                         tokInfo := MintedTokenInfo{
                                 Request:   &tokenReq,
                                 Response:  resp.TokenResponse,
                                 TokenBody: body,
                                 CA:        ca,
@@ skipping 62 matching lines @@
         serviceVer, err := utils.ServiceVersion(c, r.Signer)
         if err != nil {
                 return nil, grpc.Errorf(codes.Internal, "can't grab service version - %s", err)
         }
         return &minter.MintMachineTokenResponse{
                 ErrorCode:      code,
                 ErrorMessage:   fmt.Sprintf(msg, args...),
                 ServiceVersion: serviceVer,
         }, nil
 }