Split `UnfreezeDomain` off `FreezeDomain`. NFC

The code would branch on the value of `freeze` in basically all
implementations and call sites.

src/audit.go

···
 	return audited.Backend.DeleteManifest(ctx, name, opts)
 }
 
-func (audited *auditedBackend) FreezeDomain(ctx context.Context, domain string, freeze bool) (err error) {
-	var event AuditEvent
-	if freeze {
-		event = AuditEvent_FreezeDomain
-	} else {
-		event = AuditEvent_UnfreezeDomain
-	}
+func (audited *auditedBackend) FreezeDomain(ctx context.Context, domain string) (err error) {
+	audited.appendNewAuditRecord(ctx, &AuditRecord{
+		Event:  AuditEvent_FreezeDomain.Enum(),
+		Domain: proto.String(domain),
+	})
+
+	return audited.Backend.FreezeDomain(ctx, domain)
+}
+
+func (audited *auditedBackend) UnfreezeDomain(ctx context.Context, domain string) (err error) {
 	audited.appendNewAuditRecord(ctx, &AuditRecord{
-		Event:  event.Enum(),
+		Event:  AuditEvent_UnfreezeDomain.Enum(),
 		Domain: proto.String(domain),
 	})
 
-	return audited.Backend.FreezeDomain(ctx, domain, freeze)
+	return audited.Backend.UnfreezeDomain(ctx, domain)
 }

src/backend.go

···
 	// Create a domain. This allows us to start serving content for the domain.
 	CreateDomain(ctx context.Context, domain string) error
 
-	// Freeze or thaw a domain. This allows a site to be administratively locked, e.g. if it
+	// Freeze  a domain. This allows a site to be administratively locked, e.g. if it
 	// is discovered serving abusive content.
-	FreezeDomain(ctx context.Context, domain string, freeze bool) error
+	FreezeDomain(ctx context.Context, domain string) error
+
+	// Thaw a domain. This removes the previously placed administrative lock (if any).
+	UnfreezeDomain(ctx context.Context, domain string) error
 
 	// Append a record to the audit log.
 	AppendAuditLog(ctx context.Context, id AuditID, record *AuditRecord) error

src/backend_fs.go

···
 	return nil // no-op
 }
 
-func (fs *FSBackend) FreezeDomain(ctx context.Context, domain string, freeze bool) error {
-	if freeze {
-		return fs.siteRoot.WriteFile(domainFrozenMarkerName(domain), []byte{}, 0o644)
+func (fs *FSBackend) FreezeDomain(ctx context.Context, domain string) error {
+	return fs.siteRoot.WriteFile(domainFrozenMarkerName(domain), []byte{}, 0o644)
+}
+
+func (fs *FSBackend) UnfreezeDomain(ctx context.Context, domain string) error {
+	err := fs.siteRoot.Remove(domainFrozenMarkerName(domain))
+	if errors.Is(err, os.ErrNotExist) {
+		return nil
 	} else {
-		err := fs.siteRoot.Remove(domainFrozenMarkerName(domain))
-		if errors.Is(err, os.ErrNotExist) {
-			return nil
-		} else {
-			return err
-		}
+		return err
 	}
 }
 

src/backend_s3.go

···
 	return err
 }
 
-func (s3 *S3Backend) FreezeDomain(ctx context.Context, domain string, freeze bool) error {
-	if freeze {
-		logc.Printf(ctx, "s3: freeze domain %s\n", domain)
+func (s3 *S3Backend) FreezeDomain(ctx context.Context, domain string) error {
+	logc.Printf(ctx, "s3: freeze domain %s\n", domain)
 
-		_, err := s3.client.PutObject(ctx, s3.bucket, domainFrozenObjectName(domain),
-			&bytes.Reader{}, 0, minio.PutObjectOptions{})
-		return err
+	_, err := s3.client.PutObject(ctx, s3.bucket, domainFrozenObjectName(domain),
+		&bytes.Reader{}, 0, minio.PutObjectOptions{})
+	return err
+
+}
+
+func (s3 *S3Backend) UnfreezeDomain(ctx context.Context, domain string) error {
+	logc.Printf(ctx, "s3: unfreeze domain %s\n", domain)
+
+	err := s3.client.RemoveObject(ctx, s3.bucket, domainFrozenObjectName(domain),
+		minio.RemoveObjectOptions{})
+	if errResp := minio.ToErrorResponse(err); errResp.Code == "NoSuchKey" {
+		return nil
 	} else {
-		logc.Printf(ctx, "s3: thaw domain %s\n", domain)
-
-		err := s3.client.RemoveObject(ctx, s3.bucket, domainFrozenObjectName(domain),
-			minio.RemoveObjectOptions{})
-		if errResp := minio.ToErrorResponse(err); errResp.Code == "NoSuchKey" {
-			return nil
-		} else {
-			return err
-		}
+		return err
 	}
 }
 

src/main.go

···
 			freeze = false
 		}
 
-		if err = backend.FreezeDomain(ctx, domain, freeze); err != nil {
-			logc.Fatalln(ctx, err)
-		}
 		if freeze {
+			if err = backend.FreezeDomain(ctx, domain); err != nil {
+				logc.Fatalln(ctx, err)
+			}
 			logc.Println(ctx, "frozen")
 		} else {
+			if err = backend.UnfreezeDomain(ctx, domain); err != nil {
+				logc.Fatalln(ctx, err)
+			}
 			logc.Println(ctx, "thawed")
 		}
 

src/observe.go

···
 	return
 }
 
-func (backend *observedBackend) FreezeDomain(ctx context.Context, domain string, freeze bool) (err error) {
-	span, ctx := ObserveFunction(ctx, "FreezeDomain", "domain.name", domain, "domain.frozen", freeze)
-	err = backend.inner.FreezeDomain(ctx, domain, freeze)
+func (backend *observedBackend) FreezeDomain(ctx context.Context, domain string) (err error) {
+	span, ctx := ObserveFunction(ctx, "FreezeDomain", "domain.name", domain)
+	err = backend.inner.FreezeDomain(ctx, domain)
+	span.Finish()
+	return
+}
+
+func (backend *observedBackend) UnfreezeDomain(ctx context.Context, domain string) (err error) {
+	span, ctx := ObserveFunction(ctx, "UnfreezeDomain", "domain.name", domain)
+	err = backend.inner.UnfreezeDomain(ctx, domain)
 	span.Finish()
 	return
 }