NAV Navbar
Python Java GS2-Formation
 

GS2-Version

ゲームのバージョンチェックを実現します。 バージョンチェックを通過すると、新しいプロジェクトトークンを取得できます。 つまり、ゲームに組み込むクレデンシャルはバージョンチェックを行うのに十分な権限のみ付与し、バージョンチェックを通過することでゲームを動作させるのに十分な権限のプロジェクトトークンを取得できるようにすることで、バージョンチェックを通らなければゲームが遊べない状態を作り出します。

ネームスペースには最大10個のバージョンモデルを宣言でき、すべてのバージョンが要求バージョン以上のときにのみバージョンチェックを通過とみなします。

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

モデル

Namespace

ネームスペース

ネームスペース ごとにすべてのバージョンチェックをクリアするごとに新しいクレデンシャルを入手できます。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false 説明文
assumeUserId string true バージョンチェック通過後に改めて発行するプロジェクトトークンの権限判定に使用する ユーザ のGRN
acceptVersionScript ScriptSetting false バージョンを承認したときに実行するスクリプト
checkVersionTriggerScriptId string false バージョンチェック時 に実行されるスクリプト のGRN
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

VersionModelMaster

バージョンマスター

パラメータ データ型 必須 説明
versionModelId string true バージョンマスター
name string true バージョン名
description string false バージョンマスターの説明
metadata string false バージョンのメタデータ
warningVersion Version true バージョンアップを促すバージョン
errorVersion Version true バージョンチェックを蹴るバージョン
scope string true 判定に使用するバージョン値の種類
currentVersion Version true 現在のバージョン
needSignature boolean true 判定するバージョン値に署名検証を必要とするか
signatureKeyId string true 署名検証に使用する暗号鍵 のGRN
createdAt long true 作成日時
updatedAt long true 最終更新日時

Version

バージョン

パラメータ データ型 必須 説明
major integer true メジャーバージョン
minor integer true マイナーバージョン
micro integer true マイクロバージョン

VersionModel

バージョン設定

パラメータ データ型 必須 説明
versionModelId string true バージョン設定
name string true バージョンの種類名
metadata string false バージョンの種類のメタデータ
warningVersion Version true バージョンアップを促すバージョン
errorVersion Version true バージョンチェックを蹴るバージョン
scope string true 判定に使用するバージョン値の種類
currentVersion Version true 現在のバージョン
needSignature boolean true 判定するバージョン値に署名検証を必要とするか
signatureKeyId string true 署名検証に使用する暗号鍵 のGRN

AcceptVersion

承認したバージョン

パラメータ データ型 必須 説明
acceptVersionId string true 承認したバージョン
versionName string true 承認したバージョン名
userId string true ユーザーID
version Version true 承認したバージョン
createdAt long true 作成日時
updatedAt long true 最終更新日時

Checker

リソース配信

パラメータ データ型 必須 説明

Status

バージョンの検証結果

パラメータ データ型 必須 説明
versionModel VersionModel true バージョン設定
currentVersion Version true 現在のバージョン

TargetVersion

検証するバージョン

スコープが passive のバージョンに関して、クライアントのバージョン情報を送信する

パラメータ データ型 必須 説明
versionName string true バージョンの名前
version Version true バージョン
body string false ボディ
signature string false 署名

SignTargetVersion

署名検証に使用するバージョン

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
namespaceName string true ネームスペース名
versionName string true バージョンの種類名
version Version true バージョン

ResponseCache

レスポンスキャッシュ

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
responseCacheId string true レスポンスキャッシュ のGRN
requestHash string false
result string true APIの応答内容

CurrentVersionMaster

現在有効なバージョン

エクスポートしたマスターデータを、現在有効なバージョンとしてインポートして使用します。

パラメータ データ型 必須 説明
namespaceId string true 現在有効なバージョン
settings string true マスターデータ

ScriptSetting

スクリプト設定

パラメータ データ型 必須 説明
triggerScriptId string false 実行前に使用する GS2-Script のスクリプト のGRN
doneTriggerScriptId string false 完了時に使用する GS2-Script のスクリプト のGRN
doneTriggerQueueNamespaceId string false 完了時に使用する GS2-JobQueue のネームスペース のGRN

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_version_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_version_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 = Gs2VersionRestClient(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.version.rest.Gs2VersionRestClient

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

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

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

import gs2_core_client.model.*
import gs2_version_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 = Gs2VersionWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.version.webSocket.Gs2VersionWebSocketClient

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

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

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

import gs2_core_client.model.*
import gs2_version_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 = Gs2VersionWebSocketClient(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.version.webSocket.Gs2VersionWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

accept

同期処理

from gs2_version_client.request import AcceptRequest
from gs2_version_client.result import AcceptResult

result = client.accept(
    AcceptRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.AcceptRequest
import io.gs2.version.result.AcceptResult

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

非同期処理

from gs2_version_client.request import AcceptRequest
from gs2_version_client.result import AcceptResult

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

result = client.accept_async(
    AcceptRequest()\
    callback
)
import io.gs2.version.request.AcceptRequest
import io.gs2.version.result.AcceptResult

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

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

現在のバージョンを承認

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true 承認したバージョン名
パラメータ データ型 説明
item AcceptVersion 承認したバージョン

acceptByUserId

同期処理

from gs2_version_client.request import AcceptByUserIdRequest
from gs2_version_client.result import AcceptByUserIdResult

result = client.accept_by_user_id(
    AcceptByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.AcceptByUserIdRequest
import io.gs2.version.result.AcceptByUserIdResult

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

非同期処理

from gs2_version_client.request import AcceptByUserIdRequest
from gs2_version_client.result import AcceptByUserIdResult

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

result = client.accept_by_user_id_async(
    AcceptByUserIdRequest()\
    callback
)
import io.gs2.version.request.AcceptByUserIdRequest
import io.gs2.version.result.AcceptByUserIdResult

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

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

ユーザIDを指定して現在のバージョンを承認

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true 承認したバージョン名
userId string true ユーザーID
パラメータ データ型 説明
item AcceptVersion 承認したバージョン

calculateSignature

同期処理

from gs2_version_client.request import CalculateSignatureRequest
from gs2_version_client.result import CalculateSignatureResult

result = client.calculate_signature(
    CalculateSignatureRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.CalculateSignatureRequest
import io.gs2.version.result.CalculateSignatureResult

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

非同期処理

from gs2_version_client.request import CalculateSignatureRequest
from gs2_version_client.result import CalculateSignatureResult

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

result = client.calculate_signature_async(
    CalculateSignatureRequest()\
    callback
)
import io.gs2.version.request.CalculateSignatureRequest
import io.gs2.version.result.CalculateSignatureResult

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

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

スタンプシートのタスクを実行する

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true バージョンの種類名
version Version false バージョン
パラメータ データ型 説明
body string ボディ
signature string 署名

checkVersion

同期処理

from gs2_version_client.request import CheckVersionRequest
from gs2_version_client.result import CheckVersionResult

result = client.check_version(
    CheckVersionRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.CheckVersionRequest
import io.gs2.version.result.CheckVersionResult

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

非同期処理

from gs2_version_client.request import CheckVersionRequest
from gs2_version_client.result import CheckVersionResult

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

result = client.check_version_async(
    CheckVersionRequest()\
    callback
)
import io.gs2.version.request.CheckVersionRequest
import io.gs2.version.result.CheckVersionResult

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

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

バージョンチェック

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetVersions list[TargetVersion] false 加算するリソース
パラメータ データ型 説明
projectToken string プロジェクトトークン
warnings list[Status] バージョンの検証結果のリスト
errors list[Status] バージョンの検証結果のリスト

checkVersionByUserId

同期処理

from gs2_version_client.request import CheckVersionByUserIdRequest
from gs2_version_client.result import CheckVersionByUserIdResult

result = client.check_version_by_user_id(
    CheckVersionByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.CheckVersionByUserIdRequest
import io.gs2.version.result.CheckVersionByUserIdResult

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

非同期処理

from gs2_version_client.request import CheckVersionByUserIdRequest
from gs2_version_client.result import CheckVersionByUserIdResult

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

result = client.check_version_by_user_id_async(
    CheckVersionByUserIdRequest()\
    callback
)
import io.gs2.version.request.CheckVersionByUserIdRequest
import io.gs2.version.result.CheckVersionByUserIdResult

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

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

バージョンチェック

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
targetVersions list[TargetVersion] false 加算するリソース
パラメータ データ型 説明
projectToken string プロジェクトトークン
warnings list[Status] バージョンの検証結果のリスト
errors list[Status] バージョンの検証結果のリスト

createNamespace

同期処理

from gs2_version_client.request import CreateNamespaceRequest
from gs2_version_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_version_client.request import CreateNamespaceRequest
from gs2_version_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_assume_user_id('grn:gs2::{ownerId}:identifier:user:user-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.version.request.CreateNamespaceRequest
import io.gs2.version.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withAssumeUserId("grn:gs2::{ownerId}:identifier:user:user-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::Version::Namespace
Properties:
  Name: String
  Description: Optional[String]
  AssumeUserId: String
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false 説明文
assumeUserId string true バージョンチェック通過後に改めて発行するプロジェクトトークンの権限判定に使用する ユーザ のGRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createVersionModelMaster

同期処理

from gs2_version_client.request import CreateVersionModelMasterRequest
from gs2_version_client.result import CreateVersionModelMasterResult

result = client.create_version_model_master(
    CreateVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('version-0001')\
        .with_warning_version(Object("Version", {"major": 2, "minor": 2, "micro": 2}))\
        .with_error_version(Object("Version", {"major": 1, "minor": 1, "micro": 1}))\
        .with_scope('passive')\
        .with_need_signature(False)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.CreateVersionModelMasterRequest
import io.gs2.version.result.CreateVersionModelMasterResult

result = client.createVersionModelMaster(
    CreateVersionModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("version-0001")
        .withWarningVersion(Object("Version", {"major": 2, "minor": 2, "micro": 2}))
        .withErrorVersion(Object("Version", {"major": 1, "minor": 1, "micro": 1}))
        .withScope("passive")
        .withNeedSignature(false)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_version_client.request import CreateVersionModelMasterRequest
from gs2_version_client.result import CreateVersionModelMasterResult

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

result = client.create_version_model_master_async(
    CreateVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('version-0001')\
        .with_warning_version(Object("Version", {"major": 2, "minor": 2, "micro": 2}))\
        .with_error_version(Object("Version", {"major": 1, "minor": 1, "micro": 1}))\
        .with_scope('passive')\
        .with_need_signature(False),
    callback
)
import io.gs2.version.request.CreateVersionModelMasterRequest
import io.gs2.version.result.CreateVersionModelMasterResult

result = client.createVersionModelMaster(
    CreateVersionModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("version-0001")
        .withWarningVersion(Object("Version", {"major": 2, "minor": 2, "micro": 2}))
        .withErrorVersion(Object("Version", {"major": 1, "minor": 1, "micro": 1}))
        .withScope("passive")
        .withNeedSignature(false),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Version::VersionModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  WarningVersion:
    Major: Integer
    Minor: Integer
    Micro: Integer
  ErrorVersion:
    Major: Integer
    Minor: Integer
    Micro: Integer
  Scope: String
  CurrentVersion:
    Major: Integer
    Minor: Integer
    Micro: Integer
  NeedSignature: Bool
  SignatureKeyId: String

バージョンマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true バージョン名
description string false バージョンマスターの説明
metadata string false バージョンのメタデータ
warningVersion Version true バージョンアップを促すバージョン
errorVersion Version true バージョンチェックを蹴るバージョン
scope string true 判定に使用するバージョン値の種類
currentVersion Version true 現在のバージョン
needSignature boolean true 判定するバージョン値に署名検証を必要とするか
signatureKeyId string true 署名検証に使用する暗号鍵 のGRN
パラメータ データ型 説明
item VersionModelMaster 作成したバージョンマスター

deleteAcceptVersion

同期処理

from gs2_version_client.request import DeleteAcceptVersionRequest
from gs2_version_client.result import DeleteAcceptVersionResult

result = client.delete_accept_version(
    DeleteAcceptVersionRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name(version_model1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.DeleteAcceptVersionRequest
import io.gs2.version.result.DeleteAcceptVersionResult

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

非同期処理

from gs2_version_client.request import DeleteAcceptVersionRequest
from gs2_version_client.result import DeleteAcceptVersionResult

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

result = client.delete_accept_version_async(
    DeleteAcceptVersionRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name(version_model1['name']),
    callback
)
import io.gs2.version.request.DeleteAcceptVersionRequest
import io.gs2.version.result.DeleteAcceptVersionResult

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

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

承認したバージョンを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true 承認したバージョン名
パラメータ データ型 説明

deleteAcceptVersionByUserId

同期処理

from gs2_version_client.request import DeleteAcceptVersionByUserIdRequest
from gs2_version_client.result import DeleteAcceptVersionByUserIdResult

result = client.delete_accept_version_by_user_id(
    DeleteAcceptVersionByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_version_name(version_model2['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.DeleteAcceptVersionByUserIdRequest
import io.gs2.version.result.DeleteAcceptVersionByUserIdResult

result = client.deleteAcceptVersionByUserId(
    DeleteAcceptVersionByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withVersionName(version_model2.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_version_client.request import DeleteAcceptVersionByUserIdRequest
from gs2_version_client.result import DeleteAcceptVersionByUserIdResult

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

result = client.delete_accept_version_by_user_id_async(
    DeleteAcceptVersionByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_version_name(version_model2['name']),
    callback
)
import io.gs2.version.request.DeleteAcceptVersionByUserIdRequest
import io.gs2.version.result.DeleteAcceptVersionByUserIdResult

result = client.deleteAcceptVersionByUserId(
    DeleteAcceptVersionByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withVersionName(version_model2.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定して承認したバージョンを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
versionName string true 承認したバージョン名
パラメータ データ型 説明

deleteNamespace

同期処理

from gs2_version_client.request import DeleteNamespaceRequest
from gs2_version_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_version_client.request import DeleteNamespaceRequest
from gs2_version_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.version.request.DeleteNamespaceRequest
import io.gs2.version.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 ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

deleteVersionModelMaster

同期処理

from gs2_version_client.request import DeleteVersionModelMasterRequest
from gs2_version_client.result import DeleteVersionModelMasterResult

result = client.delete_version_model_master(
    DeleteVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name('version-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.DeleteVersionModelMasterRequest
import io.gs2.version.result.DeleteVersionModelMasterResult

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

非同期処理

from gs2_version_client.request import DeleteVersionModelMasterRequest
from gs2_version_client.result import DeleteVersionModelMasterResult

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

result = client.delete_version_model_master_async(
    DeleteVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name('version-0001'),
    callback
)
import io.gs2.version.request.DeleteVersionModelMasterRequest
import io.gs2.version.result.DeleteVersionModelMasterResult

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

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

バージョンマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true バージョン名
パラメータ データ型 説明
item VersionModelMaster 削除したバージョンマスター

describeAcceptVersions

同期処理

from gs2_version_client.request import DescribeAcceptVersionsRequest
from gs2_version_client.result import DescribeAcceptVersionsResult

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

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

非同期処理

from gs2_version_client.request import DescribeAcceptVersionsRequest
from gs2_version_client.result import DescribeAcceptVersionsResult

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

result = client.describe_accept_versions_async(
    DescribeAcceptVersionsRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.version.request.DescribeAcceptVersionsRequest
import io.gs2.version.result.DescribeAcceptVersionsResult

result = client.describeAcceptVersions(
    DescribeAcceptVersionsRequest()
        .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[AcceptVersion] 承認したバージョンのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeAcceptVersionsByUserId

同期処理

from gs2_version_client.request import DescribeAcceptVersionsByUserIdRequest
from gs2_version_client.result import DescribeAcceptVersionsByUserIdResult

result = client.describe_accept_versions_by_user_id(
    DescribeAcceptVersionsByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.DescribeAcceptVersionsByUserIdRequest
import io.gs2.version.result.DescribeAcceptVersionsByUserIdResult

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

非同期処理

from gs2_version_client.request import DescribeAcceptVersionsByUserIdRequest
from gs2_version_client.result import DescribeAcceptVersionsByUserIdResult

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

result = client.describe_accept_versions_by_user_id_async(
    DescribeAcceptVersionsByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.version.request.DescribeAcceptVersionsByUserIdRequest
import io.gs2.version.result.DescribeAcceptVersionsByUserIdResult

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

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

承認したバージョンの一覧を取得

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

describeNamespaces

同期処理

from gs2_version_client.request import DescribeNamespacesRequest
from gs2_version_client.result import DescribeNamespacesResult

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

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

非同期処理

from gs2_version_client.request import DescribeNamespacesRequest
from gs2_version_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.version.request.DescribeNamespacesRequest
import io.gs2.version.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 リストの続きを取得するためのページトークン

describeVersionModelMasters

同期処理

from gs2_version_client.request import DescribeVersionModelMastersRequest
from gs2_version_client.result import DescribeVersionModelMastersResult

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

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

非同期処理

from gs2_version_client.request import DescribeVersionModelMastersRequest
from gs2_version_client.result import DescribeVersionModelMastersResult

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

result = client.describe_version_model_masters_async(
    DescribeVersionModelMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.version.request.DescribeVersionModelMastersRequest
import io.gs2.version.result.DescribeVersionModelMastersResult

result = client.describeVersionModelMasters(
    DescribeVersionModelMastersRequest()
        .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[VersionModelMaster] バージョンマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeVersionModels

同期処理

from gs2_version_client.request import DescribeVersionModelsRequest
from gs2_version_client.result import DescribeVersionModelsResult

result = client.describe_version_models(
    DescribeVersionModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.DescribeVersionModelsRequest
import io.gs2.version.result.DescribeVersionModelsResult

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

非同期処理

from gs2_version_client.request import DescribeVersionModelsRequest
from gs2_version_client.result import DescribeVersionModelsResult

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

result = client.describe_version_models_async(
    DescribeVersionModelsRequest()\
    callback
)
import io.gs2.version.request.DescribeVersionModelsRequest
import io.gs2.version.result.DescribeVersionModelsResult

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

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

バージョン設定の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[VersionModel] バージョン設定のリスト

exportMaster

同期処理

from gs2_version_client.request import ExportMasterRequest
from gs2_version_client.result import ExportMasterResult

result = client.export_master(
    ExportMasterRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.ExportMasterRequest
import io.gs2.version.result.ExportMasterResult

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

非同期処理

from gs2_version_client.request import ExportMasterRequest
from gs2_version_client.result import ExportMasterResult

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

result = client.export_master_async(
    ExportMasterRequest()\
    callback
)
import io.gs2.version.request.ExportMasterRequest
import io.gs2.version.result.ExportMasterResult

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

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

現在有効なバージョンのマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentVersionMaster 現在有効なバージョン

getAcceptVersion

同期処理

from gs2_version_client.request import GetAcceptVersionRequest
from gs2_version_client.result import GetAcceptVersionResult

result = client.get_accept_version(
    GetAcceptVersionRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name(version_model1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.GetAcceptVersionRequest
import io.gs2.version.result.GetAcceptVersionResult

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

非同期処理

from gs2_version_client.request import GetAcceptVersionRequest
from gs2_version_client.result import GetAcceptVersionResult

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

result = client.get_accept_version_async(
    GetAcceptVersionRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name(version_model1['name']),
    callback
)
import io.gs2.version.request.GetAcceptVersionRequest
import io.gs2.version.result.GetAcceptVersionResult

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

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

承認したバージョンを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true 承認したバージョン名
パラメータ データ型 説明
item AcceptVersion 承認したバージョン

getAcceptVersionByUserId

同期処理

from gs2_version_client.request import GetAcceptVersionByUserIdRequest
from gs2_version_client.result import GetAcceptVersionByUserIdResult

result = client.get_accept_version_by_user_id(
    GetAcceptVersionByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_version_name(version_model2['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.GetAcceptVersionByUserIdRequest
import io.gs2.version.result.GetAcceptVersionByUserIdResult

result = client.getAcceptVersionByUserId(
    GetAcceptVersionByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withVersionName(version_model2.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_version_client.request import GetAcceptVersionByUserIdRequest
from gs2_version_client.result import GetAcceptVersionByUserIdResult

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

result = client.get_accept_version_by_user_id_async(
    GetAcceptVersionByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_version_name(version_model2['name']),
    callback
)
import io.gs2.version.request.GetAcceptVersionByUserIdRequest
import io.gs2.version.result.GetAcceptVersionByUserIdResult

result = client.getAcceptVersionByUserId(
    GetAcceptVersionByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withVersionName(version_model2.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定して承認したバージョンを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
versionName string true 承認したバージョン名
パラメータ データ型 説明
item AcceptVersion 承認したバージョン

getCurrentVersionMaster

同期処理

from gs2_version_client.request import GetCurrentVersionMasterRequest
from gs2_version_client.result import GetCurrentVersionMasterResult

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

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

非同期処理

from gs2_version_client.request import GetCurrentVersionMasterRequest
from gs2_version_client.result import GetCurrentVersionMasterResult

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

result = client.get_current_version_master_async(
    GetCurrentVersionMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.version.request.GetCurrentVersionMasterRequest
import io.gs2.version.result.GetCurrentVersionMasterResult

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

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

現在有効なバージョンを取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentVersionMaster 現在有効なバージョン

getNamespace

同期処理

from gs2_version_client.request import GetNamespaceRequest
from gs2_version_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_version_client.request import GetNamespaceRequest
from gs2_version_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.version.request.GetNamespaceRequest
import io.gs2.version.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_version_client.request import GetNamespaceStatusRequest
from gs2_version_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_version_client.request import GetNamespaceStatusRequest
from gs2_version_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()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.version.request.GetNamespaceStatusRequest
import io.gs2.version.result.GetNamespaceStatusResult

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

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

ネームスペースの状態を取得

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

getVersionModel

同期処理

from gs2_version_client.request import GetVersionModelRequest
from gs2_version_client.result import GetVersionModelResult

result = client.get_version_model(
    GetVersionModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.GetVersionModelRequest
import io.gs2.version.result.GetVersionModelResult

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

非同期処理

from gs2_version_client.request import GetVersionModelRequest
from gs2_version_client.result import GetVersionModelResult

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

result = client.get_version_model_async(
    GetVersionModelRequest()\
    callback
)
import io.gs2.version.request.GetVersionModelRequest
import io.gs2.version.result.GetVersionModelResult

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

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

バージョン設定を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true バージョン名
パラメータ データ型 説明
item VersionModel バージョン設定

getVersionModelMaster

同期処理

from gs2_version_client.request import GetVersionModelMasterRequest
from gs2_version_client.result import GetVersionModelMasterResult

result = client.get_version_model_master(
    GetVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name('version-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.GetVersionModelMasterRequest
import io.gs2.version.result.GetVersionModelMasterResult

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

非同期処理

from gs2_version_client.request import GetVersionModelMasterRequest
from gs2_version_client.result import GetVersionModelMasterResult

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

result = client.get_version_model_master_async(
    GetVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name('version-0001'),
    callback
)
import io.gs2.version.request.GetVersionModelMasterRequest
import io.gs2.version.result.GetVersionModelMasterResult

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

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

バージョンマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true バージョン名
パラメータ データ型 説明
item VersionModelMaster バージョンマスター

updateCurrentVersionMaster

同期処理

from gs2_version_client.request import UpdateCurrentVersionMasterRequest
from gs2_version_client.result import UpdateCurrentVersionMasterResult

result = client.update_current_version_master(
    UpdateCurrentVersionMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-10-09",\n  "versionModels": [\n    {\n      "name": "app",\n      "metadata": "APP",\n      "warningVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "errorVersion": {\n        "major": 1,\n        "minor": 1,\n        "micro": 1\n      },\n      "scope": "passive",\n      "needSignature": false\n    },\n    {\n      "name": "asset",\n      "metadata": "ASSET",\n      "warningVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "errorVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "scope": "passive",\n      "needSignature": true,\n      "signatureKeyId": "grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0001"\n    },\n    {\n      "name": "eula",\n      "metadata": "EULA",\n      "warningVersion": {\n        "major": 4,\n        "minor": 4,\n        "micro": 4\n      },\n      "errorVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "scope": "active",\n      "currentVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      }\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.UpdateCurrentVersionMasterRequest
import io.gs2.version.result.UpdateCurrentVersionMasterResult

result = client.updateCurrentVersionMaster(
    UpdateCurrentVersionMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-10-09",\n  "versionModels": [\n    {\n      "name": "app",\n      "metadata": "APP",\n      "warningVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "errorVersion": {\n        "major": 1,\n        "minor": 1,\n        "micro": 1\n      },\n      "scope": "passive",\n      "needSignature": false\n    },\n    {\n      "name": "asset",\n      "metadata": "ASSET",\n      "warningVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "errorVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "scope": "passive",\n      "needSignature": true,\n      "signatureKeyId": "grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0001"\n    },\n    {\n      "name": "eula",\n      "metadata": "EULA",\n      "warningVersion": {\n        "major": 4,\n        "minor": 4,\n        "micro": 4\n      },\n      "errorVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "scope": "active",\n      "currentVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      }\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_version_client.request import UpdateCurrentVersionMasterRequest
from gs2_version_client.result import UpdateCurrentVersionMasterResult

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

result = client.update_current_version_master_async(
    UpdateCurrentVersionMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-10-09",\n  "versionModels": [\n    {\n      "name": "app",\n      "metadata": "APP",\n      "warningVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "errorVersion": {\n        "major": 1,\n        "minor": 1,\n        "micro": 1\n      },\n      "scope": "passive",\n      "needSignature": false\n    },\n    {\n      "name": "asset",\n      "metadata": "ASSET",\n      "warningVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "errorVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "scope": "passive",\n      "needSignature": true,\n      "signatureKeyId": "grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0001"\n    },\n    {\n      "name": "eula",\n      "metadata": "EULA",\n      "warningVersion": {\n        "major": 4,\n        "minor": 4,\n        "micro": 4\n      },\n      "errorVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "scope": "active",\n      "currentVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      }\n    }\n  ]\n}'),
    callback
)
import io.gs2.version.request.UpdateCurrentVersionMasterRequest
import io.gs2.version.result.UpdateCurrentVersionMasterResult

result = client.updateCurrentVersionMaster(
    UpdateCurrentVersionMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-10-09",\n  "versionModels": [\n    {\n      "name": "app",\n      "metadata": "APP",\n      "warningVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "errorVersion": {\n        "major": 1,\n        "minor": 1,\n        "micro": 1\n      },\n      "scope": "passive",\n      "needSignature": false\n    },\n    {\n      "name": "asset",\n      "metadata": "ASSET",\n      "warningVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "errorVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      },\n      "scope": "passive",\n      "needSignature": true,\n      "signatureKeyId": "grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0001"\n    },\n    {\n      "name": "eula",\n      "metadata": "EULA",\n      "warningVersion": {\n        "major": 4,\n        "minor": 4,\n        "micro": 4\n      },\n      "errorVersion": {\n        "major": 3,\n        "minor": 3,\n        "micro": 3\n      },\n      "scope": "active",\n      "currentVersion": {\n        "major": 2,\n        "minor": 2,\n        "micro": 2\n      }\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Version::CurrentVersionMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効なバージョンを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentVersionMaster 更新した現在有効なバージョン

updateCurrentVersionMasterFromGitHub

同期処理

from gs2_version_client.request import UpdateCurrentVersionMasterFromGitHubRequest
from gs2_version_client.result import UpdateCurrentVersionMasterFromGitHubResult

result = client.update_current_version_master_from_git_hub(
    UpdateCurrentVersionMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.UpdateCurrentVersionMasterFromGitHubRequest
import io.gs2.version.result.UpdateCurrentVersionMasterFromGitHubResult

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

非同期処理

from gs2_version_client.request import UpdateCurrentVersionMasterFromGitHubRequest
from gs2_version_client.result import UpdateCurrentVersionMasterFromGitHubResult

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

result = client.update_current_version_master_from_git_hub_async(
    UpdateCurrentVersionMasterFromGitHubRequest()\
    callback
)
import io.gs2.version.request.UpdateCurrentVersionMasterFromGitHubRequest
import io.gs2.version.result.UpdateCurrentVersionMasterFromGitHubResult

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

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

現在有効なバージョンを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
checkoutSetting GitHubCheckoutSetting true GitHubからマスターデータをチェックアウトしてくる設定
パラメータ データ型 説明
item CurrentVersionMaster 更新した現在有効なバージョン

updateNamespace

同期処理

from gs2_version_client.request import UpdateNamespaceRequest
from gs2_version_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_version_client.request import UpdateNamespaceRequest
from gs2_version_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_assume_user_id('grn:gs2::{ownerId}:identifier:user:user-0002')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.version.request.UpdateNamespaceRequest
import io.gs2.version.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withAssumeUserId("grn:gs2::{ownerId}:identifier:user:user-0002")
        .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 説明文
assumeUserId string true バージョンチェック通過後に改めて発行するプロジェクトトークンの権限判定に使用する ユーザ のGRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateVersionModelMaster

同期処理

from gs2_version_client.request import UpdateVersionModelMasterRequest
from gs2_version_client.result import UpdateVersionModelMasterResult

result = client.update_version_model_master(
    UpdateVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name('version-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_warning_version(Object("Version", {"major": 3, "minor": 3, "micro": 3}))\
        .with_error_version(Object("Version", {"major": 2, "minor": 2, "micro": 2}))\
        .with_scope('active')\
        .with_current_version(Object("Version", {"major": 3, "minor": 0, "micro": 0}))\
        .with_need_signature(False)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.version.request.UpdateVersionModelMasterRequest
import io.gs2.version.result.UpdateVersionModelMasterResult

result = client.updateVersionModelMaster(
    UpdateVersionModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withVersionName("version-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withWarningVersion(Object("Version", {"major": 3, "minor": 3, "micro": 3}))
        .withErrorVersion(Object("Version", {"major": 2, "minor": 2, "micro": 2}))
        .withScope("active")
        .withCurrentVersion(Object("Version", {"major": 3, "minor": 0, "micro": 0}))
        .withNeedSignature(false)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_version_client.request import UpdateVersionModelMasterRequest
from gs2_version_client.result import UpdateVersionModelMasterResult

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

result = client.update_version_model_master_async(
    UpdateVersionModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_version_name('version-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_warning_version(Object("Version", {"major": 3, "minor": 3, "micro": 3}))\
        .with_error_version(Object("Version", {"major": 2, "minor": 2, "micro": 2}))\
        .with_scope('active')\
        .with_current_version(Object("Version", {"major": 3, "minor": 0, "micro": 0}))\
        .with_need_signature(False),
    callback
)
import io.gs2.version.request.UpdateVersionModelMasterRequest
import io.gs2.version.result.UpdateVersionModelMasterResult

result = client.updateVersionModelMaster(
    UpdateVersionModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withVersionName("version-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withWarningVersion(Object("Version", {"major": 3, "minor": 3, "micro": 3}))
        .withErrorVersion(Object("Version", {"major": 2, "minor": 2, "micro": 2}))
        .withScope("active")
        .withCurrentVersion(Object("Version", {"major": 3, "minor": 0, "micro": 0}))
        .withNeedSignature(false),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

バージョンマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
versionName string true バージョン名
description string false バージョンマスターの説明
metadata string false バージョンのメタデータ
warningVersion Version true バージョンアップを促すバージョン
errorVersion Version true バージョンチェックを蹴るバージョン
scope string true 判定に使用するバージョン値の種類
currentVersion Version true 現在のバージョン
needSignature boolean true 判定するバージョン値に署名検証を必要とするか
signatureKeyId string true 署名検証に使用する暗号鍵 のGRN
パラメータ データ型 説明
item VersionModelMaster 更新したバージョンマスター

GS2-Script トリガーイベント

AcceptVersionTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
version_model = args['versionModel']  -- type: VersionModel
accept_version = args['acceptVersion']  -- type: AcceptVersion

result = {
    permit=  -- type: boolean
}

バージョン承認時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
versionModel VersionModel バージョン設定
acceptVersion AcceptVersion 承認したバージョン
パラメータ データ型 説明
permit boolean バージョン承認を許可するか

AcceptVersionDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
version_model = args['versionModel']  -- type: VersionModel
accept_version = args['acceptVersion']  -- type: AcceptVersion

result = {
}

バージョン承認完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
versionModel VersionModel バージョン設定
acceptVersion AcceptVersion 承認したバージョン
パラメータ データ型 説明

CheckVersionTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
version_model = args['versionModel']  -- type: VersionModel
current_version = args['currentVersion']  -- type: Version
user_id = args['userId']  -- type: string
warning = args['warning']  -- type: Status
error = args['error']  -- type: Status

result = {
    overrideWarning=,  -- type: Status
    overrideError=  -- type: Status
}

バージョンチェック時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
versionModel VersionModel バージョン設定
currentVersion Version 現在のバージョン
userId string ユーザーID
warning Status 通常のバージョンチェックの結果 警告になった場合
error Status 通常のバージョンチェックの結果 エラーになった場合
パラメータ データ型 説明
overrideWarning Status チェック結果 警告
overrideError Status チェック結果 エラー

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

CurrentVersionMaster

{
  "version": "2019-10-09"
  "versionModels": [
    {
      "name": "[string] バージョンの種類名",
      "metadata": "[string] バージョンの種類のメタデータ",
      "scope": "[string] 判定に使用するバージョン値の種類",
      "needSignature": "[boolean] 判定するバージョン値に署名検証を必要とするか",
      "signatureKeyId": "[string] 署名検証に使用する暗号鍵 のGRN"
    }
  ]
}

現在有効なバージョン

エクスポートしたマスターデータを、現在有効なバージョンとしてインポートして使用します。

GS2-Version の制限・制約

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