machine-db/appengine/rpc/machines.go - infra/luci/luci-go - Git at Google

 // Copyright 2018 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package rpc

 import (
 	"context"
 	"strings"

 	"github.com/golang/protobuf/ptypes/empty"

 	"google.golang.org/genproto/protobuf/field_mask"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"

 	"github.com/Masterminds/squirrel"
 	"github.com/VividCortex/mysqlerr"
 	"github.com/go-sql-driver/mysql"

 	"go.chromium.org/luci/common/errors"

 	"go.chromium.org/luci/machine-db/api/common/v1"
 	"go.chromium.org/luci/machine-db/api/crimson/v1"
 	"go.chromium.org/luci/machine-db/appengine/database"
 )

 // CreateMachine handles a request to create a new machine.
 func (*Service) CreateMachine(c context.Context, req *crimson.CreateMachineRequest) (*crimson.Machine, error) {
 	if err := createMachine(c, req.Machine); err != nil {
 		return nil, err
 	}
 	return req.Machine, nil
 }

 // DeleteMachine handles a request to delete an existing machine.
 func (*Service) DeleteMachine(c context.Context, req *crimson.DeleteMachineRequest) (*empty.Empty, error) {
 	if err := deleteMachine(c, req.Name); err != nil {
 		return nil, err
 	}
 	return &empty.Empty{}, nil
 }

 // ListMachines handles a request to list machines.
 func (*Service) ListMachines(c context.Context, req *crimson.ListMachinesRequest) (*crimson.ListMachinesResponse, error) {
 	machines, err := listMachines(c, database.Get(c), req)
 	if err != nil {
 		return nil, err
 	}
 	return &crimson.ListMachinesResponse{
 		Machines: machines,
 	}, nil
 }

 // RenameMachine handles a request to rename an existing machine.
 func (*Service) RenameMachine(c context.Context, req *crimson.RenameMachineRequest) (*crimson.Machine, error) {
 	return renameMachine(c, req.Name, req.NewName)
 }

 // UpdateMachine handles a request to update an existing machine.
 func (*Service) UpdateMachine(c context.Context, req *crimson.UpdateMachineRequest) (*crimson.Machine, error) {
 	return updateMachine(c, req.Machine, req.UpdateMask)
 }

 // createMachine creates a new machine in the database.
 func createMachine(c context.Context, m *crimson.Machine) error {
 	if err := validateMachineForCreation(m); err != nil {
 		return err
 	}

 	db := database.Get(c)
 	// By setting machines.platform_id and machines.rack_id NOT NULL when setting up the database, we can avoid checking if the given
 	// platform and rack are valid. MySQL will turn up NULL for their column values which will be rejected as an error.
 	_, err := db.ExecContext(c, `
 		INSERT INTO machines (name, platform_id, rack_id, description, asset_tag, service_tag, deployment_ticket, drac_password, state)
 		VALUES (?, (SELECT id FROM platforms WHERE name = ?), (SELECT id FROM racks WHERE name = ?), ?, ?, ?, ?, ?, ?)
 	`, m.Name, m.Platform, m.Rack, m.Description, m.AssetTag, m.ServiceTag, m.DeploymentTicket, m.DracPassword, m.State)
 	if err != nil {
 		switch e, ok := err.(*mysql.MySQLError); {
 		case !ok:
 			// Type assertion failed.
 		case e.Number == mysqlerr.ER_DUP_ENTRY:
 			// e.g. "Error 1062: Duplicate entry 'machine-name' for key 'name'".
 			// Name is the only required unique field (ID is required unique, but it's auto-incremented).
 			return status.Errorf(codes.AlreadyExists, "duplicate machine %q", m.Name)
 		case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'platform_id'"):
 			// e.g. "Error 1048: Column 'platform_id' cannot be null".
 			return status.Errorf(codes.NotFound, "platform %q does not exist", m.Platform)
 		case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'rack_id'"):
 			// e.g. "Error 1048: Column 'rack_id' cannot be null".
 			return status.Errorf(codes.NotFound, "rack %q does not exist", m.Rack)
 		}
 		return errors.Annotate(err, "failed to create machine").Err()
 	}
 	return nil
 }

 // deleteMachine deletes an existing machine from the database.
 func deleteMachine(c context.Context, name string) error {
 	if name == "" {
 		return status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
 	}

 	db := database.Get(c)
 	res, err := db.ExecContext(c, `
 		DELETE FROM machines WHERE name = ?
 	`, name)
 	if err != nil {
 		switch e, ok := err.(*mysql.MySQLError); {
 		case !ok:
 			// Type assertion failed.
 		case e.Number == mysqlerr.ER_ROW_IS_REFERENCED_2 && strings.Contains(e.Message, "`machine_id`"):
 			// e.g. "Error 1452: Cannot add or update a child row: a foreign key constraint fails (FOREIGN KEY (`machine_id`) REFERENCES `machines` (`id`))".
 			return status.Errorf(codes.FailedPrecondition, "delete entities referencing this machine first")
 		}
 		return errors.Annotate(err, "failed to delete machine").Err()
 	}
 	switch rows, err := res.RowsAffected(); {
 	case err != nil:
 		return errors.Annotate(err, "failed to fetch affected rows").Err()
 	case rows == 0:
 		return status.Errorf(codes.NotFound, "machine %q does not exist", name)
 	}
 	return nil
 }

 // listMachines returns a slice of machines in the database.
 func listMachines(c context.Context, q database.QueryerContext, req *crimson.ListMachinesRequest) ([]*crimson.Machine, error) {
 	stmt := squirrel.Select(
 		"m.name",
 		"p.name",
 		"r.name",
 		"d.name",
 		"m.description",
 		"m.asset_tag",
 		"m.service_tag",
 		"m.deployment_ticket",
 		"m.drac_password",
 		"m.state",
 	)
 	stmt = stmt.From("machines m, platforms p, racks r, datacenters d").
 		Where("m.platform_id = p.id").Where("m.rack_id = r.id").Where("r.datacenter_id = d.id")
 	stmt = selectInString(stmt, "m.name", req.Names)
 	stmt = selectInString(stmt, "p.name", req.Platforms)
 	stmt = selectInString(stmt, "r.name", req.Racks)
 	stmt = selectInString(stmt, "d.name", req.Datacenters)
 	stmt = selectInState(stmt, "m.state", req.States)
 	query, args, err := stmt.ToSql()
 	if err != nil {
 		return nil, errors.Annotate(err, "failed to generate statement").Err()
 	}

 	rows, err := q.QueryContext(c, query, args...)
 	if err != nil {
 		return nil, errors.Annotate(err, "failed to fetch machines").Err()
 	}
 	defer rows.Close()
 	var machines []*crimson.Machine
 	for rows.Next() {
 		m := &crimson.Machine{}
 		if err = rows.Scan(
 			&m.Name,
 			&m.Platform,
 			&m.Rack,
 			&m.Datacenter,
 			&m.Description,
 			&m.AssetTag,
 			&m.ServiceTag,
 			&m.DeploymentTicket,
 			&m.DracPassword,
 			&m.State,
 		); err != nil {
 			return nil, errors.Annotate(err, "failed to fetch machine").Err()
 		}
 		machines = append(machines, m)
 	}
 	return machines, nil
 }

 // renameMachine renames an existing machine in the database.
 func renameMachine(c context.Context, name, newName string) (*crimson.Machine, error) {
 	switch {
 	case name == "":
 		return nil, status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
 	case newName == "":
 		return nil, status.Error(codes.InvalidArgument, "new name is required and must be non-empty")
 	case name == newName:
 		return nil, status.Error(codes.InvalidArgument, "new name must be different")
 	}

 	tx, err := database.Begin(c)
 	if err != nil {
 		return nil, errors.Annotate(err, "failed to begin transaction").Err()
 	}
 	defer tx.MaybeRollback(c)

 	res, err := tx.ExecContext(c, `
 		UPDATE machines
 		SET name = ?
 		WHERE name = ?
 	`, newName, name)
 	if err != nil {
 		switch e, ok := err.(*mysql.MySQLError); {
 		case !ok:
 			// Type assertion failed.
 		case e.Number == mysqlerr.ER_DUP_ENTRY:
 			// e.g. "Error 1062: Duplicate entry 'machine-name' for key 'name'".
 			return nil, status.Errorf(codes.AlreadyExists, "duplicate machine %q", newName)
 		}
 		return nil, errors.Annotate(err, "failed to rename machine").Err()
 	}
 	switch rows, err := res.RowsAffected(); {
 	case err != nil:
 		return nil, errors.Annotate(err, "failed to fetch affected rows").Err()
 	case rows == 0:
 		return nil, status.Errorf(codes.NotFound, "machine %q does not exist", name)
 	}

 	machines, err := listMachines(c, tx, &crimson.ListMachinesRequest{
 		Names: []string{newName},
 	})
 	if err != nil {
 		return nil, errors.Annotate(err, "failed to fetch renamed machine").Err()
 	}

 	if err := tx.Commit(); err != nil {
 		return nil, errors.Annotate(err, "failed to commit transaction").Err()
 	}
 	return machines[0], nil
 }

 // updateMachine updates an existing machine in the database.
 func updateMachine(c context.Context, m *crimson.Machine, mask *field_mask.FieldMask) (*crimson.Machine, error) {
 	if err := validateMachineForUpdate(m, mask); err != nil {
 		return nil, err
 	}
 	stmt := squirrel.Update("machines")
 	for _, path := range mask.Paths {
 		switch path {
 		case "platform":
 			stmt = stmt.Set("platform_id", squirrel.Expr("(SELECT id FROM platforms WHERE name = ?)", m.Platform))
 		case "rack":
 			stmt = stmt.Set("rack_id", squirrel.Expr("(SELECT id FROM racks WHERE name = ?)", m.Rack))
 		case "state":
 			stmt = stmt.Set("state", m.State)
 		case "description":
 			stmt = stmt.Set("description", m.Description)
 		case "asset_tag":
 			stmt = stmt.Set("asset_tag", m.AssetTag)
 		case "service_tag":
 			stmt = stmt.Set("service_tag", m.ServiceTag)
 		case "deployment_ticket":
 			stmt = stmt.Set("deployment_ticket", m.DeploymentTicket)
 		case "drac_password":
 			stmt = stmt.Set("drac_password", m.DracPassword)
 		}
 	}
 	stmt = stmt.Where("name = ?", m.Name)
 	query, args, err := stmt.ToSql()
 	if err != nil {
 		return nil, errors.Annotate(err, "failed to generate statement").Err()
 	}

 	tx, err := database.Begin(c)
 	if err != nil {
 		return nil, errors.Annotate(err, "failed to begin transaction").Err()
 	}
 	defer tx.MaybeRollback(c)

 	_, err = tx.ExecContext(c, query, args...)
 	if err != nil {
 		switch e, ok := err.(*mysql.MySQLError); {
 		case !ok:
 			// Type assertion failed.
 		case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'platform_id'"):
 			// e.g. "Error 1048: Column 'platform_id' cannot be null".
 			return nil, status.Errorf(codes.NotFound, "platform %q does not exist", m.Platform)
 		case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'rack_id'"):
 			// e.g. "Error 1048: Column 'rack_id' cannot be null".
 			return nil, status.Errorf(codes.NotFound, "rack %q does not exist", m.Rack)
 		}
 		return nil, errors.Annotate(err, "failed to update machine").Err()
 	}
 	// The number of rows affected cannot distinguish between zero because the machine didn't exist
 	// and zero because the row already matched, so skip looking at the number of rows affected.

 	machines, err := listMachines(c, tx, &crimson.ListMachinesRequest{
 		Names: []string{m.Name},
 	})
 	switch {
 	case err != nil:
 		return nil, errors.Annotate(err, "failed to fetch updated machine").Err()
 	case len(machines) == 0:
 		return nil, status.Errorf(codes.NotFound, "machine %q does not exist", m.Name)
 	}

 	if err := tx.Commit(); err != nil {
 		return nil, errors.Annotate(err, "failed to commit transaction").Err()
 	}
 	return machines[0], nil
 }

 // validateMachineForCreation validates a machine for creation.
 func validateMachineForCreation(m *crimson.Machine) error {
 	switch {
 	case m == nil:
 		return status.Error(codes.InvalidArgument, "machine specification is required")
 	case m.Name == "":
 		return status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
 	case m.Platform == "":
 		return status.Error(codes.InvalidArgument, "platform is required and must be non-empty")
 	case m.Rack == "":
 		return status.Error(codes.InvalidArgument, "rack is required and must be non-empty")
 	case m.Datacenter != "":
 		return status.Error(codes.InvalidArgument, "datacenter must not be specified, use rack instead")
 	case m.State == common.State_STATE_UNSPECIFIED:
 		return status.Error(codes.InvalidArgument, "state is required")
 	default:
 		return nil
 	}
 }

 // validateMachineForUpdate validates a machine for update.
 func validateMachineForUpdate(m *crimson.Machine, mask *field_mask.FieldMask) error {
 	switch err := validateUpdateMask(mask); {
 	case m == nil:
 		return status.Error(codes.InvalidArgument, "machine specification is required")
 	case m.Name == "":
 		return status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
 	case err != nil:
 		return err
 	}
 	for _, path := range mask.Paths {
 		switch path {
 		case "name":
 			return status.Error(codes.InvalidArgument, "machine name cannot be updated, delete and create a new machine instead")
 		case "platform":
 			if m.Platform == "" {
 				return status.Error(codes.InvalidArgument, "platform is required and must be non-empty")
 			}
 		case "rack":
 			if m.Rack == "" {
 				return status.Error(codes.InvalidArgument, "rack is required and must be non-empty")
 			}
 		case "datacenter":
 			return status.Error(codes.InvalidArgument, "datacenter cannot be updated, update rack instead")
 		case "state":
 			if m.State == common.State_STATE_UNSPECIFIED {
 				return status.Error(codes.InvalidArgument, "state is required")
 			}
 		case "description":
 			// Empty description is allowed, nothing to validate.
 		case "asset_tag":
 			// Empty asset tag is allowed, nothing to validate.
 		case "service_tag":
 			// Empty service tag is allowed, nothing to validate.
 		case "deployment_ticket":
 			// Empty deployment ticket is allowed, nothing to validate.
 		case "drac_password":
 			// Empty DRAC password is allowed, nothing to validate.
 		default:
 			return status.Errorf(codes.InvalidArgument, "unsupported update mask path %q", path)
 		}
 	}
 	return nil
 }
	// Copyright 2018 The LUCI Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package rpc

	import (
	"context"
	"strings"

	"github.com/golang/protobuf/ptypes/empty"

	"google.golang.org/genproto/protobuf/field_mask"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/Masterminds/squirrel"
	"github.com/VividCortex/mysqlerr"
	"github.com/go-sql-driver/mysql"

	"go.chromium.org/luci/common/errors"

	"go.chromium.org/luci/machine-db/api/common/v1"
	"go.chromium.org/luci/machine-db/api/crimson/v1"
	"go.chromium.org/luci/machine-db/appengine/database"
	)

	// CreateMachine handles a request to create a new machine.
	func (Service) CreateMachine(c context.Context, req crimson.CreateMachineRequest) (*crimson.Machine, error) {
	if err := createMachine(c, req.Machine); err != nil {
	return nil, err
	}
	return req.Machine, nil
	}

	// DeleteMachine handles a request to delete an existing machine.
	func (Service) DeleteMachine(c context.Context, req crimson.DeleteMachineRequest) (*empty.Empty, error) {
	if err := deleteMachine(c, req.Name); err != nil {
	return nil, err
	}
	return &empty.Empty{}, nil
	}

	// ListMachines handles a request to list machines.
	func (Service) ListMachines(c context.Context, req crimson.ListMachinesRequest) (*crimson.ListMachinesResponse, error) {
	machines, err := listMachines(c, database.Get(c), req)
	if err != nil {
	return nil, err
	}
	return &crimson.ListMachinesResponse{
	Machines: machines,
	}, nil
	}

	// RenameMachine handles a request to rename an existing machine.
	func (Service) RenameMachine(c context.Context, req crimson.RenameMachineRequest) (*crimson.Machine, error) {
	return renameMachine(c, req.Name, req.NewName)
	}

	// UpdateMachine handles a request to update an existing machine.
	func (Service) UpdateMachine(c context.Context, req crimson.UpdateMachineRequest) (*crimson.Machine, error) {
	return updateMachine(c, req.Machine, req.UpdateMask)
	}

	// createMachine creates a new machine in the database.
	func createMachine(c context.Context, m *crimson.Machine) error {
	if err := validateMachineForCreation(m); err != nil {
	return err
	}

	db := database.Get(c)
	// By setting machines.platform_id and machines.rack_id NOT NULL when setting up the database, we can avoid checking if the given
	// platform and rack are valid. MySQL will turn up NULL for their column values which will be rejected as an error.
	_, err := db.ExecContext(c, `
	INSERT INTO machines (name, platform_id, rack_id, description, asset_tag, service_tag, deployment_ticket, drac_password, state)
	VALUES (?, (SELECT id FROM platforms WHERE name = ?), (SELECT id FROM racks WHERE name = ?), ?, ?, ?, ?, ?, ?)
	`, m.Name, m.Platform, m.Rack, m.Description, m.AssetTag, m.ServiceTag, m.DeploymentTicket, m.DracPassword, m.State)
	if err != nil {
	switch e, ok := err.(*mysql.MySQLError); {
	case !ok:
	// Type assertion failed.
	case e.Number == mysqlerr.ER_DUP_ENTRY:
	// e.g. "Error 1062: Duplicate entry 'machine-name' for key 'name'".
	// Name is the only required unique field (ID is required unique, but it's auto-incremented).
	return status.Errorf(codes.AlreadyExists, "duplicate machine %q", m.Name)
	case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'platform_id'"):
	// e.g. "Error 1048: Column 'platform_id' cannot be null".
	return status.Errorf(codes.NotFound, "platform %q does not exist", m.Platform)
	case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'rack_id'"):
	// e.g. "Error 1048: Column 'rack_id' cannot be null".
	return status.Errorf(codes.NotFound, "rack %q does not exist", m.Rack)
	}
	return errors.Annotate(err, "failed to create machine").Err()
	}
	return nil
	}

	// deleteMachine deletes an existing machine from the database.
	func deleteMachine(c context.Context, name string) error {
	if name == "" {
	return status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
	}

	db := database.Get(c)
	res, err := db.ExecContext(c, `
	DELETE FROM machines WHERE name = ?
	`, name)
	if err != nil {
	switch e, ok := err.(*mysql.MySQLError); {
	case !ok:
	// Type assertion failed.
	case e.Number == mysqlerr.ER_ROW_IS_REFERENCED_2 && strings.Contains(e.Message, "`machine_id`"):
	// e.g. "Error 1452: Cannot add or update a child row: a foreign key constraint fails (FOREIGN KEY (`machine_id`) REFERENCES `machines` (`id`))".
	return status.Errorf(codes.FailedPrecondition, "delete entities referencing this machine first")
	}
	return errors.Annotate(err, "failed to delete machine").Err()
	}
	switch rows, err := res.RowsAffected(); {
	case err != nil:
	return errors.Annotate(err, "failed to fetch affected rows").Err()
	case rows == 0:
	return status.Errorf(codes.NotFound, "machine %q does not exist", name)
	}
	return nil
	}

	// listMachines returns a slice of machines in the database.
	func listMachines(c context.Context, q database.QueryerContext, req crimson.ListMachinesRequest) ([]crimson.Machine, error) {
	stmt := squirrel.Select(
	"m.name",
	"p.name",
	"r.name",
	"d.name",
	"m.description",
	"m.asset_tag",
	"m.service_tag",
	"m.deployment_ticket",
	"m.drac_password",
	"m.state",
	)
	stmt = stmt.From("machines m, platforms p, racks r, datacenters d").
	Where("m.platform_id = p.id").Where("m.rack_id = r.id").Where("r.datacenter_id = d.id")
	stmt = selectInString(stmt, "m.name", req.Names)
	stmt = selectInString(stmt, "p.name", req.Platforms)
	stmt = selectInString(stmt, "r.name", req.Racks)
	stmt = selectInString(stmt, "d.name", req.Datacenters)
	stmt = selectInState(stmt, "m.state", req.States)
	query, args, err := stmt.ToSql()
	if err != nil {
	return nil, errors.Annotate(err, "failed to generate statement").Err()
	}

	rows, err := q.QueryContext(c, query, args...)
	if err != nil {
	return nil, errors.Annotate(err, "failed to fetch machines").Err()
	}
	defer rows.Close()
	var machines []*crimson.Machine
	for rows.Next() {
	m := &crimson.Machine{}
	if err = rows.Scan(
	&m.Name,
	&m.Platform,
	&m.Rack,
	&m.Datacenter,
	&m.Description,
	&m.AssetTag,
	&m.ServiceTag,
	&m.DeploymentTicket,
	&m.DracPassword,
	&m.State,
	); err != nil {
	return nil, errors.Annotate(err, "failed to fetch machine").Err()
	}
	machines = append(machines, m)
	}
	return machines, nil
	}

	// renameMachine renames an existing machine in the database.
	func renameMachine(c context.Context, name, newName string) (*crimson.Machine, error) {
	switch {
	case name == "":
	return nil, status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
	case newName == "":
	return nil, status.Error(codes.InvalidArgument, "new name is required and must be non-empty")
	case name == newName:
	return nil, status.Error(codes.InvalidArgument, "new name must be different")
	}

	tx, err := database.Begin(c)
	if err != nil {
	return nil, errors.Annotate(err, "failed to begin transaction").Err()
	}
	defer tx.MaybeRollback(c)

	res, err := tx.ExecContext(c, `
	UPDATE machines
	SET name = ?
	WHERE name = ?
	`, newName, name)
	if err != nil {
	switch e, ok := err.(*mysql.MySQLError); {
	case !ok:
	// Type assertion failed.
	case e.Number == mysqlerr.ER_DUP_ENTRY:
	// e.g. "Error 1062: Duplicate entry 'machine-name' for key 'name'".
	return nil, status.Errorf(codes.AlreadyExists, "duplicate machine %q", newName)
	}
	return nil, errors.Annotate(err, "failed to rename machine").Err()
	}
	switch rows, err := res.RowsAffected(); {
	case err != nil:
	return nil, errors.Annotate(err, "failed to fetch affected rows").Err()
	case rows == 0:
	return nil, status.Errorf(codes.NotFound, "machine %q does not exist", name)
	}

	machines, err := listMachines(c, tx, &crimson.ListMachinesRequest{
	Names: []string{newName},
	})
	if err != nil {
	return nil, errors.Annotate(err, "failed to fetch renamed machine").Err()
	}

	if err := tx.Commit(); err != nil {
	return nil, errors.Annotate(err, "failed to commit transaction").Err()
	}
	return machines[0], nil
	}

	// updateMachine updates an existing machine in the database.
	func updateMachine(c context.Context, m crimson.Machine, mask field_mask.FieldMask) (*crimson.Machine, error) {
	if err := validateMachineForUpdate(m, mask); err != nil {
	return nil, err
	}
	stmt := squirrel.Update("machines")
	for _, path := range mask.Paths {
	switch path {
	case "platform":
	stmt = stmt.Set("platform_id", squirrel.Expr("(SELECT id FROM platforms WHERE name = ?)", m.Platform))
	case "rack":
	stmt = stmt.Set("rack_id", squirrel.Expr("(SELECT id FROM racks WHERE name = ?)", m.Rack))
	case "state":
	stmt = stmt.Set("state", m.State)
	case "description":
	stmt = stmt.Set("description", m.Description)
	case "asset_tag":
	stmt = stmt.Set("asset_tag", m.AssetTag)
	case "service_tag":
	stmt = stmt.Set("service_tag", m.ServiceTag)
	case "deployment_ticket":
	stmt = stmt.Set("deployment_ticket", m.DeploymentTicket)
	case "drac_password":
	stmt = stmt.Set("drac_password", m.DracPassword)
	}
	}
	stmt = stmt.Where("name = ?", m.Name)
	query, args, err := stmt.ToSql()
	if err != nil {
	return nil, errors.Annotate(err, "failed to generate statement").Err()
	}

	tx, err := database.Begin(c)
	if err != nil {
	return nil, errors.Annotate(err, "failed to begin transaction").Err()
	}
	defer tx.MaybeRollback(c)

	_, err = tx.ExecContext(c, query, args...)
	if err != nil {
	switch e, ok := err.(*mysql.MySQLError); {
	case !ok:
	// Type assertion failed.
	case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'platform_id'"):
	// e.g. "Error 1048: Column 'platform_id' cannot be null".
	return nil, status.Errorf(codes.NotFound, "platform %q does not exist", m.Platform)
	case e.Number == mysqlerr.ER_BAD_NULL_ERROR && strings.Contains(e.Message, "'rack_id'"):
	// e.g. "Error 1048: Column 'rack_id' cannot be null".
	return nil, status.Errorf(codes.NotFound, "rack %q does not exist", m.Rack)
	}
	return nil, errors.Annotate(err, "failed to update machine").Err()
	}
	// The number of rows affected cannot distinguish between zero because the machine didn't exist
	// and zero because the row already matched, so skip looking at the number of rows affected.

	machines, err := listMachines(c, tx, &crimson.ListMachinesRequest{
	Names: []string{m.Name},
	})
	switch {
	case err != nil:
	return nil, errors.Annotate(err, "failed to fetch updated machine").Err()
	case len(machines) == 0:
	return nil, status.Errorf(codes.NotFound, "machine %q does not exist", m.Name)
	}

	if err := tx.Commit(); err != nil {
	return nil, errors.Annotate(err, "failed to commit transaction").Err()
	}
	return machines[0], nil
	}

	// validateMachineForCreation validates a machine for creation.
	func validateMachineForCreation(m *crimson.Machine) error {
	switch {
	case m == nil:
	return status.Error(codes.InvalidArgument, "machine specification is required")
	case m.Name == "":
	return status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
	case m.Platform == "":
	return status.Error(codes.InvalidArgument, "platform is required and must be non-empty")
	case m.Rack == "":
	return status.Error(codes.InvalidArgument, "rack is required and must be non-empty")
	case m.Datacenter != "":
	return status.Error(codes.InvalidArgument, "datacenter must not be specified, use rack instead")
	case m.State == common.State_STATE_UNSPECIFIED:
	return status.Error(codes.InvalidArgument, "state is required")
	default:
	return nil
	}
	}

	// validateMachineForUpdate validates a machine for update.
	func validateMachineForUpdate(m crimson.Machine, mask field_mask.FieldMask) error {
	switch err := validateUpdateMask(mask); {
	case m == nil:
	return status.Error(codes.InvalidArgument, "machine specification is required")
	case m.Name == "":
	return status.Error(codes.InvalidArgument, "machine name is required and must be non-empty")
	case err != nil:
	return err
	}
	for _, path := range mask.Paths {
	switch path {
	case "name":
	return status.Error(codes.InvalidArgument, "machine name cannot be updated, delete and create a new machine instead")
	case "platform":
	if m.Platform == "" {
	return status.Error(codes.InvalidArgument, "platform is required and must be non-empty")
	}
	case "rack":
	if m.Rack == "" {
	return status.Error(codes.InvalidArgument, "rack is required and must be non-empty")
	}
	case "datacenter":
	return status.Error(codes.InvalidArgument, "datacenter cannot be updated, update rack instead")
	case "state":
	if m.State == common.State_STATE_UNSPECIFIED {
	return status.Error(codes.InvalidArgument, "state is required")
	}
	case "description":
	// Empty description is allowed, nothing to validate.
	case "asset_tag":
	// Empty asset tag is allowed, nothing to validate.
	case "service_tag":
	// Empty service tag is allowed, nothing to validate.
	case "deployment_ticket":
	// Empty deployment ticket is allowed, nothing to validate.
	case "drac_password":
	// Empty DRAC password is allowed, nothing to validate.
	default:
	return status.Errorf(codes.InvalidArgument, "unsupported update mask path %q", path)
	}
	}
	return nil
	}