This message was deleted.

So I set this up to generate the passwords themselves:

const rabbitUsers =  {
        orchestratorclient: new random.RandomPassword("orchestratorclient", {length:32}),
        orchestratoruser: new random.RandomPassword("orchestratoruser", {length:32}),
        subscriptionuser: new random.RandomPassword("subscriptionuser", {length:32}),
        orchestrator: new random.RandomPassword("orchestrator", {length:32}),
        admin: new random.RandomPassword("admin", {length:32}),
        producer: new random.RandomPassword("producer", {length:32}),
        testreader: new random.RandomPassword("testreader", {length:32})
    }

You're doing

new random.RandomPassword("foo", {length: 32}).result

right?

The trick comes with this...

let rabbitLoadFile = { 
        "rabbit_version": "3.7.13",
        "users": [{
            "name": "orchestratorclient",
            "password_hash": rabbitPassHasher(pulumi.interpolate`rabbitUsers.orchestratorclient.result`, salt),
            "hashing_algorithm": "rabbit_password_hashing_sha256",
            "tags": ""
        }, 
....
}

Because, of course, and as it should be - rabbitUsers.orchestratorclient.result is Output<string>

(just to interrupt you)

so I've tried both the .apply and the interpolate methods - and they both turn out Output<string>.. and I'm realizing that yes - they should. it needs to be that way.

Could you use a component resource? And the output is the rabbit-hashed version?

like.. we have

.result

- if I could add

.rabbitHashedResult

to the list, that should solve it nicely

can you not do:

rabbitUsers.orchestratorclient.result.apply(x => rabbitPassHasher(x, salt))

i.. i.. probably..

you might need to output tuple the salt, i didn't know if that was also an output or not

dammit Joshua - why do you have to point out the blaringly obvious 😉 thanks ❤️

haha hope it works!

the salt is of no consequence (though it would be fun to also have the salt controlled by Random - but i'm going to accept a static salt in my code ;))

that would give you

Output<string>

of the hash so then to put that in the JSON you would need to do like:

hash.apply(rabbitHash =>
{
    return {
        ...,
        "password_hash": rabbitHash,
        ...,
    };
});

So... sorry to take so long for getting confirmation, been struggling with automation, promise leaks, and everything weird in general. Regardless! I thought I got everything nicely handled - my json object got pushed into azure as a secret, and propegated into k8s as a secret through synchronization - and what do I finally find? this:

"users": [
        {
            "name": "orchestratorclient",
            "password_hash": "Calling [toJSON] on an [Output<T>] is not supported.\n\nTo get the value of an Output as a JSON value or JSON string consider either:\n    1: o.apply(v => v.toJSON())\n    2: o.apply(v => JSON.stringify(v))\n\nSee <https://pulumi.io/help/outputs> for more details.\nThis function may throw in a future version of @pulumi/pulumi.",
            "hashing_algorithm": "rabbit_password_hashing_sha256",
            "tags": ""
        },

😄 😄

you're missing a key concept

Right

so you need to do this:

let rabbitLoadFile = rabbitUsers.orchestratorclient.result.apply(password =>
{
    return {
        "rabbit_version": "3.8.14",
        "users": [{
            "name": "orchestratorclient",
            "password_hash": rabbitPassHasher(password, salt),
            "hashing_algorithm": "rabbit_password_hashing_sha256",
            "tags": "",
        }],
    };
});

now your load file is an Output<object>. And then:

const rabbitLoadSecret = new azure.keyvault.Secret(`rabbit-load-definition`, {
        resourceGroupName: environment.rg,
        vaultName: environment.vault.name,
        secretName: `rabbit-load-definition`,
        properties: {
            value: rabbitLoadFile.apply(x => JSON.stringify(x)),
        }
    })

see - this is where I'm slightly confused. Since rabbitLoadFile is already an Output<T> in the first object - would it not be pertinent to simply JSON.stringify() that return and then use it directly with

properties.value

?

rabbitLoadFile is not an

Output<T>

in your original example

i.e.

value: rabbitUsers.admin.result.apply(x => { return JSON.stringify(rabbitLoadFile)})

seems to me to be identical

it is an inline javascript object that you declared

but in your example you're wrapping the js object inside ..client.result.apply() to force it to an output. That would be the same as my one-liner right?

no

let rabbitLoadFile = rabbitUsers.orchestratorclient.result.apply(password =>
{
    return JSON.stringify({
        "rabbit_version": "3.8.14",
        "users": [{
            "name": "orchestratorclient",
            "password_hash": rabbitPassHasher(password, salt),
            "hashing_algorithm": "rabbit_password_hashing_sha256",
            "tags": "",
        }],
    });
});

The above would be an Output<string> right?

correct

ok, think I see the issue in comprehension here - I'm currently making an Output<string> of the password_hash value because I do the .result.apply() at that stage

ah. It's probably going to be painful but this is where

output.tuple

or

output.all

comes in, so you can pass multiple

Output<T>

into an

.apply(...)

call. Alternatively you could save the

JSON.stringify(...)

until the very end and append to the

users

array. So you could do:

let rabbitLoadFile = password1.apply(pw =>
{
    return {
        "rabbit_version": "3.8.14",
        "users": [{
            "name": "orchestratorclient",
            "password_hash": rabbitPassHasher(pw, salt),
            "hashing_algorithm": "rabbit_password_hashing_sha256",
            "tags": "",
        }],
    };
});

and that would just be for the first password. You want to keep it as an

Output<object>

so you can continue to manipulate it as an object. Then all passwords after that could look like:

rabbitLoadFile = output.all(rabbitLoadFile, password2).apply((file, pw) =>
{
    // instead of adding it to the existing object
    // you may want to clone it, modify the clone, and return the clone
    file.users.add({
        "name": "orchestratorclient",
        "password_hash": rabbitPassHasher(pw, salt),
        "hashing_algorithm": "rabbit_password_hashing_sha256",
        "tags": "",
    });
});

and then finally on

properties.value

you would

rabbitLoadFile.apply(x => JSON.stringify(x))

there is much contemplation in my head.. but it makes some sense yes.

what SDK are you in? TypeScript?

yup

it is this: https://www.pulumi.com/docs/reference/pkg/nodejs/pulumi/pulumi/#all

ah righty - looking good then.

good luck!

thanks 😉

glad to hear it!