powerscale.Filesystem

import * as pulumi from "@pulumi/pulumi";
import * as powerscale from "@pulumi/powerscale";

//Copyright (c) 2023-2024 Dell Inc., or its subsidiaries. All Rights Reserved.
//
//Licensed under the Mozilla Public License Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//    http://mozilla.org/MPL/2.0/
//
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Available actions: Create, Update (owner, group, access_control), Delete and Import existing FileSystem(Namespace directory) from Powerscale array.
// After `pulumi up` of this example file it will create a new FileSystem(Namespace directory) with the name set in `name` attribute in the directory path provided in `directory_path`on the PowerScale array
// PowerScale FileSystem Resource allows you to manage the Namespace Directory on the Powerscale array
const fileSystemTest = new powerscale.Filesystem("file_system_test", {
    name: "DirTf",
    group: {
        id: "GID:0",
        name: "wheel",
        type: "group",
    },
    owner: {
        id: "UID:1501",
        name: "Guest",
        type: "user",
    },
    recursive: true,
    overwrite: false,
});
// Steps to create a file system using the SID.
// First use the user datasource to get the UID using the SID.
const getUserWithSID = powerscale.getUser({
    filter: {
        names: [{
            name: "Guest",
            sid: "S-1-5-21-3219966720-1480896164-796802738-501",
        }],
    },
});
// Once you get the UID using the datasource , use that UID while creating your fileystem.
const ifsTestdir = new powerscale.Filesystem("ifs_testdir", {
    accessControl: "0770",
    directoryPath: "/ifs",
    fullPath: "/ifs/new-fs",
    group: {
        id: "GID:1800",
        name: "Isilon Users",
        type: "group",
    },
    name: "new-fs",
    overwrite: false,
    owner: {
        id: getUserWithSID.then(getUserWithSID => getUserWithSID.users?.[0]?.uid),
        name: "Guest",
        type: "user",
    },
    recursive: true,
});

import pulumi
import pulumi_powerscale as powerscale

#Copyright (c) 2023-2024 Dell Inc., or its subsidiaries. All Rights Reserved.
#
#Licensed under the Mozilla Public License Version 2.0 (the "License");
#you may not use this file except in compliance with the License.
#You may obtain a copy of the License at
#
#    http://mozilla.org/MPL/2.0/
#
#
#Unless required by applicable law or agreed to in writing, software
#distributed under the License is distributed on an "AS IS" BASIS,
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#See the License for the specific language governing permissions and
#limitations under the License.
# Available actions: Create, Update (owner, group, access_control), Delete and Import existing FileSystem(Namespace directory) from Powerscale array.
# After `pulumi up` of this example file it will create a new FileSystem(Namespace directory) with the name set in `name` attribute in the directory path provided in `directory_path`on the PowerScale array
# PowerScale FileSystem Resource allows you to manage the Namespace Directory on the Powerscale array
file_system_test = powerscale.Filesystem("file_system_test",
    name="DirTf",
    group={
        "id": "GID:0",
        "name": "wheel",
        "type": "group",
    },
    owner={
        "id": "UID:1501",
        "name": "Guest",
        "type": "user",
    },
    recursive=True,
    overwrite=False)
# Steps to create a file system using the SID.
# First use the user datasource to get the UID using the SID.
get_user_with_sid = powerscale.get_user(filter={
    "names": [{
        "name": "Guest",
        "sid": "S-1-5-21-3219966720-1480896164-796802738-501",
    }],
})
# Once you get the UID using the datasource , use that UID while creating your fileystem.
ifs_testdir = powerscale.Filesystem("ifs_testdir",
    access_control="0770",
    directory_path="/ifs",
    full_path="/ifs/new-fs",
    group={
        "id": "GID:1800",
        "name": "Isilon Users",
        "type": "group",
    },
    name="new-fs",
    overwrite=False,
    owner={
        "id": get_user_with_sid.users[0].uid,
        "name": "Guest",
        "type": "user",
    },
    recursive=True)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/powerscale/powerscale"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Copyright (c) 2023-2024 Dell Inc., or its subsidiaries. All Rights Reserved.
		//
		// Licensed under the Mozilla Public License Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		//	http://mozilla.org/MPL/2.0/
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		// Available actions: Create, Update (owner, group, access_control), Delete and Import existing FileSystem(Namespace directory) from Powerscale array.
		// After `pulumi up` of this example file it will create a new FileSystem(Namespace directory) with the name set in `name` attribute in the directory path provided in `directory_path`on the PowerScale array
		// PowerScale FileSystem Resource allows you to manage the Namespace Directory on the Powerscale array
		_, err := powerscale.NewFilesystem(ctx, "file_system_test", &powerscale.FilesystemArgs{
			Name: pulumi.String("DirTf"),
			Group: &powerscale.FilesystemGroupArgs{
				Id:   pulumi.String("GID:0"),
				Name: pulumi.String("wheel"),
				Type: pulumi.String("group"),
			},
			Owner: &powerscale.FilesystemOwnerArgs{
				Id:   pulumi.String("UID:1501"),
				Name: pulumi.String("Guest"),
				Type: pulumi.String("user"),
			},
			Recursive: pulumi.Bool(true),
			Overwrite: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// First use the user datasource to get the UID using the SID.
		getUserWithSID, err := powerscale.LookupUser(ctx, &powerscale.LookupUserArgs{
			Filter: powerscale.GetUserFilter{
				Names: []powerscale.GetUserFilterName{
					{
						Name: pulumi.StringRef("Guest"),
						Sid:  pulumi.StringRef("S-1-5-21-3219966720-1480896164-796802738-501"),
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		// Once you get the UID using the datasource , use that UID while creating your fileystem.
		_, err = powerscale.NewFilesystem(ctx, "ifs_testdir", &powerscale.FilesystemArgs{
			AccessControl: pulumi.String("0770"),
			DirectoryPath: pulumi.String("/ifs"),
			FullPath:      pulumi.String("/ifs/new-fs"),
			Group: &powerscale.FilesystemGroupArgs{
				Id:   pulumi.String("GID:1800"),
				Name: pulumi.String("Isilon Users"),
				Type: pulumi.String("group"),
			},
			Name:      pulumi.String("new-fs"),
			Overwrite: pulumi.Bool(false),
			Owner: &powerscale.FilesystemOwnerArgs{
				Id:   pulumi.String(getUserWithSID.Users[0].Uid),
				Name: pulumi.String("Guest"),
				Type: pulumi.String("user"),
			},
			Recursive: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Powerscale = Pulumi.Powerscale;

return await Deployment.RunAsync(() => 
{
    //Copyright (c) 2023-2024 Dell Inc., or its subsidiaries. All Rights Reserved.
    //
    //Licensed under the Mozilla Public License Version 2.0 (the "License");
    //you may not use this file except in compliance with the License.
    //You may obtain a copy of the License at
    //
    //    http://mozilla.org/MPL/2.0/
    //
    //
    //Unless required by applicable law or agreed to in writing, software
    //distributed under the License is distributed on an "AS IS" BASIS,
    //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //See the License for the specific language governing permissions and
    //limitations under the License.
    // Available actions: Create, Update (owner, group, access_control), Delete and Import existing FileSystem(Namespace directory) from Powerscale array.
    // After `pulumi up` of this example file it will create a new FileSystem(Namespace directory) with the name set in `name` attribute in the directory path provided in `directory_path`on the PowerScale array
    // PowerScale FileSystem Resource allows you to manage the Namespace Directory on the Powerscale array
    var fileSystemTest = new Powerscale.Filesystem("file_system_test", new()
    {
        Name = "DirTf",
        Group = new Powerscale.Inputs.FilesystemGroupArgs
        {
            Id = "GID:0",
            Name = "wheel",
            Type = "group",
        },
        Owner = new Powerscale.Inputs.FilesystemOwnerArgs
        {
            Id = "UID:1501",
            Name = "Guest",
            Type = "user",
        },
        Recursive = true,
        Overwrite = false,
    });

    // Steps to create a file system using the SID.
    // First use the user datasource to get the UID using the SID.
    var getUserWithSID = Powerscale.GetUser.Invoke(new()
    {
        Filter = new Powerscale.Inputs.GetUserFilterInputArgs
        {
            Names = new[]
            {
                new Powerscale.Inputs.GetUserFilterNameInputArgs
                {
                    Name = "Guest",
                    Sid = "S-1-5-21-3219966720-1480896164-796802738-501",
                },
            },
        },
    });

    // Once you get the UID using the datasource , use that UID while creating your fileystem.
    var ifsTestdir = new Powerscale.Filesystem("ifs_testdir", new()
    {
        AccessControl = "0770",
        DirectoryPath = "/ifs",
        FullPath = "/ifs/new-fs",
        Group = new Powerscale.Inputs.FilesystemGroupArgs
        {
            Id = "GID:1800",
            Name = "Isilon Users",
            Type = "group",
        },
        Name = "new-fs",
        Overwrite = false,
        Owner = new Powerscale.Inputs.FilesystemOwnerArgs
        {
            Id = getUserWithSID.Apply(getUserResult => getUserResult.Users[0]?.Uid),
            Name = "Guest",
            Type = "user",
        },
        Recursive = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.powerscale.Filesystem;
import com.pulumi.powerscale.FilesystemArgs;
import com.pulumi.powerscale.inputs.FilesystemGroupArgs;
import com.pulumi.powerscale.inputs.FilesystemOwnerArgs;
import com.pulumi.powerscale.PowerscaleFunctions;
import com.pulumi.powerscale.inputs.GetUserArgs;
import com.pulumi.powerscale.inputs.GetUserFilterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        //Copyright (c) 2023-2024 Dell Inc., or its subsidiaries. All Rights Reserved.
        //
        //Licensed under the Mozilla Public License Version 2.0 (the "License");
        //you may not use this file except in compliance with the License.
        //You may obtain a copy of the License at
        //
        //    http://mozilla.org/MPL/2.0/
        //
        //
        //Unless required by applicable law or agreed to in writing, software
        //distributed under the License is distributed on an "AS IS" BASIS,
        //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        //See the License for the specific language governing permissions and
        //limitations under the License.
        // Available actions: Create, Update (owner, group, access_control), Delete and Import existing FileSystem(Namespace directory) from Powerscale array.
        // After `pulumi up` of this example file it will create a new FileSystem(Namespace directory) with the name set in `name` attribute in the directory path provided in `directory_path`on the PowerScale array
        // PowerScale FileSystem Resource allows you to manage the Namespace Directory on the Powerscale array
        var fileSystemTest = new Filesystem("fileSystemTest", FilesystemArgs.builder()
            .name("DirTf")
            .group(FilesystemGroupArgs.builder()
                .id("GID:0")
                .name("wheel")
                .type("group")
                .build())
            .owner(FilesystemOwnerArgs.builder()
                .id("UID:1501")
                .name("Guest")
                .type("user")
                .build())
            .recursive(true)
            .overwrite(false)
            .build());

        // Steps to create a file system using the SID.
        // First use the user datasource to get the UID using the SID.
        final var getUserWithSID = PowerscaleFunctions.getUser(GetUserArgs.builder()
            .filter(GetUserFilterArgs.builder()
                .names(GetUserFilterNameArgs.builder()
                    .name("Guest")
                    .sid("S-1-5-21-3219966720-1480896164-796802738-501")
                    .build())
                .build())
            .build());

        // Once you get the UID using the datasource , use that UID while creating your fileystem.
        var ifsTestdir = new Filesystem("ifsTestdir", FilesystemArgs.builder()
            .accessControl("0770")
            .directoryPath("/ifs")
            .fullPath("/ifs/new-fs")
            .group(FilesystemGroupArgs.builder()
                .id("GID:1800")
                .name("Isilon Users")
                .type("group")
                .build())
            .name("new-fs")
            .overwrite(false)
            .owner(FilesystemOwnerArgs.builder()
                .id(getUserWithSID.users()[0].uid())
                .name("Guest")
                .type("user")
                .build())
            .recursive(true)
            .build());

    }
}

resources:
  # /*
  # Copyright (c) 2023-2024 Dell Inc., or its subsidiaries. All Rights Reserved.

  # Licensed under the Mozilla Public License Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at

  #     http://mozilla.org/MPL/2.0/


  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  # */


  # Available actions: Create, Update (owner, group, access_control), Delete and Import existing FileSystem(Namespace directory) from Powerscale array.
  # After `pulumi up` of this example file it will create a new FileSystem(Namespace directory) with the name set in `name` attribute in the directory path provided in `directory_path`on the PowerScale array

  # PowerScale FileSystem Resource allows you to manage the Namespace Directory on the Powerscale array
  fileSystemTest: # Steps to create a file system using the SID.
    type: powerscale:Filesystem
    name: file_system_test
    properties:
      name: DirTf
      group:
        id: GID:0
        name: wheel
        type: group
      owner:
        id: UID:1501
        name: Guest
        type: user
      recursive: true # Deletes and replaces the existing user attributes and ACLs of the directory with user-specified attributes and ACLS, when set to true.
      overwrite: false # access_control = "0777"
  # Once you get the UID using the datasource , use that UID while creating your fileystem.
  ifsTestdir:
    type: powerscale:Filesystem
    name: ifs_testdir
    properties:
      accessControl: '0770'
      directoryPath: /ifs
      fullPath: /ifs/new-fs
      group:
        id: GID:1800
        name: Isilon Users
        type: group
      name: new-fs
      overwrite: false
      owner:
        id: ${getUserWithSID.users[0].uid}
        name: Guest
        type: user
      recursive: true
variables:
  # First use the user datasource to get the UID using the SID.
  getUserWithSID:
    fn::invoke:
      function: powerscale:getUser
      arguments:
        filter:
          names:
            - name: Guest
              sid: S-1-5-21-3219966720-1480896164-796802738-501

var filesystemResource = new Powerscale.Filesystem("filesystemResource", new()
{
    Group = new Powerscale.Inputs.FilesystemGroupArgs
    {
        Id = "string",
        Name = "string",
        Type = "string",
    },
    Owner = new Powerscale.Inputs.FilesystemOwnerArgs
    {
        Id = "string",
        Name = "string",
        Type = "string",
    },
    AccessControl = "string",
    DirectoryPath = "string",
    FilesystemId = "string",
    FullPath = "string",
    Name = "string",
    Overwrite = false,
    QueryZone = "string",
    Recursive = false,
});

example, err := powerscale.NewFilesystem(ctx, "filesystemResource", &powerscale.FilesystemArgs{
	Group: &powerscale.FilesystemGroupArgs{
		Id:   pulumi.String("string"),
		Name: pulumi.String("string"),
		Type: pulumi.String("string"),
	},
	Owner: &powerscale.FilesystemOwnerArgs{
		Id:   pulumi.String("string"),
		Name: pulumi.String("string"),
		Type: pulumi.String("string"),
	},
	AccessControl: pulumi.String("string"),
	DirectoryPath: pulumi.String("string"),
	FilesystemId:  pulumi.String("string"),
	FullPath:      pulumi.String("string"),
	Name:          pulumi.String("string"),
	Overwrite:     pulumi.Bool(false),
	QueryZone:     pulumi.String("string"),
	Recursive:     pulumi.Bool(false),
})

var filesystemResource = new Filesystem("filesystemResource", FilesystemArgs.builder()
    .group(FilesystemGroupArgs.builder()
        .id("string")
        .name("string")
        .type("string")
        .build())
    .owner(FilesystemOwnerArgs.builder()
        .id("string")
        .name("string")
        .type("string")
        .build())
    .accessControl("string")
    .directoryPath("string")
    .filesystemId("string")
    .fullPath("string")
    .name("string")
    .overwrite(false)
    .queryZone("string")
    .recursive(false)
    .build());

filesystem_resource = powerscale.Filesystem("filesystemResource",
    group={
        "id": "string",
        "name": "string",
        "type": "string",
    },
    owner={
        "id": "string",
        "name": "string",
        "type": "string",
    },
    access_control="string",
    directory_path="string",
    filesystem_id="string",
    full_path="string",
    name="string",
    overwrite=False,
    query_zone="string",
    recursive=False)

const filesystemResource = new powerscale.Filesystem("filesystemResource", {
    group: {
        id: "string",
        name: "string",
        type: "string",
    },
    owner: {
        id: "string",
        name: "string",
        type: "string",
    },
    accessControl: "string",
    directoryPath: "string",
    filesystemId: "string",
    fullPath: "string",
    name: "string",
    overwrite: false,
    queryZone: "string",
    recursive: false,
});

type: powerscale:Filesystem
properties:
    accessControl: string
    directoryPath: string
    filesystemId: string
    fullPath: string
    group:
        id: string
        name: string
        type: string
    name: string
    overwrite: false
    owner:
        id: string
        name: string
        type: string
    queryZone: string
    recursive: false