aboutsummaryrefslogtreecommitdiffstats
path: root/common/package.go
blob: 7f38d8e4d933c9617a69079d1ca19498deb6348b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package common

import (
    "archive/zip"
    "encoding/json"
    "fmt"
    "io"
    "io/ioutil"
    "strings"
)

// Manifest object
//
// The manifest object holds all the relevant information supplied with the
// the manifest specified in the package
type Manifest struct {
    Entry         string
    Height, Width int
}

// External package
//
// External package contains the main html file and manifest
type ExtPackage struct {
    EntryHtml string
    Manifest  *Manifest
}

// Read file
//
// Read a given compressed file and returns the read bytes.
// Returns an error otherwise
func ReadFile(f *zip.File) ([]byte, error) {
    rc, err := f.Open()
    if err != nil {
        return nil, err
    }
    defer rc.Close()

    content, err := ioutil.ReadAll(rc)
    if err != nil {
        return nil, err
    }

    return content, nil
}

// Reads manifest
//
// Reads and returns a manifest object. Returns error otherwise
func ReadManifest(m []byte) (*Manifest, error) {
    var manifest Manifest

    dec := json.NewDecoder(strings.NewReader(string(m)))
    if err := dec.Decode(&manifest); err == io.EOF {
    } else if err != nil {
        return nil, err
    }

    return &manifest, nil
}

// Find file in archive
//
// Returns the index of the given file name if it exists. -1 if file not found
func FindFileInArchive(fn string, files []*zip.File) (index int) {
    index = -1
    // Find the manifest first
    for i, f := range files {
        if f.Name == fn {
            index = i
        }
    }

    return
}

// Open package
//
// Opens a prepared ethereum package
// Reads the manifest file and determines file contents and returns and
// the external package.
func OpenPackage(fn string) (*ExtPackage, error) {
    r, err := zip.OpenReader(fn)
    if err != nil {
        return nil, err
    }
    defer r.Close()

    manifestIndex := FindFileInArchive("manifest.json", r.File)

    if manifestIndex < 0 {
        return nil, fmt.Errorf("No manifest file found in archive")
    }

    f, err := ReadFile(r.File[manifestIndex])
    if err != nil {
        return nil, err
    }

    manifest, err := ReadManifest(f)
    if err != nil {
        return nil, err
    }

    if manifest.Entry == "" {
        return nil, fmt.Errorf("Entry file specified but appears to be empty: %s", manifest.Entry)
    }

    entryIndex := FindFileInArchive(manifest.Entry, r.File)
    if entryIndex < 0 {
        return nil, fmt.Errorf("Entry file not found: '%s'", manifest.Entry)
    }

    f, err = ReadFile(r.File[entryIndex])
    if err != nil {
        return nil, err
    }

    extPackage := &ExtPackage{string(f), manifest}

    return extPackage, nil
}