Merge pull request #12266 from Meulengracht/release/2.57

mvo5 · web-flow · commit b3625c0e369c · 2022-10-17T18:17:43.000+02:00
release: port PR 12199 and 12241
diff --git a/client/quota.go b/client/quota.go
@@ -54,10 +54,14 @@ type QuotaCPUSetValues struct {
 	CPUs []int `json:"cpus,omitempty"`
 }
 
+type QuotaJournalRate struct {
+	RateCount  int           `json:"rate-count"`
+	RatePeriod time.Duration `json:"rate-period"`
+}
+
 type QuotaJournalValues struct {
-	Size       quantity.Size `json:"size,omitempty"`
-	RateCount  int           `json:"rate-count,omitempty"`
-	RatePeriod time.Duration `json:"rate-period,omitempty"`
+	Size quantity.Size `json:"size,omitempty"`
+	*QuotaJournalRate
 }
 
 type QuotaValues struct {
diff --git a/client/quota_test.go b/client/quota_test.go
@@ -56,9 +56,11 @@ func (cs *clientSuite) TestEnsureQuotaGroup(c *check.C) {
 		},
 		Threads: 32,
 		Journal: &client.QuotaJournalValues{
-			Size:       quantity.SizeMiB,
-			RateCount:  150,
-			RatePeriod: time.Minute,
+			Size: quantity.SizeMiB,
+			QuotaJournalRate: &client.QuotaJournalRate{
+				RateCount:  150,
+				RatePeriod: time.Minute,
+			},
 		},
 	}
 
diff --git a/cmd/snap/cmd_quota.go b/cmd/snap/cmd_quota.go
@@ -259,8 +259,10 @@ func (x *cmdSetQuota) parseQuotas() (*client.QuotaValues, error) {
 			if err != nil {
 				return nil, fmt.Errorf("cannot parse journal rate limit %q: %v", x.JournalRateLimit, err)
 			}
-			quotaValues.Journal.RateCount = count
-			quotaValues.Journal.RatePeriod = period
+			quotaValues.Journal.QuotaJournalRate = &client.QuotaJournalRate{
+				RateCount:  count,
+				RatePeriod: period,
+			}
 		}
 	}
 
@@ -411,8 +413,10 @@ func (x *cmdQuota) Execute(args []string) (err error) {
 			val := strings.TrimSpace(fmtSize(int64(group.Constraints.Journal.Size)))
 			fmt.Fprintf(w, "  journal-size:\t%s\n", val)
 		}
-		if group.Constraints.Journal.RateCount != 0 && group.Constraints.Journal.RatePeriod != 0 {
-			fmt.Fprintf(w, "  journal-rate:\t%d/%s\n", group.Constraints.Journal.RateCount, group.Constraints.Journal.RatePeriod)
+		if group.Constraints.Journal.QuotaJournalRate != nil {
+			fmt.Fprintf(w, "  journal-rate:\t%d/%s\n",
+				group.Constraints.Journal.RateCount,
+				group.Constraints.Journal.RatePeriod)
 		}
 	}
 
@@ -523,8 +527,11 @@ func (x *cmdQuotas) Execute(args []string) (err error) {
 			if q.Constraints.Journal.Size != 0 {
 				grpConstraints = append(grpConstraints, "journal-size="+strings.TrimSpace(fmtSize(int64(q.Constraints.Journal.Size))))
 			}
-			if q.Constraints.Journal.RateCount != 0 && q.Constraints.Journal.RatePeriod != 0 {
-				grpConstraints = append(grpConstraints, fmt.Sprintf("journal-rate=%d/%s", q.Constraints.Journal.RateCount, q.Constraints.Journal.RatePeriod))
+
+			if q.Constraints.Journal.QuotaJournalRate != nil {
+				grpConstraints = append(grpConstraints,
+					fmt.Sprintf("journal-rate=%d/%s",
+						q.Constraints.Journal.RateCount, q.Constraints.Journal.RatePeriod))
 			}
 		}
 
diff --git a/cmd/snap/cmd_quota_test.go b/cmd/snap/cmd_quota_test.go
@@ -223,6 +223,7 @@ func (s *quotaSuite) TestParseQuotas(c *check.C) {
 		{journalRateLimit: "10/15s", quotas: `{"journal":{"rate-count":10,"rate-period":15000000000}}`},
 		{journalRateLimit: "1500/15ms", quotas: `{"journal":{"rate-count":1500,"rate-period":15000000}}`},
 		{journalRateLimit: "1/15us", quotas: `{"journal":{"rate-count":1,"rate-period":15000}}`},
+		{journalRateLimit: "0/0s", quotas: `{"journal":{"rate-count":0,"rate-period":0}}`},
 
 		// Error cases
 		{cpuMax: "ASD", err: `cannot parse cpu quota string "ASD"`},
@@ -660,11 +661,12 @@ func (s *quotaSuite) TestGetAllQuotaGroups(c *check.C) {
 			{"group-name":"fff","parent":"aaa","constraints":{"memory":1000},"current":{"memory":0}},
 			{"group-name":"xxx","constraints":{"memory":9900},"current":{"memory":10000}},
 			{"group-name":"cp0","constraints":{"memory":9900, "cpu":{"percentage":90}},"current":{"memory":10000}},
-			{"group-name":"cp1","subgroups":["cps0","js0"],"constraints":{"cpu":{"count":2, "percentage":90}}},
+			{"group-name":"cp1","subgroups":["cps0","js0","js1"],"constraints":{"cpu":{"count":2, "percentage":90}}},
 			{"group-name":"cps0","parent":"cp1","constraints":{"cpu":{"percentage":40}}},
 			{"group-name":"cp2","subgroups":["cps1"],"constraints":{"cpu":{"count":2,"percentage":100},"cpu-set":{"cpus":[0,1]}}},
 			{"group-name":"cps1","parent":"cp2","constraints":{"memory":9900,"cpu":{"percentage":50},"cpu-set":{"cpus":[1]}},"current":{"memory":10000}},
-			{"group-name":"js0","parent":"cp1","constraints":{"journal":{"size":1048576,"rate-count":50,"rate-period":60000000000}}}
+			{"group-name":"js0","parent":"cp1","constraints":{"journal":{"size":1048576,"rate-count":50,"rate-period":60000000000}}},
+			{"group-name":"js1","parent":"cp1","constraints":{"journal":{"rate-count":0,"rate-period":0}}}
 			]}`))
 
 	rest, err := main.Parser(main.Client()).ParseArgs([]string{"quotas"})
@@ -677,6 +679,7 @@ cp0              memory=9.9kB,cpu=90%                      memory=10.0kB
 cp1              cpu=2x90%                                 
 cps0     cp1     cpu=40%                                   
 js0      cp1     journal-size=1.05MB,journal-rate=50/1m0s  
+js1      cp1     journal-rate=0/0s                         
 cp2              cpu=2x100%,cpu-set=0,1                    
 cps1     cp2     memory=9.9kB,cpu=50%,cpu-set=1            memory=10.0kB
 ggg              memory=1000B,threads=100                  memory=3000B
diff --git a/daemon/api_quotas.go b/daemon/api_quotas.go
@@ -100,9 +100,13 @@ func createQuotaValues(grp *quota.Group) *client.QuotaValues {
 	}
 	if grp.JournalLimit != nil {
 		constraints.Journal = &client.QuotaJournalValues{
-			Size:       grp.JournalLimit.Size,
-			RateCount:  grp.JournalLimit.RateCount,
-			RatePeriod: grp.JournalLimit.RatePeriod,
+			Size: grp.JournalLimit.Size,
+		}
+		if grp.JournalLimit.RateEnabled {
+			constraints.Journal.QuotaJournalRate = &client.QuotaJournalRate{
+				RateCount:  grp.JournalLimit.RateCount,
+				RatePeriod: grp.JournalLimit.RatePeriod,
+			}
 		}
 	}
 	return &constraints
@@ -208,7 +212,7 @@ func quotaValuesToResources(values client.QuotaValues) quota.Resources {
 		if values.Journal.Size != 0 {
 			resourcesBuilder.WithJournalSize(values.Journal.Size)
 		}
-		if values.Journal.RateCount != 0 && values.Journal.RatePeriod != 0 {
+		if values.Journal.QuotaJournalRate != nil {
 			resourcesBuilder.WithJournalRate(values.Journal.RateCount, values.Journal.RatePeriod)
 		}
 	}
diff --git a/daemon/api_quotas_test.go b/daemon/api_quotas_test.go
@@ -116,9 +116,11 @@ func (s *apiQuotaSuite) TestCreateQuotaValues(c *check.C) {
 		CPUs: []int{0, 1},
 	})
 	c.Check(quotaValues.Journal, check.DeepEquals, &client.QuotaJournalValues{
-		Size:       quantity.SizeMiB,
-		RateCount:  150,
-		RatePeriod: time.Second,
+		Size: quantity.SizeMiB,
+		QuotaJournalRate: &client.QuotaJournalRate{
+			RateCount:  150,
+			RatePeriod: time.Second,
+		},
 	})
 }
 
@@ -259,6 +261,43 @@ func (s *apiQuotaSuite) TestPostEnsureQuotaCreateQuotaConflicts(c *check.C) {
 	c.Assert(createCalled, check.Equals, 2)
 }
 
+func (s *apiQuotaSuite) TestPostEnsureQuotaCreateJournalRateZeroHappy(c *check.C) {
+	var createCalled int
+	r := daemon.MockServicestateCreateQuota(func(st *state.State, name string, parentName string, snaps []string, resourceLimits quota.Resources) (*state.TaskSet, error) {
+		createCalled++
+		c.Check(name, check.Equals, "booze")
+		c.Check(parentName, check.Equals, "foo")
+		c.Check(snaps, check.DeepEquals, []string{"some-snap"})
+		c.Check(resourceLimits, check.DeepEquals, quota.NewResourcesBuilder().WithJournalRate(0, 0).Build())
+		ts := state.NewTaskSet(st.NewTask("foo-quota", "..."))
+		return ts, nil
+	})
+	defer r()
+
+	data, err := json.Marshal(daemon.PostQuotaGroupData{
+		Action:    "ensure",
+		GroupName: "booze",
+		Parent:    "foo",
+		Snaps:     []string{"some-snap"},
+		Constraints: client.QuotaValues{
+			Journal: &client.QuotaJournalValues{
+				QuotaJournalRate: &client.QuotaJournalRate{
+					RateCount:  0,
+					RatePeriod: 0,
+				},
+			},
+		},
+	})
+	c.Assert(err, check.IsNil)
+
+	req, err := http.NewRequest("POST", "/v2/quotas", bytes.NewBuffer(data))
+	c.Assert(err, check.IsNil)
+	rsp := s.asyncReq(c, req, nil)
+	c.Assert(rsp.Status, check.Equals, 202)
+	c.Assert(createCalled, check.Equals, 1)
+	c.Assert(s.ensureSoonCalled, check.Equals, 1)
+}
+
 func (s *apiQuotaSuite) TestPostEnsureQuotaUpdateCpuHappy(c *check.C) {
 	st := s.d.Overlord().State()
 	st.Lock()
@@ -677,6 +716,68 @@ func (s *apiQuotaSuite) TestListQuotas(c *check.C) {
 	c.Check(s.ensureSoonCalled, check.Equals, 0)
 }
 
+func (s *apiQuotaSuite) TestListJournalQuotas(c *check.C) {
+	st := s.d.Overlord().State()
+	st.Lock()
+	err := servicestatetest.MockQuotaInState(st, "foo", "", nil, quota.NewResourcesBuilder().WithJournalSize(64*quantity.SizeMiB).Build())
+	c.Assert(err, check.IsNil)
+	err = servicestatetest.MockQuotaInState(st, "bar", "foo", nil, quota.NewResourcesBuilder().WithJournalRate(100, time.Hour).Build())
+	c.Assert(err, check.IsNil)
+	err = servicestatetest.MockQuotaInState(st, "baz", "foo", nil, quota.NewResourcesBuilder().WithJournalRate(0, 0).Build())
+	c.Assert(err, check.IsNil)
+	st.Unlock()
+
+	calls := 0
+	r := daemon.MockGetQuotaUsage(func(grp *quota.Group) (*client.QuotaValues, error) {
+		calls++
+		return &client.QuotaValues{}, nil
+	})
+	defer r()
+	defer func() {
+		c.Assert(calls, check.Equals, 3)
+	}()
+
+	req, err := http.NewRequest("GET", "/v2/quotas", nil)
+	c.Assert(err, check.IsNil)
+	rsp := s.syncReq(c, req, nil)
+	c.Assert(rsp.Status, check.Equals, 200)
+	c.Assert(rsp.Result, check.FitsTypeOf, []client.QuotaGroupResult{})
+	res := rsp.Result.([]client.QuotaGroupResult)
+	c.Check(res, check.DeepEquals, []client.QuotaGroupResult{
+		{
+			GroupName: "bar",
+			Parent:    "foo",
+			Constraints: &client.QuotaValues{Journal: &client.QuotaJournalValues{
+				QuotaJournalRate: &client.QuotaJournalRate{
+					RateCount:  100,
+					RatePeriod: time.Hour,
+				},
+			}},
+			Current: &client.QuotaValues{},
+		},
+		{
+			GroupName: "baz",
+			Parent:    "foo",
+			Constraints: &client.QuotaValues{Journal: &client.QuotaJournalValues{
+				QuotaJournalRate: &client.QuotaJournalRate{
+					RateCount:  0,
+					RatePeriod: 0,
+				},
+			}},
+			Current: &client.QuotaValues{},
+		},
+		{
+			GroupName: "foo",
+			Subgroups: []string{"bar", "baz"},
+			Constraints: &client.QuotaValues{Journal: &client.QuotaJournalValues{
+				Size: 64 * quantity.SizeMiB,
+			}},
+			Current: &client.QuotaValues{},
+		},
+	})
+	c.Check(s.ensureSoonCalled, check.Equals, 0)
+}
+
 func (s *apiQuotaSuite) TestGetQuota(c *check.C) {
 	st := s.d.Overlord().State()
 	st.Lock()
diff --git a/overlord/devicestate/handlers_gadget.go b/overlord/devicestate/handlers_gadget.go
@@ -232,6 +232,9 @@ func (m *DeviceManager) updateGadgetCommandLine(t *state.Task, st *state.State,
 	if !isUndo {
 		// when updating, command line comes from the new gadget
 		gadgetData, err = pendingGadgetInfo(snapsup, devCtx)
+		if err != nil {
+			return false, err
+		}
 	} else {
 		// but when undoing, we use the current gadget which should have
 		// been restored
diff --git a/overlord/servicestate/quota_handlers.go b/overlord/servicestate/quota_handlers.go
@@ -574,10 +574,16 @@ func ensureSnapServicesForGroup(st *state.State, t *state.Task, grp *quota.Group
 			}
 
 		case "service":
-			// in this case, the only way that a service could have been changed
-			// was if it was moved into or out of a slice, in both cases we need
-			// to restart the service
-			markAppForRestart(app.Snap, app)
+			// When an app has its service file changed, we should restart the app
+			// to take into account that the app might have been moved in/out of a
+			// slice, which means limits may have changed.
+			if app != nil {
+				markAppForRestart(app.Snap, app)
+			}
+
+			// If a quota group has it's service file changed, then it's due to the
+			// journal quota being set. We do not need to do any further changes here
+			// as restart of apps in the journal quota is being handled by case 'journald'
 
 			// TODO: what about sockets and timers? activation units just start
 			// the full unit, so as long as the full unit is restarted we should
diff --git a/overlord/snapstate/handlers.go b/overlord/snapstate/handlers.go
@@ -2358,7 +2358,11 @@ func installModeDisabledServices(st *state.State, snapst *SnapState, currentInfo
 	prevCurrentSvcs := map[string]bool{}
 	if psi := snapst.previousSideInfo(); psi != nil {
 		var prevCurrentInfo *snap.Info
-		if prevCurrentInfo, err = Info(st, snapst.InstanceName(), psi.Revision); prevCurrentInfo != nil {
+		prevCurrentInfo, err = Info(st, snapst.InstanceName(), psi.Revision)
+		if err != nil {
+			return nil, err
+		}
+		if prevCurrentInfo != nil {
 			for _, prevSvc := range prevCurrentInfo.Services() {
 				prevCurrentSvcs[prevSvc.Name] = true
 			}
diff --git a/snap/quota/quota.go b/snap/quota/quota.go
@@ -24,11 +24,13 @@ package quota
 import (
 	"bytes"
 	"fmt"
+	"path/filepath"
 	"runtime"
 	"sort"
 	"time"
 
 	// TODO: move this to snap/quantity? or similar
+	"github.com/snapcore/snapd/dirs"
 	"github.com/snapcore/snapd/gadget/quantity"
 	"github.com/snapcore/snapd/progress"
 	"github.com/snapcore/snapd/snap/naming"
@@ -266,13 +268,30 @@ func (grp *Group) JournalNamespaceName() string {
 	return fmt.Sprintf("snap-%s", grp.Name)
 }
 
-// JournalFileName returns the name of the journal configuration file that should
+// JournalConfFileName returns the name of the journal configuration file that should
 // be used for this quota group. As an example, a group named "foo" will return a name
 // of journald@snap-foo.conf
-func (grp *Group) JournalFileName() string {
+func (grp *Group) JournalConfFileName() string {
 	return fmt.Sprintf("journald@%s.conf", grp.JournalNamespaceName())
 }
 
+// JournalServiceName returns the systemd service name for the quota group.
+func (grp *Group) JournalServiceName() string {
+	return fmt.Sprintf("systemd-journald@%s.service", grp.JournalNamespaceName())
+}
+
+// JournalServiceFile returns the directory specific to this quota group for
+// its journal service unit drop-in.
+func (grp *Group) JournalServiceDropInDir() string {
+	return filepath.Join(dirs.SnapServicesDir, grp.JournalServiceName()+".d")
+}
+
+// JournalServiceDropInFile returns the full path to the journal service unit drop-in
+// file for the quota group.
+func (grp *Group) JournalServiceDropInFile() string {
+	return filepath.Join(grp.JournalServiceDropInDir(), "00-snap.conf")
+}
+
 // groupQuotaAllocations contains information about current quotas of a group
 // and is used by getQuotaAllocations to contain this information. This only accounts
 // for quotas that support inheritance, which currently does not include journal quotas.
diff --git a/snap/quota/quota_test.go b/snap/quota/quota_test.go
@@ -316,10 +316,28 @@ func (ts *quotaTestSuite) TestJournalNamespaceName(c *C) {
 	c.Check(grp.JournalNamespaceName(), Equals, "snap-foo")
 }
 
-func (ts *quotaTestSuite) TestJournalFileName(c *C) {
+func (ts *quotaTestSuite) TestJournalConfFileName(c *C) {
 	grp, err := quota.NewGroup("foo", quota.NewResourcesBuilder().WithMemoryLimit(quantity.SizeMiB).Build())
 	c.Assert(err, IsNil)
-	c.Check(grp.JournalFileName(), Equals, "journald@snap-foo.conf")
+	c.Check(grp.JournalConfFileName(), Equals, "journald@snap-foo.conf")
+}
+
+func (ts *quotaTestSuite) TestJournalServiceName(c *C) {
+	grp, err := quota.NewGroup("foo", quota.NewResourcesBuilder().WithMemoryLimit(quantity.SizeMiB).Build())
+	c.Assert(err, IsNil)
+	c.Check(grp.JournalServiceName(), Equals, "systemd-journald@snap-foo.service")
+}
+
+func (ts *quotaTestSuite) TestJournalServiceDropInDir(c *C) {
+	grp, err := quota.NewGroup("foo", quota.NewResourcesBuilder().WithMemoryLimit(quantity.SizeMiB).Build())
+	c.Assert(err, IsNil)
+	c.Check(grp.JournalServiceDropInDir(), Equals, "/etc/systemd/system/systemd-journald@snap-foo.service.d")
+}
+
+func (ts *quotaTestSuite) TestJournalServiceDropInFile(c *C) {
+	grp, err := quota.NewGroup("foo", quota.NewResourcesBuilder().WithMemoryLimit(quantity.SizeMiB).Build())
+	c.Assert(err, IsNil)
+	c.Check(grp.JournalServiceDropInFile(), Equals, "/etc/systemd/system/systemd-journald@snap-foo.service.d/00-snap.conf")
 }
 
 func (ts *quotaTestSuite) TestResolveCrossReferences(c *C) {
diff --git a/tests/core/persistent-journal-namespace/task.yaml b/tests/core/persistent-journal-namespace/task.yaml
@@ -58,3 +58,12 @@ execute: |
     echo "Journal path was recreated, it shouldn't have happened"
     exit 1
   fi
+
+  # Restart the journal namespace service to make sure that the
+  # folder is not recreated once systemd starts it. See LP1912173
+  # for details.
+  systemctl restart systemd-journald@snap-group-one.service
+
+  # Verify the path was not recreated, this should have happened
+  # immediately, so no need for retries here
+  not test -e /var/log/journal/"$MACHINE_ID".snap-group-one
diff --git a/wrappers/services.go b/wrappers/services.go
diff --git a/wrappers/services_test.go b/wrappers/services_test.go

Original file line number	Diff line number	Diff line change
`@@ -259,8 +259,10 @@ func (x cmdSetQuota) parseQuotas() (client.QuotaValues, error) {`
`259`	`259`	`if err != nil {`
`260`	`260`	`return nil, fmt.Errorf("cannot parse journal rate limit %q: %v", x.JournalRateLimit, err)`
`261`	`261`	`}`
`262`		`- quotaValues.Journal.RateCount = count`
`263`		`- quotaValues.Journal.RatePeriod = period`
	`262`	`+ quotaValues.Journal.QuotaJournalRate = &client.QuotaJournalRate{`
	`263`	`+ RateCount: count,`
	`264`	`+ RatePeriod: period,`
	`265`	`+ }`
`264`	`266`	`}`
`265`	`267`	`}`
`266`	`268`
`@@ -411,8 +413,10 @@ func (x *cmdQuota) Execute(args []string) (err error) {`
`411`	`413`	`val := strings.TrimSpace(fmtSize(int64(group.Constraints.Journal.Size)))`
`412`	`414`	`fmt.Fprintf(w, " journal-size:\t%s\n", val)`
`413`	`415`	`}`
`414`		`- if group.Constraints.Journal.RateCount != 0 && group.Constraints.Journal.RatePeriod != 0 {`
`415`		`- fmt.Fprintf(w, " journal-rate:\t%d/%s\n", group.Constraints.Journal.RateCount, group.Constraints.Journal.RatePeriod)`
	`416`	`+ if group.Constraints.Journal.QuotaJournalRate != nil {`
	`417`	`+ fmt.Fprintf(w, " journal-rate:\t%d/%s\n",`
	`418`	`+ group.Constraints.Journal.RateCount,`
	`419`	`+ group.Constraints.Journal.RatePeriod)`
`416`	`420`	`}`
`417`	`421`	`}`
`418`	`422`
`@@ -523,8 +527,11 @@ func (x *cmdQuotas) Execute(args []string) (err error) {`
`523`	`527`	`if q.Constraints.Journal.Size != 0 {`
`524`	`528`	`grpConstraints = append(grpConstraints, "journal-size="+strings.TrimSpace(fmtSize(int64(q.Constraints.Journal.Size))))`
`525`	`529`	`}`
`526`		`- if q.Constraints.Journal.RateCount != 0 && q.Constraints.Journal.RatePeriod != 0 {`
`527`		`- grpConstraints = append(grpConstraints, fmt.Sprintf("journal-rate=%d/%s", q.Constraints.Journal.RateCount, q.Constraints.Journal.RatePeriod))`
	`530`	`+`
	`531`	`+ if q.Constraints.Journal.QuotaJournalRate != nil {`
	`532`	`+ grpConstraints = append(grpConstraints,`
	`533`	`+ fmt.Sprintf("journal-rate=%d/%s",`
	`534`	`+ q.Constraints.Journal.RateCount, q.Constraints.Journal.RatePeriod))`
`528`	`535`	`}`
`529`	`536`	`}`
`530`	`537`
Original file line number	Diff line number	Diff line change
`@@ -100,9 +100,13 @@ func createQuotaValues(grp quota.Group) client.QuotaValues {`
`100`	`100`	`}`
`101`	`101`	`if grp.JournalLimit != nil {`
`102`	`102`	`constraints.Journal = &client.QuotaJournalValues{`
`103`		`- Size: grp.JournalLimit.Size,`
`104`		`- RateCount: grp.JournalLimit.RateCount,`
`105`		`- RatePeriod: grp.JournalLimit.RatePeriod,`
	`103`	`+ Size: grp.JournalLimit.Size,`
	`104`	`+ }`
	`105`	`+ if grp.JournalLimit.RateEnabled {`
	`106`	`+ constraints.Journal.QuotaJournalRate = &client.QuotaJournalRate{`
	`107`	`+ RateCount: grp.JournalLimit.RateCount,`
	`108`	`+ RatePeriod: grp.JournalLimit.RatePeriod,`
	`109`	`+ }`
`106`	`110`	`}`
`107`	`111`	`}`
`108`	`112`	`return &constraints`
`@@ -208,7 +212,7 @@ func quotaValuesToResources(values client.QuotaValues) quota.Resources {`
`208`	`212`	`if values.Journal.Size != 0 {`
`209`	`213`	`resourcesBuilder.WithJournalSize(values.Journal.Size)`
`210`	`214`	`}`
`211`		`- if values.Journal.RateCount != 0 && values.Journal.RatePeriod != 0 {`
	`215`	`+ if values.Journal.QuotaJournalRate != nil {`
`212`	`216`	`resourcesBuilder.WithJournalRate(values.Journal.RateCount, values.Journal.RatePeriod)`
`213`	`217`	`}`
`214`	`218`	`}`