You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by la...@apache.org on 2026/05/15 18:14:42 UTC

(airavata-custos) branch master updated: Association mapper client impl

This is an automated email from the ASF dual-hosted git repository.

lahirujayathilake pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/airavata-custos.git


The following commit(s) were added to refs/heads/master by this push:
     new 8dd33eb16 Association mapper client impl
8dd33eb16 is described below

commit 8dd33eb16731d7b372c26cdf0acb97ffa0c38ebd
Author: DImuthuUpe <di...@gmail.com>
AuthorDate: Wed May 13 10:07:23 2026 -0400

    Association mapper client impl
---
 connectors/SLURM/Association-Mapper/.gitignore     |   4 +
 connectors/SLURM/Association-Mapper/Makefile       |  18 +++
 connectors/SLURM/Association-Mapper/README.md      |  57 ++++++-
 connectors/SLURM/Association-Mapper/go.mod         |   3 +
 .../internal/operations/accounts.go                |  53 ++++++
 .../internal/operations/accounts_test.go           |  99 ++++++++++++
 .../internal/operations/associations.go            |  62 +++++++
 .../internal/operations/associations_test.go       |  74 +++++++++
 .../internal/operations/client.go                  |  71 ++++++++
 .../internal/operations/client_test.go             |  47 ++++++
 .../Association-Mapper/internal/operations/tres.go |  39 +++++
 .../internal/operations/tres_test.go               |  33 ++++
 .../internal/operations/types.go                   | 180 +++++++++++++++++++++
 connectors/SLURM/Association-Mapper/main.go        |  25 +++
 14 files changed, 763 insertions(+), 2 deletions(-)

diff --git a/connectors/SLURM/Association-Mapper/.gitignore b/connectors/SLURM/Association-Mapper/.gitignore
new file mode 100644
index 000000000..7be4b455e
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/.gitignore
@@ -0,0 +1,4 @@
+/bin/
+*.test
+*.out
+.env
diff --git a/connectors/SLURM/Association-Mapper/Makefile b/connectors/SLURM/Association-Mapper/Makefile
new file mode 100644
index 000000000..32efab927
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/Makefile
@@ -0,0 +1,18 @@
+.PHONY: build test run tidy clean
+
+BIN := bin/association-mapper
+
+build:
+	go build -o $(BIN) .
+
+run: build
+	./$(BIN)
+
+test:
+	go test ./...
+
+tidy:
+	go mod tidy
+
+clean:
+	rm -rf bin
diff --git a/connectors/SLURM/Association-Mapper/README.md b/connectors/SLURM/Association-Mapper/README.md
index 906d5dfba..667af800f 100644
--- a/connectors/SLURM/Association-Mapper/README.md
+++ b/connectors/SLURM/Association-Mapper/README.md
@@ -1,3 +1,56 @@
-SLURM Association Creation Logic Goes into this Plugin
+# SLURM Association-Mapper
 
-This plugin is triggered when the allocation manager has processed an allocation request and relased it to downstream handlers
\ No newline at end of file
+SLURM association creation logic lives in this plugin. It is triggered when the allocation manager has processed an allocation request and released it to downstream handlers. It talks to `slurmrestd` to manage accounts, associations, and TRES limits.
+
+## Prerequisites
+
+- Go **1.24+**
+- A reachable `slurmrestd` endpoint (for integration runs) plus a SLURM user name and JWT token
+
+## Layout
+
+```
+.
+├── main.go                       # entry point
+├── internal/operations/          # slurmrestd client + accounts/associations/TRES
+├── go.mod
+└── Makefile
+```
+
+Module path: `github.com/apache/airavata-custos/connectors/SLURM/Association-Mapper`.
+
+## Build
+
+```bash
+# from this directory
+make build           # produces bin/association-mapper
+# or directly:
+go build -o bin/association-mapper .
+```
+
+## Run
+
+```bash
+make run             # build, then ./bin/association-mapper
+```
+
+The service starts, logs `association-mapper started`, and blocks until it receives `SIGINT` or `SIGTERM`.
+
+## Test
+
+```bash
+make test            # go test ./...
+go vet ./...         # static checks
+```
+
+Tests are hermetic and use `httptest` — no live `slurmrestd` required.
+
+## Common make targets
+
+| Target  | Description                          |
+|---------|--------------------------------------|
+| `build` | Compile the binary into `bin/`       |
+| `run`   | Build and run                        |
+| `test`  | Run all unit tests                   |
+| `tidy`  | `go mod tidy`                        |
+| `clean` | Remove `bin/`                        |
diff --git a/connectors/SLURM/Association-Mapper/go.mod b/connectors/SLURM/Association-Mapper/go.mod
new file mode 100644
index 000000000..0e1832e7c
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/go.mod
@@ -0,0 +1,3 @@
+module github.com/apache/airavata-custos/connectors/SLURM/Association-Mapper
+
+go 1.24.0
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/accounts.go b/connectors/SLURM/Association-Mapper/internal/operations/accounts.go
new file mode 100644
index 000000000..ea7d87708
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/accounts.go
@@ -0,0 +1,53 @@
+// cli/internal/client/accounts.go
+package operations
+
+import "fmt"
+
+type accountsResponse struct {
+	Accounts []Account `json:"accounts"`
+}
+
+func (c *Client) ListAccounts() ([]Account, error) {
+	var out accountsResponse
+	if _, err := c.do("GET", "/slurmdb/v0.0.41/accounts", nil, &out); err != nil {
+		return nil, err
+	}
+	return out.Accounts, nil
+}
+
+func (c *Client) GetAccount(name string) (*Account, error) {
+	var out accountsResponse
+	if _, err := c.do("GET", "/slurmdb/v0.0.41/account/"+name, nil, &out); err != nil {
+		return nil, err
+	}
+	if len(out.Accounts) == 0 {
+		return nil, fmt.Errorf("account %q not found", name)
+	}
+	return &out.Accounts[0], nil
+}
+
+// CreateAccount creates an account and a cluster-scope association in a single
+// call, mirroring `sacctmgr add account <name> cluster=<cluster>`. Without the
+// association, the account record exists but is unusable (subsequent attempts
+// to add a user silently no-op). slurmrestd exposes this via the
+// /accounts_association/ endpoint, whose body wraps the account metadata and
+// an association_condition naming the accounts + clusters to wire up.
+func (c *Client) CreateAccount(a Account, cluster string) error {
+	body := map[string]any{
+		"association_condition": map[string]any{
+			"accounts": []string{a.Name},
+			"clusters": []string{cluster},
+		},
+		"account": map[string]any{
+			"description":  a.Description,
+			"organization": a.Organization,
+		},
+	}
+	_, err := c.do("POST", "/slurmdb/v0.0.41/accounts_association/", body, nil)
+	return err
+}
+
+func (c *Client) DeleteAccount(name string) error {
+	_, err := c.do("DELETE", "/slurmdb/v0.0.41/account/"+name, nil, nil)
+	return err
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/accounts_test.go b/connectors/SLURM/Association-Mapper/internal/operations/accounts_test.go
new file mode 100644
index 000000000..a427116e5
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/accounts_test.go
@@ -0,0 +1,99 @@
+// cli/internal/client/accounts_test.go
+package operations
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestListAccounts(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/slurmdb/v0.0.41/accounts" || r.Method != "GET" {
+			t.Fatalf("unexpected %s %s", r.Method, r.URL.Path)
+		}
+		_, _ = w.Write([]byte(`{"accounts":[{"name":"root","description":"root account","organization":"artisan"}]}`))
+	}))
+	defer srv.Close()
+
+	c := New(srv.URL, "root", "t")
+	accts, err := c.ListAccounts()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(accts) != 1 || accts[0].Name != "root" {
+		t.Errorf("accts = %+v", accts)
+	}
+}
+
+func TestCreateAccount(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "POST" || r.URL.Path != "/slurmdb/v0.0.41/accounts_association/" {
+			t.Fatalf("unexpected %s %s", r.Method, r.URL.Path)
+		}
+		body, _ := io.ReadAll(r.Body)
+		var payload struct {
+			AssociationCondition struct {
+				Accounts []string `json:"accounts"`
+				Clusters []string `json:"clusters"`
+			} `json:"association_condition"`
+			Account struct {
+				Description  string `json:"description"`
+				Organization string `json:"organization"`
+			} `json:"account"`
+		}
+		_ = json.Unmarshal(body, &payload)
+		if len(payload.AssociationCondition.Accounts) != 1 || payload.AssociationCondition.Accounts[0] != "eng" {
+			t.Errorf("accounts = %+v", payload.AssociationCondition.Accounts)
+		}
+		if len(payload.AssociationCondition.Clusters) != 1 || payload.AssociationCondition.Clusters[0] != "artisan" {
+			t.Errorf("clusters = %+v", payload.AssociationCondition.Clusters)
+		}
+		if payload.Account.Description != "engineering" {
+			t.Errorf("description = %q", payload.Account.Description)
+		}
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer srv.Close()
+
+	c := New(srv.URL, "root", "t")
+	if err := c.CreateAccount(Account{Name: "eng", Description: "engineering"}, "artisan"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestDeleteAccount(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "DELETE" || r.URL.Path != "/slurmdb/v0.0.41/account/eng" {
+			t.Fatalf("unexpected %s %s", r.Method, r.URL.Path)
+		}
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer srv.Close()
+
+	c := New(srv.URL, "root", "t")
+	if err := c.DeleteAccount("eng"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestGetAccount(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/slurmdb/v0.0.41/account/eng" {
+			t.Fatalf("path = %s", r.URL.Path)
+		}
+		_, _ = w.Write([]byte(`{"accounts":[{"name":"eng","description":"engineering","organization":"artisan"}]}`))
+	}))
+	defer srv.Close()
+
+	c := New(srv.URL, "root", "t")
+	a, err := c.GetAccount("eng")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if a.Name != "eng" || a.Description != "engineering" {
+		t.Errorf("a = %+v", a)
+	}
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/associations.go b/connectors/SLURM/Association-Mapper/internal/operations/associations.go
new file mode 100644
index 000000000..ab34cd931
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/associations.go
@@ -0,0 +1,62 @@
+// cli/internal/client/associations.go
+package operations
+
+import "net/url"
+
+type AssocFilter struct {
+	Account   string
+	User      string
+	Cluster   string
+	Partition string
+}
+
+func (f AssocFilter) query() string {
+	v := url.Values{}
+	if f.Account != "" {
+		v.Set("account", f.Account)
+	}
+	if f.User != "" {
+		v.Set("user", f.User)
+	}
+	if f.Cluster != "" {
+		v.Set("cluster", f.Cluster)
+	}
+	if f.Partition != "" {
+		v.Set("partition", f.Partition)
+	}
+	return v.Encode()
+}
+
+type associationsResponse struct {
+	Associations []Association `json:"associations"`
+}
+
+func (c *Client) ListAssociations(f AssocFilter) ([]Association, error) {
+	path := "/slurmdb/v0.0.41/associations"
+	if q := f.query(); q != "" {
+		path += "?" + q
+	}
+	var out associationsResponse
+	if _, err := c.do("GET", path, nil, &out); err != nil {
+		return nil, err
+	}
+	return out.Associations, nil
+}
+
+// UpsertAssociation creates or updates an association. slurmrestd POST
+// /slurmdb/v0.0.41/associations is an upsert: if the (cluster,account,user)
+// triple exists, it's updated; otherwise created.
+func (c *Client) UpsertAssociation(a Association) error {
+	body := map[string]any{"associations": []Association{a}}
+	_, err := c.do("POST", "/slurmdb/v0.0.41/associations", body, nil)
+	return err
+}
+
+func (c *Client) DeleteAssociation(f AssocFilter) error {
+	path := "/slurmdb/v0.0.41/association"
+	if q := f.query(); q != "" {
+		path += "?" + q
+	}
+	_, err := c.do("DELETE", path, nil, nil)
+	return err
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/associations_test.go b/connectors/SLURM/Association-Mapper/internal/operations/associations_test.go
new file mode 100644
index 000000000..9082927b0
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/associations_test.go
@@ -0,0 +1,74 @@
+// cli/internal/client/associations_test.go
+package operations
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+)
+
+
+func TestListAssociationsByAccount(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/slurmdb/v0.0.41/associations" {
+			t.Fatalf("path = %s", r.URL.Path)
+		}
+		if got, _ := url.QueryUnescape(r.URL.RawQuery); got != "account=eng" {
+			t.Fatalf("query = %q", got)
+		}
+		_, _ = w.Write([]byte(`{"associations":[{"account":"eng","cluster":"artisan","user":"alice","id_association":5}]}`))
+	}))
+	defer srv.Close()
+	c := New(srv.URL, "root", "t")
+	assocs, err := c.ListAssociations(AssocFilter{Account: "eng"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(assocs) != 1 || assocs[0].User != "alice" || assocs[0].ID != 5 {
+		t.Errorf("assocs = %+v", assocs)
+	}
+}
+
+func TestCreateAssociation(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "POST" || r.URL.Path != "/slurmdb/v0.0.41/associations" {
+			t.Fatalf("unexpected %s %s", r.Method, r.URL.Path)
+		}
+		b, _ := io.ReadAll(r.Body)
+		var payload struct {
+			Associations []Association `json:"associations"`
+		}
+		_ = json.Unmarshal(b, &payload)
+		if len(payload.Associations) != 1 || payload.Associations[0].Account != "eng" ||
+			payload.Associations[0].User != "alice" {
+			t.Errorf("payload = %+v", payload)
+		}
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer srv.Close()
+	c := New(srv.URL, "root", "t")
+	err := c.UpsertAssociation(Association{Account: "eng", Cluster: "artisan", User: "alice"})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestDeleteAssociation(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "DELETE" || r.URL.Path != "/slurmdb/v0.0.41/association" {
+			t.Fatalf("unexpected %s %s", r.Method, r.URL.Path)
+		}
+		if r.URL.Query().Get("account") != "eng" || r.URL.Query().Get("user") != "alice" {
+			t.Fatalf("query = %v", r.URL.RawQuery)
+		}
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer srv.Close()
+	c := New(srv.URL, "root", "t")
+	if err := c.DeleteAssociation(AssocFilter{Account: "eng", User: "alice"}); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/client.go b/connectors/SLURM/Association-Mapper/internal/operations/client.go
new file mode 100644
index 000000000..62bd25b99
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/client.go
@@ -0,0 +1,71 @@
+// cli/internal/client/client.go
+package operations
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type Client struct {
+	baseURL string
+	user    string
+	token   string
+	http    *http.Client
+}
+
+func New(baseURL, user, token string) *Client {
+	return &Client{
+		baseURL: strings.TrimRight(baseURL, "/"),
+		user:    user,
+		token:   token,
+		http:    &http.Client{Timeout: 30 * time.Second},
+	}
+}
+
+func (c *Client) do(method, path string, body any, out any) (*http.Response, error) {
+	var reqBody io.Reader
+	if body != nil {
+		buf, err := json.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		reqBody = bytes.NewReader(buf)
+	}
+	req, err := http.NewRequest(method, c.baseURL+path, reqBody)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("X-SLURM-USER-NAME", c.user)
+	req.Header.Set("X-SLURM-USER-TOKEN", c.token)
+	req.Header.Set("Accept", "application/json")
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 400 {
+		defer resp.Body.Close()
+		buf, _ := io.ReadAll(resp.Body)
+		var er ErrorResponse
+		if json.Unmarshal(buf, &er) == nil && len(er.Errors) > 0 {
+			e := er.Errors[0]
+			return resp, fmt.Errorf("slurmrestd %d: %s (code=%d source=%s)",
+				resp.StatusCode, e.Description, e.ErrorNumber, e.Source)
+		}
+		return resp, fmt.Errorf("slurmrestd %d: %s", resp.StatusCode, string(buf))
+	}
+	if out != nil {
+		defer resp.Body.Close()
+		if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
+			return resp, fmt.Errorf("decode: %w", err)
+		}
+	}
+	return resp, nil
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/client_test.go b/connectors/SLURM/Association-Mapper/internal/operations/client_test.go
new file mode 100644
index 000000000..3d07b6456
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/client_test.go
@@ -0,0 +1,47 @@
+// cli/internal/client/client_test.go
+package operations
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestDoSetsHeaders(t *testing.T) {
+	var gotName, gotToken string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotName = r.Header.Get("X-SLURM-USER-NAME")
+		gotToken = r.Header.Get("X-SLURM-USER-TOKEN")
+		w.WriteHeader(200)
+		_, _ = w.Write([]byte(`{}`))
+	}))
+	defer srv.Close()
+
+	c := New(srv.URL, "root", "tok123")
+	if _, err := c.do("GET", "/slurm/v0.0.41/ping", nil, nil); err != nil {
+		t.Fatal(err)
+	}
+	if gotName != "root" {
+		t.Errorf("X-SLURM-USER-NAME = %q", gotName)
+	}
+	if gotToken != "tok123" {
+		t.Errorf("X-SLURM-USER-TOKEN = %q", gotToken)
+	}
+}
+
+func TestDoUnwrapsErrors(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(400)
+		_, _ = w.Write([]byte(`{"errors":[{"description":"nope","error_number":42,"error":"Bad","source":"test"}]}`))
+	}))
+	defer srv.Close()
+	c := New(srv.URL, "root", "tok")
+	_, err := c.do("GET", "/x", nil, nil)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if !strings.Contains(err.Error(), "42") || !strings.Contains(err.Error(), "nope") {
+		t.Errorf("err = %v", err)
+	}
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/tres.go b/connectors/SLURM/Association-Mapper/internal/operations/tres.go
new file mode 100644
index 000000000..313c58c59
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/tres.go
@@ -0,0 +1,39 @@
+// cli/internal/client/tres.go
+package operations
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// ParseTRES parses a comma-separated TRES spec:
+//
+//	"cpu=100", "cpu=100,mem=8000", "gres/gpu=2", "cpu=10,gres/gpu=4"
+func ParseTRES(s string) ([]TRES, error) {
+	if strings.TrimSpace(s) == "" {
+		return nil, nil
+	}
+	parts := strings.Split(s, ",")
+	out := make([]TRES, 0, len(parts))
+	for _, p := range parts {
+		kv := strings.SplitN(p, "=", 2)
+		if len(kv) != 2 {
+			return nil, fmt.Errorf("malformed TRES entry %q (want key=value)", p)
+		}
+		n, err := strconv.ParseInt(strings.TrimSpace(kv[1]), 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("TRES count %q not an integer", kv[1])
+		}
+		t := TRES{Count: n}
+		key := strings.TrimSpace(kv[0])
+		if slash := strings.Index(key, "/"); slash >= 0 {
+			t.Type = key[:slash]
+			t.Name = key[slash+1:]
+		} else {
+			t.Type = key
+		}
+		out = append(out, t)
+	}
+	return out, nil
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/tres_test.go b/connectors/SLURM/Association-Mapper/internal/operations/tres_test.go
new file mode 100644
index 000000000..79ba50faf
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/tres_test.go
@@ -0,0 +1,33 @@
+// cli/internal/client/tres_test.go
+package operations
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestParseTRES(t *testing.T) {
+	cases := []struct {
+		in   string
+		want []TRES
+	}{
+		{"cpu=100", []TRES{{Type: "cpu", Count: 100}}},
+		{"cpu=100,mem=8000", []TRES{{Type: "cpu", Count: 100}, {Type: "mem", Count: 8000}}},
+		{"gres/gpu=4", []TRES{{Type: "gres", Name: "gpu", Count: 4}}},
+		{"cpu=10,gres/gpu=2", []TRES{{Type: "cpu", Count: 10}, {Type: "gres", Name: "gpu", Count: 2}}},
+	}
+	for _, c := range cases {
+		got, err := ParseTRES(c.in)
+		if err != nil {
+			t.Errorf("ParseTRES(%q): err=%v", c.in, err)
+			continue
+		}
+		if !reflect.DeepEqual(got, c.want) {
+			t.Errorf("ParseTRES(%q) = %+v, want %+v", c.in, got, c.want)
+		}
+	}
+
+	if _, err := ParseTRES("nope"); err == nil {
+		t.Error("expected error on malformed input")
+	}
+}
diff --git a/connectors/SLURM/Association-Mapper/internal/operations/types.go b/connectors/SLURM/Association-Mapper/internal/operations/types.go
new file mode 100644
index 000000000..75aaca6bd
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/internal/operations/types.go
@@ -0,0 +1,180 @@
+// cli/internal/client/types.go
+package operations
+
+import "encoding/json"
+
+type ErrorResponse struct {
+	Errors []struct {
+		Description string `json:"description"`
+		ErrorNumber int    `json:"error_number"`
+		Error       string `json:"error"`
+		Source      string `json:"source"`
+	} `json:"errors"`
+	Warnings []struct {
+		Description string `json:"description"`
+		Source      string `json:"source"`
+	} `json:"warnings"`
+}
+
+type TRES struct {
+	Type  string `json:"type"`
+	Name  string `json:"name,omitempty"`
+	Count int64  `json:"count"`
+}
+
+type Account struct {
+	Name         string `json:"name"`
+	Description  string `json:"description,omitempty"`
+	Organization string `json:"organization,omitempty"`
+}
+
+type AssocLimits struct {
+	GrpJobs     *int64 `json:"grp_jobs,omitempty"`
+	GrpTRES     []TRES `json:"grp_tres,omitempty"`
+	GrpTRESMins []TRES `json:"grp_tres_mins,omitempty"`
+	MaxWallPM   *int64 `json:"max_wall_pj,omitempty"`
+}
+
+type Association struct {
+	Account       string `json:"account"`
+	Cluster       string `json:"cluster"`
+	User          string `json:"user"`
+	Partition     string `json:"partition,omitempty"`
+	ParentAccount string `json:"parent_account,omitempty"`
+	IsDefault     *bool  `json:"is_default,omitempty"`
+	ID            int64  `json:"id_association,omitempty"`
+	// Limits is a logical grouping — slurmrestd v0.0.41 actually encodes limits
+	// in a nested `max` object per-association. We translate between the two
+	// shapes in Marshal/UnmarshalJSON below.
+	Limits AssocLimits `json:"-"`
+}
+
+// slurmNumber matches slurmrestd's {set, infinite, number} triple used for
+// all scalar limit values in the v0.0.41 accounting schema.
+type slurmNumber struct {
+	Set      bool  `json:"set"`
+	Infinite bool  `json:"infinite"`
+	Number   int64 `json:"number"`
+}
+
+func numPtr(n *int64) *slurmNumber {
+	if n == nil {
+		return nil
+	}
+	return &slurmNumber{Set: true, Number: *n}
+}
+
+func ptrNum(n *slurmNumber) *int64 {
+	if n == nil || !n.Set || n.Infinite {
+		return nil
+	}
+	v := n.Number
+	return &v
+}
+
+// assocMax is the v0.0.41 "max" sub-object inside each association. We only
+// populate the fields we actually manage; slurmrestd ignores unset sub-objects.
+type assocMax struct {
+	Jobs *assocMaxJobs `json:"jobs,omitempty"`
+	TRES *assocMaxTRES `json:"tres,omitempty"`
+}
+
+type assocMaxJobs struct {
+	Per *assocMaxJobsPer `json:"per,omitempty"`
+}
+
+type assocMaxJobsPer struct {
+	Count     *slurmNumber `json:"count,omitempty"`      // GrpJobs
+	WallClock *slurmNumber `json:"wall_clock,omitempty"` // MaxWallDurationPerJob (seconds)
+}
+
+type assocMaxTRES struct {
+	Total []TRES          `json:"total,omitempty"` // GrpTRES
+	Group *assocMaxTRESGp `json:"group,omitempty"`
+}
+
+type assocMaxTRESGp struct {
+	Minutes []TRES `json:"minutes,omitempty"` // GrpTRESMins
+}
+
+// assocWire is the on-the-wire association record used for both request
+// marshaling and response unmarshaling. `user` is emitted even when empty
+// because slurmrestd rejects payloads without it (error 9200).
+type assocWire struct {
+	Account       string    `json:"account"`
+	Cluster       string    `json:"cluster"`
+	User          string    `json:"user"`
+	Partition     string    `json:"partition,omitempty"`
+	ParentAccount string    `json:"parent_account,omitempty"`
+	IsDefault     *bool     `json:"is_default,omitempty"`
+	ID            int64     `json:"id_association,omitempty"`
+	Max           *assocMax `json:"max,omitempty"`
+}
+
+func (a Association) MarshalJSON() ([]byte, error) {
+	w := assocWire{
+		Account:       a.Account,
+		Cluster:       a.Cluster,
+		User:          a.User,
+		Partition:     a.Partition,
+		ParentAccount: a.ParentAccount,
+		IsDefault:     a.IsDefault,
+		ID:            a.ID,
+	}
+	m := &assocMax{}
+	touched := false
+	if a.Limits.GrpJobs != nil || a.Limits.MaxWallPM != nil {
+		per := &assocMaxJobsPer{}
+		if a.Limits.GrpJobs != nil {
+			per.Count = numPtr(a.Limits.GrpJobs)
+		}
+		if a.Limits.MaxWallPM != nil {
+			per.WallClock = numPtr(a.Limits.MaxWallPM)
+		}
+		m.Jobs = &assocMaxJobs{Per: per}
+		touched = true
+	}
+	if len(a.Limits.GrpTRES) > 0 || len(a.Limits.GrpTRESMins) > 0 {
+		t := &assocMaxTRES{}
+		if len(a.Limits.GrpTRES) > 0 {
+			t.Total = a.Limits.GrpTRES
+		}
+		if len(a.Limits.GrpTRESMins) > 0 {
+			t.Group = &assocMaxTRESGp{Minutes: a.Limits.GrpTRESMins}
+		}
+		m.TRES = t
+		touched = true
+	}
+	if touched {
+		w.Max = m
+	}
+	return json.Marshal(w)
+}
+
+func (a *Association) UnmarshalJSON(data []byte) error {
+	var w assocWire
+	if err := json.Unmarshal(data, &w); err != nil {
+		return err
+	}
+	a.Account = w.Account
+	a.Cluster = w.Cluster
+	a.User = w.User
+	a.Partition = w.Partition
+	a.ParentAccount = w.ParentAccount
+	a.IsDefault = w.IsDefault
+	a.ID = w.ID
+	a.Limits = AssocLimits{}
+	if w.Max != nil {
+		if w.Max.Jobs != nil && w.Max.Jobs.Per != nil {
+			a.Limits.GrpJobs = ptrNum(w.Max.Jobs.Per.Count)
+			a.Limits.MaxWallPM = ptrNum(w.Max.Jobs.Per.WallClock)
+		}
+		if w.Max.TRES != nil {
+			a.Limits.GrpTRES = w.Max.TRES.Total
+			if w.Max.TRES.Group != nil {
+				a.Limits.GrpTRESMins = w.Max.TRES.Group.Minutes
+			}
+		}
+	}
+	return nil
+}
diff --git a/connectors/SLURM/Association-Mapper/main.go b/connectors/SLURM/Association-Mapper/main.go
new file mode 100644
index 000000000..d04dcad1e
--- /dev/null
+++ b/connectors/SLURM/Association-Mapper/main.go
@@ -0,0 +1,25 @@
+// Package main is the entry point for the SLURM Association-Mapper connector.
+//
+// It consumes allocation events released by the allocation manager and
+// materializes them as SLURM associations via slurmrestd.
+package main
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func main() {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
+	slog.SetDefault(logger)
+
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	logger.Info("association-mapper started")
+	<-ctx.Done()
+	logger.Info("association-mapper stopped")
+}