golang Einbettungsdatei für die spätere Analyse der Ausführung

Bin ich im wesentlichen versucht, zu Fuß durch einen Ordner mit html-Dateien. Ich will, Sie zu integrieren in die Binär-Datei und in der Lage sein, zu analysieren, Ihnen auf Anfrage für die Vorlage Ausführung Zwecken. (Bitte entschuldigen Sie mich, wenn im Wortlaut nicht, diese richtig).

Irgendwelche Ideen, Tipps, tricks oder besseren Weg, dies zu erreichen ist sehr geschätzt.

//Template Files
type TempFiles struct {
    Files map[string]string
}

//Loop through view files and load them
func LoadTempFiles() {
    t := new(TempFiles)

    //Load template files
    filepath.Walk("application/views", func(path string, info os.FileInfo, err error) error {
    if !info.IsDir() {
        content, _ := ioutil.ReadFile(path)
        t.Files[path] = string(content)
    }
    return nil
    })
}

func ViewTemp(w http.ResponseWriter, path string) {
    t := new(TempFiles)

    temp, err := template.New().Parse(t.Files[path])
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    } else {
        temp.Execute(w, nil)
    }
}

InformationsquelleAutor der Frage Brian Voelker | 2012-09-18

  1. 47

    Ich dies mit die meisten von meinen Go-web-apps. Ich benutze go-bindata automatisch generieren Gehen Sie source code von allen Dateien, die ich einbetten möchten, und kompilieren Sie Sie in die binäre.
    All dies geschieht automatisch beim bauen.

    Einzige Nachteil ist, dass die aktuelle go, build-tools nicht bieten einen Weg, um Haken in den build-Prozess, so nutze ich ein Makefile für diesen Zweck. Wenn das makefile aufgerufen wird, läuft es go-bindata zu generieren, die die Quellen für alle notwendigen Dateien, die dann in der Regel führt einige zusätzliche code-Generierung bits und bobs (insbesondere die Schaffung eines Geh-source-Datei listet alle eingebetteten Dateien in einer Karte.. Inhaltsverzeichnis, wenn man so will). Es geht dann weiter zur Kompilierung des eigentlichen Programms.

    Dies kann ein wenig chaotisch, aber Sie haben nur, um Sie alle auf einmal.
    Ein weiterer Nachteil ist, dass die Verwendung eines Makefiles bedeutet, die software ist nicht kompatibel mit der go get Befehl. Aber da die meisten meiner web-apps sind nicht dazu gedacht, geteilt zu werden, wie auch immer, das hat nicht ein problem gewesen bisher.

    Wenn es um das Debuggen/entwickeln einer solchen Anwendung ist ein weiteres Problem ergibt sich aus der Einbettung der statischen web-Inhalte: ich kann nicht nur Bearbeiten, eine HTML-oder CSS-Datei und aktualisieren Sie den browser, um zu sehen, seine Wirkung. Ich würde den server anzuhalten, neu erstellen und neu starten, mit jedem edit. Das ist natürlich nicht optimal, so dass ich split das Makefile in einem debug und release - Modus. Die release-Modus tut, was ich oben beschrieben habe. Den debug-Modus, jedoch wil eigentlich nicht einbetten der statischen Dateien. Es generiert Quell Dateien für jede von Ihnen, aber anstatt, dass Sie Sie enthalten die eigentlichen Daten, es enthält einen stub, die lädt einfach die Daten aus dem Dateisystem.

    Soweit der server-code ist besorgt, es gibt keinen Unterschied im generierten code. Alles was es tut ist rufen Sie eine Funktion zum abrufen der Inhalte von einem bestimmten statischen Datei. Ist es nicht egal, ob diese Inhalte tatsächlich eingebettet in das binäre, oder wenn es aus einer externen Quelle geladen. Also die beiden build-Modi sind frei austauschbar.

    Z.B. die generierte Funktion zu Holen, statische Datei-Inhalt in release und debug-Modus würde wie folgt Aussehen:

    Release-Modus:

    func index_html() []byte {
    return []byte {
        ....
    }
}

    Debug-Modus:

    func index_html() []byte {
   data, err := ioutil.ReadFile("index.html")
   ...
   return data
}

    Die Schnittstelle ist in beiden Fällen identisch. Dies ermöglicht eine einfache und rundum-sorglos-Entwicklung und debugging.

    InformationsquelleAutor der Antwort jimt

  2. 16

    Einem anderen Werkzeug zu betrachten: ein Weiteres Aktuelles gutes Werkzeug kommt aus esc: die Einbettung von Statischen Elemente in Go (GitHub repo)

    Programm:

    • kann einige Verzeichnisse und rekursiv einbetten alle Dateien in einer Weise, die kompatibel mit http.Dateisystem
    • kann Optional deaktiviert werden, für die Verwendung mit dem lokalen Datei-system für die lokale Entwicklung
    • wird sich nicht ändern die Ausgabe-Datei auf der anschließenden läuft
    • hat angemessene Größe der diffs, wenn Dateien geändert
    • ist vendoring-freundliche

    Vendoring-freundlich bedeutet, dass, wenn ich laufen godep oder Partei, die die statische Datei einbetten wird sich nicht ändern.

    Dies bedeutet, es dürfen nicht irgendwelche Dritten die Einfuhr (da Ihre import-Pfad umgeschrieben werden während goimports, und so anders als das, was das tool selbst produziert), oder einen definierbaren Standort für die benötigte third-party-Importe.

    Es erzeugt schöne, Gzip-Saiten, eine pro-Datei.

    Es ist ein einfaches flag zur Aktivierung der lokalen Entwicklung-Modus, der ist schlau genug, um nicht strip Verzeichnis Präfixe aus Dateinamen (eine option in esc wird manchmal benötigt).

    Die Ausgabe enthält alle erforderlichen code, und ist nicht abhängig von irgendeinem third-party-Bibliotheken, die für die Kompatibilität mit http.FileSystem.

    InformationsquelleAutor der Antwort VonC

  3. 7

    Machte ich ein Paket, das macht das Umschalten zwischen debug und Produktion erleichtern. Es bietet auch eine http.Dateisystem-Implementierung, so dass es leicht zu server die Dateien. Und es hat mehrere Möglichkeiten zum hinzufügen der Dateien zu der binäre (generieren von code gehen, oder Anhängen als zip).
    https://github.com/GeertJohan/go.rice

    InformationsquelleAutor der Antwort GeertJohan

Schreibe einen Kommentar