Exemple #1
0
func updateConfig(conn db.Conn, configPath string) error {
	pathStr, _ := os.LookupEnv(quiltPath)
	if pathStr == "" {
		pathStr = stitch.GetQuiltPath()
	}

	f, err := util.Open(configPath)
	if err != nil {
		f, err = util.Open(filepath.Join(pathStr, configPath))
		if err != nil {
			return err
		}
	}

	defer f.Close()

	sc := scanner.Scanner{
		Position: scanner.Position{
			Filename: configPath,
		},
	}

	spec, err := stitch.New(*sc.Init(bufio.NewReader(f)), pathStr, false)
	if err != nil {
		return err
	}

	return engine.UpdatePolicy(conn, spec)
}
Exemple #2
0
func checkConfig(content string) error {
	reader := strings.NewReader(content)

	var sc scanner.Scanner
	_, err := stitch.New(*sc.Init(reader), "", false)
	if err != nil {
		return err
	}
	return nil
}
Exemple #3
0
func prog(t *testing.T, code string) stitch.Stitch {
	var sc scanner.Scanner
	result, err := stitch.New(*sc.Init(strings.NewReader(code)), "", false)
	if err != nil {
		t.Error(err.Error())
		return stitch.Stitch{}
	}

	return result
}
Exemple #4
0
func configRunOnce(configPath string, quiltPath string) error {
	f, err := util.Open(configPath)
	if err != nil {
		return err
	}
	defer f.Close()

	var sc scanner.Scanner
	_, err = stitch.New(*sc.Init(bufio.NewReader(f)), quiltPath, false)
	if err != nil {
		return err
	}

	return nil
}
Exemple #5
0
func stop(conn db.Conn, namespace string) {
	specStr := "(define AdminACL (list))"
	if namespace != "" {
		specStr += fmt.Sprintf(` (define Namespace "%s")`, namespace)
	}

	var sc scanner.Scanner
	spec, err := stitch.New(*sc.Init(strings.NewReader(specStr)), "", false)
	if err != nil {
		panic(err)
	}

	err = engine.UpdatePolicy(conn, spec)
	if err != nil {
		panic(err)
	}
}
Exemple #6
0
// Main is the main function for inspect tool. Helps visualize stitches.
func Main(opts []string) {
	if arglen := len(opts); arglen < 3 {
		fmt.Println("not enough arguments: ", arglen-1)
		usage()
	}

	configPath := opts[1]

	f, err := os.Open(configPath)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	defer f.Close()

	sc := scanner.Scanner{
		Position: scanner.Position{
			Filename: configPath,
		},
	}
	pathStr, _ := os.LookupEnv(quiltPath)
	spec, err := stitch.New(*sc.Init(bufio.NewReader(f)), pathStr, false)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	graph, err := stitch.InitializeGraph(spec)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	switch opts[2] {
	case "pdf":
		fallthrough
	case "ascii":
		viz(configPath, spec, graph, opts[2])
	default:
		usage()
	}
}
Exemple #7
0
func updatePolicy(view db.Database, role db.Role, spec string) {
	var sc scanner.Scanner
	compiled, err := stitch.New(*sc.Init(strings.NewReader(spec)), "", false)
	if err != nil {
		log.WithError(err).Warn("Invalid spec.")
		return
	}

	updateConnections(view, compiled)
	if role == db.Master {
		// This must happen after `updateConnections` because we generate
		// placement rules based on whether there are incoming connections from
		// public internet.
		updatePlacements(view, compiled)

		// The container table is aspirational -- it's the set of containers that
		// should exist.  In the workers, however, the container table is just
		// what's running locally.  That's why we only sync the database
		// containers on the master.
		updateContainers(view, compiled)
	}
}
Exemple #8
0
func testConnectionTxn(conn db.Conn, spec string) string {
	var connections []db.Connection
	conn.Transact(func(view db.Database) error {
		updatePolicy(view, db.Master, spec)
		connections = view.SelectFromConnection(nil)
		return nil
	})

	var sc scanner.Scanner
	compiled, err := stitch.New(*sc.Init(strings.NewReader(spec)), "", false)
	if err != nil {
		return err.Error()
	}

	exp := compiled.QueryConnections()
	for _, e := range exp {
		found := false
		for i, c := range connections {
			if e.From == c.From && e.To == c.To && e.MinPort == c.MinPort &&
				e.MaxPort == c.MaxPort {
				connections = append(
					connections[:i], connections[i+1:]...)
				found = true
				break
			}
		}

		if found == false {
			return fmt.Sprintf("Missing expected connection: %v", e)
		}
	}

	if len(connections) > 0 {
		return spew.Sprintf("Unexpected connections: %s", connections)
	}

	return ""
}
Exemple #9
0
func testContainerTxn(conn db.Conn, spec string) string {
	var containers []db.Container
	conn.Transact(func(view db.Database) error {
		updatePolicy(view, db.Master, spec)
		containers = view.SelectFromContainer(nil)
		return nil
	})

	var sc scanner.Scanner
	compiled, err := stitch.New(*sc.Init(strings.NewReader(spec)), "", false)
	if err != nil {
		return err.Error()
	}

	for _, e := range queryContainers(compiled) {
		found := false
		for i, c := range containers {
			if e.Image == c.Image &&
				reflect.DeepEqual(e.Command, c.Command) &&
				util.EditDistance(c.Labels, e.Labels) == 0 {
				containers = append(containers[:i], containers[i+1:]...)
				found = true
				break
			}
		}

		if found == false {
			return fmt.Sprintf("Missing expected label set: %v\n%v",
				e, containers)
		}
	}

	if len(containers) > 0 {
		return spew.Sprintf("Unexpected containers: %s", containers)
	}

	return ""
}
Exemple #10
0
func initSpec(src string) (stitch.Stitch, error) {
	var sc scanner.Scanner
	spec, err := stitch.New(*sc.Init(strings.NewReader(src)), "../specs", false)
	return spec, err
}