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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
package charm
import (
"fmt"
"launchpad.net/mgo/bson"
"regexp"
"strconv"
"strings"
)
// A charm URL represents charm locations such as:
//
// cs:~joe/oneiric/wordpress
// cs:oneiric/wordpress-42
// local:oneiric/wordpress
//
type URL struct {
Schema string // "cs" or "local"
User string // "joe"
Series string // "oneiric"
Name string // "wordpress"
Revision int // -1 if unset, N otherwise
}
// WithRevision returns a URL equivalent to url but with Revision set
// to revision.
func (url *URL) WithRevision(revision int) *URL {
urlCopy := *url
urlCopy.Revision = revision
return &urlCopy
}
var validUser = regexp.MustCompile("^[a-z0-9][a-zA-Z0-9+.-]+$")
var validSeries = regexp.MustCompile("^[a-z]+([a-z-]+[a-z])?$")
var validName = regexp.MustCompile("^[a-z][a-z0-9]*(-[a-z0-9]*[a-z][a-z0-9]*)*$")
// MustParseURL works like ParseURL, but panics in case of errors.
func MustParseURL(url string) *URL {
u, err := ParseURL(url)
if err != nil {
panic(err)
}
return u
}
// ParseURL parses the provided charm URL string into its respective
// structure.
func ParseURL(url string) (*URL, error) {
u := &URL{}
i := strings.Index(url, ":")
if i > 0 {
u.Schema = url[:i]
i++
}
// cs: or local:
if u.Schema != "cs" && u.Schema != "local" {
return nil, fmt.Errorf("charm URL has invalid schema: %q", url)
}
parts := strings.Split(url[i:], "/")
if len(parts) < 1 || len(parts) > 3 {
return nil, fmt.Errorf("charm URL has invalid form: %q", url)
}
// ~<username>
if strings.HasPrefix(parts[0], "~") {
if u.Schema == "local" {
return nil, fmt.Errorf("local charm URL with user name: %q", url)
}
u.User = parts[0][1:]
if !validUser.MatchString(u.User) {
return nil, fmt.Errorf("charm URL has invalid user name: %q", url)
}
parts = parts[1:]
}
// <series>
if len(parts) < 2 {
return nil, fmt.Errorf("charm URL without series: %q", url)
}
if len(parts) == 2 {
u.Series = parts[0]
if !validSeries.MatchString(u.Series) {
return nil, fmt.Errorf("charm URL has invalid series: %q", url)
}
parts = parts[1:]
}
// <name>[-<revision>]
u.Name = parts[0]
u.Revision = -1
for i := len(u.Name) - 1; i > 0; i-- {
c := u.Name[i]
if c >= '0' && c <= '9' {
continue
}
if c == '-' && i != len(u.Name)-1 {
var err error
u.Revision, err = strconv.Atoi(u.Name[i+1:])
if err != nil {
panic(err) // We just checked it was right.
}
u.Name = u.Name[:i]
}
break
}
if !validName.MatchString(u.Name) {
return nil, fmt.Errorf("charm URL has invalid charm name: %q", url)
}
return u, nil
}
func (u *URL) String() string {
if u.User != "" {
if u.Revision >= 0 {
return fmt.Sprintf("%s:~%s/%s/%s-%d", u.Schema, u.User, u.Series, u.Name, u.Revision)
}
return fmt.Sprintf("%s:~%s/%s/%s", u.Schema, u.User, u.Series, u.Name)
}
if u.Revision >= 0 {
return fmt.Sprintf("%s:%s/%s-%d", u.Schema, u.Series, u.Name, u.Revision)
}
return fmt.Sprintf("%s:%s/%s", u.Schema, u.Series, u.Name)
}
// GetBSON turns u into a bson.Getter so it can be saved directly
// on a MongoDB database with mgo.
func (u *URL) GetBSON() (interface{}, error) {
return u.String(), nil
}
// SetBSON turns u into a bson.Setter so it can be loaded directly
// from a MongoDB database with mgo.
func (u *URL) SetBSON(raw bson.Raw) error {
var s string
err := raw.Unmarshal(&s)
if err != nil {
return err
}
url, err := ParseURL(s)
if err != nil {
return err
}
*u = *url
return nil
}
|