From 381e4d7847ca6d40b7063efd22257fd480c01422 Mon Sep 17 00:00:00 2001 From: Martin Martinez Rivera Date: Thu, 6 Jun 2019 17:56:24 -0700 Subject: [PATCH] More refactoring of backup code. (#3515) --- dgraph/cmd/alpha/admin_backup.go | 45 ++- ee/backup/backup.go | 119 +++--- ee/backup/file_handler.go | 94 ++--- ee/backup/handler.go | 67 ++-- ee/backup/handler_test.go | 2 +- ee/backup/run.go | 10 +- ee/backup/s3_handler.go | 117 +++--- protos/pb.proto | 22 +- protos/pb/pb.pb.go | 602 ++++++++++++++----------------- worker/backup_ee.go | 12 +- 10 files changed, 534 insertions(+), 556 deletions(-) diff --git a/dgraph/cmd/alpha/admin_backup.go b/dgraph/cmd/alpha/admin_backup.go index 3ec175d0c81..355fc71b327 100644 --- a/dgraph/cmd/alpha/admin_backup.go +++ b/dgraph/cmd/alpha/admin_backup.go @@ -21,6 +21,7 @@ package alpha import ( "context" "net/http" + "net/url" "time" "github.com/dgraph-io/dgraph/ee/backup" @@ -89,39 +90,49 @@ func processHttpBackupRequest(ctx context.Context, r *http.Request) error { SecretKey: secretKey, SessionToken: sessionToken, Anonymous: anonymous, - // TODO(martinmr): Check if this field can be removed. - ForceFull: forceFull, } - m := backup.Manifest{Groups: worker.KnownGroups()} - glog.Infof("Created backup request: %s. Groups=%v\n", &req, m.Groups) + // Read the manifests to get the right timestamp from which to start the backup. + uri, err := url.Parse(req.Destination) + if err != nil { + return err + } + handler, err := backup.NewUriHandler(uri) + if err != nil { + return err + } + req.SinceTs, err = handler.GetSinceTs(uri) + if err != nil { + return err + } + if forceFull { + req.SinceTs = 0 + } + + groups := worker.KnownGroups() + glog.Infof("Created backup request: %s. Groups=%v\n", &req, groups) ctx, cancel := context.WithCancel(ctx) defer cancel() - errCh := make(chan error, len(m.Groups)) - for _, gid := range m.Groups { + errCh := make(chan error, len(groups)) + for _, gid := range groups { req := req req.GroupId = gid go func(req *pb.BackupRequest) { - res, err := worker.BackupGroup(ctx, req) + _, err := worker.BackupGroup(ctx, req) errCh <- err - - // Update manifest if appropriate. - m.Lock() - if res.Since > m.Since { - m.Since = res.Since - } - m.Unlock() }(&req) } - for range m.Groups { + for range groups { if err := <-errCh; err != nil { glog.Errorf("Error received during backup: %v", err) return err } } - br := &backup.Request{Backup: &req, Manifest: &m} - return br.Complete(ctx) + m := backup.Manifest{Groups: groups} + m.Since = req.ReadTs + bp := &backup.Processor{Request: &req} + return bp.CompleteBackup(ctx, &m) } diff --git a/ee/backup/backup.go b/ee/backup/backup.go index 873372a2e6a..a27561d3479 100644 --- a/ee/backup/backup.go +++ b/ee/backup/backup.go @@ -16,6 +16,7 @@ import ( "context" "encoding/json" "fmt" + "net/url" "sync" "github.com/dgraph-io/badger" @@ -23,94 +24,106 @@ import ( "github.com/golang/glog" ) -// Request has all the information needed to perform a backup. -type Request struct { - DB *badger.DB // Badger pstore managed by this node. - Backup *pb.BackupRequest - Manifest *Manifest +// Processor handles the different stages of the backup process. +type Processor struct { + // DB is the Badger pstore managed by this node. + DB *badger.DB + // Request stores the backup request containing the parameters for this backup. + Request *pb.BackupRequest +} - // Since indicates the beginning timestamp from which the backup should start. - // For a partial backup, the value is the largest value from the previous manifest - // files. For a full backup, Since is set to zero so that all data is included. - Since uint64 +// Manifest records backup details, these are values used during restore. +// Since is the timestamp from which the next incremental backup should start (it's set +// to the readTs of the current backup). +// Groups are the IDs of the groups involved. +type Manifest struct { + sync.Mutex + Since uint64 `json:"since"` + Groups []uint32 `json:"groups"` } -// Process uses the request values to create a stream writer then hand off the data +// WriteBackup uses the request values to create a stream writer then hand off the data // retrieval to stream.Orchestrate. The writer will create all the fd's needed to // collect the data and later move to the target. // Returns errors on failure, nil on success. -func (r *Request) Process(ctx context.Context) (*pb.BackupResponse, error) { - var res pb.BackupResponse +func (pr *Processor) WriteBackup(ctx context.Context) (*pb.BackupResponse, error) { + var emptyRes pb.BackupResponse if err := ctx.Err(); err != nil { return nil, err } - handler, err := r.newHandler() + uri, err := url.Parse(pr.Request.Destination) if err != nil { - return nil, err + return &emptyRes, err + } + + handler, err := NewUriHandler(uri) + if err != nil { + return &emptyRes, err + } + + if err := handler.CreateBackupFile(uri, pr.Request); err != nil { + return &emptyRes, err } - glog.V(3).Infof("Backup manifest version: %d", r.Since) - stream := r.DB.NewStreamAt(r.Backup.ReadTs) + glog.V(3).Infof("Backup manifest version: %d", pr.Request.SinceTs) + + stream := pr.DB.NewStreamAt(pr.Request.ReadTs) stream.LogPrefix = "Dgraph.Backup" - res.Since, err = stream.Backup(handler, r.Since) + newSince, err := stream.Backup(handler, pr.Request.SinceTs) + if err != nil { glog.Errorf("While taking backup: %v", err) - return nil, err + return &emptyRes, err + } + + if newSince > pr.Request.ReadTs { + glog.Errorf("Max timestamp seen during backup (%d) is greater than readTs (%d)", + newSince, pr.Request.ReadTs) } - glog.V(2).Infof("Backup group %d version: %d", r.Backup.GroupId, res.Since) + + glog.V(2).Infof("Backup group %d version: %d", pr.Request.GroupId, pr.Request.ReadTs) if err = handler.Close(); err != nil { glog.Errorf("While closing handler: %v", err) - return nil, err + return &emptyRes, err } - glog.Infof("Backup complete: group %d at %d", r.Backup.GroupId, r.Backup.ReadTs) - return &res, nil + glog.Infof("Backup complete: group %d at %d", pr.Request.GroupId, pr.Request.ReadTs) + return &emptyRes, nil } -// Manifest records backup details, these are values used during restore. -// Since is the timestamp from which the next incremental backup should start. -// Groups are the IDs of the groups involved. -// ReadTs is the original backup request timestamp. -type Manifest struct { - sync.Mutex - Since uint64 `json:"since"` - ReadTs uint64 `json:"read_ts"` - Groups []uint32 `json:"groups"` -} - -// ManifestStatus combines a manifest along with other information about it -// that should not be inside the Manifest struct since it should not be -// recorded in manifest files. -type ManifestStatus struct { - *Manifest - FileName string -} - -// GoString implements the GoStringer interface for Manifest. -func (m *Manifest) GoString() string { - return fmt.Sprintf(`Manifest{Since: %d, ReadTs: %d, Groups: %v}`, - m.Since, m.ReadTs, m.Groups) -} - -// Complete will finalize a backup by writing the manifest at the backup destination. -func (r *Request) Complete(ctx context.Context) error { +// CompleteBackup will finalize a backup by writing the manifest at the backup destination. +func (pr *Processor) CompleteBackup(ctx context.Context, manifest *Manifest) error { if err := ctx.Err(); err != nil { return err } - handler, err := r.newHandler() + + uri, err := url.Parse(pr.Request.Destination) if err != nil { return err } - if r.Manifest.ReadTs == 0 { - r.Manifest.ReadTs = r.Backup.ReadTs + + handler, err := NewUriHandler(uri) + if err != nil { + return err + } + + if err := handler.CreateManifest(uri, pr.Request); err != nil { + return err } - if err = json.NewEncoder(handler).Encode(r.Manifest); err != nil { + + if err = json.NewEncoder(handler).Encode(manifest); err != nil { return err } + if err = handler.Close(); err != nil { return err } glog.Infof("Backup completed OK.") return nil } + +// GoString implements the GoStringer interface for Manifest. +func (m *Manifest) GoString() string { + return fmt.Sprintf(`Manifest{Since: %d, Groups: %v}`, m.Since, m.Groups) +} diff --git a/ee/backup/file_handler.go b/ee/backup/file_handler.go index 1ddfae2b0f3..4f4eedddd88 100644 --- a/ee/backup/file_handler.go +++ b/ee/backup/file_handler.go @@ -22,6 +22,7 @@ import ( "sort" "strings" + "github.com/dgraph-io/dgraph/protos/pb" "github.com/dgraph-io/dgraph/x" "github.com/golang/glog" @@ -43,60 +44,69 @@ func (h *fileHandler) readManifest(path string, m *Manifest) error { return json.Unmarshal(b, m) } -// Create prepares the a path to save backup files. -// Returns error on failure, nil on success. -func (h *fileHandler) Create(uri *url.URL, req *Request) error { - var dir, path, fileName string +func (h *fileHandler) createFiles(uri *url.URL, req *pb.BackupRequest, fileName string) error { + var dir, path string - if !pathExist(uri.Path) { - return errors.Errorf("The path %q does not exist or it is inaccessible.", uri.Path) + dir = filepath.Join(uri.Path, fmt.Sprintf(backupPathFmt, req.UnixTs)) + err := os.Mkdir(dir, 0700) + if err != nil && !os.IsExist(err) { + return err } - // Find the max Since value from the latest backup. This is done only when starting - // a new backup, not when creating a manifest. - if req.Manifest == nil { - var lastManifest string - suffix := filepath.Join(string(filepath.Separator), backupManifest) - _ = x.WalkPathFunc(uri.Path, func(path string, isdir bool) bool { - if !isdir && strings.HasSuffix(path, suffix) && path > lastManifest { - lastManifest = path - } - return false - }) + path = filepath.Join(dir, fileName) + h.fp, err = os.Create(path) + if err != nil { + return err + } + glog.V(2).Infof("Using file path: %q", path) + return nil +} - if lastManifest != "" { - var m Manifest - if err := h.readManifest(lastManifest, &m); err != nil { - return err - } +// GetSinceTs reads the manifests at the given URL and returns the appropriate +// timestamp from which the current backup should be started. +func (h *fileHandler) GetSinceTs(uri *url.URL) (uint64, error) { + if !pathExist(uri.Path) { + return 0, errors.Errorf("The path %q does not exist or it is inaccessible.", uri.Path) + } - req.Since = m.Since + // Find the max Since value from the latest backup. + var lastManifest string + suffix := filepath.Join(string(filepath.Separator), backupManifest) + _ = x.WalkPathFunc(uri.Path, func(path string, isdir bool) bool { + if !isdir && strings.HasSuffix(path, suffix) && path > lastManifest { + lastManifest = path } - fileName = fmt.Sprintf(backupNameFmt, req.Backup.ReadTs, req.Backup.GroupId) - } else { - fileName = backupManifest + return false + }) + + if lastManifest == "" { + return 0, nil } - // If a full backup is being forced, force Since to zero to stream all - // the contents from the database. - if req.Backup.ForceFull { - req.Since = 0 + var m Manifest + if err := h.readManifest(lastManifest, &m); err != nil { + return 0, err } + return m.Since, nil +} - dir = filepath.Join(uri.Path, fmt.Sprintf(backupPathFmt, req.Backup.UnixTs)) - err := os.Mkdir(dir, 0700) - if err != nil && !os.IsExist(err) { - return err +// CreateBackupFile prepares the a path to save the backup file. +func (h *fileHandler) CreateBackupFile(uri *url.URL, req *pb.BackupRequest) error { + if !pathExist(uri.Path) { + return errors.Errorf("The path %q does not exist or it is inaccessible.", uri.Path) } - path = filepath.Join(dir, fileName) - h.fp, err = os.Create(path) - if err != nil { - return err + fileName := fmt.Sprintf(backupNameFmt, req.ReadTs, req.GroupId) + return h.createFiles(uri, req, fileName) +} + +// CreateManifest completes the backup by writing the manifest to a file. +func (h *fileHandler) CreateManifest(uri *url.URL, req *pb.BackupRequest) error { + if !pathExist(uri.Path) { + return errors.Errorf("The path %q does not exist or it is inaccessible.", uri.Path) } - glog.V(2).Infof("Using file path: %q", path) - return nil + return h.createFiles(uri, req, backupManifest) } // Load uses tries to load any backup files found. @@ -127,7 +137,7 @@ func (h *fileHandler) Load(uri *url.URL, fn loadFn) (uint64, error) { if err := h.readManifest(manifest, &m); err != nil { return 0, errors.Wrapf(err, "While reading %q", manifest) } - if m.ReadTs == 0 || m.Since == 0 || len(m.Groups) == 0 { + if m.Since == 0 || len(m.Groups) == 0 { if glog.V(2) { fmt.Printf("Restore: skip backup: %s: %#v\n", manifest, &m) } @@ -136,7 +146,7 @@ func (h *fileHandler) Load(uri *url.URL, fn loadFn) (uint64, error) { path := filepath.Dir(manifest) for _, groupId := range m.Groups { - file := filepath.Join(path, fmt.Sprintf(backupNameFmt, m.ReadTs, groupId)) + file := filepath.Join(path, fmt.Sprintf(backupNameFmt, m.Since, groupId)) fp, err := os.Open(file) if err != nil { return 0, errors.Wrapf(err, "Failed to open %q", file) diff --git a/ee/backup/handler.go b/ee/backup/handler.go index 242843a3fea..00676bca498 100644 --- a/ee/backup/handler.go +++ b/ee/backup/handler.go @@ -16,6 +16,8 @@ import ( "io" "net/url" + "github.com/dgraph-io/dgraph/protos/pb" + "github.com/pkg/errors" ) @@ -38,45 +40,41 @@ const ( // { // "since": 2280, // "groups": [ 1, 2, 3 ], - // "read_ts": 110001 // } // - // "since" is the maximum data version, obtained from Backup() after it runs. This value - // is used for subsequent incremental backups. + // "since" is the read timestamp used at the backup request. This value is called "since" + // because it used by subsequent incremental backups. // "groups" are the group IDs that participated. - // "read_ts" is the read timestamp used at the backup request. backupManifest = `manifest.json` ) -// handler interface is implemented by URI scheme handlers. +// UriHandler interface is implemented by URI scheme handlers. // When adding new scheme handles, for example 'azure://', an object will implement // this interface to supply Dgraph with a way to create or load backup files into DB. -type handler interface { +// For all methods below, the URL object is parsed as described in `newHandler' and +// the Processor object has the DB, estimated tablets size, and backup parameters. +type UriHandler interface { // Handlers must know how to Write to their URI location. // These function calls are used by both Create and Load. io.WriteCloser - // Create prepares the location for write operations. This function is defined for - // creating new backup files at a location described by the URL. The caller of this - // comes from an HTTP request. - // - // The URL object is parsed as described in `newHandler`. - // The Request object has the DB, estimated tablets size, and backup parameters. - Create(*url.URL, *Request) error + // GetSinceTs reads the manifests at the given URL and returns the appropriate + // timestamp from which the current backup should be started. + GetSinceTs(*url.URL) (uint64, error) + + // CreateBackupFile prepares the object or file to save the backup file. + CreateBackupFile(*url.URL, *pb.BackupRequest) error + + // CreateManifest prepares the manifest for writing. + CreateManifest(*url.URL, *pb.BackupRequest) error // Load will scan location URI for backup files, then load them via loadFn. // Objects implementing this function will be used for retrieving (dowload) backup files // and loading the data into a DB. The restore CLI command uses this call. - // - // The URL object is parsed as described in `newHandler`. - // The loadFn receives the files as they are processed by a handler, to do the actual - // load to DB. Load(*url.URL, loadFn) (uint64, error) // ListManifests will scan the provided URI and return the paths to the manifests stored // in that location. - // - // The URL object is parsed as described in `newHandler`. ListManifests(*url.URL) ([]string, error) // ReadManifest will read the manifest at the given location and load it into the given @@ -84,9 +82,8 @@ type handler interface { ReadManifest(string, *Manifest) error } -// getHandler returns a handler for the URI scheme. -// Returns new handler on success, nil otherwise. -func getHandler(scheme string) handler { +// getHandler returns a UriHandler for the URI scheme. +func getHandler(scheme string) UriHandler { switch scheme { case "file", "": return &fileHandler{} @@ -96,7 +93,7 @@ func getHandler(scheme string) handler { return nil } -// newHandler parses the requested URI, finds a handler and then tries to create a session. +// NewUriHandler parses the requested URI and finds the corresponding UriHandler. // Target URI formats: // [scheme]://[host]/[path]?[args] // [scheme]:///[path]?[args] @@ -119,22 +116,12 @@ func getHandler(scheme string) handler { // minio://localhost:9000/dgraph?secure=true // file:///tmp/dgraph/backups // /tmp/dgraph/backups?compress=gzip -func (r *Request) newHandler() (handler, error) { - var h handler - - uri, err := url.Parse(r.Backup.Destination) - if err != nil { - return nil, err - } - - h = getHandler(uri.Scheme) +func NewUriHandler(uri *url.URL) (UriHandler, error) { + h := getHandler(uri.Scheme) if h == nil { return nil, errors.Errorf("Unable to handle url: %s", uri) } - if err = h.Create(uri, r); err != nil { - return nil, err - } return h, nil } @@ -159,7 +146,7 @@ func Load(l string, fn loadFn) (since uint64, err error) { } // ListManifests scans location l for backup files and returns the list of manifests. -func ListManifests(l string) ([]*ManifestStatus, error) { +func ListManifests(l string) (map[string]*Manifest, error) { uri, err := url.Parse(l) if err != nil { return nil, err @@ -175,17 +162,13 @@ func ListManifests(l string) ([]*ManifestStatus, error) { return nil, err } - var listedManifests []*ManifestStatus + listedManifests := make(map[string]*Manifest) for _, path := range paths { var m Manifest - var ms ManifestStatus - if err := h.ReadManifest(path, &m); err != nil { return nil, errors.Wrapf(err, "While reading %q", path) } - ms.Manifest = &m - ms.FileName = path - listedManifests = append(listedManifests, &ms) + listedManifests[path] = &m } return listedManifests, nil diff --git a/ee/backup/handler_test.go b/ee/backup/handler_test.go index ae8f2a89234..e82c027c537 100644 --- a/ee/backup/handler_test.go +++ b/ee/backup/handler_test.go @@ -21,7 +21,7 @@ import ( func TestGetHandler(t *testing.T) { tests := []struct { in string - out handler + out UriHandler }{ {in: "file", out: &fileHandler{}}, {in: "minio", out: &s3Handler{}}, diff --git a/ee/backup/run.go b/ee/backup/run.go index 6216c31d3d4..13b635cfea6 100644 --- a/ee/backup/run.go +++ b/ee/backup/run.go @@ -252,13 +252,9 @@ func runLsbackupCmd() error { return errors.Wrapf(err, "while listing manifests") } - fmt.Printf("Name\tSince\tReadTs\tGroups\n") - for _, manifest := range manifests { - fmt.Printf("%v\t%v\t%v\t%v\n", - manifest.FileName, - manifest.Since, - manifest.ReadTs, - manifest.Groups) + fmt.Printf("Name\tSince\tGroups\n") + for path, manifest := range manifests { + fmt.Printf("%v\t%v\t%v\n", path, manifest.Since, manifest.Groups) } return nil diff --git a/ee/backup/s3_handler.go b/ee/backup/s3_handler.go index 0265630ab73..5c4dfd3678f 100644 --- a/ee/backup/s3_handler.go +++ b/ee/backup/s3_handler.go @@ -23,6 +23,7 @@ import ( "strings" "time" + "github.com/dgraph-io/dgraph/protos/pb" "github.com/dgraph-io/dgraph/x" "github.com/golang/glog" @@ -50,12 +51,12 @@ type s3Handler struct { pwriter *io.PipeWriter preader *io.PipeReader cerr chan error - req *Request + req *pb.BackupRequest uri *url.URL } func (h *s3Handler) credentialsInRequest() bool { - return h.req.Backup.GetAccessKey() != "" && h.req.Backup.GetSecretKey() != "" + return h.req.GetAccessKey() != "" && h.req.GetSecretKey() != "" } // setup creates a new session, checks valid bucket at uri.Path, and configures a minio client. @@ -69,7 +70,7 @@ func (h *s3Handler) setup(uri *url.URL) (*minio.Client, error) { glog.V(2).Infof("Backup using host: %s, path: %s", uri.Host, uri.Path) var creds credentials.Value - if h.req.Backup.GetAnonymous() { + if h.req.GetAnonymous() { // No need to setup credentials. } else if !h.credentialsInRequest() { var provider credentials.Provider @@ -100,9 +101,9 @@ func (h *s3Handler) setup(uri *url.URL) (*minio.Client, error) { // with no credentials will be made. creds, _ = provider.Retrieve() // error is always nil } else { - creds.AccessKeyID = h.req.Backup.GetAccessKey() - creds.SecretAccessKey = h.req.Backup.GetSecretKey() - creds.SessionToken = h.req.Backup.GetSessionToken() + creds.AccessKeyID = h.req.GetAccessKey() + creds.SecretAccessKey = h.req.GetSecretKey() + creds.SessionToken = h.req.GetSessionToken() } secure := uri.Query().Get("secure") != "false" // secure by default @@ -145,15 +146,58 @@ func (h *s3Handler) setup(uri *url.URL) (*minio.Client, error) { return mc, err } -// Create creates a new session and sends our data stream to an object. +func (h *s3Handler) createObject(uri *url.URL, req *pb.BackupRequest, mc *minio.Client, + objectName string) { + + // The backup object is: folder1...folderN/dgraph.20181106.0113/r110001-g1.backup + object := filepath.Join(h.objectPrefix, fmt.Sprintf(backupPathFmt, req.UnixTs), + objectName) + glog.V(2).Infof("Sending data to %s blob %q ...", uri.Scheme, object) + + h.cerr = make(chan error, 1) + h.preader, h.pwriter = io.Pipe() + go func() { + h.cerr <- h.upload(mc, object) + }() +} + +// GetSinceTs reads the manifests at the given URL and returns the appropriate +// timestamp from which the current backup should be started. +func (h *s3Handler) GetSinceTs(uri *url.URL) (uint64, error) { + mc, err := h.setup(uri) + if err != nil { + return 0, err + } + + // Find the max Since value from the latest backup. + var lastManifest string + done := make(chan struct{}) + defer close(done) + suffix := "/" + backupManifest + for object := range mc.ListObjects(h.bucketName, h.objectPrefix, true, done) { + if strings.HasSuffix(object.Key, suffix) && object.Key > lastManifest { + lastManifest = object.Key + } + } + + if lastManifest == "" { + return 0, nil + } + + var m Manifest + if err := h.readManifest(mc, lastManifest, &m); err != nil { + return 0, err + } + return m.Since, nil +} + +// CreateBackupFile creates a new session and prepares the data stream for the backup. // URI formats: // minio:///bucket/folder1.../folderN?secure=true|false // minio:///bucket/folder1.../folderN?secure=true|false // s3:///bucket/folder1.../folderN?secure=true|false // s3:///bucket/folder1.../folderN?secure=true|false (use default S3 endpoint) -func (h *s3Handler) Create(uri *url.URL, req *Request) error { - var objectName string - +func (h *s3Handler) CreateBackupFile(uri *url.URL, req *pb.BackupRequest) error { glog.V(2).Infof("S3Handler got uri: %+v. Host: %s. Path: %s\n", uri, uri.Host, uri.Path) h.req = req @@ -162,47 +206,22 @@ func (h *s3Handler) Create(uri *url.URL, req *Request) error { return err } - if req.Manifest == nil { - var lastManifest string - done := make(chan struct{}) - defer close(done) - suffix := "/" + backupManifest - for object := range mc.ListObjects(h.bucketName, h.objectPrefix, true, done) { - if strings.HasSuffix(object.Key, suffix) && object.Key > lastManifest { - lastManifest = object.Key - } - } - if lastManifest != "" { - var m Manifest - if err := h.readManifest(mc, lastManifest, &m); err != nil { - return err - } + objectName := fmt.Sprintf(backupNameFmt, req.ReadTs, req.GroupId) + h.createObject(uri, req, mc, objectName) + return nil +} - req.Since = m.Since - } - objectName = fmt.Sprintf(backupNameFmt, req.Backup.ReadTs, req.Backup.GroupId) - } else { - objectName = backupManifest - } +// CreateManifest finishes a backup by creating an object to store the manifest. +func (h *s3Handler) CreateManifest(uri *url.URL, req *pb.BackupRequest) error { + glog.V(2).Infof("S3Handler got uri: %+v. Host: %s. Path: %s\n", uri, uri.Host, uri.Path) - // If a full backup is being forced, force the value of Since to zero to stream all - // the contents from the database. - if req.Backup.ForceFull { - req.Since = 0 + h.req = req + mc, err := h.setup(uri) + if err != nil { + return err } - // The backup object is: folder1...folderN/dgraph.20181106.0113/r110001-g1.backup - object := filepath.Join(h.objectPrefix, - fmt.Sprintf(backupPathFmt, req.Backup.UnixTs), - objectName) - glog.V(2).Infof("Sending data to %s blob %q ...", uri.Scheme, object) - - h.cerr = make(chan error, 1) - h.preader, h.pwriter = io.Pipe() - go func() { - h.cerr <- h.upload(mc, object) - }() - + h.createObject(uri, req, mc, backupManifest) return nil } @@ -256,7 +275,7 @@ func (h *s3Handler) Load(uri *url.URL, fn loadFn) (uint64, error) { if err := h.readManifest(mc, manifest, &m); err != nil { return 0, errors.Wrapf(err, "While reading %q", manifest) } - if m.ReadTs == 0 || m.Since == 0 || len(m.Groups) == 0 { + if m.Since == 0 || len(m.Groups) == 0 { if glog.V(2) { fmt.Printf("Restore: skip backup: %s: %#v\n", manifest, &m) } @@ -265,7 +284,7 @@ func (h *s3Handler) Load(uri *url.URL, fn loadFn) (uint64, error) { path := filepath.Dir(manifest) for _, groupId := range m.Groups { - object := filepath.Join(path, fmt.Sprintf(backupNameFmt, m.ReadTs, groupId)) + object := filepath.Join(path, fmt.Sprintf(backupNameFmt, m.Since, groupId)) reader, err := mc.GetObject(h.bucketName, object, minio.GetObjectOptions{}) if err != nil { return 0, errors.Wrapf(err, "Failed to get %q", object) diff --git a/protos/pb.proto b/protos/pb.proto index 90193cb319a..8a70d695498 100644 --- a/protos/pb.proto +++ b/protos/pb.proto @@ -475,25 +475,21 @@ message Status { message BackupRequest { uint64 read_ts = 1; - uint32 group_id = 2; - string unix_ts = 3; - string destination = 4; - string access_key = 5; - string secret_key = 6; - string session_token = 7; + uint64 since_ts = 2; + uint32 group_id = 3; + string unix_ts = 4; + string destination = 5; + string access_key = 6; + string secret_key = 7; + string session_token = 8; // True if no credentials should be used to access the S3 or minio bucket. // For example, when using a bucket with a public policy. - bool anonymous = 8; - - // If true, previous backups will be ignored and a new full backup will be - // created. If false, the backup will be full or incremental depending on - // the existing backups. - bool force_full = 9; + bool anonymous = 9; } +// Dummy empty response message BackupResponse { - uint64 since = 1; } message ExportRequest { diff --git a/protos/pb/pb.pb.go b/protos/pb/pb.pb.go index 9206f2beaea..991eec1ee74 100644 --- a/protos/pb/pb.pb.go +++ b/protos/pb/pb.pb.go @@ -3523,19 +3523,16 @@ func (m *Status) GetMsg() string { type BackupRequest struct { ReadTs uint64 `protobuf:"varint,1,opt,name=read_ts,json=readTs,proto3" json:"read_ts,omitempty"` - GroupId uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"` - UnixTs string `protobuf:"bytes,3,opt,name=unix_ts,json=unixTs,proto3" json:"unix_ts,omitempty"` - Destination string `protobuf:"bytes,4,opt,name=destination,proto3" json:"destination,omitempty"` - AccessKey string `protobuf:"bytes,5,opt,name=access_key,json=accessKey,proto3" json:"access_key,omitempty"` - SecretKey string `protobuf:"bytes,6,opt,name=secret_key,json=secretKey,proto3" json:"secret_key,omitempty"` - SessionToken string `protobuf:"bytes,7,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"` + SinceTs uint64 `protobuf:"varint,2,opt,name=since_ts,json=sinceTs,proto3" json:"since_ts,omitempty"` + GroupId uint32 `protobuf:"varint,3,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"` + UnixTs string `protobuf:"bytes,4,opt,name=unix_ts,json=unixTs,proto3" json:"unix_ts,omitempty"` + Destination string `protobuf:"bytes,5,opt,name=destination,proto3" json:"destination,omitempty"` + AccessKey string `protobuf:"bytes,6,opt,name=access_key,json=accessKey,proto3" json:"access_key,omitempty"` + SecretKey string `protobuf:"bytes,7,opt,name=secret_key,json=secretKey,proto3" json:"secret_key,omitempty"` + SessionToken string `protobuf:"bytes,8,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"` // True if no credentials should be used to access the S3 or minio bucket. // For example, when using a bucket with a public policy. - Anonymous bool `protobuf:"varint,8,opt,name=anonymous,proto3" json:"anonymous,omitempty"` - // If true, previous backups will be ignored and a new full backup will be - // created. If false, the backup will be full or incremental depending on - // the existing backups. - ForceFull bool `protobuf:"varint,9,opt,name=force_full,json=forceFull,proto3" json:"force_full,omitempty"` + Anonymous bool `protobuf:"varint,9,opt,name=anonymous,proto3" json:"anonymous,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -3581,6 +3578,13 @@ func (m *BackupRequest) GetReadTs() uint64 { return 0 } +func (m *BackupRequest) GetSinceTs() uint64 { + if m != nil { + return m.SinceTs + } + return 0 +} + func (m *BackupRequest) GetGroupId() uint32 { if m != nil { return m.GroupId @@ -3630,15 +3634,8 @@ func (m *BackupRequest) GetAnonymous() bool { return false } -func (m *BackupRequest) GetForceFull() bool { - if m != nil { - return m.ForceFull - } - return false -} - +// Dummy empty response type BackupResponse struct { - Since uint64 `protobuf:"varint,1,opt,name=since,proto3" json:"since,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -3677,13 +3674,6 @@ func (m *BackupResponse) XXX_DiscardUnknown() { var xxx_messageInfo_BackupResponse proto.InternalMessageInfo -func (m *BackupResponse) GetSince() uint64 { - if m != nil { - return m.Since - } - return 0 -} - type ExportRequest struct { GroupId uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"` ReadTs uint64 `protobuf:"varint,2,opt,name=read_ts,json=readTs,proto3" json:"read_ts,omitempty"` @@ -3822,230 +3812,229 @@ func init() { func init() { proto.RegisterFile("pb.proto", fileDescriptor_f80abaa17e25ccc8) } var fileDescriptor_f80abaa17e25ccc8 = []byte{ - // 3564 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xcd, 0x6f, 0xe3, 0x48, - 0x76, 0x6f, 0x52, 0x12, 0x45, 0x3e, 0xc9, 0x6e, 0x6d, 0x4d, 0x6f, 0x8f, 0xc6, 0xbb, 0xdb, 0xed, - 0xe1, 0x7c, 0xb4, 0xa7, 0x67, 0xc7, 0xdd, 0xe3, 0xd9, 0x24, 0x3b, 0x1b, 0xe4, 0xe0, 0xb6, 0xd5, - 0x1d, 0xcf, 0xf8, 0x2b, 0x25, 0xb9, 0x37, 0x3b, 0x87, 0x08, 0x65, 0xb2, 0x2c, 0x73, 0x4d, 0x91, - 0x0c, 0x8b, 0x72, 0xe4, 0xb9, 0xe5, 0x90, 0x00, 0x01, 0x72, 0xcb, 0x65, 0x0f, 0xc1, 0x1e, 0x72, - 0x0c, 0x10, 0xe4, 0xba, 0xe7, 0x00, 0x01, 0x72, 0x0c, 0xf2, 0x17, 0x04, 0x93, 0x1c, 0x73, 0x0e, - 0x90, 0x5b, 0xf0, 0x5e, 0x15, 0x45, 0x4a, 0xed, 0xee, 0xd9, 0x09, 0x90, 0x93, 0xeb, 0x7d, 0x14, - 0xab, 0xea, 0xf7, 0x3e, 0xea, 0xd5, 0x93, 0xc1, 0xcd, 0xce, 0xb7, 0xb3, 0x3c, 0x2d, 0x52, 0x66, - 0x67, 0xe7, 0x1b, 0x9e, 0xc8, 0x22, 0x4d, 0x6e, 0x3c, 0x9a, 0x44, 0xc5, 0xe5, 0xec, 0x7c, 0x3b, - 0x48, 0xa7, 0x4f, 0xc2, 0x49, 0x2e, 0xb2, 0xcb, 0x4f, 0xa2, 0xf4, 0xc9, 0xb9, 0x08, 0x27, 0x32, - 0x7f, 0x92, 0x9d, 0x3f, 0x29, 0xe7, 0xf9, 0x1b, 0xd0, 0x3c, 0x8c, 0x54, 0xc1, 0x18, 0x34, 0x67, - 0x51, 0xa8, 0xfa, 0xd6, 0x66, 0x63, 0xcb, 0xe1, 0x34, 0xf6, 0x8f, 0xc0, 0x1b, 0x09, 0x75, 0xf5, - 0x52, 0xc4, 0x33, 0xc9, 0x7a, 0xd0, 0xb8, 0x16, 0x71, 0xdf, 0xda, 0xb4, 0xb6, 0xba, 0x1c, 0x87, - 0x6c, 0x1b, 0xdc, 0x6b, 0x11, 0x8f, 0x8b, 0x9b, 0x4c, 0xf6, 0xed, 0x4d, 0x6b, 0x6b, 0x7d, 0xe7, - 0xad, 0xed, 0xec, 0x7c, 0xfb, 0x34, 0x55, 0x45, 0x94, 0x4c, 0xb6, 0x5f, 0x8a, 0x78, 0x74, 0x93, - 0x49, 0xde, 0xbe, 0xd6, 0x03, 0xff, 0x04, 0x3a, 0xc3, 0x3c, 0x78, 0x3e, 0x4b, 0x82, 0x22, 0x4a, - 0x13, 0x5c, 0x31, 0x11, 0x53, 0x49, 0x5f, 0xf4, 0x38, 0x8d, 0x91, 0x27, 0xf2, 0x89, 0xea, 0x37, - 0x36, 0x1b, 0xc8, 0xc3, 0x31, 0xeb, 0x43, 0x3b, 0x52, 0x7b, 0xe9, 0x2c, 0x29, 0xfa, 0xcd, 0x4d, - 0x6b, 0xcb, 0xe5, 0x25, 0xe9, 0xff, 0x55, 0x03, 0x5a, 0x7f, 0x34, 0x93, 0xf9, 0x0d, 0xcd, 0x2b, - 0x8a, 0xbc, 0xfc, 0x16, 0x8e, 0xd9, 0x3d, 0x68, 0xc5, 0x22, 0x99, 0xa8, 0xbe, 0x4d, 0x1f, 0xd3, - 0x04, 0xfb, 0x01, 0x78, 0xe2, 0xa2, 0x90, 0xf9, 0x78, 0x16, 0x85, 0xfd, 0xc6, 0xa6, 0xb5, 0xe5, - 0x70, 0x97, 0x18, 0x67, 0x51, 0xc8, 0xde, 0x01, 0x37, 0x4c, 0xc7, 0x41, 0x7d, 0xad, 0x30, 0xa5, - 0xb5, 0xd8, 0x7b, 0xe0, 0xce, 0xa2, 0x70, 0x1c, 0x47, 0xaa, 0xe8, 0xb7, 0x36, 0xad, 0xad, 0xce, - 0x8e, 0x8b, 0x87, 0x45, 0xec, 0x78, 0x7b, 0x16, 0x85, 0x04, 0xe2, 0x63, 0x70, 0x55, 0x1e, 0x8c, - 0x2f, 0x66, 0x49, 0xd0, 0x77, 0x48, 0xe9, 0x2e, 0x2a, 0xd5, 0x4e, 0xcd, 0xdb, 0x4a, 0x13, 0x78, - 0xac, 0x5c, 0x5e, 0xcb, 0x5c, 0xc9, 0x7e, 0x5b, 0x2f, 0x65, 0x48, 0xf6, 0x14, 0x3a, 0x17, 0x22, - 0x90, 0xc5, 0x38, 0x13, 0xb9, 0x98, 0xf6, 0xdd, 0xea, 0x43, 0xcf, 0x91, 0x7d, 0x8a, 0x5c, 0xc5, - 0xe1, 0x62, 0x41, 0xb0, 0xcf, 0x60, 0x8d, 0x28, 0x35, 0xbe, 0x88, 0xe2, 0x42, 0xe6, 0x7d, 0x8f, - 0xe6, 0xac, 0xd3, 0x1c, 0xe2, 0x8c, 0x72, 0x29, 0x79, 0x57, 0x2b, 0x69, 0x0e, 0xfb, 0x11, 0x80, - 0x9c, 0x67, 0x22, 0x09, 0xc7, 0x22, 0x8e, 0xfb, 0x40, 0x7b, 0xf0, 0x34, 0x67, 0x37, 0x8e, 0xd9, - 0xdb, 0xb8, 0x3f, 0x11, 0x8e, 0x0b, 0xd5, 0x5f, 0xdb, 0xb4, 0xb6, 0x9a, 0xdc, 0x41, 0x72, 0xa4, - 0x10, 0xd7, 0x40, 0x04, 0x97, 0xb2, 0xbf, 0xbe, 0x69, 0x6d, 0xb5, 0xb8, 0x26, 0xfc, 0x1d, 0xf0, - 0xc8, 0x4f, 0x08, 0x87, 0x0f, 0xc0, 0xb9, 0x46, 0x42, 0xbb, 0x53, 0x67, 0x67, 0x0d, 0x37, 0xb2, - 0x70, 0x25, 0x6e, 0x84, 0xfe, 0x03, 0x70, 0x0f, 0x45, 0x32, 0x29, 0xfd, 0x0f, 0x0d, 0x44, 0x13, - 0x3c, 0x4e, 0x63, 0xff, 0x57, 0x36, 0x38, 0x5c, 0xaa, 0x59, 0x5c, 0xb0, 0x47, 0x00, 0x08, 0xff, - 0x54, 0x14, 0x79, 0x34, 0x37, 0x5f, 0xad, 0x0c, 0xe0, 0xcd, 0xa2, 0xf0, 0x88, 0x44, 0xec, 0x29, - 0x74, 0xe9, 0xeb, 0xa5, 0xaa, 0x5d, 0x6d, 0x60, 0xb1, 0x3f, 0xde, 0x21, 0x15, 0x33, 0xe3, 0x3e, - 0x38, 0x64, 0x71, 0xed, 0x75, 0x6b, 0xdc, 0x50, 0xec, 0x03, 0x58, 0x8f, 0x92, 0x02, 0x2d, 0x12, - 0x14, 0xe3, 0x50, 0xaa, 0xd2, 0x25, 0xd6, 0x16, 0xdc, 0x7d, 0xa9, 0x0a, 0xf6, 0x29, 0x68, 0x58, - 0xcb, 0x05, 0x5b, 0xb4, 0xe0, 0xfa, 0xc2, 0x5c, 0x4a, 0xaf, 0x48, 0x3a, 0x66, 0xc5, 0x4f, 0xa0, - 0x83, 0xe7, 0x2b, 0x67, 0x38, 0x34, 0xa3, 0x4b, 0xa7, 0x31, 0x70, 0x70, 0x40, 0x05, 0xa3, 0x8e, - 0xd0, 0xa0, 0xdb, 0x69, 0x37, 0xa1, 0xb1, 0x3f, 0x80, 0xd6, 0x49, 0x1e, 0xca, 0xfc, 0x56, 0xcf, - 0x67, 0xd0, 0x0c, 0xa5, 0x0a, 0x28, 0x28, 0x5d, 0x4e, 0xe3, 0x2a, 0x1a, 0x1a, 0xb5, 0x68, 0xf0, - 0x7f, 0x6d, 0x41, 0x67, 0x98, 0xe6, 0xc5, 0x91, 0x54, 0x4a, 0x4c, 0x24, 0x7b, 0x08, 0xad, 0x14, - 0x3f, 0x6b, 0x10, 0xf6, 0x70, 0x4f, 0xb4, 0x0e, 0xd7, 0xfc, 0x15, 0x3b, 0xd8, 0xaf, 0xb7, 0x03, - 0x7a, 0x09, 0xc5, 0x51, 0xc3, 0x78, 0x09, 0x45, 0xd1, 0x7d, 0x70, 0xd2, 0x8b, 0x0b, 0x25, 0x35, - 0x96, 0x2d, 0x6e, 0xa8, 0xd7, 0x3a, 0x9b, 0xff, 0x3b, 0x00, 0xb8, 0xbf, 0xef, 0xe8, 0x05, 0xfe, - 0x25, 0x74, 0xb8, 0xb8, 0x28, 0xf6, 0xd2, 0xa4, 0x90, 0xf3, 0x82, 0xad, 0x83, 0x1d, 0x85, 0x04, - 0x91, 0xc3, 0xed, 0x28, 0xc4, 0xcd, 0x4d, 0xf2, 0x74, 0x96, 0x11, 0x42, 0x6b, 0x5c, 0x13, 0x04, - 0x65, 0x18, 0xe6, 0xb4, 0x63, 0x84, 0x32, 0x0c, 0x73, 0xf6, 0x10, 0x3a, 0x2a, 0x11, 0x99, 0xba, - 0x4c, 0x0b, 0xdc, 0x5c, 0x93, 0x36, 0x07, 0x25, 0x6b, 0xa4, 0xfc, 0x7f, 0xb6, 0xc0, 0x39, 0x92, - 0xd3, 0x73, 0x99, 0xbf, 0xb2, 0xca, 0x3b, 0xe0, 0xd2, 0x87, 0xc7, 0x51, 0x68, 0x16, 0x6a, 0x13, - 0x7d, 0x10, 0xde, 0xba, 0xd4, 0x7d, 0x70, 0x62, 0x29, 0x10, 0x7c, 0xed, 0x67, 0x86, 0x42, 0x6c, - 0xc4, 0x74, 0x1c, 0x4a, 0x11, 0x52, 0xe2, 0x71, 0xb9, 0x23, 0xa6, 0xfb, 0x52, 0x84, 0xb8, 0xb7, - 0x58, 0xa8, 0x62, 0x3c, 0xcb, 0x42, 0x51, 0x48, 0x4a, 0x38, 0x4d, 0x74, 0x1c, 0x55, 0x9c, 0x11, - 0x87, 0x3d, 0x86, 0xef, 0x05, 0xf1, 0x4c, 0x61, 0xb6, 0x8b, 0x92, 0x8b, 0x74, 0x9c, 0x26, 0xf1, - 0x0d, 0xe1, 0xeb, 0xf2, 0xbb, 0x46, 0x70, 0x90, 0x5c, 0xa4, 0x27, 0x49, 0x7c, 0xe3, 0xff, 0xc6, - 0x86, 0xd6, 0x0b, 0x82, 0xe1, 0x29, 0xb4, 0xa7, 0x74, 0xa0, 0x32, 0x7a, 0xef, 0x23, 0xc2, 0x24, - 0xdb, 0xd6, 0x27, 0x55, 0x83, 0xa4, 0xc8, 0x6f, 0x78, 0xa9, 0x86, 0x33, 0x0a, 0x71, 0x1e, 0xcb, - 0x42, 0x19, 0x8f, 0xa8, 0xcd, 0x18, 0x69, 0x81, 0x99, 0x61, 0xd4, 0x56, 0x61, 0x6d, 0xac, 0xc2, - 0xca, 0x36, 0xc0, 0x0d, 0x2e, 0x65, 0x70, 0xa5, 0x66, 0x53, 0x03, 0xfa, 0x82, 0xde, 0x78, 0x0e, - 0xdd, 0xfa, 0x3e, 0xf0, 0x66, 0xba, 0x92, 0x37, 0x04, 0x7c, 0x93, 0xe3, 0x90, 0x6d, 0x42, 0x8b, - 0x22, 0x9c, 0x60, 0xef, 0xec, 0x00, 0x6e, 0x47, 0x4f, 0xe1, 0x5a, 0xf0, 0x33, 0xfb, 0xa7, 0x16, - 0x7e, 0xa7, 0xbe, 0xbb, 0xfa, 0x77, 0xbc, 0xd7, 0x7f, 0x47, 0x4f, 0xa9, 0x7d, 0xc7, 0xff, 0x1f, - 0x1b, 0xba, 0x5f, 0xc9, 0x3c, 0x3d, 0xcd, 0xd3, 0x2c, 0x55, 0x22, 0x66, 0xbb, 0xcb, 0xa7, 0xd3, - 0x28, 0x6e, 0xe2, 0xe4, 0xba, 0xda, 0xf6, 0x70, 0x71, 0x5c, 0x8d, 0x4e, 0xfd, 0xfc, 0x3e, 0x38, - 0x1a, 0xdd, 0x5b, 0x8e, 0x60, 0x24, 0xa8, 0xa3, 0xf1, 0x24, 0xfc, 0x96, 0xb7, 0x67, 0x24, 0xec, - 0x01, 0xc0, 0x54, 0xcc, 0x0f, 0xa5, 0x50, 0xf2, 0x20, 0x2c, 0xdd, 0xb7, 0xe2, 0x20, 0xce, 0x53, - 0x31, 0x1f, 0xcd, 0x93, 0x91, 0x22, 0xef, 0x6a, 0xf2, 0x05, 0xcd, 0x7e, 0x08, 0xde, 0x54, 0xcc, - 0x31, 0x8e, 0x0e, 0x42, 0xe3, 0x5d, 0x15, 0x83, 0xbd, 0x0b, 0x8d, 0x62, 0x9e, 0x50, 0x52, 0xc2, - 0xdb, 0x09, 0x4b, 0x8f, 0xd1, 0x3c, 0x31, 0x11, 0xc7, 0x51, 0x56, 0x02, 0xea, 0x56, 0x80, 0xf6, - 0xa0, 0x11, 0x44, 0x21, 0x5d, 0x4f, 0x1e, 0xc7, 0xe1, 0xc6, 0x1f, 0xc0, 0xdd, 0x15, 0x1c, 0xea, - 0x76, 0x58, 0xd3, 0xd3, 0xee, 0xd5, 0xed, 0xd0, 0xac, 0x63, 0xff, 0x9b, 0x06, 0xdc, 0x35, 0xce, - 0x70, 0x19, 0x65, 0xc3, 0x02, 0xdd, 0xbe, 0x0f, 0x6d, 0xca, 0x36, 0x32, 0x37, 0x3e, 0x51, 0x92, - 0xec, 0xf7, 0xc0, 0xa1, 0x08, 0x2c, 0xfd, 0xf4, 0x61, 0x85, 0xea, 0x62, 0xba, 0xf6, 0x5b, 0x63, - 0x12, 0xa3, 0xce, 0x7e, 0x02, 0xad, 0xaf, 0x65, 0x9e, 0xea, 0xec, 0xd9, 0xd9, 0x79, 0x70, 0xdb, - 0x3c, 0xb4, 0xad, 0x99, 0xa6, 0x95, 0xff, 0x1f, 0xc1, 0x7f, 0x1f, 0xf3, 0xe5, 0x34, 0xbd, 0x96, - 0x61, 0xbf, 0x4d, 0x3b, 0xaa, 0xfb, 0x47, 0x29, 0x2a, 0xd1, 0x76, 0x2b, 0xb4, 0xf7, 0xa1, 0x53, - 0x3b, 0xde, 0x2d, 0x48, 0x3f, 0x5c, 0xf6, 0x78, 0x6f, 0x11, 0xc8, 0xf5, 0xc0, 0xd9, 0x07, 0xa8, - 0x0e, 0xfb, 0x7f, 0x0d, 0x3f, 0xff, 0xcf, 0x2d, 0xb8, 0xbb, 0x97, 0x26, 0x89, 0xa4, 0xc2, 0x48, - 0x9b, 0xae, 0x72, 0x7b, 0xeb, 0xb5, 0x6e, 0xff, 0x11, 0xb4, 0x14, 0x2a, 0x9b, 0xaf, 0xbf, 0x75, - 0x8b, 0x2d, 0xb8, 0xd6, 0xc0, 0x34, 0x33, 0x15, 0xf3, 0x71, 0x26, 0x93, 0x30, 0x4a, 0x26, 0x65, - 0x9a, 0x99, 0x8a, 0xf9, 0xa9, 0xe6, 0xf8, 0x7f, 0x67, 0x81, 0xa3, 0x23, 0x66, 0x29, 0x5b, 0x5b, - 0xcb, 0xd9, 0xfa, 0x87, 0xe0, 0x65, 0xb9, 0x0c, 0xa3, 0xa0, 0x5c, 0xd5, 0xe3, 0x15, 0x03, 0x9d, - 0xf3, 0x22, 0xcd, 0x03, 0x49, 0x9f, 0x77, 0xb9, 0x26, 0x90, 0xab, 0x32, 0x11, 0xe8, 0xe2, 0xae, - 0xc1, 0x35, 0x81, 0x39, 0x5e, 0x1b, 0x87, 0x8c, 0xe2, 0x72, 0x43, 0x61, 0x55, 0x4a, 0xf7, 0x1f, - 0x65, 0x68, 0x8f, 0x44, 0x2e, 0x32, 0x28, 0x35, 0xff, 0xbd, 0x0d, 0xdd, 0xfd, 0x28, 0x97, 0x41, - 0x21, 0xc3, 0x41, 0x38, 0xa1, 0xaf, 0xc8, 0xa4, 0x88, 0x8a, 0x1b, 0x73, 0xd9, 0x18, 0x6a, 0x51, - 0x0b, 0xd8, 0xcb, 0x55, 0xb0, 0xb6, 0x45, 0x83, 0x0a, 0x77, 0x4d, 0xb0, 0x1d, 0x00, 0x5d, 0x25, - 0x51, 0xf1, 0xde, 0x7c, 0x7d, 0xf1, 0xee, 0x91, 0x1a, 0x0e, 0x11, 0x20, 0x3d, 0x27, 0xd2, 0x17, - 0x91, 0x43, 0x95, 0xfd, 0x0c, 0x1d, 0x99, 0x8a, 0x8b, 0x73, 0x19, 0x93, 0xa3, 0x52, 0x71, 0x71, - 0x2e, 0xe3, 0x45, 0x49, 0xd7, 0xd6, 0xdb, 0xc1, 0x31, 0x7b, 0x0f, 0xec, 0x34, 0xa3, 0xc3, 0x9b, - 0x05, 0xeb, 0x07, 0xdb, 0x3e, 0xc9, 0xb8, 0x9d, 0x66, 0xe8, 0x05, 0xba, 0x52, 0xed, 0x7b, 0xc6, - 0xb9, 0x31, 0xbb, 0x50, 0x35, 0xc5, 0x8d, 0xc4, 0xbf, 0x0f, 0xf6, 0x49, 0xc6, 0xda, 0xd0, 0x18, - 0x0e, 0x46, 0xbd, 0x3b, 0x38, 0xd8, 0x1f, 0x1c, 0xf6, 0x2c, 0xff, 0xbf, 0x6c, 0xf0, 0x8e, 0x66, - 0x85, 0x40, 0x9f, 0x52, 0x6f, 0x32, 0xea, 0x3b, 0xe0, 0xaa, 0x42, 0xe4, 0x94, 0xa1, 0x75, 0x5a, - 0x69, 0x13, 0x3d, 0x52, 0xec, 0x43, 0x68, 0xc9, 0x70, 0x22, 0xcb, 0x68, 0xef, 0xad, 0xee, 0x93, - 0x6b, 0x31, 0xdb, 0x02, 0x47, 0x05, 0x97, 0x72, 0x2a, 0xfa, 0xcd, 0x4a, 0x71, 0x48, 0x1c, 0x7d, - 0x03, 0x73, 0x23, 0x67, 0x3b, 0xf0, 0xfd, 0x68, 0x92, 0xa4, 0xb9, 0x1c, 0x47, 0x49, 0x28, 0xe7, - 0xe3, 0x20, 0x4d, 0x2e, 0xe2, 0x28, 0x28, 0xcc, 0x8d, 0xfe, 0x96, 0x16, 0x1e, 0xa0, 0x6c, 0xcf, - 0x88, 0xd8, 0xfb, 0xd0, 0x42, 0xeb, 0x28, 0x53, 0x1f, 0x52, 0x45, 0x89, 0x86, 0x30, 0x9f, 0xd6, - 0x42, 0xf6, 0x09, 0xb4, 0xc3, 0x3c, 0xcd, 0xc6, 0x69, 0x46, 0x38, 0xaf, 0xef, 0xdc, 0xa3, 0x78, - 0x28, 0x11, 0xd8, 0xde, 0xcf, 0xd3, 0xec, 0x24, 0xe3, 0x4e, 0x48, 0x7f, 0xb1, 0xe8, 0x27, 0x75, - 0xed, 0x13, 0x3a, 0x33, 0x78, 0xc8, 0xa1, 0xe2, 0xd8, 0x7f, 0x02, 0x8e, 0x9e, 0xc0, 0x5c, 0x68, - 0x1e, 0x9f, 0x1c, 0x0f, 0x34, 0xb4, 0xbb, 0x87, 0x87, 0x3d, 0x0b, 0x59, 0xfb, 0xbb, 0xa3, 0xdd, - 0x9e, 0x8d, 0xa3, 0xd1, 0x2f, 0x4e, 0x07, 0xbd, 0x86, 0xff, 0x37, 0x16, 0xb8, 0x65, 0xfe, 0x66, - 0x1f, 0x61, 0xe2, 0xa5, 0xfc, 0x6f, 0xc2, 0x97, 0x1e, 0x2d, 0xb5, 0x42, 0x8c, 0x97, 0x72, 0xf4, - 0x18, 0x42, 0xa2, 0xcc, 0xe8, 0x44, 0xd4, 0xcb, 0xc0, 0xc6, 0xd2, 0x9b, 0x03, 0x2b, 0xda, 0x34, - 0x91, 0xa6, 0x32, 0xa2, 0x31, 0x19, 0x30, 0x4a, 0x02, 0x89, 0xda, 0x2d, 0x63, 0x40, 0xa4, 0x47, - 0xca, 0xff, 0x5b, 0x1b, 0xdc, 0xc5, 0x6d, 0xfc, 0x31, 0x78, 0xd3, 0x12, 0x0e, 0x93, 0x33, 0xd6, - 0x96, 0x30, 0xe2, 0x95, 0x9c, 0xdd, 0x07, 0xfb, 0xea, 0xda, 0x98, 0xd3, 0x41, 0xad, 0x2f, 0x5f, - 0x72, 0xfb, 0xea, 0xba, 0x4a, 0x3a, 0xad, 0x6f, 0x4d, 0x3a, 0x8f, 0xe0, 0x6e, 0x10, 0x4b, 0x91, - 0x8c, 0xab, 0x9c, 0xa1, 0xc3, 0x62, 0x9d, 0xd8, 0xa7, 0x8b, 0xc4, 0x61, 0x12, 0x67, 0xbb, 0xba, - 0x1e, 0x3f, 0x80, 0x56, 0x28, 0xe3, 0x42, 0xd4, 0xdf, 0x7c, 0x27, 0xb9, 0x08, 0x62, 0xb9, 0x8f, - 0x6c, 0xae, 0xa5, 0x6c, 0x0b, 0xdc, 0xb2, 0x54, 0x30, 0x2f, 0x3d, 0x7a, 0x3c, 0x94, 0x76, 0xe0, - 0x0b, 0x69, 0x05, 0x33, 0xd4, 0x60, 0xf6, 0x3f, 0x85, 0xc6, 0x97, 0x2f, 0x87, 0xe6, 0xac, 0xd6, - 0x2b, 0x67, 0x2d, 0xc1, 0xb6, 0x2b, 0xb0, 0xfd, 0xff, 0x6e, 0x40, 0xdb, 0xe4, 0x06, 0xdc, 0xf7, - 0x6c, 0x51, 0xe8, 0xe2, 0x70, 0xf9, 0x7e, 0x5e, 0x24, 0x99, 0x7a, 0x7f, 0xa0, 0xf1, 0xed, 0xfd, - 0x01, 0xf6, 0x33, 0xe8, 0x66, 0x5a, 0x56, 0x4f, 0x4b, 0x6f, 0xd7, 0xe7, 0x98, 0xbf, 0x34, 0xaf, - 0x93, 0x55, 0x04, 0x3a, 0x03, 0x3d, 0xa9, 0x0a, 0x31, 0x21, 0x13, 0x75, 0x79, 0x1b, 0xe9, 0x91, - 0x98, 0xbc, 0x26, 0x39, 0xfd, 0x16, 0x39, 0x06, 0x0b, 0xfa, 0x34, 0xeb, 0x77, 0x29, 0x6f, 0x60, - 0x5e, 0xaa, 0xa7, 0x8c, 0xb5, 0xe5, 0x94, 0xf1, 0x03, 0xf0, 0x82, 0x74, 0x3a, 0x8d, 0x48, 0xb6, - 0x6e, 0x0a, 0x56, 0x62, 0x8c, 0x94, 0xff, 0x97, 0x16, 0xb4, 0xcd, 0x69, 0x59, 0x07, 0xda, 0xfb, - 0x83, 0xe7, 0xbb, 0x67, 0x87, 0x98, 0xb5, 0x00, 0x9c, 0x67, 0x07, 0xc7, 0xbb, 0xfc, 0x17, 0x3d, - 0x0b, 0xc3, 0xec, 0xe0, 0x78, 0xd4, 0xb3, 0x99, 0x07, 0xad, 0xe7, 0x87, 0x27, 0xbb, 0xa3, 0x5e, - 0x03, 0xe3, 0xec, 0xd9, 0xc9, 0xc9, 0x61, 0xaf, 0xc9, 0xba, 0xe0, 0xee, 0xef, 0x8e, 0x06, 0xa3, - 0x83, 0xa3, 0x41, 0xaf, 0x85, 0xba, 0x2f, 0x06, 0x27, 0x3d, 0x07, 0x07, 0x67, 0x07, 0xfb, 0xbd, - 0x36, 0xca, 0x4f, 0x77, 0x87, 0xc3, 0x9f, 0x9f, 0xf0, 0xfd, 0x9e, 0x8b, 0xdf, 0x1d, 0x8e, 0xf8, - 0xc1, 0xf1, 0x8b, 0x9e, 0x87, 0xe3, 0x93, 0x67, 0x5f, 0x0c, 0xf6, 0x46, 0x3d, 0xf0, 0x3f, 0x85, - 0x4e, 0x0d, 0x41, 0x9c, 0xcd, 0x07, 0xcf, 0x7b, 0x77, 0x70, 0xc9, 0x97, 0xbb, 0x87, 0x67, 0x83, - 0x9e, 0xc5, 0xd6, 0x01, 0x68, 0x38, 0x3e, 0xdc, 0x3d, 0x7e, 0xd1, 0xb3, 0xfd, 0xdf, 0x05, 0xf7, - 0x2c, 0x0a, 0x9f, 0xc5, 0x69, 0x70, 0x85, 0x8e, 0x71, 0x2e, 0x94, 0x34, 0x57, 0x3d, 0x8d, 0xf1, - 0x2e, 0x22, 0xa7, 0x54, 0xc6, 0xf6, 0x86, 0xf2, 0x8f, 0xa1, 0x7d, 0x16, 0x85, 0xa7, 0x22, 0xb8, - 0xc2, 0x9c, 0x73, 0x8e, 0xf3, 0xc7, 0x2a, 0xfa, 0x5a, 0x9a, 0x34, 0xec, 0x11, 0x67, 0x18, 0x7d, - 0x2d, 0xd9, 0xfb, 0xe0, 0x10, 0x51, 0x16, 0x65, 0xe4, 0xcb, 0xe5, 0x9a, 0xdc, 0xc8, 0xfc, 0xbf, - 0xb6, 0x16, 0x7b, 0xa7, 0x7e, 0xc1, 0x43, 0x68, 0x66, 0x22, 0xb8, 0x32, 0x89, 0xa6, 0x63, 0xe6, - 0xe0, 0x7a, 0x9c, 0x04, 0xec, 0x11, 0xb8, 0xc6, 0x41, 0xca, 0x0f, 0x77, 0x6a, 0x9e, 0xc4, 0x17, - 0xc2, 0x65, 0xd3, 0x35, 0x96, 0x4d, 0x87, 0xc7, 0x53, 0x59, 0x1c, 0xd1, 0xd3, 0xaf, 0x81, 0x09, - 0x49, 0x53, 0xfe, 0x4f, 0x00, 0xaa, 0x66, 0xcc, 0x2d, 0x2f, 0x87, 0x7b, 0xd0, 0x12, 0x71, 0x64, - 0x50, 0xf1, 0xb8, 0x26, 0xfc, 0x63, 0xe8, 0xd4, 0x5a, 0x38, 0xe8, 0x4f, 0x22, 0x8e, 0xc7, 0x57, - 0xf2, 0x46, 0xd1, 0x5c, 0x97, 0xb7, 0x45, 0x1c, 0x7f, 0x29, 0x6f, 0x14, 0x26, 0x7f, 0xdd, 0xfd, - 0xb1, 0x57, 0xda, 0x09, 0x34, 0x95, 0x6b, 0xa1, 0xff, 0x63, 0x70, 0x74, 0x8f, 0xa1, 0xe6, 0xce, - 0xd6, 0x6b, 0xaf, 0xcc, 0xcf, 0xcd, 0x9e, 0xa9, 0x23, 0xc1, 0x3e, 0x36, 0x5d, 0x26, 0xa5, 0x7b, - 0x5a, 0x56, 0x55, 0x46, 0x6a, 0x25, 0xd3, 0x60, 0x22, 0x65, 0x7f, 0x1f, 0xdc, 0x37, 0xf6, 0xed, - 0x0c, 0x00, 0x76, 0x05, 0xc0, 0x2d, 0x9d, 0x3c, 0xff, 0x97, 0x00, 0x55, 0x37, 0xca, 0x44, 0x97, - 0xfe, 0x0a, 0x46, 0xd7, 0x63, 0x7c, 0xf2, 0x45, 0x71, 0x98, 0xcb, 0x64, 0xe9, 0xd4, 0x55, 0xff, - 0x6a, 0x21, 0x67, 0x9b, 0xd0, 0xa4, 0x26, 0x5b, 0xa3, 0xca, 0x7e, 0x8b, 0x0e, 0x1b, 0x49, 0xfc, - 0x39, 0xac, 0xe9, 0x9b, 0x98, 0xcb, 0x3f, 0x9d, 0x49, 0xf5, 0xc6, 0xfa, 0xee, 0x01, 0xc0, 0x22, - 0x57, 0x97, 0xed, 0xc2, 0x1a, 0x07, 0x9d, 0xe0, 0x22, 0x92, 0x71, 0x58, 0x9e, 0xc6, 0x50, 0x68, - 0x64, 0x7d, 0x43, 0x37, 0x75, 0x4f, 0x85, 0x08, 0xff, 0xf7, 0xa1, 0x5b, 0xae, 0x4c, 0x4d, 0x8b, - 0x8f, 0x17, 0x55, 0x82, 0xc6, 0x58, 0xbf, 0x95, 0xb4, 0xca, 0x71, 0x1a, 0xca, 0x67, 0x76, 0xdf, - 0x2a, 0x0b, 0x05, 0xff, 0xdf, 0x1a, 0xe5, 0x6c, 0xf3, 0x86, 0x5f, 0xaa, 0x3d, 0xad, 0xd5, 0xda, - 0x73, 0xb9, 0x8e, 0xb3, 0x7f, 0xab, 0x3a, 0xee, 0xa7, 0xe0, 0x85, 0x54, 0xcc, 0x44, 0xd7, 0x65, - 0x5e, 0xde, 0x58, 0x2d, 0x5c, 0x4c, 0xb9, 0x13, 0x5d, 0x4b, 0x5e, 0x29, 0xe3, 0x5e, 0x8a, 0xf4, - 0x4a, 0x26, 0xd1, 0xd7, 0xd4, 0xa4, 0xc0, 0x33, 0x57, 0x8c, 0xaa, 0xe3, 0xa3, 0x6b, 0x1a, 0xd3, - 0xf1, 0x29, 0x9b, 0x57, 0x4e, 0xd5, 0xbc, 0x42, 0x3c, 0x67, 0x99, 0x92, 0x79, 0x51, 0x56, 0xc1, - 0x9a, 0x5a, 0x14, 0x8c, 0x9e, 0xd1, 0xc5, 0x82, 0xf1, 0x5d, 0xe8, 0x26, 0x69, 0x32, 0x4e, 0x66, - 0x71, 0x8c, 0x75, 0xba, 0xe9, 0x53, 0x76, 0x92, 0x34, 0x39, 0x36, 0x2c, 0xf6, 0x18, 0xbe, 0x57, - 0x57, 0xd1, 0xfe, 0xdc, 0xd1, 0x6d, 0x8e, 0x9a, 0x1e, 0x79, 0xfd, 0x16, 0xf4, 0xd2, 0xf3, 0x5f, - 0xca, 0xa0, 0x20, 0xc4, 0xc6, 0xe4, 0xc8, 0x5d, 0x7d, 0x3b, 0x6b, 0x3e, 0x42, 0x74, 0x2c, 0xa6, - 0xd2, 0xff, 0x1c, 0xbc, 0x05, 0x08, 0xb5, 0x6a, 0xc8, 0x83, 0xd6, 0xc1, 0xf1, 0xfe, 0xe0, 0x8f, - 0x7b, 0x16, 0xa6, 0x72, 0x3e, 0x78, 0x39, 0xe0, 0xc3, 0x41, 0xcf, 0xc6, 0x34, 0xbb, 0x3f, 0x38, - 0x1c, 0x8c, 0x06, 0xbd, 0xc6, 0x17, 0x4d, 0xb7, 0xdd, 0x73, 0xb9, 0x2b, 0xe7, 0x59, 0x1c, 0x05, - 0x51, 0xe1, 0x0f, 0x01, 0xaa, 0xc2, 0x0d, 0xf3, 0x4d, 0xb5, 0xb6, 0xb6, 0xa8, 0x5b, 0x98, 0x55, - 0xb1, 0xa4, 0x34, 0xae, 0x66, 0xbf, 0xae, 0xa4, 0xd4, 0x72, 0xff, 0x0c, 0xdc, 0x23, 0x91, 0xbd, - 0xf2, 0x04, 0xeb, 0x2e, 0x1e, 0xda, 0x33, 0xd3, 0x76, 0x32, 0x77, 0xf4, 0x07, 0xd0, 0x36, 0x29, - 0xcf, 0x44, 0xcd, 0x52, 0x3a, 0x2c, 0x65, 0xfe, 0x5f, 0x58, 0x70, 0xef, 0x28, 0xbd, 0x96, 0x8b, - 0x32, 0xe5, 0x54, 0xdc, 0xc4, 0xa9, 0x08, 0xbf, 0xc5, 0x11, 0x7f, 0x04, 0xa0, 0xd2, 0x59, 0x1e, - 0xc8, 0xf1, 0x64, 0xd1, 0xed, 0xf2, 0x34, 0xe7, 0x85, 0x69, 0xac, 0x4b, 0x55, 0x90, 0xb0, 0xa1, - 0x83, 0x0f, 0x69, 0x14, 0x7d, 0x1f, 0x9c, 0x62, 0x9e, 0x54, 0xcd, 0xb5, 0x56, 0x81, 0xef, 0x5f, - 0x7f, 0x0f, 0xbc, 0xd1, 0x9c, 0x5e, 0x85, 0x33, 0xb5, 0x74, 0xf1, 0x5a, 0x6f, 0xb8, 0x78, 0xed, - 0x95, 0x8b, 0xf7, 0x3f, 0x2d, 0xe8, 0xd4, 0xea, 0x27, 0xf6, 0x2e, 0x34, 0x8b, 0x79, 0xb2, 0xdc, - 0x95, 0x2e, 0x17, 0xe1, 0x24, 0x42, 0x7f, 0xc3, 0x27, 0xa3, 0x50, 0x2a, 0x9a, 0x24, 0x32, 0x34, - 0x9f, 0xc4, 0x67, 0xe4, 0xae, 0x61, 0xb1, 0x43, 0xb8, 0xab, 0x33, 0x49, 0xd9, 0x91, 0x2a, 0x1f, - 0x0a, 0xef, 0xad, 0xd4, 0x6b, 0xfa, 0xe5, 0xbc, 0x57, 0x6a, 0xe9, 0xde, 0xc0, 0xfa, 0x64, 0x89, - 0xb9, 0xb1, 0x0b, 0x6f, 0xdd, 0xa2, 0xf6, 0x9d, 0x9a, 0x20, 0x0f, 0x61, 0x6d, 0x34, 0x4f, 0x46, - 0xd1, 0x54, 0xaa, 0x42, 0x4c, 0x33, 0x2a, 0x5c, 0xcc, 0x4d, 0xd0, 0xe4, 0x76, 0xa1, 0xfc, 0x0f, - 0xa1, 0x7b, 0x2a, 0x65, 0xce, 0xa5, 0xca, 0xd2, 0x44, 0x5f, 0xda, 0x8a, 0x0e, 0x6d, 0xae, 0x1d, - 0x43, 0xf9, 0x7f, 0x02, 0x1e, 0x56, 0xeb, 0xcf, 0x44, 0x11, 0x5c, 0x7e, 0x97, 0x6a, 0xfe, 0x43, - 0x68, 0x67, 0xda, 0x4d, 0x4c, 0x81, 0xdd, 0xa5, 0x1c, 0x67, 0x5c, 0x87, 0x97, 0x42, 0x9f, 0x43, - 0xe3, 0x78, 0x36, 0xad, 0xff, 0x94, 0xd4, 0xd4, 0x3f, 0x25, 0x2d, 0xbd, 0x7f, 0xed, 0xe5, 0xf7, - 0x2f, 0x7a, 0xde, 0x45, 0x9a, 0xff, 0x99, 0xc8, 0x43, 0x19, 0x9a, 0x47, 0x76, 0xc5, 0xf0, 0xbf, - 0x82, 0x4e, 0x69, 0x99, 0x83, 0x90, 0x7e, 0x2d, 0x22, 0xd7, 0x38, 0x08, 0x97, 0x3c, 0x45, 0x3f, - 0x52, 0x65, 0x12, 0x1e, 0x94, 0x26, 0xd5, 0xc4, 0xf2, 0xca, 0xa6, 0x09, 0xb3, 0x78, 0x79, 0x3f, - 0x87, 0x6e, 0x59, 0x54, 0x1f, 0xc9, 0x42, 0x90, 0xb3, 0xc5, 0x91, 0x4c, 0x6a, 0x8e, 0xe8, 0x6a, - 0xc6, 0x48, 0xbd, 0xa1, 0xdd, 0xeb, 0x6f, 0x83, 0x63, 0x3c, 0x99, 0x41, 0x33, 0x48, 0x43, 0x1d, - 0x40, 0x2d, 0x4e, 0x63, 0x84, 0x63, 0xaa, 0x26, 0xe5, 0xe5, 0x39, 0x55, 0x13, 0xff, 0xd7, 0x36, - 0xac, 0x3d, 0x13, 0xc1, 0xd5, 0x2c, 0x2b, 0x6f, 0xaf, 0xda, 0xcb, 0xc8, 0x5a, 0x7a, 0x19, 0xbd, - 0xa1, 0xc9, 0xfc, 0x36, 0xb4, 0x67, 0x49, 0x34, 0x2f, 0xcb, 0x1a, 0x8f, 0x3b, 0x48, 0x8e, 0x14, - 0xdb, 0x84, 0x0e, 0x46, 0x5f, 0x94, 0xd0, 0xa3, 0x87, 0xe2, 0xce, 0xe3, 0x75, 0x16, 0x86, 0xb3, - 0x08, 0x02, 0xa9, 0x14, 0x16, 0x27, 0x04, 0x8b, 0xc7, 0x3d, 0xcd, 0xf9, 0x52, 0xde, 0x50, 0xb4, - 0xcb, 0x20, 0x97, 0x05, 0x89, 0x75, 0x5d, 0xed, 0x69, 0x0e, 0x8a, 0xdf, 0x83, 0x35, 0x25, 0x95, - 0x8a, 0xd2, 0x64, 0x4c, 0xd7, 0x83, 0x79, 0xe2, 0x74, 0x0d, 0x73, 0x84, 0x3c, 0xb4, 0xaa, 0x48, - 0xd2, 0xe4, 0x66, 0x9a, 0xce, 0x94, 0xb9, 0x07, 0x2a, 0x06, 0xae, 0x40, 0x7d, 0x94, 0xf1, 0xc5, - 0x2c, 0x8e, 0xcd, 0x85, 0xe0, 0x11, 0xe7, 0xf9, 0x2c, 0x8e, 0xfd, 0x0f, 0x61, 0xbd, 0xc4, 0xc7, - 0xb8, 0xf4, 0x3d, 0x68, 0xd1, 0xeb, 0xcf, 0xc0, 0xa3, 0x09, 0xbf, 0x80, 0xb5, 0xc1, 0x3c, 0xa3, - 0x1f, 0x10, 0xbe, 0xb5, 0x0a, 0xa8, 0x41, 0x6c, 0x2f, 0x41, 0xbc, 0x82, 0x63, 0x63, 0x81, 0x23, - 0xd6, 0x05, 0x69, 0x3e, 0x15, 0x85, 0x81, 0xd0, 0x50, 0x3b, 0xff, 0x64, 0x41, 0x13, 0xe3, 0x04, - 0x9f, 0x9e, 0x7f, 0x28, 0x45, 0x5e, 0x9c, 0x4b, 0x51, 0xb0, 0xa5, 0x98, 0xd8, 0x58, 0xa2, 0xfc, - 0x3b, 0x4f, 0x2d, 0xb6, 0xad, 0x7f, 0xb3, 0x28, 0x7f, 0x8a, 0x59, 0x2b, 0xa3, 0x8d, 0xa2, 0x71, - 0x55, 0x7f, 0x8b, 0xf4, 0xbf, 0x48, 0xa3, 0x64, 0x4f, 0x37, 0xf2, 0xd9, 0x6a, 0x74, 0xae, 0xce, - 0x60, 0x9f, 0x80, 0x73, 0xa0, 0x30, 0x0d, 0xbc, 0xaa, 0x4a, 0xb7, 0x4c, 0x3d, 0x43, 0xf8, 0x77, - 0x76, 0xfe, 0xb1, 0x01, 0xcd, 0xaf, 0x64, 0x9e, 0xb2, 0x1f, 0x43, 0xdb, 0xb4, 0xe9, 0x58, 0xad, - 0x1d, 0xb7, 0x41, 0x65, 0xc6, 0x4a, 0xff, 0x8e, 0x56, 0xe9, 0xe9, 0x8b, 0xaa, 0x7a, 0x1d, 0xb3, - 0xaa, 0x8b, 0xf8, 0xca, 0xa6, 0x3e, 0x87, 0xde, 0xb0, 0xc8, 0xa5, 0x98, 0xd6, 0xd4, 0x97, 0x81, - 0xba, 0xed, 0xa9, 0x4d, 0x78, 0x7d, 0x0c, 0x8e, 0xce, 0xb5, 0x2b, 0x13, 0x56, 0x5f, 0xcd, 0xa4, - 0xfc, 0x08, 0x3a, 0xc3, 0xcb, 0x74, 0x16, 0x87, 0x43, 0x99, 0x5f, 0x4b, 0x56, 0x6b, 0x95, 0x6f, - 0xd4, 0xc6, 0xfe, 0x1d, 0xb6, 0x05, 0xa0, 0xd3, 0xc9, 0x59, 0x14, 0x2a, 0xd6, 0x46, 0xd9, 0xf1, - 0x6c, 0xaa, 0x3f, 0x5a, 0xcb, 0x33, 0x5a, 0xb3, 0x96, 0x72, 0xdf, 0xa4, 0xf9, 0x19, 0xac, 0xed, - 0xd1, 0x95, 0x74, 0x92, 0xef, 0x9e, 0xa7, 0x79, 0xc1, 0x56, 0xdb, 0xe5, 0x1b, 0xab, 0x0c, 0xff, - 0x0e, 0x7b, 0x0a, 0xee, 0x28, 0xbf, 0xd1, 0xfa, 0xdf, 0x33, 0x37, 0x55, 0xb5, 0xde, 0x2d, 0xa7, - 0xdc, 0xf9, 0x87, 0x06, 0x38, 0x3f, 0x4f, 0xf3, 0x2b, 0x99, 0xb3, 0xc7, 0xe0, 0x50, 0x7b, 0xc3, - 0xb8, 0xd1, 0xa2, 0xd5, 0x71, 0xdb, 0x42, 0xef, 0x83, 0x47, 0xa0, 0x8c, 0x84, 0xba, 0xd2, 0xa6, - 0xa2, 0xdf, 0xd4, 0x35, 0x2e, 0xba, 0x86, 0x25, 0xbb, 0xae, 0x6b, 0x43, 0x2d, 0xba, 0x3d, 0x4b, - 0x3d, 0x87, 0x8d, 0xb6, 0x6e, 0x20, 0x0c, 0xd1, 0x35, 0x9f, 0x5a, 0xec, 0x23, 0x68, 0x0e, 0xf5, - 0x49, 0x51, 0xa9, 0xfa, 0x85, 0x71, 0x63, 0xbd, 0x64, 0x2c, 0xbe, 0xfc, 0x04, 0x1c, 0x5d, 0xe0, - 0xe8, 0x63, 0x2e, 0x55, 0xed, 0x1b, 0xbd, 0x3a, 0xcb, 0x4c, 0xf8, 0x14, 0x1c, 0x1d, 0xfc, 0x7a, - 0xc2, 0x52, 0xa2, 0xdc, 0x60, 0x75, 0x56, 0xe9, 0xcc, 0xec, 0x23, 0x70, 0x74, 0x1e, 0xd0, 0x53, - 0x96, 0x72, 0x82, 0x3e, 0xa8, 0xce, 0xcf, 0xda, 0x81, 0xb9, 0x0c, 0x64, 0x54, 0x2b, 0x81, 0x58, - 0x79, 0xb8, 0x5b, 0xa2, 0xf0, 0x73, 0x58, 0x5b, 0x2a, 0x97, 0x58, 0x9f, 0x00, 0xbf, 0xa5, 0x82, - 0x5a, 0x9d, 0xfc, 0xac, 0xf7, 0x2f, 0xdf, 0x3c, 0xb0, 0xfe, 0xf5, 0x9b, 0x07, 0xd6, 0xbf, 0x7f, - 0xf3, 0xc0, 0xfa, 0xd5, 0x7f, 0x3c, 0xb8, 0x73, 0xee, 0xd0, 0xff, 0x64, 0x7c, 0xf6, 0xbf, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x03, 0x64, 0xf0, 0xcf, 0xd7, 0x21, 0x00, 0x00, + // 3549 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xcd, 0x6f, 0xdc, 0x48, + 0x76, 0x37, 0xd9, 0xdd, 0x6c, 0xf2, 0x75, 0x4b, 0xee, 0xad, 0xf1, 0x7a, 0x7a, 0xb4, 0xbb, 0xb6, + 0x86, 0xf3, 0x61, 0x8d, 0x67, 0x47, 0xf6, 0x68, 0x36, 0xc9, 0xce, 0x06, 0x39, 0xc8, 0x56, 0xdb, + 0xd1, 0x8c, 0x2c, 0x29, 0xa5, 0x96, 0x37, 0x3b, 0x87, 0x34, 0x4a, 0x64, 0xa9, 0xc5, 0x15, 0x9b, + 0x64, 0x58, 0x6c, 0xa5, 0x35, 0xb7, 0x1c, 0x12, 0x20, 0x40, 0x6e, 0xb9, 0x2c, 0x82, 0x20, 0x87, + 0x1c, 0x03, 0x04, 0xb9, 0xee, 0x39, 0x40, 0x80, 0x1c, 0x83, 0xfc, 0x05, 0xc1, 0x24, 0xc7, 0x9c, + 0x03, 0xe4, 0x16, 0xbc, 0x57, 0xc5, 0x26, 0xd9, 0x96, 0x3d, 0x3b, 0x01, 0x72, 0x52, 0xbd, 0x8f, + 0x62, 0x55, 0xfd, 0xea, 0xd5, 0xfb, 0x6a, 0x81, 0x9b, 0x9d, 0x6d, 0x67, 0x79, 0x5a, 0xa4, 0xcc, + 0xce, 0xce, 0x36, 0x3c, 0x91, 0x45, 0x9a, 0xdc, 0x78, 0x30, 0x8d, 0x8a, 0x8b, 0xf9, 0xd9, 0x76, + 0x90, 0xce, 0x1e, 0x85, 0xd3, 0x5c, 0x64, 0x17, 0x9f, 0x44, 0xe9, 0xa3, 0x33, 0x11, 0x4e, 0x65, + 0xfe, 0x28, 0x3b, 0x7b, 0x54, 0xce, 0xf3, 0x37, 0xa0, 0x7d, 0x10, 0xa9, 0x82, 0x31, 0x68, 0xcf, + 0xa3, 0x50, 0x0d, 0xad, 0xcd, 0xd6, 0x96, 0xc3, 0x69, 0xec, 0xbf, 0x00, 0x6f, 0x2c, 0xd4, 0xe5, + 0x4b, 0x11, 0xcf, 0x25, 0x1b, 0x40, 0xeb, 0x4a, 0xc4, 0x43, 0x6b, 0xd3, 0xda, 0xea, 0x73, 0x1c, + 0xb2, 0x6d, 0x70, 0xaf, 0x44, 0x3c, 0x29, 0xae, 0x33, 0x39, 0xb4, 0x37, 0xad, 0xad, 0xf5, 0x9d, + 0xb7, 0xb6, 0xb3, 0xb3, 0xed, 0xe3, 0x54, 0x15, 0x51, 0x32, 0xdd, 0x7e, 0x29, 0xe2, 0xf1, 0x75, + 0x26, 0x79, 0xf7, 0x4a, 0x0f, 0xfc, 0x23, 0xe8, 0x9d, 0xe4, 0xc1, 0xb3, 0x79, 0x12, 0x14, 0x51, + 0x9a, 0xe0, 0x8a, 0x89, 0x98, 0x49, 0xfa, 0xa2, 0xc7, 0x69, 0x8c, 0x3c, 0x91, 0x4f, 0xd5, 0xb0, + 0xb5, 0xd9, 0x42, 0x1e, 0x8e, 0xd9, 0x10, 0xba, 0x91, 0x7a, 0x9a, 0xce, 0x93, 0x62, 0xd8, 0xde, + 0xb4, 0xb6, 0x5c, 0x5e, 0x92, 0xfe, 0x5f, 0xb4, 0xa0, 0xf3, 0x07, 0x73, 0x99, 0x5f, 0xd3, 0xbc, + 0xa2, 0xc8, 0xcb, 0x6f, 0xe1, 0x98, 0xdd, 0x81, 0x4e, 0x2c, 0x92, 0xa9, 0x1a, 0xda, 0xf4, 0x31, + 0x4d, 0xb0, 0x1f, 0x80, 0x27, 0xce, 0x0b, 0x99, 0x4f, 0xe6, 0x51, 0x38, 0x6c, 0x6d, 0x5a, 0x5b, + 0x0e, 0x77, 0x89, 0x71, 0x1a, 0x85, 0xec, 0x1d, 0x70, 0xc3, 0x74, 0x12, 0xd4, 0xd7, 0x0a, 0x53, + 0x5a, 0x8b, 0xbd, 0x07, 0xee, 0x3c, 0x0a, 0x27, 0x71, 0xa4, 0x8a, 0x61, 0x67, 0xd3, 0xda, 0xea, + 0xed, 0xb8, 0x78, 0x58, 0xc4, 0x8e, 0x77, 0xe7, 0x51, 0x48, 0x20, 0x3e, 0x04, 0x57, 0xe5, 0xc1, + 0xe4, 0x7c, 0x9e, 0x04, 0x43, 0x87, 0x94, 0x6e, 0xa3, 0x52, 0xed, 0xd4, 0xbc, 0xab, 0x34, 0x81, + 0xc7, 0xca, 0xe5, 0x95, 0xcc, 0x95, 0x1c, 0x76, 0xf5, 0x52, 0x86, 0x64, 0x8f, 0xa1, 0x77, 0x2e, + 0x02, 0x59, 0x4c, 0x32, 0x91, 0x8b, 0xd9, 0xd0, 0xad, 0x3e, 0xf4, 0x0c, 0xd9, 0xc7, 0xc8, 0x55, + 0x1c, 0xce, 0x97, 0x04, 0xfb, 0x0c, 0xd6, 0x88, 0x52, 0x93, 0xf3, 0x28, 0x2e, 0x64, 0x3e, 0xf4, + 0x68, 0xce, 0x3a, 0xcd, 0x21, 0xce, 0x38, 0x97, 0x92, 0xf7, 0xb5, 0x92, 0xe6, 0xb0, 0x1f, 0x01, + 0xc8, 0x45, 0x26, 0x92, 0x70, 0x22, 0xe2, 0x78, 0x08, 0xb4, 0x07, 0x4f, 0x73, 0x76, 0xe3, 0x98, + 0xbd, 0x8d, 0xfb, 0x13, 0xe1, 0xa4, 0x50, 0xc3, 0xb5, 0x4d, 0x6b, 0xab, 0xcd, 0x1d, 0x24, 0xc7, + 0x0a, 0x71, 0x0d, 0x44, 0x70, 0x21, 0x87, 0xeb, 0x9b, 0xd6, 0x56, 0x87, 0x6b, 0xc2, 0xdf, 0x01, + 0x8f, 0xec, 0x84, 0x70, 0xf8, 0x00, 0x9c, 0x2b, 0x24, 0xb4, 0x39, 0xf5, 0x76, 0xd6, 0x70, 0x23, + 0x4b, 0x53, 0xe2, 0x46, 0xe8, 0xdf, 0x03, 0xf7, 0x40, 0x24, 0xd3, 0xd2, 0xfe, 0xf0, 0x82, 0x68, + 0x82, 0xc7, 0x69, 0xec, 0xff, 0xca, 0x06, 0x87, 0x4b, 0x35, 0x8f, 0x0b, 0xf6, 0x00, 0x00, 0xe1, + 0x9f, 0x89, 0x22, 0x8f, 0x16, 0xe6, 0xab, 0xd5, 0x05, 0x78, 0xf3, 0x28, 0x7c, 0x41, 0x22, 0xf6, + 0x18, 0xfa, 0xf4, 0xf5, 0x52, 0xd5, 0xae, 0x36, 0xb0, 0xdc, 0x1f, 0xef, 0x91, 0x8a, 0x99, 0x71, + 0x17, 0x1c, 0xba, 0x71, 0x6d, 0x75, 0x6b, 0xdc, 0x50, 0xec, 0x03, 0x58, 0x8f, 0x92, 0x02, 0x6f, + 0x24, 0x28, 0x26, 0xa1, 0x54, 0xa5, 0x49, 0xac, 0x2d, 0xb9, 0x7b, 0x52, 0x15, 0xec, 0x53, 0xd0, + 0xb0, 0x96, 0x0b, 0x76, 0x68, 0xc1, 0xf5, 0xe5, 0x75, 0x29, 0xbd, 0x22, 0xe9, 0x98, 0x15, 0x3f, + 0x81, 0x1e, 0x9e, 0xaf, 0x9c, 0xe1, 0xd0, 0x8c, 0x3e, 0x9d, 0xc6, 0xc0, 0xc1, 0x01, 0x15, 0x8c, + 0x3a, 0x42, 0x83, 0x66, 0xa7, 0xcd, 0x84, 0xc6, 0xfe, 0x08, 0x3a, 0x47, 0x79, 0x28, 0xf3, 0x1b, + 0x2d, 0x9f, 0x41, 0x3b, 0x94, 0x2a, 0xa0, 0x47, 0xe9, 0x72, 0x1a, 0x57, 0xaf, 0xa1, 0x55, 0x7b, + 0x0d, 0xfe, 0xdf, 0x5a, 0xd0, 0x3b, 0x49, 0xf3, 0xe2, 0x85, 0x54, 0x4a, 0x4c, 0x25, 0xbb, 0x0f, + 0x9d, 0x14, 0x3f, 0x6b, 0x10, 0xf6, 0x70, 0x4f, 0xb4, 0x0e, 0xd7, 0xfc, 0x95, 0x7b, 0xb0, 0x5f, + 0x7f, 0x0f, 0x68, 0x25, 0xf4, 0x8e, 0x5a, 0xc6, 0x4a, 0xe8, 0x15, 0xdd, 0x05, 0x27, 0x3d, 0x3f, + 0x57, 0x52, 0x63, 0xd9, 0xe1, 0x86, 0x7a, 0xad, 0xb1, 0xf9, 0xbf, 0x05, 0x80, 0xfb, 0xfb, 0x8e, + 0x56, 0xe0, 0x5f, 0x40, 0x8f, 0x8b, 0xf3, 0xe2, 0x69, 0x9a, 0x14, 0x72, 0x51, 0xb0, 0x75, 0xb0, + 0xa3, 0x90, 0x20, 0x72, 0xb8, 0x1d, 0x85, 0xb8, 0xb9, 0x69, 0x9e, 0xce, 0x33, 0x42, 0x68, 0x8d, + 0x6b, 0x82, 0xa0, 0x0c, 0xc3, 0x9c, 0x76, 0x8c, 0x50, 0x86, 0x61, 0xce, 0xee, 0x43, 0x4f, 0x25, + 0x22, 0x53, 0x17, 0x69, 0x81, 0x9b, 0x6b, 0xd3, 0xe6, 0xa0, 0x64, 0x8d, 0x95, 0xff, 0xcf, 0x16, + 0x38, 0x2f, 0xe4, 0xec, 0x4c, 0xe6, 0xaf, 0xac, 0xf2, 0x0e, 0xb8, 0xf4, 0xe1, 0x49, 0x14, 0x9a, + 0x85, 0xba, 0x44, 0xef, 0x87, 0x37, 0x2e, 0x75, 0x17, 0x9c, 0x58, 0x0a, 0x04, 0x5f, 0xdb, 0x99, + 0xa1, 0x10, 0x1b, 0x31, 0x9b, 0x84, 0x52, 0x84, 0xe4, 0x78, 0x5c, 0xee, 0x88, 0xd9, 0x9e, 0x14, + 0x21, 0xee, 0x2d, 0x16, 0xaa, 0x98, 0xcc, 0xb3, 0x50, 0x14, 0x92, 0x1c, 0x4e, 0x1b, 0x0d, 0x47, + 0x15, 0xa7, 0xc4, 0x61, 0x0f, 0xe1, 0x7b, 0x41, 0x3c, 0x57, 0xe8, 0xed, 0xa2, 0xe4, 0x3c, 0x9d, + 0xa4, 0x49, 0x7c, 0x4d, 0xf8, 0xba, 0xfc, 0xb6, 0x11, 0xec, 0x27, 0xe7, 0xe9, 0x51, 0x12, 0x5f, + 0xfb, 0xbf, 0xb6, 0xa1, 0xf3, 0x9c, 0x60, 0x78, 0x0c, 0xdd, 0x19, 0x1d, 0xa8, 0x7c, 0xbd, 0x77, + 0x11, 0x61, 0x92, 0x6d, 0xeb, 0x93, 0xaa, 0x51, 0x52, 0xe4, 0xd7, 0xbc, 0x54, 0xc3, 0x19, 0x85, + 0x38, 0x8b, 0x65, 0xa1, 0x8c, 0x45, 0xd4, 0x66, 0x8c, 0xb5, 0xc0, 0xcc, 0x30, 0x6a, 0xab, 0xb0, + 0xb6, 0x56, 0x61, 0x65, 0x1b, 0xe0, 0x06, 0x17, 0x32, 0xb8, 0x54, 0xf3, 0x99, 0x01, 0x7d, 0x49, + 0x6f, 0x3c, 0x83, 0x7e, 0x7d, 0x1f, 0x18, 0x99, 0x2e, 0xe5, 0x35, 0x01, 0xdf, 0xe6, 0x38, 0x64, + 0x9b, 0xd0, 0xa1, 0x17, 0x4e, 0xb0, 0xf7, 0x76, 0x00, 0xb7, 0xa3, 0xa7, 0x70, 0x2d, 0xf8, 0x99, + 0xfd, 0x53, 0x0b, 0xbf, 0x53, 0xdf, 0x5d, 0xfd, 0x3b, 0xde, 0xeb, 0xbf, 0xa3, 0xa7, 0xd4, 0xbe, + 0xe3, 0xff, 0x8f, 0x0d, 0xfd, 0xaf, 0x64, 0x9e, 0x1e, 0xe7, 0x69, 0x96, 0x2a, 0x11, 0xb3, 0xdd, + 0xe6, 0xe9, 0x34, 0x8a, 0x9b, 0x38, 0xb9, 0xae, 0xb6, 0x7d, 0xb2, 0x3c, 0xae, 0x46, 0xa7, 0x7e, + 0x7e, 0x1f, 0x1c, 0x8d, 0xee, 0x0d, 0x47, 0x30, 0x12, 0xd4, 0xd1, 0x78, 0x12, 0x7e, 0xcd, 0xed, + 0x19, 0x09, 0xbb, 0x07, 0x30, 0x13, 0x8b, 0x03, 0x29, 0x94, 0xdc, 0x0f, 0x4b, 0xf3, 0xad, 0x38, + 0x88, 0xf3, 0x4c, 0x2c, 0xc6, 0x8b, 0x64, 0xac, 0xc8, 0xba, 0xda, 0x7c, 0x49, 0xb3, 0x1f, 0x82, + 0x37, 0x13, 0x0b, 0x7c, 0x47, 0xfb, 0xa1, 0xb1, 0xae, 0x8a, 0xc1, 0xde, 0x85, 0x56, 0xb1, 0x48, + 0xc8, 0x29, 0x61, 0x74, 0xc2, 0xd4, 0x63, 0xbc, 0x48, 0xcc, 0x8b, 0xe3, 0x28, 0x2b, 0x01, 0x75, + 0x2b, 0x40, 0x07, 0xd0, 0x0a, 0xa2, 0x90, 0xc2, 0x93, 0xc7, 0x71, 0xb8, 0xf1, 0x7b, 0x70, 0x7b, + 0x05, 0x87, 0xfa, 0x3d, 0xac, 0xe9, 0x69, 0x77, 0xea, 0xf7, 0xd0, 0xae, 0x63, 0xff, 0xeb, 0x16, + 0xdc, 0x36, 0xc6, 0x70, 0x11, 0x65, 0x27, 0x05, 0x9a, 0xfd, 0x10, 0xba, 0xe4, 0x6d, 0x64, 0x6e, + 0x6c, 0xa2, 0x24, 0xd9, 0xef, 0x80, 0x43, 0x2f, 0xb0, 0xb4, 0xd3, 0xfb, 0x15, 0xaa, 0xcb, 0xe9, + 0xda, 0x6e, 0xcd, 0x95, 0x18, 0x75, 0xf6, 0x13, 0xe8, 0x7c, 0x2d, 0xf3, 0x54, 0x7b, 0xcf, 0xde, + 0xce, 0xbd, 0x9b, 0xe6, 0xe1, 0xdd, 0x9a, 0x69, 0x5a, 0xf9, 0xff, 0x11, 0xfc, 0xf7, 0xd1, 0x5f, + 0xce, 0xd2, 0x2b, 0x19, 0x0e, 0xbb, 0xb4, 0xa3, 0xba, 0x7d, 0x94, 0xa2, 0x12, 0x6d, 0xb7, 0x42, + 0x7b, 0x0f, 0x7a, 0xb5, 0xe3, 0xdd, 0x80, 0xf4, 0xfd, 0xa6, 0xc5, 0x7b, 0xcb, 0x87, 0x5c, 0x7f, + 0x38, 0x7b, 0x00, 0xd5, 0x61, 0xff, 0xaf, 0xcf, 0xcf, 0xff, 0x53, 0x0b, 0x6e, 0x3f, 0x4d, 0x93, + 0x44, 0x52, 0x62, 0xa4, 0xaf, 0xae, 0x32, 0x7b, 0xeb, 0xb5, 0x66, 0xff, 0x11, 0x74, 0x14, 0x2a, + 0x9b, 0xaf, 0xbf, 0x75, 0xc3, 0x5d, 0x70, 0xad, 0x81, 0x6e, 0x66, 0x26, 0x16, 0x93, 0x4c, 0x26, + 0x61, 0x94, 0x4c, 0x4b, 0x37, 0x33, 0x13, 0x8b, 0x63, 0xcd, 0xf1, 0xff, 0xce, 0x02, 0x47, 0xbf, + 0x98, 0x86, 0xb7, 0xb6, 0x9a, 0xde, 0xfa, 0x87, 0xe0, 0x65, 0xb9, 0x0c, 0xa3, 0xa0, 0x5c, 0xd5, + 0xe3, 0x15, 0x03, 0x8d, 0xf3, 0x3c, 0xcd, 0x03, 0x49, 0x9f, 0x77, 0xb9, 0x26, 0x90, 0xab, 0x32, + 0x11, 0xe8, 0xe4, 0xae, 0xc5, 0x35, 0x81, 0x3e, 0x5e, 0x5f, 0x0e, 0x5d, 0x8a, 0xcb, 0x0d, 0x85, + 0x59, 0x29, 0xc5, 0x3f, 0xf2, 0xd0, 0x1e, 0x89, 0x5c, 0x64, 0x90, 0x6b, 0xfe, 0x7b, 0x1b, 0xfa, + 0x7b, 0x51, 0x2e, 0x83, 0x42, 0x86, 0xa3, 0x70, 0x4a, 0x5f, 0x91, 0x49, 0x11, 0x15, 0xd7, 0x26, + 0xd8, 0x18, 0x6a, 0x99, 0x0b, 0xd8, 0xcd, 0x2c, 0x58, 0xdf, 0x45, 0x8b, 0x12, 0x77, 0x4d, 0xb0, + 0x1d, 0x00, 0x9d, 0x25, 0x51, 0xf2, 0xde, 0x7e, 0x7d, 0xf2, 0xee, 0x91, 0x1a, 0x0e, 0x11, 0x20, + 0x3d, 0x27, 0xd2, 0x81, 0xc8, 0xa1, 0xcc, 0x7e, 0x8e, 0x86, 0x4c, 0xc9, 0xc5, 0x99, 0x8c, 0xc9, + 0x50, 0x29, 0xb9, 0x38, 0x93, 0xf1, 0x32, 0xa5, 0xeb, 0xea, 0xed, 0xe0, 0x98, 0xbd, 0x07, 0x76, + 0x9a, 0xd1, 0xe1, 0xcd, 0x82, 0xf5, 0x83, 0x6d, 0x1f, 0x65, 0xdc, 0x4e, 0x33, 0xb4, 0x02, 0x9d, + 0xa9, 0x0e, 0x3d, 0x63, 0xdc, 0xe8, 0x5d, 0x28, 0x9b, 0xe2, 0x46, 0xe2, 0xdf, 0x05, 0xfb, 0x28, + 0x63, 0x5d, 0x68, 0x9d, 0x8c, 0xc6, 0x83, 0x5b, 0x38, 0xd8, 0x1b, 0x1d, 0x0c, 0x2c, 0xff, 0xbf, + 0x6c, 0xf0, 0x5e, 0xcc, 0x0b, 0x81, 0x36, 0xa5, 0xde, 0x74, 0xa9, 0xef, 0x80, 0xab, 0x0a, 0x91, + 0x93, 0x87, 0xd6, 0x6e, 0xa5, 0x4b, 0xf4, 0x58, 0xb1, 0x0f, 0xa1, 0x23, 0xc3, 0xa9, 0x2c, 0x5f, + 0xfb, 0x60, 0x75, 0x9f, 0x5c, 0x8b, 0xd9, 0x16, 0x38, 0x2a, 0xb8, 0x90, 0x33, 0x31, 0x6c, 0x57, + 0x8a, 0x27, 0xc4, 0xd1, 0x11, 0x98, 0x1b, 0x39, 0xdb, 0x81, 0xef, 0x47, 0xd3, 0x24, 0xcd, 0xe5, + 0x24, 0x4a, 0x42, 0xb9, 0x98, 0x04, 0x69, 0x72, 0x1e, 0x47, 0x41, 0x61, 0x22, 0xfa, 0x5b, 0x5a, + 0xb8, 0x8f, 0xb2, 0xa7, 0x46, 0xc4, 0xde, 0x87, 0x0e, 0xde, 0x8e, 0x32, 0xf9, 0x21, 0x65, 0x94, + 0x78, 0x11, 0xe6, 0xd3, 0x5a, 0xc8, 0x3e, 0x81, 0x6e, 0x98, 0xa7, 0xd9, 0x24, 0xcd, 0x08, 0xe7, + 0xf5, 0x9d, 0x3b, 0xf4, 0x1e, 0x4a, 0x04, 0xb6, 0xf7, 0xf2, 0x34, 0x3b, 0xca, 0xb8, 0x13, 0xd2, + 0x5f, 0x4c, 0xfa, 0x49, 0x5d, 0xdb, 0x84, 0xf6, 0x0c, 0x1e, 0x72, 0x28, 0x39, 0xf6, 0x1f, 0x81, + 0xa3, 0x27, 0x30, 0x17, 0xda, 0x87, 0x47, 0x87, 0x23, 0x0d, 0xed, 0xee, 0xc1, 0xc1, 0xc0, 0x42, + 0xd6, 0xde, 0xee, 0x78, 0x77, 0x60, 0xe3, 0x68, 0xfc, 0x8b, 0xe3, 0xd1, 0xa0, 0xe5, 0xff, 0x95, + 0x05, 0x6e, 0xe9, 0xbf, 0xd9, 0x47, 0xe8, 0x78, 0xc9, 0xff, 0x9b, 0xe7, 0x4b, 0x45, 0x4b, 0x2d, + 0x11, 0xe3, 0xa5, 0x1c, 0x2d, 0x86, 0x90, 0x28, 0x3d, 0x3a, 0x11, 0xf5, 0x34, 0xb0, 0xd5, 0xa8, + 0x39, 0x30, 0xa3, 0x4d, 0x13, 0x69, 0x32, 0x23, 0x1a, 0xd3, 0x05, 0x46, 0x49, 0x20, 0x51, 0xbb, + 0x63, 0x2e, 0x10, 0xe9, 0xb1, 0xf2, 0xff, 0xc6, 0x06, 0x77, 0x19, 0x8d, 0x3f, 0x06, 0x6f, 0x56, + 0xc2, 0x61, 0x7c, 0xc6, 0x5a, 0x03, 0x23, 0x5e, 0xc9, 0xd9, 0x5d, 0xb0, 0x2f, 0xaf, 0xcc, 0x75, + 0x3a, 0xa8, 0xf5, 0xe5, 0x4b, 0x6e, 0x5f, 0x5e, 0x55, 0x4e, 0xa7, 0xf3, 0xad, 0x4e, 0xe7, 0x01, + 0xdc, 0x0e, 0x62, 0x29, 0x92, 0x49, 0xe5, 0x33, 0xf4, 0xb3, 0x58, 0x27, 0xf6, 0xf1, 0xd2, 0x71, + 0x18, 0xc7, 0xd9, 0xad, 0xc2, 0xe3, 0x07, 0xd0, 0x09, 0x65, 0x5c, 0x88, 0x7a, 0xcd, 0x77, 0x94, + 0x8b, 0x20, 0x96, 0x7b, 0xc8, 0xe6, 0x5a, 0xca, 0xb6, 0xc0, 0x2d, 0x53, 0x05, 0x53, 0xe9, 0x51, + 0xf1, 0x50, 0xde, 0x03, 0x5f, 0x4a, 0x2b, 0x98, 0xa1, 0x06, 0xb3, 0xff, 0x29, 0xb4, 0xbe, 0x7c, + 0x79, 0x62, 0xce, 0x6a, 0xbd, 0x72, 0xd6, 0x12, 0x6c, 0xbb, 0x02, 0xdb, 0xff, 0xef, 0x16, 0x74, + 0x8d, 0x6f, 0xc0, 0x7d, 0xcf, 0x97, 0x89, 0x2e, 0x0e, 0x9b, 0xf1, 0x79, 0xe9, 0x64, 0xea, 0xfd, + 0x81, 0xd6, 0xb7, 0xf7, 0x07, 0xd8, 0xcf, 0xa0, 0x9f, 0x69, 0x59, 0xdd, 0x2d, 0xbd, 0x5d, 0x9f, + 0x63, 0xfe, 0xd2, 0xbc, 0x5e, 0x56, 0x11, 0x68, 0x0c, 0x54, 0x52, 0x15, 0x62, 0x4a, 0x57, 0xd4, + 0xe7, 0x5d, 0xa4, 0xc7, 0x62, 0xfa, 0x1a, 0xe7, 0xf4, 0x1b, 0xf8, 0x18, 0x4c, 0xe8, 0xd3, 0x6c, + 0xd8, 0x27, 0xbf, 0x81, 0x7e, 0xa9, 0xee, 0x32, 0xd6, 0x9a, 0x2e, 0xe3, 0x07, 0xe0, 0x05, 0xe9, + 0x6c, 0x16, 0x91, 0x6c, 0xdd, 0x24, 0xac, 0xc4, 0x18, 0x2b, 0xff, 0xcf, 0x2d, 0xe8, 0x9a, 0xd3, + 0xb2, 0x1e, 0x74, 0xf7, 0x46, 0xcf, 0x76, 0x4f, 0x0f, 0xd0, 0x6b, 0x01, 0x38, 0x4f, 0xf6, 0x0f, + 0x77, 0xf9, 0x2f, 0x06, 0x16, 0x3e, 0xb3, 0xfd, 0xc3, 0xf1, 0xc0, 0x66, 0x1e, 0x74, 0x9e, 0x1d, + 0x1c, 0xed, 0x8e, 0x07, 0x2d, 0x7c, 0x67, 0x4f, 0x8e, 0x8e, 0x0e, 0x06, 0x6d, 0xd6, 0x07, 0x77, + 0x6f, 0x77, 0x3c, 0x1a, 0xef, 0xbf, 0x18, 0x0d, 0x3a, 0xa8, 0xfb, 0x7c, 0x74, 0x34, 0x70, 0x70, + 0x70, 0xba, 0xbf, 0x37, 0xe8, 0xa2, 0xfc, 0x78, 0xf7, 0xe4, 0xe4, 0xe7, 0x47, 0x7c, 0x6f, 0xe0, + 0xe2, 0x77, 0x4f, 0xc6, 0x7c, 0xff, 0xf0, 0xf9, 0xc0, 0xc3, 0xf1, 0xd1, 0x93, 0x2f, 0x46, 0x4f, + 0xc7, 0x03, 0xf0, 0x3f, 0x85, 0x5e, 0x0d, 0x41, 0x9c, 0xcd, 0x47, 0xcf, 0x06, 0xb7, 0x70, 0xc9, + 0x97, 0xbb, 0x07, 0xa7, 0xa3, 0x81, 0xc5, 0xd6, 0x01, 0x68, 0x38, 0x39, 0xd8, 0x3d, 0x7c, 0x3e, + 0xb0, 0xfd, 0xdf, 0x06, 0xf7, 0x34, 0x0a, 0x9f, 0xc4, 0x69, 0x70, 0x89, 0x86, 0x71, 0x26, 0x94, + 0x34, 0xa1, 0x9e, 0xc6, 0x18, 0x8b, 0xc8, 0x28, 0x95, 0xb9, 0x7b, 0x43, 0xf9, 0x87, 0xd0, 0x3d, + 0x8d, 0xc2, 0x63, 0x11, 0x5c, 0xa2, 0xcf, 0x39, 0xc3, 0xf9, 0x13, 0x15, 0x7d, 0x2d, 0x8d, 0x1b, + 0xf6, 0x88, 0x73, 0x12, 0x7d, 0x2d, 0xd9, 0xfb, 0xe0, 0x10, 0x51, 0x26, 0x65, 0x64, 0xcb, 0xe5, + 0x9a, 0xdc, 0xc8, 0xfc, 0xbf, 0xb4, 0x96, 0x7b, 0xa7, 0x7e, 0xc1, 0x7d, 0x68, 0x67, 0x22, 0xb8, + 0x34, 0x8e, 0xa6, 0x67, 0xe6, 0xe0, 0x7a, 0x9c, 0x04, 0xec, 0x01, 0xb8, 0xc6, 0x40, 0xca, 0x0f, + 0xf7, 0x6a, 0x96, 0xc4, 0x97, 0xc2, 0xe6, 0xd5, 0xb5, 0x9a, 0x57, 0x87, 0xc7, 0x53, 0x59, 0x1c, + 0x51, 0xe9, 0xd7, 0x42, 0x87, 0xa4, 0x29, 0xff, 0x27, 0x00, 0x55, 0x33, 0xe6, 0x86, 0xca, 0xe1, + 0x0e, 0x74, 0x44, 0x1c, 0x19, 0x54, 0x3c, 0xae, 0x09, 0xff, 0x10, 0x7a, 0xb5, 0x16, 0x0e, 0xda, + 0x93, 0x88, 0xe3, 0xc9, 0xa5, 0xbc, 0x56, 0x34, 0xd7, 0xe5, 0x5d, 0x11, 0xc7, 0x5f, 0xca, 0x6b, + 0x85, 0xce, 0x5f, 0x77, 0x7f, 0xec, 0x95, 0x76, 0x02, 0x4d, 0xe5, 0x5a, 0xe8, 0xff, 0x18, 0x1c, + 0xdd, 0x63, 0xa8, 0x99, 0xb3, 0xf5, 0xda, 0x90, 0xf9, 0xb9, 0xd9, 0x33, 0x75, 0x24, 0xd8, 0xc7, + 0xa6, 0xcb, 0xa4, 0x74, 0x4f, 0xcb, 0xaa, 0xd2, 0x48, 0xad, 0x64, 0x1a, 0x4c, 0xa4, 0xec, 0xef, + 0x81, 0xfb, 0xc6, 0xbe, 0x9d, 0x01, 0xc0, 0xae, 0x00, 0xb8, 0xa1, 0x93, 0xe7, 0xff, 0x12, 0xa0, + 0xea, 0x46, 0x99, 0xd7, 0xa5, 0xbf, 0x82, 0xaf, 0xeb, 0x21, 0x96, 0x7c, 0x51, 0x1c, 0xe6, 0x32, + 0x69, 0x9c, 0xba, 0xea, 0x5f, 0x2d, 0xe5, 0x6c, 0x13, 0xda, 0xd4, 0x64, 0x6b, 0x55, 0xde, 0x6f, + 0xd9, 0x61, 0x23, 0x89, 0xbf, 0x80, 0x35, 0x1d, 0x89, 0xb9, 0xfc, 0xe3, 0xb9, 0x54, 0x6f, 0xcc, + 0xef, 0xee, 0x01, 0x2c, 0x7d, 0x75, 0xd9, 0x2e, 0xac, 0x71, 0xd0, 0x08, 0xce, 0x23, 0x19, 0x87, + 0xe5, 0x69, 0x0c, 0x85, 0x97, 0xac, 0x23, 0x74, 0x5b, 0xf7, 0x54, 0x88, 0xf0, 0x7f, 0x17, 0xfa, + 0xe5, 0xca, 0xd4, 0xb4, 0xf8, 0x78, 0x99, 0x25, 0x68, 0x8c, 0x75, 0xad, 0xa4, 0x55, 0x0e, 0xd3, + 0x50, 0x3e, 0xb1, 0x87, 0x56, 0x99, 0x28, 0xf8, 0xff, 0xd6, 0x2a, 0x67, 0x9b, 0x1a, 0xbe, 0x91, + 0x7b, 0x5a, 0xab, 0xb9, 0x67, 0x33, 0x8f, 0xb3, 0x7f, 0xa3, 0x3c, 0xee, 0xa7, 0xe0, 0x85, 0x94, + 0xcc, 0x44, 0x57, 0xa5, 0x5f, 0xde, 0x58, 0x4d, 0x5c, 0x4c, 0xba, 0x13, 0x5d, 0x49, 0x5e, 0x29, + 0xe3, 0x5e, 0x8a, 0xf4, 0x52, 0x26, 0xd1, 0xd7, 0xd4, 0xa4, 0xc0, 0x33, 0x57, 0x8c, 0xaa, 0xe3, + 0xa3, 0x73, 0x1a, 0xd3, 0xf1, 0x29, 0x9b, 0x57, 0x4e, 0xd5, 0xbc, 0x42, 0x3c, 0xe7, 0x99, 0x92, + 0x79, 0x51, 0x66, 0xc1, 0x9a, 0x5a, 0x26, 0x8c, 0x9e, 0xd1, 0xc5, 0x84, 0xf1, 0x5d, 0xe8, 0x27, + 0x69, 0x32, 0x49, 0xe6, 0x71, 0x8c, 0x79, 0xba, 0xe9, 0x53, 0xf6, 0x92, 0x34, 0x39, 0x34, 0x2c, + 0xf6, 0x10, 0xbe, 0x57, 0x57, 0xd1, 0xf6, 0xdc, 0xd3, 0x6d, 0x8e, 0x9a, 0x1e, 0x59, 0xfd, 0x16, + 0x0c, 0xd2, 0xb3, 0x5f, 0xca, 0xa0, 0x20, 0xc4, 0x26, 0x64, 0xc8, 0x7d, 0x1d, 0x9d, 0x35, 0x1f, + 0x21, 0x3a, 0x14, 0x33, 0xe9, 0x7f, 0x0e, 0xde, 0x12, 0x84, 0x5a, 0x36, 0xe4, 0x41, 0x67, 0xff, + 0x70, 0x6f, 0xf4, 0x87, 0x03, 0x0b, 0x5d, 0x39, 0x1f, 0xbd, 0x1c, 0xf1, 0x93, 0xd1, 0xc0, 0x46, + 0x37, 0xbb, 0x37, 0x3a, 0x18, 0x8d, 0x47, 0x83, 0xd6, 0x17, 0x6d, 0xb7, 0x3b, 0x70, 0xb9, 0x2b, + 0x17, 0x59, 0x1c, 0x05, 0x51, 0xe1, 0x9f, 0x00, 0x54, 0x89, 0x1b, 0xfa, 0x9b, 0x6a, 0x6d, 0x7d, + 0xa3, 0x6e, 0x61, 0x56, 0xc5, 0x94, 0xd2, 0x98, 0x9a, 0xfd, 0xba, 0x94, 0x52, 0xcb, 0xfd, 0x53, + 0x70, 0x5f, 0x88, 0xec, 0x95, 0x12, 0xac, 0xbf, 0x2c, 0xb4, 0xe7, 0xa6, 0xed, 0x64, 0x62, 0xf4, + 0x07, 0xd0, 0x35, 0x2e, 0xcf, 0xbc, 0x9a, 0x86, 0x3b, 0x2c, 0x65, 0xfe, 0x9f, 0x59, 0x70, 0xe7, + 0x45, 0x7a, 0x25, 0x97, 0x69, 0xca, 0xb1, 0xb8, 0x8e, 0x53, 0x11, 0x7e, 0x8b, 0x21, 0xfe, 0x08, + 0x40, 0xa5, 0xf3, 0x3c, 0x90, 0x93, 0xe9, 0xb2, 0xdb, 0xe5, 0x69, 0xce, 0x73, 0xd3, 0x58, 0x97, + 0xaa, 0x20, 0x61, 0x4b, 0x3f, 0x3e, 0xa4, 0x51, 0xf4, 0x7d, 0x70, 0x8a, 0x45, 0x52, 0x35, 0xd7, + 0x3a, 0x05, 0xd6, 0xbf, 0xfe, 0x53, 0xf0, 0xc6, 0x0b, 0xaa, 0x0a, 0xe7, 0xaa, 0x11, 0x78, 0xad, + 0x37, 0x04, 0x5e, 0x7b, 0x25, 0xf0, 0xfe, 0xa7, 0x05, 0xbd, 0x5a, 0xfe, 0xc4, 0xde, 0x85, 0x76, + 0xb1, 0x48, 0x9a, 0x5d, 0xe9, 0x72, 0x11, 0x4e, 0x22, 0xb4, 0x37, 0x2c, 0x19, 0x85, 0x52, 0xd1, + 0x34, 0x91, 0xa1, 0xf9, 0x24, 0x96, 0x91, 0xbb, 0x86, 0xc5, 0x0e, 0xe0, 0xb6, 0xf6, 0x24, 0x65, + 0x47, 0xaa, 0x2c, 0x14, 0xde, 0x5b, 0xc9, 0xd7, 0x74, 0xe5, 0xfc, 0xb4, 0xd4, 0xd2, 0xbd, 0x81, + 0xf5, 0x69, 0x83, 0xb9, 0xb1, 0x0b, 0x6f, 0xdd, 0xa0, 0xf6, 0x9d, 0x9a, 0x20, 0xf7, 0x61, 0x6d, + 0xbc, 0x48, 0xc6, 0xd1, 0x4c, 0xaa, 0x42, 0xcc, 0x32, 0x4a, 0x5c, 0x4c, 0x24, 0x68, 0x73, 0xbb, + 0x50, 0xfe, 0x87, 0xd0, 0x3f, 0x96, 0x32, 0xe7, 0x52, 0x65, 0x69, 0xa2, 0x83, 0xb6, 0xa2, 0x43, + 0x9b, 0xb0, 0x63, 0x28, 0xff, 0x8f, 0xc0, 0xc3, 0x6c, 0xfd, 0x89, 0x28, 0x82, 0x8b, 0xef, 0x92, + 0xcd, 0x7f, 0x08, 0xdd, 0x4c, 0x9b, 0x89, 0x49, 0xb0, 0xfb, 0xe4, 0xe3, 0x8c, 0xe9, 0xf0, 0x52, + 0xe8, 0x73, 0x68, 0x1d, 0xce, 0x67, 0xf5, 0x9f, 0x92, 0xda, 0xfa, 0xa7, 0xa4, 0x46, 0xfd, 0x6b, + 0x37, 0xeb, 0x5f, 0xb4, 0xbc, 0xf3, 0x34, 0xff, 0x13, 0x91, 0x87, 0x32, 0x34, 0x45, 0x76, 0xc5, + 0xf0, 0xbf, 0x82, 0x5e, 0x79, 0x33, 0xfb, 0x21, 0xfd, 0x5a, 0x44, 0xa6, 0xb1, 0x1f, 0x36, 0x2c, + 0x45, 0x17, 0xa9, 0x32, 0x09, 0xf7, 0xcb, 0x2b, 0xd5, 0x44, 0x73, 0x65, 0xd3, 0x84, 0x59, 0x56, + 0xde, 0xcf, 0xa0, 0x5f, 0x26, 0xd5, 0x2f, 0x64, 0x21, 0xc8, 0xd8, 0xe2, 0x48, 0x26, 0x35, 0x43, + 0x74, 0x35, 0x63, 0xac, 0xde, 0xd0, 0xee, 0xf5, 0xb7, 0xc1, 0x31, 0x96, 0xcc, 0xa0, 0x1d, 0xa4, + 0xa1, 0x7e, 0x40, 0x1d, 0x4e, 0x63, 0x84, 0x63, 0xa6, 0xa6, 0x65, 0xf0, 0x9c, 0xa9, 0xa9, 0xff, + 0xd7, 0x36, 0xac, 0x3d, 0x11, 0xc1, 0xe5, 0x3c, 0x2b, 0xa3, 0x57, 0xad, 0x32, 0xb2, 0x1a, 0x95, + 0x51, 0xbd, 0x0a, 0xb2, 0x1b, 0x55, 0x50, 0x63, 0x43, 0xad, 0x66, 0xc4, 0x7b, 0x1b, 0xba, 0xf3, + 0x24, 0x5a, 0x94, 0xaf, 0xce, 0xe3, 0x0e, 0x92, 0x63, 0xc5, 0x36, 0xa1, 0x87, 0x0f, 0x33, 0x4a, + 0xa8, 0x1e, 0x22, 0x40, 0x3c, 0x5e, 0x67, 0xe1, 0x4b, 0x17, 0x41, 0x20, 0x95, 0xc2, 0xbc, 0xc5, + 0xe4, 0xd4, 0x9e, 0xe6, 0x7c, 0x29, 0xaf, 0xc9, 0x11, 0xc8, 0x20, 0x97, 0xc5, 0xa4, 0xaa, 0x6d, + 0x3c, 0xcd, 0x41, 0xf1, 0x7b, 0xb0, 0xa6, 0xa4, 0x52, 0x51, 0x9a, 0x4c, 0x28, 0x72, 0x98, 0x12, + 0xb4, 0x6f, 0x98, 0x63, 0xe4, 0xe1, 0x85, 0x8b, 0x24, 0x4d, 0xae, 0x67, 0xe9, 0x5c, 0x99, 0x60, + 0x50, 0x31, 0xfc, 0x01, 0xac, 0x97, 0xd8, 0x68, 0x73, 0xf6, 0x0b, 0x58, 0x1b, 0x2d, 0x32, 0xfa, + 0x99, 0xe0, 0x5b, 0x63, 0x7d, 0x0d, 0x48, 0xbb, 0x01, 0x64, 0x0d, 0x92, 0x16, 0xb5, 0x6c, 0x4a, + 0x48, 0x30, 0xfa, 0xa7, 0xf9, 0x4c, 0x14, 0x25, 0x54, 0x9a, 0xda, 0xf9, 0x27, 0x0b, 0xda, 0xf8, + 0x1a, 0xb0, 0xc0, 0xfc, 0x7d, 0x29, 0xf2, 0xe2, 0x4c, 0x8a, 0x82, 0x35, 0x2c, 0x7f, 0xa3, 0x41, + 0xf9, 0xb7, 0x1e, 0x5b, 0x6c, 0x5b, 0xff, 0x32, 0x51, 0xfe, 0xe0, 0xb2, 0x56, 0xbe, 0x29, 0x7a, + 0x73, 0xab, 0xfa, 0x5b, 0xa4, 0xff, 0x45, 0x1a, 0x25, 0x4f, 0x75, 0xbb, 0x9e, 0xad, 0xbe, 0xc1, + 0xd5, 0x19, 0xec, 0x13, 0x70, 0xf6, 0x15, 0x3e, 0xf6, 0x57, 0x55, 0x29, 0x96, 0xd4, 0xfd, 0x80, + 0x7f, 0x6b, 0xe7, 0x1f, 0x5b, 0xd0, 0xfe, 0x4a, 0xe6, 0x29, 0xfb, 0x31, 0x74, 0x4d, 0x33, 0x8e, + 0xd5, 0x9a, 0x6e, 0x1b, 0x94, 0x4c, 0xac, 0x74, 0xe9, 0x68, 0x95, 0x81, 0x0e, 0x47, 0x55, 0x0d, + 0xcc, 0xaa, 0x5e, 0xe1, 0x2b, 0x9b, 0xfa, 0x1c, 0x06, 0x27, 0x45, 0x2e, 0xc5, 0xac, 0xa6, 0xde, + 0x04, 0xea, 0xa6, 0x82, 0x9a, 0xf0, 0xfa, 0x18, 0x1c, 0xed, 0x51, 0x57, 0x26, 0xac, 0xd6, 0xc6, + 0xa4, 0xfc, 0x00, 0x7a, 0x27, 0x17, 0xe9, 0x3c, 0x0e, 0x4f, 0x64, 0x7e, 0x25, 0x59, 0xad, 0x21, + 0xbe, 0x51, 0x1b, 0xfb, 0xb7, 0xd8, 0x16, 0x80, 0x76, 0x1a, 0xa7, 0x51, 0xa8, 0x58, 0x17, 0x65, + 0x87, 0xf3, 0x99, 0xfe, 0x68, 0xcd, 0x9b, 0x68, 0xcd, 0x9a, 0x63, 0x7d, 0x93, 0xe6, 0x67, 0xb0, + 0xf6, 0x94, 0x02, 0xcf, 0x51, 0xbe, 0x7b, 0x96, 0xe6, 0x05, 0x5b, 0x6d, 0x8a, 0x6f, 0xac, 0x32, + 0xfc, 0x5b, 0xec, 0x31, 0xb8, 0xe3, 0xfc, 0x5a, 0xeb, 0x7f, 0xcf, 0xc4, 0xa3, 0x6a, 0xbd, 0x1b, + 0x4e, 0xb9, 0xf3, 0x0f, 0x2d, 0x70, 0x7e, 0x9e, 0xe6, 0x97, 0x32, 0x67, 0x0f, 0xc1, 0xa1, 0x26, + 0x86, 0x31, 0xa3, 0x65, 0x43, 0xe3, 0xa6, 0x85, 0xde, 0x07, 0x8f, 0x40, 0x19, 0x0b, 0x75, 0xa9, + 0xaf, 0x8a, 0x7e, 0x39, 0xd7, 0xb8, 0xe8, 0x4c, 0x95, 0xee, 0x75, 0x5d, 0x5f, 0xd4, 0xb2, 0xa7, + 0xd3, 0xe8, 0x2c, 0x6c, 0x74, 0x75, 0x9b, 0xe0, 0x04, 0x4d, 0xf3, 0xb1, 0xc5, 0x3e, 0x82, 0xf6, + 0x89, 0x3e, 0x29, 0x2a, 0x55, 0xbf, 0x23, 0x6e, 0xac, 0x97, 0x8c, 0xe5, 0x97, 0x1f, 0x81, 0xa3, + 0xd3, 0x18, 0x7d, 0xcc, 0x46, 0x6e, 0xbe, 0x31, 0xa8, 0xb3, 0xcc, 0x84, 0x4f, 0xc1, 0xd1, 0xcf, + 0x5c, 0x4f, 0x68, 0xb8, 0xc3, 0x0d, 0x56, 0x67, 0x95, 0xc6, 0xcc, 0x3e, 0x02, 0x47, 0xfb, 0x01, + 0x3d, 0xa5, 0xe1, 0x13, 0xf4, 0x41, 0xb5, 0x17, 0xd6, 0x06, 0xcc, 0x65, 0x20, 0xa3, 0x5a, 0xa2, + 0xc3, 0xca, 0xc3, 0xdd, 0xf0, 0x0a, 0x3f, 0x87, 0xb5, 0x46, 0x52, 0xc4, 0x86, 0x04, 0xf8, 0x0d, + 0x79, 0xd2, 0xea, 0xe4, 0x27, 0x83, 0x7f, 0xf9, 0xe6, 0x9e, 0xf5, 0xaf, 0xdf, 0xdc, 0xb3, 0xfe, + 0xfd, 0x9b, 0x7b, 0xd6, 0xaf, 0xfe, 0xe3, 0xde, 0xad, 0x33, 0x87, 0xfe, 0xf3, 0xe2, 0xb3, 0xff, + 0x0d, 0x00, 0x00, 0xff, 0xff, 0xe6, 0xa6, 0xd7, 0x8c, 0xbd, 0x21, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -7744,55 +7733,50 @@ func (m *BackupRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPb(dAtA, i, uint64(m.ReadTs)) } - if m.GroupId != 0 { + if m.SinceTs != 0 { dAtA[i] = 0x10 i++ + i = encodeVarintPb(dAtA, i, uint64(m.SinceTs)) + } + if m.GroupId != 0 { + dAtA[i] = 0x18 + i++ i = encodeVarintPb(dAtA, i, uint64(m.GroupId)) } if len(m.UnixTs) > 0 { - dAtA[i] = 0x1a + dAtA[i] = 0x22 i++ i = encodeVarintPb(dAtA, i, uint64(len(m.UnixTs))) i += copy(dAtA[i:], m.UnixTs) } if len(m.Destination) > 0 { - dAtA[i] = 0x22 + dAtA[i] = 0x2a i++ i = encodeVarintPb(dAtA, i, uint64(len(m.Destination))) i += copy(dAtA[i:], m.Destination) } if len(m.AccessKey) > 0 { - dAtA[i] = 0x2a + dAtA[i] = 0x32 i++ i = encodeVarintPb(dAtA, i, uint64(len(m.AccessKey))) i += copy(dAtA[i:], m.AccessKey) } if len(m.SecretKey) > 0 { - dAtA[i] = 0x32 + dAtA[i] = 0x3a i++ i = encodeVarintPb(dAtA, i, uint64(len(m.SecretKey))) i += copy(dAtA[i:], m.SecretKey) } if len(m.SessionToken) > 0 { - dAtA[i] = 0x3a + dAtA[i] = 0x42 i++ i = encodeVarintPb(dAtA, i, uint64(len(m.SessionToken))) i += copy(dAtA[i:], m.SessionToken) } if m.Anonymous { - dAtA[i] = 0x40 - i++ - if m.Anonymous { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i++ - } - if m.ForceFull { dAtA[i] = 0x48 i++ - if m.ForceFull { + if m.Anonymous { dAtA[i] = 1 } else { dAtA[i] = 0 @@ -7820,11 +7804,6 @@ func (m *BackupResponse) MarshalTo(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.Since != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintPb(dAtA, i, uint64(m.Since)) - } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } @@ -9219,6 +9198,9 @@ func (m *BackupRequest) Size() (n int) { if m.ReadTs != 0 { n += 1 + sovPb(uint64(m.ReadTs)) } + if m.SinceTs != 0 { + n += 1 + sovPb(uint64(m.SinceTs)) + } if m.GroupId != 0 { n += 1 + sovPb(uint64(m.GroupId)) } @@ -9245,9 +9227,6 @@ func (m *BackupRequest) Size() (n int) { if m.Anonymous { n += 2 } - if m.ForceFull { - n += 2 - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -9260,9 +9239,6 @@ func (m *BackupResponse) Size() (n int) { } var l int _ = l - if m.Since != 0 { - n += 1 + sovPb(uint64(m.Since)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -17332,6 +17308,25 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } } case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SinceTs", wireType) + } + m.SinceTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SinceTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType) } @@ -17350,7 +17345,7 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { break } } - case 3: + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UnixTs", wireType) } @@ -17382,7 +17377,7 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } m.UnixTs = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Destination", wireType) } @@ -17414,7 +17409,7 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } m.Destination = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", wireType) } @@ -17446,7 +17441,7 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } m.AccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: + case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SecretKey", wireType) } @@ -17478,7 +17473,7 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } m.SecretKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SessionToken", wireType) } @@ -17510,7 +17505,7 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } m.SessionToken = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: + case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Anonymous", wireType) } @@ -17530,26 +17525,6 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } } m.Anonymous = bool(v != 0) - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ForceFull", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ForceFull = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPb(dAtA[iNdEx:]) @@ -17604,25 +17579,6 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: BackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Since", wireType) - } - m.Since = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Since |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipPb(dAtA[iNdEx:]) diff --git a/worker/backup_ee.go b/worker/backup_ee.go index 85922fc697e..5cfce551c6c 100644 --- a/worker/backup_ee.go +++ b/worker/backup_ee.go @@ -28,12 +28,7 @@ func (w *grpcWorker) Backup(ctx context.Context, req *pb.BackupRequest) ( *pb.BackupResponse, error) { glog.V(2).Infof("Received backup request via Grpc: %+v", req) - res, err := backupCurrentGroup(ctx, req) - if err != nil { - return nil, err - } - - return res, nil + return backupCurrentGroup(ctx, req) } func backupCurrentGroup(ctx context.Context, req *pb.BackupRequest) ( @@ -54,8 +49,8 @@ func backupCurrentGroup(ctx context.Context, req *pb.BackupRequest) ( return nil, err } - br := &backup.Request{DB: pstore, Backup: req} - return br.Process(ctx) + bp := &backup.Processor{DB: pstore, Request: req} + return bp.WriteBackup(ctx) } // BackupGroup backs up the group specified in the backup request. @@ -76,6 +71,5 @@ func BackupGroup(ctx context.Context, in *pb.BackupRequest) (*pb.BackupResponse, return nil, err } - glog.V(2).Infof("Backup request to gid=%d, since=%d. OK\n", in.GroupId, res.Since) return res, nil }