//Update update resource in the db
func (tx *Transaction) Update(resource *schema.Resource) error {
s := resource.Schema()
data := resource.Data()
db := tx.db
q := sq.Update(quote(s.GetDbTableName()))
for _, attr := range s.Properties {
//TODO(nati) support optional value
if _, ok := data[attr.ID]; ok {
handler := db.handler(&attr)
encoded, err := handler.encode(&attr, data[attr.ID])
if err != nil {
return fmt.Errorf("SQL Update encoding error: %s", err)
}
q = q.Set(quote(attr.ID), encoded)
}
}
if s.Parent != "" {
q.Set(s.ParentSchemaPropertyID(), resource.ParentID())
}
q = q.Where(sq.Eq{"id": resource.ID()})
sql, args, err := q.ToSql()
if err != nil {
return err
}
return tx.Exec(sql, args...)
}
func (tl *transactionEventLogger) Update(resource *schema.Resource) error {
err := tl.Transaction.Update(resource)
if err != nil {
return err
}
if !resource.Schema().StateVersioning() {
return tl.logEvent("update", resource, 0)
}
state, err := tl.StateFetch(resource.Schema(), transaction.IDFilter(resource.ID()))
if err != nil {
return err
}
return tl.logEvent("update", resource, state.ConfigVersion)
}
//Update update resource in the db
func (tx *Transaction) Update(resource *schema.Resource) error {
q, err := tx.updateQuery(resource)
if err != nil {
return err
}
sql, args, err := q.ToSql()
if err != nil {
return err
}
if resource.Schema().StateVersioning() {
sql += ", `" + configVersionColumnName + "` = `" + configVersionColumnName + "` + 1"
}
sql += " WHERE id = ?"
args = append(args, resource.ID())
return tx.Exec(sql, args...)
}
//Update update resource in the db
func (tx *Transaction) Update(resource *schema.Resource) error {
db := tx.db
db.load()
s := resource.Schema()
data := resource.Data()
table := db.getTable(s)
for _, rawDataInDB := range table {
dataInDB := rawDataInDB.(map[string]interface{})
if dataInDB["id"] == resource.ID() {
for key, value := range data {
dataInDB[key] = value
}
}
}
db.write()
return nil
}
//StateUpdate update resource state
func (tx *Transaction) StateUpdate(resource *schema.Resource, state *transaction.ResourceState) error {
q, err := tx.updateQuery(resource)
if err != nil {
return err
}
if resource.Schema().StateVersioning() && state != nil {
q = q.Set(quote(stateVersionColumnName), state.StateVersion)
q = q.Set(quote(stateErrorColumnName), state.Error)
q = q.Set(quote(stateColumnName), state.State)
q = q.Set(quote(stateMonitoringColumnName), state.Monitoring)
}
q = q.Where(sq.Eq{"id": resource.ID()})
sql, args, err := q.ToSql()
if err != nil {
return err
}
return tx.Exec(sql, args...)
}
It("Should work", func() {
possibleEvent = gohan_sync.Event{
Action: "this is ignored here",
Data: map[string]interface{}{
"version": float64(1),
"error": "",
"state": "Ni malvarmetas",
},
Key: statePrefix + networkResource.Path(),
}
Expect(srv.StateUpdate(&possibleEvent, server)).To(Succeed())
tx, err := wrappedTestDB.Begin()
Expect(err).ToNot(HaveOccurred())
defer tx.Close()
afterState, err := tx.StateFetch(networkSchema, networkResource.ID(), nil)
Expect(err).ToNot(HaveOccurred())
Expect(tx.Commit()).To(Succeed())
Expect(afterState.ConfigVersion).To(Equal(int64(1)))
Expect(afterState.StateVersion).To(Equal(int64(1)))
Expect(afterState.State).To(Equal("Ni malvarmetas"))
Expect(afterState.Error).To(Equal(""))
Expect(afterState.Monitoring).To(Equal(""))
})
It("Should ignore backwards updates", func() {
possibleEvent = gohan_sync.Event{
Action: "this is ignored here",
Data: map[string]interface{}{
"version": float64(1),
"error": "",
}
_, _, err := tx.List(networkSchema, filter, nil)
Expect(err).To(HaveOccurred())
})
It("Shows related resources", func() {
list, num, err := tx.List(serverSchema, nil, nil)
Expect(err).ToNot(HaveOccurred())
Expect(num).To(Equal(uint64(1)))
Expect(list).To(HaveLen(1))
Expect(list[0].Data()).To(HaveKeyWithValue("network", HaveKeyWithValue("name", networkResource1.Data()["name"])))
Expect(tx.Commit()).To(Succeed())
})
It("Fetches an existing resource", func() {
networkResourceFetched, err := tx.Fetch(networkSchema, transaction.IDFilter(networkResource1.ID()))
Expect(err).ToNot(HaveOccurred())
Expect(networkResourceFetched).To(util.MatchAsJSON(networkResource1))
Expect(tx.Commit()).To(Succeed())
})
It("Updates the resource properly", func() {
By("Not allowing to update some fields")
Expect(networkResource1.Update(map[string]interface{}{"id": "new_id"})).ToNot(Succeed())
By("Updating other fields")
Expect(networkResource1.Update(map[string]interface{}{"name": "new_name"})).To(Succeed())
Expect(tx.Update(networkResource1)).To(Succeed())
Expect(tx.Commit()).To(Succeed())
})
It("Should work", func() {
possibleEvent = gohan_sync.Event{
Action: "this is ignored here",
Data: map[string]interface{}{
"version": float64(1),
"error": "",
"state": "Ni malvarmetas",
},
Key: statePrefix + networkResource.Path(),
}
Expect(srv.StateUpdate(&possibleEvent, server)).To(Succeed())
tx, err := wrappedTestDB.Begin()
Expect(err).ToNot(HaveOccurred())
defer tx.Close()
afterState, err := tx.StateFetch(networkSchema, transaction.IDFilter(networkResource.ID()))
Expect(err).ToNot(HaveOccurred())
Expect(tx.Commit()).To(Succeed())
Expect(afterState.ConfigVersion).To(Equal(int64(1)))
Expect(afterState.StateVersion).To(Equal(int64(1)))
Expect(afterState.State).To(Equal("Ni malvarmetas"))
Expect(afterState.Error).To(Equal(""))
Expect(afterState.Monitoring).To(Equal(""))
})
It("Should ignore backwards updates", func() {
possibleEvent = gohan_sync.Event{
Action: "this is ignored here",
Data: map[string]interface{}{
"version": float64(1),
"error": "",
}
_, _, err := tx.List(networkSchema, filter, nil)
Expect(err).To(HaveOccurred())
})
It("Shows related resources", func() {
list, num, err := tx.List(serverSchema, nil, nil)
Expect(err).ToNot(HaveOccurred())
Expect(num).To(Equal(uint64(1)))
Expect(list).To(HaveLen(1))
Expect(list[0].Data()).To(HaveKeyWithValue("network", HaveKeyWithValue("name", networkResource1.Data()["name"])))
Expect(tx.Commit()).To(Succeed())
})
It("Fetches an existing resource", func() {
networkResourceFetched, err := tx.Fetch(networkSchema, networkResource1.ID(), nil)
Expect(err).ToNot(HaveOccurred())
Expect(networkResourceFetched).To(util.MatchAsJSON(networkResource1))
Expect(tx.Commit()).To(Succeed())
})
It("Updates the resource properly", func() {
By("Not allowing to update some fields")
Expect(networkResource1.Update(map[string]interface{}{"id": "new_id"})).ToNot(Succeed())
By("Updating other fields")
Expect(networkResource1.Update(map[string]interface{}{"name": "new_name"})).To(Succeed())
Expect(tx.Update(networkResource1)).To(Succeed())
Expect(tx.Commit()).To(Succeed())
})