Beispiel #1
1
func MustNewWinPdhCollector(name, prefix string, opts config.Config_win_pdh_collector) *win_pdh_collector {

	c := &win_pdh_collector{
		name:        name,
		enabled:     true,
		prefix:      prefix,
		interval:    opts.Interval.MustDuration(time.Second),
		config:      opts,
		hPdh:        pdh.NewPdhCollector(),
		map_queries: make(map[string]config.Config_win_pdh_query),
	}

	for _, q := range opts.Queries {
		if q.Metric == "" {
			logging.Errorf("Error Phd Collector metric is empty: %# v", pretty.Formatter(q))
			continue
		}

		c.hPdh.AddEnglishCounter(q.Query)
		if q.Tags == nil {
			q.Tags = newcore.AddTags.Copy()
		}

		if opts.Query_to_tag == true || q.Query_to_tag == true {
			q.Tags["query"] = q.Query
		}

		c.map_queries[q.Query] = q
	}
	logging.Tracef("MustNewWinPdhCollector:opts.Queries: %# v", pretty.Formatter(opts.Queries))
	logging.Tracef("MustNuewWinPdhCollector c.map_queries: %# v", pretty.Formatter(c.map_queries))
	return c
}
Beispiel #2
0
func TestGetChart(t *testing.T) {
	server, zillow := testFixtures(t, chartPath, func(values url.Values) {
		assertOnlyParam(t, values, zpidParam, zpid)
		assertOnlyParam(t, values, unitTypeParam, unitType)
		assertOnlyParam(t, values, widthParam, strconv.Itoa(width))
		assertOnlyParam(t, values, heightParam, strconv.Itoa(height))
	})
	defer server.Close()

	request := ChartRequest{Zpid: zpid, UnitType: unitType, Width: width, Height: height}
	result, err := zillow.GetChart(request)
	if err != nil {
		t.Fatal(err)
	}
	expected := &ChartResult{
		XMLName: xml.Name{Space: "http://www.zillowstatic.com/vstatic/8d9b5f1/static/xsd/Chart.xsd", Local: "chart"},
		Request: request,
		Message: Message{
			Text: "Request successfully processed",
			Code: 0,
		},
		Url: "http://www.zillow.com/app?chartDuration=1year&chartType=partner&height=150&page=webservice%2FGetChart&service=chart&showPercent=true&width=300&zpid=48749425",
	}

	if !reflect.DeepEqual(result, expected) {
		t.Fatalf("expected:\n %#v\n\n but got:\n %#v\n\n diff:\n %s\n",
			pretty.Formatter(expected), pretty.Formatter(result), pretty.Diff(expected, result))
	}
}
Beispiel #3
0
func TestCopy_MakeTarStream_SingleFileToDir(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"foo.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	assertions := [][3]string{
		{"foo.txt", "foo", "foo"},
		{"foo.txt", "foo/", "foo/foo.txt"},
	}

	for _, a := range assertions {
		includes := []string{a[0]}
		excludes := []string{}
		dest := a[1]

		t.Logf("includes: %# v", pretty.Formatter(includes))
		t.Logf("excludes: %# v", pretty.Formatter(excludes))
		t.Logf("dest: %# v", pretty.Formatter(dest))

		stream, err := makeTarStream(tmpDir, dest, "COPY", includes, excludes, nil)
		if err != nil {
			t.Fatal(err)
		}

		out := writeReadTar(t, tmpDir, stream.tar)

		assertion := strings.Join([]string{a[2]}, "\n") + "\n"

		assert.Equal(t, assertion, out, "bad tar content for COPY %s %s", a[0], a[1])
	}
}
Beispiel #4
0
func main() {
	r := Rocket{
		name:         "Audrey Mark 0",
		mass:         Measurement{value: 0.05, units: "kg"},
		area:         Measurement{value: 0.0004, units: "m^2"},
		drag:         Measurement{value: 0.75, units: ""}, //seems reasonable
		max_velocity: Measurement{value: 0, units: "m/s"},
		max_altitude: Measurement{value: 0, units: "m"},
		//https://en.wikipedia.org/wiki/Drag_coefficient

	} //estimated rocket

	e := Engine{
		product_number:  1598,
		name:            "A8-3",
		max_payload:     Measurement{value: 0.085, units: "kg"},
		delay:           Measurement{value: 3, units: "s"},
		impulse:         Measurement{value: 2.5, units: "N-s"},
		thrust:          Measurement{value: 10.7, units: "N"},
		mass:            Measurement{value: 0.0162, units: "kg"},
		propellant_mass: Measurement{value: 0.00312, units: "kg"},
		burn_time:       Measurement{value: 0.5, units: "s"},
	} //example for A8-3

	compute_terminal_conditons(&r, &e)
	fmt.Printf("%# v\n", pretty.Formatter(r))
	fmt.Printf("%# v\n", pretty.Formatter(e))

	fmt.Printf("You're going to reach %v maximum velocity\n", r.max_velocity)
	fmt.Println("Your maximum altitude will be:", r.max_altitude)

}
Beispiel #5
0
func TestCopy_ListFiles_Dir_Simple(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"dir/foo.txt": "hello",
		"dir/bar.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	includes := []string{
		"dir",
	}
	excludes := []string{}

	matches, err := listFiles(tmpDir, includes, excludes, "COPY", nil)
	if err != nil {
		t.Fatal(err)
	}

	t.Logf("includes: %# v", pretty.Formatter(includes))
	t.Logf("excludes: %# v", pretty.Formatter(excludes))
	t.Logf("matches: %# v", pretty.Formatter(matches))

	assertions := [][2]string{
		{tmpDir + "/dir/bar.txt", "dir/bar.txt"},
		{tmpDir + "/dir/foo.txt", "dir/foo.txt"},
	}

	assert.Len(t, matches, len(assertions))
	for i, a := range assertions {
		assert.Equal(t, a[0], matches[i].src, "bad match src at index %d", i)
		assert.Equal(t, a[1], matches[i].dest, "bad match dest at index %d", i)
	}
}
Beispiel #6
0
func TestCopy_MakeTarStream_SingleFileDirRename(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"c/foo.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	// ADD ./c /src --> /src
	// ADD ./a/b[/1,2] /src -> /src[/1,2]

	includes := []string{
		"./c",
	}
	excludes := []string{}
	dest := "/src"

	t.Logf("includes: %# v", pretty.Formatter(includes))
	t.Logf("excludes: %# v", pretty.Formatter(excludes))
	t.Logf("dest: %# v", pretty.Formatter(dest))

	stream, err := makeTarStream(tmpDir, dest, "COPY", includes, excludes, nil)
	if err != nil {
		t.Fatal(err)
	}

	out := writeReadTar(t, tmpDir, stream.tar)

	assertion := strings.Join([]string{
		"src/foo.txt",
	}, "\n") + "\n"

	assert.Equal(t, assertion, out, "bad tar content")
}
Beispiel #7
0
func TestSNSMessageNotFound(t *testing.T) {
	server := server.MockDBServer()
	defer server.Close()

	snsString := fmt.Sprintf(`{
		"Type" : "Notification",
		"MessageId" : "12",
		"TopicArn" : "arn",
		"Subject" : "Amazon S3 Notification",
		"Message" : "{\"Records\":[{\"s3\":{\"bucket\":{\"name\":\"sc-gallery\"},\"object\":{\"key\":\"%v\",\"size\":71501}}}]}",
		"Timestamp" : "2015-04-14T03:48:23.584Z",
		"SignatureVersion" : "1",
		"Signature" : "liP1M"
	}`, "original_file/134444")

	req := tests.MockRequest{}
	req.Url = "/notify/sns/"
	req.Method = "post"
	req.Data = map[string]interface{}{}
	utils.Decoder([]byte(snsString), &req.Data)

	server.Test(&req, func(msg *tests.MockResponse) {
		exception := "This message should be ignored."
		if msg.Status != 200 {
			fmt.Printf("%# v", pretty.Formatter(msg))
			t.Error(exception)
		}

		if msg.Message != "" {
			fmt.Printf("%# v", pretty.Formatter(msg))
			t.Error(exception)
		}
	})
}
Beispiel #8
0
func TestCreatePDFCollection(t *testing.T) {
	server := server.MockDBServer()
	defer server.Close()

	req := tests.MockRequest{}
	req.Url = "/assets"
	req.Method = "post"
	req.Data = map[string]interface{}{
		"mime_type":  "application/pdf",
		"name":       randSeq(10),
		"collection": randSeq(5),
	}

	server.Test(&req, func(msg *tests.MockResponse) {
		utils.Convert(&msg.Data, &assetRet)

		if msg.Status != 200 {
			fmt.Printf("%# v", pretty.Formatter(msg))
			t.Error("Asset creation should return status 200.")
		}

		for _, key := range []string{"upload_url", "url", "_id"} {
			if val, ok := assetRet[key]; !ok || len(val) == 0 {
				fmt.Printf("%# v", pretty.Formatter(msg))
				t.Error(key + " should be a valid string in creation return.")
			}
		}
	})
}
Beispiel #9
0
func TestCopy_MakeTarStream_SubDirRenameWildcard(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"a/c/foo.txt": "hello",
		"a/c/x/1.txt": "hello",
		"a/c/x/2.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	includes := []string{
		"a/*",
	}
	excludes := []string{}
	dest := "/src"

	t.Logf("includes: %# v", pretty.Formatter(includes))
	t.Logf("excludes: %# v", pretty.Formatter(excludes))
	t.Logf("dest: %# v", pretty.Formatter(dest))

	stream, err := makeTarStream(tmpDir, dest, "COPY", includes, excludes)
	if err != nil {
		t.Fatal(err)
	}

	out := writeReadTar(t, tmpDir, stream.tar)

	assertion := strings.Join([]string{
		"src/c/foo.txt",
		"src/c/x/1.txt",
		"src/c/x/2.txt",
	}, "\n") + "\n"

	assert.Equal(t, assertion, out, "bad tar content")
}
Beispiel #10
0
func TestSNSMessageIgnoredPath(t *testing.T) {
	server := server.MockDBServer()
	defer server.Close()

	snsString := fmt.Sprintf(`{
		"Type" : "Notification",
		"MessageId" : "12",
		"TopicArn" : "arn",
		"Subject" : "Amazon S3 Notification",
		"Message" : "{\"Records\":[{\"s3\":{\"bucket\":{\"name\":\"sc-gallery\"},\"object\":{\"key\":\"%v\",\"size\":71501}}}]}",
		"Timestamp" : "2015-04-14T03:48:23.584Z",
		"SignatureVersion" : "1",
		"Signature" : "liP1M"
	}`, "/hello/world/")

	req := tests.MockRequest{}
	req.Url = "/notify/sns/"
	req.Method = "post"
	req.Data = map[string]interface{}{}
	utils.Decoder([]byte(snsString), &req.Data)

	server.Test(&req, func(msg *tests.MockResponse) {
		exception := "This path should have been ignroed."

		if msg.Status != 400 {
			fmt.Printf("%# v", pretty.Formatter(msg))
			t.Error(exception)
		}

		if !strings.Contains(msg.Message, "not meant to be monitored") {
			fmt.Printf("%# v", pretty.Formatter(msg))
			t.Error(exception)
		}
	})
}
Beispiel #11
0
func TestCopy_ListFiles_Excludes_FileInAnyDir(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"a/test1.txt":     "hello",
		"b/test2.txt":     "hello",
		"c/d/e/test2.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	includes := []string{
		".",
	}
	excludes := []string{
		"**/test2.txt",
	}

	matches, err := listFiles(tmpDir, includes, excludes)
	if err != nil {
		t.Fatal(err)
	}

	t.Logf("includes: %# v", pretty.Formatter(includes))
	t.Logf("excludes: %# v", pretty.Formatter(excludes))
	t.Logf("matches: %# v", pretty.Formatter(matches))

	assertions := [][2]string{
		{tmpDir + "/a/test1.txt", "a/test1.txt"},
	}

	assert.Len(t, matches, len(assertions))
	for i, a := range assertions {
		assert.Equal(t, a[0], matches[i].src, "bad match src at index %d", i)
		assert.Equal(t, a[1], matches[i].dest, "bad match dest at index %d", i)
	}
}
Beispiel #12
0
// ExampleProxy shows a chain of servers and clients.
func ExampleProxy() {
	log.Println("\n***** ExampleProxy *****\n")

	// Real
	var realServer = offers.MustNewServer(configure("Real Server"), offers.Offers{Configuration: configure("Server")}, ":4030") // Use s as the service.
	go func() {
		if err := realServer.Start(); err != nil {
			panic(err)
		}
	}()
	var realClient = offers.MustNewClient(configure("Real Client"), ":4030")

	// Proxy
	var proxyServer = offers.MustNewServer(configure("Proxy Server"), realClient, ":4031") // Use realClient as the service.
	go func() {
		if err := proxyServer.Start(); err != nil {
			panic(err)
		}
	}()
	var proxyClient = offers.MustNewClient(configure("Proxy Client"), ":4031").ForContext(offers.Context{ID: tigertonic.RandomBase62String(8)}).(offers.Client)

	// Use
	m, err := proxyClient.New(offer.Offer{Name: "nerddomo"})
	if err != nil {
		panic(err)
	}
	log.Printf("New: Got: %# v\n\n", pretty.Formatter(simplify(m)))
	m, err = proxyClient.Get(m.ID)
	if err != nil {
		panic(err)
	}
	log.Printf("Get: Got: %# v\n\n", pretty.Formatter(simplify(m)))
	m.Name = "test"
	m, err = proxyClient.Set(m)
	if err != nil {
		panic(err)
	}
	log.Printf("Set: Got: %# v\n\n", pretty.Formatter(simplify(m)))
	m, err = proxyClient.Delete(m)
	if err != nil {
		panic(err)
	}
	log.Printf("Delete: Got: %# v\n\n", pretty.Formatter(simplify(m)))

	// Proxy
	if err := proxyClient.Close(); err != nil {
		panic(err)
	}
	if err := proxyServer.Stop(); err != nil {
		panic(err)
	}

	// Real
	if err := realClient.Close(); err != nil {
		panic(err)
	}
	if err := realServer.Stop(); err != nil {
		panic(err)
	}
}
Beispiel #13
0
func TestGetRateSummary(t *testing.T) {
	server, zillow := testFixtures(t, rateSummaryPath, func(values url.Values) {
		assertOnlyParam(t, values, stateParam, state)
	})
	defer server.Close()

	request := RateSummaryRequest{State: state}
	result, err := zillow.GetRateSummary(request)
	if err != nil {
		t.Fatal(err)
	}
	expected := &RateSummary{
		XMLName: xml.Name{Space: "http://www.zillow.com/static/xsd/RateSummary.xsd", Local: "rateSummary"},
		Message: Message{
			Text: "Request successfully processed",
			Code: 0,
		},
		Today: []Rate{
			Rate{LoanType: "thirtyYearFixed", Count: 1252, Value: 5.91},
			Rate{LoanType: "fifteenYearFixed", Count: 839, Value: 5.68},
			Rate{LoanType: "fiveOneARM", Count: 685, Value: 5.49},
		},
		LastWeek: []Rate{
			Rate{LoanType: "thirtyYearFixed", Count: 8933, Value: 6.02},
			Rate{LoanType: "fifteenYearFixed", Count: 5801, Value: 5.94},
			Rate{LoanType: "fiveOneARM", Count: 3148, Value: 5.71},
		},
	}

	if !reflect.DeepEqual(result, expected) {
		t.Fatalf("expected:\n %#v\n\n but got:\n %#v\n\n diff:\n %s\n",
			pretty.Formatter(expected), pretty.Formatter(result), pretty.Diff(expected, result))
	}
}
Beispiel #14
0
func TestCopy_MakeTarStream_WierdWildcards(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"abc.txt": "hello",
		"adf.txt": "hello",
		"bvz.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	includes := []string{
		"a*.txt",
	}
	excludes := []string{}
	dest := "./"

	t.Logf("includes: %# v", pretty.Formatter(includes))
	t.Logf("excludes: %# v", pretty.Formatter(excludes))
	t.Logf("dest: %# v", pretty.Formatter(dest))

	stream, err := makeTarStream(tmpDir, dest, "COPY", includes, excludes, nil)
	if err != nil {
		t.Fatal(err)
	}

	out := writeReadTar(t, tmpDir, stream.tar)

	assertion := strings.Join([]string{
		"./abc.txt",
		"./adf.txt",
	}, "\n") + "\n"

	assert.Equal(t, assertion, out, "bad tar content")
}
Beispiel #15
0
func main() {
	var (
		mongoSession *mgo.Session
		database     *mgo.Database
		collection   *mgo.Collection
		changeInfo   *mgo.ChangeInfo
		err          error
	)

	if mongoSession, err = mgo.Dial("localhost"); err != nil {
		panic(err)
	}

	database = mongoSession.DB("mgo_examples_03")
	collection = database.C("todos")

	// START OMIT
	var todo = Todo{
		Id:      bson.NewObjectId(),
		Task:    "Demo mgo",
		Created: time.Now(),
	}

	// This is a shortcut to collection.Upsert(bson.M{"_id": todo.id}, &todo)
	if changeInfo, err = collection.UpsertId(todo.Id, &todo); err != nil {
		panic(err)
	}
	// END OMIT

	fmt.Printf("Todo: %# v", pretty.Formatter(todo))
	fmt.Printf("Change Info: %# v", pretty.Formatter(changeInfo))

}
Beispiel #16
0
func TestConnGrant(t *testing.T) {
	for _, tst := range grantTests {
		ok := tst.c.grant(tst.sk)
		assert.Equalf(t, tst.ok, ok, "%# v", pretty.Formatter(tst))
		assert.Equalf(t, tst.r, tst.c.raccess, "%# v", pretty.Formatter(tst))
		assert.Equalf(t, tst.w, tst.c.waccess, "%# v", pretty.Formatter(tst))
	}
}
Beispiel #17
0
func TestCopy_MakeTarStream_DirRenameDestLeadingSlash(t *testing.T) {
	tmpDir := makeTmpDir(t, map[string]string{
		"lib/foo.txt": "hello",
		"lib/x/1.txt": "hello",
		"lib/x/2.txt": "hello",
	})
	defer os.RemoveAll(tmpDir)

	// WORKDIR /app
	// COPY lib lib
	// COPY lib lib/
	// COPY lib/ lib
	// COPY lib/ lib/
	// /app
	// /app/lib
	// /app/lib/foo.txt
	// /app/lib/x/1.txt
	// /app/lib/x/2.txt

	assertions := [][2]string{
		{"lib", "lib"},
		{"lib", "lib/"},
		{"lib/", "lib"},
		{"lib/", "lib/"},
	}

	for _, a := range assertions {
		includes := []string{a[0]}
		excludes := []string{}
		dest := a[1]

		t.Logf("includes: %# v", pretty.Formatter(includes))
		t.Logf("excludes: %# v", pretty.Formatter(excludes))
		t.Logf("dest: %# v", pretty.Formatter(dest))

		stream, err := makeTarStream(tmpDir, dest, "COPY", includes, excludes, nil)
		if err != nil {
			t.Fatal(err)
		}

		out := writeReadTar(t, tmpDir, stream.tar)

		assertion := strings.Join([]string{
			"lib/foo.txt",
			"lib/x/1.txt",
			"lib/x/2.txt",
		}, "\n") + "\n"

		assert.Equal(t, assertion, out, "bad tar content for COPY %s %s", a[0], a[1])
	}
}
Beispiel #18
0
func TestGetMonthlyPayments(t *testing.T) {
	server, zillow := testFixtures(t, monthlyPaymentsPath, func(values url.Values) {
		assertOnlyParam(t, values, priceParam, strconv.Itoa(price))
		assertOnlyParam(t, values, downParam, strconv.Itoa(down))
		assertOnlyParam(t, values, zipParam, zip)
	})
	defer server.Close()

	request := MonthlyPaymentsRequest{Price: price, Down: down, Zip: zip}
	result, err := zillow.GetMonthlyPayments(request)
	if err != nil {
		t.Fatal(err)
	}
	expected := &MonthlyPayments{
		XMLName: xml.Name{Space: "http://www.zillow.com/static/xsd/MonthlyPayments.xsd", Local: "paymentsSummary"},
		Request: request,
		Message: Message{
			Text: "Request successfully processed",
			Code: 0,
		},
		Payments: []Payment{
			{
				LoanType: "thirtyYearFixed",
				Rate:     5.9,
				MonthlyPrincipalAndInterest: 1512,
				MonthlyMortgageInsurance:    68,
			},
			{
				LoanType: "fifteenYearFixed",
				Rate:     5.68,
				MonthlyPrincipalAndInterest: 1477,
				MonthlyMortgageInsurance:    68,
			},
			{
				LoanType: "fiveOneARM",
				Rate:     5.71,
				MonthlyPrincipalAndInterest: 1482,
				MonthlyMortgageInsurance:    74,
			},
		},
		DownPayment:            45000,
		MonthlyPropertyTaxes:   193,
		MonthlyHazardInsurance: 49,
	}

	if !reflect.DeepEqual(result, expected) {
		t.Fatalf("expected:\n %#v\n\n but got:\n %#v\n\n diff:\n %s\n",
			pretty.Formatter(expected), pretty.Formatter(result), pretty.Diff(expected, result))
	}
}
Beispiel #19
0
// Run runs the build following the given Plan
func (b *Build) Run(plan Plan) (err error) {

	for k := 0; k < len(plan); k++ {
		c := plan[k]

		log.Debugf("Step %d: %# v", k+1, pretty.Formatter(c))

		var doRun bool
		if doRun, err = c.ShouldRun(b); err != nil {
			return err
		}
		if !doRun {
			continue
		}

		// Replace env for the command if appropriate
		if c, ok := c.(EnvReplacableCommand); ok {
			c.ReplaceEnv(b.state.Config.Env)
		}

		log.Infof("%s", color.New(color.FgWhite, color.Bold).SprintFunc()(c))

		if b.state, err = c.Execute(b); err != nil {
			return err
		}

		log.Debugf("State after step %d: %# v", k+1, pretty.Formatter(b.state))

		// Here we need to inject ONBUILD commands on the fly,
		// build sub plan and merge it with the main plan.
		// Not very beautiful, because Run uses Plan as the argument
		// and then it builds its own. But.
		if len(b.state.InjectCommands) > 0 {
			commands, err := parseOnbuildCommands(b.state.InjectCommands)
			if err != nil {
				return err
			}
			subPlan, err := NewPlan(commands, false)
			if err != nil {
				return err
			}
			tail := append(subPlan, plan[k+1:]...)
			plan = append(plan[:k+1], tail...)

			b.state.InjectCommands = []string{}
		}
	}

	return nil
}
Beispiel #20
0
// ExampleMethod shows using a method.
func ExampleMethod() {
	log.Println("\n***** ExampleMethod *****\n")

	// Server
	var server = offers.MustNewServer(configure("Server"), offers.Offers{Configuration: configure("Server")}, ":4020")
	go func() {
		if err := server.Start(); err != nil {
			panic(err)
		}
	}()

	// Client
	var client = offers.MustNewClient(configure("Client"), ":4020").ForContext(offers.Context{ID: tigertonic.RandomBase62String(8)}).(offers.Client)

	// Use
	var m = offer.Offer{Interface: client, Name: "nerddomo"}
	m, err := m.New()
	if err != nil {
		panic(err)
	}
	log.Printf("New: Got: %# v\n\n", pretty.Formatter(simplify(m)))
	m, err = client.Get(m.ID)
	if err != nil {
		panic(err)
	}
	log.Printf("Get: Got: %# v\n\n", pretty.Formatter(simplify(m)))
	m.Name = "bar"
	m, err = m.Set()
	if err != nil {
		panic(err)
	}
	log.Printf("Set: Got: %# v\n\n", pretty.Formatter(simplify(m)))
	m, err = m.Delete()
	if err != nil {
		panic(err)
	}
	log.Printf("Delete: Got: %# v\n\n", pretty.Formatter(simplify(m)))

	// Client
	if err := client.Close(); err != nil {
		panic(err)
	}

	// Server
	if err := server.Stop(); err != nil {
		panic(err)
	}
}
Beispiel #21
0
func TestNilAnnotator_multiLineTokens(t *testing.T) {
	for _, tt := range []struct {
		src  string
		want [][]string
	}{
		{
			src: "/* I am\na multiline\ncomment\n*/",
			want: [][]string{
				[]string{"/* I am"},
				[]string{"a multiline"},
				[]string{"comment"},
				[]string{"*/"},
			},
		},
		{
			src: "a := `I am\na multiline\nstring literal\n`",
			want: [][]string{
				[]string{"a", " ", ":", "=", " ", "`I am"},
				[]string{"a multiline"},
				[]string{"string literal"},
				[]string{"`"},
			},
		},
	} {
		e := newFileWithRange([]byte(tt.src))
		ann := NewNilAnnotator(e)
		_, err := Annotate(e.Contents, ann)
		if err != nil {
			t.Fatal(err)
		}
		if !codeEquals(ann.Code, tt.want) {
			t.Errorf("Expected %# v\n\nGot %# v", tt.want, pretty.Formatter(ann.Code.Lines))
		}
	}
}
Beispiel #22
0
func TestNSResolution(t *testing.T) {
	root, err := Parse(doc)
	if err != nil {
		t.Fatal(err)
	}

	for _, el := range root.Search("http://schemas.xmlsoap.org/wsdl/", "definitions") {
		for _, prefix := range []string{"soap", "wsdl", "s", "soap12"} {
			if name, ok := el.ResolveNS(prefix + ":foo"); !ok {
				t.Errorf("Failed to resolve %s: prefix at <%s>", prefix, el.Name.Local)
			} else {
				t.Logf("Resoved prefix %s to %q at <%s name=%q>", prefix, name.Space,
					el.Name.Local, el.Attr("", "name"))
			}
		}
	}

	defaultns := root.SearchFunc(func(el *Element) bool {
		if (el.Name != xml.Name{"http://schemas.xmlsoap.org/wsdl/", "binding"}) {
			return false
		}
		return el.Attr("", "name") == "wseDocReciboSoap12"
	})[0]

	name := defaultns.Resolve("foo")
	if name.Space != "http://custom/" {
		t.Errorf("Resolve default namespace at <%s name=%q>: wanted %q, got %q",
			defaultns.Prefix(defaultns.Name), defaultns.Attr("", "name"), defaultns.Attr("", "xmlns"), name.Space)
		t.Logf("NS stack is %# v", pretty.Formatter(defaultns.Scope))
	}
}
// ValidateAndHandleJsonInput is the main entry point into this package for the
// API server (i.e. given a POST'ed JSON body). It loads JSON into struct and
// essentially just calls the Simulate() method.
// Receiver: None
// Params: j io.ReadCloser (via r.Body)
// Returns: ApiResponse {Response/StatusCode}
func ValidateAndHandleJsonInput(j io.ReadCloser) ApiResponse {
	decoder := json.NewDecoder(j)

	var simulationData SimulationData

	err := decoder.Decode(&simulationData)
	if err != nil {
		return ApiResponse{
			Response: map[string]interface{}{
				"success": false,
				"message": "Invalid JSON structure.",
			},
			StatusCode: http.StatusBadRequest,
		}
	}

	log.Printf("%# v", pretty.Formatter(simulationData))
	resp := Simulate(&simulationData)

	return ApiResponse{
		Response: map[string]interface{}{
			"success":   true,
			"timesteps": resp,
		},
		StatusCode: http.StatusOK,
	}
}
Beispiel #24
0
func (c *Conn) sendLoop() {
	defer c.wg.Done()

	sendc := c.Send

	for {
		select {
		case msg := <-sendc:
			log.Printf("ws-conn-%04d: send-> %# v", c.ID, pretty.Formatter(msg))
			err := websocket.JSON.Send(c.WSConn, msg)
			if err != nil {
				if !isUseOfClosed(err) {
					log.Printf("ws-conn-%04d: send error: %v", c.ID, err)
					c.errors.Push(errors.Wrap(err, "send error"))
				}
				c.Close()
				sendc = nil // stop sending messages after an error
			}

		case <-c.shutdown:
			err := c.WSConn.Close()
			if err != nil && !isUseOfClosed(err) {
				log.Printf("ws-conn-%04d: close error: %v", c.ID, err)
				c.errors.Push(errors.Wrap(err, "close error"))
			}
			log.Printf("ws-conn-%04d: closed", c.ID)
			return

		case <-c.Done:
			c.Close()
		}
	}
}
Beispiel #25
0
func TestComplexSchema(t *testing.T) {

	ty := &types{
		schemas: []*XSDSchema{},
	}

	data := []byte(complex)
	err := xml.Unmarshal(data, &ty.schemas)
	if err != nil {
		t.Error(err)
	}

	err = xml.Unmarshal(data, &ty.schemaMetas)
	if err != nil {
		t.Error(err)
	}

	if ty.schemaMetas[0].xsdPrefix() != "" {
		t.Error("should have got xsd prefix \"\" got", ty.schemaMetas[0].xsdPrefix())
	}

	if ty.schemaMetas[0].tnsPrefix() != "tns" {
		t.Error("should have got prefix \"tns\" got", ty.schemaMetas[0].tnsPrefix())
	}
	// ty.genTypes()

	t.Log(fmt.Printf("%# v\n\n", pretty.Formatter(ty)))
}
Beispiel #26
0
func makeTempDir(t *testing.T, prefix string, files map[string]string) string {
	// We produce tmp dirs within home to make integration tests work within
	// Mac OS and VirtualBox
	home, err := homedir.Dir()
	if err != nil {
		log.Fatal(err)
	}

	baseTmpDir := path.Join(home, ".rocker-integ-tmp")

	if err := os.MkdirAll(baseTmpDir, 0755); err != nil {
		log.Fatal(err)
	}

	tmpDir, err := ioutil.TempDir(baseTmpDir, prefix)
	if err != nil {
		t.Fatal(err)
	}
	if err := test.MakeFiles(tmpDir, files); err != nil {
		os.RemoveAll(tmpDir)
		t.Fatal(err)
	}
	if *verbosityLevel >= 2 {
		fmt.Printf("temp directory: %s\n", tmpDir)
		fmt.Printf("  with files: %# v\n", pretty.Formatter(files))
	}
	return tmpDir
}
Beispiel #27
0
func TestCommandCopy_Simple(t *testing.T) {
	// TODO: do we need to check the dest is always a directory?
	b, c := makeBuild(t, "", Config{})
	cmd := NewCommand(ConfigCommand{
		name: "copy",
		args: []string{"testdata/Rockerfile", "/Rockerfile"},
	})

	c.On("CreateContainer", mock.AnythingOfType("State")).Return("456", nil).Run(func(args mock.Arguments) {
		arg := args.Get(0).(State)
		// TODO: a better check
		assert.True(t, len(arg.Config.Cmd) > 0)
	}).Once()

	c.On("UploadToContainer", "456", mock.AnythingOfType("*io.PipeReader"), "/").Return(nil).Once()

	state, err := cmd.Execute(b)
	if err != nil {
		t.Fatal(err)
	}

	t.Logf("state: %# v", pretty.Formatter(state))

	c.AssertExpectations(t)
	assert.Equal(t, "456", state.NoCache.ContainerID)
}
Beispiel #28
0
// RunContainer implements creating and optionally running a container
// depending on its state preference.
func (client *DockerClient) RunContainer(container *Container) error {
	log.Infof("Create container %s", container.Name)

	opts, err := container.CreateContainerOptions()
	if err != nil {
		return fmt.Errorf("Failed to initialize container options, error: %s", err)
	}
	log.Debugf("Creating container with opts: %# v", pretty.Formatter(opts))

	apiContainer, err := client.Docker.CreateContainer(*opts)
	if err != nil {
		return fmt.Errorf("Failed to create container, error: %s", err)
	}
	container.ID = apiContainer.ID

	if container.State.Running || container.Config.State.IsRan() {
		if client.Attach {
			if err := client.AttachToContainer(container); err != nil {
				return err
			}
		}

		if err := client.StartContainer(container); err != nil {
			return err
		}
	}

	return nil
}
Beispiel #29
0
// CreateContainer creates docker container
func (c *DockerClient) CreateContainer(s State) (string, error) {

	s.Config.Image = s.ImageID

	// TODO: assign human readable name?

	opts := docker.CreateContainerOptions{
		Config:     &s.Config,
		HostConfig: &s.NoCache.HostConfig,
	}

	c.log.Debugf("Create container: %# v", pretty.Formatter(opts))

	container, err := c.client.CreateContainer(opts)
	if err != nil {
		return "", err
	}

	imageStr := fmt.Sprintf("(image %.12s)", s.ImageID)
	if s.ImageID == "" {
		imageStr = "(from scratch)"
	}

	c.log.Infof("| Created container %.12s %s", container.ID, imageStr)

	return container.ID, nil
}
Beispiel #30
0
func main() {
	var todo = Todo{
		Task:    "Demo mgo",
		Created: time.Now(),
	}
	fmt.Printf("Todo: %# v", pretty.Formatter(todo))
}