GS2-Freeze SDK API Reference

Specification of models and API references for GS2-Freeze SDK for various programming languages

Model

Output

Output of stage update progress

Represents a log entry generated during a stage version update operation. Each output captures a step or event in the update process. Outputs are automatically cleaned up after 30 days.

Details

	Type	Required	Default	Value Limits	Description
outputId	string	*		~ 1024 chars	Stage update progress output GRN * Set automatically by the server
name	string	✓	UUID	~ 36 chars	Output Name Maintains a unique name for each output of stage update progress. The name is automatically generated in UUID (Universally Unique Identifier) format and used to identify each output of stage update progress.
text	string	✓		~ 1048576 chars	Text The log message content describing a specific step or event during the stage update process. May contain status information, error details, or progress indicators for the version transition operation.
createdAt	long	*	Now		Timestamp
revision	long		0	0 ~ 9223372036854775805	Revision

Stage

A stage is an environment information that fixes the program version. You can have multiple stages for one project. A stage has a source stage, and it is possible to switch to the version fixed by the source stage.

By using this mechanism, you can first incorporate the latest version into the dev stage and check the operation at the developer level. If there seems to be no problem, the dev stage can be reflected in the stg stage, which has the dev stage as the source stage. After QA, the stg stage can be reflected in the live stage, which has the stg stage as the source stage.

Details

Type

Condition

Required

Default

Value Limits

Description

stageId

string

~ 1024 chars

Stage GRN

* Set automatically by the server

name

string

✓

~ 128 chars

Stage name

The identifier for this stage environment (e.g., “dev”, “stg”, “live”).

sourceStageName

string

~ 128 chars

Source Stage name

The name of the stage from which this stage pulls its version configuration. When updating, the versions pinned by the source stage are adopted. For example, a “stg” stage might have “dev” as its source, and “live” might have “stg”. If not specified, the latest versions are used directly.

sortNumber

int

✓

0 ~ 100

Sort number

A numeric value used to control the display order of stages. Lower numbers are displayed first. Useful for arranging stages in a logical progression (e.g., dev=0, stg=50, live=100).

status

String Enum
enum {
  “Active”,
  “Updating”,
  “UpdateFailed”
}

“Active”

Status

The current state of the stage. “Active” indicates normal operation with pinned versions serving requests. “Updating” indicates a version transition is in progress. “UpdateFailed” indicates the version update encountered an error and may require manual intervention.

Definition	Description
“Active”	Active
“Updating”	Updating
“UpdateFailed”	Update Failed

createdAt

long

Now

Datetime of creation

Unix time, milliseconds
* Set automatically by the server

updatedAt

long

Now

Datetime of last update

Unix time, milliseconds
* Set automatically by the server

revision

long

0 ~ 9223372036854775805

Revision

Microservice

Represents a GS2 microservice component. Each microservice has a name and version that can be pinned to a specific stage.

Details

	Type	Condition	Required	Default	Value Limits	Description
name	string		✓		~ 128 chars	Microservice name The identifier for this microservice.
version	string		✓		~ 32 chars	Microservice version The version identifier of this microservice. Used to pin the microservice to a specific version during stage deployment, ensuring consistent behavior across environments.

Methods

describeOutputs

Get a list of stage update progress outputs

Retrieves a paginated list of output log entries for a specific stage’s update operations (promote/rollback). Output entries are created at each step of the promote or rollback process, including start, step completion, and final success or failure messages. This API can be used to monitor the progress of ongoing deployments.

Details

Request

	Type	Required	Default	Value Limits	Description
stageName	string	✓		~ 128 chars	Stage name The identifier for this stage environment (e.g., “dev”, “stg”, “live”).
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int		30	1 ~ 1000	Number of data items to retrieve

Result

	Type	Description
items	List<Output>	List of Output of stage update progress
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/freeze"
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 := freeze.Gs2FreezeRestClient{
    Session: &session,
}
result, err := client.DescribeOutputs(
    &freeze.DescribeOutputsRequest {
        StageName: pointy.String("namespace-0001"),
        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\Freeze\Gs2FreezeRestClient;
use Gs2\Freeze\Request\DescribeOutputsRequest;

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

$session->open();

$client = new Gs2FreezeRestClient(
    $session
);

try {
    $result = $client->describeOutputs(
        (new DescribeOutputsRequest())
            ->withStageName("namespace-0001")
            ->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.freeze.rest.Gs2FreezeRestClient;
import io.gs2.freeze.request.DescribeOutputsRequest;
import io.gs2.freeze.result.DescribeOutputsResult;

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

try {
    DescribeOutputsResult result = client.describeOutputs(
        new DescribeOutputsRequest()
            .withStageName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Output> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FreezeRestClient(session);

AsyncResult<Gs2.Gs2Freeze.Result.DescribeOutputsResult> asyncResult = null;
yield return client.DescribeOutputs(
    new Gs2.Gs2Freeze.Request.DescribeOutputsRequest()
        .WithStageName("namespace-0001")
        .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 Gs2Freeze from '@/gs2/freeze';

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

try {
    const result = await client.describeOutputs(
        new Gs2Freeze.DescribeOutputsRequest()
            .withStageName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import freeze

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

try:
    result = client.describe_outputs(
        freeze.DescribeOutputsRequest()
            .with_stage_name('namespace-0001')
            .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('freeze')

api_result = client.describe_outputs({
    stageName="namespace-0001",
    pageToken=nil,
    limit=nil,
})

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

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

client = gs2('freeze')

api_result_handler = client.describe_outputs_async({
    stageName="namespace-0001",
    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['errorMessage'])
end

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

getOutput

Get stage update progress output

Retrieves a specific output log entry for a stage’s update operation. Each output entry contains a text message describing what occurred at that point in the promote or rollback process.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
stageName	string		✓		~ 128 chars	Stage name The identifier for this stage environment (e.g., “dev”, “stg”, “live”).
outputName	string		✓	UUID	~ 36 chars	Output Name Maintains a unique name for each output of stage update progress. The name is automatically generated in UUID (Universally Unique Identifier) format and used to identify each output of stage update progress.

Result

	Type	Description
item	Output	Output

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/freeze"
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 := freeze.Gs2FreezeRestClient{
    Session: &session,
}
result, err := client.GetOutput(
    &freeze.GetOutputRequest {
        StageName: pointy.String("namespace-0001"),
        OutputName: pointy.String("output-0001"),
    }
)
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\Freeze\Gs2FreezeRestClient;
use Gs2\Freeze\Request\GetOutputRequest;

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

$session->open();

$client = new Gs2FreezeRestClient(
    $session
);

try {
    $result = $client->getOutput(
        (new GetOutputRequest())
            ->withStageName("namespace-0001")
            ->withOutputName("output-0001")
    );
    $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.freeze.rest.Gs2FreezeRestClient;
import io.gs2.freeze.request.GetOutputRequest;
import io.gs2.freeze.result.GetOutputResult;

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

try {
    GetOutputResult result = client.getOutput(
        new GetOutputRequest()
            .withStageName("namespace-0001")
            .withOutputName("output-0001")
    );
    Output item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FreezeRestClient(session);

AsyncResult<Gs2.Gs2Freeze.Result.GetOutputResult> asyncResult = null;
yield return client.GetOutput(
    new Gs2.Gs2Freeze.Request.GetOutputRequest()
        .WithStageName("namespace-0001")
        .WithOutputName("output-0001"),
    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 Gs2Freeze from '@/gs2/freeze';

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

try {
    const result = await client.getOutput(
        new Gs2Freeze.GetOutputRequest()
            .withStageName("namespace-0001")
            .withOutputName("output-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import freeze

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

try:
    result = client.get_output(
        freeze.GetOutputRequest()
            .with_stage_name('namespace-0001')
            .with_output_name('output-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('freeze')

api_result = client.get_output({
    stageName="namespace-0001",
    outputName="output-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('freeze')

api_result_handler = client.get_output_async({
    stageName="namespace-0001",
    outputName="output-0001",
})

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['errorMessage'])
end

result = api_result.result
item = result.item;

describeStages

Get a list of stages

Retrieves a list of deployment stages owned by the requesting user. Each stage represents an environment (e.g., development, staging, production) with its own microservice version configuration.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description

Result

	Type	Description
items	List<Stage>	List of Stage

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/freeze"
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 := freeze.Gs2FreezeRestClient{
    Session: &session,
}
result, err := client.DescribeStages(
    &freeze.DescribeStagesRequest {
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Freeze\Gs2FreezeRestClient;
use Gs2\Freeze\Request\DescribeStagesRequest;

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

$session->open();

$client = new Gs2FreezeRestClient(
    $session
);

try {
    $result = $client->describeStages(
        (new DescribeStagesRequest())
    );
    $items = $result->getItems();
} 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.freeze.rest.Gs2FreezeRestClient;
import io.gs2.freeze.request.DescribeStagesRequest;
import io.gs2.freeze.result.DescribeStagesResult;

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

try {
    DescribeStagesResult result = client.describeStages(
        new DescribeStagesRequest()
    );
    List<Stage> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FreezeRestClient(session);

AsyncResult<Gs2.Gs2Freeze.Result.DescribeStagesResult> asyncResult = null;
yield return client.DescribeStages(
    new Gs2.Gs2Freeze.Request.DescribeStagesRequest(),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;

import Gs2Core from '@/gs2/core';
import * as Gs2Freeze from '@/gs2/freeze';

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

try {
    const result = await client.describeStages(
        new Gs2Freeze.DescribeStagesRequest()
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import freeze

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

try:
    result = client.describe_stages(
        freeze.DescribeStagesRequest()
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('freeze')

api_result = client.describe_stages({
})

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

result = api_result.result
items = result.items;

client = gs2('freeze')

api_result_handler = client.describe_stages_async({
})

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['errorMessage'])
end

result = api_result.result
items = result.items;

getStage

Get stage

Retrieves detailed information about a specific deployment stage, including the source microservice versions (from the previous stage) and the currently deployed microservice versions. The source versions represent the version configuration that would be applied on the next promotion, while the current versions represent what is actually deployed.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
stageName	string		✓		~ 128 chars	Stage name The identifier for this stage environment (e.g., “dev”, “stg”, “live”).

Result

	Type	Description
item	Stage	Stage
source	List<Microservice>	List of version of source microservices
current	List<Microservice>	List of current version of microservices

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/freeze"
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 := freeze.Gs2FreezeRestClient{
    Session: &session,
}
result, err := client.GetStage(
    &freeze.GetStageRequest {
        StageName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
source := result.Source
current := result.Current

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Freeze\Gs2FreezeRestClient;
use Gs2\Freeze\Request\GetStageRequest;

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

$session->open();

$client = new Gs2FreezeRestClient(
    $session
);

try {
    $result = $client->getStage(
        (new GetStageRequest())
            ->withStageName("namespace-0001")
    );
    $item = $result->getItem();
    $source = $result->getSource();
    $current = $result->getCurrent();
} 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.freeze.rest.Gs2FreezeRestClient;
import io.gs2.freeze.request.GetStageRequest;
import io.gs2.freeze.result.GetStageResult;

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

try {
    GetStageResult result = client.getStage(
        new GetStageRequest()
            .withStageName("namespace-0001")
    );
    Stage item = result.getItem();
    List<Microservice> source = result.getSource();
    List<Microservice> current = result.getCurrent();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FreezeRestClient(session);

AsyncResult<Gs2.Gs2Freeze.Result.GetStageResult> asyncResult = null;
yield return client.GetStage(
    new Gs2.Gs2Freeze.Request.GetStageRequest()
        .WithStageName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var source = result.Source;
var current = result.Current;

import Gs2Core from '@/gs2/core';
import * as Gs2Freeze from '@/gs2/freeze';

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

try {
    const result = await client.getStage(
        new Gs2Freeze.GetStageRequest()
            .withStageName("namespace-0001")
    );
    const item = result.getItem();
    const source = result.getSource();
    const current = result.getCurrent();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import freeze

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

try:
    result = client.get_stage(
        freeze.GetStageRequest()
            .with_stage_name('namespace-0001')
    )
    item = result.item
    source = result.source
    current = result.current
except core.Gs2Exception as e:
    exit(1)

client = gs2('freeze')

api_result = client.get_stage({
    stageName="namespace-0001",
})

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

result = api_result.result
item = result.item;
source = result.source;
current = result.current;

client = gs2('freeze')

api_result_handler = client.get_stage_async({
    stageName="namespace-0001",
})

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['errorMessage'])
end

result = api_result.result
item = result.item;
source = result.source;
current = result.current;

promoteStage

Promote stage

Applies the microservice versions from the source stage to this stage, initiating an asynchronous deployment process. The stage status changes to Updating during the process, and returns to Active on success or UpdateFailed on failure. Progress can be monitored via the Output API.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
stageName	string		✓		~ 128 chars	Stage name The identifier for this stage environment (e.g., “dev”, “stg”, “live”).

Result

	Type	Description
item	Stage	Stage updated

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/freeze"
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 := freeze.Gs2FreezeRestClient{
    Session: &session,
}
result, err := client.PromoteStage(
    &freeze.PromoteStageRequest {
        StageName: pointy.String("namespace-0001"),
    }
)
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\Freeze\Gs2FreezeRestClient;
use Gs2\Freeze\Request\PromoteStageRequest;

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

$session->open();

$client = new Gs2FreezeRestClient(
    $session
);

try {
    $result = $client->promoteStage(
        (new PromoteStageRequest())
            ->withStageName("namespace-0001")
    );
    $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.freeze.rest.Gs2FreezeRestClient;
import io.gs2.freeze.request.PromoteStageRequest;
import io.gs2.freeze.result.PromoteStageResult;

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

try {
    PromoteStageResult result = client.promoteStage(
        new PromoteStageRequest()
            .withStageName("namespace-0001")
    );
    Stage item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FreezeRestClient(session);

AsyncResult<Gs2.Gs2Freeze.Result.PromoteStageResult> asyncResult = null;
yield return client.PromoteStage(
    new Gs2.Gs2Freeze.Request.PromoteStageRequest()
        .WithStageName("namespace-0001"),
    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 Gs2Freeze from '@/gs2/freeze';

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

try {
    const result = await client.promoteStage(
        new Gs2Freeze.PromoteStageRequest()
            .withStageName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import freeze

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

try:
    result = client.promote_stage(
        freeze.PromoteStageRequest()
            .with_stage_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('freeze')

api_result = client.promote_stage({
    stageName="namespace-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('freeze')

api_result_handler = client.promote_stage_async({
    stageName="namespace-0001",
})

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['errorMessage'])
end

result = api_result.result
item = result.item;

rollbackStage

Rollback stage

Reverts the stage to the previously deployed microservice versions, initiating an asynchronous rollback process. The stage status changes to Updating during the process, and returns to Active on success or UpdateFailed on failure. Progress can be monitored via the Output API.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
stageName	string		✓		~ 128 chars	Stage name The identifier for this stage environment (e.g., “dev”, “stg”, “live”).

Result

	Type	Description
item	Stage	Stage updated

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/freeze"
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 := freeze.Gs2FreezeRestClient{
    Session: &session,
}
result, err := client.RollbackStage(
    &freeze.RollbackStageRequest {
        StageName: pointy.String("namespace-0001"),
    }
)
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\Freeze\Gs2FreezeRestClient;
use Gs2\Freeze\Request\RollbackStageRequest;

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

$session->open();

$client = new Gs2FreezeRestClient(
    $session
);

try {
    $result = $client->rollbackStage(
        (new RollbackStageRequest())
            ->withStageName("namespace-0001")
    );
    $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.freeze.rest.Gs2FreezeRestClient;
import io.gs2.freeze.request.RollbackStageRequest;
import io.gs2.freeze.result.RollbackStageResult;

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

try {
    RollbackStageResult result = client.rollbackStage(
        new RollbackStageRequest()
            .withStageName("namespace-0001")
    );
    Stage item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FreezeRestClient(session);

AsyncResult<Gs2.Gs2Freeze.Result.RollbackStageResult> asyncResult = null;
yield return client.RollbackStage(
    new Gs2.Gs2Freeze.Request.RollbackStageRequest()
        .WithStageName("namespace-0001"),
    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 Gs2Freeze from '@/gs2/freeze';

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

try {
    const result = await client.rollbackStage(
        new Gs2Freeze.RollbackStageRequest()
            .withStageName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import freeze

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

try:
    result = client.rollback_stage(
        freeze.RollbackStageRequest()
            .with_stage_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('freeze')

api_result = client.rollback_stage({
    stageName="namespace-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('freeze')

api_result_handler = client.rollback_stage_async({
    stageName="namespace-0001",
})

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['errorMessage'])
end

result = api_result.result
item = result.item;