package org.openecomp.sdcrests.health.rest.services;
import org.apache.cxf.jaxrs.impl.ResponseBuilderImpl;
+import org.openecomp.sdc.common.session.SessionContext;
import org.openecomp.sdc.common.session.SessionContextProviderFactory;
import org.openecomp.sdc.health.HealthCheckManager;
import org.openecomp.sdc.health.HealthCheckManagerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
-import javax.inject.Named;
-import javax.ws.rs.core.Response;
import java.util.Arrays;
import java.util.Collection;
+import javax.inject.Named;
+import javax.ws.rs.core.Response;
@Named
@Service("healthCheck")
@Override
public Response checkHealth() {
HealthCheckResult healthCheckResult = new HealthCheckResult();
- SessionContextProviderFactory.getInstance().createInterface().create("public");
+
+ SessionContext context =
+ SessionContextProviderFactory.getInstance().createInterface().get();
+
+ SessionContextProviderFactory.getInstance().createInterface().create("public",
+ context.getTenant());
try {
Collection<HealthInfo> healthInfos = healthCheckManager.checkHealth();
--- /dev/null
+package org.openecomp.server.filters;
+
+import static org.openecomp.sdcrests.common.RestConstants.USER_ID_HEADER_PARAM;
+
+import javax.servlet.ServletRequest;
+import javax.servlet.http.HttpServletRequest;
+
+import org.openecomp.sdcrests.filters.SessionContextFilter;
+
+public class OnboardingSessionContextFilter extends SessionContextFilter {
+
+ @Override
+ public String getUser(ServletRequest servletRequest) {
+ return ((HttpServletRequest) servletRequest).getHeader(USER_ID_HEADER_PARAM);
+ }
+
+ @Override
+ public String getTenant(ServletRequest servletRequest) {
+ return "dox";
+ }
+}
package org.openecomp.server.listeners;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
import org.springframework.web.context.ContextLoaderListener;
import javax.servlet.ServletContextEvent;
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
+ SessionContextProviderFactory.getInstance().createInterface().create("onboarding",
+ "dox");
springListener = new ContextLoaderListener();
springListener.initWebApplicationContext(servletContextEvent.getServletContext());
}
</filter-mapping>
<filter>
<filter-name>SessionContextFilter</filter-name>
- <filter-class>org.openecomp.server.filters.SessionContextFilter</filter-class>
+ <filter-class>org.openecomp.server.filters.OnboardingSessionContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>SessionContextFilter</filter-name>
<version>${swagger.version}</version>
<scope>compile</scope>
</dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc.core</groupId>
+ <artifactId>openecomp-session-lib</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>javax.servlet</groupId>
+ <artifactId>servlet-api</artifactId>
+ <version>${javax.servlet.version}</version>
+ </dependency>
</dependencies>
</project>
\ No newline at end of file
-package org.openecomp.server.filters;
+package org.openecomp.sdcrests.filters;
import org.openecomp.sdc.common.session.SessionContextProvider;
import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
-import java.io.IOException;
-
-import static org.openecomp.sdcrests.common.RestConstants.USER_ID_HEADER_PARAM;
-public class SessionContextFilter implements Filter {
+public abstract class SessionContextFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
try {
if (servletRequest instanceof HttpServletRequest) {
- String userName = ((HttpServletRequest) servletRequest).getHeader(USER_ID_HEADER_PARAM);
- contextProvider.create(userName);
+
+ contextProvider.create(getUser(servletRequest),getTenant(servletRequest));
}
filterChain.doFilter(servletRequest, servletResponse);
public void destroy() {
}
+
+ public abstract String getUser(ServletRequest servletRequest);
+
+ public abstract String getTenant(ServletRequest servletRequest);
}
private static final String AFFECTED_USER1 = "affected_user1";
private static final String AFFECTED_USER2 = "affected_user2";
private static final String AFFECTED_USER3 = "affected_user3";
+ private static final String tenant = "dox";
@Mock
private PermissionsServices permissionsServicesMock;
@BeforeMethod
public void setUp() throws Exception {
- SessionContextProviderFactory.getInstance().createInterface().create(USER);
+ SessionContextProviderFactory.getInstance().createInterface().create(USER, tenant);
MockitoAnnotations.initMocks(this);
}
private static final Version VERSION = new Version("version_id");
private static final String NETWORK1_ID = "network1";
private static final String NETWORK2_ID = "network2";
+ private static final String tenant = "dox";
@Mock
private NetworkDao networkDaoMock;
@BeforeMethod
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- SessionContextProviderFactory.getInstance().createInterface().create(USER_ID);
+ SessionContextProviderFactory.getInstance().createInterface().create(USER_ID, tenant);
}
@AfterMethod
import com.datastax.driver.mapping.annotations.PartitionKey;
import com.datastax.driver.mapping.annotations.Table;
-@Table(keyspace = "dox", name = "unique_value")
+@Table(name = "unique_value")
public class UniqueValueEntity {
@PartitionKey
<scope>test</scope>
<version>${junit.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc.core</groupId>
+ <artifactId>openecomp-session-lib</artifactId>
+ <version>1.2.0-SNAPSHOT</version>
+ </dependency>
</dependencies>
</project>
import com.datastax.driver.core.policies.TokenAwarePolicy;
import org.openecomp.core.nosqldb.util.CassandraUtils;
import org.openecomp.sdc.common.errors.SdcConfigurationException;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
Cluster cluster = builder.build();
- String keyStore = CassandraUtils.getKeySpace();
+ String keyStore = SessionContextProviderFactory.getInstance().createInterface().get()
+ .getTenant();
return cluster.connect(keyStore);
}
public interface SessionContextProvider {
- void create(String user);
+ void create(String user, String tenant);
SessionContext get();
package org.openecomp.sdc.common.session.impl;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCode;
import org.openecomp.sdc.common.session.SessionContext;
import org.openecomp.sdc.common.session.SessionContextProvider;
import org.openecomp.sdc.common.session.User;
public class AsdcSessionContextProvider implements SessionContextProvider {
private static final ThreadLocal<String> threadUserId = new ThreadLocal<>();
+ private static final ThreadLocal<String> threadTenant = new ThreadLocal<>();
@Override
- public void create(String userId) {
+ public void create(String userId, String tenant) {
threadUserId.set(userId);
+ threadTenant.set(tenant);
}
@Override
public SessionContext get() {
if (threadUserId.get() == null) {
- throw new RuntimeException("UserId was not set for this thread");
+ throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage("UserId was not set "
+ + "for this thread").build());
}
- return new AsdcSessionContext(new User(threadUserId.get()), "dox");
+ if (threadTenant.get() == null) {
+ throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage("Tenant was not set "
+ + "for this thread").build());
+ }
+
+ return new AsdcSessionContext(new User(threadUserId.get()), threadTenant.get());
}
@Override
public void close() {
threadUserId.remove();
+ threadTenant.remove();
}
private static class AsdcSessionContext implements SessionContext {
public class ZusammenUtil {
+ private ZusammenUtil() {
+ throw new IllegalStateException("Utility class");
+ }
+
public static SessionContext createSessionContext() {
org.openecomp.sdc.common.session.SessionContext asdcSessionContext =
SessionContextProviderFactory.getInstance().createInterface().get();
+ return createSessionContext(asdcSessionContext.getUser().getUserId(), asdcSessionContext
+ .getTenant());
+ }
+
+ private static SessionContext createSessionContext(String user, String tenant) {
SessionContext sessionContext = new SessionContext();
- sessionContext.setUser(new UserInfo(asdcSessionContext.getUser().getUserId()));
- sessionContext.setTenant(asdcSessionContext.getTenant());
+ sessionContext.setUser(new UserInfo(user));
+ sessionContext.setTenant(tenant);
return sessionContext;
}
public static ZusammenElement buildStructuralElement(ElementType elementType, Action action) {
+ return buildStructuralElement(elementType.name(), action);
+ }
+
+
+ public static ZusammenElement buildStructuralElement(String elementType, Action action) {
ZusammenElement element = buildElement(null, action);
Info info = new Info();
- info.setName(elementType.name());
- info.addProperty(ElementPropertyName.elementType.name(), elementType.name());
+ info.setName(elementType);
+ info.addProperty(ElementPropertyName.elementType.name(), elementType);
element.setInfo(info);
return element;
}
import org.openecomp.core.utilities.CommonMethods;
import org.openecomp.core.utilities.file.FileUtils;
import org.openecomp.core.utilities.json.JsonUtil;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCode;
import org.openecomp.sdc.common.errors.Messages;
+import org.openecomp.sdc.common.session.SessionContext;
import org.openecomp.sdc.common.session.SessionContextProviderFactory;
import org.openecomp.sdc.datatypes.model.ItemType;
import org.openecomp.sdc.healing.api.HealingManager;
: Optional.empty();
if (privateFailureMessages.isPresent() || publicFailureMessages.isPresent()) {
- throw new RuntimeException(
- publicFailureMessages.orElse("") + " " + privateFailureMessages.orElse(""));
+ throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage(
+ publicFailureMessages.orElse("") + " " + privateFailureMessages.orElse(""))
+ .build());
}
}
private Optional<String> healPublic(String itemId, Version version,
Map<String, Map<String, String>> itemHealers, String user) {
- SessionContextProviderFactory.getInstance().createInterface()
- .create(user + HEALING_USER_SUFFIX);
+ SessionContext context =
+ SessionContextProviderFactory.getInstance().createInterface().get();
+ SessionContextProviderFactory.getInstance().createInterface().create(user
+ + HEALING_USER_SUFFIX,context.getTenant());
versioningManager.sync(itemId, version);
versioningManager.publish(itemId, version, "Healing vsp");
}
- SessionContextProviderFactory.getInstance().createInterface().create(user);
+ SessionContextProviderFactory.getInstance().createInterface().create(user, context.getTenant());
return healingFailureMessages;
}
Object result = executeHealer(itemId, version, healerClassName, healingFailureMessages);
if (!healingFailureMessages.isEmpty()) {
- throw new RuntimeException(CommonMethods.listToSeparatedString(healingFailureMessages, '\n'));
+ throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage(CommonMethods
+ .listToSeparatedString(healingFailureMessages, '\n')).build());
}
return result;
}
}
private Map<String, Map<String, String>> getItemHealers(ItemType itemType) {
- // TODO: 11/29/2017 create objects to hold this configuration +
- // load once from the json file and use the relevant healers (by itemType, healerType) as needed.
Map healingConfig = FileUtils
.readViaInputStream(HEALERS_BY_ENTITY_TYPE_FILE,
stream -> JsonUtil.json2Object(stream, Map.class));
private static final Version version = Version.valueOf("1.0");
private static final String baseServiceTemplateName = "baseYaml.yaml";
private static String artifact001;
+ private static final String tenant = "dox";
@BeforeMethod
public void setUp(){
- SessionContextProviderFactory.getInstance().createInterface().create("test");
+ SessionContextProviderFactory.getInstance().createInterface().create("test", tenant);
}
@AfterMethod
private static final String ITEM_VERSIONS_STATUSES = "item_versions_statuses";
private static final String APP_PROP_1 = "app_prop1";
private static final String APP_PROP_2 = "app_prop2";
+ private static final String tenant = "dox";
@Mock
private ZusammenAdaptor zusammenAdaptorMock;
@BeforeMethod
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- SessionContextProviderFactory.getInstance().createInterface().create(USER);
+ SessionContextProviderFactory.getInstance().createInterface().create(USER, tenant);
}
@Test
public class VersionZusammenDaoImplTest {
private static final String USER = "user1";
+ private static final String tenant = "dox";
@Mock
private ZusammenAdaptor zusammenAdaptorMock;
@InjectMocks
@BeforeMethod
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- SessionContextProviderFactory.getInstance().createInterface().create(USER);
+ SessionContextProviderFactory.getInstance().createInterface().create(USER, tenant);
}
@Test
private static final String ITEM_NAME = "item 1 name";
private static final String ITEM_TYPE_A = "A";
private static final String ITEM_TYPE_B = "B";
+ private static final String tenant = "dox";
@Mock
private ItemDao itemDao;
@Mock
@Test
public void testCreate() throws Exception {
- SessionContextProviderFactory.getInstance().createInterface().create(USER);
+ SessionContextProviderFactory.getInstance().createInterface().create(USER, tenant);
Item returnedItem = createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A);
doReturn(returnedItem).when(itemDao).create(any(Item.class));
Code Review / sdc.git / commitdiff