func ExampleClient_PutMulti() {
ctx := context.Background()
client, _ := datastore.NewClient(ctx, "my-proj")
// [START batch_upsert]
tasks := []*Task{
{
Type: "Personal",
Done: false,
Priority: 4,
Description: "Learn Cloud Datastore",
},
{
Type: "Personal",
Done: false,
Priority: 5,
Description: "Integrate Cloud Datastore",
},
}
keys := []*datastore.Key{
datastore.NewIncompleteKey(ctx, "Task", nil),
datastore.NewIncompleteKey(ctx, "Task", nil),
}
keys, err := client.PutMulti(ctx, keys, tasks)
// [END batch_upsert]
_ = err // Make sure you check err.
_ = keys // keys now has the complete keys for the newly stored tasks.
}
// LogRunComplete logs the end of a completed (failed of finished) run of
// a coduno testrun
func LogRunComplete(pKey *datastore.Key, build *BuildData, in,
out, extra string, exit error, prepLog string, stats syscall.Rusage) {
tx, err := datastore.NewTransaction(ctx)
if err != nil {
fmt.Fprintf(os.Stderr, "LogRunComplete: Could not get transaction!")
}
build.EndTime = time.Now()
if exit != nil {
build.Status = "failed"
} else {
build.Status = "good"
}
_, err = tx.Put(pKey, build)
if err != nil {
fmt.Fprintf(os.Stderr, "LogRunComplete: Putting build failed!")
tx.Rollback()
return
}
data := &LogData{in, out, extra, prepLog, stats}
k := datastore.NewIncompleteKey(ctx, buildKind, pKey)
_, err = tx.Put(k, data)
if err != nil {
fmt.Fprintf(os.Stderr, "LogRunComplete: Putting data failed!")
tx.Rollback()
return
}
tx.Commit()
}
func ExampleNewIncompleteKey() {
ctx := context.Background()
// [START incomplete_key]
taskKey := datastore.NewIncompleteKey(ctx, "Task", nil)
// [END incomplete_key]
_ = taskKey // Use the task key for datastore operations.
}
func ExamplePut() {
ctx := context.Background()
client, err := datastore.NewClient(ctx, "project-id")
if err != nil {
log.Fatal(err)
}
type Article struct {
Title string
Description string
Body string `datastore:",noindex"`
Author *datastore.Key
PublishedAt time.Time
}
newKey := datastore.NewIncompleteKey(ctx, "Article", nil)
_, err = client.Put(ctx, newKey, &Article{
Title: "The title of the article",
Description: "The description of the article...",
Body: "...",
Author: datastore.NewKey(ctx, "Author", "jbd", 0, nil),
PublishedAt: time.Now(),
})
if err != nil {
log.Fatal(err)
}
}
// AddTask adds a task with the given description to the datastore,
// returning the key of the newly created entity.
func AddTask(ctx context.Context, client *datastore.Client, desc string) (*datastore.Key, error) {
task := &Task{
Desc: desc,
Created: time.Now(),
}
key := datastore.NewIncompleteKey(ctx, "Task", nil)
return client.Put(ctx, key, task)
}
// AddBook saves a given book, assigning it a new ID.
func (db *datastoreDB) AddBook(b *Book) (id int64, err error) {
ctx := context.Background()
k := datastore.NewIncompleteKey(ctx, "Book", nil)
k, err = db.client.Put(ctx, k, b)
if err != nil {
return 0, fmt.Errorf("datastoredb: could not put Book: %v", err)
}
return k.ID(), nil
}
// LogBuildStart sends info to the datastore, informing that a new build
// started
func LogBuildStart(challenge string, commit string, user string) (*datastore.Key, *BuildData) {
key := datastore.NewIncompleteKey(ctx, buildKind, nil)
build := &BuildData{challenge, user, commit, "started", time.Now(), time.Unix(0, 0)}
key, err := datastore.Put(ctx, key, build)
if err != nil {
fmt.Fprintf(os.Stderr, "LogBuildStart: %v", err)
}
return key, build
}
// Save will put this AccessToken into Datastore using the given key.
func (x AccessToken) Save(ctx context.Context, key ...*datastore.Key) (*datastore.Key, error) {
if len(key) > 1 {
panic("zero or one key expected")
}
if len(key) == 1 && key[0] != nil {
return datastore.Put(ctx, key[0], &x)
}
return datastore.Put(ctx, datastore.NewIncompleteKey(ctx, AccessTokenKind, nil), &x)
}
func ExampleClient_Put_upsert() {
ctx := context.Background()
client, _ := datastore.NewClient(ctx, "my-proj")
task := &Task{} // Populated with appropriate data.
key := datastore.NewIncompleteKey(ctx, "Task", nil)
// [START upsert]
key, err := client.Put(ctx, key, task)
// [END upsert]
_ = err // Make sure you check err.
_ = key // key is the complete key for the newly stored task
}
func recordVisit(ctx context.Context, now time.Time, userIP string) error {
v := &visit{
Timestamp: now,
UserIP: userIP,
}
k := datastore.NewIncompleteKey(ctx, "Visit", nil)
_, err := datastoreClient.Put(ctx, k, v)
return err
}
// Put installs the Repository in the Client's datastore.
func (r *Repository) Put(c *Client) error {
key := datastore.NewIncompleteKey(c.ctx, repositoryKind, nil)
key, err := c.datastore.Put(c.ctx, key, r)
if err != nil {
return err
}
r.key = key
return nil
}
func example() {
// [START master_slave_data_definition_code]
g := Greeting{ /* ... */ }
key := datastore.NewIncompleteKey(ctx, "Greeting", nil)
// [END master_slave_data_definition_code]
// [START master_slave_query_code]
q := datastore.NewQuery("Greeting").Order("-Date").Limit(10)
// [END master_slave_query_code]
_ = g
_ = key
_ = q
}
func example2() {
// [START high_replication_data_definition_code]
g := Greeting{ /* ... */ }
key := datastore.NewIncompleteKey(ctx, "Greeting", guestbookKey(ctx))
// [END high_replication_data_definition_code]
// [START high_replication_query_code]
q := datastore.NewQuery("Greeting").Ancestor(guestbookKey(ctx)).Order("-Date").Limit(10)
// [END high_replication_query_code]
_ = g
_ = key
_ = q
}
func ExampleClient_Put() {
ctx := context.Background()
client, _ := datastore.NewClient(ctx, "my-proj")
// [START entity_with_parent]
parentKey := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
key := datastore.NewIncompleteKey(ctx, "Task", parentKey)
task := Task{
Type: "Personal",
Done: false,
Priority: 4,
Description: "Learn Cloud Datastore",
}
// A complete key is assigned to the entity when it is Put.
var err error
key, err = client.Put(ctx, key, &task)
// [END entity_with_parent]
_ = err // Make sure you check err.
}
func putAuthorizedKey(ak *AuthorizedKey, username string) (err error) {
ctx, err := connect()
if err != nil {
return
}
var coder Coder
it := datastore.NewQuery(coderKind).Filter("Nickname =", username).Limit(1).Run(ctx)
ck, err := it.Next(&coder)
if err != nil {
return
}
ak.Coder = ck
dk := datastore.NewIncompleteKey(ctx, keyKind, nil)
_, err = datastore.Put(ctx, dk, ak)
return
}
func (fe *FeServiceImpl) AddBiosphere(ctx context.Context, q *api.AddBiosphereQ) (*api.AddBiosphereS, error) {
ctx = TraceStart(ctx, "/frontend.AddBiosphere")
defer TraceEnd(ctx, fe.ServerCred)
if q.Auth == nil {
return nil, errors.New("AddBiosphere requires auth")
}
canWrite, err := fe.isWriteAuthorized(ctx, q.Auth)
if err != nil {
return nil, err
}
if !canWrite {
return nil, errors.New("UI must disallow unauthorized actions")
}
client, err := fe.AuthDatastore(ctx)
if err != nil {
return nil, err
}
valid, err := fe.isValidNewConfig(ctx, client, q.Config)
if err != nil {
return nil, err
}
if !valid || q.TestOnly {
return &api.AddBiosphereS{Success: valid}, nil
}
envBlob, err := proto.Marshal(q.Config.Env)
if err != nil {
return nil, err
}
key := datastore.NewIncompleteKey(ctx, "BiosphereMeta", nil)
meta := &BiosphereMeta{
Name: q.Config.Name,
Nx: q.Config.Nx,
Ny: q.Config.Ny,
Env: envBlob,
}
key, err = client.Put(ctx, key, meta)
if err != nil {
return nil, err
}
if q.Config.Env.StorageFileId != "" {
bsTopo := NewCylinderTopology(uint64(key.ID()), int(meta.Nx), int(meta.Ny))
err = fe.expandStorageToSnapshot(ctx, bsTopo, q.Config.Env.StorageFileId)
if err != nil {
log.Printf("ERROR: Failed to initialize with snapshot %v", err)
log.Printf("Deleting biosphere entry %v", key)
dsErr := client.Delete(ctx, key)
if dsErr != nil {
log.Printf("ERROR: Failed to delete BiosphereMeta(%v); datastore might have become inconsistent", key)
}
return nil, err
}
}
return &api.AddBiosphereS{
Success: true,
BiosphereDesc: &api.BiosphereDesc{
BiosphereId: uint64(key.ID()),
Name: meta.Name,
NumCores: uint32(meta.Nx*meta.Ny/5) + 1,
},
}, nil
}
// SaveWithParent can be used to save this AccessToken as child of another
// entity.
// This will error if parent == nil.
func (x AccessToken) SaveWithParent(ctx context.Context, parent *datastore.Key) (*datastore.Key, error) {
if parent == nil {
return nil, errors.New("parent key is nil, expected a valid key")
}
return datastore.Put(ctx, datastore.NewIncompleteKey(ctx, AccessTokenKind, parent), &x)
}
// Reads storage file (binary proto of ChunkSnapshot) and copies it as snapshots
// of multiple chunks.
func (fe *FeServiceImpl) expandStorageToSnapshot(ctx context.Context, bsTopo BiosphereTopology, objectName string) error {
ctx = TraceStart(ctx, "/frontend._.getStorage")
defer TraceEnd(ctx, fe.ServerCred)
service, err := fe.AuthStorage(ctx)
res, err := service.Objects.Get(InitialEnvBucket, objectName).Download()
if err != nil {
log.Printf("WARNING: Failed to retrieve cloud storage object containing initial env, %v", err)
return err
}
defer res.Body.Close()
blob, err := ioutil.ReadAll(res.Body)
if err != nil {
log.Printf("ERROR: Failed to download storage %v", err)
return err
}
snapshot := &api.ChunkSnapshot{}
err = proto.Unmarshal(blob, snapshot)
if err != nil {
log.Printf("ERROR: Failed to unmarshal snapshot proto %v", err)
return err
}
// Bin grains.
type ChunkKey struct {
ix, iy int
}
bins := make(map[ChunkKey][]*api.Grain)
for _, grain := range snapshot.Grains {
key := ChunkKey{int(grain.Pos.X), int(grain.Pos.Y)}
localGrain := proto.Clone(grain).(*api.Grain)
localGrain.Pos.X -= float32(key.ix)
localGrain.Pos.Y -= float32(key.iy)
bins[key] = append(bins[key], localGrain)
}
dsClient, err := fe.AuthDatastore(ctx)
if err != nil {
return err
}
// Convert to chunk snapshots and write them.
offsets := bsTopo.GetGlobalOffsets()
for _, chunk := range bsTopo.GetChunkTopos() {
offset := offsets[chunk.ChunkId]
key := ChunkKey{int(offset.X), int(offset.Y)}
// We need to create snapshot even though 0 grains is contained.
chunkSnapshot := &api.ChunkSnapshot{
Grains: bins[key],
}
chunkBlob, err := proto.Marshal(chunkSnapshot)
if err != nil {
log.Printf("ERROR: Failed to marshal chunk snapshot proto %v", err)
return err
}
// TODO: use transaction.
dsKey := datastore.NewIncompleteKey(ctx, "PersistentChunkSnapshot", nil)
_, err = func(ctx context.Context) (*datastore.Key, error) {
ctx = TraceStart(ctx, "/google/datastore.Put")
defer TraceEnd(ctx, fe.ServerCred)
return dsClient.Put(ctx, dsKey, &PersistentChunkSnapshot{
ChunkId: chunk.ChunkId,
Timestamp: 0,
Snapshot: chunkBlob,
})
}(ctx)
if err != nil {
log.Printf("ERROR: Failed to write chunk snapshot %v; snapshot became inconsistent", err)
return err
}
}
return nil
}
func (ds *Datastore) getIKey(i x.Instruction, tablePrefix string) *datastore.Key {
skey := datastore.NewKey(ds.ctx, tablePrefix+"Entity", i.SubjectId, 0, nil)
return datastore.NewIncompleteKey(ds.ctx, tablePrefix+"Instruction", skey)
}
// PutRepository uploads the described repository, and all of its files in dir.
func (c *Client) PutRepository(r *Repository, dir string) error {
// Install the repository, so we can get its key.
if err := r.Put(c); err != nil {
return err
}
dir = filepath.Clean(dir)
// Upload all files to GCS and install their datastore entries.
return filepath.Walk(dir, func(localPath string, info os.FileInfo, err error) error {
log.Printf("Processing %q", localPath)
defer log.Printf("Finished %q", localPath)
if err != nil {
// We don't even try to deal with errors.
return err
}
if info.IsDir() {
// We only need to upload real files.
return nil
}
src, err := os.Open(localPath)
if err != nil {
return err
}
// We upload the file under the r.Root path.
rel, err := filepath.Rel(dir, localPath)
if err != nil {
return err
}
name := path.Join(r.Root, rel)
dst := gcs.NewWriter(c.ctx, c.bucket, name)
if _, err := io.Copy(dst, src); err != nil {
// CloseWithError always returns nil.
dst.CloseWithError(err)
return err
}
if err := dst.Close(); err != nil {
return err
}
// Describe the file in datastore.
file := &File{
Repository: r.key,
Bucket: c.bucket,
Path: name,
}
fileKey := datastore.NewIncompleteKey(c.ctx, fileKind, nil)
if _, err := c.datastore.Put(c.ctx, fileKey, file); err != nil {
return err
}
return nil
})
}