API Reference of GS2-Script SDK

Model

Namespace

Namespace

Namespace is a mechanism that allows multiple uses of the same service for different purposes within a single project. Basically, GS2 services have a layer called namespace, and different namespaces are treated as completely different data spaces, even for the same service.

Therefore, it is necessary to create a namespace before starting to use each service.

TypeConditionRequireDefaultLimitationDescription
namespaceIdstring~ 1024 charsNamespace GRN
namestring~ 32 charsNamespace name
descriptionstring~ 1024 charsdescription of Namespace
logSettingLogSettingLog output settings
createdAtlongDatetime of creation
updatedAtlongDatetime of last update
revisionlong0~ 9223372036854775805Revision

Script

Script

GS2 provides scripts to extend functionality when the standard functions are not sufficient. Scripts can be written in the Lua language.

Scripts can also retrieve data from GS2 services, allowing for flexible processing. Please refer to the documentation for details.

TypeConditionRequireDefaultLimitationDescription
scriptIdstring~ 1024 charsScript GRN
namestring~ 128 charsScript Name
descriptionstring~ 1024 charsdescription of Namespace
scriptstring~ 5242880 charsLua Script
createdAtlongDatetime of creation
updatedAtlongDatetime of last update
revisionlong0~ 9223372036854775805Revision

GitHubCheckoutSetting

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

LogSetting

TypeConditionRequireDefaultLimitationDescription
loggingNamespaceIdstring~ 1024 charsNamespace GRN

RandomStatus

TypeConditionRequireDefaultLimitationDescription
seedlong~ 4294967294Random seed
usedList<RandomUsed>~ 1000 itemsList of used random number

RandomUsed

TypeConditionRequireDefaultLimitationDescription
categorylong~ 4294967294Category
usedlong~ 4294967294Used random number

Methods

describeNamespaces

Get list of namespaces

Request

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

Result

TypeDescription
itemsList<Namespace>List of Namespace
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/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &script.DescribeNamespacesRequest {
        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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DescribeNamespacesRequest;
import io.gs2.script.result.DescribeNamespacesResult;

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

try {
    DescribeNamespacesResult result = client.describeNamespaces(
        new DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.DescribeNamespacesRequest;
using Gs2.Gs2Script.Result.DescribeNamespacesResult;

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

AsyncResult<Gs2.Gs2Script.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2Script.Request.DescribeNamespacesRequest()
        .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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.describeNamespaces(
        new Gs2Script.DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.describe_namespaces(
        script.DescribeNamespacesRequest()
            .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('script')

api_result = client.describe_namespaces({
    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;

createNamespace

Create a new namespace

Request

TypeConditionRequireDefaultLimitationDescription
namestring~ 32 charsNamespace name
descriptionstring~ 1024 charsdescription of Namespace
logSettingLogSettingLog output settings

Result

TypeDescription
itemNamespaceNamespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &script.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        LogSetting: &script.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName(self::namespace1)
            ->withDescription(null)
            ->withLogSetting((new \Gs2\Script\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.CreateNamespaceRequest;
import io.gs2.script.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withLogSetting(new io.gs2.script.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    Namespace 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.CreateNamespaceRequest;
using Gs2.Gs2Script.Result.CreateNamespaceResult;

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

AsyncResult<Gs2.Gs2Script.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Script.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithLogSetting(new Gs2.Gs2Script.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1")),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.createNamespace(
        new Gs2Script.CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withLogSetting(new Gs2Script.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.create_namespace(
        script.CreateNamespaceRequest()
            .with_name(self.hash1)
            .with_description(None)
            .with_log_setting(
                script.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.create_namespace({
    name='namespace1',
    description=nil,
    logSetting={
        loggingNamespaceId='grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1',
    },
})

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

result = api_result.result
item = result.item;

getNamespaceStatus

Get namespace status

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name

Result

TypeDescription
statusstring

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &script.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.GetNamespaceStatusRequest;
import io.gs2.script.result.GetNamespaceStatusResult;

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

try {
    GetNamespaceStatusResult result = client.getNamespaceStatus(
        new GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.GetNamespaceStatusRequest;
using Gs2.Gs2Script.Result.GetNamespaceStatusResult;

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

AsyncResult<Gs2.Gs2Script.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Script.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace1"),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.getNamespaceStatus(
        new Gs2Script.GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.get_namespace_status(
        script.GetNamespaceStatusRequest()
            .with_namespace_name(self.hash1)
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.get_namespace_status({
    namespaceName='namespace1',
})

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

result = api_result.result
status = result.status;

getNamespace

Get namespace

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name

Result

TypeDescription
itemNamespaceNamespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &script.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.GetNamespaceRequest;
import io.gs2.script.result.GetNamespaceResult;

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

try {
    GetNamespaceResult result = client.getNamespace(
        new GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.GetNamespaceRequest;
using Gs2.Gs2Script.Result.GetNamespaceResult;

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

AsyncResult<Gs2.Gs2Script.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Script.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace1"),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.getNamespace(
        new Gs2Script.GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.get_namespace(
        script.GetNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.get_namespace({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

updateNamespace

Update namespace

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
descriptionstring~ 1024 charsdescription of Namespace
logSettingLogSettingLog output settings

Result

TypeDescription
itemNamespaceUpdated namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &script.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        LogSetting: &script.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName(self::namespace1)
            ->withDescription("description1")
            ->withLogSetting((new \Gs2\Script\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.UpdateNamespaceRequest;
import io.gs2.script.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withLogSetting(new io.gs2.script.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    Namespace 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.UpdateNamespaceRequest;
using Gs2.Gs2Script.Result.UpdateNamespaceResult;

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

AsyncResult<Gs2.Gs2Script.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Script.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithLogSetting(new Gs2.Gs2Script.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1")),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.updateNamespace(
        new Gs2Script.UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withLogSetting(new Gs2Script.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.update_namespace(
        script.UpdateNamespaceRequest()
            .with_namespace_name(self.hash1)
            .with_description('description1')
            .with_log_setting(
                script.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.update_namespace({
    namespaceName='namespace1',
    description='description1',
    logSetting={
        loggingNamespaceId='grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1',
    },
})

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

result = api_result.result
item = result.item;

deleteNamespace

Delete namespace

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name

Result

TypeDescription
itemNamespaceDeleted namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &script.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DeleteNamespaceRequest;
import io.gs2.script.result.DeleteNamespaceResult;

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

try {
    DeleteNamespaceResult result = client.deleteNamespace(
        new DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.DeleteNamespaceRequest;
using Gs2.Gs2Script.Result.DeleteNamespaceResult;

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

AsyncResult<Gs2.Gs2Script.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Script.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace1"),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.deleteNamespace(
        new Gs2Script.DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.delete_namespace(
        script.DeleteNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.delete_namespace({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

describeScripts

Get list of scripts

Request

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

Result

TypeDescription
itemsList<Script>List of Scripts
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/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.DescribeScripts(
    &script.DescribeScriptsRequest {
        NamespaceName: pointy.String("namespace1"),
        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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DescribeScriptsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeScripts(
        (new DescribeScriptsRequest())
            ->withNamespaceName(self::namespace1)
            ->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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DescribeScriptsRequest;
import io.gs2.script.result.DescribeScriptsResult;

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

try {
    DescribeScriptsResult result = client.describeScripts(
        new DescribeScriptsRequest()
            .withNamespaceName("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Script> 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.DescribeScriptsRequest;
using Gs2.Gs2Script.Result.DescribeScriptsResult;

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

AsyncResult<Gs2.Gs2Script.Result.DescribeScriptsResult> asyncResult = null;
yield return client.DescribeScripts(
    new Gs2.Gs2Script.Request.DescribeScriptsRequest()
        .WithNamespaceName("namespace1")
        .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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.describeScripts(
        new Gs2Script.DescribeScriptsRequest()
            .withNamespaceName("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.describe_scripts(
        script.DescribeScriptsRequest()
            .with_namespace_name(self.hash1)
            .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('script')

api_result = client.describe_scripts({
    namespaceName='namespace1',
    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;

createScript

Create a new script

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
namestring~ 128 charsScript Name
descriptionstring~ 1024 charsdescription of Namespace
scriptstring~ 5242880 charsLua Script

Result

TypeDescription
itemScriptCreated Script

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.CreateScript(
    &script.CreateScriptRequest {
        NamespaceName: pointy.String("namespace1"),
        Name: pointy.String("script-0001"),
        Description: nil,
        Script: pointy.String("result = {permit=true}"),
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\CreateScriptRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createScript(
        (new CreateScriptRequest())
            ->withNamespaceName(self::namespace1)
            ->withName("script-0001")
            ->withDescription(null)
            ->withScript("result = {permit=true}")
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.CreateScriptRequest;
import io.gs2.script.result.CreateScriptResult;

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

try {
    CreateScriptResult result = client.createScript(
        new CreateScriptRequest()
            .withNamespaceName("namespace1")
            .withName("script-0001")
            .withDescription(null)
            .withScript("result = {permit=true}")
    );
    Script 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.CreateScriptRequest;
using Gs2.Gs2Script.Result.CreateScriptResult;

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

AsyncResult<Gs2.Gs2Script.Result.CreateScriptResult> asyncResult = null;
yield return client.CreateScript(
    new Gs2.Gs2Script.Request.CreateScriptRequest()
        .WithNamespaceName("namespace1")
        .WithName("script-0001")
        .WithDescription(null)
        .WithScript("result = {permit=true}"),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.createScript(
        new Gs2Script.CreateScriptRequest()
            .withNamespaceName("namespace1")
            .withName("script-0001")
            .withDescription(null)
            .withScript("result = {permit=true}")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.create_script(
        script.CreateScriptRequest()
            .with_namespace_name(self.hash1)
            .with_name('script-0001')
            .with_description(None)
            .with_script('result = {permit=true}')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.create_script({
    namespaceName='namespace1',
    name='script-0001',
    description=nil,
    script='result = {permit=true}',
})

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

result = api_result.result
item = result.item;

createScriptFromGitHub

Create a new script from code in the GitHub repository

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
namestring~ 128 charsScript Name
descriptionstring~ 1024 charsdescription of Namespace
checkoutSettingGitHubCheckoutSettingSetup to check out source code from GitHub

Result

TypeDescription
itemScriptCreated Script

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.CreateScriptFromGitHub(
    &script.CreateScriptFromGitHubRequest {
        NamespaceName: pointy.String("namespace1"),
        Name: pointy.String("script-0001"),
        Description: nil,
        CheckoutSetting: {'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\CreateScriptFromGitHubRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createScriptFromGitHub(
        (new CreateScriptFromGitHubRequest())
            ->withNamespaceName(self::namespace1)
            ->withName("script-0001")
            ->withDescription(null)
            ->withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.CreateScriptFromGitHubRequest;
import io.gs2.script.result.CreateScriptFromGitHubResult;

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

try {
    CreateScriptFromGitHubResult result = client.createScriptFromGitHub(
        new CreateScriptFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withName("script-0001")
            .withDescription(null)
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    Script 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.CreateScriptFromGitHubRequest;
using Gs2.Gs2Script.Result.CreateScriptFromGitHubResult;

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

AsyncResult<Gs2.Gs2Script.Result.CreateScriptFromGitHubResult> asyncResult = null;
yield return client.CreateScriptFromGitHub(
    new Gs2.Gs2Script.Request.CreateScriptFromGitHubRequest()
        .WithNamespaceName("namespace1")
        .WithName("script-0001")
        .WithDescription(null)
        .WithCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.createScriptFromGitHub(
        new Gs2Script.CreateScriptFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withName("script-0001")
            .withDescription(null)
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.create_script_from_git_hub(
        script.CreateScriptFromGitHubRequest()
            .with_namespace_name(self.hash1)
            .with_name('script-0001')
            .with_description(None)
            .with_checkout_setting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.create_script_from_git_hub({
    namespaceName='namespace1',
    name='script-0001',
    description=nil,
    checkoutSetting={'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'},
})

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

result = api_result.result
item = result.item;

getScript

Get Script

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
scriptNamestring~ 128 charsScript Name

Result

TypeDescription
itemScriptScript

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.GetScript(
    &script.GetScriptRequest {
        NamespaceName: pointy.String("namespace1"),
        ScriptName: pointy.String("script-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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetScriptRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getScript(
        (new GetScriptRequest())
            ->withNamespaceName(self::namespace1)
            ->withScriptName("script-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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.GetScriptRequest;
import io.gs2.script.result.GetScriptResult;

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

try {
    GetScriptResult result = client.getScript(
        new GetScriptRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
    );
    Script 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.GetScriptRequest;
using Gs2.Gs2Script.Result.GetScriptResult;

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

AsyncResult<Gs2.Gs2Script.Result.GetScriptResult> asyncResult = null;
yield return client.GetScript(
    new Gs2.Gs2Script.Request.GetScriptRequest()
        .WithNamespaceName("namespace1")
        .WithScriptName("script-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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.getScript(
        new Gs2Script.GetScriptRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.get_script(
        script.GetScriptRequest()
            .with_namespace_name(self.hash1)
            .with_script_name('script-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.get_script({
    namespaceName='namespace1',
    scriptName='script-0001',
})

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

result = api_result.result
item = result.item;

updateScript

Update Script

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
scriptNamestring~ 128 charsScript Name
descriptionstring~ 1024 charsdescription of Namespace
scriptstring~ 5242880 charsLua Script

Result

TypeDescription
itemScriptUpdated Script

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.UpdateScript(
    &script.UpdateScriptRequest {
        NamespaceName: pointy.String("namespace1"),
        ScriptName: pointy.String("script-0001"),
        Description: pointy.String("description1"),
        Script: pointy.String("result = \"hogehoge\""),
    }
)
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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\UpdateScriptRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateScript(
        (new UpdateScriptRequest())
            ->withNamespaceName(self::namespace1)
            ->withScriptName("script-0001")
            ->withDescription("description1")
            ->withScript("result = \"hogehoge\"")
    );
    $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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.UpdateScriptRequest;
import io.gs2.script.result.UpdateScriptResult;

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

try {
    UpdateScriptResult result = client.updateScript(
        new UpdateScriptRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
            .withDescription("description1")
            .withScript("result = \"hogehoge\"")
    );
    Script 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.UpdateScriptRequest;
using Gs2.Gs2Script.Result.UpdateScriptResult;

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

AsyncResult<Gs2.Gs2Script.Result.UpdateScriptResult> asyncResult = null;
yield return client.UpdateScript(
    new Gs2.Gs2Script.Request.UpdateScriptRequest()
        .WithNamespaceName("namespace1")
        .WithScriptName("script-0001")
        .WithDescription("description1")
        .WithScript("result = \"hogehoge\""),
    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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.updateScript(
        new Gs2Script.UpdateScriptRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
            .withDescription("description1")
            .withScript("result = \"hogehoge\"")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.update_script(
        script.UpdateScriptRequest()
            .with_namespace_name(self.hash1)
            .with_script_name('script-0001')
            .with_description('description1')
            .with_script('result = "hogehoge"')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.update_script({
    namespaceName='namespace1',
    scriptName='script-0001',
    description='description1',
    script='result = "hogehoge"',
})

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

result = api_result.result
item = result.item;

updateScriptFromGitHub

Update scripts using GitHub as a data source

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
scriptNamestring~ 128 charsScript Name
descriptionstring~ 1024 charsdescription of Namespace
checkoutSettingGitHubCheckoutSettingSetup to check out source code from GitHub

Result

TypeDescription
itemScriptUpdated Script

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.UpdateScriptFromGitHub(
    &script.UpdateScriptFromGitHubRequest {
        NamespaceName: pointy.String("namespace1"),
        ScriptName: pointy.String("script-0001"),
        Description: nil,
        CheckoutSetting: {'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\UpdateScriptFromGitHubRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateScriptFromGitHub(
        (new UpdateScriptFromGitHubRequest())
            ->withNamespaceName(self::namespace1)
            ->withScriptName("script-0001")
            ->withDescription(null)
            ->withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.UpdateScriptFromGitHubRequest;
import io.gs2.script.result.UpdateScriptFromGitHubResult;

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

try {
    UpdateScriptFromGitHubResult result = client.updateScriptFromGitHub(
        new UpdateScriptFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
            .withDescription(null)
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    Script 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.UpdateScriptFromGitHubRequest;
using Gs2.Gs2Script.Result.UpdateScriptFromGitHubResult;

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

AsyncResult<Gs2.Gs2Script.Result.UpdateScriptFromGitHubResult> asyncResult = null;
yield return client.UpdateScriptFromGitHub(
    new Gs2.Gs2Script.Request.UpdateScriptFromGitHubRequest()
        .WithNamespaceName("namespace1")
        .WithScriptName("script-0001")
        .WithDescription(null)
        .WithCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.updateScriptFromGitHub(
        new Gs2Script.UpdateScriptFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
            .withDescription(null)
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.update_script_from_git_hub(
        script.UpdateScriptFromGitHubRequest()
            .with_namespace_name(self.hash1)
            .with_script_name('script-0001')
            .with_description(None)
            .with_checkout_setting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.update_script_from_git_hub({
    namespaceName='namespace1',
    scriptName='script-0001',
    description=nil,
    checkoutSetting={'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/script-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'},
})

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

result = api_result.result
item = result.item;

deleteScript

Delete script

Request

TypeConditionRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
scriptNamestring~ 128 charsScript Name

Result

TypeDescription
itemScriptDeleted script

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.DeleteScript(
    &script.DeleteScriptRequest {
        NamespaceName: pointy.String("namespace1"),
        ScriptName: pointy.String("script-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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DeleteScriptRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteScript(
        (new DeleteScriptRequest())
            ->withNamespaceName(self::namespace1)
            ->withScriptName("script-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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DeleteScriptRequest;
import io.gs2.script.result.DeleteScriptResult;

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

try {
    DeleteScriptResult result = client.deleteScript(
        new DeleteScriptRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
    );
    Script 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.DeleteScriptRequest;
using Gs2.Gs2Script.Result.DeleteScriptResult;

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

AsyncResult<Gs2.Gs2Script.Result.DeleteScriptResult> asyncResult = null;
yield return client.DeleteScript(
    new Gs2.Gs2Script.Request.DeleteScriptRequest()
        .WithNamespaceName("namespace1")
        .WithScriptName("script-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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.deleteScript(
        new Gs2Script.DeleteScriptRequest()
            .withNamespaceName("namespace1")
            .withScriptName("script-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.delete_script(
        script.DeleteScriptRequest()
            .with_namespace_name(self.hash1)
            .with_script_name('script-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.delete_script({
    namespaceName='namespace1',
    scriptName='script-0001',
})

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

result = api_result.result
item = result.item;

invokeScript

Execute the script

Request

TypeConditionRequireDefaultLimitationDescription
scriptIdstring~ 1024 charsScript GRN
userIdstring~ 128 charsUser Id
argsstring“{}”~ 5242880 charsArguments (JSON Format)
randomStatusRandomStatusRandom number status

Result

TypeDescription
codeintStatus Code
resultstringResult Value
transactionstringTransaction
randomStatusRandomStatusRandom number status
execute_timeintScript execution time (milliseconds)
chargedintTime (seconds) for which costs were calculated
outputList<string>List of contents of standard output

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.InvokeScript(
    &script.InvokeScriptRequest {
        ScriptId: pointy.String("script-0001"),
        UserId: nil,
        Args: pointy.String("{}"),
        RandomStatus: nil,
    }
)
if err != nil {
    panic("error occurred")
}
code := result.Code
result := result.Result
transaction := result.Transaction
randomStatus := result.RandomStatus
executeTime := result.ExecuteTime
charged := result.Charged
output := result.Output
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\InvokeScriptRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->invokeScript(
        (new InvokeScriptRequest())
            ->withScriptId("script-0001")
            ->withUserId(null)
            ->withArgs("{}")
            ->withRandomStatus(null)
    );
    $code = $result->getCode();
    $result = $result->getResult();
    $transaction = $result->getTransaction();
    $randomStatus = $result->getRandomStatus();
    $executeTime = $result->getExecuteTime();
    $charged = $result->getCharged();
    $output = $result->getOutput();
} 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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.InvokeScriptRequest;
import io.gs2.script.result.InvokeScriptResult;

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

try {
    InvokeScriptResult result = client.invokeScript(
        new InvokeScriptRequest()
            .withScriptId("script-0001")
            .withUserId(null)
            .withArgs("{}")
            .withRandomStatus(null)
    );
    int code = result.getCode();
    String result = result.getResult();
    String transaction = result.getTransaction();
    RandomStatus randomStatus = result.getRandomStatus();
    int executeTime = result.getExecuteTime();
    int charged = result.getCharged();
    List<String> output = result.getOutput();
} 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.InvokeScriptRequest;
using Gs2.Gs2Script.Result.InvokeScriptResult;

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

AsyncResult<Gs2.Gs2Script.Result.InvokeScriptResult> asyncResult = null;
yield return client.InvokeScript(
    new Gs2.Gs2Script.Request.InvokeScriptRequest()
        .WithScriptId("script-0001")
        .WithUserId(null)
        .WithArgs("{}")
        .WithRandomStatus(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var code = result.Code;
var result = result.Result;
var transaction = result.Transaction;
var randomStatus = result.RandomStatus;
var executeTime = result.ExecuteTime;
var charged = result.Charged;
var output = result.Output;
import Gs2Core from '@/gs2/core';
import * as Gs2Script from '@/gs2/script';

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

try {
    const result = await client.invokeScript(
        new Gs2Script.InvokeScriptRequest()
            .withScriptId("script-0001")
            .withUserId(null)
            .withArgs("{}")
            .withRandomStatus(null)
    );
    const code = result.getCode();
    const result = result.getResult();
    const transaction = result.getTransaction();
    const randomStatus = result.getRandomStatus();
    const executeTime = result.getExecuteTime();
    const charged = result.getCharged();
    const output = result.getOutput();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.invoke_script(
        script.InvokeScriptRequest()
            .with_script_id('script-0001')
            .with_user_id(None)
            .with_args('{}')
            .with_random_status(None)
    )
    code = result.code
    result = result.result
    transaction = result.transaction
    random_status = result.random_status
    execute_time = result.execute_time
    charged = result.charged
    output = result.output
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.invoke_script({
    scriptId='script-0001',
    userId=nil,
    args='{}',
    randomStatus=nil,
})

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

result = api_result.result
code = result.code;
result = result.result;
transaction = result.transaction;
randomStatus = result.randomStatus;
executeTime = result.executeTime;
charged = result.charged;
output = result.output;

debugInvoke

Execute Script

Request

TypeConditionRequireDefaultLimitationDescription
scriptstring~ 5242880 charsLua Script
argsstring“{}”~ 5242880 charsArguments (JSON Format)
randomStatusRandomStatusRandom number status

Result

TypeDescription
codeintStatus Code
resultstringResult Value
transactionstringTransaction
randomStatusRandomStatusRandom number status
execute_timeintScript execution time (milliseconds)
chargedintTime (seconds) for which costs were calculated
outputList<string>List of contents of standard output

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/script"
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 := script.Gs2ScriptRestClient{
    Session: &session,
}
result, err := client.DebugInvoke(
    &script.DebugInvokeRequest {
        Script: pointy.String("result = \"hello\""),
        Args: pointy.String("{}"),
        RandomStatus: nil,
    }
)
if err != nil {
    panic("error occurred")
}
code := result.Code
result := result.Result
transaction := result.Transaction
randomStatus := result.RandomStatus
executeTime := result.ExecuteTime
charged := result.Charged
output := result.Output
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DebugInvokeRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->debugInvoke(
        (new DebugInvokeRequest())
            ->withScript("result = \"hello\"")
            ->withArgs("{}")
            ->withRandomStatus(null)
    );
    $code = $result->getCode();
    $result = $result->getResult();
    $transaction = $result->getTransaction();
    $randomStatus = $result->getRandomStatus();
    $executeTime = $result->getExecuteTime();
    $charged = $result->getCharged();
    $output = $result->getOutput();
} 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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DebugInvokeRequest;
import io.gs2.script.result.DebugInvokeResult;

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

try {
    DebugInvokeResult result = client.debugInvoke(
        new DebugInvokeRequest()
            .withScript("result = \"hello\"")
            .withArgs("{}")
            .withRandomStatus(null)
    );
    int code = result.getCode();
    String result = result.getResult();
    String transaction = result.getTransaction();
    RandomStatus randomStatus = result.getRandomStatus();
    int executeTime = result.getExecuteTime();
    int charged = result.getCharged();
    List<String> output = result.getOutput();
} 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.Gs2Script.Gs2ScriptRestClient;
using Gs2.Gs2Script.Request.DebugInvokeRequest;
using Gs2.Gs2Script.Result.DebugInvokeResult;

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

AsyncResult<Gs2.Gs2Script.Result.DebugInvokeResult> asyncResult = null;
yield return client.DebugInvoke(
    new Gs2.Gs2Script.Request.DebugInvokeRequest()
        .WithScript("result = \"hello\"")
        .WithArgs("{}")
        .WithRandomStatus(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var code = result.Code;
var result = result.Result;
var transaction = result.Transaction;
var randomStatus = result.RandomStatus;
var executeTime = result.ExecuteTime;
var charged = result.Charged;
var output = result.Output;
import Gs2Core from '@/gs2/core';
import * as Gs2Script from '@/gs2/script';

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

try {
    const result = await client.debugInvoke(
        new Gs2Script.DebugInvokeRequest()
            .withScript("result = \"hello\"")
            .withArgs("{}")
            .withRandomStatus(null)
    );
    const code = result.getCode();
    const result = result.getResult();
    const transaction = result.getTransaction();
    const randomStatus = result.getRandomStatus();
    const executeTime = result.getExecuteTime();
    const charged = result.getCharged();
    const output = result.getOutput();
} catch (e) {
    process.exit(1);
}
from gs2 import core
from gs2 import script

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

try:
    result = client.debug_invoke(
        script.DebugInvokeRequest()
            .with_script('result = "hello"')
            .with_args('{}')
            .with_random_status(None)
    )
    code = result.code
    result = result.result
    transaction = result.transaction
    random_status = result.random_status
    execute_time = result.execute_time
    charged = result.charged
    output = result.output
except core.Gs2Exception as e:
    exit(1)
client = gs2('script')

api_result = client.debug_invoke({
    script='result = "hello"',
    args='{}',
    randomStatus=nil,
})

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

result = api_result.result
code = result.code;
result = result.result;
transaction = result.transaction;
randomStatus = result.randomStatus;
executeTime = result.executeTime;
charged = result.charged;
output = result.output;