NAV Navbar
Python Java GS2-Formation
 

GS2-Lock

排他処理を実現するためのサービスです。

GS2内のAPIによるリソースの操作は、そのままでは排他されません。 スタンプシートによってリソースの増減を行うときは、自動的にこのサービスが利用され、対象リソースのIDをキーとしてロックを取得します。 スタンプシートを経由せずにリソースの増減を行う場合、明示的に GS2-Lock を使用してロック操作を行う必要があります。

モデル

Namespace

ネームスペース

ネームスペースはロックの管理単位を表現します。 1つのネームスペースには複数のロック用ミューテックスを登録することができます。

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

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

Mutex

ミューテックス

参照カウント付きのロックオブジェクト。 たとえロック中でも同一トランザクションIDによるロック取得の場合は参照カウントが上昇し、ロックを取得できます。 アンロックする場合も同様に、ロックを取得したときに指定したトランザクションIDを指定してアンロックしなければエラーになります。 複数回ロックを取得して参照カウントが上昇している場合は、参照カウントが0になるまでアンロックするまで実際には開放されません。

パラメータ データ型 必須 説明
mutexId string true ミューテックス
userId string false ユーザーID
propertyId string true プロパティID
transactionId string true ロックを取得したトランザクションID
referenceCount integer true 参照回数
createdAt long true 作成日時
ttlAt long true ロックの有効期限

ResponseCache

レスポンスキャッシュ

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

LogSetting

ロギング通知設定

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

初期化処理

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

import gs2_core_client.model.*
import gs2_lock_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_lock_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 = Gs2LockRestClient(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.lock.rest.Gs2LockRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_lock_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 = Gs2LockWebSocketClient(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.lock.webSocket.Gs2LockWebSocketClient

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

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

GS2-Lock は 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_lock_client.request import CreateNamespaceRequest
from gs2_lock_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.lock.request.CreateNamespaceRequest
import io.gs2.lock.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_lock_client.request import CreateNamespaceRequest
from gs2_lock_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.lock.request.CreateNamespaceRequest
import io.gs2.lock.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::Lock::Namespace
Properties:
  Name: String
  Description: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

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

deleteMutexByUserId

同期処理

from gs2_lock_client.request import DeleteMutexByUserIdRequest
from gs2_lock_client.result import DeleteMutexByUserIdResult

result = client.delete_mutex_by_user_id(
    DeleteMutexByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_property_id('property-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.DeleteMutexByUserIdRequest
import io.gs2.lock.result.DeleteMutexByUserIdResult

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

非同期処理

from gs2_lock_client.request import DeleteMutexByUserIdRequest
from gs2_lock_client.result import DeleteMutexByUserIdResult

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

result = client.delete_mutex_by_user_id_async(
    DeleteMutexByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_property_id('property-0001'),
    callback
)
import io.gs2.lock.request.DeleteMutexByUserIdRequest
import io.gs2.lock.result.DeleteMutexByUserIdResult

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

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

ミューテックスを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
userId string true ユーザーID
propertyId string true プロパティID
パラメータ データ型 説明
item Mutex ミューテックス

deleteNamespace

同期処理

from gs2_lock_client.request import DeleteNamespaceRequest
from gs2_lock_client.result import DeleteNamespaceResult

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

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

非同期処理

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

describeMutexes

同期処理

from gs2_lock_client.request import DescribeMutexesRequest
from gs2_lock_client.result import DescribeMutexesResult

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

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

非同期処理

from gs2_lock_client.request import DescribeMutexesRequest
from gs2_lock_client.result import DescribeMutexesResult

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

result = client.describe_mutexes_async(
    DescribeMutexesRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.lock.request.DescribeMutexesRequest
import io.gs2.lock.result.DescribeMutexesResult

result = client.describeMutexes(
    DescribeMutexesRequest()
        .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[Mutex] ミューテックスのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeMutexesByUserId

同期処理

from gs2_lock_client.request import DescribeMutexesByUserIdRequest
from gs2_lock_client.result import DescribeMutexesByUserIdResult

result = client.describe_mutexes_by_user_id(
    DescribeMutexesByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.DescribeMutexesByUserIdRequest
import io.gs2.lock.result.DescribeMutexesByUserIdResult

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

非同期処理

from gs2_lock_client.request import DescribeMutexesByUserIdRequest
from gs2_lock_client.result import DescribeMutexesByUserIdResult

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

result = client.describe_mutexes_by_user_id_async(
    DescribeMutexesByUserIdRequest()\
    callback
)
import io.gs2.lock.request.DescribeMutexesByUserIdRequest
import io.gs2.lock.result.DescribeMutexesByUserIdResult

result = client.describeMutexesByUserId(
    DescribeMutexesByUserIdRequest(),
    (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[Mutex] ミューテックスのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_lock_client.request import DescribeNamespacesRequest
from gs2_lock_client.result import DescribeNamespacesResult

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

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

非同期処理

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

getMutex

同期処理

from gs2_lock_client.request import GetMutexRequest
from gs2_lock_client.result import GetMutexResult

result = client.get_mutex(
    GetMutexRequest()\
        .with_namespace_name('namespace-0001')\
        .with_property_id('property-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.GetMutexRequest
import io.gs2.lock.result.GetMutexResult

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

非同期処理

from gs2_lock_client.request import GetMutexRequest
from gs2_lock_client.result import GetMutexResult

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

result = client.get_mutex_async(
    GetMutexRequest()\
        .with_namespace_name('namespace-0001')\
        .with_property_id('property-0001'),
    callback
)
import io.gs2.lock.request.GetMutexRequest
import io.gs2.lock.result.GetMutexResult

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

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

ミューテックスを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
propertyId string true プロパティID
パラメータ データ型 説明
item Mutex ミューテックス

getMutexByUserId

同期処理

from gs2_lock_client.request import GetMutexByUserIdRequest
from gs2_lock_client.result import GetMutexByUserIdResult

result = client.get_mutex_by_user_id(
    GetMutexByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_property_id('property-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.GetMutexByUserIdRequest
import io.gs2.lock.result.GetMutexByUserIdResult

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

非同期処理

from gs2_lock_client.request import GetMutexByUserIdRequest
from gs2_lock_client.result import GetMutexByUserIdResult

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

result = client.get_mutex_by_user_id_async(
    GetMutexByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_property_id('property-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.lock.request.GetMutexByUserIdRequest
import io.gs2.lock.result.GetMutexByUserIdResult

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

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

ユーザIDを指定してミューテックスを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
propertyId string true プロパティID
userId string false ユーザーID
パラメータ データ型 説明
item Mutex ミューテックス

getNamespace

同期処理

from gs2_lock_client.request import GetNamespaceRequest
from gs2_lock_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_lock_client.request import GetNamespaceRequest
from gs2_lock_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.lock.request.GetNamespaceRequest
import io.gs2.lock.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_lock_client.request import GetNamespaceStatusRequest
from gs2_lock_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_lock_client.request import GetNamespaceStatusRequest
from gs2_lock_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.lock.request.GetNamespaceStatusRequest
import io.gs2.lock.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

lock

同期処理

from gs2_lock_client.request import LockRequest
from gs2_lock_client.result import LockResult

result = client.lock(
    LockRequest()\
        .with_namespace_name('namespace-0001')\
        .with_property_id('property-0001')\
        .with_transaction_id('transaction-0001')\
        .with_ttl(10)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.LockRequest
import io.gs2.lock.result.LockResult

result = client.lock(
    LockRequest()
        .withNamespaceName("namespace-0001")
        .withPropertyId("property-0001")
        .withTransactionId("transaction-0001")
        .withTtl(10l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_lock_client.request import LockRequest
from gs2_lock_client.result import LockResult

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

result = client.lock_async(
    LockRequest()\
        .with_namespace_name('namespace-0001')\
        .with_property_id('property-0001')\
        .with_transaction_id('transaction-0001')\
        .with_ttl(10),
    callback
)
import io.gs2.lock.request.LockRequest
import io.gs2.lock.result.LockResult

result = client.lock(
    LockRequest()
        .withNamespaceName("namespace-0001")
        .withPropertyId("property-0001")
        .withTransactionId("transaction-0001")
        .withTtl(10l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ミューテックスを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
propertyId string true プロパティID
transactionId string true ロックを取得するトランザクションID
ttl long true ロックを取得する期限(秒)
パラメータ データ型 説明
item Mutex ミューテックス

lockByUserId

同期処理

from gs2_lock_client.request import LockByUserIdRequest
from gs2_lock_client.result import LockByUserIdResult

result = client.lock_by_user_id(
    LockByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.LockByUserIdRequest
import io.gs2.lock.result.LockByUserIdResult

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

非同期処理

from gs2_lock_client.request import LockByUserIdRequest
from gs2_lock_client.result import LockByUserIdResult

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

result = client.lock_by_user_id_async(
    LockByUserIdRequest()\
    callback
)
import io.gs2.lock.request.LockByUserIdRequest
import io.gs2.lock.result.LockByUserIdResult

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

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

ユーザIDを指定してミューテックスを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
propertyId string true プロパティID
userId string false ユーザーID
transactionId string true ロックを取得するトランザクションID
ttl long true ロックを取得する期限(秒)
パラメータ データ型 説明
item Mutex ミューテックス

unlock

同期処理

from gs2_lock_client.request import UnlockRequest
from gs2_lock_client.result import UnlockResult

result = client.unlock(
    UnlockRequest()\
        .with_namespace_name('namespace-0001')\
        .with_property_id('property-0001')\
        .with_transaction_id('transaction-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.UnlockRequest
import io.gs2.lock.result.UnlockResult

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

非同期処理

from gs2_lock_client.request import UnlockRequest
from gs2_lock_client.result import UnlockResult

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

result = client.unlock_async(
    UnlockRequest()\
        .with_namespace_name('namespace-0001')\
        .with_property_id('property-0001')\
        .with_transaction_id('transaction-0001'),
    callback
)
import io.gs2.lock.request.UnlockRequest
import io.gs2.lock.result.UnlockResult

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

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

ミューテックスを解放

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
propertyId string true プロパティID
transactionId string true ロックを取得したトランザクションID
パラメータ データ型 説明
item Mutex ミューテックス

unlockByUserId

同期処理

from gs2_lock_client.request import UnlockByUserIdRequest
from gs2_lock_client.result import UnlockByUserIdResult

result = client.unlock_by_user_id(
    UnlockByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.lock.request.UnlockByUserIdRequest
import io.gs2.lock.result.UnlockByUserIdResult

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

非同期処理

from gs2_lock_client.request import UnlockByUserIdRequest
from gs2_lock_client.result import UnlockByUserIdResult

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

result = client.unlock_by_user_id_async(
    UnlockByUserIdRequest()\
    callback
)
import io.gs2.lock.request.UnlockByUserIdRequest
import io.gs2.lock.result.UnlockByUserIdResult

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

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

ユーザIDを指定してミューテックスを解放

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
propertyId string true プロパティID
userId string false ユーザーID
transactionId string true ロックを取得したトランザクションID
パラメータ データ型 説明
item Mutex ミューテックス

updateNamespace

同期処理

from gs2_lock_client.request import UpdateNamespaceRequest
from gs2_lock_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.lock.request.UpdateNamespaceRequest
import io.gs2.lock.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_lock_client.request import UpdateNamespaceRequest
from gs2_lock_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.lock.request.UpdateNamespaceRequest
import io.gs2.lock.result.UpdateNamespaceResult

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

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

ネームスペースを更新

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

GS2-Script トリガーイベント

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

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

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

GS2-Lock の制限・制約

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