API Reference of GS2-Deploy SDK

Model

Stack

Stack

A stack is an entity that sets up resources on GS2 using GS2-Deploy.

The stack is designed to specify a template file, and the template file defines the resources needed on GS2. When GS2-Deploy creates a new or updated stack, it detects changes in the template file and sends the If a resource is added, it is created; if it is changed, it is updated; if it is deleted, it is removed.

This mechanism allows resources on GS2 to be described declaratively and managed in a reproducible manner. This reproducibility allows for error-free execution when migrating settings from the development environment to the production environment, for example.

TypeConditionRequireDefaultLimitationDescription
stackIdstring~ 1024 charsStack GRN
namestring~ 128 charsStack name
descriptionstring~ 1024 charsDescription
templatestring~ 5242880 charsTemplate data
statusenum [
“CREATE_PROCESSING”,
“CREATE_COMPLETE”,
“UPDATE_PROCESSING”,
“UPDATE_COMPLETE”,
“CLEAN_PROCESSING”,
“CLEAN_COMPLETE”,
“DELETE_PROCESSING”,
“DELETE_COMPLETE”,
“ROLLBACK_INITIALIZING”,
“ROLLBACK_PROCESSING”,
“ROLLBACK_COMPLETE”
]
“CREATE_PROCESSING”~ 128 charsExecution state
createdAtlongDatetime of creation
updatedAtlongDatetime of last update
revisionlong0~ 9223372036854775805Revision

Resource

Resource

Sources are areas within the microservice namespace that hold unique data.

TypeConditionRequireDefaultLimitationDescription
resourceIdstring~ 1024 charsResource GRN
typestring~ 1024 charsResource Type
namestring~ 128 charsResource Name
requeststring~ 1048576 charsRequest parameter
responsestring~ 1048576 charsResponse to resource creation/update
rollbackContextenum [
“create”,
“update”,
“delete”
]
~ 128 charsTypes of rollback operations
rollbackRequeststring~ 1048576 charsRequest parameters for rollback
rollbackAfterList<string>[]~ 1000 itemsName of the resource on which you are relying at the time of rollback
outputFieldsList<OutputField>[]~ 1000 itemsFields to be recorded in Output when the resource is created
workIdstring~ 1024 charsExecution ID at the time this resource was created
createdAtlongDatetime of creation

Event

Event

Events are generated to provide information when operations such as creating, updating, or deleting resources in the stack are performed. Developers can monitor how the stack deployment process and resource changes are progressing and take necessary actions.

TypeConditionRequireDefaultLimitationDescription
eventIdstring~ 1024 charsEvent GRN
namestringUUID~ 36 charsEvent name
resourceNamestring~ 128 charsResource Name
typeenum [
“CREATE_IN_PROGRESS”,
“CREATE_COMPLETE”,
“CREATE_FAILED”,
“UPDATE_IN_PROGRESS”,
“UPDATE_COMPLETE”,
“UPDATE_FAILED”,
“CLEAN_IN_PROGRESS”,
“CLEAN_COMPLETE”,
“CLEAN_FAILED”,
“DELETE_IN_PROGRESS”,
“DELETE_COMPLETE”,
“DELETE_FAILED”,
“ROLLBACK_IN_PROGRESS”,
“ROLLBACK_COMPLETE”,
“ROLLBACK_FAILED”
]
~ 128 charsStatus
messagestring~ 5242880 charsMessage
eventAtlongDatetime of creation
revisionlong0~ 9223372036854775805Revision

Output

Output

TypeConditionRequireDefaultLimitationDescription
outputIdstring~ 1024 charsOutput GRN
namestring~ 1024 charsOutput Name
valuestring~ 1048576 charsValue
createdAtlongDatetime of creation

OutputField

Output field

Fields to be recorded in Output when the resource is created

TypeConditionRequireDefaultLimitationDescription
namestring~ 1024 charsName
fieldNamestring~ 1024 charsField name

ChangeSet

Change

TypeConditionRequireDefaultLimitationDescription
resourceNamestring~ 128 charsResource name
resourceTypestring~ 128 charsResource type
operationenum [
“create”,
“update”,
“delete”
]
~ 128 charsChange type

GitHubCheckoutSetting

Setup to check out master data from GitHub

TypeConditionRequireDefaultLimitationDescription
apiKeyIdstring~ 1024 charsGitHub API key GRN
repositoryNamestring~ 1024 charsRepository Name
sourcePathstring~ 1024 charsSource code file path
referenceTypeenum [
“commit_hash”,
“branch”,
“tag”
]
~ 128 charsSource of code
commitHashstring{referenceType} == “commit_hash”~ 1024 charsCommit hash
branchNamestring{referenceType} == “branch”~ 1024 charsBranch Name
tagNamestring{referenceType} == “tag”~ 1024 charsTag Name

Methods

describeStacks

Get list of stacks

Request

TypeConditionRequireDefaultLimitationDescription
pageTokenstring~ 1024 charsToken specifying the position from which to start acquiring data
limitint301 ~ 1000Number of data acquired

Result

TypeDescription
itemsList<Stack>List of Stack
nextPageTokenstringPage token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.DescribeStacks(
    &deploy.DescribeStacksRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\DescribeStacksRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeStacks(
        (new DescribeStacksRequest())
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.DescribeStacksRequest;
import io.gs2.deploy.result.DescribeStacksResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    DescribeStacksResult result = client.describeStacks(
        new DescribeStacksRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Stack> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.DescribeStacksRequest;
using Gs2.Gs2Deploy.Result.DescribeStacksResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.DescribeStacksResult> asyncResult = null;
yield return client.DescribeStacks(
    new Gs2.Gs2Deploy.Request.DescribeStacksRequest()
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.describeStacks(
        new Gs2Deploy.DescribeStacksRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.describe_stacks(
        deploy.DescribeStacksRequest()
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.describe_stacks({
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

createStack

Create new stack

Request

TypeConditionRequireDefaultLimitationDescription
namestring~ 128 charsStack name
descriptionstring~ 1024 charsDescription
templatestring~ 5242880 charsTemplate data

Result

TypeDescription
itemStackStack created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.CreateStack(
    &deploy.CreateStackRequest {
        Name: pointy.String("stack-0001"),
        Description: nil,
        Template: pointy.String("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\CreateStackRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createStack(
        (new CreateStackRequest())
            ->withName("stack-0001")
            ->withDescription(null)
            ->withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.CreateStackRequest;
import io.gs2.deploy.result.CreateStackResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    CreateStackResult result = client.createStack(
        new CreateStackRequest()
            .withName("stack-0001")
            .withDescription(null)
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.CreateStackRequest;
using Gs2.Gs2Deploy.Result.CreateStackResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.CreateStackResult> asyncResult = null;
yield return client.CreateStack(
    new Gs2.Gs2Deploy.Request.CreateStackRequest()
        .WithName("stack-0001")
        .WithDescription(null)
        .WithTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.createStack(
        new Gs2Deploy.CreateStackRequest()
            .withName("stack-0001")
            .withDescription(null)
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.create_stack(
        deploy.CreateStackRequest()
            .with_name('stack-0001')
            .with_description(None)
            .with_template('\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.create_stack({
    name="stack-0001",
    description=nil,
    template="\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

createStackFromGitHub

Create new stack

Request

TypeConditionRequireDefaultLimitationDescription
namestring~ 128 charsStack name
descriptionstring~ 1024 charsDescription
checkoutSettingGitHubCheckoutSettingSetup to check out template file from GitHub

Result

TypeDescription
itemStackStack created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.CreateStackFromGitHub(
    &deploy.CreateStackFromGitHubRequest {
        Name: pointy.String("stack-0001"),
        Description: nil,
        CheckoutSetting: &deploy.GitHubCheckoutSetting{
            ApiKeyId: pointy.String("$gitHubApiKey1.apiKeyId"),
            RepositoryName: pointy.String("gs2io/master-data"),
            SourcePath: pointy.String("path/to/file.json"),
            ReferenceType: pointy.String("branch"),
            BranchName: pointy.String("develop"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\CreateStackFromGitHubRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createStackFromGitHub(
        (new CreateStackFromGitHubRequest())
            ->withName("stack-0001")
            ->withDescription(null)
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId(self::$gitHubApiKey1.apiKeyId)
                ->withRepositoryName("gs2io/master-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.CreateStackFromGitHubRequest;
import io.gs2.deploy.result.CreateStackFromGitHubResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    CreateStackFromGitHubResult result = client.createStackFromGitHub(
        new CreateStackFromGitHubRequest()
            .withName("stack-0001")
            .withDescription(null)
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("$gitHubApiKey1.apiKeyId")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.CreateStackFromGitHubRequest;
using Gs2.Gs2Deploy.Result.CreateStackFromGitHubResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.CreateStackFromGitHubResult> asyncResult = null;
yield return client.CreateStackFromGitHub(
    new Gs2.Gs2Deploy.Request.CreateStackFromGitHubRequest()
        .WithName("stack-0001")
        .WithDescription(null)
        .WithCheckoutSetting(new Gs2.Gs2Deploy.Model.GitHubCheckoutSetting()
            .WithApiKeyId("$gitHubApiKey1.apiKeyId")
            .WithRepositoryName("gs2io/master-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        ),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.createStackFromGitHub(
        new Gs2Deploy.CreateStackFromGitHubRequest()
            .withName("stack-0001")
            .withDescription(null)
            .withCheckoutSetting(new Gs2Deploy.model.GitHubCheckoutSetting()
                .withApiKeyId("$gitHubApiKey1.apiKeyId")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.create_stack_from_git_hub(
        deploy.CreateStackFromGitHubRequest()
            .with_name('stack-0001')
            .with_description(None)
            .with_checkout_setting(deploy.GitHubCheckoutSetting()
                .with_api_key_id(self.git_hub_api_key1.api_key_id)
                .with_repository_name('gs2io/master-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.create_stack_from_git_hub({
    name="stack-0001",
    description=nil,
    checkoutSetting={
        api_key_id="$gitHubApiKey1.apiKeyId",
        repository_name="gs2io/master-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

validate

Validate Template

The validation content of this API only performs a simple validation. Even if the validation passes with this API, an error may still occur when you run it.

Request

TypeConditionRequireDefaultLimitationDescription
templatestring~ 5242880 charsTemplate data

Result

TypeDescription

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.Validate(
    &deploy.ValidateRequest {
        Template: pointy.String("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    }
)
if err != nil {
    panic("error occurred")
}
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\ValidateRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->validate(
        (new ValidateRequest())
            ->withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.ValidateRequest;
import io.gs2.deploy.result.ValidateResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    ValidateResult result = client.validate(
        new ValidateRequest()
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.ValidateRequest;
using Gs2.Gs2Deploy.Result.ValidateResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.ValidateResult> asyncResult = null;
yield return client.Validate(
    new Gs2.Gs2Deploy.Request.ValidateRequest()
        .WithTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.validate(
        new Gs2Deploy.ValidateRequest()
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.validate(
        deploy.ValidateRequest()
            .with_template('\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n')
    )
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.validate({
    template="\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

getStackStatus

Get Stack

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name

Result

TypeDescription
statusstring

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.GetStackStatus(
    &deploy.GetStackStatusRequest {
        StackName: pointy.String("stack-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
status := result.Status
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\GetStackStatusRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getStackStatus(
        (new GetStackStatusRequest())
            ->withStackName("stack-0001")
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.GetStackStatusRequest;
import io.gs2.deploy.result.GetStackStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    GetStackStatusResult result = client.getStackStatus(
        new GetStackStatusRequest()
            .withStackName("stack-0001")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.GetStackStatusRequest;
using Gs2.Gs2Deploy.Result.GetStackStatusResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.GetStackStatusResult> asyncResult = null;
yield return client.GetStackStatus(
    new Gs2.Gs2Deploy.Request.GetStackStatusRequest()
        .WithStackName("stack-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.getStackStatus(
        new Gs2Deploy.GetStackStatusRequest()
            .withStackName("stack-0001")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.get_stack_status(
        deploy.GetStackStatusRequest()
            .with_stack_name('stack-0001')
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.get_stack_status({
    stackName="stack-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
status = result.status;

getStack

Get Stack

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name

Result

TypeDescription
itemStackStack

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.GetStack(
    &deploy.GetStackRequest {
        StackName: pointy.String("stack-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\GetStackRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getStack(
        (new GetStackRequest())
            ->withStackName("stack-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.GetStackRequest;
import io.gs2.deploy.result.GetStackResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    GetStackResult result = client.getStack(
        new GetStackRequest()
            .withStackName("stack-0001")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.GetStackRequest;
using Gs2.Gs2Deploy.Result.GetStackResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.GetStackResult> asyncResult = null;
yield return client.GetStack(
    new Gs2.Gs2Deploy.Request.GetStackRequest()
        .WithStackName("stack-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.getStack(
        new Gs2Deploy.GetStackRequest()
            .withStackName("stack-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.get_stack(
        deploy.GetStackRequest()
            .with_stack_name('stack-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.get_stack({
    stackName="stack-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateStack

Update Stack

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
descriptionstring~ 1024 charsDescription
templatestring~ 5242880 charsTemplate data

Result

TypeDescription
itemStackUpdated Stack

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.UpdateStack(
    &deploy.UpdateStackRequest {
        StackName: pointy.String("stack-0001"),
        Description: nil,
        Template: pointy.String("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\UpdateStackRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateStack(
        (new UpdateStackRequest())
            ->withStackName("stack-0001")
            ->withDescription(null)
            ->withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.UpdateStackRequest;
import io.gs2.deploy.result.UpdateStackResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    UpdateStackResult result = client.updateStack(
        new UpdateStackRequest()
            .withStackName("stack-0001")
            .withDescription(null)
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.UpdateStackRequest;
using Gs2.Gs2Deploy.Result.UpdateStackResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.UpdateStackResult> asyncResult = null;
yield return client.UpdateStack(
    new Gs2.Gs2Deploy.Request.UpdateStackRequest()
        .WithStackName("stack-0001")
        .WithDescription(null)
        .WithTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.updateStack(
        new Gs2Deploy.UpdateStackRequest()
            .withStackName("stack-0001")
            .withDescription(null)
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.update_stack(
        deploy.UpdateStackRequest()
            .with_stack_name('stack-0001')
            .with_description(None)
            .with_template('\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.update_stack({
    stackName="stack-0001",
    description=nil,
    template="\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

changeSet

Get Change Set

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
templatestring~ 5242880 charsTemplate data

Result

TypeDescription
itemsList<ChangeSet>List of Stack

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.ChangeSet(
    &deploy.ChangeSetRequest {
        StackName: pointy.String("stack-0001"),
        Template: pointy.String("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\ChangeSetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->changeSet(
        (new ChangeSetRequest())
            ->withStackName("stack-0001")
            ->withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    $items = $result->getItems();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.ChangeSetRequest;
import io.gs2.deploy.result.ChangeSetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    ChangeSetResult result = client.changeSet(
        new ChangeSetRequest()
            .withStackName("stack-0001")
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    List<ChangeSet> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.ChangeSetRequest;
using Gs2.Gs2Deploy.Result.ChangeSetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.ChangeSetResult> asyncResult = null;
yield return client.ChangeSet(
    new Gs2.Gs2Deploy.Request.ChangeSetRequest()
        .WithStackName("stack-0001")
        .WithTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.changeSet(
        new Gs2Deploy.ChangeSetRequest()
            .withStackName("stack-0001")
            .withTemplate("\nGS2TemplateFormatVersion: \"2019-05-01\"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.change_set(
        deploy.ChangeSetRequest()
            .with_stack_name('stack-0001')
            .with_template('\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.change_set({
    stackName="stack-0001",
    template="\nGS2TemplateFormatVersion: "2019-05-01"\nDescription: Template Sample\n\nResources:\n  IdentifierAuthUser:\n    Type: GS2::Identifier::User\n    Properties:\n      Name: auth\n\nOutputs:\n  SecretKey: !GetAttr IdentifierAuthUser.Name\n",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

updateStackFromGitHub

Update Stack

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
descriptionstring~ 1024 charsDescription
checkoutSettingGitHubCheckoutSettingSetup to check out template file from GitHub

Result

TypeDescription
itemStackUpdated Stack

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.UpdateStackFromGitHub(
    &deploy.UpdateStackFromGitHubRequest {
        StackName: pointy.String("stack-0001"),
        Description: nil,
        CheckoutSetting: &deploy.GitHubCheckoutSetting{
            ApiKeyId: pointy.String("$gitHubApiKey1.apiKeyId"),
            RepositoryName: pointy.String("gs2io/master-data"),
            SourcePath: pointy.String("path/to/file.json"),
            ReferenceType: pointy.String("branch"),
            BranchName: pointy.String("develop"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\UpdateStackFromGitHubRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateStackFromGitHub(
        (new UpdateStackFromGitHubRequest())
            ->withStackName("stack-0001")
            ->withDescription(null)
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId(self::$gitHubApiKey1.apiKeyId)
                ->withRepositoryName("gs2io/master-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.UpdateStackFromGitHubRequest;
import io.gs2.deploy.result.UpdateStackFromGitHubResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    UpdateStackFromGitHubResult result = client.updateStackFromGitHub(
        new UpdateStackFromGitHubRequest()
            .withStackName("stack-0001")
            .withDescription(null)
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("$gitHubApiKey1.apiKeyId")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.UpdateStackFromGitHubRequest;
using Gs2.Gs2Deploy.Result.UpdateStackFromGitHubResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.UpdateStackFromGitHubResult> asyncResult = null;
yield return client.UpdateStackFromGitHub(
    new Gs2.Gs2Deploy.Request.UpdateStackFromGitHubRequest()
        .WithStackName("stack-0001")
        .WithDescription(null)
        .WithCheckoutSetting(new Gs2.Gs2Deploy.Model.GitHubCheckoutSetting()
            .WithApiKeyId("$gitHubApiKey1.apiKeyId")
            .WithRepositoryName("gs2io/master-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        ),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.updateStackFromGitHub(
        new Gs2Deploy.UpdateStackFromGitHubRequest()
            .withStackName("stack-0001")
            .withDescription(null)
            .withCheckoutSetting(new Gs2Deploy.model.GitHubCheckoutSetting()
                .withApiKeyId("$gitHubApiKey1.apiKeyId")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.update_stack_from_git_hub(
        deploy.UpdateStackFromGitHubRequest()
            .with_stack_name('stack-0001')
            .with_description(None)
            .with_checkout_setting(deploy.GitHubCheckoutSetting()
                .with_api_key_id(self.git_hub_api_key1.api_key_id)
                .with_repository_name('gs2io/master-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.update_stack_from_git_hub({
    stackName="stack-0001",
    description=nil,
    checkoutSetting={
        api_key_id="$gitHubApiKey1.apiKeyId",
        repository_name="gs2io/master-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteStack

Delete Stack

Deletes the resources created by the stack and, if successful, deletes the entity. If for some reason the resource deletion fails, the entity remains.

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name

Result

TypeDescription
itemStackDeleted stacks

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.DeleteStack(
    &deploy.DeleteStackRequest {
        StackName: pointy.String("stack-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\DeleteStackRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteStack(
        (new DeleteStackRequest())
            ->withStackName("stack-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.DeleteStackRequest;
import io.gs2.deploy.result.DeleteStackResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    DeleteStackResult result = client.deleteStack(
        new DeleteStackRequest()
            .withStackName("stack-0001")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.DeleteStackRequest;
using Gs2.Gs2Deploy.Result.DeleteStackResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.DeleteStackResult> asyncResult = null;
yield return client.DeleteStack(
    new Gs2.Gs2Deploy.Request.DeleteStackRequest()
        .WithStackName("stack-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.deleteStack(
        new Gs2Deploy.DeleteStackRequest()
            .withStackName("stack-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.delete_stack(
        deploy.DeleteStackRequest()
            .with_stack_name('stack-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.delete_stack({
    stackName="stack-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

forceDeleteStack

Forced final deletion of stack

Forcibly deletes entities in the stack. If any resources created by the stack remain, they are not deleted.

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name

Result

TypeDescription
itemStackDeleted stacks

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.ForceDeleteStack(
    &deploy.ForceDeleteStackRequest {
        StackName: pointy.String("stack-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\ForceDeleteStackRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->forceDeleteStack(
        (new ForceDeleteStackRequest())
            ->withStackName("stack-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.ForceDeleteStackRequest;
import io.gs2.deploy.result.ForceDeleteStackResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    ForceDeleteStackResult result = client.forceDeleteStack(
        new ForceDeleteStackRequest()
            .withStackName("stack-0001")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.ForceDeleteStackRequest;
using Gs2.Gs2Deploy.Result.ForceDeleteStackResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.ForceDeleteStackResult> asyncResult = null;
yield return client.ForceDeleteStack(
    new Gs2.Gs2Deploy.Request.ForceDeleteStackRequest()
        .WithStackName("stack-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.forceDeleteStack(
        new Gs2Deploy.ForceDeleteStackRequest()
            .withStackName("stack-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.force_delete_stack(
        deploy.ForceDeleteStackRequest()
            .with_stack_name('stack-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.force_delete_stack({
    stackName="stack-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteStackResources

Delete Stack Resources

Deletes resources created by the stack. It behaves much like updating the stack with an empty template, but since the template that was applied to the stack remains, the resource can be restored from the remaining template in the event of a mishandling.

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name

Result

TypeDescription
itemStackStack of deleted resources

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.DeleteStackResources(
    &deploy.DeleteStackResourcesRequest {
        StackName: pointy.String("stack-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\DeleteStackResourcesRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteStackResources(
        (new DeleteStackResourcesRequest())
            ->withStackName("stack-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.DeleteStackResourcesRequest;
import io.gs2.deploy.result.DeleteStackResourcesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    DeleteStackResourcesResult result = client.deleteStackResources(
        new DeleteStackResourcesRequest()
            .withStackName("stack-0001")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.DeleteStackResourcesRequest;
using Gs2.Gs2Deploy.Result.DeleteStackResourcesResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.DeleteStackResourcesResult> asyncResult = null;
yield return client.DeleteStackResources(
    new Gs2.Gs2Deploy.Request.DeleteStackResourcesRequest()
        .WithStackName("stack-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.deleteStackResources(
        new Gs2Deploy.DeleteStackResourcesRequest()
            .withStackName("stack-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.delete_stack_resources(
        deploy.DeleteStackResourcesRequest()
            .with_stack_name('stack-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.delete_stack_resources({
    stackName="stack-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteStackEntity

Final Stack Deletion

Deletes entities in the stack. Attempting to delete a stack with remaining resources will result in an error.

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name

Result

TypeDescription
itemStackDeleted stacks

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.DeleteStackEntity(
    &deploy.DeleteStackEntityRequest {
        StackName: pointy.String("stack-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\DeleteStackEntityRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteStackEntity(
        (new DeleteStackEntityRequest())
            ->withStackName("stack-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.DeleteStackEntityRequest;
import io.gs2.deploy.result.DeleteStackEntityResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    DeleteStackEntityResult result = client.deleteStackEntity(
        new DeleteStackEntityRequest()
            .withStackName("stack-0001")
    );
    Stack item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.DeleteStackEntityRequest;
using Gs2.Gs2Deploy.Result.DeleteStackEntityResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.DeleteStackEntityResult> asyncResult = null;
yield return client.DeleteStackEntity(
    new Gs2.Gs2Deploy.Request.DeleteStackEntityRequest()
        .WithStackName("stack-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.deleteStackEntity(
        new Gs2Deploy.DeleteStackEntityRequest()
            .withStackName("stack-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.delete_stack_entity(
        deploy.DeleteStackEntityRequest()
            .with_stack_name('stack-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.delete_stack_entity({
    stackName="stack-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeResources

Get list of resources

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
pageTokenstring~ 1024 charsToken specifying the position from which to start acquiring data
limitint301 ~ 1000Number of data acquired

Result

TypeDescription
itemsList<Resource>List of Resource
nextPageTokenstringPage token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.DescribeResources(
    &deploy.DescribeResourcesRequest {
        StackName: pointy.String("stack-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\DescribeResourcesRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeResources(
        (new DescribeResourcesRequest())
            ->withStackName("stack-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.DescribeResourcesRequest;
import io.gs2.deploy.result.DescribeResourcesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    DescribeResourcesResult result = client.describeResources(
        new DescribeResourcesRequest()
            .withStackName("stack-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Resource> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.DescribeResourcesRequest;
using Gs2.Gs2Deploy.Result.DescribeResourcesResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.DescribeResourcesResult> asyncResult = null;
yield return client.DescribeResources(
    new Gs2.Gs2Deploy.Request.DescribeResourcesRequest()
        .WithStackName("stack-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.describeResources(
        new Gs2Deploy.DescribeResourcesRequest()
            .withStackName("stack-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.describe_resources(
        deploy.DescribeResourcesRequest()
            .with_stack_name('stack-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.describe_resources({
    stackName="stack-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getResource

Get Resources

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
resourceNamestring~ 128 charsResource Name

Result

TypeDescription
itemResourceResource

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.GetResource(
    &deploy.GetResourceRequest {
        StackName: pointy.String("stack-0001"),
        ResourceName: pointy.String("resource-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\GetResourceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getResource(
        (new GetResourceRequest())
            ->withStackName("stack-0001")
            ->withResourceName("resource-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.GetResourceRequest;
import io.gs2.deploy.result.GetResourceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    GetResourceResult result = client.getResource(
        new GetResourceRequest()
            .withStackName("stack-0001")
            .withResourceName("resource-0001")
    );
    Resource item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.GetResourceRequest;
using Gs2.Gs2Deploy.Result.GetResourceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.GetResourceResult> asyncResult = null;
yield return client.GetResource(
    new Gs2.Gs2Deploy.Request.GetResourceRequest()
        .WithStackName("stack-0001")
        .WithResourceName("resource-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.getResource(
        new Gs2Deploy.GetResourceRequest()
            .withStackName("stack-0001")
            .withResourceName("resource-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.get_resource(
        deploy.GetResourceRequest()
            .with_stack_name('stack-0001')
            .with_resource_name('resource-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.get_resource({
    stackName="stack-0001",
    resourceName="resource-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeEvents

Get list of events

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
pageTokenstring~ 1024 charsToken specifying the position from which to start acquiring data
limitint301 ~ 1000Number of data acquired

Result

TypeDescription
itemsList<Event>List of Event
nextPageTokenstringPage token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.DescribeEvents(
    &deploy.DescribeEventsRequest {
        StackName: pointy.String("stack-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\DescribeEventsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeEvents(
        (new DescribeEventsRequest())
            ->withStackName("stack-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.DescribeEventsRequest;
import io.gs2.deploy.result.DescribeEventsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    DescribeEventsResult result = client.describeEvents(
        new DescribeEventsRequest()
            .withStackName("stack-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Event> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}
using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Deploy.Gs2DeployRestClient;
using Gs2.Gs2Deploy.Request.DescribeEventsRequest;
using Gs2.Gs2Deploy.Result.DescribeEventsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2DeployRestClient(session);

AsyncResult<Gs2.Gs2Deploy.Result.DescribeEventsResult> asyncResult = null;
yield return client.DescribeEvents(
    new Gs2.Gs2Deploy.Request.DescribeEventsRequest()
        .WithStackName("stack-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
import Gs2Core from '@/gs2/core';
import * as Gs2Deploy from '@/gs2/deploy';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Deploy.Gs2DeployRestClient(session);

try {
    const result = await client.describeEvents(
        new Gs2Deploy.DescribeEventsRequest()
            .withStackName("stack-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import deploy

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = deploy.Gs2DeployRestClient(session)

try:
    result = client.describe_events(
        deploy.DescribeEventsRequest()
            .with_stack_name('stack-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)
client = gs2('deploy')

api_result = client.describe_events({
    stackName="stack-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getEvent

Get Event

Request

TypeConditionRequireDefaultLimitationDescription
stackNamestring~ 128 charsStack name
eventNamestringUUID~ 36 charsEvent name

Result

TypeDescription
itemEventEvent

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/deploy"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := deploy.Gs2DeployRestClient{
    Session: &session,
}
result, err := client.GetEvent(
    &deploy.GetEventRequest {
        StackName: pointy.String("stack-0001"),
        EventName: pointy.String("event-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Deploy\Gs2DeployRestClient;
use Gs2\Deploy\Request\GetEventRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getEvent(
        (new GetEventRequest())
            ->withStackName("stack-0001")
            ->withEventName("event-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.deploy.rest.Gs2DeployRestClient;
import io.gs2.deploy.request.GetEventRequest;
import io.gs2.deploy.result.GetEventResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2DeployRestClient client = new Gs2DeployRestClient(session);

try {
    GetEventResult result = client.getEvent(
        new GetEventRequest()
            .withStackName("stack-0001")
            .withEventName("event-0001")