Merge "Commit 2 for Integrate minizinc optimizer engine"

4 files changed, 636 insertions, 0 deletions

diff --git a/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/availability/timewindows/RecurringWindows.java b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/availability/timewindows/RecurringWindows.java
index 84fc039..23e3ad8 100644
--- a/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/availability/timewindows/RecurringWindows.java
+++ b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/availability/timewindows/RecurringWindows.java
@@ -211,5 +211,17 @@ public class RecurringWindows {
         return instant.plus(date.toEpochMilli(), ChronoUnit.MILLIS);
     }
 
+    public static DateTimeIterator getRecurringListForChangeWindow(ChangeWindow window, Long durationInSeconds)
+                    throws ParseException {
+
+        String rdata = "RRULE:FREQ=MINUTELY;INTERVAL=" + durationInSeconds/60;
+        DateTime start = new DateTime(window.getStartTime().toInstant().toEpochMilli());
+        DateTimeIterator recur =
+                        DateTimeIteratorFactory.createDateTimeIterator(rdata, start, DateTimeZone.UTC, true);
+        return recur;
+    }
+
+
+
 
 }
diff --git a/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/ElementAvailability.java b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/ElementAvailability.java
new file mode 100644
index 0000000..4766db2
--- /dev/null
+++ b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/ElementAvailability.java
@@ -0,0 +1,197 @@
+/*
+ *  ============LICENSE_START==============================================
+ *  Copyright (c) 2019 AT&T Intellectual Property.
+ *  =======================================================================
+ *  Licensed 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.
+ * ============LICENSE_END=================================================
+ */
+
+package org.onap.optf.cmso.optimizer.clients.optimizer;
+
+import com.google.ical.compat.jodatime.DateTimeIterator;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import org.joda.time.DateTime;
+import org.onap.optf.cmso.optimizer.availability.policies.model.TimeLimitAndVerticalTopology;
+import org.onap.optf.cmso.optimizer.availability.timewindows.RecurringWindows;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerParameters;
+import org.onap.optf.cmso.optimizer.clients.ticketmgt.models.ActiveTicketsResponse;
+import org.onap.optf.cmso.optimizer.clients.ticketmgt.models.TicketData;
+import org.onap.optf.cmso.optimizer.clients.topology.models.TopologyElementInfo;
+import org.onap.optf.cmso.optimizer.clients.topology.models.TopologyResponse;
+import org.onap.optf.cmso.optimizer.service.rs.models.ChangeWindow;
+import org.onap.optf.cmso.optimizer.service.rs.models.OptimizerRequest;
+import org.springframework.expression.spel.ast.OpInc;
+
+public class ElementAvailability extends ElementWindowMapping{
+
+    private List<TimeLimitAndVerticalTopology> policies;
+    private ActiveTicketsResponse ticketResponse;
+
+    private OptimizerParameters parameters = null;
+
+    private List<List<ChangeWindow>> globalRelativeAvailability = new ArrayList<>();
+
+    private Map<String, List<TicketData>> nodeUnAvailability = new TreeMap<>();
+
+    public ElementAvailability(List<TimeLimitAndVerticalTopology> policies, OptimizerRequest optimizerRequest,
+                    TopologyResponse topologyResponse, ActiveTicketsResponse ticketResponse) throws ParseException
+    {
+        super(optimizerRequest, topologyResponse);
+        this.policies         = policies;
+        this.ticketResponse   = ticketResponse;
+    }
+
+    public void populate(OptimizerParameters parameters) throws ParseException {
+        this.parameters = parameters;
+        for (ChangeWindow changeWindow : optimizerRequest.getChangeWindows()) {
+            if  (policies.size() > 0) {
+                globalRelativeAvailability.add(RecurringWindows.getAvailabilityWindowsForPolicies(policies, changeWindow));
+            }
+            else {
+                List<ChangeWindow> wholeWindow = new ArrayList<>();
+                wholeWindow.add(changeWindow);
+                globalRelativeAvailability.add(wholeWindow);
+            }
+        }
+        for (String id : nodeInfo.keySet()) {
+            calculateNodeAvailability(nodeInfo.get(id));
+        }
+        setNoConflicts();
+        parameters.setMaxTime(new Long(parameters.getNoConflict().get(0).size()));
+        parameters.setNumElements(new Long(parameters.getNoConflict().size()));
+
+        // for now we have 1 loader with unlimited capacity
+        parameters.setNumLoaders(1L);
+        Long loaderCapacity = parameters.getNumElements();
+        List<Long> capacity =  new ArrayList<>();
+        for (Long slot =0L ; slot < parameters.getMaxTime() ; slot++) {
+            capacity.add(loaderCapacity);
+        }
+        parameters.getLoaderCapacity().add(capacity);
+
+        // For now every slot has the same concurrency limit
+        capacity =  new ArrayList<>();
+        Long limit = new Long(optimizerRequest.getConcurrencyLimit());
+        if (limit > parameters.getNumElements()) {
+            limit = parameters.getNumElements();
+        }
+
+        for (Long slot =0L ; slot < parameters.getMaxTime() ; slot++) {
+            capacity.add(limit);
+        }
+        parameters.setElementSlotCapacity(capacity);
+
+    }
+
+    private void setNoConflicts() throws ParseException {
+        // Only support 1 change window for now
+        ChangeWindow window = optimizerRequest.getChangeWindows().get(0);
+        Long duration = new Long(optimizerRequest.getNormalDuration());
+        if (optimizerRequest.getAdditionalDuration() != null) {
+            duration += optimizerRequest.getAdditionalDuration();
+        }
+        for (String elementId : nodeInfo.keySet()) {
+
+            TopologyElementInfo info = nodeInfo.get(elementId);
+            Long timeZoneOffset = getTimeZoneOffset(info);
+            DateTimeIterator recur = getRecurringIterator();
+            List<Boolean> element = new ArrayList<>();
+            while (recur.hasNext()) {
+                DateTime next = recur.next();
+                if (next.isAfter(window.getEndTime().getTime())) {
+                    break;
+                }
+                ChangeWindow slot = new ChangeWindow();
+                slot.setStartTime(next.toDate());
+                slot.setEndTime(next.plus(duration).toDate());
+                if (slotIsAvailable(slot, timeZoneOffset, nodeUnAvailability.get(elementId))) {
+                    element.add(true);
+                } else {
+                    element.add(false);
+                }
+            }
+            parameters.getNoConflict().add(element);
+        }
+
+    }
+
+    private boolean slotIsAvailable(ChangeWindow slot, Long timeZoneOffset, List<TicketData> tickets) {
+        if (isGloballyAvailable(slot, timeZoneOffset) && isNotRestricted(slot, tickets)) {
+            return true;
+        }
+        return false;
+    }
+
+    private boolean isNotRestricted(ChangeWindow slot, List<TicketData> tickets) {
+        if (tickets != null) {
+            for (TicketData ticket : tickets) {
+                ChangeWindow window = new ChangeWindow();
+                window.setStartTime(ticket.getStartTime());
+                window.setEndTime(ticket.getEndTime());
+                if (slot.overlaps(window)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private boolean isGloballyAvailable(ChangeWindow slot, Long timeZoneOffset) {
+        for (ChangeWindow global : globalRelativeAvailability.get(0)) {
+            if (global.containsInTimeZone(slot, timeZoneOffset)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Long getTimeZoneOffset(TopologyElementInfo info) {
+        // TODO Auto-generated method stub
+        return 0L;
+    }
+
+    private void calculateNodeAvailability(TopologyElementInfo info) {
+        Set<String> requiredElements = new HashSet<>();
+        requiredElements.add(info.getElementId());
+        if (info.getRequiredElements() != null) {
+            requiredElements.addAll(info.getRequiredElements());
+        }
+        if (ticketResponse.getElements() != null) {
+            List<TicketData> tickets = ticketResponse.getElements();
+            for (TicketData data : tickets) {
+                for (String id : data.getElementIds()) {
+                    if (requiredElements.contains(id)) {
+                        updateNodeAvailability(id, data);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private void updateNodeAvailability(String elementId, TicketData data) {
+        List<TicketData> list = nodeUnAvailability.get(elementId);
+        if (list == null) {
+            list = new ArrayList<>();
+            nodeUnAvailability.put(elementId, list);
+        }
+        list.add(data);
+    }
+
+}
diff --git a/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/ElementWindowMapping.java b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/ElementWindowMapping.java
new file mode 100644
index 0000000..42c69a2
--- /dev/null
+++ b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/ElementWindowMapping.java
@@ -0,0 +1,148 @@
+/*
+ *  ============LICENSE_START==============================================
+ *  Copyright (c) 2019 AT&T Intellectual Property.
+ *  =======================================================================
+ *  Licensed 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.
+ * ============LICENSE_END=================================================
+ */
+
+package org.onap.optf.cmso.optimizer.clients.optimizer;
+
+import com.google.ical.compat.jodatime.DateTimeIterator;
+import java.text.ParseException;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+import org.joda.time.DateTime;
+import org.onap.optf.cmso.optimizer.availability.timewindows.RecurringWindows;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.ElementSlot;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerSchedule;
+import org.onap.optf.cmso.optimizer.clients.topology.models.TopologyElementInfo;
+import org.onap.optf.cmso.optimizer.clients.topology.models.TopologyResponse;
+import org.onap.optf.cmso.optimizer.service.rs.models.ChangeWindow;
+import org.onap.optf.cmso.optimizer.service.rs.models.OptimizerRequest;
+import org.onap.optf.cmso.optimizer.service.rs.models.OptimizerScheduleInfo;
+import org.onap.optf.cmso.optimizer.service.rs.models.ScheduledElement;
+import org.onap.optf.cmso.optimizer.service.rs.models.ScheduledElement.ScheduleType;
+import org.onap.optf.cmso.optimizer.service.rs.models.UnScheduledElement;
+import org.onap.optf.cmso.optimizer.service.rs.models.UnScheduledElement.NotScheduledReason;
+
+// This class ensures that the node indices nodes and the time slots are the
+// same when processing the optimizer engine response as when initiating.
+public class ElementWindowMapping {
+
+    protected OptimizerRequest optimizerRequest;
+    protected TopologyResponse topologyResponse;
+
+    protected Map<String, TopologyElementInfo> nodeInfo = new TreeMap<>();
+    private List<TopologyElementInfo> nodeArray = null;
+
+    public ElementWindowMapping(OptimizerRequest optimizerRequest, TopologyResponse topologyResponse)
+                    throws ParseException {
+        this.optimizerRequest = optimizerRequest;
+        this.topologyResponse = topologyResponse;
+        initialize();
+
+    }
+
+    private void initialize() throws ParseException {
+        List<TopologyElementInfo> elements = topologyResponse.getElements();
+        for (TopologyElementInfo info : elements) {
+            nodeInfo.put(info.getElementId(), info);
+        }
+    }
+
+    protected DateTimeIterator getRecurringIterator() throws ParseException {
+        // Only support 1 change window for now
+        ChangeWindow window = optimizerRequest.getChangeWindows().get(0);
+        Long duration = new Long(optimizerRequest.getNormalDuration());
+        if (optimizerRequest.getAdditionalDuration() != null) {
+            duration += optimizerRequest.getAdditionalDuration();
+        }
+        DateTimeIterator recur = RecurringWindows.getRecurringListForChangeWindow(window, duration);
+        return recur;
+    }
+
+    public void initializeForProcessResult()
+    {
+       // we need nodeInfo to be an array to speed up the result processing.
+       // but we need it sorted by elementId as when we created it....
+       nodeArray = nodeInfo.values().stream().collect(Collectors.toList());
+       nodeInfo.clear();
+
+    }
+    public OptimizerScheduleInfo processResult(OptimizerSchedule result) throws ParseException {
+        // When considering the memory vs performance
+        // 5 minute duration for a month long change window is 8928 slots
+        // The assumption is that there were be fewer allocated slots
+        // than potential slots.
+        List<ElementSlot> elements = result.getElementSlotLoader();
+        Map<Integer, List<ElementSlot>> mapSlotToElement = elements.stream().
+                        collect(Collectors.groupingBy(ElementSlot::getSlot));
+        DateTimeIterator iter = getRecurringIterator();
+        // TODO - supporting only 1 change window at the moment.....
+        Long endWindow = optimizerRequest.getChangeWindows().get(0).getEndTime().getTime();
+        Integer slotIndex = 1;
+        while (iter.hasNext()) {
+            DateTime dateTime = iter.next();
+            if (dateTime.isAfter(endWindow))
+                break;
+            List<ElementSlot> list = mapSlotToElement.get(slotIndex);
+            if (list != null) {
+                list.stream().forEach(x -> x.setTime(dateTime.getMillis()));
+            }
+            slotIndex++;
+        }
+        //
+        // All assigned ElementSlots now have corresponding UTC time
+        //
+        OptimizerScheduleInfo info = new OptimizerScheduleInfo();
+        for (ElementSlot slot : elements)
+        {
+            updateInfo(slot, info);
+        }
+        return info;
+    }
+
+    private void updateInfo(ElementSlot slot, OptimizerScheduleInfo info)
+    {
+        TopologyElementInfo element = nodeArray.get(slot.getElementIndex()-1);
+        if (slot.getSlot() > 0)
+        {
+            ScheduledElement scheduled = new ScheduledElement();
+            Integer durationInSeconds = optimizerRequest.getNormalDuration();
+            if (optimizerRequest.getAdditionalDuration() != null) {
+                durationInSeconds += optimizerRequest.getAdditionalDuration();
+            }
+            scheduled.setDurationSeconds(durationInSeconds.longValue());
+            scheduled.setElementId(element.getElementId());
+            scheduled.setStartTime(new Date(slot.getTime()));
+            scheduled.setEndTime(new Date(slot.getTime() + (durationInSeconds*1000)));
+            scheduled.setScheduleType(ScheduleType.INDIVIDUAL);
+            info.getScheduledElements().add(scheduled);
+        }
+        else
+        {
+            UnScheduledElement unscheduled = new UnScheduledElement();
+            unscheduled.setElementId(element.getElementId());
+            unscheduled.setGroupId("unknown");
+            unscheduled.getNotScheduledReaons().add(NotScheduledReason.Other);
+            unscheduled.getNotScheduledMessages().add("Unknown");
+            info.getUnScheduledElements().add(unscheduled);
+        }
+    }
+
+
+}
diff --git a/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/OptimizerClient.java b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/OptimizerClient.java
new file mode 100644
index 0000000..514097e
--- /dev/null
+++ b/cmso-optimizer/src/main/java/org/onap/optf/cmso/optimizer/clients/optimizer/OptimizerClient.java
@@ -0,0 +1,279 @@
+/*
+ * ============LICENSE_START==============================================
+ * Copyright (c) 2019 AT&T Intellectual Property.
+ * =======================================================================
+ * Licensed 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.
+ * ============LICENSE_END=================================================
+ *
+ */
+
+package org.onap.optf.cmso.optimizer.clients.optimizer;
+
+import com.att.eelf.configuration.EELFLogger;
+import com.att.eelf.configuration.EELFManager;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import org.apache.commons.io.IOUtils;
+import org.onap.observations.Observation;
+import org.onap.optf.cmso.common.PropertiesManagement;
+import org.onap.optf.cmso.common.exceptions.CmsoException;
+import org.onap.optf.cmso.optimizer.availability.policies.PolicyManager;
+import org.onap.optf.cmso.optimizer.availability.policies.model.TimeLimitAndVerticalTopology;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerEngineResponse;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerEngineResponse.OptimizerEngineResponseStatus;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerParameters;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerResponseUtility;
+import org.onap.optf.cmso.optimizer.clients.optimizer.models.OptimizerResults;
+import org.onap.optf.cmso.optimizer.clients.ticketmgt.TicketMgtRequestManager;
+import org.onap.optf.cmso.optimizer.clients.ticketmgt.models.ActiveTicketsResponse;
+import org.onap.optf.cmso.optimizer.clients.topology.TopologyRequestManager;
+import org.onap.optf.cmso.optimizer.clients.topology.models.TopologyResponse;
+import org.onap.optf.cmso.optimizer.common.LogMessages;
+import org.onap.optf.cmso.optimizer.model.Optimizer;
+import org.onap.optf.cmso.optimizer.model.Request;
+import org.onap.optf.cmso.optimizer.model.Ticket;
+import org.onap.optf.cmso.optimizer.model.Topology;
+import org.onap.optf.cmso.optimizer.model.dao.OptimizerDao;
+import org.onap.optf.cmso.optimizer.model.dao.RequestDao;
+import org.onap.optf.cmso.optimizer.service.rs.models.OptimizerRequest;
+import org.onap.optf.cmso.optimizer.service.rs.models.OptimizerResponse.OptimizeScheduleStatus;
+import org.onap.optf.cmso.optimizer.service.rs.models.PolicyInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.stereotype.Component;
+
+/**
+ * The Class OptimizerClient.
+ */
+@Component
+public class OptimizerClient {
+    private static EELFLogger debug = EELFManager.getInstance().getDebugLogger();
+
+    @Autowired
+    Environment env;
+
+    @Autowired
+    PropertiesManagement pm;
+
+    @Autowired
+    RequestDao requestDao;
+
+    @Autowired
+    TopologyRequestManager topologyRequestManager;
+
+    @Autowired
+    TicketMgtRequestManager ticketMgtRequestManager;
+
+    @Autowired
+    OptimizerDao optimizerDao;
+
+    @Autowired
+    PolicyManager policyManager;
+
+    /**
+     * Make request.
+     *
+     * @param request the request
+     * @param optimizer the Optimizer
+     * @return the Optimizer response
+     */
+    public OptimizerEngineResponse makeRequest(Request request, Optimizer optimizer) {
+        Integer maxAttempts = env.getProperty("cmso.optimizer.maxAttempts", Integer.class, 20);
+        OptimizerEngineResponse apiResponse = new OptimizerEngineResponse();
+        if (optimizer.getOptimizeRetries() >= maxAttempts) {
+            apiResponse.setStatus(OptimizerEngineResponseStatus.FAILED);
+            apiResponse.setErrorMessage(LogMessages.EXCEEDED_RETRY_LIMIT.format("Optimizer", maxAttempts.toString()));
+            Observation.report(LogMessages.EXCEEDED_RETRY_LIMIT, "Optimizer", maxAttempts.toString());
+            return apiResponse;
+        }
+        OptimizerRequest optimizerRequest = null;
+        TopologyResponse topologyResponse = null;
+        ActiveTicketsResponse ticketResponse = null;
+        try {
+            optimizerRequest = getOptimizerRequest(request);
+            topologyResponse = getTopologyResponse(request.getUuid());
+            ticketResponse   = getTicketResponse(request.getUuid());
+            OptimizerParameters optimizerParameters =
+                            buildOptimizerParameters(optimizerRequest, topologyResponse, ticketResponse);
+            apiResponse = initiateOptimizer(optimizerParameters, request);
+        } catch (Exception e) {
+            apiResponse.setStatus(OptimizerEngineResponseStatus.FAILED);
+            apiResponse.setErrorMessage(LogMessages.UNEXPECTED_EXCEPTION.format(e.getMessage()));
+            Observation.report(LogMessages.UNEXPECTED_EXCEPTION, e, e.getMessage());
+        }
+        return apiResponse;
+    }
+
+    private OptimizerParameters buildOptimizerParameters(OptimizerRequest optimizerRequest,
+                    TopologyResponse topologyResponse, ActiveTicketsResponse ticketResponse) throws ParseException {
+        List<TimeLimitAndVerticalTopology> policies = getPolicies(optimizerRequest);
+        OptimizerParameters parameters = new OptimizerParameters();
+        ElementAvailability elementAvailability =
+                        new ElementAvailability(policies, optimizerRequest, topologyResponse, ticketResponse);
+        elementAvailability.populate(parameters);
+
+        // Policies for this are undefined...
+        parameters.setAttributes(getAttributes(policies, optimizerRequest));
+        parameters.setAttributesRange(getAttributesRange(policies, optimizerRequest));
+        parameters.setAttributeConcurrencyLimit(getAttributeConcrrencyLimit(policies, optimizerRequest));
+        parameters.setNumAttributes(new Long(parameters.getAttributesRange().size()));
+        return parameters;
+    }
+
+    private List<List<Long>> getAttributeConcrrencyLimit(List<TimeLimitAndVerticalTopology> policies,
+                    OptimizerRequest optimizerRequest) {
+        List<List<Long>> list = new ArrayList<>();
+        return list;
+    }
+
+    private List<Long> getAttributesRange(List<TimeLimitAndVerticalTopology> policies,
+                    OptimizerRequest optimizerRequest) {
+        List<Long> list = new ArrayList<>();
+        return list;
+    }
+
+    private List<List<Long>> getAttributes(List<TimeLimitAndVerticalTopology> policies,
+                    OptimizerRequest optimizerRequest) {
+        List<List<Long>> list = new ArrayList<>();
+        return list;
+    }
+
+
+    private List<TimeLimitAndVerticalTopology> getPolicies(OptimizerRequest optimizerRequest) {
+        List<TimeLimitAndVerticalTopology> list = new ArrayList<>();
+        for (PolicyInfo policyInfo : optimizerRequest.getPolicies()) {
+            TimeLimitAndVerticalTopology policy =
+                            policyManager.getTimeLimitAndVerticalTopologyByName(policyInfo.getPolicyName());
+            list.add(policy);
+        }
+        return list;
+    }
+
+    private ActiveTicketsResponse getTicketResponse(UUID uuid)
+                    throws JsonParseException, JsonMappingException, IOException {
+        Ticket ticketRow = ticketMgtRequestManager.getExistingTickets(uuid);
+        String ticketString = ticketRow.getTickets();
+        ObjectMapper om = new ObjectMapper();
+        return om.readValue(ticketString, ActiveTicketsResponse.class);
+    }
+
+    private TopologyResponse getTopologyResponse(UUID uuid)
+                    throws JsonParseException, JsonMappingException, IOException {
+        Topology topologyRow = topologyRequestManager.getExistingTopology(uuid);
+        String topologyString = topologyRow.getTopology();
+        ObjectMapper om = new ObjectMapper();
+        return om.readValue(topologyString, TopologyResponse.class);
+    }
+
+    private OptimizerRequest getOptimizerRequest(Request request)
+                    throws JsonParseException, JsonMappingException, IOException {
+        String requestString = request.getRequest();
+        ObjectMapper om = new ObjectMapper();
+        return om.readValue(requestString, OptimizerRequest.class);
+    }
+
+
+    private OptimizerEngineResponse initiateOptimizer(OptimizerParameters request, Request requestRow)
+                    throws CmsoException, JsonProcessingException {
+
+
+        UUID uuid = requestRow.getUuid();
+        OptimizerEngineResponse apiResponse = new OptimizerEngineResponse();
+        apiResponse.setRequestId(uuid.toString());
+
+        String workingFolderString = env.getProperty("cmso.optimizer.engine.working.folder", "data/engine");
+        File workingFolder = new File(workingFolderString + File.separator + requestRow.getUuid().toString());
+        workingFolder.mkdirs();
+        Long timeLimit = env.getProperty("cmso.minizinc.command.timelimit", Long.class);
+        // TODO calculate time limit
+        Process p = null;
+        try {
+            Path inputFileName = Paths.get(workingFolder.getAbsolutePath(), "input.dzn");
+            Path outputFileName = Paths.get(workingFolder.getAbsolutePath(), "results.yaml");
+            String dzn = request.toMiniZinc();
+            Files.write(inputFileName, dzn.getBytes());
+            List<String> command = buildCommand(inputFileName, outputFileName, timeLimit.toString());
+            debug.debug("engine command=", command.toString());
+            ProcessBuilder pb = new ProcessBuilder(command);
+            p = pb.start();
+            String stdout = IOUtils.toString(p.getInputStream(), "UTF-8");
+            String stderr = IOUtils.toString(p.getErrorStream(), "UTF-8");
+            debug.debug("stdout=" + stdout);
+            debug.debug("stderr=" + stderr);
+            if (p.isAlive()) {
+                p.wait();
+            }
+            OptimizerResponseUtility responseUtility = new OptimizerResponseUtility();
+            OptimizerResults optimizerResults = responseUtility.parseOptimizerResult(outputFileName.toFile());
+            apiResponse.setOptimizerResults(optimizerResults);
+            apiResponse.setStatus(OptimizerEngineResponseStatus.COMPLETED);
+
+        } catch (InterruptedException e) {
+            apiResponse.setStatus(OptimizerEngineResponseStatus.FAILED);
+            apiResponse.setErrorMessage(
+                            LogMessages.OPTIMIZER_REQUEST_TIMEOUT.format(uuid.toString(), timeLimit.toString()));
+            Observation.report(LogMessages.OPTIMIZER_REQUEST_TIMEOUT, uuid.toString(), timeLimit.toString());
+            p.destroyForcibly();
+        } catch (Exception e) {
+            apiResponse.setStatus(OptimizerEngineResponseStatus.FAILED);
+            apiResponse.setErrorMessage(LogMessages.UNEXPECTED_EXCEPTION.format(e.getMessage()));
+            Observation.report(LogMessages.UNEXPECTED_RESPONSE, e, e.getMessage());
+        } finally {
+            if (workingFolder.exists()) {
+                workingFolder.delete();
+            }
+        }
+        return apiResponse;
+    }
+
+    private List<String> buildCommand(Path inputFileName, Path outputFileName, String timeLimit) {
+        List<String> command = new ArrayList<>();
+        String minizinc = env.getProperty("cmso.minizinc.command.exe", "minizinc");
+        String solver = env.getProperty("cmso.minizinc.command.solver", "OSICBC");
+        String additional = env.getProperty("cmso.minizinc.command.additional", "");
+        String script = env.getProperty("cmso.minizinc.command.mzn", "scripts/minizinc/generic_attributes.mzn");
+
+        command.add(minizinc);
+        command.add("--solver");
+        command.add(solver);
+        command.add("--time-limit");
+        command.add(timeLimit);
+        command.add("--time-limit");
+        command.add(timeLimit);
+        command.add("--soln-sep");
+        command.add("\"\"");
+        command.add("--search-complete-msg");
+        command.add("\"\"");
+        for (String add : additional.split(" ")) {
+            command.add(add);
+        }
+        command.add("-o");
+        command.add(outputFileName.toString());
+        command.add(script);
+        command.add(inputFileName.toString());
+        return command;
+    }
+
+
+}