return nil
			}
			return err
		}
		msg, err := target.toProducerMessage(eventData)
		if err != nil {
			return err
		}
		if err = target.batch.Add(key.Name, msg); err != nil {
			return err
		}
	}
	// commit the batch if the key is the last one present in the store.
	if key.IsLast || target.batch.IsFull() {
		return target.commitBatch()
	}
	return nil
}

		return "s3:ObjectAccessed:Head"
	case ObjectAccessedAttributes:
		return "s3:ObjectAccessed:Attributes"
	case ObjectCreatedAll:
		return "s3:ObjectCreated:*"
	case ObjectCreatedCompleteMultipartUpload:
		return "s3:ObjectCreated:CompleteMultipartUpload"
	case ObjectCreatedCopy:
		return "s3:ObjectCreated:Copy"
	case ObjectCreatedPost:
		return "s3:ObjectCreated:Post"
	case ObjectCreatedPut:
		return "s3:ObjectCreated:Put"

		return "BYTES"
	case []Value:
		return "ARRAY"
	case Missing:
		return "MISSING"
	}
	return "--"
}

// Repr returns a string representation of value.
func (v Value) Repr() string {
	switch x := v.value.(type) {
	case nil:
		return ":NULL"
	case bool, int64, float64:
		return fmt.Sprintf("%v:%s", v.value, v.GetTypeString())
	case time.Time:
		return fmt.Sprintf("%s:TIMESTAMP", x)
	case string:

		err = msgp.WrapError(err, "Handler")
		return
	}
	err = en.WriteUint8(uint8(z.Op))
	if err != nil {
		err = msgp.WrapError(err, "Op")
		return
	}
	err = en.WriteUint8(uint8(z.Flags))
	if err != nil {
		err = msgp.WrapError(err, "Flags")
		return
	}
	err = en.WriteBytes(z.Payload)
	if err != nil {
		err = msgp.WrapError(err, "Payload")
		return
	}
	return
}

			if err != nil {
				err = msgp.WrapError(err, "SecretKey")
				return
			}
		case "SessionToken":
			z.SessionToken, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "SessionToken")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable

	if err != nil {
		return
	}
	err = en.WriteInt64(z.ReplicatedCount)
	if err != nil {
		err = msgp.WrapError(err, "ReplicatedCount")
		return
	}
	// write "Failed"
	err = en.Append(0xa6, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64)
	if err != nil {
		return
	}
	err = z.Failed.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "Failed")
		return
	}
	return
}

	if err != nil {
		return
	}
	err = en.WriteString(z.Endpoint)
	if err != nil {
		err = msgp.WrapError(err, "Endpoint")
		return
	}
	// write "Token"
	err = en.Append(0xa5, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteString(z.Token)
	if err != nil {
		err = msgp.WrapError(err, "Token")
		return
	}
	return
}

	return p.storage.LastConn()
}

func (p *xlStorageDiskIDCheck) IsLocal() bool {
	return p.storage.IsLocal()
}

func (p *xlStorageDiskIDCheck) Endpoint() Endpoint {
	return p.storage.Endpoint()
}

func (p *xlStorageDiskIDCheck) Hostname() string {
	return p.storage.Hostname()
}

func (p *xlStorageDiskIDCheck) Healing() *healingTracker {
	return p.storage.Healing()
}

		return
	}
	// write "pool"
	err = en.Append(0xa4, 0x70, 0x6f, 0x6f, 0x6c)
	if err != nil {
		return
	}
	err = en.WriteInt(z.pool)
	if err != nil {
		err = msgp.WrapError(err, "pool")
		return
	}
	// write "set"
	err = en.Append(0xa3, 0x73, 0x65, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.set)
	if err != nil {
		err = msgp.WrapError(err, "set")
		return
	}
	return
}

		if len(params) >= 1 {
			apiErr.Bucket = params[0]
		}
		return apiErr
	case errVolumeExists.Error():
		apiErr := BucketExists{}
		if len(params) >= 1 {
			apiErr.Bucket = params[0]
		}
		return apiErr
	case errDiskFull.Error():
		return StorageFull{}
	case errTooManyOpenFiles.Error():
		return SlowDown{}
	case errFileAccessDenied.Error():
		apiErr := PrefixAccessDenied{}
		if len(params) >= 1 {
			apiErr.Bucket = params[0]