From f2f6726ec09be4325e2d1d04fe6eb3774a7ff935 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sybren=20A=2E=20St=C3=BCvel?= Date: Tue, 31 May 2022 11:21:41 +0200 Subject: [PATCH] OAPI: regenerate code --- addon/flamenco/manager/__init__.py | 2 +- addon/flamenco/manager/api/worker_mgt_api.py | 127 ++++++++ addon/flamenco/manager/api_client.py | 2 +- addon/flamenco/manager/configuration.py | 2 +- addon/flamenco/manager/docs/Worker.md | 20 ++ addon/flamenco/manager/docs/WorkerMgtApi.md | 66 ++++ addon/flamenco/manager/model/worker.py | 307 ++++++++++++++++++ addon/flamenco/manager/models/__init__.py | 1 + addon/flamenco/manager_README.md | 4 +- internal/worker/mocks/client.gen.go | 20 ++ pkg/api/openapi_client.gen.go | 109 +++++++ pkg/api/openapi_server.gen.go | 20 ++ pkg/api/openapi_spec.gen.go | 256 +++++++-------- pkg/api/openapi_types.gen.go | 18 + web/app/src/manager-api/ApiClient.js | 2 +- web/app/src/manager-api/index.js | 7 + .../src/manager-api/manager/WorkerMgtApi.js | 47 +++ web/app/src/manager-api/model/Worker.js | 146 +++++++++ 18 files changed, 1024 insertions(+), 132 deletions(-) create mode 100644 addon/flamenco/manager/docs/Worker.md create mode 100644 addon/flamenco/manager/model/worker.py create mode 100644 web/app/src/manager-api/model/Worker.js diff --git a/addon/flamenco/manager/__init__.py b/addon/flamenco/manager/__init__.py index 80861e3f..594f4d2e 100644 --- a/addon/flamenco/manager/__init__.py +++ b/addon/flamenco/manager/__init__.py @@ -10,7 +10,7 @@ """ -__version__ = "4f8fd14d" +__version__ = "ccea8869" # import ApiClient from flamenco.manager.api_client import ApiClient diff --git a/addon/flamenco/manager/api/worker_mgt_api.py b/addon/flamenco/manager/api/worker_mgt_api.py index 2df6e7f1..0e637d16 100644 --- a/addon/flamenco/manager/api/worker_mgt_api.py +++ b/addon/flamenco/manager/api/worker_mgt_api.py @@ -21,6 +21,7 @@ from flamenco.manager.model_utils import ( # noqa: F401 none_type, validate_and_convert_types ) +from flamenco.manager.model.worker import Worker from flamenco.manager.model.worker_list import WorkerList @@ -35,6 +36,55 @@ class WorkerMgtApi(object): if api_client is None: api_client = ApiClient() self.api_client = api_client + self.fetch_worker_endpoint = _Endpoint( + settings={ + 'response_type': (Worker,), + 'auth': [], + 'endpoint_path': '/api/worker-mgt/workers/{worker_id}', + 'operation_id': 'fetch_worker', + 'http_method': 'GET', + 'servers': None, + }, + params_map={ + 'all': [ + 'worker_id', + ], + 'required': [ + 'worker_id', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] + }, + root_map={ + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'worker_id': + (str,), + }, + 'attribute_map': { + 'worker_id': 'worker_id', + }, + 'location_map': { + 'worker_id': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, + api_client=api_client + ) self.fetch_workers_endpoint = _Endpoint( settings={ 'response_type': (WorkerList,), @@ -78,6 +128,83 @@ class WorkerMgtApi(object): api_client=api_client ) + def fetch_worker( + self, + worker_id, + **kwargs + ): + """Fetch info about the worker. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.fetch_worker(worker_id, async_req=True) + >>> result = thread.get() + + Args: + worker_id (str): + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): timeout setting for this request. If + one number provided, it will be total request timeout. It can also + be a pair (tuple) of (connection, read) timeouts. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _content_type (str/None): force body content-type. + Default is None and content-type will be predicted by allowed + content-types and body. + _host_index (int/None): specifies the index of the server + that we want to use. + Default is read from the configuration. + async_req (bool): execute request asynchronously + + Returns: + Worker + If the method is called asynchronously, returns the request + thread. + """ + kwargs['async_req'] = kwargs.get( + 'async_req', False + ) + kwargs['_return_http_data_only'] = kwargs.get( + '_return_http_data_only', True + ) + kwargs['_preload_content'] = kwargs.get( + '_preload_content', True + ) + kwargs['_request_timeout'] = kwargs.get( + '_request_timeout', None + ) + kwargs['_check_input_type'] = kwargs.get( + '_check_input_type', True + ) + kwargs['_check_return_type'] = kwargs.get( + '_check_return_type', True + ) + kwargs['_spec_property_naming'] = kwargs.get( + '_spec_property_naming', False + ) + kwargs['_content_type'] = kwargs.get( + '_content_type') + kwargs['_host_index'] = kwargs.get('_host_index') + kwargs['worker_id'] = \ + worker_id + return self.fetch_worker_endpoint.call_with_http_info(**kwargs) + def fetch_workers( self, **kwargs diff --git a/addon/flamenco/manager/api_client.py b/addon/flamenco/manager/api_client.py index 9c4649ab..9d5e817c 100644 --- a/addon/flamenco/manager/api_client.py +++ b/addon/flamenco/manager/api_client.py @@ -76,7 +76,7 @@ class ApiClient(object): self.default_headers[header_name] = header_value self.cookie = cookie # Set default User-Agent. - self.user_agent = 'Flamenco/4f8fd14d (Blender add-on)' + self.user_agent = 'Flamenco/ccea8869 (Blender add-on)' def __enter__(self): return self diff --git a/addon/flamenco/manager/configuration.py b/addon/flamenco/manager/configuration.py index cef48c86..7b2aff2f 100644 --- a/addon/flamenco/manager/configuration.py +++ b/addon/flamenco/manager/configuration.py @@ -404,7 +404,7 @@ conf = flamenco.manager.Configuration( "OS: {env}\n"\ "Python Version: {pyversion}\n"\ "Version of the API: 1.0.0\n"\ - "SDK Package Version: 4f8fd14d".\ + "SDK Package Version: ccea8869".\ format(env=sys.platform, pyversion=sys.version) def get_host_settings(self): diff --git a/addon/flamenco/manager/docs/Worker.md b/addon/flamenco/manager/docs/Worker.md new file mode 100644 index 00000000..155731de --- /dev/null +++ b/addon/flamenco/manager/docs/Worker.md @@ -0,0 +1,20 @@ +# Worker + +All information about a Worker + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **str** | | +**nickname** | **str** | | +**status** | [**WorkerStatus**](WorkerStatus.md) | | +**ip_address** | **str** | IP address of the Worker | +**platform** | **str** | Operating system of the Worker | +**version** | **str** | Version of Flamenco this Worker is running | +**supported_task_types** | **[str]** | | +**status_requested** | [**WorkerStatus**](WorkerStatus.md) | | [optional] +**any string name** | **bool, date, datetime, dict, float, int, list, str, none_type** | any string name can be used but the value must be the correct type | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/addon/flamenco/manager/docs/WorkerMgtApi.md b/addon/flamenco/manager/docs/WorkerMgtApi.md index 854f0395..293225a8 100644 --- a/addon/flamenco/manager/docs/WorkerMgtApi.md +++ b/addon/flamenco/manager/docs/WorkerMgtApi.md @@ -4,9 +4,75 @@ All URIs are relative to *http://localhost* Method | HTTP request | Description ------------- | ------------- | ------------- +[**fetch_worker**](WorkerMgtApi.md#fetch_worker) | **GET** /api/worker-mgt/workers/{worker_id} | Fetch info about the worker. [**fetch_workers**](WorkerMgtApi.md#fetch_workers) | **GET** /api/worker-mgt/workers | Get list of workers. +# **fetch_worker** +> Worker fetch_worker(worker_id) + +Fetch info about the worker. + +### Example + + +```python +import time +import flamenco.manager +from flamenco.manager.api import worker_mgt_api +from flamenco.manager.model.worker import Worker +from pprint import pprint +# Defining the host is optional and defaults to http://localhost +# See configuration.py for a list of all supported configuration parameters. +configuration = flamenco.manager.Configuration( + host = "http://localhost" +) + + +# Enter a context with an instance of the API client +with flamenco.manager.ApiClient() as api_client: + # Create an instance of the API class + api_instance = worker_mgt_api.WorkerMgtApi(api_client) + worker_id = "worker_id_example" # str | + + # example passing only required values which don't have defaults set + try: + # Fetch info about the worker. + api_response = api_instance.fetch_worker(worker_id) + pprint(api_response) + except flamenco.manager.ApiException as e: + print("Exception when calling WorkerMgtApi->fetch_worker: %s\n" % e) +``` + + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **worker_id** | **str**| | + +### Return type + +[**Worker**](Worker.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Worker info | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + # **fetch_workers** > WorkerList fetch_workers() diff --git a/addon/flamenco/manager/model/worker.py b/addon/flamenco/manager/model/worker.py new file mode 100644 index 00000000..50cf1db1 --- /dev/null +++ b/addon/flamenco/manager/model/worker.py @@ -0,0 +1,307 @@ +""" + Flamenco manager + + Render Farm manager API # noqa: E501 + + The version of the OpenAPI document: 1.0.0 + Generated by: https://openapi-generator.tech +""" + + +import re # noqa: F401 +import sys # noqa: F401 + +from flamenco.manager.model_utils import ( # noqa: F401 + ApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, + OpenApiModel +) +from flamenco.manager.exceptions import ApiAttributeError + + +def lazy_import(): + from flamenco.manager.model.worker_status import WorkerStatus + globals()['WorkerStatus'] = WorkerStatus + + +class Worker(ModelNormal): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + allowed_values = { + } + + validations = { + } + + @cached_property + def additional_properties_type(): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, date, datetime, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_property + def openapi_types(): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'id': (str,), # noqa: E501 + 'nickname': (str,), # noqa: E501 + 'status': (WorkerStatus,), # noqa: E501 + 'ip_address': (str,), # noqa: E501 + 'platform': (str,), # noqa: E501 + 'version': (str,), # noqa: E501 + 'supported_task_types': ([str],), # noqa: E501 + 'status_requested': (WorkerStatus,), # noqa: E501 + } + + @cached_property + def discriminator(): + return None + + + attribute_map = { + 'id': 'id', # noqa: E501 + 'nickname': 'nickname', # noqa: E501 + 'status': 'status', # noqa: E501 + 'ip_address': 'ip_address', # noqa: E501 + 'platform': 'platform', # noqa: E501 + 'version': 'version', # noqa: E501 + 'supported_task_types': 'supported_task_types', # noqa: E501 + 'status_requested': 'status_requested', # noqa: E501 + } + + read_only_vars = { + } + + _composed_schemas = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls, id, nickname, status, ip_address, platform, version, supported_task_types, *args, **kwargs): # noqa: E501 + """Worker - a model defined in OpenAPI + + Args: + id (str): + nickname (str): + status (WorkerStatus): + ip_address (str): IP address of the Worker + platform (str): Operating system of the Worker + version (str): Version of Flamenco this Worker is running + supported_task_types ([str]): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + status_requested (WorkerStatus): [optional] # noqa: E501 + """ + + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise ApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + self.nickname = nickname + self.status = status + self.ip_address = ip_address + self.platform = platform + self.version = version + self.supported_task_types = supported_task_types + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, id, nickname, status, ip_address, platform, version, supported_task_types, *args, **kwargs): # noqa: E501 + """Worker - a model defined in OpenAPI + + Args: + id (str): + nickname (str): + status (WorkerStatus): + ip_address (str): IP address of the Worker + platform (str): Operating system of the Worker + version (str): Version of Flamenco this Worker is running + supported_task_types ([str]): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + status_requested (WorkerStatus): [optional] # noqa: E501 + """ + + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise ApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + self.nickname = nickname + self.status = status + self.ip_address = ip_address + self.platform = platform + self.version = version + self.supported_task_types = supported_task_types + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise ApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/addon/flamenco/manager/models/__init__.py b/addon/flamenco/manager/models/__init__.py index 707b299c..6db3db68 100644 --- a/addon/flamenco/manager/models/__init__.py +++ b/addon/flamenco/manager/models/__init__.py @@ -53,6 +53,7 @@ from flamenco.manager.model.task_status_change import TaskStatusChange from flamenco.manager.model.task_summary import TaskSummary from flamenco.manager.model.task_update import TaskUpdate from flamenco.manager.model.task_worker import TaskWorker +from flamenco.manager.model.worker import Worker from flamenco.manager.model.worker_list import WorkerList from flamenco.manager.model.worker_registration import WorkerRegistration from flamenco.manager.model.worker_sign_on import WorkerSignOn diff --git a/addon/flamenco/manager_README.md b/addon/flamenco/manager_README.md index 21887c93..f1b4059c 100644 --- a/addon/flamenco/manager_README.md +++ b/addon/flamenco/manager_README.md @@ -4,7 +4,7 @@ Render Farm manager API The `flamenco.manager` package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: - API version: 1.0.0 -- Package version: 4f8fd14d +- Package version: ccea8869 - Build package: org.openapitools.codegen.languages.PythonClientCodegen For more information, please visit [https://flamenco.io/](https://flamenco.io/) @@ -95,6 +95,7 @@ Class | Method | HTTP request | Description *WorkerApi* | [**task_update**](flamenco/manager/docs/WorkerApi.md#task_update) | **POST** /api/worker/task/{task_id} | Update the task, typically to indicate progress, completion, or failure. *WorkerApi* | [**worker_state**](flamenco/manager/docs/WorkerApi.md#worker_state) | **GET** /api/worker/state | *WorkerApi* | [**worker_state_changed**](flamenco/manager/docs/WorkerApi.md#worker_state_changed) | **POST** /api/worker/state-changed | Worker changed state. This could be as acknowledgement of a Manager-requested state change, or in response to worker-local signals. +*WorkerMgtApi* | [**fetch_worker**](flamenco/manager/docs/WorkerMgtApi.md#fetch_worker) | **GET** /api/worker-mgt/workers/{worker_id} | Fetch info about the worker. *WorkerMgtApi* | [**fetch_workers**](flamenco/manager/docs/WorkerMgtApi.md#fetch_workers) | **GET** /api/worker-mgt/workers | Get list of workers. @@ -144,6 +145,7 @@ Class | Method | HTTP request | Description - [TaskSummary](flamenco/manager/docs/TaskSummary.md) - [TaskUpdate](flamenco/manager/docs/TaskUpdate.md) - [TaskWorker](flamenco/manager/docs/TaskWorker.md) + - [Worker](flamenco/manager/docs/Worker.md) - [WorkerList](flamenco/manager/docs/WorkerList.md) - [WorkerRegistration](flamenco/manager/docs/WorkerRegistration.md) - [WorkerSignOn](flamenco/manager/docs/WorkerSignOn.md) diff --git a/internal/worker/mocks/client.gen.go b/internal/worker/mocks/client.gen.go index a509beed..da25b3ff 100644 --- a/internal/worker/mocks/client.gen.go +++ b/internal/worker/mocks/client.gen.go @@ -116,6 +116,26 @@ func (mr *MockFlamencoClientMockRecorder) FetchTaskWithResponse(arg0, arg1 inter return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaskWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchTaskWithResponse), varargs...) } +// FetchWorkerWithResponse mocks base method. +func (m *MockFlamencoClient) FetchWorkerWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchWorkerResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FetchWorkerWithResponse", varargs...) + ret0, _ := ret[0].(*api.FetchWorkerResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchWorkerWithResponse indicates an expected call of FetchWorkerWithResponse. +func (mr *MockFlamencoClientMockRecorder) FetchWorkerWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchWorkerWithResponse), varargs...) +} + // FetchWorkersWithResponse mocks base method. func (m *MockFlamencoClient) FetchWorkersWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.FetchWorkersResponse, error) { m.ctrl.T.Helper() diff --git a/pkg/api/openapi_client.gen.go b/pkg/api/openapi_client.gen.go index 5b473e4f..b8438c95 100644 --- a/pkg/api/openapi_client.gen.go +++ b/pkg/api/openapi_client.gen.go @@ -137,6 +137,9 @@ type ClientInterface interface { // FetchWorkers request FetchWorkers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + // FetchWorker request + FetchWorker(ctx context.Context, workerId string, reqEditors ...RequestEditorFn) (*http.Response, error) + // RegisterWorker request with any body RegisterWorkerWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -390,6 +393,18 @@ func (c *Client) FetchWorkers(ctx context.Context, reqEditors ...RequestEditorFn return c.Client.Do(req) } +func (c *Client) FetchWorker(ctx context.Context, workerId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewFetchWorkerRequest(c.Server, workerId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + func (c *Client) RegisterWorkerWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { req, err := NewRegisterWorkerRequestWithBody(c.Server, contentType, body) if err != nil { @@ -1058,6 +1073,40 @@ func NewFetchWorkersRequest(server string) (*http.Request, error) { return req, nil } +// NewFetchWorkerRequest generates requests for FetchWorker +func NewFetchWorkerRequest(server string, workerId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "worker_id", runtime.ParamLocationPath, workerId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/worker-mgt/workers/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + // NewRegisterWorkerRequest calls the generic RegisterWorker builder with application/json body func NewRegisterWorkerRequest(server string, body RegisterWorkerJSONRequestBody) (*http.Request, error) { var bodyReader io.Reader @@ -1616,6 +1665,9 @@ type ClientWithResponsesInterface interface { // FetchWorkers request FetchWorkersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*FetchWorkersResponse, error) + // FetchWorker request + FetchWorkerWithResponse(ctx context.Context, workerId string, reqEditors ...RequestEditorFn) (*FetchWorkerResponse, error) + // RegisterWorker request with any body RegisterWorkerWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterWorkerResponse, error) @@ -1955,6 +2007,28 @@ func (r FetchWorkersResponse) StatusCode() int { return 0 } +type FetchWorkerResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *Worker +} + +// Status returns HTTPResponse.Status +func (r FetchWorkerResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r FetchWorkerResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + type RegisterWorkerResponse struct { Body []byte HTTPResponse *http.Response @@ -2379,6 +2453,15 @@ func (c *ClientWithResponses) FetchWorkersWithResponse(ctx context.Context, reqE return ParseFetchWorkersResponse(rsp) } +// FetchWorkerWithResponse request returning *FetchWorkerResponse +func (c *ClientWithResponses) FetchWorkerWithResponse(ctx context.Context, workerId string, reqEditors ...RequestEditorFn) (*FetchWorkerResponse, error) { + rsp, err := c.FetchWorker(ctx, workerId, reqEditors...) + if err != nil { + return nil, err + } + return ParseFetchWorkerResponse(rsp) +} + // RegisterWorkerWithBodyWithResponse request with arbitrary body returning *RegisterWorkerResponse func (c *ClientWithResponses) RegisterWorkerWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterWorkerResponse, error) { rsp, err := c.RegisterWorkerWithBody(ctx, contentType, body, reqEditors...) @@ -2901,6 +2984,32 @@ func ParseFetchWorkersResponse(rsp *http.Response) (*FetchWorkersResponse, error return response, nil } +// ParseFetchWorkerResponse parses an HTTP response from a FetchWorkerWithResponse call +func ParseFetchWorkerResponse(rsp *http.Response) (*FetchWorkerResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &FetchWorkerResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Worker + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + } + + return response, nil +} + // ParseRegisterWorkerResponse parses an HTTP response from a RegisterWorkerWithResponse call func ParseRegisterWorkerResponse(rsp *http.Response) (*RegisterWorkerResponse, error) { bodyBytes, err := ioutil.ReadAll(rsp.Body) diff --git a/pkg/api/openapi_server.gen.go b/pkg/api/openapi_server.gen.go index 614c3a42..c53ec28d 100644 --- a/pkg/api/openapi_server.gen.go +++ b/pkg/api/openapi_server.gen.go @@ -52,6 +52,9 @@ type ServerInterface interface { // Get list of workers. // (GET /api/worker-mgt/workers) FetchWorkers(ctx echo.Context) error + // Fetch info about the worker. + // (GET /api/worker-mgt/workers/{worker_id}) + FetchWorker(ctx echo.Context, workerId string) error // Register a new worker // (POST /api/worker/register-worker) RegisterWorker(ctx echo.Context) error @@ -262,6 +265,22 @@ func (w *ServerInterfaceWrapper) FetchWorkers(ctx echo.Context) error { return err } +// FetchWorker converts echo context to params. +func (w *ServerInterfaceWrapper) FetchWorker(ctx echo.Context) error { + var err error + // ------------- Path parameter "worker_id" ------------- + var workerId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "worker_id", runtime.ParamLocationPath, ctx.Param("worker_id"), &workerId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter worker_id: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.FetchWorker(ctx, workerId) + return err +} + // RegisterWorker converts echo context to params. func (w *ServerInterfaceWrapper) RegisterWorker(ctx echo.Context) error { var err error @@ -504,6 +523,7 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL router.POST(baseURL+"/api/tasks/:task_id/setstatus", wrapper.SetTaskStatus) router.GET(baseURL+"/api/version", wrapper.GetVersion) router.GET(baseURL+"/api/worker-mgt/workers", wrapper.FetchWorkers) + router.GET(baseURL+"/api/worker-mgt/workers/:worker_id", wrapper.FetchWorker) router.POST(baseURL+"/api/worker/register-worker", wrapper.RegisterWorker) router.POST(baseURL+"/api/worker/sign-off", wrapper.SignOff) router.POST(baseURL+"/api/worker/sign-on", wrapper.SignOn) diff --git a/pkg/api/openapi_spec.gen.go b/pkg/api/openapi_spec.gen.go index 471bc07c..c463bda9 100644 --- a/pkg/api/openapi_spec.gen.go +++ b/pkg/api/openapi_spec.gen.go @@ -18,133 +18,135 @@ import ( // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+R93W4budLgqxD9LZAZrCw5tvPn72ZzkskZ5ySTbOycWWAS2FR3SWLcIjUk24omMPA9", - "xL7J7gH2Ys/VvkDOGy1YRXaz1WxLTuJMZr5cBLa7SRbrv4rF6g9ZruYLJUFakx1+yEw+gznHHx8aI6YS", - "ihNuzt3vBZhci4UVSmaHradMGMaZdT9xw4R1v2vIQVxAwcYrZmfAflb6HPQwG2QLrRagrQBcJVfzOZcF", - "/iwszPGH/6Jhkh1m/zZqgBt5yEaPaEB2OcjsagHZYca15iv3+zs1dqP9n43VQk79308XWigt7Cp6QUgL", - "U9DhDfprYrjk8/SDq+c0lttq43Yc/o7pTbcjbs77AakqUbgHE6Xn3GaH9IfB+ouXg0zDr5XQUGSHv4SX", - "HHL8XmrYoi2sYSlCSQzVoKHX23pdNX4HuXUAPrzgouTjEp6q8TFY68DpcM6xkNMSmKHnTE0YZ0/VmLnZ", - "TIJBZkrk9GN7np9nINlUXIAcsFLMhUU+u+ClKNz/FRhmlfubAeYnGbIXslyxyjgY2VLYGSOk4eJu7ZoF", - "O8hfZ7YCJrwqbReukxkw/5DgYGamltIDwyoDmi0d7AVY0HMhcf2ZMAElQ5o+mjO9RP2XkVWqtGLhFxKy", - "Wcjxo57wHHBSKIR1W6cZPfwTXhoYdJFrZ6Ad0Lws1ZK5oeuAMj6x7p0ZsHdqzGbcsDGAZKYaz4W1UAzZ", - "z6oqCybmi3LFCiiBhpUlg/fC0ITcnBs2UZqmfqfGA8Zl4RSImi9E6d4RdvhGNow+VqoELnFHF7zs4ufl", - "ys6UZPB+ocEYoRD5Y2Du7YpbKByOlC5og4EOgDtpk66Gq6bNoMsa57DqwnBUgLRiIkD7SWqWH7B5ZayD", - "p5Li14oY0RPtnReE5DpOMLieJmThoVwxeG81Z1xPq7nTMIHfxovV0A00w2M1h5ckW6vvvme5I0NloHBv", - "5hq4Bdqql79VBEMj4o1muQYLifkcCsEtlCumwU3FOG61gImQwg0YOEWAy7slB4gTVVkPEddW5FXJdU2H", - "Hn4w1Tioz6u0bkJRHfuRtahfe4YTP/xCGOGF7Joz/N2NFKVTwOta3PGYh2xLzXvcoGJNAVfjHfeEME48", - "F9DKHlVag7TliimnKnmYF5k4UpZmyM5+fHj84w+PT58cPfvh9OXDkx/PyBEohIbcKr1iC25n7L+yszfZ", - "6N/w35vsjPHFAmQBBZEQZDV3+5uIEk7d+9kgK4QOP+KfvdGacTOD4rR5821CRvro0tWhHgPR7iPBJAvB", - "DTt6HEQGt+0Ux19KB78esp8Uk2CcOjFWV7mtNBj2HVoIM2CFyN1SXAsw3zOugZlqsVDarm/dAz9wzsP+", - "ntt0qbjNBsjX224yYp1YMmtmHKSsp1VoMtoajp35MWeHjJdLvjL40pCdoV5HfXp2SOyBo73qen1EthwR", - "6i2AZt+V4hwYD0hjvCh2lPx+yM6WME5Ns4RxY7WQ6+Zc8ik4pTZg48oyqSwZUL8KmSXk4yE7m4miAAeg", - "hAvQOPW/r/OyV40OUjIy7kVEDjqwbnXJy7auCdRqEEorZah0PF6yQbaE8UaapTkyOEENn5DzLAx7jijQ", - "ZBmFRY3I585uJTymko+hvJ4n63e6vRee8vQ6TtKaCvNiTOBFa27SZw5bCZv3TBgbBBg1Uj/eujgK3u2n", - "7fikZSh6ttsskdpgCGM62/IPmAbnvKAl58yQz+ydb8e/8B7yysKm8Ko/dqkZKHocwEsTLhqS2tEPWivd", - "3c9fQYIWOQP3mGkwCyUNpALBIiETP56cvGQUrTD3Ru0l1BOxIyexeVkV5NY5bCz4qlS8YMbJObcNAgna", - "Fm6dL4qgCUlxlVBy+EY+covd2d13Jg2dJNQ46CByy8fcgHsyrsxqyJw7joAGoNhSlCXLlbRcSMbZrVdg", - "9WrnoXOXb9GrM+DofjrwhCxEzi0Y71AvZyKfMSvm5JE6UoCxLOfS2SYNVgvnWz9RzjMP2s9PKAzqR8cm", - "3NngoDJuGVYtguLLSwHSou+rmFFzcP7nlGngRknUkKi14T0JgeAlG/P8XE0mpAvrADRYrG70Owdj+DTF", - "e2vMhXRv3k9x1pOSz0Hm6u+gjY+HtuTyi2bE1VCEF72OTEHxlLILvCxfTLLDX67WFschBHKjLgfrAPPc", - "iovaVscM/7j5LfhnJTeWhRHMBTM+UEoGCeTJpxSLe4CxkJiDsXy+iClZcAs77klqTpGY7vXro8cBwqeY", - "W9iQltg2I+IsSp0QqRZFejcnYRMOBsQQvTrcclNr9EeAA+qaZaNMSU2yt5dviRueg+VOGSBBiwLDGF6+", - "bBG6g4O1uE2PhdVcr9jcT+Z9bDNkz5VGjb8o4X3sYHo1MFcunkZTVzntxs74cDzMz5z4E51D2HkOGMrB", - "e+7m8tKDXH2YHS+0sMCeaDGdOZezMqCHMOeidFCvxhrkfxt7f1fpaXiDBC47xhfYsf1///cCysgitqTm", - "OHIu0niyuoKesTXLBP8L6YCZKC5zhwFKSi1KsP5nScgSSu5MuKA36h8W3GnzbJD9WkGFP3Cdz8RF9CM5", - "4zT9jle++Bh/roCeVw4nO/FqSbev3sOjGZdT6OouUrrpHA89i5IQ3hDiVMMvImJrclCzuwerRxGecHNu", - "jqv5nOtVKsM3X5RiIqBgpXfSKMsT4oMhe0S2kewvPmx8e/cnZ4zd68CdJeTmvOsw4Kit3TfMs3qAt/Dc", - "TN/OzX+vgPYcyROmH7PDO86MNTqhT8ouBxnmnk7HK8zPruuat+GnUyFbHF+zrOfmt5cd158A+ZDNhRRz", - "JzC308b5szXXE1E6V2XcaK5B0EPPjv72Q6OGklkkNZkYaAO6mwK0wdOHa6RmzZYKp29HUUrAXGdXEdXW", - "ReIV2EpLikMde1HymQeJFt6o4xZaeeitLWWHo/u59xUYn7nuBEXbCxQ5Np8oSD4ue6TkREwrzW3SrTMz", - "PufyB/RIi+QBACUYZ8CO8VU2ES6611yaCWj28OURZqRC5DZMpwyt0nwKz1TO09n2x3U+CwMBp40dh+Ba", - "fvBwo4OxvspgbXdpLK3+BrB4VUmZPEk5quOGZYSKJYaCbM5X7BxgwTQNx2dpTTrvrNPFUmOmemwO2bdX", - "tbm8AtoQk8XWjNWGtvZbaCNDdmSZmeE5QmUoIjqjR4754Yy5rXjPNk7mUxTlFsGEz1S5/yW8t0N25INI", - "YdiZUwVnA3bWRsIZe/76+MT5WWeY3D5LJ5zXiLyGyBprfThKEf0VTIWxoKGgmL4rFrwoNJi0KpQiP++P", - "+UtunW+cpqKa2CXXcAWJN6mEn2uqkEqq8zGn9QmiuZ4m/6wTzxoXgxpl8clnQMYgyynnjVBmESZ6dpCi", - "2jHklRZ2VSdB1iRs22j4qjCYdNyjGeTnqkocPB4DulpOL3n7YmcgNDv+8eHenbssdwNNNR8wI37DRPZ4", - "ZcFQgqAA40BgpddPIZOS+9WapP5aKIGrYTiMKfnDrDnSGU4VqbnsMNu/M949eHA737s33t3f3y9uT8YH", - "dyb57r37D/jtvZzv3h3fLu4e7BZ7d+4+uHd/d3x/914Bd3YPinu7ew9g100kfoPs8PbB3gHG07RaqaZT", - "IafxUnf3x/f28rv74wcHeweT4vb++MH+vd3J+O7u7t0Hu/d3831++8692/fyyT4vDg727u7fGd++fy+/", - "y+8/uLN770Gz1N69y66LFTDyEgHonDxyO3PaWJOi8nYu6K/4lC3Mg/oNE1old35eyNF4i1YTAM9SuGG5", - "t5lQUCqgXmTIjiRTZQGa+WyGCfG5nwvXXXLD3lWGTsvf1NthR4/fZOSDB2fEz8JEnXriBAUmh868e7tj", - "ymo6MjlI2HHSNqJDzZ2jx22d2Qi5Z5kt/QyC/Yko4XgB+UaXgyYftMm0WZoalygVhblnFLysUSVVrvAJ", - "7OETD+uMcYK/EuoLMZmAxqzdjEu2dCbUkbI2mwPHHPGkmIMEaSrtCOePmhsxxqwlkvOLMF+K1OuZvu1I", - "UpO6q+AWkIuJ8BoK6YFOmNdVHujIJWuTZpEkSfDIgqzEMwaIk5H2jCcgbKvaeM7kHKhnPnQDEWjr6ESG", - "dd29nPGgtwbZYjsE/yzsrMmvbIXqgfeqclRn4x7UD5jSLlIasAIWIAss85F4bkXm909Om239pYgcPdmY", - "DlXjJMFV5O2kzSp5LtVSYm6zVLwg/9QRrOWHNvunyV4RNFhR4v3WT3Y80NFo4a7Xl7ghp+GrOAhfwbz1", - "E79NLzqNSls1otZEqznjTEfDgkkZxKT0sZpqizvoC+d3PMGpKKrTwJDRnCXxr7m/wXt/QocL0qlWcxL4", - "tXigEcxaHm6GLeKFanH7wrwSqe/P5RoqyWwrjjUR9/S/rs39UorwCqWn8nOwRy+eqvFrzKQmC54M2LrS", - "dMCM86PUBWgWRtPxLhWvUELCDNkTZ8ZgiQm7gXN44UKoypwSNGfkYY0b5iYnqI2AL3R0FmL69kQ/8Xlc", - "xZWuGWwBfa2UYlzfXFcU3UkmajVMNJjZaZ2UvzL3E51B+8jIj6fjANrNLUMHA94PxgolaX1FkDH+vM8M", - "vD+NvzpPA48MhCzEhSgqTqcLbImrTEGCpnyQYnMuV2ESXx+60Dy3Iudlb3nh9ZHYX8193aPNzzjZTJxn", - "+nruqOK7TcOrZM0JVH918jFIPJasZYtIbVwAcTYy0dgzBhcY0mDJp1W+1CvYnOhN99DJpqfXkD0Kc1KF", - "2hRs/JwCWUwkOuoHKoffSzXFWGnFJIAvp1mUIhe2XIVlx0AKwOBhVi7salBvxMVkVLgW3nVzKEklZd9Z", - "hfC0lqakJkcov0dPyL3uXrllHDwMU6KOoiktohYbVWiCNC9CYnTbotbUJKHWKaTi+lUZFZFY1cbKiFWy", - "+YMz/8PNCm+Nh9WiYVgcsC1zNhiIXOEaGjzFbX5LesF9GEmcRnDLzoUj7ORaqAhgeQXOzXmpplcCc8LN", - "+TM17TN3J57FWT6r5Lm3dlYx3kikVmrOCiClXNBDXyLlAEBZ5BdKFG5wQXtpa8wUlzq4u2UnDoiaRTxo", - "Q/acr+oCqXlVWrHAqiMJlLSC9zZ5vo1p2E2MeEJ53OvxWJh5kLXR32UwN/02rsYJYrLf10BkdJwNfxj+", - "ad5GXFd07Sqe7dBGN4O2Sstv47b4nPvn+i3ta1SfMuZrmmOPwfo61pXlRilOjKvLknXETRa+uY3jhDqU", - "0q1FXduULXx+cZB/sP/xf7J//cfHf3z858f//fEf//qPj//n4z8//q/YF0EnMz7F96uc5vMiO8w++F8v", - "Mc9byfNTCrz23Z6s8+FOeVUIFc75XcDizwtGGkeOzGTkvHrKW9/e2x/ilDFJX/70V/frwmSHLnCcaD53", - "Mpbd3rntgkox51Mwp0qfXogClPOG8S/ZIFOVXVSW7inAewuSShCz4cKfCeJW/FtduGilGrJRGl3+QkVn", - "Pq2UvXK+KFhE1wZ2PDZ3aEjWCVJj5tjg9tYlcdtem9wQVsQ8sMnjDq/2+9zpsuZ1RzglcOk7sCfBotGt", - "V7zSZkJkHNLwoVx4wMQQhmwME6WBXXAtsNBWw6LkOWZehtdT51/y5uzNFY3ehDX5/S/i3lRV6iBb1of+", - "m4D15QFbV7KuG53UHeD4pm/NfBsu/UaIu0aZZl2QWRe1GTWxO+t1mik3uFnwW6qpjPnnE4oq4/rErkWv", - "jGUgVTWdxdcUGB/TFUmvhsJ1ruYuqc+hYBnmsCc39YcUu0/1vLbk/bBSH6WuCr3oWZ2vGq8Y99dzHIFo", - "ZroOTJz3ptrd3btLOQmMG5BieGODLvngpbyHZcka6mFOXS2osPHfmfIO3toLYiqVhoJ9h5ZHhbtyZ0Gy", - "fUwhlWWgua+tqi8ahGvAsaf+/aago42OFxJ2XExHl4B9DhDPrm8Zltc3TWd4JdSBFk4cqFCNvbgAvXQ+", - "qGEhHihXhNYazFAvn+LcZED6TE19oFnrAIp5Q4AVLqg6oJEquCBwXQq6YpWMSo8/RUskmetT6r4+T5Sv", - "kJSwaEoSCNBnInUmGG7nkT1LnPj6B1t7L764bMsS7jB7P9hUZ9dXevoZdXSQaypt7j76zHq4dbNCK7VK", - "2ZJLRKVw/fg4FlP54rqYCKVyp/0Xrb74tqOyvp7ddqC6YteWW+hzI3w9t45rWrevf0w6AdFkWwFV9EH1", - "BWDZAEHbnzOWa0tFA3zJz1E1mBLAxQN4fxLr7ypbUJGBBePfVpOJ07ZJT64t0x0d8hduRJ5weHjvdddt", - "1eCVPP1pta5fklfWy1d76UX6BitPj93EsWo95VWqpua1Ae2mdQ5KVC5+9HjAFtyYpdJFeEQKhnrsMG7D", - "qzrSnI4EuCU8KHP0avA9s3aRXToYHQnpjq+0PLfNlc36aic7Ae70V6VLP9IcjkaTkK0SatS9gvKKOgo8", - "4XruD46w5D8bZKXIwRc++HX++vLZxX5n/uVyOZzKaqj0dOTHmNF0Ue7sD3eHIIczO6dbbcKWLWj9cll0", - "wzS7Pdwd7uKllQVIvhDZYbaPf6LSHaTMiC/EKF+/9TAle1HXsR8VeG/atq9HOBahkgmcam93N6AUJI7n", - "i0XpK7ZG73z8Q+y2iRmT1zGQcm2MSydYZV26QfwXpNdBTCe78TT1he3oKr7lU0PFzpbjJaZmjh9ksVDC", - "H/NOfZuhzoQ1HepJLweE23CFZaFMAqeUN6Ujdy+pf1HF6ovhsX3rt4s/7PCgfEY2i2Xe6goub5DCVwC0", - "5IaZKs/BTKqyXIWOGAUT0nvt0UG6Ga71vvoi0FHVfAI+fMBCUXyb3QjZjIcSDWSZdc6IWiXEnEcXk1rT", - "PQ1tS6hhFHhGbLPW6Ndw+y/NYHi96qmb/GYYrLmAmEBWp2aTajXxuhkdSQ+/Ns+17pslQP6JFApitVYr", - "g1DzDPOFXdEVUjFxYSqeqs65zWdYLA008NthySdg81l959UhfgPTvRjjAWhzI3CClxCxSZosmFG6bgjX", - "8KAzr6MP7v+f+Bwur7IgoVdJu9/HLx8y4bbiK0q9iQwTdnhkEKFsPXB8e4P80+240qNR6dm6KfLn2aE9", - "TE/rnCuIcyQnqvY4jReuqENbhyhmC1KY7CtizKRQVr/UdM5JYK/sdNfBxjNYmLM1Bpular38run02MLf", - "B0pP93MzyhaZ7s28XOe6+zl5U3XA29/HGqOrnNIqouHG0Oxqs0GjQbKIemil0T4yYJvAp8d7QiY+rlOn", - "X40KN2JHWycICWKcNBlaf0PVqlAavY0dPegtovXTOb+L5zksLBQoDAd7e31HFuFqbBsg3+uHWp6GW7M+", - "rVpXbE8advmaZvK1hPcLyB3QmB4YUr6zn1397YLOveCwL4pCwz4SHFyXnl6pPrBzxZ9Eh7S6cCRogFYQ", - "HwswcRrf1FHZN8IX68qOe7jx8KFuERK2ELHC1ebHBTWmZ8fIQfho9MHXfm0wPr4+agtPqi4l+zZZBzfS", - "o/Lo8ElO1DfKFk2R4gbiJ0b0kX1UqqnFqqZN5H+mpifuxW+HCyy8t6NFycUaFdZn6id2qSjASJos6lsS", - "t7/DMTPuTA8Wma7AfousUjdOm8AyqiudxTXXW3FQPKSeLxwh9mqSLf2p6Djwq7LUl/eoOkUZf3qXinTQ", - "n8CnorN2vGQz5ys24xfAYDKB3Ib7ftgQiWbghi2hLP37IUvm8DYH7vO2s2rOpaGYo2nxfiF4t8Hv0B/l", - "GOZkxPHDGYoTHTWgVDVCdcaENBY4lj4HwYtOHvtC77/XzR1vzKSut6j85OR5HSiH7gtr+fOr0+ePogsq", - "1CxHYO4Pr+DWPW94bitelivGm+X8Xc4arUSAnfnUjqKT+n7r6Ml4kziOyg0S6P0b3joNsPYnNKKChIDI", - "Zq/p9FwYGli1vuAaN0BYw9xI+z4+O01FX9oMhIY/vuzjZtRzouYhgcOmTClA/1UTxp3WR9tI0VfUv9Wa", - "/l3jsgC+P5JYBnq22ayjohuSOB5rRpp1jjJiKnfUZHKFRyGm8sVkkm1jOb89RPqDbHR+WkfYv7x1XkuD", - "s+dcn8dn19zZZKoy2IDtR7z0PVODLFvFSq96w5GRE2+8HXhLA5sq+kgNTj9Mk0RuoIi8UaH2S/SLc12/", - "/zVluVte84cQ5q158GFlZyAtVTT6Ek7HDfVnDOoKlS/MkBp4sXJvufmoeVerrFQ0BO+yq/VVq0k7HpEs", - "+705g9r2rbcG7A1TpWL9I75tlro+e5AzF7V81Bi3cLnqQUKaD3byqMIsqbwS1Wg3qsjihVKHxbVppH1+", - "WsT4B9Y5Xp97uhESQpew0JAJI2CnMEoo6MCHisq9LtlpB76BV7Bjk5DNBwy8fgG9U6qcl6jaeGm+tD67", - "gNZuKtNhVetvXvWY13wGRVWCT83e3MFq/C3EVGbDX7+oS036FNVPykfD7Q8rYWQWihovB9nB7v6XK0pq", - "taZMAP8SdKh6eQxSkNI82H2QuONODOiTJN7S0U0fYqcBMyo8xu/GQetjJbR1vE7KpFr6FM3+1zUtQYq4", - "dFAqCvGim9fjytJ3oKhjLJcK9SxJ2zUl1geQvJ4/wsYmUUKeMp7BdaIgKZkj6ZeV6N7KnyDX6HfSJ4ve", - "H4pqhz/NWpzMIMzVTS6mRKQ5QzGMe60RsxERbUCfpmnNjTITz/9HMUuvmytNvnnEaiFyTDDF134WWk01", - "GDPwH7XwX/3TbMJFWWnYaFuCRTEgi1Y5hEN3mN1pMecRbRCT0ZyvdsSOrvoTh8/5ymdNKvmnOPZbayf+", - "54rHTqKWctEHlRKN0YWJTZOuJBv1NEpnL/wNu7LuVWIYZ3RjNXZFm/uj1DdqGy7uePEY3UWQrcHkr6kR", - "X1Pv+FHogTmi+75X+Ent1tE3VP3cXiRVoRo3iqwjGd9H9+vlJpKtfxPghjdQPYcevVGpdGwFblY4akh4", - "SfE/9RrwDtTBzQNwglHm0v1H1EOPUU6H7LUBdmbWMNp0kzxzdKaewQxRiTXJKpydfiu520fUmTv6eCml", - "VsxqXgp5Xn+HDZukEwaoPN5SI2WPFOc28rKkMzT8FjK1fySJ9s0SfQsIZyFr0W68u0Z9EFLX1MexB4gz", - "EwsTAtNq2M418LSyiJt9bqsyYpLeqPpINZzdVpP8Dkok2W81BW/dFwq/T6gwAo8JMQhGK1gg36CUtvht", - "yQr2822aocc48F2i/QcslbbGSzxRiut6Yxs5/aEzhW6Z5muFwWa2J2xCaX9cTWeZBEWjb+gTvFaUZQNC", - "JB443+hDaFZ8OfqAfxG/XVFhH/ctVRoeeSZccxW3bkONH/7p+pXh1WsV5g+6H+X6Ddb7aNdNmBOrht1v", - "s2rTlfztjUtcp1dt/7WSpsXwtyY9cf+Hpqdusrtyy6OMBOUqrV1z5H9uZhykgnOvTUS7I63/xkUBE9Cs", - "btlMthmxgVb+Tba3e/9NtvadV0wjyXLlP866Vi9H2zO150aX7FolBC2CUwKKl0b5j1yrOSgJDEr65GzT", - "NiMFJnILIpC+B9ug8H/s0DI7j7jceez2ufMaJ8gSOIw+cJTCodJiKiQvcU03P35SifpylCru41H3Ehe2", - "7q+x/rVe2je22qi/L8Al4wLfKGBc0TdettjbCw/YzhMPWLbx8tI2jozKLdgdYzXweVtD1PH8WEgn34PN", - "hZePaA2z9gGCT0xOIXt1UlN7u/c3ve7ZscWIURHQwe17yRm0H+4CALyJx8Zgl+CZPXyquFE64dqQLzry", - "X01D8dcdvVM7y4GXMby5k2hL1moevUFqgwQ2khM+E60VFoirCRuDG1ivP1615I5cibNeETpk+BUxukpL", - "2iVGh9/Jt2KB0DL4nHS/3WE/KUzq+XbdrYconxOlczEuVywvle8dhF+2zpWUgB9E9Y1OfebTK96JkMLM", - "wLToBQze89wyw+fgXUirsOePG1Koynl3NMAM38hA1Vv4RRqSJs8LY0hRgI1Vseo1pXEqE78bXocVXbT4", - "tJT7mQwqdRQYZdFZbrf7eevqVueOsrAGysmw0WdY2ddVvU/VOJQaYM7z1wq0ADOI7i0P1m57DVv3WUxi", - "0ocvj9o3p+OTZjWfV9J3bXIqvXvxvp7eJ7u6C/jzluc1TOzhy6NB85W/uBzULUqXgd02HG21KgNEncWw", - "Yi/hXBDB6lWQxxtu8xjEfI77nVr+U5gbr+EZ5PLt5f8PAAD//xIpvlsljQAA", + "H4sIAAAAAAAC/+R9724bOZL4qxC9PyAz+MmSY+ev98tlk8mOs8kkFzs7B0wCm+ouSYxbpIZkW9EEAfYh", + "7k3uFrgPt5/uBbJvdGAV2c1Wsy3ZiTOZuXwIbHc3Wawq1j9WFd9nuZovlARpTXbwPjP5DOYcf3xgjJhK", + "KI65OXO/F2ByLRZWKJkdtJ4yYRhn1v3EDRPW/a4hB3EOBRuvmJ0B+1HpM9DDbJAttFqAtgJwllzN51wW", + "+LOwMMcf/p+GSXaQ/WHUADfykI0e0gfZh0FmVwvIDjKuNV+539+qsfva/9lYLeTU//1koYXSwq6iF4S0", + "MAUd3qC/Jj6XfJ5+cPGYxnJbbVyOw98RvelWxM1ZPyBVJQr3YKL0nNvsgP4wWH/xwyDT8HMlNBTZwU/h", + "JYccv5YatmgJa1iKUBJDNWjo9aaeV43fQm4dgA/OuSj5uIQnanwE1jpwOpxzJOS0BGboOVMTxtkTNWZu", + "NJNgkJkSOf3YHufHGUg2FecgB6wUc2GRz855KQr3fwWGWeX+ZoD5QYbsuSxXrDIORrYUdsYIaTi5m7tm", + "wQ7y15mtgAmvStuF63gGzD8kOJiZqaX0wLDKgGZLB3sBFvRcSJx/JkxAyZCGj8ZMT1H/ZWSVKq1Y+ImE", + "bCZy/KgnPAccFAph3dJpRA//hJcGBl3k2hloBzQvS7Vk7tN1QBmfWPfODNhbNWYzbtgYQDJTjefCWiiG", + "7EdVlQUT80W5YgWUQJ+VJYN3wtCA3JwZNlGahn6rxgPGZeEEiJovROneEXb4WjaMPlaqBC5xRee87OLn", + "xcrOlGTwbqHBGKEQ+WNg7u2KWygcjpQuaIGBDoAraZOuhqumzaDLGmew6sJwWIC0YiJA+0Fqlh+weWWs", + "g6eS4ueKGNET7a3fCMl53MbgeprYCw/kisE7qznjelrNnYQJ/DZerIbuQzM8UnN4QXtr9c23LHdkqAwU", + "7s1cA7dAS/X7bxXB0GzxRrJcgoXEfA6F4BbKFdPghmIcl1rAREjhPhg4QYDTuykHiBNVWQ8R11bkVcl1", + "TYcefjDVOIjPi6RuQlAd+S/rrX7pEY795+fCCL/JLjnCX92XonQCeF2KOx7zkG0peY8aVKwJ4Gq8454Q", + "xonnAlrZw0prkLZcMeVEJQ/jIhNHwtIM2en3D46+/+7RyePDp9+dvHhw/P0pGQKF0JBbpVdswe2M/X92", + "+job/QH/vc5OGV8sQBZQEAlBVnO3voko4cS9nw2yQujwI/7ZK60ZNzMoTpo33yT2SB9dujLUYyBafbQx", + "SUNwww4fhS2Dy3aC40+lg18P2Q+KSTBOnBirq9xWGgz7BjWEGbBC5G4qrgWYbxnXwEy1WCht15fugR84", + "42F/zy26VNxmA+TrbRcZsU68M2tmHKS0p1WoMtoSjp36b04PGC+XfGXwpSE7RbmO8vT0gNgDv/ai69Uh", + "6XJEqNcAmn1TijNgPCCN8aLYUfLbITtdwjg1zBLGjdZCrptzyafghNqAjSvLpLKkQP0spJaQj4fsdCaK", + "AhyAEs5B49B/XOdlLxodpKRk3IuIHDRg3eySl21ZE6jVIJRmylDoeLxkg2wJ4400S3NkMIIaPiHjWRj2", + "DFGgSTMKixKRz53eSlhMJR9DeTlL1q90eys8Zel1jKQ1Eea3MYEXzblJnjlsJXTeU2Fs2MAokfrx1sVR", + "sG6vtuLjlqLoWW4zRWqBwY3pLMs/YBqc8YKanDNDNrM3vh3/wjvIKwub3Kt+36VmoOhxAC9NuOiT1Iq+", + "01rp7nr+DBK0yBm4x0yDWShpIOUIFok98f3x8QtG3gpzb9RWQj0QO3Q7Ni+rgsw6h40FX5WKF8y4fc5t", + "g0CCtoVbZ4siaEKSXyWUHL6WD91kt3f3nUpDIwklDhqI3PIxN+CejCuzGjJnjiOgASi2FGXJciUtF5Jx", + "duMlWL3aeeDM5Rv06gw4mp8OPCELkXMLxhvUy5nIZ8yKOVmkjhRgLMu5dLpJg9XC2daPlbPMg/TzAwqD", + "8tGxCXc6OIiMG4ZViyD48lKAtGj7KmbUHJz9OWUauFESJSRKbXhHm0Dwko15fqYmE5KFtQMaNFbX+52D", + "MXya4r015kK6N++nOOtxyecgc/VX0Mb7Q1ty+XnzxcVQhBe9jExB8YSiC7wsn0+yg58ulhZHwQVyX30Y", + "rAPMcyvOa10dM/yj5rdgn5XcWBa+YM6Z8Y5S0kkgSz4lWNwD9IXEHIzl80VMyYJb2HFPUmOKxHCvXh0+", + "ChA+wdjChrDEthERp1HqgEi1KNKrOQ6LcDAghujV4ZaLWqM/AhxQ10wbRUpqkr358Ia44RlY7oQBErQo", + "0I3h5YsWoTs4WPPb9FhYzfWKzf1g3sY2Q/ZMaZT4ixLexQamFwNz5fxpVHWVk27slA/Hw/zUbX+ic3A7", + "zwBdOXjH3Vh+9yBXH2RHCy0ssMdaTGfO5KwM6CHMuSgd1KuxBvkvY2/vKj0Nb9CGy47wBXZk/+e/z6GM", + "NGJr1xxFxkUaT1ZX0PNtzTLB/kI6YCSKy9xhgIJSixKs/1kSsoSSOxMu6I36hwV30jwbZD9XUOEPXOcz", + "cR79SMY4Db/jhS8+xp8roOeVw8lOPFvS7KvX8HDG5RS6souEbjrGQ8+iIIRXhDjU8LNssbV9ULO7B6tH", + "EB5zc2aOqvmc61UqwjdflGIioGClN9IoyhP8gyF7SLqR9C8+bGx79yenjN3rwJ0m5OasazDgV1ubbxhn", + "9QBvYbmZvpWbf62A1hztJww/Zge3nRprZELfLvswyDD2dDJeYXx2Xda8CT+dCNni+JplPTe/+dAx/QmQ", + "99lcSDF3G+ZmWjl/suR6LEpnqowbyTUIcujp4V++a8RQMoqkJhMDbUB3U4A2eHp/idCs2VLg9K0oCgmY", + "y6wqotr6lngJttKS/FDHXhR85mFHC6/UcQmtOPTWmrLD0f3c+xKMj1x3nKLtNxQZNlfcSN4ve6jkREwr", + "zW3SrDMzPufyO7RIi+QBAAUYZ8CO8FU2Ec6711yaCWj24MUhRqSC5zZMhwyt0nwKT1XO09H2R3U8Cx0B", + "J40dh+Bc/uPhRgNjfZbB2urSWFr9BWDxspIyeZJyWPsNywgVS3QF2Zyv2BnAgmn6HJ+lJem8M08XS42a", + "6tE5pN9e1uryAmiDTxZrM1Yr2tpuoYUM2aFlZobnCJUhj+iUHjnmh1PmluIt2ziYT16UmwQDPlPl/pfw", + "zg7ZoXcihWGnThScDthpGwmn7Nmro2NnZ51icPs0HXBeI/IaImus9eEoRfSXMBXGgoaCfPrutuBFocGk", + "RaEU+Vm/z19y62zjNBXVxC65hgtIvEkk/FhThURSHY85qU8QzeUk+SedeNa4GNQoi08+AzIGWU4xb4Qy", + "izDRs4IU1Y4gr7SwqzoIsrbDtvWGL3KDScY9nEF+pqrEweMRoKnl5JLXL3YGQrOj7x/s3b7DcvehqeYD", + "ZsQvGMgerywYChAUYBwIrPTyKURScj9bE9RfcyVwNnSHMSR/kDVHOsOpIjGXHWT7t8e7t+7fzPfujnf3", + "9/eLm5PxrduTfPfuvfv85l7Od++MbxZ3bu0We7fv3L97b3d8b/duAbd3bxV3d/fuw64bSPwC2cHNW3u3", + "0J+m2Uo1nQo5jae6sz++u5ff2R/fv7V3a1Lc3B/f37+7Oxnf2d29c3/33m6+z2/evnvzbj7Z58WtW3t3", + "9m+Pb967m9/h9+7f3r17v5lq7+6HrokVMPICAeicPHI7c9JYk6Dyei7Ir/iULYyD8g0DWiV3dl6I0XiN", + "VhMAz1K4YbnXmVBQKKCeZMgOJVNlAZr5aIYJ/rkfC+ddcsPeVoZOy1/Xy2GHj15nZIMHY8SPwkQdeuIE", + "BQaHTr15u2PKajoyOUjYcbttRIeaO4eP2jKz2eSeZba0Mwj2x6KEowXkG00OGnzQJtPm3dSYRCkvzD0j", + "52WNKql0hSuwhw88rDPGMf5KqC/EZAIao3YzLtnSqVBHylptDhxzxINiDBKkqbQjnD9qbrYxRi2RnJ+F", + "+VKkXo/0bUeSmtRdAbeAXEyEl1BIDzTCvKzyQEcmWZs0iyRJgkUW9ko8YoA46WnPeALCtqiNx0yOgXLm", + "fdcRgbaMTkRY183LGQ9ya5AttkPwj8LOmvjKVqgeeKsqR3E27kH9gCntPKUBK2ABssA0H4nnVqR+f+e0", + "2dZeisjRE43pUDUOElxE3k7YrJJnUi0lxjZLxQuyTx3BWnZos34a7CVBgxkl3m69suGBhkYLd722xDUZ", + "DV/EQPgC6q2f+G160WlUWqsRtSZazRlnOvosqJRBTErvq6n2dgd97uyOxzgUeXUaGDKa0yT+Nfc3eOdP", + "6HBCOtVqTgK/FA80G7PeD9fDFvFE9Xb7zLwSie9P5RpKyWwLjrUt7ul/WZ37uQThBUJP5WdgD58/UeNX", + "GElNJjwZsHWm6YAZZ0epc9AsfE3Hu5S8QgEJM2SPnRqDJQbsBs7ghXOhKnNC0JyShTVumJuMoDYCPtPR", + "WfDp2wP9wOdxFlc6Z7AF9KVCinF+c51RdDsZqNUw0WBmJ3VQ/sLYT3QG7T0j/z0dB9Bqbhg6GPB2MGYo", + "Seszgozx531m4O1p/NVZGnhkIGQhzkVRcTpdYEucZQoSNMWDFJtzuQqD+PzQhea5FTkve9MLL4/E/mzu", + "yx5tfsLJZuI80+dzRxnfbRpetNfchurPTj4CiceS9d4iUhvnQJyOTPTtKYNzdGkw5dMqn+oVdE70pnvo", + "9qan15A9DGNShtoUbPycHFkMJDrqByqH30s1RV9pxSSAT6dZlCIXtlyFacdAAsDgYVYu7GpQL8T5ZJS4", + "Ft51YyhJKWXfWIXwtKamoCZHKL9FS8i97l65YRw8DEOijqIpKaIWG0VogjTPQ2B026TW1CAh1ymE4vpF", + "GSWRWNXGyohVsvmDU//DzQJvjYfVomFY/GBb5mwwEJnCNTR4itv8lrSC+zCSOI3glp0JR9jJpVARwPIC", + "nJuzUk0vBOaYm7Onatqn7o49i7N8Vskzr+2sYrzZkVqpOSuAhHJBD32KlAMA9yI/V6JwHxe0lrbETHGp", + "g7ubduKAqFnEgzZkz/iqTpCaV6UVC8w6kkBBK3hnk+fbGIbdxIjHFMe9HI+FkQdZG/1dBnPDb2NqHCMm", + "+20NREbH2PCH4VezNuK8oktn8WyHNqoM2iosv43Z4mPun2q3tMuorvLNl1THHoN1OdaF6UYpToyzy5J5", + "xE0UvqnGcZs6pNKteV3bpC18enKQf7D/8d/ZP//28e8f//HxPz/+/Z9/+/hfH//x8T9iWwSNzPgU389y", + "ks+L7CB773/9gHHeSp6dkOO179ZknQ13wqtCqHDO7xwWf14w0vjlyExGzqqnuPXNvf0hDhmT9MUPf3a/", + "Lkx24BzHieZzt8eymzs3nVMp5nwK5kTpk3NRgHLWMP4lG2SqsovKUp0CvLMgKQUxGy78mSAuxb/VhYtm", + "qiEbpdHlCyo642ml7IXjRc4imjaw47G5Q59kHSc1Zo4NZm+dErdt2eQGtyLmgU0Wd3i13+ZOpzWvG8Kp", + "DZeugT0OGo2qXrGkzQTPOIThQ7rwgIkhDNkYJkoDO+daYKKthkXJc4y8DC8nzj9n5ez1JY1ehzb59Qtx", + "rysrdZAt60P/TcD69ICtM1nXlU6qBjiu9K2Zb0PRb4S4S6Rp1gmZdVKbURO7s56nmTKDmwm/ppzKmH+u", + "kFQZ5yd2NXplLAOpquksLlNgfEwlkl4MhXKuppbUx1AwDXPYE5v6TW67q1peW/J+mKmPUhe5XvSsjleN", + "V4z78hxHIBqZyoGJ815Xu7t7dygmgX4DUgwrNqjIB4vyHpQla6iHMXW1oMTGPzLlDby1F8RUKg0F+wY1", + "jwq1cqdhZ3ufQirLQHOfW1UXGoQy4NhS/3aT09FGx3MJO86noyJgHwPEs+sbhuV1pekMS0IdaOHEgRLV", + "2PNz0EtngxoW/IFyRWitwQz58inOTTqkT9XUO5q1DCCfNzhYoUDVAY1UwQmB61JQiVXSKz26ipRIMtdV", + "8r4+bStfsFPCpKmd0AC6VtXgE7jbYirsgquKIbE4iTCwFl9+wfyzwK31XFdPkVvjZQolySkzK2Nhvnmi", + "KybNURKxjhMpv2zSXVQ01UaBr79yKw9+JO0fL96ECcmmWwrjJkGvFsgRlVs5ek2B1tY5eQTVU5E6sg7F", + "o2RuJRIS/IOtjWtPhi0rDMLo/WBTGmhfZvQnpHlCrinzvvvoEzln3eqhmVpUTE4RMUI/Po7EVD6/LCZC", + "JudJfx3gZ192zNTp1XagumDVllvos3I/TVIkbdRosK2AKvqg+gywbICg7W4Yy7UlwcOX/Aw1lykBnLuK", + "5b2YHlrZgnJgLBj/tppMnDGQdDTae7ojQ/7EjcgvUHRXN7gv5OlfQatsJ7y79CJ5g4nRR27gWLSe8CqV", + "8vXKgHbDOmUSVTMcPhqwBTdmqXQRHpGAoRZQjNvwqo4kpyMBLgnPcR29GnzPrF1kHxyMjoRUgi4tz21T", + "UVxXHrNj4E5+Vbr0X5qD0WgSgqlCjboVUi+p4cVjruf+XBMrUrJBVoocfF6On+fPL56e73fGXy6Xw6ms", + "hkpPR/4bM5ouyp394e4Q5HBm51R0KWzZgtZPF6nNg+zmcHe4izVVC5B8IbKDbB//RJllSJkRX4hRvl6U", + "MyV9UZdZHBZY1m/b1TuORSijB4fa290NKAWJ3/PFovQJhaO33j0ndtvEjMlqIaRcG+PSbayyziwi/gu7", + "10FMiQfxMHU/gahThOVTQ7n4lmONXTPGd7JYKOGzEKa+C1ZnwJoO9aAfBoTbUGG1UCaBUwrrU0aI36l/", + "UsXqs+GxXZTexR82IFH+wCCL97zVFXy4RgpfANCSG2aqPAczqcpyFRq2FExI71RGeR5muNaa7bNAR0Ud", + "CfjwAQs1G212I2QzHjKIkGXWOSPq5BFzHtXNtYZ7ErrqUD8z8IzYZq3Rz6E4Nc1gWP33xA1+PQzW1Mcm", + "kNVJKaZUYqyGpIyJ4ZfmuVY5ZALkH0igIFZrsTIIKfkwX9gVVTiLCZOKDv3n3OYzzOUH+vDrYcnHYPNZ", + "XZLtEL+B6Z6P8Xy+KVidYI0s9vCTBTNK1/0KGx506nX03v3/A5/Dh4s0SGil025H89P7TLil+IRnryLD", + "gB0eGUQoW3c631wj/3QbAvVIVHq2rop8ukXoXtTT2ekC4hzKiaotTuM3V9RAsEMUswUpTPYFMWZSKKtf", + "aho7JbBXdpo/YV8kzBvbGoPNVLVcfts0Im3h7z2dnvRzM+4tUt2bebk+iunn5E3JK29+HW2MpnJKqoiG", + "G0Mvts0KjT6SRdTiLY32kQHbOD491hMy8VEd2f9iVLgWPdo64EoQ47g5QPAF1FaFzP1t9Oit3hxvP5yz", + "u3iew8JCgZvh1t5e34laqNxuA+RbUVFH3lDU7aP+dUHBpGGXL6kmX0l4t4DcAY3hgSGF4/vZ1Re/dMrW", + "w7rICw3rSHBwnRl9ofjAxiq/ExnSahKToAFqQXwswMSnTKb2yr4SvlgXdtzDjWdjdQebsISIFS5WP86p", + "MT0rRg7CR6P3PjVxg/Lx6XtbWFJ1puPXyTq4kB6RR2ejcqK+UrZocmg3ED/xRR/ZR6WaWky620T+p2p6", + "7F78erjAwjs7WpRcrFFhfaR+YpeKHIykyqK2OnF3Rvxmxp3qwRzoFdivkVXqvn4TWEZpz7O4JGArDoo/", + "qccLJ9y9kmRLeyo6rf6iLPX5LapOztDv3qQiGfQ7sKkoFQRrwOZ8xWb8HBhMJpDbUI6K/bpoBG7YEsrS", + "vx+iZA5vc+A+bjur5lwa8jmaGwjOBe/2nx76oxzD3B5x/HCK24mOGnBXNZvqlAlpLHDMzA8bLzp57HO9", + "/1ofbV+bSl3voHrl4HntKJ83uQBx/Pzi8PnDqH6KejkJjP1hhXjdkonntuJluWK8mc6XGtdoJQLszKd2", + "FJ3U92tHT8brxHGUbpBA71+wKDrA2h/QiBISAiKbtabDc+HTwKp1/XXcn+MCzI3e+xO5jSZmk8CzURfU", + "Q361ZmadP9uhVUhn2TLWsaxPezdSzFG6AItJruG8srZmY8mifRewnSYfOK2lQ7uwmjTXoT0TKSn9aEOl", + "SUB90Xh+p3HaNkLuC6rHak09rrFWAN+fGC3rtLIWT3U0aEMSJwKaL806RxkxlTtqMrnA4BNT+XwyybYx", + "bL4+RPo8A5RHrQyDn944MdLg7BnXZ3FqAXcmEyWBbMD2Q176jstB1FrFSq8Zw4mek75YW3xDA5squuIK", + "hx+mSSI3UERe66b2U/Rv57r650vu5W72029iM2/Ngw8qOwNpKR/aJ4A7bqgvQelRKZ/MkBp4sXJvufGo", + "9V8rKV00BO+yq/U570kDISJZ9mtzBjX9XG8s2htFkIr1f/F1s9Tl2YNs7ahhrEa3kstVDxLSfLCTRwmA", + "SeGVSBa8VkEWT5Q6y69VI63zag79b1jmeHnu6UZICD0GQzs3DFA4gVFCQedxVJLiZclOOy4ReAX7vQnZ", + "XH/i5QvonVLlvETRxkvzueXZObRWU5kOq1pft9mjXvMZFFUJPnJ+fefe8U2qqcCTL96qM4H6BNUPygcr", + "2teyRTn4FFba3f98OWOtxrYJ4F+ADklJj0AKEpq3du8nOmTUVQJS2aDpqE6Q2GnAjAqP8dZJaF11REvH", + "YnQm1dJH0Pa/rGoJu4hLB6UiDzzq2zCuLN0iR/2muVQoZ2m3XXLHev+e1+NH2Ni0lZCnjGdwncgXS4aw", + "+vdKVPX2OwgF+5X07UVvD0Wp3VfTFsczCGN1Y7+pLdIccRnGvdSI2YiINqCLrVpj456Jx/+tqKVXTUGk", + "bz2zWogc439x0eBCq6kGYwb+Shx/Z6hmEy7KSsNG3RI0igFZtCI4Dt1hdCfFnEW0YZuM5ny1I3Z01R/X", + "fcZXPmpSyd/FqezaZQS/L3/sOGpIGV3HlrhWQZhYNelKslHPNQvsua/PLetOR4ZxRvXusSnaVJ9T17lt", + "uLhjxaN3F0G2BpMvciW+ppsnRqGD7oi6BVxgJ7Ubz19Tcnp7klQCcdxmtvZkfBfuLxebSDYOT4Ab3kDx", + "HDp8R5nssRa43s1RQ8JL8v+pU4k3oG5dPwDH6GUu3X9EPbQY5XTIXhlgp2YNo00v2lNHZ+o4zhCVmDKu", + "wtH21xK7fUh9/aOrjym0YlbzUsiz+hZHvGKBMEDVC5basHukOLORlyUdceJN6tQ8lna0b7XqG8g4DVlv", + "7ca6a8QHIXVNfBx5gDgz8WZCYFrXPXANPC0s4lbB24qMmKTXKj5S7aq3lSS/ghBJdmtOwVt3lcPbTRV6", + "4DEhBkFpBQ3k2xvTEr+uvYLdwJurFGIc+B7z/vpbpa3xO54oxXW9sI2c/sCpQjdNc9dp0JntARtX2mcT", + "0FEzQdHIG7rA24qybECItgeON3ofWp1/GL3Hv4hfLiiAiLseKw0PPROumYpbN7HHa8O6dmV49VJ1E4Pu", + "lX6/wHoX/rqFe2LWsPptZm3uNHhz7Tuu0+m6v+qnaVD+te2euHtM05E72Zu9ZVFGG+UiqV1z5P9tZhyk", + "nHMvTUS7n7W/IaeACWhWN3wn3YzYQC3/Otvbvfc6W7slGsNIslz5q53X0hlpeaa23KgGspXh0SI4BaB4", + "aZS/Il/NQUlgUNKF1U3TnRSYyC2IQLpNukHhv+3QNDsPudx55Na58woHyBI4jK5HS+FQaTEVkpc4pxsf", + "L2Sjrj6lirsA1TcRCFt351m/65vWjY166ttJuGRc4BsFjCu6IWqLtT33gO089oBlG2vLtjFkVG7B7hir", + "gc/bEqL258dCuv092JwX+5DmMGvXl1wxOIXs1QlN7e3e2/S6Z8cWI0Y5Wrdu3k2OoP3nzgHAQkk2BrsE", + "z+zhovNG6ISqLp8T5u9cxO2vO3KnNpYDL6N7czvR1LDVen7Drg07sNk54ZJ5rXLfcGgM7sN6/vGqte/I", + "lDjt3UIHDO8gpEpnki4xOvxKvhYNhJrBx6T79Q77QWFQzzf7bz3E/TlROhfjcsXyUvnOY3gvfq6kBLxO", + "2bdJ9pFPL3gnQgozA9OiFzB4x3PLDJ+DNyGtwo5h7pNCVc66ow/M8LUMVL2B91nRbvK8MIYUBdhYFate", + "VRqHMt0UjVvRRYsPS7mfSaFSw4dRFp3ldu9OaGWbdUrIhTVQToaNPMPEy67ofaLGIdUAY54/V6AFmEFU", + "Vj5YK8YbtsqNTGLQBy8O24Xt8Umzms8r6Xu+OZHe7Yuwli6YmMCftzyrYWIPXhwOmjtC42xdNynVartl", + "ONpqVQaIOpNhel7CuCCC1bMgjzfc5jGI8Rz3O10YQm5uPIdnkA9vPvxvAAAA//88L7dcY5EAAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/pkg/api/openapi_types.gen.go b/pkg/api/openapi_types.gen.go index a4bffca8..5780def6 100644 --- a/pkg/api/openapi_types.gen.go +++ b/pkg/api/openapi_types.gen.go @@ -513,6 +513,24 @@ type TaskWorker struct { Name string `json:"name"` } +// All information about a Worker +type Worker struct { + Id string `json:"id"` + + // IP address of the Worker + IpAddress string `json:"ip_address"` + Nickname string `json:"nickname"` + + // Operating system of the Worker + Platform string `json:"platform"` + Status WorkerStatus `json:"status"` + StatusRequested *WorkerStatus `json:"status_requested,omitempty"` + SupportedTaskTypes []string `json:"supported_task_types"` + + // Version of Flamenco this Worker is running + Version string `json:"version"` +} + // List of workers. type WorkerList struct { Workers []WorkerSummary `json:"workers"` diff --git a/web/app/src/manager-api/ApiClient.js b/web/app/src/manager-api/ApiClient.js index 959de790..bbab3fc5 100644 --- a/web/app/src/manager-api/ApiClient.js +++ b/web/app/src/manager-api/ApiClient.js @@ -55,7 +55,7 @@ class ApiClient { * @default {} */ this.defaultHeaders = { - 'User-Agent': 'Flamenco/4f8fd14d / webbrowser' + 'User-Agent': 'Flamenco/ccea8869 / webbrowser' }; /** diff --git a/web/app/src/manager-api/index.js b/web/app/src/manager-api/index.js index 4759e91b..d058074f 100644 --- a/web/app/src/manager-api/index.js +++ b/web/app/src/manager-api/index.js @@ -55,6 +55,7 @@ import TaskStatusChange from './model/TaskStatusChange'; import TaskSummary from './model/TaskSummary'; import TaskUpdate from './model/TaskUpdate'; import TaskWorker from './model/TaskWorker'; +import Worker from './model/Worker'; import WorkerList from './model/WorkerList'; import WorkerRegistration from './model/WorkerRegistration'; import WorkerSignOn from './model/WorkerSignOn'; @@ -359,6 +360,12 @@ export { */ TaskWorker, + /** + * The Worker model constructor. + * @property {module:model/Worker} + */ + Worker, + /** * The WorkerList model constructor. * @property {module:model/WorkerList} diff --git a/web/app/src/manager-api/manager/WorkerMgtApi.js b/web/app/src/manager-api/manager/WorkerMgtApi.js index be5297de..de8e346d 100644 --- a/web/app/src/manager-api/manager/WorkerMgtApi.js +++ b/web/app/src/manager-api/manager/WorkerMgtApi.js @@ -13,6 +13,7 @@ import ApiClient from "../ApiClient"; +import Worker from '../model/Worker'; import WorkerList from '../model/WorkerList'; /** @@ -35,6 +36,52 @@ export default class WorkerMgtApi { + /** + * Fetch info about the worker. + * @param {String} workerId + * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Worker} and HTTP response + */ + fetchWorkerWithHttpInfo(workerId) { + let postBody = null; + // verify the required parameter 'workerId' is set + if (workerId === undefined || workerId === null) { + throw new Error("Missing the required parameter 'workerId' when calling fetchWorker"); + } + + let pathParams = { + 'worker_id': workerId + }; + let queryParams = { + }; + let headerParams = { + }; + let formParams = { + }; + + let authNames = []; + let contentTypes = []; + let accepts = ['application/json']; + let returnType = Worker; + return this.apiClient.callApi( + '/api/worker-mgt/workers/{worker_id}', 'GET', + pathParams, queryParams, headerParams, formParams, postBody, + authNames, contentTypes, accepts, returnType, null + ); + } + + /** + * Fetch info about the worker. + * @param {String} workerId + * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Worker} + */ + fetchWorker(workerId) { + return this.fetchWorkerWithHttpInfo(workerId) + .then(function(response_and_data) { + return response_and_data.data; + }); + } + + /** * Get list of workers. * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/WorkerList} and HTTP response diff --git a/web/app/src/manager-api/model/Worker.js b/web/app/src/manager-api/model/Worker.js new file mode 100644 index 00000000..ad514992 --- /dev/null +++ b/web/app/src/manager-api/model/Worker.js @@ -0,0 +1,146 @@ +/** + * Flamenco manager + * Render Farm manager API + * + * The version of the OpenAPI document: 1.0.0 + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + * + */ + +import ApiClient from '../ApiClient'; +import WorkerStatus from './WorkerStatus'; + +/** + * The Worker model module. + * @module model/Worker + * @version 0.0.0 + */ +class Worker { + /** + * Constructs a new Worker. + * All information about a Worker + * @alias module:model/Worker + * @param id {String} + * @param nickname {String} + * @param status {module:model/WorkerStatus} + * @param ipAddress {String} IP address of the Worker + * @param platform {String} Operating system of the Worker + * @param version {String} Version of Flamenco this Worker is running + * @param supportedTaskTypes {Array.} + */ + constructor(id, nickname, status, ipAddress, platform, version, supportedTaskTypes) { + + Worker.initialize(this, id, nickname, status, ipAddress, platform, version, supportedTaskTypes); + } + + /** + * Initializes the fields of this object. + * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins). + * Only for internal use. + */ + static initialize(obj, id, nickname, status, ipAddress, platform, version, supportedTaskTypes) { + obj['id'] = id; + obj['nickname'] = nickname; + obj['status'] = status; + obj['ip_address'] = ipAddress; + obj['platform'] = platform; + obj['version'] = version; + obj['supported_task_types'] = supportedTaskTypes; + } + + /** + * Constructs a Worker from a plain JavaScript object, optionally creating a new instance. + * Copies all relevant properties from data to obj if supplied or a new instance if not. + * @param {Object} data The plain JavaScript object bearing properties of interest. + * @param {module:model/Worker} obj Optional instance to populate. + * @return {module:model/Worker} The populated Worker instance. + */ + static constructFromObject(data, obj) { + if (data) { + obj = obj || new Worker(); + + if (data.hasOwnProperty('id')) { + obj['id'] = ApiClient.convertToType(data['id'], 'String'); + } + if (data.hasOwnProperty('nickname')) { + obj['nickname'] = ApiClient.convertToType(data['nickname'], 'String'); + } + if (data.hasOwnProperty('status')) { + obj['status'] = WorkerStatus.constructFromObject(data['status']); + } + if (data.hasOwnProperty('status_requested')) { + obj['status_requested'] = WorkerStatus.constructFromObject(data['status_requested']); + } + if (data.hasOwnProperty('ip_address')) { + obj['ip_address'] = ApiClient.convertToType(data['ip_address'], 'String'); + } + if (data.hasOwnProperty('platform')) { + obj['platform'] = ApiClient.convertToType(data['platform'], 'String'); + } + if (data.hasOwnProperty('version')) { + obj['version'] = ApiClient.convertToType(data['version'], 'String'); + } + if (data.hasOwnProperty('supported_task_types')) { + obj['supported_task_types'] = ApiClient.convertToType(data['supported_task_types'], ['String']); + } + } + return obj; + } + + +} + +/** + * @member {String} id + */ +Worker.prototype['id'] = undefined; + +/** + * @member {String} nickname + */ +Worker.prototype['nickname'] = undefined; + +/** + * @member {module:model/WorkerStatus} status + */ +Worker.prototype['status'] = undefined; + +/** + * @member {module:model/WorkerStatus} status_requested + */ +Worker.prototype['status_requested'] = undefined; + +/** + * IP address of the Worker + * @member {String} ip_address + */ +Worker.prototype['ip_address'] = undefined; + +/** + * Operating system of the Worker + * @member {String} platform + */ +Worker.prototype['platform'] = undefined; + +/** + * Version of Flamenco this Worker is running + * @member {String} version + */ +Worker.prototype['version'] = undefined; + +/** + * @member {Array.} supported_task_types + */ +Worker.prototype['supported_task_types'] = undefined; + + + + + + +export default Worker; +