Merge branch 'master' of github.com:snapcore/snapd into tweak/opensus…

…e-snapd-mk

.travis.yml

@@ -4,9 +4,9 @@ git:
 jobs:
   include:
     - stage: quick
-      name: go 1.6/xenial static and unit test suites
+      name: go 1.9/xenial static and unit test suites
       dist: xenial
-      go: 1.6
+      go: "1.9"
       before_install:
         - sudo apt --quiet -o Dpkg::Progress-Fancy=false update
       install:
@@ -17,7 +17,7 @@ jobs:
         - ./run-checks --static
         - ./run-checks --short-unit
     - stage: quick
-      go: 1.10
+      go: "1.10"
       name: OSX build and minimal runtime sanity check
       os: osx
       addons:
@@ -36,6 +36,7 @@ jobs:
         - /tmp/snp pack tests/lib/snaps/test-snapd-tools/ /tmp
     - stage: quick
       name: CLA check
+      dist: xenial
       if: type = pull_request
       language: bash
       addons:
@@ -46,7 +47,7 @@ jobs:
         - ./tests/lib/cla_check.py
     - stage: integration
       name: spread
-      os: linux
+      dist: xenial
       addons:
         apt:
           packages:

asserts/device_asserts.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/snapcore/snapd/snap/naming"
 	"github.com/snapcore/snapd/strutil"
 )
 
@@ -222,24 +223,8 @@ var (
 	classicModelOptional = []string{"architecture", "gadget"}
 )
 
-var almostValidName = regexp.MustCompile("^[a-z0-9-]*[a-z][a-z0-9-]*$")
-
-// validateSnapName checks whether the name can be used as a snap name
-//
-// This function should be synchronized with the reference implementation
-// snap.ValidateName() in snap/validate.go
 func validateSnapName(name string, headerName string) error {
-	isValidName := func() bool {
-		if !almostValidName.MatchString(name) {
-			return false
-		}
-		if name[0] == '-' || name[len(name)-1] == '-' || strings.Contains(name, "--") {
-			return false
-		}
-		return true
-	}
-
-	if len(name) > 40 || !isValidName() {
+	if err := naming.ValidateSnap(name); err != nil {
 		return fmt.Errorf("invalid snap name in %q header: %s", headerName, name)
 	}
 	return nil

asserts/device_asserts_test.go

@@ -201,7 +201,7 @@ func (mods modelSuite) TestDecodeValidSnapNames(c *C) {
 	withTimestamp := strings.Replace(modelExample, "TSLINE", mods.tsLine, 1)
 
 	validNames := []string{
-		"a", "aa", "aaa", "aaaa",
+		"aa", "aaa", "aaaa",
 		"a-a", "aa-a", "a-aa", "a-b-c",
 		"a0", "a-0", "a-0a",
 		"01game", "1-or-2",
@@ -218,6 +218,8 @@ func (mods modelSuite) TestDecodeValidSnapNames(c *C) {
 	invalidNames := []string{
 		// name cannot be empty, never reaches snap name validation
 		"",
+		// too short (min 2 chars)
+		"a",
 		// names cannot be too long
 		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
 		"xxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxx",

asserts/snap_asserts.go

@@ -23,13 +23,13 @@ import (
 	"bytes"
 	"crypto"
 	"fmt"
-	"regexp"
 	"time"
 
 	_ "golang.org/x/crypto/sha3" // expected for digests
 
 	"github.com/snapcore/snapd/osutil"
 	"github.com/snapcore/snapd/release"
+	"github.com/snapcore/snapd/snap/naming"
 )
 
 // SnapDeclaration holds a snap-declaration assertion, declaring a
@@ -195,11 +195,6 @@ func snapDeclarationFormatAnalyze(headers map[string]interface{}, body []byte) (
 	return formatnum, nil
 }
 
-var (
-	validAlias   = regexp.MustCompile("^[a-zA-Z0-9][-_.a-zA-Z0-9]*$")
-	validAppName = regexp.MustCompile("^[a-zA-Z0-9](?:-?[a-zA-Z0-9])*$")
-)
-
 func checkAliases(headers map[string]interface{}) (map[string]string, error) {
 	value, ok := headers["aliases"]
 	if !ok {
@@ -221,13 +216,13 @@ func checkAliases(headers map[string]interface{}) (map[string]string, error) {
 		}
 
 		what := fmt.Sprintf(`in "aliases" item %d`, i+1)
-		name, err := checkStringMatchesWhat(aliasItem, "name", what, validAlias)
+		name, err := checkStringMatchesWhat(aliasItem, "name", what, naming.ValidAlias)
 		if err != nil {
 			return nil, err
 		}
 
 		what = fmt.Sprintf(`for alias %q`, name)
-		target, err := checkStringMatchesWhat(aliasItem, "target", what, validAppName)
+		target, err := checkStringMatchesWhat(aliasItem, "target", what, naming.ValidApp)
 		if err != nil {
 			return nil, err
 		}
@@ -296,7 +291,7 @@ func assembleSnapDeclaration(assert assertionBase) (Assertion, error) {
 	}
 
 	// XXX: depracated, will go away later
-	autoAliases, err := checkStringListMatches(assert.headers, "auto-aliases", validAlias)
+	autoAliases, err := checkStringListMatches(assert.headers, "auto-aliases", naming.ValidAlias)
 	if err != nil {
 		return nil, err
 	}

client/connections.go

@@ -0,0 +1,77 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2019 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package client
+
+import (
+	"net/url"
+)
+
+// Connection describes a connection between a plug and a slot.
+type Connection struct {
+	Slot      SlotRef `json:"slot"`
+	Plug      PlugRef `json:"plug"`
+	Interface string  `json:"interface"`
+	// Manual is set for connections that were established manually.
+	Manual bool `json:"manual"`
+	// Gadget is set for connections that were enabled by the gadget snap.
+	Gadget bool `json:"gadget"`
+}
+
+// Connections contains information about connections, as well as related plugs
+// and slots.
+type Connections struct {
+	// Established is the list of connections that are currently present.
+	Established []Connection `json:"established"`
+	// Undersired is a list of connections that are manually denied.
+	Undesired []Connection `json:"undesired"`
+	Plugs     []Plug       `json:"plugs"`
+	Slots     []Slot       `json:"slots"`
+}
+
+// ConnectionOptions contains criteria for selecting matching connections, plugs
+// and slots.
+type ConnectionOptions struct {
+	// Snap selects connections with the snap on one of the sides, as well
+	// as plugs and slots of a given snap.
+	Snap string
+	// Interface selects connections, plugs or slots using given interface.
+	Interface string
+	// All when true, selects established and undesired connections as well
+	// as all disconnected plugs and slots.
+	All bool
+}
+
+// Connections returns matching plugs, slots and their connections. Unless
+// specified by matching options, returns established connections.
+func (client *Client) Connections(opts *ConnectionOptions) (Connections, error) {
+	var conns Connections
+	query := url.Values{}
+	if opts != nil && opts.Snap != "" {
+		query.Set("snap", opts.Snap)
+	}
+	if opts != nil && opts.Interface != "" {
+		query.Set("interface", opts.Interface)
+	}
+	if opts != nil && opts.All {
+		query.Set("select", "all")
+	}
+	_, err := client.doSync("GET", "/v2/connections", query, nil, nil, &conns)
+	return conns, err
+}