o More common XML parsing and HTTP client code. o Reimplemented the Nexus code to consume the timeline instead of calculating its own diff.

5 files changed, 413 insertions, 178 deletions

diff --git a/src/main/java/io/trygvis/esper/testing/nexus/ArtifactDto.java b/src/main/java/io/trygvis/esper/testing/nexus/ArtifactDto.java
index 144913e..b732bfa 100644..100755
--- a/src/main/java/io/trygvis/esper/testing/nexus/ArtifactDto.java
+++ b/src/main/java/io/trygvis/esper/testing/nexus/ArtifactDto.java
@@ -2,32 +2,20 @@ package io.trygvis.esper.testing.nexus;
 
 import fj.data.*;
 
-import java.net.*;
+import java.util.*;
 
 public class ArtifactDto implements Comparable<ArtifactDto> {
-    public final URI serverUrl;
+    public final UUID uuid;
     public final String repositoryId;
     public final ArtifactId id;
 
-    public ArtifactDto(URI serverUrl, String repositoryId, ArtifactId id) {
-        this.serverUrl = serverUrl;
+    public ArtifactDto(UUID uuid, String repositoryId, ArtifactId id) {
+        this.uuid = uuid;
         this.repositoryId = repositoryId;
         this.id = id;
     }
 
     public int compareTo(ArtifactDto o) {
-        int i = serverUrl.compareTo(o.serverUrl);
-
-        if (i != 0) {
-            return i;
-        }
-
-        i = repositoryId.compareTo(o.repositoryId);
-
-        if (i != 0) {
-            return i;
-        }
-
         return id.compareTo(o.id);
     }
 
@@ -37,17 +25,11 @@ public class ArtifactDto implements Comparable<ArtifactDto> {
 
         ArtifactDto that = (ArtifactDto) o;
 
-        if (!serverUrl.equals(that.serverUrl)) return false;
-        if (!repositoryId.equals(that.repositoryId)) return false;
-
-        return id.equals(that.id);
+        return uuid.equals(that.uuid);
     }
 
     public int hashCode() {
-        int result = serverUrl.hashCode();
-        result = 31 * result + repositoryId.hashCode();
-        result = 31 * result + id.hashCode();
-        return result;
+        return uuid.hashCode();
     }
 }
 
diff --git a/src/main/java/io/trygvis/esper/testing/nexus/NexusClient.java b/src/main/java/io/trygvis/esper/testing/nexus/NexusClient.java
index 9b2b899..02dc28c 100755
--- a/src/main/java/io/trygvis/esper/testing/nexus/NexusClient.java
+++ b/src/main/java/io/trygvis/esper/testing/nexus/NexusClient.java
@@ -3,31 +3,52 @@ package io.trygvis.esper.testing.nexus;
 import fj.data.*;
 import static fj.data.Option.*;
 import static io.trygvis.esper.testing.nexus.SearchNGResponseParser.*;
+import io.trygvis.esper.testing.util.*;
 import org.apache.commons.io.*;
 import org.apache.commons.lang.*;
 import static org.codehaus.httpcache4j.HTTPMethod.*;
 import org.codehaus.httpcache4j.*;
 import org.codehaus.httpcache4j.cache.*;
 import org.codehaus.httpcache4j.util.*;
+import org.jdom2.*;
 
 import java.io.*;
 import java.net.*;
+import java.util.*;
 import javax.xml.stream.*;
 
 public class NexusClient {
     private final HTTPCache http;
+
     private final URI nexusUrl;
 
+    private final XmlHttpClient xmlHttpClient;
+
     public NexusClient(HTTPCache http, URI nexusUrl) {
         this.http = http;
         this.nexusUrl = nexusUrl;
+        this.xmlHttpClient = new XmlHttpClient(http);
+    }
+
+    public NexusFeed fetchTimeline(String timeline) throws IOException {
+        URI uri = URI.create(nexusUrl.toASCIIString() + "/service/local/feeds/" + timeline);
+
+        Option<Document> d = xmlHttpClient.fetch(uri);
+
+        if (d.isNone()) {
+            return new NexusFeed(Collections.<NexusEvent>emptyList());
+        }
+
+        Document document = d.some();
+
+        return NexusFeedParser.parseDocument(document);
     }
 
     public ArtifactSearchResult fetchIndex(String groupId, Option<String> repositoryId) throws IOException {
         ArtifactSearchResult aggregate = fetchIndexPage(groupId, repositoryId, Option.<Integer>none());
         ArtifactSearchResult result = aggregate;
 
-        while(result.artifacts.size() > 0) {
+        while (result.artifacts.size() > 0) {
             result = fetchIndexPage(groupId, repositoryId, some(aggregate.artifacts.size()));
             aggregate = aggregate.append(result);
         }
diff --git a/src/main/java/io/trygvis/esper/testing/nexus/NexusDao.java b/src/main/java/io/trygvis/esper/testing/nexus/NexusDao.java
index c5e8742..cb93a63 100755
--- a/src/main/java/io/trygvis/esper/testing/nexus/NexusDao.java
+++ b/src/main/java/io/trygvis/esper/testing/nexus/NexusDao.java
@@ -3,8 +3,7 @@ package io.trygvis.esper.testing.nexus;
 import fj.data.*;
 import static fj.data.Option.*;
 import io.trygvis.esper.testing.*;
-import static io.trygvis.esper.testing.DaoUtil.timestampToLocalDateTime;
-import org.joda.time.*;
+import static java.lang.System.currentTimeMillis;
 
 import java.net.*;
 import java.sql.*;
@@ -13,6 +12,14 @@ import java.util.Date;
 import java.util.List;
 
 public class NexusDao {
+    public static final String NEXUS_SERVER = "uuid, url, name";
+
+    public static final String NEXUS_REPOSITORY = "uuid, server, id, group_ids";
+
+    private final String NEXUS_ARTIFACT_ID = "group_id, artifact_id, version";
+
+    private final String NEXUS_ARTIFACT = "uuid, repository, " + NEXUS_ARTIFACT_ID;
+
     private final Connection c;
 
     public NexusDao(Connection c) {
@@ -28,59 +35,65 @@ public class NexusDao {
         }
     }
 
+    private static ArtifactDto artifactDto(ResultSet rs) throws SQLException {
+        int i = 1;
+
+        return new ArtifactDto(
+                UUID.fromString(rs.getString(i++)),
+                rs.getString(i++),
+                new ArtifactId(rs.getString(i++),
+                        rs.getString(i++),
+                        rs.getString(i)));
+    }
+
     private NexusRepositoryDto nexusRepositoryDto(ResultSet rs) throws SQLException {
         int i = 1;
 
         return new NexusRepositoryDto(
-            rs.getString(i++),
-            uri(rs.getString(i++)),
-            (String[]) rs.getArray(i++).getArray(),
-            fromNull(rs.getTimestamp(i++)).map(timestampToLocalDateTime),
-            fromNull(rs.getTimestamp(i++)).map(timestampToLocalDateTime),
-            fromNull(rs.getTimestamp(i)).map(timestampToLocalDateTime)
+                UUID.fromString(rs.getString(i++)),
+                UUID.fromString(rs.getString(i++)),
+                rs.getString(i++),
+                (String[]) rs.getArray(i).getArray()
         );
     }
 
-    /*
-    public void insertRepository(String repositoryId, URI nexusUri, LocalDateTime discoveryDate) throws SQLException {
-        int i = 1;
-        try (PreparedStatement s = prepareStatement("INSERT INTO nexus_repository(id, uri, discovered_date) VALUES(?, ?, ?)")) {
-            s.setString(i++, repositoryId);
-            s.setString(i++, nexusUri.toASCIIString());
-            s.setTimestamp(i, new Timestamp(discoveryDate.toDateTime().getMillis()));
-            s.executeUpdate();
-        }
-    }
-    */
+    // -----------------------------------------------------------------------
+    // Nexus Artifact
+    // -----------------------------------------------------------------------
 
     public List<NexusServerDto> selectServer() throws SQLException {
-        try (PreparedStatement s = c.prepareStatement("SELECT url, name FROM nexus_server")) {
+        try (PreparedStatement s = c.prepareStatement("SELECT " + NEXUS_SERVER + " FROM nexus_server")) {
             ResultSet rs = s.executeQuery();
 
             List<NexusServerDto> servers = new ArrayList<>();
             while (rs.next()) {
-                servers.add(new NexusServerDto(uri(rs.getString(1)), rs.getString(2)));
+                int i = 1;
+                servers.add(new NexusServerDto(
+                        UUID.fromString(rs.getString(i++)),
+                        uri(rs.getString(i++)),
+                        rs.getString(i)));
             }
             return servers;
         }
     }
 
-    public Option<NexusRepositoryDto> findRepository(String repositoryId) throws SQLException {
-        try (PreparedStatement s = c.prepareStatement("SELECT id, server_url, group_ids, discovery_date, last_update, last_successful_update FROM nexus_repository WHERE id=?")) {
-            s.setString(1, repositoryId);
+    public Option<NexusRepositoryDto> findRepository(UUID server, String repositoryId) throws SQLException {
+        try (PreparedStatement s = c.prepareStatement("SELECT " + NEXUS_REPOSITORY + " FROM nexus_repository WHERE server=? AND id=?")) {
+            s.setString(1, server.toString());
+            s.setString(2, repositoryId);
 
-            try (ResultSet rs = s.executeQuery()) {
-                if (!rs.next()) {
-                    return Option.none();
-                }
+            ResultSet rs = s.executeQuery();
 
-                return some(nexusRepositoryDto(rs));
+            if (!rs.next()) {
+                return Option.none();
             }
+
+            return some(nexusRepositoryDto(rs));
         }
     }
 
     public List<NexusRepositoryDto> findRepositories(URI nexusUrl) throws SQLException {
-        try (PreparedStatement s = c.prepareStatement("SELECT id, server_url, group_ids, created_date, last_update, last_successful_update FROM nexus_repository WHERE server_url=?")) {
+        try (PreparedStatement s = c.prepareStatement("SELECT " + NEXUS_REPOSITORY + " FROM nexus_repository WHERE server=?")) {
             s.setString(1, nexusUrl.toASCIIString());
 
             List<NexusRepositoryDto> list = new ArrayList<>();
@@ -94,14 +107,6 @@ public class NexusDao {
         }
     }
 
-    // -----------------------------------------------------------------------
-    // Nexus Artifact
-    // -----------------------------------------------------------------------
-
-    private final String NEXUS_ARTIFACT_ID = "group_id, artifact_id, version";
-
-    private final String NEXUS_ARTIFACT = NEXUS_ARTIFACT_ID + ", snapshot_version, classifiers, packagings, created_date";
-
     private int setArtifactId(int i, PreparedStatement s, ArtifactId id) throws SQLException {
         s.setString(i++, id.groupId);
         s.setString(i++, id.artifactId);
@@ -109,45 +114,24 @@ public class NexusDao {
         return i;
     }
 
-    private static ArtifactDto artifactDto(URI serverUrl, String repositoryId, ResultSet rs) throws SQLException {
-        int i = 1;
+    public UUID insertArtifact(UUID repository, ArtifactId id) throws SQLException {
+        try (PreparedStatement s = c.prepareStatement("INSERT INTO nexus_artifact(" + NEXUS_ARTIFACT + ") VALUES(?, ?, ?, ?, ?)")) {
+            UUID uuid = UUID.randomUUID();
 
-        return new ArtifactDto(
-            serverUrl,
-            repositoryId,
-            new ArtifactId(rs.getString(i++),
-                rs.getString(i++),
-                rs.getString(i)));
-    }
-
-    public void insertArtifact(URI nexusUrl, String repositoryId, ArtifactId id, Option<String> snapshotVersion, List<ArtifactFile> files, Date createdDate) throws SQLException {
-        String[] classifiers = new String[files.size()];
-        String[] packagings = new String[files.size()];
-
-        for (int i = 0; i < files.size(); i++) {
-            classifiers[i] = files.get(i).classifier.toNull();
-            packagings[i] = files.get(i).extension;
-        }
-
-        int i = 1;
-        try (PreparedStatement s = c.prepareStatement("INSERT INTO nexus_artifact(server_url, repository_id, " + NEXUS_ARTIFACT + ") VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)")) {
-            s.setString(i++, nexusUrl.toASCIIString());
-            s.setString(i++, repositoryId);
-            i = setArtifactId(i, s, id);
-            s.setString(i++, snapshotVersion.toNull());
-            s.setArray(i++, c.createArrayOf("varchar", classifiers));
-            s.setArray(i++, c.createArrayOf("varchar", packagings));
-            s.setTimestamp(i, DaoUtil.dateToTimestamp.f(createdDate));
+            int i = 1;
+            s.setString(i++, uuid.toString());
+            s.setString(i++, repository.toString());
+            setArtifactId(i, s, id);
             s.executeUpdate();
+
+            return uuid;
         }
     }
 
-    public void deleteArtifact(URI nexusUrl, String repositoryId, ArtifactId id) throws SQLException {
+    public void deleteArtifact(UUID uuid) throws SQLException {
         int i = 1;
-        try (PreparedStatement s = c.prepareStatement("DELETE FROM nexus_artifact WHERE server_url=? AND repository_id=? AND group_id=? AND artifact_id=? AND version=?")) {
-            s.setString(i++, nexusUrl.toASCIIString());
-            s.setString(i++, repositoryId);
-            i += setArtifactId(i, s, id);
+        try (PreparedStatement s = c.prepareStatement("DELETE FROM nexus_artifact WHERE uuid=?")) {
+            s.setString(i, uuid.toString());
             s.executeUpdate();
         }
     }
@@ -160,53 +144,101 @@ public class NexusDao {
 
             List<ArtifactDto> list = new ArrayList<>();
             while (rs.next()) {
-                list.add(artifactDto(url, repositoryId, rs));
+                list.add(artifactDto(rs));
             }
             return list;
         }
     }
+
+    public Option<ArtifactDto> findArtifact(UUID repository, ArtifactId id) throws SQLException {
+        try (PreparedStatement s = c.prepareStatement("SELECT " + NEXUS_ARTIFACT + " FROM nexus_artifact WHERE repository=? AND group_id=? AND artifact_id=? AND version =?")) {
+            int i = 1;
+            s.setString(i++, repository.toString());
+            setArtifactId(i, s, id);
+
+            ResultSet rs = s.executeQuery();
+            if (!rs.next()) {
+                return none();
+            }
+
+            return some(artifactDto(rs));
+        }
+    }
+
+//    public void updateSnapshotTimestamp(UUID uuid, String snapshotTimestamp) throws SQLException {
+//        try(PreparedStatement s = c.prepareStatement("UPDATE nexus_artifact SET snapshot_timestamp=? WHERE uuid=?")) {
+//            s.setString(1, snapshotTimestamp);
+//            s.setString(2, uuid.toString());
+//            s.executeUpdate();
+//        }
+//    }
+
+    public UUID insertNewSnapshotEvent(UUID artifact, String guid, String file, String snapshotTimestamp) throws SQLException {
+        try(PreparedStatement s = c.prepareStatement("INSERT INTO nexus_event(uuid, artifact, timestamp, guid, type, snapshot_timestamp, file) VALUES(?, ?, ?, ?, ?, ?, ?)")) {
+            UUID uuid = UUID.randomUUID();
+            int i = 1;
+            s.setString(i++, uuid.toString());
+            s.setString(i++, artifact.toString());
+            s.setTimestamp(i++, new Timestamp(currentTimeMillis()));
+            s.setString(i++, guid);
+            s.setString(i++, "new_snapshot");
+            s.setString(i++, snapshotTimestamp);
+            s.setString(i, file);
+            s.executeUpdate();
+            return uuid;
+        }
+    }
+
+    public int countEventByGuid(String guid) throws SQLException {
+        try (PreparedStatement s = c.prepareStatement("SELECT count(guid) FROM nexus_event WHERE guid=?")) {
+            s.setString(1, guid);
+            ResultSet rs = s.executeQuery();
+            rs.next();
+            return rs.getInt(1);
+        }
+    }
 }
 
 class NexusServerDto {
+    public final UUID uuid;
+
     public final URI url;
+
     public final String name;
 
-    NexusServerDto(URI url, String name) {
+    NexusServerDto(UUID uuid, URI url, String name) {
+        this.uuid = uuid;
         this.url = url;
         this.name = name;
     }
 
     public boolean equals(Object o) {
         if (this == o) return true;
-        if (!(o instanceof NexusServerDto)) return false;
+        if (o == null || getClass() != o.getClass()) return false;
 
         NexusServerDto that = (NexusServerDto) o;
 
-        if (!url.equals(that.url)) return false;
-
-        return true;
+        return uuid.equals(that.uuid);
     }
 
     public int hashCode() {
-        return url.hashCode();
+        return uuid.hashCode();
     }
 }
 
 class NexusRepositoryDto {
+    public final UUID uuid;
+
+    public final UUID server;
+
     public final String repositoryId;
-    public final URI nexusUrl;
+
     public final String[] groupIds;
-    public final Option<LocalDateTime> discoveryDate;
-    public final Option<LocalDateTime> lastUpdate;
-    public final Option<LocalDateTime> lastSuccessfulUpdate;
 
-    NexusRepositoryDto(String repositoryId, URI nexusUrl, String[] groupIds, Option<LocalDateTime> discoveryDate, Option<LocalDateTime> lastUpdate, Option<LocalDateTime> lastSuccessfulUpdate) {
+    NexusRepositoryDto(UUID uuid, UUID server, String repositoryId, String[] groupIds) {
+        this.uuid = uuid;
+        this.server = server;
         this.repositoryId = repositoryId;
-        this.nexusUrl = nexusUrl;
         this.groupIds = groupIds;
-        this.discoveryDate = discoveryDate;
-        this.lastUpdate = lastUpdate;
-        this.lastSuccessfulUpdate = lastSuccessfulUpdate;
     }
 }
-
diff --git a/src/main/java/io/trygvis/esper/testing/nexus/NexusFeedParser.java b/src/main/java/io/trygvis/esper/testing/nexus/NexusFeedParser.java
new file mode 100755
index 0000000..d85803f
--- /dev/null
+++ b/src/main/java/io/trygvis/esper/testing/nexus/NexusFeedParser.java
@@ -0,0 +1,132 @@
+package io.trygvis.esper.testing.nexus;
+
+import fj.*;
+import fj.data.*;
+import static fj.data.Option.*;
+import org.jdom2.*;
+import static org.jdom2.filter.Filters.*;
+import org.joda.time.*;
+import org.joda.time.format.*;
+
+import java.net.*;
+import java.util.*;
+import java.util.List;
+import java.util.regex.*;
+
+public class NexusFeedParser {
+    private static Namespace dc = Namespace.getNamespace("http://purl.org/dc/elements/1.1/");
+
+    public static NexusFeed parseDocument(Document document) {
+        List<Element> channels = document.getRootElement().getContent(element("channel"));
+
+        List<NexusEvent> events = new ArrayList<>();
+
+        if (channels.size() != 1) {
+            return new NexusFeed(events);
+        }
+
+        Element channel = channels.get(0);
+
+        for (Element item : channel.getContent(element("item"))) {
+            Option<NexusEvent> e = parseEvent(item);
+
+            if (e.isNone()) {
+                continue;
+            }
+
+            events.add(e.some());
+        }
+
+        return new NexusFeed(events);
+    }
+
+    public static Option<NexusEvent> parseEvent(Element item) {
+        String title = item.getChildText("title");
+
+        Option<String> guid = Option.fromNull(item.getChildText("guid"));
+        Option<String> creator = Option.fromNull(item.getChildText("creator", dc));
+        Option<DateTime> date = Option.fromNull(item.getChildText("date", dc)).bind(new F<String, Option<DateTime>>() {
+            @Override
+            public Option<DateTime> f(String s) {
+                try {
+                    return some(ISODateTimeFormat.dateTimeNoMillis().parseDateTime(s));
+                } catch (IllegalArgumentException e) {
+                    e.printStackTrace();
+                    return Option.none();
+                }
+            }
+        });
+
+        String[] strings = title.split(":");
+
+        String groupId;
+        String artifactId;
+        String version;
+        Option<String> classifier;
+
+        if (strings.length == 3) {
+            groupId = strings[0];
+            artifactId = strings[1];
+            version = strings[2];
+            classifier = Option.none();
+        } else if (strings.length == 4) {
+            groupId = strings[0];
+            artifactId = strings[1];
+            version = strings[2];
+            classifier = some(strings[3]);
+        } else {
+            return null;
+        }
+
+        if (guid.isNone() || creator.isNone() || date.isNone()) {
+            return null;
+        }
+
+        Pattern regexp = Pattern.compile("(.*)-([0-9]{8}\\.[0-9]{6}-[0-9]*)$");
+
+        Matcher matcher = regexp.matcher(version);
+
+        if (matcher.matches()) {
+            ArtifactId id = new ArtifactId(groupId, artifactId, matcher.group(1) + "-SNAPSHOT");
+            return Option.<NexusEvent>some(new NewSnapshotEvent(guid.some(), id, classifier, creator.some(),
+                    date.some(), matcher.group(2), URI.create(item.getChildText("link"))));
+        }
+
+        return none();
+    }
+}
+
+class NexusFeed {
+    List<NexusEvent> events = new ArrayList<>();
+
+    NexusFeed(List<NexusEvent> events) {
+        this.events = events;
+    }
+}
+
+abstract class NexusEvent {
+    public final String guid;
+    public final ArtifactId artifactId;
+    public final Option<String> classifier;
+    public final String creator;
+    public final DateTime date;
+
+    NexusEvent(String guid, ArtifactId artifactId, Option<String> classifier, String creator, DateTime date) {
+        this.guid = guid;
+        this.artifactId = artifactId;
+        this.classifier = classifier;
+        this.creator = creator;
+        this.date = date;
+    }
+}
+
+class NewSnapshotEvent extends NexusEvent {
+    public final String snapshotTimestamp;
+    public final URI url;
+
+    NewSnapshotEvent(String guid, ArtifactId artifactId, Option<String> classifier, String creator, DateTime date, String snapshotTimestamp, URI url) {
+        super(guid, artifactId, classifier, creator, date);
+        this.snapshotTimestamp = snapshotTimestamp;
+        this.url = url;
+    }
+}
diff --git a/src/main/java/io/trygvis/esper/testing/nexus/NexusImporter.java b/src/main/java/io/trygvis/esper/testing/nexus/NexusImporter.java
index ea57c43..8e49074 100755
--- a/src/main/java/io/trygvis/esper/testing/nexus/NexusImporter.java
+++ b/src/main/java/io/trygvis/esper/testing/nexus/NexusImporter.java
@@ -2,34 +2,34 @@ package io.trygvis.esper.testing.nexus;
 
 import com.jolbox.bonecp.*;
 import fj.data.*;
-import static fj.data.Option.*;
 import io.trygvis.esper.testing.*;
 import io.trygvis.esper.testing.object.*;
+import io.trygvis.esper.testing.util.*;
 import static java.lang.Thread.*;
+import static java.util.regex.Pattern.quote;
 import org.codehaus.httpcache4j.cache.*;
 
 import java.sql.*;
 import java.util.*;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.TreeMap;
+import java.util.List;
 import java.util.concurrent.atomic.*;
 
 public class NexusImporter {
     public static void main(String[] args) throws Exception {
         final Config config = Config.loadFromDisk();
-
-        final HTTPCache http = HttpClient.createHttpClient(config);
-
+        final HTTPCache http = HttpClient.createHttpCache(config);
+        final XmlParser xmlParser = new XmlParser();
         final BoneCPDataSource boneCp = config.createBoneCp();
 
+        XmlParser.debugXml = true;
+
         ObjectManager<NexusServerDto, ActorRef<NexusServer>> serverManager = new ObjectManager<>("Nexus server", Collections.<NexusServerDto>emptySet(), new ObjectFactory<NexusServerDto, ActorRef<NexusServer>>() {
             public ActorRef<NexusServer> create(NexusServerDto server) {
                 final NexusClient client = new NexusClient(http, server.url);
 
                 String name = server.name;
 
-                return ObjectUtil.threadedActor(name, config.nexusUpdateInterval, boneCp, new NexusServer(client, server));
+                return ObjectUtil.threadedActor(name, config.nexusUpdateInterval, boneCp, "Nexus Server: " + name, new NexusServer(client, server, xmlParser));
             }
         });
 
@@ -38,9 +38,13 @@ public class NexusImporter {
 
         while (shouldRun.get()) {
             try {
+                List<NexusServerDto> newKeys;
+
                 try (Connection c = boneCp.getConnection()) {
-                    serverManager.update(new NexusDao(c).selectServer());
+                    newKeys = new NexusDao(c).selectServer();
                 }
+
+                serverManager.update(newKeys);
             } catch (SQLException e) {
                 e.printStackTrace(System.out);
             }
@@ -58,92 +62,156 @@ class NexusServer implements TransactionalActor {
 
     public final NexusClient client;
     public final NexusServerDto server;
+    public final XmlParser xmlParser;
 
-    NexusServer(NexusClient client, NexusServerDto server) {
+    NexusServer(NexusClient client, NexusServerDto server, XmlParser xmlParser) {
         this.client = client;
         this.server = server;
+        this.xmlParser = xmlParser;
     }
 
+    @Override
     public void act(Connection c) throws Exception {
-        Date timestamp = new Date();
+
         NexusDao dao = new NexusDao(c);
 
-        String p = server.name;
+        NexusFeed feed = client.fetchTimeline("recentlyDeployedArtifacts");
 
-        for (NexusRepositoryDto repository : dao.findRepositories(server.url)) {
-            String p2 = p + "/" + repository.repositoryId;
+        int newEvents = 0, oldEvents = 0;
 
-            System.out.println(p2 + ": Updating repository: " + repository.repositoryId);
+        for (NexusEvent event : feed.events) {
 
-            TreeMap<ArtifactId, ArtifactXml> artifactsInNexus = new TreeMap<>();
+            if(dao.countEventByGuid(event.guid) != 0) {
+                oldEvents++;
+                continue;
+            }
 
-            for (String groupId : repository.groupIds) {
-                String p3 = p2 + "/" + groupId;
+            newEvents++;
 
-                System.out.println(p3 + ": Updating group id");
-                ArtifactSearchResult result = client.fetchIndex(groupId, some(repository.repositoryId));
-                System.out.println(p3 + ": Found " + result.artifacts.size() + " artifacts");
+            String repositoryId = event.guid.replaceAll("^" + quote(server.url.toASCIIString()) + "/content/repositories/([-a-zA-Z0-9]*)/.*", "$1");
 
-                for (ArtifactXml xml : result.artifacts) {
-                    artifactsInNexus.put(xml.id, xml);
-                }
+            if(repositoryId.length() == 0) {
+                continue;
+            }
 
-                System.out.println(p3 + ": Updating everything under group id");
-                result = client.fetchIndex(groupId + ".*", some(repository.repositoryId));
-                System.out.println(p3 + ": Found " + result.artifacts.size() + " artifacts");
+            Option<NexusRepositoryDto> r = dao.findRepository(server.uuid, repositoryId);
 
-                for (ArtifactXml xml : result.artifacts) {
-                    artifactsInNexus.put(xml.id, xml);
-                }
+            if(r.isNone()) {
+                continue;
             }
 
-            Map<ArtifactId, ArtifactDto> artifactsInDatabase = new HashMap<>();
-            for (ArtifactDto dto : dao.findArtifactsInRepository(server.url, repository.repositoryId)) {
-                artifactsInDatabase.put(dto.id, dto);
-            }
+            NexusRepositoryDto repository = r.some();
 
-            ArrayList<FlatArtifact> created = new ArrayList<>();
-            ArrayList<FlatArtifact> kept = new ArrayList<>();
-            ArrayList<ArtifactDto> removed = new ArrayList<>();
+            Option<ArtifactDto> a = dao.findArtifact(repository.uuid, event.artifactId);
 
-            for (ArtifactXml xml : artifactsInNexus.values()) {
-                Option<FlatArtifact> o = xml.flatten(repository.repositoryId);
+            if(event instanceof NewSnapshotEvent) {
+                NewSnapshotEvent newSnapshotEvent = (NewSnapshotEvent) event;
 
-                if(o.isNone()) {
-                    continue;
-                }
+                Option<String> snapshotTimestamp = Option.some(newSnapshotEvent.snapshotTimestamp);
 
-                FlatArtifact artifact = o.some();
+                UUID uuid;
 
-                if(!artifactsInDatabase.containsKey(xml.id)) {
-                    created.add(artifact);
+                if(a.isNone()) {
+                    System.out.println("New artifact: " + event.artifactId);
+                    List<ArtifactFile> files = Collections.emptyList();
+                    uuid = dao.insertArtifact(repository.uuid, event.artifactId);
                 }
                 else {
-                    kept.add(artifact);
-                }
-            }
-
-            for (ArtifactDto dto : artifactsInDatabase.values()) {
-                if(!artifactsInNexus.containsKey(dto.id)) {
-                    removed.add(dto);
-                }
-            }
+                    ArtifactDto artifact = a.some();
 
-            System.out.println(p2 + ": found " + created.size() + " new artifacts, " + removed.size() + " removed artifacts and " + kept.size() + " existing artifacts.");
+                    System.out.println("Updated artifact: " + event.artifactId);
+//                    dao.updateSnapshotTimestamp(artifact.uuid, newSnapshotEvent.snapshotTimestamp);
 
-            System.out.println(p2 + ": inserting new artifacts");
-            for (FlatArtifact artifact : created) {
-                dao.insertArtifact(repository.nexusUrl, repository.repositoryId, artifact.id, Option.<String>none(), artifact.files, timestamp);
-            }
-            System.out.println(p2 + ": inserted");
+                    uuid = artifact.uuid;
+                }
 
-            System.out.println(p2 + ": deleting removed artifacts");
-            for (ArtifactDto artifact : removed) {
-                dao.deleteArtifact(repository.nexusUrl, repository.repositoryId, artifact.id);
+                dao.insertNewSnapshotEvent(uuid, event.guid, newSnapshotEvent.url.toASCIIString(), newSnapshotEvent.snapshotTimestamp);
             }
-            System.out.println(p2 + ": deleted");
         }
 
-        c.commit();
+        System.out.println("Timeline updated. New=" + newEvents + ", old=" + oldEvents);
     }
+
+//    public void act(Connection c) throws Exception {
+//        Date timestamp = new Date();
+//        NexusDao dao = new NexusDao(c);
+//
+//        String p = server.name;
+//
+//        for (NexusRepositoryDto repository : dao.findRepositories(server.url)) {
+//            String p2 = p + "/" + repository.repositoryId;
+//
+//            System.out.println(p2 + ": Updating repository: " + repository.repositoryId);
+//
+//            TreeMap<ArtifactId, ArtifactXml> artifactsInNexus = new TreeMap<>();
+//
+//            for (String groupId : repository.groupIds) {
+//                String p3 = p2 + "/" + groupId;
+//
+//                System.out.println(p3 + ": Updating group id");
+//                ArtifactSearchResult result = client.fetchIndex(groupId, some(repository.repositoryId));
+//                System.out.println(p3 + ": Found " + result.artifacts.size() + " artifacts");
+//
+//                for (ArtifactXml xml : result.artifacts) {
+//                    artifactsInNexus.put(xml.id, xml);
+//                }
+//
+//                System.out.println(p3 + ": Updating everything under group id");
+//                result = client.fetchIndex(groupId + ".*", some(repository.repositoryId));
+//                System.out.println(p3 + ": Found " + result.artifacts.size() + " artifacts");
+//
+//                for (ArtifactXml xml : result.artifacts) {
+//                    artifactsInNexus.put(xml.id, xml);
+//                }
+//            }
+//
+//            Map<ArtifactId, ArtifactDto> artifactsInDatabase = new HashMap<>();
+//            for (ArtifactDto dto : dao.findArtifactsInRepository(server.url, repository.repositoryId)) {
+//                artifactsInDatabase.put(dto.id, dto);
+//            }
+//
+//            ArrayList<FlatArtifact> created = new ArrayList<>();
+//            ArrayList<FlatArtifact> kept = new ArrayList<>();
+//            ArrayList<ArtifactDto> removed = new ArrayList<>();
+//
+//            for (ArtifactXml xml : artifactsInNexus.values()) {
+//                Option<FlatArtifact> o = xml.flatten(repository.repositoryId);
+//
+//                if(o.isNone()) {
+//                    continue;
+//                }
+//
+//                FlatArtifact artifact = o.some();
+//
+//                if(!artifactsInDatabase.containsKey(xml.id)) {
+//                    created.add(artifact);
+//                }
+//                else {
+//                    kept.add(artifact);
+//                }
+//            }
+//
+//            for (ArtifactDto dto : artifactsInDatabase.values()) {
+//                if(!artifactsInNexus.containsKey(dto.id)) {
+//                    removed.add(dto);
+//                }
+//            }
+//
+//            System.out.println(p2 + ": found " + created.size() + " new artifacts, " + removed.size() + " removed artifacts and " + kept.size() + " existing artifacts.");
+//
+//            System.out.println(p2 + ": inserting new artifacts");
+//            for (FlatArtifact artifact : created) {
+//                dao.insertArtifact(repository.nexusUrl, repository.repositoryId, artifact.id, Option.<String>none(), artifact.files, timestamp);
+//            }
+//            System.out.println(p2 + ": inserted");
+//
+//            System.out.println(p2 + ": deleting removed artifacts");
+//            for (ArtifactDto artifact : removed) {
+//                dao.deleteArtifact(repository.nexusUrl, repository.repositoryId, artifact.id);
+//            }
+//            System.out.println(p2 + ": deleted");
+//        }
+//
+//        c.commit();
+//    }
 }