// Acquire a lease on the most recent version of a table descriptor.
// If the lease cannot be obtained because the descriptor is in the process of
// being deleted, the error will be errTableDeleted.
func (s LeaseStore) Acquire(
txn *client.Txn,
tableID sqlbase.ID,
minVersion sqlbase.DescriptorVersion,
minExpirationTime parser.DTimestamp,
) (*LeaseState, error) {
lease := &LeaseState{}
expiration := time.Unix(0, s.clock.Now().WallTime).Add(jitteredLeaseDuration())
if !minExpirationTime.IsZero() && expiration.Before(minExpirationTime.Time) {
expiration = minExpirationTime.Time
}
lease.expiration = parser.DTimestamp{Time: expiration}
// Use the supplied (user) transaction to look up the descriptor because the
// descriptor might have been created within the transaction.
p := makeInternalPlanner(txn, security.RootUser)
const getDescriptor = `SELECT descriptor FROM system.descriptor WHERE id = $1`
values, err := p.queryRow(getDescriptor, int(tableID))
if err != nil {
return nil, err
}
if values == nil {
return nil, sqlbase.ErrDescriptorNotFound
}
desc := &sqlbase.Descriptor{}
if err := proto.Unmarshal([]byte(*values[0].(*parser.DBytes)), desc); err != nil {
return nil, err
}
tableDesc := desc.GetTable()
if tableDesc == nil {
return nil, errors.Errorf("ID %d is not a table", tableID)
}
if err := filterTableState(tableDesc); err != nil {
return nil, err
}
tableDesc.MaybeUpgradeFormatVersion()
lease.TableDescriptor = *tableDesc
// ValidateTable instead of Validate, even though we have a txn available,
// so we don't block reads waiting for this lease.
if err := lease.ValidateTable(); err != nil {
return nil, err
}
if lease.Version < minVersion {
return nil, errors.Errorf("version %d of table %d does not exist yet", minVersion, tableID)
}
// Insert the entry in the lease table in a separate transaction. This is
// necessary because we want to ensure that the lease entry is added and the
// transaction passed to Acquire() might be aborted. The lease entry needs to
// be added because we store the returned LeaseState in local in-memory maps
// and cannot handle the entry being reverted. This is safe because either
// the descriptor we're acquiring the lease on existed prior to the acquire
// transaction in which case acquiring the lease is kosher, or the descriptor
// was created within the acquire transaction. The second case is more
// subtle. We might create a lease entry for a table that doesn't exist, but
// there is no harm in that as no other transaction will be attempting to
// modify the descriptor and even if the descriptor is never created we'll
// just have a dangling lease entry which will eventually get GC'd.
ctx := txn.Context // propagate context/trace to new transaction
err = s.db.Txn(context.TODO(), func(txn *client.Txn) error {
txn.Context = ctx
p := makeInternalPlanner(txn, security.RootUser)
const insertLease = `INSERT INTO system.lease (descID, version, nodeID, expiration) ` +
`VALUES ($1, $2, $3, $4)`
count, err := p.exec(insertLease, lease.ID, int(lease.Version), s.nodeID, &lease.expiration)
if err != nil {
return err
}
if count != 1 {
return errors.Errorf("%s: expected 1 result, found %d", insertLease, count)
}
return nil
})
return lease, err
}
