Export Policy and File operation changes NAS Storage pool creation

plugins/storage/volume/ontap/pom.xml

@@ -76,6 +76,16 @@
             <artifactId>feign-httpclient</artifactId>
             <version>${openfeign.version}</version>
         </dependency>
+        <!--        <dependency>-->
+        <!--            <groupId>io.github.openfeign</groupId>-->
+        <!--            <artifactId>feign-slf4j</artifactId>-->
+        <!--            <version>${openfeign.version}</version>-->
+        <!--        </dependency>-->
+        <dependency>
+            <groupId>io.github.openfeign</groupId>
+            <artifactId>feign-jackson</artifactId>
+            <version>${openfeign.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.cloudstack</groupId>
             <artifactId>cloud-engine-storage-volume</artifactId>

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/driver/OntapPrimaryDatastoreDriver.java

@@ -37,15 +37,16 @@
 import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
 import org.apache.cloudstack.framework.async.AsyncCompletionCallback;
 import org.apache.cloudstack.storage.command.CommandResult;
-import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class OntapPrimaryDatastoreDriver implements PrimaryDataStoreDriver {
 
-    private static final Logger s_logger = (Logger)LogManager.getLogger(OntapPrimaryDatastoreDriver.class);
+    private static final Logger s_logger = LogManager.getLogger(OntapPrimaryDatastoreDriver.class);
     @Override
     public Map<String, String> getCapabilities() {
         s_logger.trace("OntapPrimaryDatastoreDriver: getCapabilities: Called");

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/FeignClientFactory.java

@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cloudstack.storage.feign;
+
+import feign.Feign;
+
+public class FeignClientFactory {
+
+    private final FeignConfiguration feignConfiguration;
+
+    public FeignClientFactory() {
+        this.feignConfiguration = new FeignConfiguration();
+    }
+
+    public FeignClientFactory(FeignConfiguration feignConfiguration) {
+        this.feignConfiguration = feignConfiguration;
+    }
+
+    public <T> T createClient(Class<T> clientClass) {
+        return Feign.builder()
+                .client(feignConfiguration.createClient())
+                .encoder(feignConfiguration.createEncoder())
+                .decoder(feignConfiguration.createDecoder())
+//                .logger(feignConfiguration.createLogger())
+                .retryer(feignConfiguration.createRetryer())
+                .requestInterceptor(feignConfiguration.createRequestInterceptor())
+                .target(clientClass, "https://10.196.38.171/");
+    }
+}

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/FeignConfiguration.java

@@ -19,41 +19,43 @@
 
 package org.apache.cloudstack.storage.feign;
 
-
 import feign.RequestInterceptor;
-import feign.RequestTemplate;
 import feign.Retryer;
-import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory;
+import feign.Client;
+import feign.httpclient.ApacheHttpClient;
+import feign.codec.Decoder;
+import feign.codec.Encoder;
+import feign.Response;
+import feign.codec.DecodeException;
+import feign.codec.EncodeException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import org.apache.http.conn.ConnectionKeepAliveStrategy;
 import org.apache.http.conn.ssl.NoopHostnameVerifier;
 import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
 import org.apache.http.conn.ssl.TrustAllStrategy;
 import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.http.ssl.SSLContexts;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import feign.Client;
-import feign.httpclient.ApacheHttpClient;
+
 import javax.net.ssl.SSLContext;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
 import java.util.concurrent.TimeUnit;
 
-@Configuration
 public class FeignConfiguration {
-    private static Logger logger = LogManager.getLogger(FeignConfiguration.class);
+    private static final Logger logger = LogManager.getLogger(FeignConfiguration.class);
 
-    private int retryMaxAttempt = 3;
-
-    private int retryMaxInterval = 5;
-
-    private String ontapFeignMaxConnection = "80";
-
-    private String ontapFeignMaxConnectionPerRoute = "20";
-
-    @Bean
-    public Client client(ApacheHttpClientFactory httpClientFactory) {
+    private final int retryMaxAttempt = 3;
+    private final int retryMaxInterval = 5;
+    private final String ontapFeignMaxConnection = "80";
+    private final String ontapFeignMaxConnectionPerRoute = "20";
+    private final ObjectMapper objectMapper = new ObjectMapper();
 
+    public Client createClient() {
         int maxConn;
         int maxConnPerRoute;
         try {
@@ -68,10 +70,11 @@ public Client client(ApacheHttpClientFactory httpClientFactory) {
             logger.error("ontapFeignClient: encounter exception while parse the max connection per route from env. setting default value");
             maxConnPerRoute = 2;
         }
+
         // Disable Keep Alive for Http Connection
         logger.debug("ontapFeignClient: Setting the feign client config values as max connection: {}, max connections per route: {}", maxConn, maxConnPerRoute);
         ConnectionKeepAliveStrategy keepAliveStrategy = (response, context) -> 0;
-        CloseableHttpClient httpClient = httpClientFactory.createBuilder()
+        CloseableHttpClient httpClient = HttpClientBuilder.create()
                 .setMaxConnTotal(maxConn)
                 .setMaxConnPerRoute(maxConnPerRoute)
                 .setKeepAliveStrategy(keepAliveStrategy)
@@ -91,22 +94,55 @@ private SSLConnectionSocketFactory getSSLSocketFactory() {
         }
     }
 
+    public RequestInterceptor createRequestInterceptor() {
+        return template -> {
+            logger.info("Feign Request URL: {}", template.url());
+            logger.info("HTTP Method: {}", template.method());
+            logger.info("Headers: {}", template.headers());
+            if (template.body() != null) {
+                logger.info("Body: {}", new String(template.body()));
+            }
+        };
+    }
+
+    public Retryer createRetryer() {
+        return new Retryer.Default(1000L, retryMaxInterval * 1000L, retryMaxAttempt);
+    }
 
-    @Bean
-    public RequestInterceptor requestInterceptor() {
-        return new RequestInterceptor() {
+    public Encoder createEncoder() {
+        return new Encoder() {
             @Override
-            public void apply(RequestTemplate template) {
-                logger.info("Feign Request URL: {}", template.url());
-                logger.info("HTTP Method: {}", template.method());
-                logger.info("Headers: {}", template.headers());
-                logger.info("Body: {}", template.requestBody().asString());
+            public void encode(Object object, Type bodyType, feign.RequestTemplate template) throws EncodeException {
+                try {
+                    String json = objectMapper.writeValueAsString(object);
+                    logger.debug("Encoding object to JSON: {}", json);
+
+                    // Use the String version - it handles charset conversion internally
+                    template.body(json);
+
+                    template.header("Content-Type", "application/json");
+                } catch (JsonProcessingException e) {
+                    throw new EncodeException("Error encoding object to JSON", e);
+                }
             }
         };
     }
 
-    @Bean
-    public Retryer feignRetryer() {
-        return new Retryer.Default(1000L, retryMaxInterval * 1000L, retryMaxAttempt);
+    public Decoder createDecoder() {
+        return new Decoder() {
+            @Override
+            public Object decode(Response response, Type type) throws IOException, DecodeException {
+                if (response.body() == null) {
+                    return null;
+                }
+                try {
+                    String json = new String(response.body().asInputStream().readAllBytes(), StandardCharsets.UTF_8);
+                    return objectMapper.readValue(json, objectMapper.getTypeFactory().constructType(type));
+                } catch (IOException e) {
+                    throw new DecodeException(response.status(), "Error decoding JSON response", response.request(), e);
+                }
+            }
+        };
     }
-}
+
+}

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/client/AggregateFeignClient.java

@@ -20,26 +20,19 @@
 package org.apache.cloudstack.storage.feign.client;
 
 import org.apache.cloudstack.storage.feign.model.Aggregate;
-import org.apache.cloudstack.storage.feign.FeignConfiguration;
 import org.apache.cloudstack.storage.feign.model.response.OntapResponse;
-import org.springframework.cloud.openfeign.FeignClient;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
 import java.net.URI;
 
-@Lazy
-@FeignClient(name="AggregateClient", url="https://{clusterIP}/api/storage/aggregates", configuration = FeignConfiguration.class)
 public interface AggregateFeignClient {
 
-    //this method to get all aggregates and also filtered aggregates based on query params as a part of URL
-    @RequestMapping(method=RequestMethod.GET)
-    OntapResponse<Aggregate> getAggregateResponse(URI baseURL, @RequestHeader("Authorization") String header);
-
-    @RequestMapping(method=RequestMethod.GET, value="/{uuid}")
-    Aggregate getAggregateByUUID(URI baseURL,@RequestHeader("Authorization") String header, @PathVariable(name = "uuid", required = true) String uuid);
+    @RequestLine("GET /")
+    @Headers("Authorization: {authHeader}")
+    OntapResponse<Aggregate> getAggregateResponse(@Param("baseURL") URI baseURL, @Param("authHeader") String authHeader);
 
+    @RequestLine("GET /{uuid}")
+    @Headers("Authorization: {authHeader}")
+    Aggregate getAggregateByUUID(@Param("baseURL") URI baseURL, @Param("authHeader") String authHeader, @Param("uuid") String uuid);
 }

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/client/ClusterFeignClient.java

@@ -19,19 +19,15 @@
 
 package org.apache.cloudstack.storage.feign.client;
 
-import org.apache.cloudstack.storage.feign.FeignConfiguration;
 import org.apache.cloudstack.storage.feign.model.Cluster;
-import org.springframework.cloud.openfeign.FeignClient;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
 import java.net.URI;
 
-@FeignClient(name="ClusterClient", url="https://{clusterIP}/api/cluster", configuration = FeignConfiguration.class)
 public interface ClusterFeignClient {
 
-    @RequestMapping(method= RequestMethod.GET)
-    Cluster getCluster(URI baseURL, @RequestHeader("Authorization") String header, @RequestHeader("return_records") boolean value);
-
+    @RequestLine("GET /")
+    @Headers({"Authorization: {authHeader}", "return_records: {returnRecords}"})
+    Cluster getCluster(@Param("baseURL") URI baseURL, @Param("authHeader") String authHeader, @Param("returnRecords") boolean returnRecords);
 }

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/client/JobFeignClient.java

@@ -18,25 +18,15 @@
  */
 package org.apache.cloudstack.storage.feign.client;
 
-import org.apache.cloudstack.storage.feign.FeignConfiguration;
 import org.apache.cloudstack.storage.feign.model.Job;
-import org.springframework.cloud.openfeign.FeignClient;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
 import java.net.URI;
 
-/**
- * @author Administrator
- *
- */
-@Lazy
-@FeignClient(name = "JobClient", url = "https://{clusterIP}/api/cluster/jobs" , configuration = FeignConfiguration.class)
 public interface JobFeignClient {
 
-    @RequestMapping(method = RequestMethod.GET, value="/{uuid}")
-    Job getJobByUUID(URI baseURL, @RequestHeader("Authorization") String header, @PathVariable(name = "uuid", required = true) String uuid);
-
+    @RequestLine("GET /{uuid}")
+    @Headers("Authorization: {authHeader}")
+    Job getJobByUUID(URI baseURL, @Param("authHeader") String authHeader, @Param("uuid") String uuid);
 }