NAV Navbar
Python Java GS2-Formation
 

GS2-Script

ゲーム固有の仕様を実現するためのサービス。

GS2内の様々なイベントをトリガーとしてスクリプトを実行できます。 例えば、アカウントの登録をしたときのイベントをトリガーとして、アカウントの初期設定スクリプトを実行したり、 プレイヤーのレベルアップイベントをトリガーとして、スタミナを回復するスクリプトを実行したり、 ゲームの仕様を標準のGS2の機能で実現できないときにスクリプトを使用して機能を拡張できます。

GS2-Script のデータ構造は以下です。

利用料金

GS2-Script は通常の料金モデルに加えて以下の料金モデルを採用します。

スクリプトの実行時間1秒あたり 0.005円

モデル

Namespace

ネームスペース

ネームスペースはスクリプトの管理単位を表現します。 1つのネームスペースには複数のスクリプトを登録することができます。

ネームスペースを分けることによる弊害や、同一ネームスペースでなければいけない処理は存在しません。 スクリプトのグルーピングとして利用してください。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false 説明文
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Script

スクリプト

Lua言語で記述したスクリプト

GS2内の様々なイベントをトリガーとしてスクリプトを実行できます。 例えば、アカウントの登録をしたときのイベントをトリガーとして、アカウントの初期設定スクリプトを実行したり、 プレイヤーのレベルアップイベントをトリガーとして、スタミナを回復するスクリプトを実行したり、 ゲームの仕様を標準のGS2の機能で実現できないときにスクリプトを使用して機能を拡張できます。

パラメータ データ型 必須 説明
scriptId string true スクリプト
ownerId string true オーナーID
name string true スクリプト名
description string false 説明文
script string true Luaスクリプト
createdAt long true 作成日時
updatedAt long true 最終更新日時

GitHubCheckoutSetting

GitHubからリソースをチェックアウトしてくる設定

パラメータ データ型 必須 説明
apiKeyId string true リソースの取得に使用するGitHub のAPIキー のGRN
repositoryName string true リポジトリ名
sourcePath string true ソースコードのファイルパス
referenceType string true コードの取得元
commitHash string true コミットハッシュ
branchName string true ブランチ名
tagName string true タグ名

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_script_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2ScriptRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.script.rest.Gs2ScriptRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2ScriptRestClient client = new Gs2ScriptRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_script_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2ScriptRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.script.rest.Gs2ScriptRestClient

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

session.connect_async(
    (result) => {
        Gs2ScriptRestClient client = new Gs2ScriptRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_script_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2ScriptWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.script.webSocket.Gs2ScriptWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2ScriptWebSocketClient client = new Gs2ScriptWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_script_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2ScriptWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.script.webSocket.Gs2ScriptWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2ScriptWebSocketClient client = new Gs2ScriptWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Script は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

createNamespace

同期処理

from gs2_script_client.request import CreateNamespaceRequest
from gs2_script_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.CreateNamespaceRequest
import io.gs2.script.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import CreateNamespaceRequest
from gs2_script_client.result import CreateNamespaceResult

def callback(async_result: AsyncResult[CreateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.script.request.CreateNamespaceRequest
import io.gs2.script.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Script::Namespace
Properties:
  Name: String
  Description: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

ネームスペースを新規作成

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false 説明文
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createScript

同期処理

from gs2_script_client.request import CreateScriptRequest
from gs2_script_client.result import CreateScriptResult

result = client.create_script(
    CreateScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('script-0001')\
        .with_script('result = "hoge"')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.CreateScriptRequest
import io.gs2.script.result.CreateScriptResult

result = client.createScript(
    CreateScriptRequest()
        .withNamespaceName("namespace-0001")
        .withName("script-0001")
        .withScript("result = "hoge"")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import CreateScriptRequest
from gs2_script_client.result import CreateScriptResult

def callback(async_result: AsyncResult[CreateScriptResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_script_async(
    CreateScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('script-0001')\
        .with_script('result = "hoge"'),
    callback
)
import io.gs2.script.request.CreateScriptRequest
import io.gs2.script.result.CreateScriptResult

result = client.createScript(
    CreateScriptRequest()
        .withNamespaceName("namespace-0001")
        .withName("script-0001")
        .withScript("result = "hoge""),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Script::Script
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Script: String

スクリプトを新規作成します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true スクリプト名
description string false 説明文
script string true Luaスクリプト
パラメータ データ型 説明
item Script 作成したスクリプト

createScriptFromGitHub

同期処理

from gs2_script_client.request import CreateScriptFromGitHubRequest
from gs2_script_client.result import CreateScriptFromGitHubResult

result = client.create_script_from_git_hub(
    CreateScriptFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.CreateScriptFromGitHubRequest
import io.gs2.script.result.CreateScriptFromGitHubResult

result = client.createScriptFromGitHub(
    CreateScriptFromGitHubRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import CreateScriptFromGitHubRequest
from gs2_script_client.result import CreateScriptFromGitHubResult

def callback(async_result: AsyncResult[CreateScriptFromGitHubResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_script_from_git_hub_async(
    CreateScriptFromGitHubRequest()\
    callback
)
import io.gs2.script.request.CreateScriptFromGitHubRequest
import io.gs2.script.result.CreateScriptFromGitHubResult

result = client.createScriptFromGitHub(
    CreateScriptFromGitHubRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Script::Script
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  CheckoutSetting:
    ApiKeyId: String
    RepositoryName: String
    SourcePath: String
    ReferenceType: String
    CommitHash: String
    BranchName: String
    TagName: String

GitHubリポジトリのコードからスクリプトを新規作成します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true スクリプト名
description string false 説明文
checkoutSetting GitHubCheckoutSetting true GitHubからソースコードをチェックアウトしてくる設定
パラメータ データ型 説明
item Script 作成したスクリプト

debugInvoke

同期処理

from gs2_script_client.request import DebugInvokeRequest
from gs2_script_client.result import DebugInvokeResult

result = client.debug_invoke(
    DebugInvokeRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.DebugInvokeRequest
import io.gs2.script.result.DebugInvokeResult

result = client.debugInvoke(
    DebugInvokeRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import DebugInvokeRequest
from gs2_script_client.result import DebugInvokeResult

def callback(async_result: AsyncResult[DebugInvokeResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.debug_invoke_async(
    DebugInvokeRequest()\
    callback
)
import io.gs2.script.request.DebugInvokeRequest
import io.gs2.script.result.DebugInvokeResult

result = client.debugInvoke(
    DebugInvokeRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スクリプトを実行します

パラメータ データ型 必須 説明
script string true スクリプト
args string false None
パラメータ データ型 説明
code integer ステータスコード
result string 戻り値
executeTime integer スクリプトの実行時間(ミリ秒)
charged integer 費用の計算対象となった時間(秒)
output list[string] 標準出力の内容のリスト

deleteNamespace

同期処理

from gs2_script_client.request import DeleteNamespaceRequest
from gs2_script_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.DeleteNamespaceRequest
import io.gs2.script.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import DeleteNamespaceRequest
from gs2_script_client.result import DeleteNamespaceResult

def callback(async_result: AsyncResult[DeleteNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.script.request.DeleteNamespaceRequest
import io.gs2.script.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明

deleteScript

同期処理

from gs2_script_client.request import DeleteScriptRequest
from gs2_script_client.result import DeleteScriptResult

result = client.delete_script(
    DeleteScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_script_name('script-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.DeleteScriptRequest
import io.gs2.script.result.DeleteScriptResult

result = client.deleteScript(
    DeleteScriptRequest()
        .withNamespaceName("namespace-0001")
        .withScriptName("script-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import DeleteScriptRequest
from gs2_script_client.result import DeleteScriptResult

def callback(async_result: AsyncResult[DeleteScriptResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_script_async(
    DeleteScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_script_name('script-0001'),
    callback
)
import io.gs2.script.request.DeleteScriptRequest
import io.gs2.script.result.DeleteScriptResult

result = client.deleteScript(
    DeleteScriptRequest()
        .withNamespaceName("namespace-0001")
        .withScriptName("script-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スクリプトを削除します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
scriptName string true スクリプト名
パラメータ データ型 説明

describeNamespaces

同期処理

from gs2_script_client.request import DescribeNamespacesRequest
from gs2_script_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.DescribeNamespacesRequest
import io.gs2.script.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import DescribeNamespacesRequest
from gs2_script_client.result import DescribeNamespacesResult

def callback(async_result: AsyncResult[DescribeNamespacesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.script.request.DescribeNamespacesRequest
import io.gs2.script.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースの一覧を取得

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Namespace] ネームスペースのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeScripts

同期処理

from gs2_script_client.request import DescribeScriptsRequest
from gs2_script_client.result import DescribeScriptsResult

result = client.describe_scripts(
    DescribeScriptsRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.DescribeScriptsRequest
import io.gs2.script.result.DescribeScriptsResult

result = client.describeScripts(
    DescribeScriptsRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import DescribeScriptsRequest
from gs2_script_client.result import DescribeScriptsResult

def callback(async_result: AsyncResult[DescribeScriptsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_scripts_async(
    DescribeScriptsRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.script.request.DescribeScriptsRequest
import io.gs2.script.result.DescribeScriptsResult

result = client.describeScripts(
    DescribeScriptsRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スクリプトの一覧を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Script] スクリプトのリスト
nextPageToken string リストの続きを取得するためのページトークン

getNamespace

同期処理

from gs2_script_client.request import GetNamespaceRequest
from gs2_script_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.GetNamespaceRequest
import io.gs2.script.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import GetNamespaceRequest
from gs2_script_client.result import GetNamespaceResult

def callback(async_result: AsyncResult[GetNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.script.request.GetNamespaceRequest
import io.gs2.script.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_script_client.request import GetNamespaceStatusRequest
from gs2_script_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.GetNamespaceStatusRequest
import io.gs2.script.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import GetNamespaceStatusRequest
from gs2_script_client.result import GetNamespaceStatusResult

def callback(async_result: AsyncResult[GetNamespaceStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
    callback
)
import io.gs2.script.request.GetNamespaceStatusRequest
import io.gs2.script.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

getScript

同期処理

from gs2_script_client.request import GetScriptRequest
from gs2_script_client.result import GetScriptResult

result = client.get_script(
    GetScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_script_name('script-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.GetScriptRequest
import io.gs2.script.result.GetScriptResult

result = client.getScript(
    GetScriptRequest()
        .withNamespaceName("namespace-0001")
        .withScriptName("script-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import GetScriptRequest
from gs2_script_client.result import GetScriptResult

def callback(async_result: AsyncResult[GetScriptResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_script_async(
    GetScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_script_name('script-0001'),
    callback
)
import io.gs2.script.request.GetScriptRequest
import io.gs2.script.result.GetScriptResult

result = client.getScript(
    GetScriptRequest()
        .withNamespaceName("namespace-0001")
        .withScriptName("script-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スクリプトを取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
scriptName string true スクリプト名
パラメータ データ型 説明
item Script スクリプト

updateNamespace

同期処理

from gs2_script_client.request import UpdateNamespaceRequest
from gs2_script_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.UpdateNamespaceRequest
import io.gs2.script.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import UpdateNamespaceRequest
from gs2_script_client.result import UpdateNamespaceResult

def callback(async_result: AsyncResult[UpdateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.script.request.UpdateNamespaceRequest
import io.gs2.script.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false 説明文
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateScript

同期処理

from gs2_script_client.request import UpdateScriptRequest
from gs2_script_client.result import UpdateScriptResult

result = client.update_script(
    UpdateScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_script_name('script-0001')\
        .with_description('description1')\
        .with_script('result = "hogehoge"')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.UpdateScriptRequest
import io.gs2.script.result.UpdateScriptResult

result = client.updateScript(
    UpdateScriptRequest()
        .withNamespaceName("namespace-0001")
        .withScriptName("script-0001")
        .withDescription("description1")
        .withScript("result = "hogehoge"")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import UpdateScriptRequest
from gs2_script_client.result import UpdateScriptResult

def callback(async_result: AsyncResult[UpdateScriptResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_script_async(
    UpdateScriptRequest()\
        .with_namespace_name('namespace-0001')\
        .with_script_name('script-0001')\
        .with_description('description1')\
        .with_script('result = "hogehoge"'),
    callback
)
import io.gs2.script.request.UpdateScriptRequest
import io.gs2.script.result.UpdateScriptResult

result = client.updateScript(
    UpdateScriptRequest()
        .withNamespaceName("namespace-0001")
        .withScriptName("script-0001")
        .withDescription("description1")
        .withScript("result = "hogehoge""),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スクリプトを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
scriptName string true スクリプト名
description string false 説明文
script string true Luaスクリプト
パラメータ データ型 説明
item Script 更新したスクリプト

updateScriptFromGitHub

同期処理

from gs2_script_client.request import UpdateScriptFromGitHubRequest
from gs2_script_client.result import UpdateScriptFromGitHubResult

result = client.update_script_from_git_hub(
    UpdateScriptFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.script.request.UpdateScriptFromGitHubRequest
import io.gs2.script.result.UpdateScriptFromGitHubResult

result = client.updateScriptFromGitHub(
    UpdateScriptFromGitHubRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_script_client.request import UpdateScriptFromGitHubRequest
from gs2_script_client.result import UpdateScriptFromGitHubResult

def callback(async_result: AsyncResult[UpdateScriptFromGitHubResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_script_from_git_hub_async(
    UpdateScriptFromGitHubRequest()\
    callback
)
import io.gs2.script.request.UpdateScriptFromGitHubRequest
import io.gs2.script.result.UpdateScriptFromGitHubResult

result = client.updateScriptFromGitHub(
    UpdateScriptFromGitHubRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

GithHub をデータソースとしてスクリプトを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
scriptName string true スクリプト名
description string false 説明文
checkoutSetting GitHubCheckoutSetting true GitHubからソースコードをチェックアウトしてくる設定
パラメータ データ型 説明
item Script 更新したスクリプト

GS2-Script トリガーイベント

GS2-Script が提供するスクリプトトリガーはありません

マスターデータフォーマット

マスターデータはありません

GS2-Script の制限・制約

利用いただくにあたって注意いただく制限・制約はありません