API Reference of GS2-Guard SDK

Model

Namespace

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

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

	Type	Require	Default	Limitation	Description
namespaceId	string	✓		~ 1024 chars	Namespace GRN
name	string	✓		~ 128 chars	Namespace name
description	string			~ 1024 chars	Description
blockingPolicy	BlockingPolicyModel	✓			Blocking Policy
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

BlockingPolicyModel

Blocking Policy

	Type	Condition	Require	Default	Limitation	Description
passServices	List<string>		✓		1 ~ 100 items	List of GS2 services that can be accessed
defaultRestriction	enum { “Allow”, “Deny” }		✓	“Allow”	~ 128 chars	Default restriction
locationDetection	enum { “Enable”, “Disable” }		✓	“Disable”	~ 128 chars	Location detection
locations	List<string>	{locationDetection} == “Enable”	✓	[]	1 ~ 100 items	List of countries to detect access
locationRestriction	enum { “Allow”, “Deny” }	{locationDetection} == “Enable”	✓		~ 128 chars	Behavior when matched with the country list
anonymousIpDetection	enum { “Enable”, “Disable” }		✓	“Disable”	~ 128 chars	Anonymous IP Service Detection
anonymousIpRestriction	enum { “Deny” }	{anonymousIpDetection} == “Enable”	✓	“Deny”	~ 128 chars	Behavior when detected anonymous IP service
hostingProviderIpDetection	enum { “Enable”, “Disable” }		✓	“Disable”	~ 128 chars	Hosting Service Detection
hostingProviderIpRestriction	enum { “Deny” }	{hostingProviderIpDetection} == “Enable”	✓	“Deny”	~ 128 chars	Behavior when detected hosting service
reputationIpDetection	enum { “Enable”, “Disable” }		✓	“Disable”	~ 128 chars	Reputation access IP Detection
reputationIpRestriction	enum { “Deny” }	{reputationIpDetection} == “Enable”	✓	“Deny”	~ 128 chars	Behavior when detected malicious access source IP
ipAddressesDetection	enum { “Enable”, “Disable” }		✓	“Disable”	~ 128 chars	Access source IP detection
ipAddresses	List<string>	{ipAddressesDetection} == “Enable”			~ 100 items	List of ip addresses
ipAddressRestriction	enum { “Allow”, “Deny” }	{ipAddressesDetection} == “Enable”	✓		~ 128 chars	Behavior when matched with the IP address list

Enumeration type definition to specify as defaultRestriction

Enumerator String Definition	Description
Allow	Allow access from a predetermined access source
Deny	Deny access from a predetermined access source

Enumeration type definition to specify as locationDetection

Enumerator String Definition	Description
Enable	Enable
Disable	Disable

Enumeration type definition to specify as locationRestriction

Enumerator String Definition	Description
Allow	Allow
Deny	Deny

Enumeration type definition to specify as anonymousIpDetection

Enumerator String Definition	Description
Enable	Enable
Disable	Disable

Enumeration type definition to specify as anonymousIpRestriction

Enumerator String Definition	Description
Deny	Deny

Enumeration type definition to specify as hostingProviderIpDetection

Enumerator String Definition	Description
Enable	Enable
Disable	Disable

Enumeration type definition to specify as hostingProviderIpRestriction

Enumerator String Definition	Description
Deny	Deny

Enumeration type definition to specify as reputationIpDetection

Enumerator String Definition	Description
Enable	Enable
Disable	Disable

Enumeration type definition to specify as reputationIpRestriction

Enumerator String Definition	Description
Deny	Deny

Enumeration type definition to specify as ipAddressesDetection

Enumerator String Definition	Description
Enable	Enable
Disable	Disable

Enumeration type definition to specify as ipAddressRestriction

Enumerator String Definition	Description
Allow	Allow
Deny	Deny

Methods

describeNamespaces

Get list of namespaces

Get a list of all namespaces in the project. You can use the optional page token to start acquiring data from a specific location in the list. You can also limit the number of namespaces to be acquired.

Request

	Type	Condition	Require	Default	Limitation	Description
pageToken	string				~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int		✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<Namespace>	List of Namespace
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/guard"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := guard.Gs2GuardRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &guard.DescribeNamespacesRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Guard\Gs2GuardRestClient;
use Gs2\Guard\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.guard.rest.Gs2GuardRestClient;
import io.gs2.guard.request.DescribeNamespacesRequest;
import io.gs2.guard.result.DescribeNamespacesResult;

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

try {
    DescribeNamespacesResult result = client.describeNamespaces(
        new DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Guard.Gs2GuardRestClient;
using Gs2.Gs2Guard.Request.DescribeNamespacesRequest;
using Gs2.Gs2Guard.Result.DescribeNamespacesResult;

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

AsyncResult<Gs2.Gs2Guard.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2Guard.Request.DescribeNamespacesRequest()
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Guard from '@/gs2/guard';

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

try {
    const result = await client.describeNamespaces(
        new Gs2Guard.DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import guard

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

try:
    result = client.describe_namespaces(
        guard.DescribeNamespacesRequest()
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('guard')

api_result = client.describe_namespaces({
    pageToken=nil,
    limit=nil,
})

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

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('guard')

api_result_handler = client.describe_namespaces_async({
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

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

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

createNamespace

Create new namespace

You must specify detailed information including the name, description, and various settings of the namespace.

Request

	Type	Require	Limitation	Description
name	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
blockingPolicy	BlockingPolicyModel	✓		Blocking Policy

Result

	Type	Description
item	Namespace	Namespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/guard"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := guard.Gs2GuardRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &guard.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        BlockingPolicy: &guard.BlockingPolicyModel{
            PassServices: []*string{
                pointy.String("account"),
            },
            DefaultRestriction: pointy.String("Deny"),
            IpAddresses: []*string{
                pointy.String("192.168.0.0/24"),
            },
            IpAddressRestriction: pointy.String("Allow"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Guard\Gs2GuardRestClient;
use Gs2\Guard\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName(self::namespace1)
            ->withDescription(null)
            ->withBlockingPolicy((new \Gs2\Guard\Model\BlockingPolicyModel())
                ->withPassServices([
                    "account",
                ])
                ->withDefaultRestriction("Deny")
                ->withIpAddresses([
                    "192.168.0.0/24",
                ])
                ->withIpAddressRestriction("Allow"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.guard.rest.Gs2GuardRestClient;
import io.gs2.guard.request.CreateNamespaceRequest;
import io.gs2.guard.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withBlockingPolicy(new io.gs2.guard.model.BlockingPolicyModel()
                .withPassServices(Arrays.asList(
                    "account"
                ))
                .withDefaultRestriction("Deny")
                .withIpAddresses(Arrays.asList(
                    "192.168.0.0/24"
                ))
                .withIpAddressRestriction("Allow"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Guard.Gs2GuardRestClient;
using Gs2.Gs2Guard.Request.CreateNamespaceRequest;
using Gs2.Gs2Guard.Result.CreateNamespaceResult;

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

AsyncResult<Gs2.Gs2Guard.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Guard.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithBlockingPolicy(new Gs2.Gs2Guard.Model.BlockingPolicyModel()
            .WithPassServices(new string[] {
                "account",
            })
            .WithDefaultRestriction("Deny")
            .WithIpAddresses(new string[] {
                "192.168.0.0/24",
            })
            .WithIpAddressRestriction("Allow")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Guard from '@/gs2/guard';

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

try {
    const result = await client.createNamespace(
        new Gs2Guard.CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withBlockingPolicy(new Gs2Guard.model.BlockingPolicyModel()
                .withPassServices([
                    "account",
                ])
                .withDefaultRestriction("Deny")
                .withIpAddresses([
                    "192.168.0.0/24",
                ])
                .withIpAddressRestriction("Allow"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import guard

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

try:
    result = client.create_namespace(
        guard.CreateNamespaceRequest()
            .with_name(self.hash1)
            .with_description(None)
            .with_blocking_policy(
                guard.BlockingPolicyModel()
                    .with_pass_services([
                        'account',
                    ])
                    .with_default_restriction('Deny')
                    .with_ip_addresses([
                        '192.168.0.0/24',
                    ])
                    .with_ip_address_restriction('Allow'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('guard')

api_result = client.create_namespace({
    name="namespace1",
    description=nil,
    blockingPolicy={
        passServices={
            "account"
        },
        defaultRestriction="Deny",
        ipAddresses={
            "192.168.0.0/24"
        },
        ipAddressRestriction="Allow",
    },
})

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

result = api_result.result
item = result.item;

client = gs2('guard')

api_result_handler = client.create_namespace_async({
    name="namespace1",
    description=nil,
    blockingPolicy={
        passServices={
            "account"
        },
        defaultRestriction="Deny",
        ipAddresses={
            "192.168.0.0/24"
        },
        ipAddressRestriction="Allow",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

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

result = api_result.result
item = result.item;

getNamespaceStatus

Get namespace status

Get the current status of the specified namespace. This includes whether the namespace is active, pending, or in some other state.

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name

Result

	Type	Description
status	string

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/guard"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := guard.Gs2GuardRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &guard.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
status := result.Status

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Guard\Gs2GuardRestClient;
use Gs2\Guard\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName(self::namespace1)
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.guard.rest.Gs2GuardRestClient;
import io.gs2.guard.request.GetNamespaceStatusRequest;
import io.gs2.guard.result.GetNamespaceStatusResult;

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

try {
    GetNamespaceStatusResult result = client.getNamespaceStatus(
        new GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Guard.Gs2GuardRestClient;
using Gs2.Gs2Guard.Request.GetNamespaceStatusRequest;
using Gs2.Gs2Guard.Result.GetNamespaceStatusResult;

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

AsyncResult<Gs2.Gs2Guard.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Guard.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;

import Gs2Core from '@/gs2/core';
import * as Gs2Guard from '@/gs2/guard';

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

try {
    const result = await client.getNamespaceStatus(
        new Gs2Guard.GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import guard

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

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

client = gs2('guard')

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

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

result = api_result.result
status = result.status;

client = gs2('guard')

api_result_handler = client.get_namespace_status_async({
    namespaceName="namespace1",
})

api_result = api_result_handler()  -- Call the handler to get the result

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

result = api_result.result
status = result.status;

getNamespace

Get namespace

Get detailed information about the specified namespace. This includes the name, description, and other settings of the namespace.

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name

Result

	Type	Description
item	Namespace	Namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/guard"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := guard.Gs2GuardRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &guard.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Guard\Gs2GuardRestClient;
use Gs2\Guard\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.guard.rest.Gs2GuardRestClient;
import io.gs2.guard.request.GetNamespaceRequest;
import io.gs2.guard.result.GetNamespaceResult;

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

try {
    GetNamespaceResult result = client.getNamespace(
        new GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Guard.Gs2GuardRestClient;
using Gs2.Gs2Guard.Request.GetNamespaceRequest;
using Gs2.Gs2Guard.Result.GetNamespaceResult;

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

AsyncResult<Gs2.Gs2Guard.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Guard.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Guard from '@/gs2/guard';

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

try {
    const result = await client.getNamespace(
        new Gs2Guard.GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import guard

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

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

client = gs2('guard')

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

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

result = api_result.result
item = result.item;

client = gs2('guard')

api_result_handler = client.get_namespace_async({
    namespaceName="namespace1",
})

api_result = api_result_handler()  -- Call the handler to get the result

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

result = api_result.result
item = result.item;

updateNamespace

Update namespace

Update the settings of the specified namespace. You can change the description of the namespace and specific settings.

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
blockingPolicy	BlockingPolicyModel	✓		Blocking Policy

Result

	Type	Description
item	Namespace	Updated namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/guard"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := guard.Gs2GuardRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &guard.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        BlockingPolicy: &guard.BlockingPolicyModel{
            PassServices: []*string{
                pointy.String("account"),
                pointy.String("dictionary"),
                pointy.String("inventory"),
            },
            DefaultRestriction: pointy.String("Allow"),
            LocationDetection: pointy.String("Enable"),
            Locations: []*string{
                pointy.String("CN"),
            },
            LocationRestriction: pointy.String("Deny"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Guard\Gs2GuardRestClient;
use Gs2\Guard\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName(self::namespace1)
            ->withDescription("description1")
            ->withBlockingPolicy((new \Gs2\Guard\Model\BlockingPolicyModel())
                ->withPassServices([
                    "account",
                    "dictionary",
                    "inventory",
                ])
                ->withDefaultRestriction("Allow")
                ->withLocationDetection("Enable")
                ->withLocations([
                    "CN",
                ])
                ->withLocationRestriction("Deny"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.guard.rest.Gs2GuardRestClient;
import io.gs2.guard.request.UpdateNamespaceRequest;
import io.gs2.guard.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withBlockingPolicy(new io.gs2.guard.model.BlockingPolicyModel()
                .withPassServices(Arrays.asList(
                    "account",
                    "dictionary",
                    "inventory"
                ))
                .withDefaultRestriction("Allow")
                .withLocationDetection("Enable")
                .withLocations(Arrays.asList(
                    "CN"
                ))
                .withLocationRestriction("Deny"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Guard.Gs2GuardRestClient;
using Gs2.Gs2Guard.Request.UpdateNamespaceRequest;
using Gs2.Gs2Guard.Result.UpdateNamespaceResult;

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

AsyncResult<Gs2.Gs2Guard.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Guard.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithBlockingPolicy(new Gs2.Gs2Guard.Model.BlockingPolicyModel()
            .WithPassServices(new string[] {
                "account",
                "dictionary",
                "inventory",
            })
            .WithDefaultRestriction("Allow")
            .WithLocationDetection("Enable")
            .WithLocations(new string[] {
                "CN",
            })
            .WithLocationRestriction("Deny")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Guard from '@/gs2/guard';

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

try {
    const result = await client.updateNamespace(
        new Gs2Guard.UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withBlockingPolicy(new Gs2Guard.model.BlockingPolicyModel()
                .withPassServices([
                    "account",
                    "dictionary",
                    "inventory",
                ])
                .withDefaultRestriction("Allow")
                .withLocationDetection("Enable")
                .withLocations([
                    "CN",
                ])
                .withLocationRestriction("Deny"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import guard

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

try:
    result = client.update_namespace(
        guard.UpdateNamespaceRequest()
            .with_namespace_name(self.hash1)
            .with_description('description1')
            .with_blocking_policy(
                guard.BlockingPolicyModel()
                    .with_pass_services([
                        'account',
                        'dictionary',
                        'inventory',
                    ])
                    .with_default_restriction('Allow')
                    .with_location_detection('Enable')
                    .with_locations([
                        'CN',
                    ])
                    .with_location_restriction('Deny'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('guard')

api_result = client.update_namespace({
    namespaceName="namespace1",
    description="description1",
    blockingPolicy={
        passServices={
            "account",
            "dictionary",
            "inventory"
        },
        defaultRestriction="Allow",
        locationDetection="Enable",
        locations={
            "CN"
        },
        locationRestriction="Deny",
    },
})

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

result = api_result.result
item = result.item;

client = gs2('guard')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace1",
    description="description1",
    blockingPolicy={
        passServices={
            "account",
            "dictionary",
            "inventory"
        },
        defaultRestriction="Allow",
        locationDetection="Enable",
        locations={
            "CN"
        },
        locationRestriction="Deny",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

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

result = api_result.result
item = result.item;

deleteNamespace

Delete namespace

Delete the specified namespace. This operation is irreversible and all data associated with the deleted namespace will be lost.

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name

Result

	Type	Description
item	Namespace	Deleted namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/guard"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := guard.Gs2GuardRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &guard.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Guard\Gs2GuardRestClient;
use Gs2\Guard\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.guard.rest.Gs2GuardRestClient;
import io.gs2.guard.request.DeleteNamespaceRequest;
import io.gs2.guard.result.DeleteNamespaceResult;

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

try {
    DeleteNamespaceResult result = client.deleteNamespace(
        new DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Guard.Gs2GuardRestClient;
using Gs2.Gs2Guard.Request.DeleteNamespaceRequest;
using Gs2.Gs2Guard.Result.DeleteNamespaceResult;

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

AsyncResult<Gs2.Gs2Guard.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Guard.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Guard from '@/gs2/guard';

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

try {
    const result = await client.deleteNamespace(
        new Gs2Guard.DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import guard

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

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

client = gs2('guard')

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

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

result = api_result.result
item = result.item;

client = gs2('guard')

api_result_handler = client.delete_namespace_async({
    namespaceName="namespace1",
})

api_result = api_result_handler()  -- Call the handler to get the result

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

result = api_result.result
item = result.item;