From d099a315317fe0021faa319cfa9e6e8de601de48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sybren=20A=2E=20St=C3=BCvel?= Date: Fri, 15 Apr 2022 16:21:48 +0200 Subject: [PATCH] OAPI: add endpoint for getting a single job type This will be used by the web frontend to determine which job settings to show and which to hide. --- addon/flamenco/manager/__init__.py | 2 +- addon/flamenco/manager/api/jobs_api.py | 127 +++++++++++ addon/flamenco/manager/api_client.py | 2 +- addon/flamenco/manager/configuration.py | 2 +- addon/flamenco/manager/docs/JobsApi.md | 66 ++++++ addon/flamenco/manager_README.md | 4 +- internal/manager/api_impl/api_impl.go | 1 + internal/manager/api_impl/jobs.go | 21 ++ internal/manager/api_impl/jobs_test.go | 57 +++++ .../api_impl/mocks/api_impl_mock.gen.go | 15 ++ internal/manager/api_impl/support_test.go | 7 + .../manager/job_compilers/job_compilers.go | 10 + internal/worker/mocks/client.gen.go | 20 ++ pkg/api/flamenco-manager.yaml | 18 ++ pkg/api/openapi_client.gen.go | 109 ++++++++++ pkg/api/openapi_server.gen.go | 20 ++ pkg/api/openapi_spec.gen.go | 199 +++++++++--------- web/app/src/manager-api/ApiClient.js | 2 +- web/app/src/manager-api/manager/JobsApi.js | 47 +++++ 19 files changed, 625 insertions(+), 104 deletions(-) diff --git a/addon/flamenco/manager/__init__.py b/addon/flamenco/manager/__init__.py index 16dea2c6..717fa6ef 100644 --- a/addon/flamenco/manager/__init__.py +++ b/addon/flamenco/manager/__init__.py @@ -10,7 +10,7 @@ """ -__version__ = "61618531-dirty" +__version__ = "70584ce9-dirty" # import ApiClient from flamenco.manager.api_client import ApiClient diff --git a/addon/flamenco/manager/api/jobs_api.py b/addon/flamenco/manager/api/jobs_api.py index f1664a82..b9c6fd9e 100644 --- a/addon/flamenco/manager/api/jobs_api.py +++ b/addon/flamenco/manager/api/jobs_api.py @@ -21,6 +21,7 @@ from flamenco.manager.model_utils import ( # noqa: F401 none_type, validate_and_convert_types ) +from flamenco.manager.model.available_job_type import AvailableJobType from flamenco.manager.model.available_job_types import AvailableJobTypes from flamenco.manager.model.error import Error from flamenco.manager.model.job import Job @@ -89,6 +90,55 @@ class JobsApi(object): }, api_client=api_client ) + self.get_job_type_endpoint = _Endpoint( + settings={ + 'response_type': (AvailableJobType,), + 'auth': [], + 'endpoint_path': '/api/jobs/type/{typeName}', + 'operation_id': 'get_job_type', + 'http_method': 'GET', + 'servers': None, + }, + params_map={ + 'all': [ + 'type_name', + ], + 'required': [ + 'type_name', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] + }, + root_map={ + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'type_name': + (str,), + }, + 'attribute_map': { + 'type_name': 'typeName', + }, + 'location_map': { + 'type_name': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, + api_client=api_client + ) self.get_job_types_endpoint = _Endpoint( settings={ 'response_type': (AvailableJobTypes,), @@ -309,6 +359,83 @@ class JobsApi(object): job_id return self.fetch_job_endpoint.call_with_http_info(**kwargs) + def get_job_type( + self, + type_name, + **kwargs + ): + """Get single job type and its parameters. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.get_job_type(type_name, async_req=True) + >>> result = thread.get() + + Args: + type_name (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: + AvailableJobType + 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['type_name'] = \ + type_name + return self.get_job_type_endpoint.call_with_http_info(**kwargs) + def get_job_types( self, **kwargs diff --git a/addon/flamenco/manager/api_client.py b/addon/flamenco/manager/api_client.py index b839d30b..cc0d1937 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/61618531-dirty (Blender add-on)' + self.user_agent = 'Flamenco/70584ce9-dirty (Blender add-on)' def __enter__(self): return self diff --git a/addon/flamenco/manager/configuration.py b/addon/flamenco/manager/configuration.py index f11a81dc..dd0168cd 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: 61618531-dirty".\ + "SDK Package Version: 70584ce9-dirty".\ format(env=sys.platform, pyversion=sys.version) def get_host_settings(self): diff --git a/addon/flamenco/manager/docs/JobsApi.md b/addon/flamenco/manager/docs/JobsApi.md index 5a0697a1..ade0d60d 100644 --- a/addon/flamenco/manager/docs/JobsApi.md +++ b/addon/flamenco/manager/docs/JobsApi.md @@ -5,6 +5,7 @@ All URIs are relative to *http://localhost* Method | HTTP request | Description ------------- | ------------- | ------------- [**fetch_job**](JobsApi.md#fetch_job) | **GET** /api/jobs/{job_id} | Fetch info about the job. +[**get_job_type**](JobsApi.md#get_job_type) | **GET** /api/jobs/type/{typeName} | Get single job type and its parameters. [**get_job_types**](JobsApi.md#get_job_types) | **GET** /api/jobs/types | Get list of job types and their parameters. [**query_jobs**](JobsApi.md#query_jobs) | **POST** /api/jobs/query | Fetch list of jobs. [**submit_job**](JobsApi.md#submit_job) | **POST** /api/jobs | Submit a new job for Flamenco Manager to execute. @@ -75,6 +76,71 @@ No authorization required [[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) +# **get_job_type** +> AvailableJobType get_job_type(type_name) + +Get single job type and its parameters. + +### Example + + +```python +import time +import flamenco.manager +from flamenco.manager.api import jobs_api +from flamenco.manager.model.available_job_type import AvailableJobType +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 = jobs_api.JobsApi(api_client) + type_name = "typeName_example" # str | + + # example passing only required values which don't have defaults set + try: + # Get single job type and its parameters. + api_response = api_instance.get_job_type(type_name) + pprint(api_response) + except flamenco.manager.ApiException as e: + print("Exception when calling JobsApi->get_job_type: %s\n" % e) +``` + + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **type_name** | **str**| | + +### Return type + +[**AvailableJobType**](AvailableJobType.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Job type | - | + +[[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) + # **get_job_types** > AvailableJobTypes get_job_types() diff --git a/addon/flamenco/manager_README.md b/addon/flamenco/manager_README.md index 3bd75a10..38919cf9 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: 61618531-dirty +- Package version: 70584ce9-dirty - Build package: org.openapitools.codegen.languages.PythonClientCodegen For more information, please visit [https://flamenco.io/](https://flamenco.io/) @@ -32,6 +32,7 @@ import time import flamenco.manager from pprint import pprint from flamenco.manager.api import jobs_api +from flamenco.manager.model.available_job_type import AvailableJobType from flamenco.manager.model.available_job_types import AvailableJobTypes from flamenco.manager.model.error import Error from flamenco.manager.model.job import Job @@ -67,6 +68,7 @@ All URIs are relative to *http://localhost* Class | Method | HTTP request | Description ------------ | ------------- | ------------- | ------------- *JobsApi* | [**fetch_job**](flamenco/manager/docs/JobsApi.md#fetch_job) | **GET** /api/jobs/{job_id} | Fetch info about the job. +*JobsApi* | [**get_job_type**](flamenco/manager/docs/JobsApi.md#get_job_type) | **GET** /api/jobs/type/{typeName} | Get single job type and its parameters. *JobsApi* | [**get_job_types**](flamenco/manager/docs/JobsApi.md#get_job_types) | **GET** /api/jobs/types | Get list of job types and their parameters. *JobsApi* | [**query_jobs**](flamenco/manager/docs/JobsApi.md#query_jobs) | **POST** /api/jobs/query | Fetch list of jobs. *JobsApi* | [**submit_job**](flamenco/manager/docs/JobsApi.md#submit_job) | **POST** /api/jobs | Submit a new job for Flamenco Manager to execute. diff --git a/internal/manager/api_impl/api_impl.go b/internal/manager/api_impl/api_impl.go index f8589d79..edf816d0 100644 --- a/internal/manager/api_impl/api_impl.go +++ b/internal/manager/api_impl/api_impl.go @@ -81,6 +81,7 @@ var _ ChangeBroadcaster = (*webupdates.BiDirComms)(nil) type JobCompiler interface { ListJobTypes() api.AvailableJobTypes + GetJobType(typeName string) (api.AvailableJobType, error) Compile(ctx context.Context, job api.SubmittedJob) (*job_compilers.AuthoredJob, error) } diff --git a/internal/manager/api_impl/jobs.go b/internal/manager/api_impl/jobs.go index e7f269e5..dc4b1559 100644 --- a/internal/manager/api_impl/jobs.go +++ b/internal/manager/api_impl/jobs.go @@ -7,6 +7,7 @@ import ( "fmt" "net/http" + "git.blender.org/flamenco/internal/manager/job_compilers" "git.blender.org/flamenco/internal/manager/persistence" "git.blender.org/flamenco/internal/manager/webupdates" "git.blender.org/flamenco/pkg/api" @@ -28,6 +29,26 @@ func (f *Flamenco) GetJobTypes(e echo.Context) error { return e.JSON(http.StatusOK, &jobTypes) } +func (f *Flamenco) GetJobType(e echo.Context, typeName string) error { + logger := requestLogger(e) + + if f.jobCompiler == nil { + logger.Error().Msg("Flamenco is running without job compiler") + return sendAPIError(e, http.StatusInternalServerError, "no job types available") + } + + logger.Debug().Str("typeName", typeName).Msg("getting job type") + jobType, err := f.jobCompiler.GetJobType(typeName) + if err != nil { + if err == job_compilers.ErrJobTypeUnknown { + return sendAPIError(e, http.StatusNotFound, "no such job type known") + } + return sendAPIError(e, http.StatusInternalServerError, "error getting job type") + } + + return e.JSON(http.StatusOK, jobType) +} + func (f *Flamenco) SubmitJob(e echo.Context) error { logger := requestLogger(e) diff --git a/internal/manager/api_impl/jobs_test.go b/internal/manager/api_impl/jobs_test.go index 3fac0859..fc8a04dd 100644 --- a/internal/manager/api_impl/jobs_test.go +++ b/internal/manager/api_impl/jobs_test.go @@ -4,6 +4,8 @@ package api_impl import ( "context" + "errors" + "net/http" "testing" "time" @@ -138,3 +140,58 @@ func TestTaskUpdate(t *testing.T) { assert.Equal(t, "pre-update activity", statusChangedtask.Activity) // the 'save' should come from the change in status. assert.Equal(t, "testing", actUpdatedTask.Activity) // the activity should be saved separately. } + +func TestGetJobTypeHappy(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mf := newMockedFlamenco(mockCtrl) + + // Get an existing job type. + jt := api.AvailableJobType{ + Name: "test-job-type", + Label: "Test Job Type", + Settings: []api.AvailableJobSetting{ + {Key: "setting", Type: api.AvailableJobSettingTypeString}, + }, + } + mf.jobCompiler.EXPECT().GetJobType("test-job-type"). + Return(jt, nil) + + echoCtx := mf.prepareMockedRequest(nil) + err := mf.flamenco.GetJobType(echoCtx, "test-job-type") + assert.NoError(t, err) + + assertJSONResponse(t, echoCtx, http.StatusOK, jt) +} + +func TestGetJobTypeUnknown(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mf := newMockedFlamenco(mockCtrl) + + // Get a non-existing job type. + mf.jobCompiler.EXPECT().GetJobType("nonexistent-type"). + Return(api.AvailableJobType{}, job_compilers.ErrJobTypeUnknown) + + echoCtx := mf.prepareMockedRequest(nil) + err := mf.flamenco.GetJobType(echoCtx, "nonexistent-type") + assert.NoError(t, err) + assertJSONResponse(t, echoCtx, http.StatusNotFound, api.Error{ + Code: http.StatusNotFound, + Message: "no such job type known", + }) +} + +func TestGetJobTypeError(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mf := newMockedFlamenco(mockCtrl) + + // Get an error situation. + mf.jobCompiler.EXPECT().GetJobType("error"). + Return(api.AvailableJobType{}, errors.New("didn't expect this")) + echoCtx := mf.prepareMockedRequest(nil) + err := mf.flamenco.GetJobType(echoCtx, "error") + assert.NoError(t, err) + assertAPIErrorResponse(t, echoCtx, http.StatusInternalServerError, "error getting job type") +} diff --git a/internal/manager/api_impl/mocks/api_impl_mock.gen.go b/internal/manager/api_impl/mocks/api_impl_mock.gen.go index 820306e1..e0c49fd7 100644 --- a/internal/manager/api_impl/mocks/api_impl_mock.gen.go +++ b/internal/manager/api_impl/mocks/api_impl_mock.gen.go @@ -287,6 +287,21 @@ func (mr *MockJobCompilerMockRecorder) Compile(arg0, arg1 interface{}) *gomock.C return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compile", reflect.TypeOf((*MockJobCompiler)(nil).Compile), arg0, arg1) } +// GetJobType mocks base method. +func (m *MockJobCompiler) GetJobType(arg0 string) (api.AvailableJobType, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetJobType", arg0) + ret0, _ := ret[0].(api.AvailableJobType) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetJobType indicates an expected call of GetJobType. +func (mr *MockJobCompilerMockRecorder) GetJobType(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobType", reflect.TypeOf((*MockJobCompiler)(nil).GetJobType), arg0) +} + // ListJobTypes mocks base method. func (m *MockJobCompiler) ListJobTypes() api.AvailableJobTypes { m.ctrl.T.Helper() diff --git a/internal/manager/api_impl/support_test.go b/internal/manager/api_impl/support_test.go index 06134d8a..c6181aea 100644 --- a/internal/manager/api_impl/support_test.go +++ b/internal/manager/api_impl/support_test.go @@ -111,6 +111,13 @@ func assertJSONResponse(t *testing.T, echoCtx echo.Context, expectStatusCode int assert.JSONEq(t, string(expectJSON), string(actualJSON)) } +func assertAPIErrorResponse(t *testing.T, echoCtx echo.Context, expectStatusCode int, expectMessage string) { + assertJSONResponse(t, echoCtx, expectStatusCode, api.Error{ + Code: int32(expectStatusCode), + Message: expectMessage, + }) +} + func testWorker() persistence.Worker { return persistence.Worker{ Model: gorm.Model{ID: 1}, diff --git a/internal/manager/job_compilers/job_compilers.go b/internal/manager/job_compilers/job_compilers.go index 2864387b..306f70cd 100644 --- a/internal/manager/job_compilers/job_compilers.go +++ b/internal/manager/job_compilers/job_compilers.go @@ -147,6 +147,16 @@ func (s *Service) ListJobTypes() api.AvailableJobTypes { return api.AvailableJobTypes{JobTypes: jobTypes} } +// GetJobType returns information about the named job type. +// Returns ErrJobTypeUnknown when the name doesn't correspond with a known job type. +func (s *Service) GetJobType(typeName string) (api.AvailableJobType, error) { + compiler, err := s.compilerForJobType(typeName) + if err != nil { + return api.AvailableJobType{}, err + } + return compiler.getJobTypeInfo() +} + func (vm *VM) getCompileJob() (jobCompileFunc, error) { compileJob, isCallable := goja.AssertFunction(vm.runtime.Get("compileJob")) if !isCallable { diff --git a/internal/worker/mocks/client.gen.go b/internal/worker/mocks/client.gen.go index b5428859..af9965bc 100644 --- a/internal/worker/mocks/client.gen.go +++ b/internal/worker/mocks/client.gen.go @@ -76,6 +76,26 @@ func (mr *MockFlamencoClientMockRecorder) GetConfigurationWithResponse(arg0 inte return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetConfigurationWithResponse), varargs...) } +// GetJobTypeWithResponse mocks base method. +func (m *MockFlamencoClient) GetJobTypeWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.GetJobTypeResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetJobTypeWithResponse", varargs...) + ret0, _ := ret[0].(*api.GetJobTypeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetJobTypeWithResponse indicates an expected call of GetJobTypeWithResponse. +func (mr *MockFlamencoClientMockRecorder) GetJobTypeWithResponse(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, "GetJobTypeWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetJobTypeWithResponse), varargs...) +} + // GetJobTypesWithResponse mocks base method. func (m *MockFlamencoClient) GetJobTypesWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetJobTypesResponse, error) { m.ctrl.T.Helper() diff --git a/pkg/api/flamenco-manager.yaml b/pkg/api/flamenco-manager.yaml index 8dda143d..0a9fd9ec 100644 --- a/pkg/api/flamenco-manager.yaml +++ b/pkg/api/flamenco-manager.yaml @@ -236,6 +236,24 @@ paths: application/json: schema: {$ref: "#/components/schemas/AvailableJobTypes"} + /api/jobs/type/{typeName}: + summary: Info about a specific job type. + get: + operationId: getJobType + summary: Get single job type and its parameters. + tags: [jobs] + parameters: + - name: typeName + in: path + required: true + schema: {type: string} + responses: + "200": + description: Job type + content: + application/json: + schema: {$ref: "#/components/schemas/AvailableJobType"} + /api/jobs: summary: Job submission endpoint. post: diff --git a/pkg/api/openapi_client.gen.go b/pkg/api/openapi_client.gen.go index d78c5793..7aeab204 100644 --- a/pkg/api/openapi_client.gen.go +++ b/pkg/api/openapi_client.gen.go @@ -103,6 +103,9 @@ type ClientInterface interface { QueryJobs(ctx context.Context, body QueryJobsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + // GetJobType request + GetJobType(ctx context.Context, typeName string, reqEditors ...RequestEditorFn) (*http.Response, error) + // GetJobTypes request GetJobTypes(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -218,6 +221,18 @@ func (c *Client) QueryJobs(ctx context.Context, body QueryJobsJSONRequestBody, r return c.Client.Do(req) } +func (c *Client) GetJobType(ctx context.Context, typeName string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewGetJobTypeRequest(c.Server, typeName) + 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) GetJobTypes(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { req, err := NewGetJobTypesRequest(c.Server) if err != nil { @@ -565,6 +580,40 @@ func NewQueryJobsRequestWithBody(server string, contentType string, body io.Read return req, nil } +// NewGetJobTypeRequest generates requests for GetJobType +func NewGetJobTypeRequest(server string, typeName string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "typeName", runtime.ParamLocationPath, typeName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/jobs/type/%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 +} + // NewGetJobTypesRequest generates requests for GetJobTypes func NewGetJobTypesRequest(server string) (*http.Request, error) { var err error @@ -1143,6 +1192,9 @@ type ClientWithResponsesInterface interface { QueryJobsWithResponse(ctx context.Context, body QueryJobsJSONRequestBody, reqEditors ...RequestEditorFn) (*QueryJobsResponse, error) + // GetJobType request + GetJobTypeWithResponse(ctx context.Context, typeName string, reqEditors ...RequestEditorFn) (*GetJobTypeResponse, error) + // GetJobTypes request GetJobTypesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetJobTypesResponse, error) @@ -1266,6 +1318,28 @@ func (r QueryJobsResponse) StatusCode() int { return 0 } +type GetJobTypeResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *AvailableJobType +} + +// Status returns HTTPResponse.Status +func (r GetJobTypeResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r GetJobTypeResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + type GetJobTypesResponse struct { Body []byte HTTPResponse *http.Response @@ -1627,6 +1701,15 @@ func (c *ClientWithResponses) QueryJobsWithResponse(ctx context.Context, body Qu return ParseQueryJobsResponse(rsp) } +// GetJobTypeWithResponse request returning *GetJobTypeResponse +func (c *ClientWithResponses) GetJobTypeWithResponse(ctx context.Context, typeName string, reqEditors ...RequestEditorFn) (*GetJobTypeResponse, error) { + rsp, err := c.GetJobType(ctx, typeName, reqEditors...) + if err != nil { + return nil, err + } + return ParseGetJobTypeResponse(rsp) +} + // GetJobTypesWithResponse request returning *GetJobTypesResponse func (c *ClientWithResponses) GetJobTypesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetJobTypesResponse, error) { rsp, err := c.GetJobTypes(ctx, reqEditors...) @@ -1893,6 +1976,32 @@ func ParseQueryJobsResponse(rsp *http.Response) (*QueryJobsResponse, error) { return response, nil } +// ParseGetJobTypeResponse parses an HTTP response from a GetJobTypeWithResponse call +func ParseGetJobTypeResponse(rsp *http.Response) (*GetJobTypeResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &GetJobTypeResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest AvailableJobType + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + } + + return response, nil +} + // ParseGetJobTypesResponse parses an HTTP response from a GetJobTypesWithResponse call func ParseGetJobTypesResponse(rsp *http.Response) (*GetJobTypesResponse, error) { bodyBytes, err := ioutil.ReadAll(rsp.Body) diff --git a/pkg/api/openapi_server.gen.go b/pkg/api/openapi_server.gen.go index b54737a8..28ace4df 100644 --- a/pkg/api/openapi_server.gen.go +++ b/pkg/api/openapi_server.gen.go @@ -22,6 +22,9 @@ type ServerInterface interface { // Fetch list of jobs. // (POST /api/jobs/query) QueryJobs(ctx echo.Context) error + // Get single job type and its parameters. + // (GET /api/jobs/type/{typeName}) + GetJobType(ctx echo.Context, typeName string) error // Get list of job types and their parameters. // (GET /api/jobs/types) GetJobTypes(ctx echo.Context) error @@ -99,6 +102,22 @@ func (w *ServerInterfaceWrapper) QueryJobs(ctx echo.Context) error { return err } +// GetJobType converts echo context to params. +func (w *ServerInterfaceWrapper) GetJobType(ctx echo.Context) error { + var err error + // ------------- Path parameter "typeName" ------------- + var typeName string + + err = runtime.BindStyledParameterWithLocation("simple", false, "typeName", runtime.ParamLocationPath, ctx.Param("typeName"), &typeName) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter typeName: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.GetJobType(ctx, typeName) + return err +} + // GetJobTypes converts echo context to params. func (w *ServerInterfaceWrapper) GetJobTypes(ctx echo.Context) error { var err error @@ -347,6 +366,7 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL router.GET(baseURL+"/api/configuration", wrapper.GetConfiguration) router.POST(baseURL+"/api/jobs", wrapper.SubmitJob) router.POST(baseURL+"/api/jobs/query", wrapper.QueryJobs) + router.GET(baseURL+"/api/jobs/type/:typeName", wrapper.GetJobType) router.GET(baseURL+"/api/jobs/types", wrapper.GetJobTypes) router.GET(baseURL+"/api/jobs/:job_id", wrapper.FetchJob) router.GET(baseURL+"/api/version", wrapper.GetVersion) diff --git a/pkg/api/openapi_spec.gen.go b/pkg/api/openapi_spec.gen.go index a1f96ee3..73826a66 100644 --- a/pkg/api/openapi_spec.gen.go +++ b/pkg/api/openapi_spec.gen.go @@ -18,105 +18,106 @@ import ( // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+Q823LcOHa/guKmanYr7IsuvukpWnu8I2dmrFjyTqrGLgkkD7thkUAPAKrd41LVfkT+", - "JNmqPGSf8gPeP0rhHPDWREstW/J6N35wtUgQODj3G/AhSlW5UBKkNdHBh8ikcyg5/jw0RswkZKfcXLi/", - "MzCpFgsrlIwOem+ZMIwz635xw4R1f2tIQVxCxpIVs3NgPyl9AXocxdFCqwVoKwBXSVVZcpnhb2GhxB//", - "pCGPDqLfTFrgJh6yyVP6ILqKI7taQHQQca35yv39TiXua//YWC3kzD8/W2ihtLCrzgAhLcxA1yPoaeBz", - "ycvwi+vnNJbb6sbtOPyd0Ei3I24uNgNSVSJzL3KlS26jA3oQrw+8iiMNv1RCQxYd/FwPcsjxe2lg62xh", - "DUsdlHShilt6vW3WVck7SK0D8PCSi4InBbxQyQlY68AZcM6JkLMCmKH3TOWMsxcqYW42E2CQuRIp/ezP", - "89McJJuJS5AxK0QpLPLZJS9E5v6vwDCr3DMDzE8yZi9lsWKVcTCypbBzRkjDxd3aDQsOkL/ObBnkvCrs", - "EK7TOTD/kuBgZq6W0gPDKgOaLR3sGVjQpZC4/lyYGiVjmr4zZ3iJ5snEKlVYsfALCdku5PhR5zwFnBQy", - "Yd3WaUYPf84LA/EQuXYO2gHNi0Itmft0HVDGc+vGzIG9Uwmbc8MSAMlMlZTCWsjG7CdVFRkT5aJYsQwK", - "oM+KgsF7YWhCbi4My5Wmqd+pJGZcZk6BqHIhCjdG2PEb2TJ6olQBXOKOLnkxxM/xys6VZPB+ocEYoRD5", - "CTA3uuIWMocjpTPaYE0HwJ30SdfA1dAmHrLGBayGMBxlIK3IBWg/ScPyMSsrYx08lRS/VMSInmjvvCAE", - "13GCwfUsIAuHcsXgvdWccT2rSqdhan5LFqux+9CMT1QJxyRbq9/+jqWODJWBzI1MNXALtFUvf6sODK2I", - "t5rlFiwkyhIywS0UK6bBTcU4bjWDXEjhPoidIsDl3ZIx4kRV1kPEtRVpVXDd0GEDP5gqqdXndVo3oKhO", - "/JeNqN96hlP/+aUwYl3IrK6uQ5AT3L5oeX54fUQK0iGrFivNfluIC2Cc/b4A6ZiYZ9lIyd+N2QlYN905", - "EuSc1AzZYy5JF0heNGvYObdu6arI5DfIkI2mApmhAjFhRK+ZGCcAftCWZuGkpdOadaiSkXtD7EACUdOc", - "Pa20BmmLFVNOj/N6XpSwjiY3Y3b+3eHJd98+O3t+9P23Z8eHp9+dk5eSCQ2pVXrFFtzO2T+z8zfR5Df4", - "7010zvhi4VCa0bZBVqXbXy4KOHPjozjKhK5/4mNvUefczCE7a0e+DQjwJqYZKniPgc7uO1qDzBc37OhZ", - "Lc+4bcc0niXG7EfFJBin64zVVWorDYb9Fs2XiVkmUrcU1wLM7xjXwEy1WCht17fugY+dZ7O36zZdKG6j", - "GHnhxk2Gd1db+3ZN8hKFYT9wyWegyQQIi6LPS6egA65BwRMobueyeWRu726GXJqBN7AmDp4lCLzOmjfJ", - "hsNWQLl/L4ytmQG5ezPehjiq3bhP2/FpTyNu2G67RGiDtb8+2JZ/wTQ4K40mizNDzqH3MlETvYe0snBT", - "HLHZSW8YqPO6Bi9MuM4noR19q7XSw/38ASRokTJwr5kGs1DSQCjiyQIy8d3p6TEjt5y5EY05bCZiR4YJ", - "mRZVRv6Lw8aCrwrFM2YUKfMGgQRtD7fO6ULQhKQAQig5fiOfusUeTPecekRvAI0GekLc8oQbcG+SyqzG", - "zPmdCGgNFFuKomCpkpYLyTj75hVYvRodOr/wGxo6B45+lgNPyEyk3ILxnuNyLtI5s6Ik18uRAoxlKZdO", - "z2mwWjgn8rlyLihZLKgnFIZJZZljE+70ea0yvjGsWtTOT1oIkGgSM8WMKsE5WjOmgRslUYuiJYX3JASC", - "Fyzh6YXKc9KCTaRVa79hmFeCMXwW4r015kK6t+NDnPW84CXIVP0RtPGO/5Zcftl+cT0U9UCvI0NQvKAw", - "mhfFyzw6+Pl6bXFS+/ruq6t4HWDyK0PS716gZy5KMJaXiy66M25h5N6E3GARmO7166NntcvwAiPdG4Lk", - "beNzp/ab8LxaZHe8mzXqIKQ1ztr1GmDfXr0lAv0Aljv5REJlGbrQvDju4X6w47WYQSfCaq5XrPSTeRfK", - "jNkPSqMSXhTwvus/eMkslYvl0PpUTuGwcz5Oxum5k0jCQx3yXACGEfCeu7k8QyOjHUQnCy0ssOdazObO", - "o3D+5hhKLgoH9SrRIP8l8e6M0rN6BMlAdIID2In93/+5hKJjpHqMfNKx92E8kWce/LZhkNoZ4qkVl5gF", - "4TJ1GKCEyKIA639LQpZQcpRzQSOaHwvuFGwUR79UUOEPrtO5uOz8JF+Lph95fdhM0nuAv2mWyqFo1F08", - "iqMlx4B9lCs9cl6pCTprL1TyGpks6IkbsE1+JmbOjjB1CZqdqPQC7NFLshUUnaRzLmfO836uNJOwdA9N", - "zM4XGi6FqswZsfA5mQwXjL8nW0aatq827kjEa3XZn+hHXnbDi3Ck3QP6VkqimxVs4r8H0/iTU4S92Tcn", - "BzfpptNaJbk9F9xYRkM/Q0MN9JL/qrP5DYbF/FsFGlHTUQmYvYsOHjjj2Kq1TYriKo4wdXOWrDC9OdCR", - "9a8zIXtC28iLF8i3V4OAggD5EJVCitLJ/E7Y5H+28n0uCucAJa3yjWtV+v3Rv37batJgEkbluYE+oEH+", - "avH04RaZTbOlzty0o07Qam6zqw7V1nn4FdhKS4r6nV6h3C2vHWb0hl1477bQS+PeUq46Ec5m7n0Fxid+", - "B6HW9lEWuUs3BlbhCMRHe0+VzMWs0twGnUUz5yWX36KfmwXz55R+mgM7waHM2QlmNZcmB80Oj48wZ1LH", - "g+Nwxs0qzWfwvUp5OFn9rMm4YHjhPAPHIbiW/3h8o9pZXyVe210IS69gJowFDRkFjUMM8SzTYMJS4TTl", - "GeqOfoWnY11EerE57Cy4deo1nIVQuV1yvSFFsZVRoC21/NukBM6aao25ndh/VnWpwUXcILVbZaqREUcp", - "pfAQymgdyx3MbNhRiM4nkFbO5jRxeZ/IWwdo10VmJCBP55BeqCpQ9DkhTwkdLVJOdg5Cs5PvDncfPGSp", - "+9BUZcyM+BXzdMnKgqGYNQPjQGCFZ+46uE/9am3Ocs2VJrfORWiYcTyI2nT6eKZIRqKDaO9BMt1/spPu", - "Pkqme3t72U6e7D/I0+mjx0/4zm7Kpw+Tnezh/jTbffDwyaPH0+Tx9FEGD6b72aPp7hOYuonErxAd7Ozv", - "7mOIR6sVajYTctZd6uFe8mg3fbiXPNnf3c+znb3kyd6jaZ48nE4fPpk+nqZ7fOfBo51Hab7Hs/393Yd7", - "D5Kdx4/Sh/zxkwfTR0/apXYfXQ3tc42RYwRgUPXhdu48Uk3ZBK8kfYK7V+Go5xmzI1+sLrhzEuq0gVeH", - "DQEwVcwNS73ChYwp2V1kzI4kU0UGmvkA29Qepp8L111yw95VhiqVb5rtsKNnb6KYJZVtLJmfhYkmG8IJ", - "CsxXnHvfaGSKajYxKUgYOembUEFpdPTsvJe3b4Xes8yWRopgfy4KOFlAeqO9osnjPplulqbWng6rnBrf", - "URCyRpVQqfgT2MNH2+uMcYp/EuozkeegMZE055It59wiKZtwLHbM0Z0UYxyQptKOcL7M14oxJtKQnHfC", - "fCFSryeftiNJQ+qhgltAKnLhNRTSAy2411Ue6I4975NmESRJbc5rWenOWEMcTN3MeQDCvqrtzhmcA/XM", - "h6EXC30dHUj6rfsmc17rrThabIfgn4Sdt/mFrVAd+3Rpiuos2YD6mLnwW9mYZbAAmWGLhcRSCpnjf3Da", - "bOs/dcjhfagbqdqNMK8j7yBtVMkLqZYSA+dC8YySPI5gPc+13T9N9oqgwWr+K1I1n+x4oKPRw91GX+Ke", - "nIYv4iB8AfO2mfh9elGBJGzViFq5ViXjTHc+q01K3CWlD3JVX9xBXzq/4zlORcUfDQwZzVkSP8w9qxNt", - "tCAVWtri1JfigVYwG3m4H7boLtSI2x3zSkd9fy7XUDtcX3Gsibin/21t7l0pwmuUXrf4EyzztxFJ2xXm", - "2LOudK1x4Db5v88vFPgXex//g/31Tx///PEvH//r45//+qeP//3xLx//s5vExLRtNx3mVzlLyyw6iD74", - "P6/Q563kxRkx4Z7bk9U8tWe8yoSqE2aOeD52mmj8cmLyyTuVGPLhd3b3xjhlNzV7/OMf3J8LEx04Ico1", - "Lx15o53RjhMwUfIZmDOlzy5FBsqZQnwSxZGq7KKy1JIC7y1IqhBG4wXaH4LgzI8awkUrNZBNwujyvTOD", - "+bRS9tr5OoJjhKP/yGNzRJ9EA4HtMscNqbWmPLZt++5NifoOD9yUUqyHbk7Wh7sOtsmgd7qFb1GWagpQ", - "TQbcqNy2BapAucmXqkLOiYNhU82ofcewl01alqwY910bTvApXU/tkKTX3lTT6e5DVqiZ13HYSI6FfOr9", - "8G2Xa6m7TmauD8NLCaNCSN956DsOMGj7xrC06SCbY6uXc49rU4sLj9nLS9BLp3AMq8tAxYr2Ui/aFEpD", - "zmuhZiFvesYcUJ1OV7da3FTD6sYzBzSiAhcErgtB7S7D/F2PF7btMQ9ltok6lC7dlEz+jGQnpJqKFcNX", - "n5m0XLdUtFIv3xhcopOvfLsRHydiJl/eFhN1/vJsc0PGnW+7k3vdsNsBVNfs2nILT7GWG6goUIWmVRS3", - "SlIH/YrOZFsBlW2C6g5guQGCvtI1lmtLkRxf8gvMfJsCYOE8GsxEu1i4shlFfhaMH63y3GmCgG4lYcFc", - "9omDmra3RADOeBWK0l8b0I72Tt06FUaD2dGzmC24MUuls/oVSQedmGDc1kN1R+ydnkF8YY2HG5G2imdu", - "7SK6cjAKmStqZJOWp7btS2r6l9gpcCd8lS78l+ZgMslrn0+oybAi+opamZ9zXbLSp9EOj4+iOCpECj6U", - "8uv84fj7y73B/MvlcjyTlXMBJ/4bM5ktitHeeDoGOZ7bkvpEhC160Prlok4bVbQzno6nWENdgOQL4fxF", - "fETJAKTMhC/EJF0vws1I2TkOxWdHGTYH2n61zvEfBWE41e50WqMUJH7PF4vC54Am7wxNTbx8E6cHq4NI", - "uT7GpXMxiyYYJP6rypLrFUFMuZ7uNE1XYqff1HLnF/2M7hnW1Ns5vpXZQglp0ejNfNf5YMKGDs2kVzHh", - "tq6oLpQJ4JSiD2oF8Vrk9ypb3Rke+61tQ/xhG7PycU3UVSjO3b+6RwpfA9CSG2aqNAWTV0WxYnSIBjtG", - "vTt0KbKKF3TuZrx2kulOoKM6XAA+fMHqMluf3QjZjNetQ8gy65zR6Qfuch7VyXvTvajPS9DxH/CM2Get", - "yS91M0qYwbDa/8JNfj8M1vbDBJA1yAJT9he7H6xy0jT+0jzXa38IgPwjKRTEaqNW4rqKAuXCrlghjGUi", - "Z1JRK27JbTrH8gvQh18PSz4Hm84JYOq+Nzcw3csE26DbBpUce2LwyJvMmFG6Od7X8mDj/W2yG83BgHsk", - "7vAUQgBXzaD2JELAZhSD0wrYyI+ZzP5hjmsw2S7VqIB37RHRHv4+vFPJmciuNqIQyUhWonsW4OcPkXC7", - "8ql971nQZAPBijt4vKk/4u3fRvGjVxZiYPeC8YQO0yHtttCd9JHMvG9UOshrtHdCm008+8emy/zeULHe", - "K//JDk7DYXXNfc3Hud7FeYonDKhUXBnfX2AVFV7oL2EYT23FnTnm7XI+g9+glfzxifZdS6Nl27QUtE51", - "e5NvbrofExVIDQQQ3aZ3aui/qGkaNHptwwtf0MhUEt4vILWQ0QmcNUaswffOz7KmZ811/sHbwEetE91+", - "adY5yoiZHKk8v8aTFjP5Ms+H4ro/jDi/PkT6kBlVei9Y/vmtU8Ytzn7g+qIbJXPD6mD8Bmw/5YU/70Ac", - "hiJeeAVSO6cXEg/xwuobDWym6HIDnH4cJom8gSLyXoXaL7FZnJt8+5eU5WEW6u9CmLfmwcPKzkFaSkr7", - "1Lfjhrqot2zON94xQ2rg2cqNcvNR42EvHS9agg/Z1fpsf9Ded0gW/a05AyH1Z1Ha/iy3nw3KjG3+4utm", - "qduzB7kky7btWwPdDLDagIQwH4zSTiI2qLwCSdt7VWTdhUJhaWMaaZ9b6LN/LLvn9bmnGyGh7nCsm8m4", - "c1KdwiggI3+finFel7TFwR6vYLeZkO15YK9fQI8KlfICVRsvzF3rs0vo7aYyA1a1/taqDeY1nUNWFXBK", - "Xej3F1d379AKEBZvz+omtTYpqh+Vvyinf+cFxhf1kfirONqf7t1d+rPXVh8A/hh0nV97BlKQ0tyfPgkc", - "NSEG9Ee2vaWjqjWxU8yMql/jfUPQO/tPW8f2DybVkra6u/dlTUstRVw6KBXlepzbjdBR+zZe0TFTeG2S", - "VKhnSdpuKbE+k8Sb+TvYuEmUkKeMZ3AdSH12JGTyAeuEPn0SlpVOvX+bDIqf8PNTKHdvLjo72SSL3h/q", - "XJHwadbidA71XEtUrSksaosaFJFT33+AFtlrjS4bEdFiuumhNzfKTHf+vxez9LptBaFeCLtaiBTTJN3O", - "jYVWMw3GxP5Aur8tSrOci6LScKNtqS2KAZn1smEO3fXsTos5j4jEhA6XTeo+5wkdErjGnvSPB91TPaq/", - "SKhm0G0Gbjw+f1biy8VwweMdAXDrEcjG9TmMTvGqKy33y8kNJLygOAmvpzPe0OzfPwCn6I0v3X9EPbSs", - "cjZmrw2wc7OG0bZj+NzRmc6FMEQlVomUBDP+mnJcT+n0Vef+LQpBzaoshLxorn/Bg3CEASpYWjos45Hi", - "zCsvCjbnl0B3DVKLL+lK3xCbQI7XV/CiaG4sbK1gqywIqWvK4sQDxJnpChMC0zuUxzXwsLLoNnRvqzK6", - "JL1X9RE6VLCtJvkbKJFgT30I3uayCrwWSWGk0iVEXBuU+hoh34ROW/y6ZAXPbLQH3ro48CeB/L1ZSlvj", - "JZ4oxXWzsRs5/dD52W6Z9pKkOkPQn7ANOfwRBKpcEBStvqFb5KwoihaEjnjgfJMP9YGUq8kHfCJ+hc2l", - "u25vutLw1DPhmhO69VEjvBlg6LHWQ691WQetWsNrbX+F9bNSzUGbwKr17rdZtT159vbeJW5wHmFzob89", - "RvK1SU+3v7g9NxE8QUOHJ4eCcp3Wbjjy/zczxqEgxmuT9qo3uvmNzjFnkINmzbEcss2IDbTyb6Ld6eM3", - "0dr1chhuy2Ll74SrtOzeUkfbM43nRm1PzTmoAcEpUOeFUTSHUSUoCQwKuumu7RAPgYncggika+haFP77", - "iJYZPeVy9Mztc/QaJ4gCOOxcpBrCodJiJiQvcE03/5gd5b4FvVDdlvXmvJiwTSv5+iWBtG/sKm/OkHLJ", - "uMARGSQVnePfYm8vPWCj5x6w6Dq23DqMV6kFOzJWAy/7GqLJFCRCOvke5gqGvjytYdYOmX5iEI/sNQjh", - "d6ePbxru2bHHiJ2S//7Oo+AM2n/uAgDsjWIJ2CV4Zq9vSGyVTt1d41sM/LUqKP56oHcaZ7nmZQxvHgTu", - "syMh9lcn3CC1tQS2klPfTqlVCgYJkYD7sFk/WfXkjlyJ840idMAczc6puZG0SxcdfidfiwVCy+Bzd5vt", - "DvtRYfKD2+FLlM9c6VQkxYqlhTKUJsELNVMlJeAtb/76NZ8h8oo3F1KYOZgevYDBe55aZngJ3oW0Co+3", - "uE8yVTnvjj4w4zeypuo3eOsASZPnhQRCFGCJylYbTWk35YPXlTZhxRAtPofkfpNBpR7vSdSpeQ2uWu93", - "OA26RoU1UOTjVp9hH89Q9b5QSV2SxdzQLxVoASbudJLGa01R417rmAlMenh81O9l7VbkVFlW0h9Qcip9", - "2ArdTO9TWwFbT/g7PD6KcSFkuZb4fkOYXnF/0119FHWazvyeXldvr/4vAAD//zuOfr8UZAAA", + "H4sIAAAAAAAC/+Q823LcOHa/guKmyrsV9kUXW7aeorXHO3JmbMWSd1I1dkkgedgNiwQ4AKh2j0tV+xH5", + "k2Sr8pB9yg94/ygFHICXJlrdsiWvd+MHV4sEgYNzvwEfo1SUleDAtYoOP0YqnUNJ7c8jpdiMQ3ZG1aX5", + "OwOVSlZpJnh02HtLmCKUaPOLKsK0+VtCCuwKMpIsiZ4D+UnIS5DjKI4qKSqQmoFdJRVlSXlmfzMNpf3x", + "TxLy6DD6zaQFbuIgmzzFD6LrONLLCqLDiEpJl+bv9yIxX7vHSkvGZ+75eSWZkEwvOwMY1zAD6Ufg08Dn", + "nJbhFzfPqTTV9cbtGPyd4kizI6ou1wNS1ywzL3IhS6qjQ3wQrw68jiMJv9RMQhYd/uwHGeS4vTSwdbaw", + "gqUOSrpQxS293jXriuQ9pNoAeHRFWUGTAl6I5BS0NuAMOOeU8VkBROF7InJCyQuREDObCjDIXLAUf/bn", + "+WkOnMzYFfCYFKxk2vLZFS1YZv6vQREtzDMFxE0yJq94sSS1MjCSBdNzgkizi5u1GxYcIH+V2TLIaV3o", + "IVxncyDuJcJB1FwsuAOG1AokWRjYM9AgS8bt+nOmPErGOH1nzvASzZOJFqLQrHILMd4uZPhR5jQFOylk", + "TJut44wO/pwWCuIhcvUcpAGaFoVYEPPpKqCE5tqMmQN5LxIyp4okAJyoOimZ1pCNyU+iLjLCyqpYkgwK", + "wM+KgsAHpnBCqi4VyYXEqd+LJCaUZ0aBiLJihRnD9Pgtbxk9EaIAyu2OrmgxxM/JUs8FJ/ChkqAUExb5", + "CRAzuqYaMoMjITPcoKcD2J30SdfA1dAmHrLGJSyHMBxnwDXLGUg3ScPyMSlrpQ08NWe/1MiIjmjvnSAE", + "1zGCQeUsIAtHfEngg5aUUDmrS6NhPL8l1XJsPlTjU1HCCcrW8re/I6khQ60gMyNTCVQDbtXJ37IDQyvi", + "rWa5BQuxsoSMUQ3FkkgwUxFqt5pBzjgzH8RGEdjlzZKxxYmotYOISs3SuqCyocMaflB14tXnTVo3oKhO", + "3ZeNqN96hjP3+RVTbFXItKxvQpAR3L5oOX54c4wK0iDLi5Ukvy3YJRBKfl8AN0xMs2wk+O/G5BS0me7C", + "EuQC1QzaY8pRF3BaNGvoOdVm6brI+APLkI2mAp5ZBaLCiF4xMUYA3KAtzcJpS6cV61AnI/MG2QEFwtOc", + "PK2lBK6LJRFGj1M/r5WwjiZXY3Lx/dHp9989O39+/MN35ydHZ99foJeSMQmpFnJJKqrn5J/Jxdto8hv7", + "7210QWhVGZRmuG3gdWn2l7MCzs34KI4yJv1P+9hZ1DlVc8jO25HvAgK8jmmGCt5hoLP7jtZA80UVOX7m", + "5dlu2zCNY4kxeSkIB2V0ndKyTnUtQZHfWvOlYpKx1CxFJQP1O0IlEFVXlZB6desO+Nh4Nnu7ZtOFoDqK", + "LS9s3GR4d97at2uil8gU+ZFyOgOJJoBpK/q0NAo64BoUNIHidi6bQ+b27mbIpRl4Ayvi4FgCweusuUk2", + "DLYCyv0HprRnBsvd6/E2xJF34z5vx2c9jbhmu+0SoQ16f32wLfeCSDBW2posShQ6h87LtJroA6S1hk1x", + "xHonvWGgzmsPXphwnU9CO/pOSiGH+/kDcJAsJWBeEwmqElxBKOLJAjLx/dnZCUG3nJgRjTlsJiLHijCe", + "FnWG/ovBRkWXhaAZUQKVeYNAhLaHW+N0WdAYxwCCCT5+y5+axR5O94x6tN6ANRrWE6KaJlSBeZPUajkm", + "xu+0gHqgyIIVBUkF15RxQsmD16DlcnRk/MIHOHQO1PpZBjzGM5ZSDcp5jos5S+dEsxJdL0MKUJqklBs9", + "J0FLZpzI58K4oGixwE/IFOFCE8Mm1OhzrzIeKFJX3vlJCwbcmsRMECVKMI7WjEigSnCrRa0lhQ8oBIwW", + "JKHppchz1IJNpOW13zDMK0EpOgvx3gpzWbq340Oc9bygJfBU/BGkco7/llx+1X5xMxR+oNORISheYBhN", + "i+JVHh3+fLO2OPW+vvnqOl4FGP3KkPSbF9YzZyUoTcuqi+6MahiZNyE3mAWme/Pm+Jl3GV7YSHdDkLxt", + "fG7UfhOe11V2x7tZoY6F1OOsXa8B9t31OyTQj6CpkU9LqCyzLjQtTnq4H+x4JWaQCdOSyiUp3WTOhVJj", + "8qOQVglXBXzo+g9OMkthYjlrfWqjcMgFHSfj9MJIJOLBhzyXYMMI+EDNXI6hLaMdRqeVZBrIc8lmc+NR", + "GH9zDCVlhYF6mUjg/5I4d0bImR+BMhCd2gHkVP/v/1xB0TFSPUY+7dj7MJ7QMw9+2zCId4ZoqtmVzYJQ", + "nhoMYEKkKkC73xyRxQQf5ZThiOZHRY2CjeLolxpq+4PKdM6uOj/R18LpR04fNpP0HtjfOEttUDTqLh7F", + "0YLagH2UCzkyXqkKOmsvRPLGMlnQE1egm/xMTIwdIeIKJDkV6SXo41doKzA6SeeUz4zn/VxIwmFhHqqY", + "XFQSrpio1Tmy8AWaDBOMf0Bbhpq2rzbuSMS9uuxP9JKW3fAiHGn3gL6VkuhmBZv47+E0/uwUYW/29cnB", + "dbrpzKsks+eCKk1w6BdoqIFecl91Nr/GsKh/q0Fa1HRUgs3eRYcPjXFs1do6RXEdRzZ1c54sbXpzoCP9", + "r3PGe0LbyIsTyHfXg4ACAfkYlYyz0sj8Ttjkf7Hyfc4K4wAlrfKNvSr94fhfv2s1aTAJI/JcQR/QIH+1", + "ePp4i8ym2lJnrttRJ2hVt9lVh2qrPPwadC05Rv1Gr2DulnqH2XrDJrw3W+ilcW8pV50IZz33vgblEr+D", + "UGv7KAvdpY2BVTgCcdHeU8FzNqsl1UFnUc1pSfl31s/NgvlzTD/NgZzaocTYCaIl5SoHSY5Ojm3OxMeD", + "43DGTQtJZ/CDSGk4Wf2sybjY8MJ4BoZD7Fru4/FGtbO6SryyuxCWXsOMKQ0SMgwahxiiWSZBhaXCaMpz", + "qzv6FZ6OdWHp5fqws6DaqNdwFkLkekHlmhTFVkYBt9Tyb5MSOG+qNep2Yv9F1aUGF3GD1G6VySMjjlJM", + "4Vkoo1UsdzCzZkchOp9CWhub08TlfSJvHaDdFJmhgDydQ3op6kDR5xQ9JetooXLSc2CSnH5/tPvwEUnN", + "h6ouY6LYrzZPlyw1KIxZM1AGBFI45vbBfepWa3OWK640unUmQrMZx8OoTaePZwJlJDqM9h4m0/0nO+nu", + "QTLd29vLdvJk/2GeTg8eP6E7uymdPkp2skf702z34aMnB4+nyePpQQYPp/vZwXT3CUzNROxXiA539nf3", + "bYiHqxViNmN81l3q0V5ysJs+2kue7O/u59nOXvJk72CaJ4+m00dPpo+n6R7deXiwc5DmezTb3999tPcw", + "2Xl8kD6ij588nB48aZfaPbge2mePkRMLwKDqQ/XceKQSswlOSboEd6/C4ecZk2NXrC6ocRJ82sCpw4YA", + "NlVMFUmdwoWMCN5dZEyOORFFBpK4AFt5D9PNZdddUEXe1worlW+b7ZDjZ2+jmCS1biyZm4WwJhtCEQqb", + "r7hwvtFIFfVsolLgMDLSN8GC0uj42UUvb98KvWOZLY0Uwv6cFXBaQbrRXuHkcZ9Mm6WptafDKqe07zAI", + "WaFKqFT8Gezhou1VxjizfyLqM5bnIG0iaU45WcyptqRswrHYMEd3UhvjAFe1NIRzZb5WjG0izZLzTpgv", + "ROrV5NN2JGlIPVRwFaQsZ05DWXpYC+50lQO6Y8/7pKmCJPHm3MtKd0YPcTB1M6cBCPuqtjtncA6rZz4O", + "vVjo6+hA0m/VN5lTr7fiqNoOwT8xPW/zC1uhOnbp0tSqs2QN6mNiwm+hY5JBBTyzLRbcllLQHP+D02Zb", + "/6lDDudDbaRqN8K8ibyDtFHNL7lYcBs4F4JmmOQxBOt5ru3+cbLXCI2t5r9GVfPZjod1NHq4W+tL3JPT", + "8FUchK9g3tYTv08vLJCErRpSK5eiJJTIzmfepMRdUrogV/TFHeSV8Tue26mw+COBWEYzlsQNM898og0X", + "xEJLW5z6WjzQCmYjD/fDFt2FGnG7Y17pqO8v5Rpsh+srjhURd/S/rc29K0V4g9LrFn+CZf42Imm7wgx7", + "+krXCgduk//78kKBe7H36T/IX//06c+f/vLpvz79+a9/+vTfn/7y6T+7SUybtu2mw9wq52mZRYfRR/fn", + "tfV5a355jky4Z/akJU31Oa0zJnzCzBDPxU4Tab+cqHzyXiQKffid3b2xnbKbmj15+QfzZ6WiQyNEuaSl", + "IW+0M9oxAsZKOgN1LuT5FctAGFNon0RxJGpd1RpbUuCDBo4VwmhcWfuDEJy7UUO4cKUGskkYXa53ZjCf", + "FELfOF9HcBQz9B85bI7wk2ggsF3m2JBaa8pj27bvbkrUd3hgU0rRD12frA93HWyTQe90C9+iLNUUoJoM", + "uBK5bgtUgXKTK1WFnBMDw7qaUfuO2F42rkmyJNR1bRjBx3Q9tkOiXntbT6e7j0ghZk7H2UZyW8jH3g/X", + "drmSuutk5vowvOIwKhh3nYeu48AGbQ8USZsOsrlt9TLusTe1duExeXUFcmEUjiK+DFQscS9+0aZQGnJe", + "CzELedMzYoDqdLqa1eKmGuYbzwzQFhV2QaCyYNjuMszf9Xhh2x7zUGYbqYPp0nXJ5C9IdkIqsVgxfPWF", + "SctVS4Ur9fKNwSU6+cp3a/Fxymb81W0x4fOX5+sbMu58253c65rdDqC6Ydeaanhqa7mBigJWaFpFcask", + "ddCv6Ey2FVDZOqjuAJYNEPSVrtJUaozk6IJe2sy3KgAq49HYTLSJhWudYeSnQbnRIs+NJgjoVhQWm8s+", + "NVDj9hYWgHNah6L0Nwqkob1Rt0aF4WBy/CwmFVVqIWTmX6F04IkJQrUfKjtib/SMxZet8VDF0lbxzLWu", + "omsDI+O5wEY2rmmq276kpn+JnAE1wlfLwn2pDieT3Pt8TEyGFdHX2Mr8nMqSlC6NdnRyHMVRwVJwoZRb", + "5w8nP1ztDeZfLBbjGa+NCzhx36jJrCpGe+PpGPh4rkvsE2G66EHrlos6bVTRzng6ntoaagWcVsz4i/YR", + "JgMsZSa0YpN0tQg3Q2VnONQ+O85sc6DuV+sM/2EQZqfanU49SoHb72lVFS4HNHmvcGrk5U2cHqwOWsr1", + "Mc6Ni1k0wSDyX12WVC4RYsz1dKdpuhI7/aaaGr/oZ+ue2Zp6O8d3PKsE49oavZnrOh9M2NChmfQ6Rtz6", + "imolVACnGH1gK4jTIr8X2fLO8NhvbRviz7YxCxfXRF2FYtz963uk8A0ALagiqk5TUHldFEuCh2hsx6hz", + "h65YVtMCz92MV04y3Ql0WIcLwGdfEF9m67MbIptQ3zpkWWaVMzr9wF3Owzp5b7oX/rwEHv8Bx4h91pr8", + "4ptRwgxmq/0vzOT3w2BtP0wAWYMsMGZ/bfeDFkaaxl+b53rtDwGQX6JCsVht1ErsqyhQVnpJCqY0YTnh", + "AltxS6rTuS2/AH747bDkc9DpHAHG7nu1geleJbYNum1QyW1PjD3yxjOihGyO97U8aMzr5KP5/yUt4fom", + "C+Ib8vtN7T9/jJjZistROxPpJxzwSNxB2ar/8e4e+Wd4rGCNRsV3q6bI9bX7MxBrzofcQJxjngtCE1Hb", + "LnknXJ3zdgOiqC1IoaKviDEVQlkzqD0eEsBeMThCYk9X2PTy1hhsl2r08vv23G4Pfx/fi+ScZeu52coW", + "mu7NvIyT3cjJm5pW3v1trLF1lUNahbXc6NpQtzBo+BHPnMNaGsg92jvx5jqe/WPT+n9vqFg9wPDZXmfD", + "Yb4RYsXxvNnvfGqPfWD9vlau6UMLrIbhX0wRmuqaGh+Jtsu5skqDVgySJtK1ko0WbSdZ0GXwPWeu4+x+", + "/IZAviaA6Dbn5qH/qv7CoPtuG174ipa/5vChglRDhseiVhjRg+880oWnp+c69+Bd4KM2smm/VKscpdiM", + "j0Se3xDesBl/ledDcd0fpgG+PUS6PIZV6b0Mxs/vjDJucfYjlZfd1AVVxGdINmD7KS3cIRTkMCvihVMg", + "PmK45PZkNSwfSCAzgTdO2OnHYZLwDRTh9yrUbon14twUQb6mLA9Tg38Xwrw1Dx7Veg5cY6XA1SMMN/hK", + "66I5dHrHDCmBZkszysyH3aC9GglrCT5kV+1KMEF73yFZ9LfmDAupOyDUNs2Z/axRZmT9F982S92ePdAl", + "WbS9+BLwuoblGiSE+WCUdrLjQeUVyKTfqyLrLhTKFTSmEfe5hT77x7J7Tp87uiESfNup7/Cjxkk1CqOA", + "DP19rJA6XdJWbHu8YlsAGW8PaTv9AnJUiJQWVrXRQt21PruC3m5qNWBV7a4SW2Ne0zlkdQFneDTg/uLq", + "7sVmAcLaK826mcZ1iuqlcLcX9S8isfGFv6fgOo72p3t3l5PunXUIAH8C0ic9nwFnqDT3p08C53+QAd05", + "emfpsJUA2SkmSvjX9hIo6F3IgFu3PTmEiwVudXfv65oWL0WUGygFJuCM222hw556e2/KTNi7rLiwehal", + "7ZYS69J7tJm/g41NomR5SjkGl4F8dEdCJh9t8dalT8Ky0mnC2CobiBN+eQrl7s1FZyfrZNH5Q517Kz7P", + "WpzNwc+1sKo1hcpb1KCInLmmEGuRndboshESLcbrN3pzW5npzv/3YpbetP052KCilxVLbZqk205TSTGT", + "oFTsbglwV3hJklNW1BI22hZvURTwrJcNM+j2sxstZjwiFBM88TfxzecTPLlxgz3pn9m6pyJhf5FQIafb", + "od14fO4Ay9eL4YJnbgLg+hGWjf3hmE5FsSst98vJDSS0wDjJ3hmonKHZv38Azqw3vjD/IfWsZeWzMXmj", + "gFyoFYy2bdwXhs54WIdYVNrSneCgxt9SjuspHonrXIqGIahalgXjl82dPPZ0ImIAq8gaTzA5pBjzSouC", + "zOkV4AWQ2HeNutJ1KSeQ2ztFaFE010i2VrBVFojUFWVx6gCiRHWFyQLTOylJJdCwsuh22W+rMrokvVf1", + "ETrpsa0m+RsokeBBhxC8zQ0i9q4qYSOVLiFib1D83U7uZABu8duSFXuQpj2F2MWBO57lLjMTUisn8Ugp", + "KpuNbeT0I+Nnm2Xam6t8hqA/YRtyuHMhWLlAKFp9g1f7aVYULQgd8bDzTT76U0LXk4/2Cfv1hkJ098CA", + "kPDUMeGKE7r1+S97XcPQY/VDb1W/jod3Df8KqwfYmtNPgVX97rdZtT0O+O7eJW5wSGR990V7tudbk55u", + "03d7mCV4rAlPtA4F5Sat3XDk/29mjENBjNMm7f17eB0fHi7PIAdJmrNSaJstNqyVfxvtTh+/jVbu/LPh", + "Ni+W7qK+WvLu1YG4PdV4btiL1hxOGxAcA3VaKIFzKFGC4ECgwOsH27b9EJiWWywC8W7AFoX/PsJlRk8p", + "Hz0z+xy9sRNEARx2brcN4VBINmOcFnZNM/+YHOfuXEAhuucImkN8TDf9/as3N+K+bat/c7CXckKZHZFB", + "UuPlClvs7ZUDbPTcARZt7PHZxpERqQY9UloCLfsaoskUJIwb+R7mCoa+PK6hVk7+fmYQb9lrEMLvTh9v", + "Gu7YsceInZL//s5BcAbpPjcBgG1YIwnoBThm99dWtkrHd9e4FgN3140VfznQO42z7HnZhjcPA5cMohC7", + "+yw2SK2XwFZy/JWhUqSgLCESMB826yfLntyhK3GxVoQOiaHZBXaconbposPt5FuxQNYyuNzdertDXgqb", + "/KB6+NLKZy5kypJiSdJCKEyT2FtOU8E52Kv33J14LkPkFG/OOFNzUD16AYEPNNVE0RKcC6mFPXNkPslE", + "bbw7/ECN33JP1Qf2KgiUJscLCYQoQBKRLdea0m7Kx94h24QVQ7S4HJL5jQYVG+8nUafmNbj/vt/hNGjl", + "ZVpBkY9bfWb7eIaq94VIfEnW5oZ+qUEyUHGnvTdeaYoa91rHVGDSo5PjfoNxtyInyrLm7tSYUenD/vRm", + "epfaCth6xN/RyXFsF7Is1xLfbcimV8zfeIEiRp2qM7+j1/W76/8LAAD//1fmENKpZQAA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/web/app/src/manager-api/ApiClient.js b/web/app/src/manager-api/ApiClient.js index df72dfdb..f990c950 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/61618531-dirty / webbrowser' + 'User-Agent': 'Flamenco/70584ce9-dirty / webbrowser' }; /** diff --git a/web/app/src/manager-api/manager/JobsApi.js b/web/app/src/manager-api/manager/JobsApi.js index 0c520b0c..3a3b3d0f 100644 --- a/web/app/src/manager-api/manager/JobsApi.js +++ b/web/app/src/manager-api/manager/JobsApi.js @@ -13,6 +13,7 @@ import ApiClient from "../ApiClient"; +import AvailableJobType from '../model/AvailableJobType'; import AvailableJobTypes from '../model/AvailableJobTypes'; import Error from '../model/Error'; import Job from '../model/Job'; @@ -86,6 +87,52 @@ export default class JobsApi { } + /** + * Get single job type and its parameters. + * @param {String} typeName + * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/AvailableJobType} and HTTP response + */ + getJobTypeWithHttpInfo(typeName) { + let postBody = null; + // verify the required parameter 'typeName' is set + if (typeName === undefined || typeName === null) { + throw new Error("Missing the required parameter 'typeName' when calling getJobType"); + } + + let pathParams = { + 'typeName': typeName + }; + let queryParams = { + }; + let headerParams = { + }; + let formParams = { + }; + + let authNames = []; + let contentTypes = []; + let accepts = ['application/json']; + let returnType = AvailableJobType; + return this.apiClient.callApi( + '/api/jobs/type/{typeName}', 'GET', + pathParams, queryParams, headerParams, formParams, postBody, + authNames, contentTypes, accepts, returnType, null + ); + } + + /** + * Get single job type and its parameters. + * @param {String} typeName + * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/AvailableJobType} + */ + getJobType(typeName) { + return this.getJobTypeWithHttpInfo(typeName) + .then(function(response_and_data) { + return response_and_data.data; + }); + } + + /** * Get list of job types and their parameters. * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/AvailableJobTypes} and HTTP response