add README

README.md

@@ -1,18 +1,16 @@
-# iFrame Link Extractor
+# Pad Stratum0 Link Extractor
 
 ## Beschreibung
 
-Dieses Go-Programm verwendet die go-rod Bibliothek, um den Inhalt von verschachtelten iFrames auf einer Webseite zu extrahieren und alle darin enthaltenen HTTPS-Links zu identifizieren und auszugeben. Es ist besonders nützlich für Webseiten mit komplexen iFrame-Strukturen, bei denen der Zugriff auf den Inhalt tiefer verschachtelter iFrames erforderlich ist.
+Dieses Go-Programm ist ein spezialisierter Web Scraper, der entwickelt wurde, um Links von der Pad Stratum0 Plattform zu extrahieren. Es navigiert durch verschachtelte iFrames und sammelt alle URLs, die mit "https://pad.stratum0.org/p/dc" beginnen.
 
 ## Funktionen
 
-- Navigiert zu einer angegebenen URL
-- Wartet auf das Laden der Hauptseite
-- Findet und wechselt in den Kontext eines äußeren iFrames
-- Findet und wechselt in den Kontext eines inneren iFrames innerhalb des äußeren iFrames
-- Extrahiert den Textinhalt des inneren iFrames
-- Identifiziert alle HTTPS-Links im extrahierten Text
-- Gibt die gefundenen Links aus
+- Extrahiert Links von einer initialen URL und folgt diesen rekursiv bis zu einer konfigurierbaren maximalen Tiefe.
+- Navigiert durch verschachtelte iFrames, um versteckte Links zu finden.
+- Vermeidet doppelte Besuche von URLs.
+- Bietet detaillierte Konsolenausgaben über den Fortschritt des Scrapings.
+- Sammelt Statistiken über gefundene und besuchte Links.
 
 ## Voraussetzungen
 
@@ -25,8 +23,8 @@ Dieses Go-Programm verwendet die go-rod Bibliothek, um den Inhalt von verschacht
 
 2. Klonen Sie das Repository:
    ```
-   git clone https://github.com/yourusername/iframe-link-extractor.git
-   cd iframe-link-extractor
+   git clone https://github.com/yourusername/pad-stratum0-link-extractor.git
+   cd pad-stratum0-link-extractor
    ```
 
 3. Installieren Sie die erforderlichen Abhängigkeiten:
@@ -34,26 +32,43 @@ Dieses Go-Programm verwendet die go-rod Bibliothek, um den Inhalt von verschacht
    go mod tidy
    ```
 
+## Konfiguration
+
+Sie können die maximale Suchtiefe anpassen, indem Sie den Wert der `maxDepth` Variable am Anfang der `main.go` Datei ändern:
+
+```go
+maxDepth = 3 // Ändern Sie diesen Wert nach Bedarf
+```
+
 ## Verwendung
 
-1. Öffnen Sie die `main.go` Datei und passen Sie die URL und iFrame-Selektoren an Ihre Zielwebseite an.
-
-2. Führen Sie das Programm aus:
+1. Führen Sie das Programm aus:
    ```
    go run main.go
    ```
 
-3. Das Programm wird die gefundenen HTTPS-Links in der Konsole ausgeben.
+2. Das Programm wird mit der Extraktion von Links beginnen und den Fortschritt in der Konsole ausgeben.
+
+3. Nach Abschluss wird eine Liste aller gefundenen Links sowie Statistiken angezeigt.
+
+## Ausgabe
+
+Das Programm gibt folgende Informationen aus:
+
+- Fortschrittsmeldungen für jede verarbeitete URL
+- Informationen über gefundene und geladene iFrames
+- Eine Liste aller gefundenen einzigartigen Links
+- Statistiken über die Gesamtanzahl der gefundenen Links, besuchten URLs und die Gesamtlaufzeit
 
 ## Anpassung
 
-- Um auf spezifische Elemente innerhalb der iFrames zu warten, können Sie zusätzliche `MustElement().MustWaitVisible()` Aufrufe hinzufügen.
-- Der reguläre Ausdruck für die Link-Erkennung kann angepasst werden, um spezifischere URL-Muster zu erfassen.
+- Um andere Websites zu scrapen, passen Sie die initiale URL und den regulären Ausdruck für die Link-Erkennung an.
+- Für komplexere Scraping-Logik können Sie die `extractLinks` Funktion modifizieren.
 
 ## Fehlerbehebung
 
-- Wenn Sie Probleme mit Timeouts haben, erhöhen Sie die Wartezeiten mit `page.Timeout()` oder `MustElement().WaitVisible()`.
-- Bei Problemen mit dem Zugriff auf iFrames aufgrund von Sicherheitseinstellungen, erwägen Sie die Verwendung zusätzlicher Browser-Optionen wie im Kommentar im Code beschrieben.
+- Wenn Sie Probleme mit dem Laden von iFrames haben, überprüfen Sie die CSS-Selektoren in der `processNestedIframes` Funktion.
+- Bei Timeout-Problemen können Sie die `MustWaitLoad` Aufrufe anpassen oder zusätzliche Wartezeiten einbauen.
 
 ## Beitrag
 
@@ -62,15 +77,16 @@ Beiträge zum Projekt sind willkommen. Bitte öffnen Sie ein Issue oder einen Pu
 ## Lizenz
 
 [Fügen Sie hier Ihre gewählte Lizenz ein, z.B. MIT, GPL, etc.]
+
 ```
 
 Diese README.md bietet eine umfassende Übersicht über Ihr Projekt und enthält Abschnitte für:
 
-1. Eine kurze Beschreibung des Projekts
-2. Die Hauptfunktionen
-3. Voraussetzungen für die Nutzung
-4. Installationsanweisungen
-5. Verwendungshinweise
+1. Eine Beschreibung des Projekts und seiner Hauptfunktionen
+2. Installationsanweisungen
+3. Konfigurationsmöglichkeiten
+4. Verwendungshinweise
+5. Erklärung der Ausgabe
 6. Anpassungsmöglichkeiten
 7. Tipps zur Fehlerbehebung
 8. Informationen zum Beitragen zum Projekt

scraper.go

@@ -3,18 +3,96 @@ package main
 import (
     "fmt"
     "regexp"
+    "time"
     "github.com/go-rod/rod"
 )
 
+var (
+    visitedURLs = make(map[string]bool)
+    allLinks    = make(map[string]bool)
+    maxDepth    = 3 // Hier können Sie die maximale Tiefe festlegen
+)
+
 func main() {
+    fmt.Println("Starte das Programm...")
+    startTime := time.Now()
+
     browser := rod.New().MustConnect()
     defer browser.MustClose()
 
-    page := browser.MustPage("https://pad.stratum0.org/p/dc") // URL der Hauptseite
+    initialURL := "https://pad.stratum0.org/p/dc"
+    fmt.Printf("Beginne mit der initialen URL: %s\n", initialURL)
+    fmt.Printf("Maximale Tiefe: %d\n", maxDepth)
+
+    toVisit := []struct {
+        url   string
+        depth int
+    }{{initialURL, 0}}
+
+    for len(toVisit) > 0 {
+        current := toVisit[0]
+        toVisit = toVisit[1:]
+
+        newLinks := extractLinksFromPage(browser, current.url, current.depth)
+
+        for _, link := range newLinks {
+            if !visitedURLs[link] && current.depth < maxDepth {
+                toVisit = append(toVisit, struct {
+                    url   string
+                    depth int
+                }{link, current.depth + 1})
+            }
+        }
+    }
+
+    fmt.Println("\nAlle gefundenen Links:")
+    for link := range allLinks {
+        fmt.Println(link)
+    }
+
+    fmt.Printf("\nStatistik:\n")
+    fmt.Printf("Gesamtanzahl der gefundenen Links: %d\n", len(allLinks))
+    fmt.Printf("Anzahl der besuchten URLs: %d\n", len(visitedURLs))
+    fmt.Printf("Gesamtzeit: %v\n", time.Since(startTime))
+}
+
+func extractLinksFromPage(browser *rod.Browser, url string, depth int) []string {
+    fmt.Printf("\nVerarbeite URL: %s (Tiefe: %d)\n", url, depth)
+
+    if depth > maxDepth {
+        fmt.Printf("Maximale Tiefe erreicht für URL: %s\n", url)
+        return nil
+    }
+
+    if visitedURLs[url] {
+        fmt.Printf("URL bereits besucht: %s\n", url)
+        return nil
+    }
+
+    visitedURLs[url] = true
+
+    page := browser.MustPage(url)
+    defer page.MustClose()
     page.MustWaitLoad()
 
+    fmt.Printf("Seite geladen: %s\n", url)
+
+    var newLinks []string
+
+    // Verarbeite die Hauptseite
+    newLinks = append(newLinks, extractLinks(page, url)...)
+
+    // Verarbeite die verschachtelten iFrames
+    newLinks = append(newLinks, processNestedIframes(page, url)...)
+
+    return newLinks
+}
+
+func processNestedIframes(page *rod.Page, sourceURL string) []string {
+    fmt.Printf("Suche nach äußerem iFrame auf %s\n", sourceURL)
+
     // Finden Sie das erste iFrame-Element
-    outerIframeElement := page.MustElement("#editorcontainer > iframe:nth-child(1)") // Passen Sie den Selektor an
+    outerIframeElement := page.MustElement("#editorcontainer > iframe:nth-child(1)")
 
     // Wechseln Sie zum Kontext des ersten iFrames
     outerFrame := outerIframeElement.MustFrame()
@@ -22,22 +100,44 @@ func main() {
     // Warten Sie, bis der Inhalt des ersten iFrames geladen ist
     outerFrame.MustWaitLoad()
 
+    fmt.Printf("Äußeres iFrame geladen auf %s\n", sourceURL)
+
+    // Extrahiere Links aus dem äußeren iFrame
+    outerLinks := extractLinks(outerFrame, sourceURL+" (äußeres iFrame)")
+
+    fmt.Printf("Suche nach innerem iFrame auf %s\n", sourceURL)
+
     // Finden Sie das zweite iFrame-Element innerhalb des ersten iFrames
-    innerIframeElement := outerFrame.MustElement("#outerdocbody > iframe:nth-child(1)") // Passen Sie den Selektor an
+    innerIframeElement := outerFrame.MustElement("#outerdocbody > iframe:nth-child(1)")
 
     // Wechseln Sie zum Kontext des zweiten iFrames
     innerFrame := innerIframeElement.MustFrame()
     innerFrame.MustWaitLoad()
 
-    // Extrahieren Sie den Text aus dem zweiten iFrame (Benutze statt #innderdocbody auch body für jedes Element)
-    text := innerFrame.MustElement("#innerdocbody").MustText()
+    fmt.Printf("Inneres iFrame geladen auf %s\n", sourceURL)
 
-    // Regex zum Finden von Links, die mit https beginnen
-    re := regexp.MustCompile(`https://[\w\.-]+(?:/[\w\.-]*)*`)
-    httpsLinks := re.FindAllString(text, -1)
+    // Extrahiere Links aus dem inneren iFrame
+    innerLinks := extractLinks(innerFrame, sourceURL+" (inneres iFrame)")
 
-    fmt.Println("Gefundene https-Links:")
-    for _, link := range httpsLinks {
-        fmt.Println(link)
-    }
+    return append(outerLinks, innerLinks...)
+}
+
+func extractLinks(page *rod.Page, sourceURL string) []string {
+    text := page.MustElement("body").MustText()
+
+    re := regexp.MustCompile(`https://pad\.stratum0\.org/p/dc[^\s"']+`)
+    links := re.FindAllString(text, -1)
+
+    fmt.Printf("Gefundene Links auf %s: %d\n", sourceURL, len(links))
+
+    var newLinks []string
+    for _, link := range links {
+        if !allLinks[link] {
+            allLinks[link] = true
+            fmt.Printf("Neuer Link gefunden: %s\n", link)
+            newLinks = append(newLinks, link)
+        }
+    }
+
+    return newLinks
 }