Datastore has its own error type

[david-crespo]

Getting a start on prototyping #347. Generally I think all the datastore functions should return a datastore error, and then it's the responsibility of the nexus wrapper (probably, could also be the endpoint) to convert it to an external error. UpdateResult is trivial to convert because there's only one query in all three examples, so I started with that.

The insight that I'm rolling with here is that if public_error_from_diesel_pool is what we call with errors everywhere, then roughly speaking the datastore error struct just needs to represent the args to public_error_from_diesel_pool:

pub struct DSError {
    error: PoolError,
    resource_type: ResourceType,
    lookup_type: LookupType,
}

And then we can make public_error_from_diesel_pool the From that converts a DSError to an external error.

impl From<DSError> for Error {
    fn from(e: DSError) -> Self {
        public_error_from_diesel_pool(e.error, e.resource_type, e.lookup_type)
    }
}

Unfortunately it's not quite that simple, because there's also public_error_from_diesel_pool_create for create errors, which would be ok, but there are methods that might return both kinds of error, for example project create: it gives a normal error if it can't find the org, but a create error if it can't create the project.

omicron/nexus/src/db/datastore.rs

Lines 340 to 352 in 488db25

	.map_err(|e| match e {
	InsertError::CollectionNotFound => Error::ObjectNotFound {
	type_name: ResourceType::Organization,
	lookup_type: LookupType::ById(organization_id),
	},
	InsertError::DatabaseError(e) => {
	public_error_from_diesel_pool_create(
	e,
	ResourceType::Project,
	&name,
	)
	}
	})

So if there's a single common datastore Error type, it probably has to be an enum of both create and non-create error info.

[davepacheco]

I think authorization errors will show up too. You can have the equivalents of both Error::Unauthenticated and Error::Forbidden. We also currently return InternalError from Datastore in some cases.

[david-crespo]

different kinds of errors have different metadata, so this becomes a whole thing

[david-crespo]

these don't all have to have the same kind of error — instead of the big pattern match on the error type in Error::from, there could be CreateError etc and they each have their own Error::from

[david-crespo]

I will come back to this later.