content: // 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.datastore.lifecycle;
  
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.inject.Inject;
  
  import org.apache.logging.log4j.Logger;
  import org.apache.logging.log4j.LogManager;
  
  import com.cloud.utils.StringUtils;
  
  import org.apache.cloudstack.engine.subsystem.api.storage.ClusterScope;
  import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
  import org.apache.cloudstack.engine.subsystem.api.storage.HostScope;
  import org.apache.cloudstack.engine.subsystem.api.storage.ZoneScope;
  import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
  import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
  import org.apache.cloudstack.storage.image.datastore.ImageStoreHelper;
  import org.apache.cloudstack.storage.image.datastore.ImageStoreProviderManager;
  import org.apache.cloudstack.storage.image.store.lifecycle.ImageStoreLifeCycle;
  
  import com.cloud.agent.api.StoragePoolInfo;
  import com.cloud.exception.InvalidParameterValueException;
  import com.cloud.hypervisor.Hypervisor.HypervisorType;
  import com.cloud.resource.Discoverer;
  import com.cloud.resource.ResourceManager;
  import com.cloud.storage.DataStoreRole;
  import com.cloud.storage.ScopeType;
  import com.cloud.utils.UriUtils;
  
  public class CloudStackImageStoreLifeCycleImpl implements ImageStoreLifeCycle {
  
      protected Logger logger = LogManager.getLogger(getClass());
      @Inject
      protected ResourceManager _resourceMgr;
      @Inject
      protected ImageStoreDao imageStoreDao;
      @Inject
      ImageStoreHelper imageStoreHelper;
      @Inject
      ImageStoreProviderManager imageStoreMgr;
  
      protected List<? extends Discoverer> _discoverers;
  
      public List<? extends Discoverer> getDiscoverers() {
          return _discoverers;
      }
  
      public void setDiscoverers(List<? extends Discoverer> discoverers) {
          this._discoverers = discoverers;
      }
  
      public CloudStackImageStoreLifeCycleImpl() {
      }
  
      @SuppressWarnings("unchecked")
      @Override
      public DataStore initialize(Map<String, Object> dsInfos) {
  
          Long dcId = (Long)dsInfos.get("zoneId");
          String url = (String)dsInfos.get("url");
          String name = (String)dsInfos.get("name");
          if (name == null) {
              name = url;
          }
          String providerName = (String)dsInfos.get("providerName");
          DataStoreRole role = (DataStoreRole)dsInfos.get("role");
          Map<String, String> details = (Map<String, String>)dsInfos.get("details");
  
          String logString = "";
          if(url.contains("cifs")) {
              logString = cleanPassword(url);
          } else {
              logString = StringUtils.cleanString(url);
          }
          logger.info("Trying to add a new data store at " + logString + " to data center " + dcId);
  
          URI uri = null;
          try {
              uri = new URI(UriUtils.encodeURIComponent(url));
              if (uri.getScheme() == null) {
                  throw new InvalidParameterValueException("uri.scheme is null " + StringUtils.cleanString(url) + ", add nfs:// (or cifs://) as a prefix");
              } else if (uri.getScheme().equalsIgnoreCase("nfs")) {
                  if (uri.getHost() == null || uri.getHost().equalsIgnoreCase("") || uri.getPath() == null || uri.getPath().equalsIgnoreCase("")) {
                      throw new InvalidParameterValueException("Your host and/or path is wrong.  Make sure it's of the format nfs://hostname/path");
                  }
              } else if (uri.getScheme().equalsIgnoreCase("cifs")) {
                  // Don't validate against a URI encoded URI.
                  URI cifsUri = new URI(url);
                  String warnMsg = UriUtils.getCifsUriParametersProblems(cifsUri);
                  if (warnMsg != null) {
                      throw new InvalidParameterValueException(warnMsg);
                  }
              }
          } catch (URISyntaxException e) {
              throw new InvalidParameterValueException(logString + " is not a valid uri. Note that the URL in this message has been sanitized");
          }
  
          if (dcId == null) {
              throw new InvalidParameterValueException("DataCenter id is null, and cloudstack default image store has to be associated with a data center");
          }
  
          Map<String, Object> imageStoreParameters = new HashMap<String, Object>();
          imageStoreParameters.put("name", name);
          imageStoreParameters.put("zoneId", dcId);
          imageStoreParameters.put("url", url);
          imageStoreParameters.put("protocol", uri.getScheme().toLowerCase());
          imageStoreParameters.put("scope", ScopeType.ZONE); // default cloudstack
                                                             // provider only
                                                             // supports zone-wide
                                                             // image store
          imageStoreParameters.put("providerName", providerName);
          imageStoreParameters.put("role", role);
  
          ImageStoreVO ids = imageStoreHelper.createImageStore(imageStoreParameters, details);
          return imageStoreMgr.getImageStore(ids.getId());
      }
  
      @Override
      public boolean attachCluster(DataStore store, ClusterScope scope) {
          return false;
      }
  
      @Override
      public boolean attachHost(DataStore store, HostScope scope, StoragePoolInfo existingInfo) {
          return false;
      }
  
      @Override
      public boolean attachZone(DataStore dataStore, ZoneScope scope, HypervisorType hypervisorType) {
          return false;
      }
  
      @Override
      public boolean maintain(DataStore store) {
          return false;
      }
  
      @Override
      public boolean cancelMaintain(DataStore store) {
          return false;
      }
  
      @Override
      public boolean deleteDataStore(DataStore store) {
          return false;
      }
  
      /* (non-Javadoc)
       * @see org.apache.cloudstack.engine.subsystem.api.storage.DataStoreLifeCycle#migrateToObjectStore(org.apache.cloudstack.engine.subsystem.api.storage.DataStore)
       */
      @Override
      public boolean migrateToObjectStore(DataStore store) {
          return imageStoreHelper.convertToStagingStore(store);
      }
  
      public static String cleanPassword(String logString) {
          String cleanLogString = null;
          if (logString != null) {
              cleanLogString = logString;
              String[] temp = logString.split(",");
              int i = 0;
              if (temp != null) {
                  while (i < temp.length) {
                      temp[i] = StringUtils.cleanString(temp[i]);
                      i++;
                  }
                  List<String> stringList = new ArrayList<String>();
                  Collections.addAll(stringList, temp);
                  cleanLogString = org.apache.commons.lang3.StringUtils.join(stringList, ",");
              }
          }
          return cleanLogString;
      }
  }
  