Update github.com/xenolf/lego to 0.4.1

vendor/github.com/JamesClonk/vultr/lib/account_info.go

@@ -35,19 +35,31 @@ func (a *AccountInfo) UnmarshalJSON(data []byte) (err error) {
 		return err
 	}
 
-	b, err := strconv.ParseFloat(fmt.Sprintf("%v", fields["balance"]), 64)
+	value := fmt.Sprintf("%v", fields["balance"])
+	if len(value) == 0 || value == "<nil>" {
+		value = "0"
+	}
+	b, err := strconv.ParseFloat(value, 64)
 	if err != nil {
 		return err
 	}
 	a.Balance = b
 
-	pc, err := strconv.ParseFloat(fmt.Sprintf("%v", fields["pending_charges"]), 64)
+	value = fmt.Sprintf("%v", fields["pending_charges"])
+	if len(value) == 0 || value == "<nil>" {
+		value = "0"
+	}
+	pc, err := strconv.ParseFloat(value, 64)
 	if err != nil {
 		return err
 	}
 	a.PendingCharges = pc
 
-	lpa, err := strconv.ParseFloat(fmt.Sprintf("%v", fields["last_payment_amount"]), 64)
+	value = fmt.Sprintf("%v", fields["last_payment_amount"])
+	if len(value) == 0 || value == "<nil>" {
+		value = "0"
+	}
+	lpa, err := strconv.ParseFloat(value, 64)
 	if err != nil {
 		return err
 	}

vendor/github.com/JamesClonk/vultr/lib/client.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"bytes"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@@ -168,8 +169,25 @@ func (c *Client) do(req *http.Request, data interface{}) error {
 	// Throttle http requests to avoid hitting Vultr's API rate-limit
 	c.bucket.Wait(1)
 
+	// Request body gets drained on each read so we
+	// need to save it's content for retrying requests
+	var err error
+	var requestBody []byte
+	if req.Body != nil {
+		requestBody, err = ioutil.ReadAll(req.Body)
+		if err != nil {
+			return fmt.Errorf("Error reading request body: %v", err)
+		}
+		req.Body.Close()
+	}
+
 	var apiError error
 	for tryCount := 1; tryCount <= c.MaxAttempts; tryCount++ {
+		// Restore request body to the original state
+		if requestBody != nil {
+			req.Body = ioutil.NopCloser(bytes.NewBuffer(requestBody))
+		}
+
 		resp, err := c.client.Do(req)
 		if err != nil {
 			return err

vendor/github.com/JamesClonk/vultr/lib/dns.go

@@ -72,7 +72,7 @@ func (c *Client) GetDNSRecords(domain string) (records []DNSRecord, err error) {
 func (c *Client) CreateDNSDomain(domain, serverIP string) error {
 	values := url.Values{
 		"domain":   {domain},
-		"serverIP": {serverIP},
+		"serverip": {serverIP},
 	}
 
 	if err := c.post(`dns/create_domain`, values, nil); err != nil {

vendor/github.com/JamesClonk/vultr/lib/firewall.go

@@ -0,0 +1,248 @@
+package lib
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// FirewallGroup represents a firewall group on Vultr
+type FirewallGroup struct {
+	ID            string `json:"FIREWALLGROUPID"`
+	Description   string `json:"description"`
+	Created       string `json:"date_created"`
+	Modified      string `json:"date_modified"`
+	InstanceCount int    `json:"instance_count"`
+	RuleCount     int    `json:"rule_count"`
+	MaxRuleCount  int    `json:"max_rule_count"`
+}
+
+// FirewallRule represents a firewall rule on Vultr
+type FirewallRule struct {
+	RuleNumber int    `json:"rulenumber"`
+	Action     string `json:"action"`
+	Protocol   string `json:"protocol"`
+	Port       string `json:"port"`
+	Network    *net.IPNet
+}
+
+type firewallGroups []FirewallGroup
+
+func (f firewallGroups) Len() int      { return len(f) }
+func (f firewallGroups) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
+func (f firewallGroups) Less(i, j int) bool {
+	// sort order: description
+	return strings.ToLower(f[i].Description) < strings.ToLower(f[j].Description)
+}
+
+type firewallRules []FirewallRule
+
+func (r firewallRules) Len() int      { return len(r) }
+func (r firewallRules) Swap(i, j int) { r[i], r[j] = r[j], r[i] }
+func (r firewallRules) Less(i, j int) bool {
+	// sort order: rule number
+	return r[i].RuleNumber < r[j].RuleNumber
+}
+
+// UnmarshalJSON implements json.Unmarshaller on FirewallRule.
+// This is needed because the Vultr API is inconsistent in it's JSON responses.
+// Some fields can change type, from JSON number to JSON string and vice-versa.
+func (r *FirewallRule) UnmarshalJSON(data []byte) (err error) {
+	if r == nil {
+		*r = FirewallRule{}
+	}
+
+	var fields map[string]interface{}
+	if err := json.Unmarshal(data, &fields); err != nil {
+		return err
+	}
+
+	value := fmt.Sprintf("%v", fields["rulenumber"])
+	if len(value) == 0 || value == "<nil>" {
+		value = "0"
+	}
+	number, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return err
+	}
+	r.RuleNumber = int(number)
+
+	value = fmt.Sprintf("%v", fields["subnet_size"])
+	if len(value) == 0 || value == "<nil>" {
+		value = "0"
+	}
+	subnetSize, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	r.Action = fmt.Sprintf("%v", fields["action"])
+	r.Protocol = fmt.Sprintf("%v", fields["protocol"])
+	r.Port = fmt.Sprintf("%v", fields["port"])
+	subnet := fmt.Sprintf("%v", fields["subnet"])
+
+	if subnetSize > 0 && len(subnet) > 0 {
+		_, r.Network, err = net.ParseCIDR(fmt.Sprintf("%s/%d", subnet, subnetSize))
+		if err != nil {
+			return fmt.Errorf("Failed to parse subnet from Vultr API")
+		}
+	} else {
+		_, r.Network, _ = net.ParseCIDR("0.0.0.0/0")
+	}
+
+	return
+}
+
+// GetFirewallGroups returns a list of all available firewall groups on Vultr
+func (c *Client) GetFirewallGroups() ([]FirewallGroup, error) {
+	var groupMap map[string]FirewallGroup
+	if err := c.get(`firewall/group_list`, &groupMap); err != nil {
+		return nil, err
+	}
+
+	var groupList []FirewallGroup
+	for _, g := range groupMap {
+		groupList = append(groupList, g)
+	}
+	sort.Sort(firewallGroups(groupList))
+	return groupList, nil
+}
+
+// GetFirewallGroup returns the firewall group with given ID
+func (c *Client) GetFirewallGroup(id string) (FirewallGroup, error) {
+	groups, err := c.GetFirewallGroups()
+	if err != nil {
+		return FirewallGroup{}, err
+	}
+
+	for _, g := range groups {
+		if g.ID == id {
+			return g, nil
+		}
+	}
+	return FirewallGroup{}, fmt.Errorf("Firewall group with ID %v not found", id)
+}
+
+// CreateFirewallGroup creates a new firewall group in Vultr account
+func (c *Client) CreateFirewallGroup(description string) (string, error) {
+	values := url.Values{}
+
+	// Optional description
+	if len(description) > 0 {
+		values.Add("description", description)
+	}
+
+	var result FirewallGroup
+	err := c.post(`firewall/group_create`, values, &result)
+	if err != nil {
+		return "", err
+	}
+	return result.ID, nil
+}
+
+// DeleteFirewallGroup deletes an existing firewall group
+func (c *Client) DeleteFirewallGroup(groupID string) error {
+	values := url.Values{
+		"FIREWALLGROUPID": {groupID},
+	}
+
+	if err := c.post(`firewall/group_delete`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
+// SetFirewallGroupDescription sets the description of an existing firewall group
+func (c *Client) SetFirewallGroupDescription(groupID, description string) error {
+	values := url.Values{
+		"FIREWALLGROUPID": {groupID},
+		"description":     {description},
+	}
+
+	if err := c.post(`firewall/group_set_description`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetFirewallRules returns a list of rules for the given firewall group
+func (c *Client) GetFirewallRules(groupID string) ([]FirewallRule, error) {
+	var ruleMap map[string]FirewallRule
+	ipTypes := []string{"v4", "v6"}
+	for _, ipType := range ipTypes {
+		args := fmt.Sprintf("direction=in&FIREWALLGROUPID=%s&ip_type=%s",
+			groupID, ipType)
+		if err := c.get(`firewall/rule_list?`+args, &ruleMap); err != nil {
+			return nil, err
+		}
+	}
+
+	var ruleList []FirewallRule
+	for _, r := range ruleMap {
+		ruleList = append(ruleList, r)
+	}
+	sort.Sort(firewallRules(ruleList))
+	return ruleList, nil
+}
+
+// CreateFirewallRule creates a new firewall rule in Vultr account.
+// groupID is the ID of the firewall group to create the rule in
+// protocol must be one of: "icmp", "tcp", "udp", "gre"
+// port can be a port number or colon separated port range (TCP/UDP only)
+func (c *Client) CreateFirewallRule(groupID, protocol, port string,
+	network *net.IPNet) (int, error) {
+	ip := network.IP.String()
+	maskBits, _ := network.Mask.Size()
+	if ip == "<nil>" {
+		return 0, fmt.Errorf("Invalid network")
+	}
+
+	var ipType string
+	if network.IP.To4() != nil {
+		ipType = "v4"
+	} else {
+		ipType = "v6"
+	}
+
+	values := url.Values{
+		"FIREWALLGROUPID": {groupID},
+		// possible values: "in"
+		"direction": {"in"},
+		// possible values: "icmp", "tcp", "udp", "gre"
+		"protocol": {protocol},
+		// possible values: "v4", "v6"
+		"ip_type": {ipType},
+		// IP address representing a subnet
+		"subnet": {ip},
+		// IP prefix size in bits
+		"subnet_size": {fmt.Sprintf("%v", maskBits)},
+	}
+
+	if len(port) > 0 {
+		values.Add("port", port)
+	}
+
+	var result FirewallRule
+	err := c.post(`firewall/rule_create`, values, &result)
+	if err != nil {
+		return 0, err
+	}
+	return result.RuleNumber, nil
+}
+
+// DeleteFirewallRule deletes an existing firewall rule
+func (c *Client) DeleteFirewallRule(ruleNumber int, groupID string) error {
+	values := url.Values{
+		"FIREWALLGROUPID": {groupID},
+		"rulenumber":      {fmt.Sprintf("%v", ruleNumber)},
+	}
+
+	if err := c.post(`firewall/rule_delete`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}

vendor/github.com/JamesClonk/vultr/lib/ip.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"fmt"
 	"net/url"
 	"sort"
 )
@@ -78,6 +79,32 @@ func (c *Client) ListIPv4(id string) (list []IPv4, err error) {
 	return list, nil
 }
 
+// CreateIPv4 creates an IPv4 address and attaches it to a virtual machine
+func (c *Client) CreateIPv4(id string, reboot bool) error {
+	values := url.Values{
+		"SUBID":  {id},
+		"reboot": {fmt.Sprintf("%t", reboot)},
+	}
+
+	if err := c.post(`server/create_ipv4`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteIPv4 deletes an IPv4 address and detaches it from a virtual machine
+func (c *Client) DeleteIPv4(id, ip string) error {
+	values := url.Values{
+		"SUBID": {id},
+		"ip":    {ip},
+	}
+
+	if err := c.post(`server/destroy_ipv4`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
 // ListIPv6 lists the IPv4 information of a virtual machine
 func (c *Client) ListIPv6(id string) (list []IPv6, err error) {
 	var ipMap map[string][]IPv6

vendor/github.com/JamesClonk/vultr/lib/servers.go

@@ -40,6 +40,7 @@ type Server struct {
 	Tag              string      `json:"tag"`
 	OSID             string      `json:"OSID"`
 	AppID            string      `json:"APPID"`
+	FirewallGroupID  string      `json:"FIREWALLGROUPID"`
 }
 
 // ServerOptions are optional parameters to be used during server creation
@@ -50,6 +51,7 @@ type ServerOptions struct {
 	UserData             string
 	Snapshot             string
 	SSHKey               string
+	ReservedIP           string
 	IPV6                 bool
 	PrivateNetworking    bool
 	AutoBackups          bool
@@ -57,6 +59,7 @@ type ServerOptions struct {
 	Hostname             string
 	Tag                  string
 	AppID                string
+	FirewallGroupID      string
 }
 
 type servers []Server
@@ -166,11 +169,17 @@ func (s *Server) UnmarshalJSON(data []byte) (err error) {
 	s.OSID = value
 
 	value = fmt.Sprintf("%v", fields["APPID"])
-	if value == "<nil>" {
+	if value == "<nil>" || value == "0" {
 		value = ""
 	}
 	s.AppID = value
 
+	value = fmt.Sprintf("%v", fields["FIREWALLGROUPID"])
+	if value == "<nil>" || value == "0" {
+		value = ""
+	}
+	s.FirewallGroupID = value
+
 	s.ID = fmt.Sprintf("%v", fields["SUBID"])
 	s.Name = fmt.Sprintf("%v", fields["label"])
 	s.OS = fmt.Sprintf("%v", fields["os"])
@@ -280,6 +289,10 @@ func (c *Client) CreateServer(name string, regionID, planID, osID int, options *
 			values.Add("SSHKEYID", options.SSHKey)
 		}
 
+		if options.ReservedIP != "" {
+			values.Add("reserved_ip_v4", options.ReservedIP)
+		}
+
 		values.Add("enable_ipv6", "no")
 		if options.IPV6 {
 			values.Set("enable_ipv6", "yes")
@@ -311,6 +324,10 @@ func (c *Client) CreateServer(name string, regionID, planID, osID int, options *
 		if options.AppID != "" {
 			values.Add("APPID", options.AppID)
 		}
+
+		if options.FirewallGroupID != "" {
+			values.Add("FIREWALLGROUPID", options.FirewallGroupID)
+		}
 	}
 
 	var server Server
@@ -337,6 +354,19 @@ func (c *Client) RenameServer(id, name string) error {
 	return nil
 }
 
+// TagServer replaces the tag on an existing virtual machine
+func (c *Client) TagServer(id, tag string) error {
+	values := url.Values{
+		"SUBID": {id},
+		"tag":   {tag},
+	}
+
+	if err := c.post(`server/tag_set`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
 // StartServer starts an existing virtual machine
 func (c *Client) StartServer(id string) error {
 	values := url.Values{
@@ -457,6 +487,24 @@ func (c *Client) DeleteServer(id string) error {
 	return nil
 }
 
+// SetFirewallGroup adds a virtual machine to a firewall group
+func (c *Client) SetFirewallGroup(id, firewallgroup string) error {
+	values := url.Values{
+		"SUBID":           {id},
+		"FIREWALLGROUPID": {firewallgroup},
+	}
+
+	if err := c.post(`server/firewall_group_set`, values, nil); err != nil {
+		return err
+	}
+	return nil
+}
+
+// UnsetFirewallGroup removes a virtual machine from a firewall group
+func (c *Client) UnsetFirewallGroup(id string) error {
+	return c.SetFirewallGroup(id, "0")
+}
+
 // BandwidthOfServer retrieves the bandwidth used by a virtual machine
 func (c *Client) BandwidthOfServer(id string) (bandwidth []map[string]string, err error) {
 	var bandwidthMap map[string][][]string