NAV Navbar
Python Java GS2-Formation
 

GS2-JobQueue

ジョブキュー機能を提供するサービスです。

ジョブキューはFIFOを保証したキューで、結果整合処理に使用できます。 結果整合処理とはAPIが応答した時点では処理の完了が保証されず、しばらくの時間の経過をもって”結果的に意図した状態になる”仕組みです。

GS2 では報酬付与の多くの部分を結果整合で処理します。 これは、報酬を付与する際に報酬を管理するサーバーがダウンしていると、芋づる式にいろいろなサービスが利用できなくなることを避けるためです。 報酬付与の処理をジョブキューに登録し、ジョブを実行する際に対象のサーバーが利用できない状態だったとしても、ジョブのリトライで結果整合を実現します。 リトライ回数には最大値を指定でき、最大値に達しても成功しなかった場合はデッドレタージョブという失敗したジョブが蓄積するモデルに格納されます。 デッドレタージョブを使って、処理の失敗したジョブに関して、個別対応を行えるようになっています。

GS2-JobQueue のジョブは勝手には実行されず、明示的に実行APIを呼び出す必要があります。 これにはジョブの戻り値をクライアント側で把握できるようにする目的があります。 例えば、GS2-Quest上でクエストをクリアしたあと、ジョブキューに報酬を付与するジョブが登録され、 クライアントはジョブキューを終端まで実行することでクエストによって得られた報酬付与処理を明示的に実行することができます。(結果整合の遅延処理の完了を待つことが可能) なおかつ、そのジョブの戻り値を参照することで得られた報酬をUIに反映することができます。

ジョブの登録・実行は1秒間に3回までしか行なえません。

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

モデル

Namespace

ネームスペース

1つのネームスペースにゲームプレイヤーごとにジョブキューが作成されます。 ジョブキューに対する操作(ジョブの登録・実行)は1秒間に実行できる回数に制限があります。 ジョブのカテゴリごとにネームスペースを分割することで、1秒間に登録・実行できるジョブの数に関する制約を回避できます。

ネームスペースを分割するデメリットとして、ジョブを実行するジョブキューの総数が増えるため、ジョブキューの状態管理が複雑化します。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
pushNotification NotificationSetting false ジョブキューにジョブが登録されたときののプッシュ通知
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Job

ジョブ

ジョブには実行する GS2-Script とその引数、リトライ回数が記録されています。

パラメータ データ型 必須 説明
jobId string true ジョブ
name string true ジョブの名前
userId string false ユーザーID
scriptId string true ジョブの実行に使用するスクリプト のGRN
args string true 引数
currentRetryCount integer true 現在のリトライ回数
maxTryCount integer true 最大試行回数
index double true ソート用インデックス(現在時刻(ミリ秒).登録時のインデックス)
createdAt long true 作成日時
updatedAt long true 最終更新日時

JobResult

ジョブ実行結果

ジョブの実行に失敗したときに記録される GS2-Script の実行結果

パラメータ データ型 必須 説明
jobResultId string true ジョブ実行結果
jobId string true ジョブ
tryNumber integer true
statusCode integer true
result string true レスポンスの内容
tryAt long true 作成日時

DeadLetterJob

デッドレタージョブ

最大リトライ回数実行したが、一度も成功しなかったジョブが記録されます。

パラメータ データ型 必須 説明
deadLetterJobId string true デッドレタージョブ
name string true ジョブの名前
userId string false ユーザーID
scriptId string true ジョブの実行に使用するスクリプト のGRN
args string true 引数
result list[JobResultBody] true ジョブ実行結果
createdAt long true 作成日時
updatedAt long true 最終更新日時

ResponseCache

レスポンスキャッシュ

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

NotificationSetting

プッシュ通知設定

パラメータ データ型 必須 説明
gatewayNamespaceId string false プッシュ通知に使用する GS2-Gateway のネームスペース のGRN
enableTransferMobileNotification boolean false モバイルプッシュ通知へ転送するか
sound string false モバイルプッシュ通知で使用するサウンドファイル名

LogSetting

ロギング通知設定

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

JobEntry

ジョブ

パラメータ データ型 必須 説明
scriptId string true スクリプト のGRN
args string true 引数
maxTryCount integer true 最大試行回数

JobResultBody

ジョブの実行結果

ジョブとして実行した GS2-Script の実行結果

パラメータ データ型 必須 説明
tryNumber integer true 試行回数
statusCode integer true ステータスコード
result string true レスポンスの内容
tryAt long true 実行日時

初期化処理

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

import gs2_core_client.model.*
import gs2_job_queue_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_job_queue_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 = Gs2JobQueueRestClient(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.jobQueue.rest.Gs2JobQueueRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_job_queue_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 = Gs2JobQueueWebSocketClient(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.jobQueue.webSocket.Gs2JobQueueWebSocketClient

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

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

GS2-JobQueue は 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_job_queue_client.request import CreateNamespaceRequest
from gs2_job_queue_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.jobQueue.request.CreateNamespaceRequest
import io.gs2.jobQueue.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_job_queue_client.request import CreateNamespaceRequest
from gs2_job_queue_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.jobQueue.request.CreateNamespaceRequest
import io.gs2.jobQueue.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::JobQueue::Namespace
Properties:
  Name: String
  Description: Optional[String]
  PushNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
pushNotification NotificationSetting false ジョブキューにジョブが登録されたときののプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteDeadLetterJobByUserId

同期処理

from gs2_job_queue_client.request import DeleteDeadLetterJobByUserIdRequest
from gs2_job_queue_client.result import DeleteDeadLetterJobByUserIdResult

result = client.delete_dead_letter_job_by_user_id(
    DeleteDeadLetterJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_dead_letter_job_name('deadLetterJob1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.DeleteDeadLetterJobByUserIdRequest
import io.gs2.jobQueue.result.DeleteDeadLetterJobByUserIdResult

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

非同期処理

from gs2_job_queue_client.request import DeleteDeadLetterJobByUserIdRequest
from gs2_job_queue_client.result import DeleteDeadLetterJobByUserIdResult

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

result = client.delete_dead_letter_job_by_user_id_async(
    DeleteDeadLetterJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_dead_letter_job_name('deadLetterJob1'),
    callback
)
import io.gs2.jobQueue.request.DeleteDeadLetterJobByUserIdRequest
import io.gs2.jobQueue.result.DeleteDeadLetterJobByUserIdResult

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

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

デッドレタージョブを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
deadLetterJobName string true ジョブの名前
パラメータ データ型 説明
item DeadLetterJob デッドレタージョブ

deleteJobByUserId

同期処理

from gs2_job_queue_client.request import DeleteJobByUserIdRequest
from gs2_job_queue_client.result import DeleteJobByUserIdResult

result = client.delete_job_by_user_id(
    DeleteJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_job_name('job1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.DeleteJobByUserIdRequest
import io.gs2.jobQueue.result.DeleteJobByUserIdResult

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

非同期処理

from gs2_job_queue_client.request import DeleteJobByUserIdRequest
from gs2_job_queue_client.result import DeleteJobByUserIdResult

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

result = client.delete_job_by_user_id_async(
    DeleteJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_job_name('job1'),
    callback
)
import io.gs2.jobQueue.request.DeleteJobByUserIdRequest
import io.gs2.jobQueue.result.DeleteJobByUserIdResult

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

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

ジョブを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
jobName string true ジョブの名前
パラメータ データ型 説明
item Job ジョブ

deleteNamespace

同期処理

from gs2_job_queue_client.request import DeleteNamespaceRequest
from gs2_job_queue_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_job_queue_client.request import DeleteNamespaceRequest
from gs2_job_queue_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.jobQueue.request.DeleteNamespaceRequest
import io.gs2.jobQueue.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 削除したネームスペース

describeDeadLetterJobsByUserId

同期処理

from gs2_job_queue_client.request import DescribeDeadLetterJobsByUserIdRequest
from gs2_job_queue_client.result import DescribeDeadLetterJobsByUserIdResult

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

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

非同期処理

from gs2_job_queue_client.request import DescribeDeadLetterJobsByUserIdRequest
from gs2_job_queue_client.result import DescribeDeadLetterJobsByUserIdResult

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

result = client.describe_dead_letter_jobs_by_user_id_async(
    DescribeDeadLetterJobsByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.jobQueue.request.DescribeDeadLetterJobsByUserIdRequest
import io.gs2.jobQueue.result.DescribeDeadLetterJobsByUserIdResult

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

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

デッドレタージョブの一覧を取得

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

describeJobsByUserId

同期処理

from gs2_job_queue_client.request import DescribeJobsByUserIdRequest
from gs2_job_queue_client.result import DescribeJobsByUserIdResult

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

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

非同期処理

from gs2_job_queue_client.request import DescribeJobsByUserIdRequest
from gs2_job_queue_client.result import DescribeJobsByUserIdResult

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

result = client.describe_jobs_by_user_id_async(
    DescribeJobsByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.jobQueue.request.DescribeJobsByUserIdRequest
import io.gs2.jobQueue.result.DescribeJobsByUserIdResult

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

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

ジョブの一覧を取得

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

describeNamespaces

同期処理

from gs2_job_queue_client.request import DescribeNamespacesRequest
from gs2_job_queue_client.result import DescribeNamespacesResult

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

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

非同期処理

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

getDeadLetterJobByUserId

同期処理

from gs2_job_queue_client.request import GetDeadLetterJobByUserIdRequest
from gs2_job_queue_client.result import GetDeadLetterJobByUserIdResult

result = client.get_dead_letter_job_by_user_id(
    GetDeadLetterJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_dead_letter_job_name('deadLetterJob1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.GetDeadLetterJobByUserIdRequest
import io.gs2.jobQueue.result.GetDeadLetterJobByUserIdResult

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

非同期処理

from gs2_job_queue_client.request import GetDeadLetterJobByUserIdRequest
from gs2_job_queue_client.result import GetDeadLetterJobByUserIdResult

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

result = client.get_dead_letter_job_by_user_id_async(
    GetDeadLetterJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_dead_letter_job_name('deadLetterJob1'),
    callback
)
import io.gs2.jobQueue.request.GetDeadLetterJobByUserIdRequest
import io.gs2.jobQueue.result.GetDeadLetterJobByUserIdResult

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

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

デッドレタージョブを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
deadLetterJobName string true ジョブの名前
パラメータ データ型 説明
item DeadLetterJob デッドレタージョブ

getJobByUserId

同期処理

from gs2_job_queue_client.request import GetJobByUserIdRequest
from gs2_job_queue_client.result import GetJobByUserIdResult

result = client.get_job_by_user_id(
    GetJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_job_name('job1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.GetJobByUserIdRequest
import io.gs2.jobQueue.result.GetJobByUserIdResult

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

非同期処理

from gs2_job_queue_client.request import GetJobByUserIdRequest
from gs2_job_queue_client.result import GetJobByUserIdResult

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

result = client.get_job_by_user_id_async(
    GetJobByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_job_name('job1'),
    callback
)
import io.gs2.jobQueue.request.GetJobByUserIdRequest
import io.gs2.jobQueue.result.GetJobByUserIdResult

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

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

ジョブを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
jobName string true ジョブの名前
パラメータ データ型 説明
item Job ジョブ

getNamespace

同期処理

from gs2_job_queue_client.request import GetNamespaceRequest
from gs2_job_queue_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_job_queue_client.request import GetNamespaceRequest
from gs2_job_queue_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.jobQueue.request.GetNamespaceRequest
import io.gs2.jobQueue.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_job_queue_client.request import GetNamespaceStatusRequest
from gs2_job_queue_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_job_queue_client.request import GetNamespaceStatusRequest
from gs2_job_queue_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.jobQueue.request.GetNamespaceStatusRequest
import io.gs2.jobQueue.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

pushByStampSheet

同期処理

from gs2_job_queue_client.request import PushByStampSheetRequest
from gs2_job_queue_client.result import PushByStampSheetResult

result = client.push_by_stamp_sheet(
    PushByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.PushByStampSheetRequest
import io.gs2.jobQueue.result.PushByStampSheetResult

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

非同期処理

from gs2_job_queue_client.request import PushByStampSheetRequest
from gs2_job_queue_client.result import PushByStampSheetResult

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

result = client.push_by_stamp_sheet_async(
    PushByStampSheetRequest()\
    callback
)
import io.gs2.jobQueue.request.PushByStampSheetRequest
import io.gs2.jobQueue.result.PushByStampSheetResult

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

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

スタンプシートでジョブを登録

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
items list[Job] 追加した{model_name}の一覧

pushByUserId

同期処理

from gs2_job_queue_client.request import PushByUserIdRequest
from gs2_job_queue_client.result import PushByUserIdResult

result = client.push_by_user_id(
    PushByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_jobs([
Object("JobEntry", {"scriptId": 'script-0001', "args": '{"hoge": "fuga"}'}),    
Object("JobEntry", {"scriptId": 'script-0001', "args": '{"piyo": "piyopiyo"}'})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.PushByUserIdRequest
import io.gs2.jobQueue.result.PushByUserIdResult

result = client.pushByUserId(
    PushByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withUserId("user-0001")
        .withJobs(new [] {
Object("JobEntry", {"scriptId": "script-0001", "args": "{"hoge": "fuga"}"}),    
Object("JobEntry", {"scriptId": "script-0001", "args": "{"piyo": "piyopiyo"}"})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_job_queue_client.request import PushByUserIdRequest
from gs2_job_queue_client.result import PushByUserIdResult

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

result = client.push_by_user_id_async(
    PushByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')\
        .with_jobs([
Object("JobEntry", {"scriptId": 'script-0001', "args": '{"hoge": "fuga"}'}),    
Object("JobEntry", {"scriptId": 'script-0001', "args": '{"piyo": "piyopiyo"}'})
]),
    callback
)
import io.gs2.jobQueue.request.PushByUserIdRequest
import io.gs2.jobQueue.result.PushByUserIdResult

result = client.pushByUserId(
    PushByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withUserId("user-0001")
        .withJobs(new [] {
Object("JobEntry", {"scriptId": "script-0001", "args": "{"hoge": "fuga"}"}),    
Object("JobEntry", {"scriptId": "script-0001", "args": "{"piyo": "piyopiyo"}"})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザIDを指定してジョブを登録

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
jobs list[JobEntry] false 追加するジョブの一覧
パラメータ データ型 説明
items list[Job] 追加した{model_name}の一覧

run

同期処理

from gs2_job_queue_client.request import RunRequest
from gs2_job_queue_client.result import RunResult

result = client.run(
    RunRequest()\
        .with_namespace_name('namespace-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.RunRequest
import io.gs2.jobQueue.result.RunResult

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

非同期処理

from gs2_job_queue_client.request import RunRequest
from gs2_job_queue_client.result import RunResult

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

result = client.run_async(
    RunRequest()\
        .with_namespace_name('namespace-0002'),
    callback
)
import io.gs2.jobQueue.request.RunRequest
import io.gs2.jobQueue.result.RunResult

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

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

ジョブを実行

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Job ジョブ
result JobResultBody ジョブの実行結果
isLastJob boolean

runByUserId

同期処理

from gs2_job_queue_client.request import RunByUserIdRequest
from gs2_job_queue_client.result import RunByUserIdResult

result = client.run_by_user_id(
    RunByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.jobQueue.request.RunByUserIdRequest
import io.gs2.jobQueue.result.RunByUserIdResult

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

非同期処理

from gs2_job_queue_client.request import RunByUserIdRequest
from gs2_job_queue_client.result import RunByUserIdResult

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

result = client.run_by_user_id_async(
    RunByUserIdRequest()\
    callback
)
import io.gs2.jobQueue.request.RunByUserIdRequest
import io.gs2.jobQueue.result.RunByUserIdResult

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

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

ユーザIDを指定してジョブを実行

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
パラメータ データ型 説明
item Job ジョブ
result JobResultBody ジョブの実行結果
isLastJob boolean

updateNamespace

同期処理

from gs2_job_queue_client.request import UpdateNamespaceRequest
from gs2_job_queue_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.jobQueue.request.UpdateNamespaceRequest
import io.gs2.jobQueue.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_job_queue_client.request import UpdateNamespaceRequest
from gs2_job_queue_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.jobQueue.request.UpdateNamespaceRequest
import io.gs2.jobQueue.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 ネームスペースの説明
pushNotification NotificationSetting false ジョブキューにジョブが登録されたときののプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

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

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

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

GS2-JobQueue の制限・制約

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