1 files changed, 151 insertions, 33 deletions

diff --git a/vendor/cloud.google.com/go/storage/bucket.go b/vendor/cloud.google.com/go/storage/bucket.go
index 93473ce..1c23979 100644
--- a/vendor/cloud.google.com/go/storage/bucket.go
+++ b/vendor/cloud.google.com/go/storage/bucket.go
@@ -82,6 +82,12 @@ func (b *BucketHandle) Create(ctx context.Context, projectID string, attrs *Buck
 	}
 	req := b.c.raw.Buckets.Insert(projectID, bkt)
 	setClientHeader(req.Header())
+	if attrs != nil && attrs.PredefinedACL != "" {
+		req.PredefinedAcl(attrs.PredefinedACL)
+	}
+	if attrs != nil && attrs.PredefinedDefaultObjectACL != "" {
+		req.PredefinedDefaultObjectAcl(attrs.PredefinedDefaultObjectACL)
+	}
 	return runWithRetry(ctx, func() error { _, err := req.Context(ctx).Do(); return err })
 }
 
@@ -188,6 +194,12 @@ func (b *BucketHandle) Update(ctx context.Context, uattrs BucketAttrsToUpdate) (
 	if err != nil {
 		return nil, err
 	}
+	if uattrs.PredefinedACL != "" {
+		req.PredefinedAcl(uattrs.PredefinedACL)
+	}
+	if uattrs.PredefinedDefaultObjectACL != "" {
+		req.PredefinedDefaultObjectAcl(uattrs.PredefinedDefaultObjectACL)
+	}
 	// TODO(jba): retry iff metagen is set?
 	rb, err := req.Context(ctx).Do()
 	if err != nil {
@@ -223,6 +235,20 @@ type BucketAttrs struct {
 	// apply to new objects when no object ACL is provided.
 	DefaultObjectACL []ACLRule
 
+	// If not empty, applies a predefined set of access controls. It should be set
+	// only when creating a bucket.
+	// It is always empty for BucketAttrs returned from the service.
+	// See https://cloud.google.com/storage/docs/json_api/v1/buckets/insert
+	// for valid values.
+	PredefinedACL string
+
+	// If not empty, applies a predefined set of default object access controls.
+	// It should be set only when creating a bucket.
+	// It is always empty for BucketAttrs returned from the service.
+	// See https://cloud.google.com/storage/docs/json_api/v1/buckets/insert
+	// for valid values.
+	PredefinedDefaultObjectACL string
+
 	// Location is the location of the bucket. It defaults to "US".
 	Location string
 
@@ -272,6 +298,12 @@ type BucketAttrs struct {
 
 	// The encryption configuration used by default for newly inserted objects.
 	Encryption *BucketEncryption
+
+	// The logging configuration.
+	Logging *BucketLogging
+
+	// The website configuration.
+	Website *BucketWebsite
 }
 
 // Lifecycle is the lifecycle configuration for objects in the bucket.
@@ -389,6 +421,34 @@ type LifecycleCondition struct {
 	NumNewerVersions int64
 }
 
+// BucketLogging holds the bucket's logging configuration, which defines the
+// destination bucket and optional name prefix for the current bucket's
+// logs.
+type BucketLogging struct {
+	// The destination bucket where the current bucket's logs
+	// should be placed.
+	LogBucket string
+
+	// A prefix for log object names.
+	LogObjectPrefix string
+}
+
+// Website holds the bucket's website configuration, controlling how the
+// service behaves when accessing bucket contents as a web site. See
+// https://cloud.google.com/storage/docs/static-website for more information.
+type BucketWebsite struct {
+	// If the requested object path is missing, the service will ensure the path has
+	// a trailing '/', append this suffix, and attempt to retrieve the resulting
+	// object. This allows the creation of index.html objects to represent directory
+	// pages.
+	MainPageSuffix string
+
+	// If the requested object path is missing, and any mainPageSuffix object is
+	// missing, if applicable, the service will return the named object from this
+	// bucket as the content for a 404 Not Found result.
+	NotFoundPage string
+}
+
 func newBucket(b *raw.Bucket) (*BucketAttrs, error) {
 	if b == nil {
 		return nil, nil
@@ -397,52 +457,28 @@ func newBucket(b *raw.Bucket) (*BucketAttrs, error) {
 	if err != nil {
 		return nil, err
 	}
-	bucket := &BucketAttrs{
+	return &BucketAttrs{
 		Name:              b.Name,
 		Location:          b.Location,
 		MetaGeneration:    b.Metageneration,
 		StorageClass:      b.StorageClass,
 		Created:           convertTime(b.TimeCreated),
 		VersioningEnabled: b.Versioning != nil && b.Versioning.Enabled,
+		ACL:               toBucketACLRules(b.Acl),
+		DefaultObjectACL:  toObjectACLRules(b.DefaultObjectAcl),
 		Labels:            b.Labels,
 		RequesterPays:     b.Billing != nil && b.Billing.RequesterPays,
 		Lifecycle:         toLifecycle(b.Lifecycle),
 		RetentionPolicy:   rp,
 		CORS:              toCORS(b.Cors),
 		Encryption:        toBucketEncryption(b.Encryption),
-	}
-	acl := make([]ACLRule, len(b.Acl))
-	for i, rule := range b.Acl {
-		acl[i] = ACLRule{
-			Entity: ACLEntity(rule.Entity),
-			Role:   ACLRole(rule.Role),
-		}
-	}
-	bucket.ACL = acl
-	objACL := make([]ACLRule, len(b.DefaultObjectAcl))
-	for i, rule := range b.DefaultObjectAcl {
-		objACL[i] = ACLRule{
-			Entity: ACLEntity(rule.Entity),
-			Role:   ACLRole(rule.Role),
-		}
-	}
-	bucket.DefaultObjectACL = objACL
-	return bucket, nil
+		Logging:           toBucketLogging(b.Logging),
+		Website:           toBucketWebsite(b.Website),
+	}, nil
 }
 
 // toRawBucket copies the editable attribute from b to the raw library's Bucket type.
 func (b *BucketAttrs) toRawBucket() *raw.Bucket {
-	var acl []*raw.BucketAccessControl
-	if len(b.ACL) > 0 {
-		acl = make([]*raw.BucketAccessControl, len(b.ACL))
-		for i, rule := range b.ACL {
-			acl[i] = &raw.BucketAccessControl{
-				Entity: string(rule.Entity),
-				Role:   string(rule.Role),
-			}
-		}
-	}
-	dACL := toRawObjectACL(b.DefaultObjectACL)
 	// Copy label map.
 	var labels map[string]string
 	if len(b.Labels) > 0 {
@@ -464,10 +500,10 @@ func (b *BucketAttrs) toRawBucket() *raw.Bucket {
 	}
 	return &raw.Bucket{
 		Name:             b.Name,
-		DefaultObjectAcl: dACL,
 		Location:         b.Location,
 		StorageClass:     b.StorageClass,
-		Acl:              acl,
+		Acl:              toRawBucketACL(b.ACL),
+		DefaultObjectAcl: toRawObjectACL(b.DefaultObjectACL),
 		Versioning:       v,
 		Labels:           labels,
 		Billing:          bb,
@@ -475,6 +511,8 @@ func (b *BucketAttrs) toRawBucket() *raw.Bucket {
 		RetentionPolicy:  b.RetentionPolicy.toRawRetentionPolicy(),
 		Cors:             toRawCORS(b.CORS),
 		Encryption:       b.Encryption.toRawBucketEncryption(),
+		Logging:          b.Logging.toRawBucketLogging(),
+		Website:          b.Website.toRawBucketWebsite(),
 	}
 }
 
@@ -536,6 +574,20 @@ type BucketAttrsToUpdate struct {
 	// If set, replaces the lifecycle configuration of the bucket.
 	Lifecycle *Lifecycle
 
+	// If set, replaces the logging configuration of the bucket.
+	Logging *BucketLogging
+
+	// If set, replaces the website configuration of the bucket.
+	Website *BucketWebsite
+
+	// If not empty, applies a predefined set of access controls.
+	// See https://cloud.google.com/storage/docs/json_api/v1/buckets/patch.
+	PredefinedACL string
+
+	// If not empty, applies a predefined set of default object access controls.
+	// See https://cloud.google.com/storage/docs/json_api/v1/buckets/patch.
+	PredefinedDefaultObjectACL string
+
 	setLabels    map[string]string
 	deleteLabels map[string]bool
 }
@@ -595,6 +647,32 @@ func (ua *BucketAttrsToUpdate) toRawBucket() *raw.Bucket {
 	if ua.Lifecycle != nil {
 		rb.Lifecycle = toRawLifecycle(*ua.Lifecycle)
 	}
+	if ua.Logging != nil {
+		if *ua.Logging == (BucketLogging{}) {
+			rb.NullFields = append(rb.NullFields, "Logging")
+			rb.Logging = nil
+		} else {
+			rb.Logging = ua.Logging.toRawBucketLogging()
+		}
+	}
+	if ua.Website != nil {
+		if *ua.Website == (BucketWebsite{}) {
+			rb.NullFields = append(rb.NullFields, "Website")
+			rb.Website = nil
+		} else {
+			rb.Website = ua.Website.toRawBucketWebsite()
+		}
+	}
+	if ua.PredefinedACL != "" {
+		// Clear ACL or the call will fail.
+		rb.Acl = nil
+		rb.ForceSendFields = append(rb.ForceSendFields, "Acl")
+	}
+	if ua.PredefinedDefaultObjectACL != "" {
+		// Clear ACLs or the call will fail.
+		rb.DefaultObjectAcl = nil
+		rb.ForceSendFields = append(rb.ForceSendFields, "DefaultObjectAcl")
+	}
 	if ua.setLabels != nil || ua.deleteLabels != nil {
 		rb.Labels = map[string]string{}
 		for k, v := range ua.setLabels {
@@ -612,7 +690,7 @@ func (ua *BucketAttrsToUpdate) toRawBucket() *raw.Bucket {
 
 // If returns a new BucketHandle that applies a set of preconditions.
 // Preconditions already set on the BucketHandle are ignored.
-// Operations on the new handle will only occur if the preconditions are
+// Operations on the new handle will return an error if the preconditions are not
 // satisfied. The only valid preconditions for buckets are MetagenerationMatch
 // and MetagenerationNotMatch.
 func (b *BucketHandle) If(conds BucketConditions) *BucketHandle {
@@ -836,6 +914,46 @@ func toBucketEncryption(e *raw.BucketEncryption) *BucketEncryption {
 	return &BucketEncryption{DefaultKMSKeyName: e.DefaultKmsKeyName}
 }
 
+func (b *BucketLogging) toRawBucketLogging() *raw.BucketLogging {
+	if b == nil {
+		return nil
+	}
+	return &raw.BucketLogging{
+		LogBucket:       b.LogBucket,
+		LogObjectPrefix: b.LogObjectPrefix,
+	}
+}
+
+func toBucketLogging(b *raw.BucketLogging) *BucketLogging {
+	if b == nil {
+		return nil
+	}
+	return &BucketLogging{
+		LogBucket:       b.LogBucket,
+		LogObjectPrefix: b.LogObjectPrefix,
+	}
+}
+
+func (w *BucketWebsite) toRawBucketWebsite() *raw.BucketWebsite {
+	if w == nil {
+		return nil
+	}
+	return &raw.BucketWebsite{
+		MainPageSuffix: w.MainPageSuffix,
+		NotFoundPage:   w.NotFoundPage,
+	}
+}
+
+func toBucketWebsite(w *raw.BucketWebsite) *BucketWebsite {
+	if w == nil {
+		return nil
+	}
+	return &BucketWebsite{
+		MainPageSuffix: w.MainPageSuffix,
+		NotFoundPage:   w.NotFoundPage,
+	}
+}
+
 // Objects returns an iterator over the objects in the bucket that match the Query q.
 // If q is nil, no filtering is done.
 func (b *BucketHandle) Objects(ctx context.Context, q *Query) *ObjectIterator {