release 0.0.9-beta source code

Author: unionsdk

CHANGELOG.md

@@ -1,3 +1,30 @@
+# 0.0.9-beta 2023-08-26
+
+### G42Cloud SDK SMS
+
+- _Features_
+  - New Support SMS
+- _Bug Fix_
+  - None
+- _Change_
+  - None
+
+### G42Cloud SDK MPC
+
+- _Features_
+  - None
+- _Bug Fix_
+  - None
+- _Change_
+  - **CreateThumbnailsTask**
+    - changes of request param
+      - `+ thumbnail_para.dots_ms`
+      - `+ thumbnail_para.type: enum value [DOTS_MS]`
+  - **CreateTranscodingTask**
+    - changes of request param
+      - `+ thumbnail.params.dots_ms`
+      - `+ thumbnail.params.type: enum value [DOTS_MS]`
+
 # 0.0.8-beta 2023-06-26
 
 ### G42Cloud SDK MPC

LICENSE

@@ -0,0 +1 @@
+0.0.9-beta

README.md

@@ -5,16 +5,78 @@
 
     <parent>
         <groupId>io.github.g42cloud-sdk</groupId>
-        <version>0.0.8-beta</version>
+        <version>0.0.9-beta</version>
         <artifactId>g42cloud-sdk</artifactId>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <packaging>jar</packaging>
     <artifactId>g42cloud-sdk-core</artifactId>
-    <version>0.0.8-beta</version>
+    <version>0.0.9-beta</version>
     <name>G42 Cloud SDK for Java Core</name>
     <description>Core library for G42 Cloud Java SDK</description>
     <url>https://github.com/g42cloud-sdk/g42cloud-sdk-java</url>
 
+    <dependencies>
+        <dependency>
+            <groupId>org.yaml</groupId>
+            <artifactId>snakeyaml</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-jsr310</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-jdk8</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okio</groupId>
+            <artifactId>okio</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>okhttp</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.openeuler</groupId>
+            <artifactId>bgmprovider</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk18on</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.github.tomakehurst</groupId>
+            <artifactId>wiremock-jre8</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
 </project>

VERSION

@@ -35,6 +35,7 @@
 import com.g42cloud.sdk.core.http.Field;
 import com.g42cloud.sdk.core.http.HttpClient;
 import com.g42cloud.sdk.core.http.HttpConfig;
+import com.g42cloud.sdk.core.http.HttpMethod;
 import com.g42cloud.sdk.core.http.HttpRequest;
 import com.g42cloud.sdk.core.http.HttpRequestDef;
 import com.g42cloud.sdk.core.http.HttpResponse;
@@ -157,12 +158,12 @@ public HcClient preInvoke(Map<String, String> extraHeader) {
         return client;
     }
 
-    public <ReqT, ResT> ResT syncInvokeHttp(ReqT request, HttpRequestDef<ReqT, ResT> reqDef)
+    public <R, S> S syncInvokeHttp(R request, HttpRequestDef<R, S> reqDef)
             throws ServiceResponseException {
         return syncInvokeHttp(request, reqDef, new SdkExchange());
     }
 
-    public <ReqT, ResT> ResT syncInvokeHttp(ReqT request, HttpRequestDef<ReqT, ResT> reqDef, SdkExchange exchange)
+    public <R, S> S syncInvokeHttp(R request, HttpRequestDef<R, S> reqDef, SdkExchange exchange)
             throws ServiceResponseException {
 
         if (Objects.isNull(exchange)) {
@@ -206,12 +207,12 @@ public <ReqT, ResT> ResT syncInvokeHttp(ReqT request, HttpRequestDef<ReqT, ResT>
         }
     }
 
-    public <ReqT, ResT> CompletableFuture<ResT> asyncInvokeHttp(ReqT request, HttpRequestDef<ReqT, ResT> reqDef) {
+    public <R, S> CompletableFuture<S> asyncInvokeHttp(R request, HttpRequestDef<R, S> reqDef) {
         return asyncInvokeHttp(request, reqDef, new SdkExchange());
     }
 
-    public <ReqT, ResT> CompletableFuture<ResT> asyncInvokeHttp(ReqT request, HttpRequestDef<ReqT, ResT> reqDef,
-                                                                SdkExchange exchange) {
+    public <R, S> CompletableFuture<S> asyncInvokeHttp(R request, HttpRequestDef<R, S> reqDef,
+                                                       SdkExchange exchange) {
 
         if (Objects.isNull(exchange)) {
             return CompletableFuture.supplyAsync(() -> {
@@ -227,7 +228,7 @@ public <ReqT, ResT> CompletableFuture<ResT> asyncInvokeHttp(ReqT request, HttpRe
         try {
             httpRequest = buildRequest(request, reqDef);
         } catch (SdkException e) {
-            CompletableFuture<ResT> future = new CompletableFuture<>();
+            CompletableFuture<S> future = new CompletableFuture<>();
             future.completeExceptionally(e);
             return future;
         }
@@ -254,52 +255,48 @@ public <ReqT, ResT> CompletableFuture<ResT> asyncInvokeHttp(ReqT request, HttpRe
         }, httpConfig.getExecutorService());
     }
 
-    protected <ReqT, ResT> HttpRequest buildRequest(ReqT request, HttpRequestDef<ReqT, ResT> reqDef) {
+    protected <R, S> HttpRequest buildRequest(R request, HttpRequestDef<R, S> reqDef) {
         String endpoint = this.endpoints.get(endpointIndex.intValue());
         HttpRequest.HttpRequestBuilder httpRequestBuilder = HttpRequest.newBuilder();
         httpRequestBuilder.withMethod(reqDef.getMethod())
-                .withContentType(reqDef.getContentType())
                 .withEndpoint(endpoint)
                 .withPath(reqDef.getUri());
 
-        for (Field<ReqT, ?> field : reqDef.getRequestFields()) {
-            Optional<?> reqValueOption;
-            if (httpConfig.isIgnoreRequiredValidation()) {
-                reqValueOption = field.readValueNoValidation(request);
-            } else {
-                reqValueOption = field.readValue(request);
+        boolean hasBody = false;
+        for (Field<R, ?> field : reqDef.getRequestFields()) {
+            Optional<?> reqValueOption = httpConfig.isIgnoreRequiredValidation() ?
+                    field.readValueNoValidation(request) : field.readValue(request);
+
+            if (!reqValueOption.isPresent()) {
+                continue;
             }
-            if (reqValueOption.isPresent()) {
-                Object reqValue = reqValueOption.get();
-                if (field.getLocation() == LocationType.Header) {
+            Object reqValue = reqValueOption.get();
+            switch (field.getLocation()) {
+                case Header:
                     httpRequestBuilder.addHeader(field.getName(), convertToStringParams(reqValue));
-                } else if (field.getLocation() == LocationType.Query) {
+                    break;
+                case Query:
                     buildQueryParams(httpRequestBuilder, field.getName(), reqValue);
-                } else if (field.getLocation() == LocationType.Path) {
+                    break;
+                case Path:
                     httpRequestBuilder.addPathParam(field.getName(), convertToStringParams(reqValue));
-                } else if (field.getLocation() == LocationType.Body) {
+                    break;
+                case Body:
                     buildRequestBody(httpRequestBuilder, reqValue);
-                } else if (field.getLocation() == LocationType.Cname) {
-                    try {
-                        URL url = new URL(
-                                endpoint.replace("\r", "").replace("\n", ""));
-                        StringBuilder endpointBuilder = new StringBuilder();
-                        endpointBuilder.append(url.getProtocol())
-                                .append("://")
-                                .append(reqValue)
-                                .append(".")
-                                .append(url.getHost());
-                        if (!StringUtils.isEmpty(url.getPath())) {
-                            endpointBuilder.append("/").append(url.getPath());
-                        }
-                        httpRequestBuilder.withEndpoint(endpointBuilder.toString());
-                    } catch (MalformedURLException e) {
-                        throw new SdkException("Failed to parse endpoint");
-                    }
-                }
+                    hasBody = true;
+                    break;
+                case Cname:
+                    buildCname(httpRequestBuilder, endpoint, reqValue);
+                    break;
+                default:
+                    break;
             }
         }
 
+        if (!(this.httpConfig.isIgnoreContentTypeForGetRequest() && reqDef.getMethod() == HttpMethod.GET && !hasBody)) {
+            httpRequestBuilder.withContentType(reqDef.getContentType());
+        }
+
         // handle upload/download progress
         if (request instanceof ProgressRequest) {
             ProgressRequest progressRequest = (ProgressRequest) request;
@@ -319,13 +316,32 @@ protected <ReqT, ResT> HttpRequest buildRequest(ReqT request, HttpRequestDef<Req
         }
 
         // sign algorithm
-        if (Objects.nonNull(httpConfig) && Objects.nonNull(httpConfig.getSigningAlgorithm())) {
+        if (Objects.nonNull(httpConfig.getSigningAlgorithm())) {
             httpRequestBuilder.withSigningAlgorithm(httpConfig.getSigningAlgorithm());
         }
 
         return httpRequestBuilder.build();
     }
 
+    private void buildCname(HttpRequest.HttpRequestBuilder httpRequestBuilder, String endpoint, Object reqValue) {
+        try {
+            URL url = new URL(
+                    endpoint.replace("\r", "").replace("\n", ""));
+            StringBuilder endpointBuilder = new StringBuilder();
+            endpointBuilder.append(url.getProtocol())
+                    .append("://")
+                    .append(reqValue)
+                    .append(".")
+                    .append(url.getHost());
+            if (!StringUtils.isEmpty(url.getPath())) {
+                endpointBuilder.append("/").append(url.getPath());
+            }
+            httpRequestBuilder.withEndpoint(endpointBuilder.toString());
+        } catch (MalformedURLException e) {
+            throw new SdkException("Failed to parse endpoint");
+        }
+    }
+
     private void buildRequestBody(HttpRequest.HttpRequestBuilder httpRequestBuilder, Object reqValue) {
         if (reqValue instanceof SdkFormDataBody) {
             httpRequestBuilder.withFormDataPart(((SdkFormDataBody) reqValue).buildFormData());
@@ -402,10 +418,10 @@ private void handleException(HttpRequest httpRequest, HttpResponse httpResponse)
         }
     }
 
-    private <T> T processTextBasedType(HttpResponse httpResponse, HttpRequestDef<?, T> reqDef)
+    private <S> S processTextBasedType(HttpResponse httpResponse, HttpRequestDef<?, S> reqDef)
             throws InstantiationException, IllegalAccessException {
 
-        T response;
+        S response;
         String stringResult = httpResponse.getBodyAsString();
         int statusCode = httpResponse.getStatusCode();
         if (SdkSerializable.class.isAssignableFrom(reqDef.getResponseType())) {
@@ -419,7 +435,7 @@ private <T> T processTextBasedType(HttpResponse httpResponse, HttpRequestDef<?,
             }
 
             if (reqDef.hasResponseField(String.valueOf(statusCode))) {
-                Field<T, ?> resTField = reqDef.getResponseField(String.valueOf(statusCode));
+                Field<S, ?> resTField = reqDef.getResponseField(String.valueOf(statusCode));
                 resTField.writeValueSafe(response,
                         JsonUtils.toObjectIgnoreUnknown(stringResult, resTField.getFieldType()),
                         resTField.getFieldType());
@@ -428,23 +444,23 @@ private <T> T processTextBasedType(HttpResponse httpResponse, HttpRequestDef<?,
         } else {
             // process response with body[object, map, list, string...]
             response = reqDef.getResponseType().newInstance();
-            Field<T, ?> responseField = reqDef.getResponseField(Constants.BODY);
+            Field<S, ?> responseField = reqDef.getResponseField(Constants.BODY);
             Object obj = responseToObject(stringResult, responseField);
             responseField.writeValueSafe(response, obj, responseField.getFieldType());
 
             if (reqDef.hasResponseField(String.valueOf(statusCode))) {
-                Field<T, ?> resTField = reqDef.getResponseField(String.valueOf(statusCode));
+                Field<S, ?> resTField = reqDef.getResponseField(String.valueOf(statusCode));
                 resTField.writeValueSafe(response, obj, resTField.getFieldType());
             }
         }
 
         return response;
     }
 
-    private <T> T processStreamType(HttpRequest httpRequest, HttpResponse httpResponse, HttpRequestDef<?, T> reqDef)
+    private <S> S processStreamType(HttpRequest httpRequest, HttpResponse httpResponse, HttpRequestDef<?, S> reqDef)
             throws InstantiationException, IllegalAccessException {
 
-        T response = reqDef.getResponseType().newInstance();
+        S response = reqDef.getResponseType().newInstance();
         if (response instanceof SdkStreamResponse) {
             if (Objects.nonNull(httpRequest.getProgressListener())) {
                 SimpleProgressManager progressManager = new SimpleProgressManager(
@@ -464,11 +480,11 @@ private <T> T processStreamType(HttpRequest httpRequest, HttpResponse httpRespon
         return response;
     }
 
-    private <ReqT, ResT> ResT extractResponse(
-            HttpRequest httpRequest, HttpResponse httpResponse, HttpRequestDef<ReqT, ResT> reqDef) {
+    private <R, S> S extractResponse(
+            HttpRequest httpRequest, HttpResponse httpResponse, HttpRequestDef<R, S> reqDef) {
 
         try {
-            ResT finalResT = HttpUtils.isTextBasedContentType(httpResponse.getContentType()) ?
+            S finalResT = HttpUtils.isTextBasedContentType(httpResponse.getContentType()) ?
                     processTextBasedType(httpResponse, reqDef) : processStreamType(httpRequest, httpResponse, reqDef);
 
             reqDef.getResponseFields().forEach(resTField -> {
@@ -492,13 +508,13 @@ private <ReqT, ResT> ResT extractResponse(
     }
 
     @SuppressWarnings("unchecked")
-    private <ResT> ResT deserializeSerializableResponse(Class<ResT> clazz, String string)
+    private <S> S deserializeSerializableResponse(Class<S> clazz, String string)
             throws InstantiationException, IllegalAccessException {
-        ResT instance = clazz.newInstance();
-        return ((SdkSerializable<ResT>) instance).deserialize(string);
+        S instance = clazz.newInstance();
+        return ((SdkSerializable<S>) instance).deserialize(string);
     }
 
-    public <ResT> Object responseToObject(String respBody, Field<ResT, ?> responseField) {
+    public <S> Object responseToObject(String respBody, Field<S, ?> responseField) {
         Object obj;
         if (responseField.getFieldType().isAssignableFrom(List.class)) {
             obj = JsonUtils.toListObject(respBody, responseField.getInnerContainerType());
@@ -510,7 +526,7 @@ public <ResT> Object responseToObject(String respBody, Field<ResT, ?> responseFi
         return obj;
     }
 
-    private <ResT> void fillHeaderField(HttpResponse httpResponse, ResT wrapperResponse, Field<ResT, ?> field) {
+    private <S> void fillHeaderField(HttpResponse httpResponse, S wrapperResponse, Field<S, ?> field) {
         List<String> infos = httpResponse.getHeaders().get(field.getName());
         if (Objects.nonNull(infos) && infos.size() > 0) {
             if (field.getFieldType().isAssignableFrom(List.class)) {