Example #1
1
func TestUpdate(t *testing.T) {
	neuralNetwork := CreateSimpleNetwork(t)
	inputs := mat64.NewDense(1, 2, []float64{0.05, 0.10})
	neuralNetwork.Forward(inputs)
	values := mat64.NewDense(1, 2, []float64{0.01, 0.99})
	neuralNetwork.Backward(values)
	learningConfiguration := neural.LearningConfiguration{
		Epochs:    proto.Int32(1),
		Rate:      proto.Float64(0.5),
		Decay:     proto.Float64(0),
		BatchSize: proto.Int32(1),
	}
	neuralNetwork.Update(learningConfiguration)
	expected_weights_0 := mat64.NewDense(
		3, 2, []float64{0.149780716, 0.24975114, 0.19956143, 0.29950229, 0.35,
			0.35})
	if !mat64.EqualApprox(
		neuralNetwork.Layers[0].Weight, expected_weights_0, 0.0001) {
		t.Errorf("weights 0 unexpected:\n%v",
			mat64.Formatted(neuralNetwork.Layers[0].Weight))
	}
	expected_weights_1 := mat64.NewDense(
		3, 2, []float64{0.35891648, 0.51130127, 0.408666186, 0.561370121, 0.6,
			0.6})
	if !mat64.EqualApprox(
		neuralNetwork.Layers[1].Weight, expected_weights_1, 0.0001) {
		t.Errorf("weights 1 unexpected:\n%v",
			mat64.Formatted(neuralNetwork.Layers[1].Weight))
	}
}
Example #2
0
func (s *summary) Write(out *dto.Metric) error {
	sum := &dto.Summary{}
	qs := make([]*dto.Quantile, 0, len(s.objectives))

	s.bufMtx.Lock()
	s.mtx.Lock()

	if len(s.hotBuf) != 0 {
		s.swapBufs(time.Now())
	}
	s.bufMtx.Unlock()

	s.flushColdBuf()
	sum.SampleCount = proto.Uint64(s.cnt)
	sum.SampleSum = proto.Float64(s.sum)

	for _, rank := range s.sortedObjectives {
		qs = append(qs, &dto.Quantile{
			Quantile: proto.Float64(rank),
			Value:    proto.Float64(s.headStream.Query(rank)),
		})
	}

	s.mtx.Unlock()

	if len(qs) > 0 {
		sort.Sort(quantSort(qs))
	}
	sum.Quantile = qs

	out.Summary = sum
	out.Label = s.labelPairs
	return nil
}
Example #3
0
func makeServerRequest(fix fixture, resID string, clients []clientWants, has float64) (*pb.GetServerCapacityResponse, error) {
	var wants []*pb.PriorityBandAggregate
	for _, client := range clients {
		wants = append(wants, &pb.PriorityBandAggregate{
			Priority:   proto.Int64(0),
			NumClients: proto.Int64(client.numClients),
			Wants:      proto.Float64(client.wants),
		})
	}

	req := &pb.GetServerCapacityRequest{
		ServerId: proto.String("server"),
		Resource: []*pb.ServerCapacityResourceRequest{
			{
				ResourceId: proto.String(resID),
				Has: &pb.Lease{
					ExpiryTime:      proto.Int64(0),
					RefreshInterval: proto.Int64(0),
					Capacity:        proto.Float64(0),
				},
				Wants: wants,
			},
		},
	}

	if has > 0 {
		req.Resource[0].Has = &pb.Lease{
			ExpiryTime:      proto.Int64(time.Now().Add(1 * time.Minute).Unix()),
			RefreshInterval: proto.Int64(1),
			Capacity:        proto.Float64(has),
		}
	}

	return fix.client.GetServerCapacity(context.Background(), req)
}
Example #4
0
func makeRequest(fix fixture, wants, has float64) (*pb.GetCapacityResponse, error) {
	req := &pb.GetCapacityRequest{
		ClientId: proto.String("client"),
		Resource: []*pb.ResourceRequest{
			{
				ResourceId: proto.String("resource"),
				Priority:   proto.Int64(1),
				Has: &pb.Lease{
					ExpiryTime:      proto.Int64(0),
					RefreshInterval: proto.Int64(0),
					Capacity:        proto.Float64(0),
				},
				Wants: proto.Float64(wants),
			},
		},
	}

	if has > 0 {
		req.Resource[0].Has = &pb.Lease{
			ExpiryTime:      proto.Int64(time.Now().Add(1 * time.Minute).Unix()),
			RefreshInterval: proto.Int64(5),
			Capacity:        proto.Float64(has),
		}
	}

	return fix.client.GetCapacity(context.Background(), req)
}
func TestParseTextFiles(t *testing.T) {
	tests := []struct {
		path string
		out  string
	}{
		{
			path: "fixtures/textfile/no_metric_files",
			out:  "fixtures/textfile/no_metric_files.out",
		},
		{
			path: "fixtures/textfile/two_metric_files",
			out:  "fixtures/textfile/two_metric_files.out",
		},
		{
			path: "fixtures/textfile/nonexistent_path",
			out:  "fixtures/textfile/nonexistent_path.out",
		},
	}

	for i, test := range tests {
		c := textFileCollector{
			path: test.path,
		}

		// Suppress a log message about `nonexistent_path` not existing, this is
		// expected and clutters the test output.
		err := flag.Set("log.level", "fatal")
		if err != nil {
			t.Fatal(err)
		}

		mfs := c.parseTextFiles()
		textMFs := make([]string, 0, len(mfs))
		for _, mf := range mfs {
			if mf.GetName() == "node_textfile_mtime" {
				mf.GetMetric()[0].GetGauge().Value = proto.Float64(1)
				mf.GetMetric()[1].GetGauge().Value = proto.Float64(2)
			}
			textMFs = append(textMFs, proto.MarshalTextString(mf))
		}
		sort.Strings(textMFs)
		got := strings.Join(textMFs, "")

		want, err := ioutil.ReadFile(test.out)
		if err != nil {
			t.Fatalf("%d. error reading fixture file %s: %s", i, test.out, err)
		}

		if string(want) != got {
			t.Fatalf("%d. want:\n\n%s\n\ngot:\n\n%s", i, string(want), got)
		}
	}
}
Example #6
0
func TestOffer(t *testing.T) {
	offer := util.NewOffer(util.NewOfferID("487c73d8-9951-f23c-34bd-8085bfd30c49"), util.NewFrameworkID("20150903-065451-84125888-5050-10715-0053"),
		util.NewSlaveID("20150903-065451-84125888-5050-10715-S1"), "slave0")

	if Offer(offer) != "slave0#30c49" {
		t.Errorf(`util.NewOffer(util.NewOfferID("487c73d8-9951-f23c-34bd-8085bfd30c49"), util.NewFrameworkID("20150903-065451-84125888-5050-10715-0053"), util.NewSlaveID("20150903-065451-84125888-5050-10715-S1"), "slave0") != "slave0#30c49"; actual %s`, Offer(offer))
	}

	offer.Resources = []*mesos.Resource{util.NewScalarResource("cpus", 4), util.NewScalarResource("mem", 512), util.NewRangesResource("ports", []*mesos.Value_Range{util.NewValueRange(31000, 32000)})}
	if Offer(offer) != "slave0#30c49 cpus:4.00 mem:512.00 ports:[31000..32000]" {
		t.Errorf("Expected slave0#30c49 cpus:4.00 mem:512.00 ports:[31000..32000]; actual %s", Offer(offer))
	}

	offer.Attributes = []*mesos.Attribute{&mesos.Attribute{
		Name:   proto.String("rack"),
		Type:   mesos.Value_SCALAR.Enum(),
		Scalar: &mesos.Value_Scalar{Value: proto.Float64(2)},
	}}
	if Offer(offer) != "slave0#30c49 cpus:4.00 mem:512.00 ports:[31000..32000] rack:2.00" {
		t.Errorf("Expected slave0#30c49 cpus:4.00 mem:512.00 ports:[31000..32000] rack:2.00; actual %s", Offer(offer))
	}

	offer.Resources = nil
	if Offer(offer) != "slave0#30c49 rack:2.00" {
		t.Errorf("Expected slave0#30c49 rack:2.00; actual %s", Offer(offer))
	}
}
Example #7
0
func TestAttribute(t *testing.T) {
	attr := Attribute(&mesos.Attribute{
		Name:   proto.String("rack"),
		Type:   mesos.Value_SCALAR.Enum(),
		Scalar: &mesos.Value_Scalar{Value: proto.Float64(2)},
	})
	if attr != "rack:2.00" {
		t.Errorf(`Attribute(&mesos.Attribute{
        Name: proto.String("rack"),
        Type: mesos.Value_SCALAR.Enum(),
        Scalar: &mesos.Value_Scalar{Value: proto.Float64(2)},
    }) != "rack:2.00"; actual %s`, attr)
	}

	attr = Attribute(&mesos.Attribute{
		Name: proto.String("datacenter"),
		Type: mesos.Value_TEXT.Enum(),
		Text: &mesos.Value_Text{Value: proto.String("DC-1")},
	})
	if attr != "datacenter:DC-1" {
		t.Errorf(`Attribute(&mesos.Attribute{
        Name: proto.String("datacenter"),
        Type: mesos.Value_TEXT.Enum(),
        Text: proto.String("DC-1"),
    }) != "datacenter:DC-1"; actual %s`, attr)
	}
}
Example #8
0
func lease(c context.Context, maxTasks int, queueName string, leaseTime int, groupByTag bool, tag []byte) ([]*Task, error) {
	if queueName == "" {
		queueName = "default"
	}
	req := &pb.TaskQueueQueryAndOwnTasksRequest{
		QueueName:    []byte(queueName),
		LeaseSeconds: proto.Float64(float64(leaseTime)),
		MaxTasks:     proto.Int64(int64(maxTasks)),
		GroupByTag:   proto.Bool(groupByTag),
		Tag:          tag,
	}
	res := &pb.TaskQueueQueryAndOwnTasksResponse{}
	if err := internal.Call(c, "taskqueue", "QueryAndOwnTasks", req, res); err != nil {
		return nil, err
	}
	tasks := make([]*Task, len(res.Task))
	for i, t := range res.Task {
		tasks[i] = &Task{
			Payload:    t.Body,
			Name:       string(t.TaskName),
			Method:     "PULL",
			ETA:        time.Unix(0, *t.EtaUsec*1e3),
			RetryCount: *t.RetryCount,
			Tag:        string(t.Tag),
		}
	}
	return tasks, nil
}
Example #9
0
// Float64P parses the given string representation of a floating point number,
// and returns a pointer to a float64 whose value is same as the parsed number.
func Float64P(val string) (*float64, error) {
	f, err := Float64(val)
	if err != nil {
		return nil, err
	}
	return proto.Float64(f), nil
}
Example #10
0
func (cn *Conn) Write(b []byte) (n int, err error) {
	const lim = 1 << 20 // max per chunk

	for n < len(b) {
		chunk := b[n:]
		if len(chunk) > lim {
			chunk = chunk[:lim]
		}

		req := &pb.SendRequest{
			SocketDescriptor: &cn.desc,
			Data:             chunk,
			StreamOffset:     &cn.offset,
		}
		res := &pb.SendReply{}
		if !cn.writeDeadline.IsZero() {
			req.TimeoutSeconds = proto.Float64(cn.writeDeadline.Sub(time.Now()).Seconds())
		}
		if err = cn.c.Call("remote_socket", "Send", req, res, opts(cn.writeDeadline)); err != nil {
			// assume zero bytes were sent in this RPC
			break
		}
		n += int(res.GetDataSent())
	}

	cn.offset += int64(n)
	return
}
Example #11
0
// SetSafeCapacity sets the safe capacity in a response.
func (res *Resource) SetSafeCapacity(resp *pb.ResourceResponse) {
	res.mu.RLock()
	defer res.mu.RUnlock()

	// If the resource configuration does not have a safe capacity
	// configured we return a dynamic safe capacity which equals
	// the capacity divided by the number of clients that we
	// know about.
	// TODO(josv): The calculation of the dynamic safe capacity
	// needs to take sub clients into account (in a multi-server tree).
	if res.config.SafeCapacity == nil {
		resp.SafeCapacity = proto.Float64(*res.config.Capacity / float64(res.store.Count()))
	} else {
		resp.SafeCapacity = proto.Float64(*res.config.SafeCapacity)
	}
}
Example #12
0
func createDriver(scheduler *Scheduler, settings *Settings) (*mesossched.MesosSchedulerDriver, error) {
	publishedAddr := net.ParseIP(settings.MessengerAddress)
	bindingPort := settings.MessengerPort
	credential, err := getCredential(settings)

	if err != nil {
		return nil, err
	}

	return mesossched.NewMesosSchedulerDriver(mesossched.DriverConfig{
		Master: settings.Master,
		Framework: &mesosproto.FrameworkInfo{
			Id:              getFrameworkID(settings),
			Name:            proto.String(settings.Name),
			User:            proto.String(settings.User),
			Checkpoint:      proto.Bool(settings.Checkpoint),
			FailoverTimeout: proto.Float64(settings.FailoverTimeout),
			Principal:       getPrincipalID(credential),
		},
		Scheduler:        scheduler,
		BindingAddress:   net.ParseIP("0.0.0.0"),
		PublishedAddress: publishedAddr,
		BindingPort:      bindingPort,
		Credential:       credential,
		WithAuthContext:  getAuthContext,
	})
}
Example #13
0
func testSafeCapacity(t *testing.T) {
	template := makeResourceTemplate("res_with_safe_caoacity", pb.Algorithm_FAIR_SHARE)
	template.SafeCapacity = proto.Float64(10.0)
	s, err := MakeTestServer(template,
		makeResourceTemplate("*", pb.Algorithm_FAIR_SHARE))
	if err != nil {
		t.Errorf("MakeTestServer: %v", err)
	}

	res := s.getOrCreateResource("res_with_safe_capacity")
	res.store.Assign("client1", fiveMinutes, fiveSeconds, 10, 100, 1)
	res.store.Assign("client2", fiveMinutes, fiveSeconds, 10, 100, 1)
	resp := &pb.ResourceResponse{}
	res.SetSafeCapacity(resp)

	if *resp.SafeCapacity != 10 {
		t.Errorf("*resp.SafeCapacity: want:10, got:%v", *resp.SafeCapacity)
	}

	res = s.getOrCreateResource("res_without_safe_capacity")
	res.store.Assign("client1", fiveMinutes, fiveSeconds, 10, 100, 1)
	res.store.Assign("client2", fiveMinutes, fiveSeconds, 10, 100, 1)
	resp = &pb.ResourceResponse{}
	res.SetSafeCapacity(resp)

	if *resp.SafeCapacity != 50 {
		t.Errorf("*resp.SafeCapacity: want:50, got:%v", *resp.SafeCapacity)
	}
}
Example #14
0
func (cn *Conn) Read(b []byte) (n int, err error) {
	const maxRead = 1 << 20
	if len(b) > maxRead {
		b = b[:maxRead]
	}

	req := &pb.ReceiveRequest{
		SocketDescriptor: &cn.desc,
		DataSize:         proto.Int32(int32(len(b))),
	}
	res := &pb.ReceiveReply{}
	if !cn.readDeadline.IsZero() {
		req.TimeoutSeconds = proto.Float64(cn.readDeadline.Sub(time.Now()).Seconds())
	}
	if err := cn.c.Call("remote_socket", "Receive", req, res, opts(cn.readDeadline)); err != nil {
		return 0, err
	}
	if len(res.Data) == 0 {
		return 0, io.EOF
	}
	if len(res.Data) > len(b) {
		return 0, fmt.Errorf("socket: internal error: read too much data: %d > %d", len(res.Data), len(b))
	}
	return copy(b, res.Data), nil
}
Example #15
0
func NewNotification(ty string, m map[string]interface{}) *Notification {
	res := &Notification{}
	res.Type = ty
	for k, v := range m {
		variant := &attribute.Variant{}
		switch v := v.(type) {
		case bool:
			variant.BoolValue = proto.Bool(v)
		// Minor annoyance here to have to do these casts, but it would be
		// a huge annoyance elsewhere:
		case int:
			variant.IntValue = proto.Int64(int64(v))
		case int32:
			variant.IntValue = proto.Int64(int64(v))
		case int64:
			variant.IntValue = proto.Int64(v)
		case uint:
			variant.UintValue = proto.Uint64(uint64(v))
		case uint32:
			variant.UintValue = proto.Uint64(uint64(v))
		case uint64:
			variant.UintValue = proto.Uint64(v)
		case float32:
			variant.FloatValue = proto.Float64(float64(v))
		case float64:
			variant.FloatValue = proto.Float64(v)
		case string:
			variant.StringValue = proto.String(v)
		case []byte:
			variant.BlobValue = v
		case MessageValue:
			variant.MessageValue = v.Value
		case FourccValue:
			variant.FourccValue = proto.String(v.Value)
		case entity.EntityId:
			variant.EntityidValue = &v
		default:
			log.Panicf("error: can't convert %s: %T to attribute", k, v)
		}
		res.Attributes = append(res.Attributes, &attribute.Attribute{
			Name:  proto.String(k),
			Value: variant,
		})
	}
	return res
}
Example #16
0
func TestAttributes(t *testing.T) {
	attributes := Attributes([]*mesos.Attribute{&mesos.Attribute{
		Name:   proto.String("rack"),
		Type:   mesos.Value_SCALAR.Enum(),
		Scalar: &mesos.Value_Scalar{Value: proto.Float64(2)},
	}, &mesos.Attribute{
		Name:   proto.String("floor"),
		Type:   mesos.Value_SCALAR.Enum(),
		Scalar: &mesos.Value_Scalar{Value: proto.Float64(1)},
	}})
	if !strings.Contains(attributes, "rack") {
		t.Errorf(`%s does not contain "rack"`, attributes)
	}

	if !strings.Contains(attributes, "floor") {
		t.Errorf(`%s does not contain "floor"`, attributes)
	}
}
Example #17
0
func populateMetric(
	t ValueType,
	v float64,
	labelPairs []*dto.LabelPair,
	m *dto.Metric,
) error {
	m.Label = labelPairs
	switch t {
	case CounterValue:
		m.Counter = &dto.Counter{Value: proto.Float64(v)}
	case GaugeValue:
		m.Gauge = &dto.Gauge{Value: proto.Float64(v)}
	case UntypedValue:
		m.Untyped = &dto.Untyped{Value: proto.Float64(v)}
	default:
		return fmt.Errorf("encountered unknown type %v", t)
	}
	return nil
}
Example #18
0
// setUpIntermediate sets up a test intermediate server.
func setUpIntermediate(name string, addr string) (fixture, error) {
	var (
		fix fixture
		err error
	)

	fix.server, err = MakeTestIntermediateServer(
		name, addr,
		&pb.ResourceTemplate{
			IdentifierGlob: proto.String("*"),
			Capacity:       proto.Float64(100),
			SafeCapacity:   proto.Float64(2),
			Algorithm: &pb.Algorithm{
				Kind:            pb.Algorithm_PROPORTIONAL_SHARE.Enum(),
				RefreshInterval: proto.Int64(1),
				LeaseLength:     proto.Int64(2),
			},
		})
	if err != nil {
		return fixture{}, err
	}

	lis, err := net.Listen("tcp", ":0")
	if err != nil {
		return fixture{}, err
	}

	fix.lis = lis

	fix.rpcServer = rpc.NewServer()

	pb.RegisterCapacityServer(fix.rpcServer, fix.server)

	go fix.rpcServer.Serve(lis)

	conn, err := rpc.Dial(fix.Addr(), rpc.WithInsecure())
	if err != nil {
		return fixture{}, err
	}

	fix.client = pb.NewCapacityClient(conn)
	return fix, nil
}
Example #19
0
func (h *histogram) Write(out *dto.Metric) error {
	his := &dto.Histogram{}
	buckets := make([]*dto.Bucket, len(h.upperBounds))

	his.SampleSum = proto.Float64(math.Float64frombits(atomic.LoadUint64(&h.sumBits)))
	his.SampleCount = proto.Uint64(atomic.LoadUint64(&h.count))
	var count uint64
	for i, upperBound := range h.upperBounds {
		count += atomic.LoadUint64(&h.counts[i])
		buckets[i] = &dto.Bucket{
			CumulativeCount: proto.Uint64(count),
			UpperBound:      proto.Float64(upperBound),
		}
	}
	his.Bucket = buckets
	out.Histogram = his
	out.Label = h.labelPairs
	return nil
}
Example #20
0
// toRetryParameter converts RetryOptions to pb.TaskQueueRetryParameters.
func (opt *RetryOptions) toRetryParameters() *pb.TaskQueueRetryParameters {
	params := &pb.TaskQueueRetryParameters{}
	if opt.RetryLimit > 0 {
		params.RetryLimit = proto.Int32(opt.RetryLimit)
	}
	if opt.AgeLimit > 0 {
		params.AgeLimitSec = proto.Int64(int64(opt.AgeLimit.Seconds()))
	}
	if opt.MinBackoff > 0 {
		params.MinBackoffSec = proto.Float64(opt.MinBackoff.Seconds())
	}
	if opt.MaxBackoff > 0 {
		params.MaxBackoffSec = proto.Float64(opt.MaxBackoff.Seconds())
	}
	if opt.MaxDoublings > 0 || (opt.MaxDoublings == 0 && opt.ApplyZeroMaxDoublings) {
		params.MaxDoublings = proto.Int32(opt.MaxDoublings)
	}
	return params
}
Example #21
0
func (s *StackDeployScheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) {
	Logger.Debug("[ResourceOffers] %s", pretty.Offers(offers))

	for _, offer := range offers {
		declineReason := s.acceptOffer(driver, offer)
		if declineReason != "" {
			driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(10)})
			Logger.Debug("Declined offer %s: %s", pretty.Offer(offer), declineReason)
		}
	}
}
Example #22
0
// mesos.Scheduler interface method.
// Invoked when resources have been offered to this framework.
func (this *ElodinaTransportScheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) {
	log.Logger.Info("Received offers")
	offersAndTasks := make(map[*mesos.Offer][]*mesos.TaskInfo)
	remainingPartitions, err := this.GetTopicPartitions()
	if err != nil {
		return
	}
	remainingPartitions.RemoveAll(this.TakenTopicPartitions.GetArray())
	log.Logger.Debug("%v", remainingPartitions)
	tps := remainingPartitions.GetArray()

	offersAndResources := this.wrapInOfferAndResources(offers)
	for !remainingPartitions.IsEmpty() {
		log.Logger.Debug("Iteration %v", remainingPartitions)
		if this.hasEnoughInstances() {
			for _, transfer := range this.taskIdToTaskState {
				if len(transfer.assignment) < this.config.ThreadsPerTask {
					transfer.assignment = append(transfer.assignment, tps[0])
					remainingPartitions.Remove(tps[0])
					this.TakenTopicPartitions.Add(tps[0])
					if len(tps) > 1 {
						tps = tps[1:]
					} else {
						tps = []consumer.TopicAndPartition{}
					}
				}
			}
		} else {
			log.Logger.Debug("Trying to launch new task")
			offer, task := this.launchNewTask(offersAndResources)
			if offer != nil && task != nil {
				offersAndTasks[offer] = append(offersAndTasks[offer], task)
			} else {
				for _, offer := range offers {
					if _, exists := offersAndTasks[offer]; !exists {
						offersAndTasks[offer] = make([]*mesos.TaskInfo, 0)
					}
				}
				break
			}
		}
	}

	this.assignPendingPartitions()

	for _, offer := range offers {
		if tasks, ok := offersAndTasks[offer]; ok {
			driver.LaunchTasks([]*mesos.OfferID{offer.Id}, tasks, &mesos.Filters{RefuseSeconds: proto.Float64(1)})
		} else {
			driver.DeclineOffer(offer.Id, &mesos.Filters{RefuseSeconds: proto.Float64(10)})
		}
	}
}
Example #23
0
func makeResourceTemplate(name string, algo pb.Algorithm_Kind) *pb.ResourceTemplate {
	return &pb.ResourceTemplate{
		IdentifierGlob: proto.String(name),
		Capacity:       proto.Float64(100),
		Algorithm: &pb.Algorithm{
			Kind:                 algo.Enum(),
			RefreshInterval:      proto.Int64(5),
			LeaseLength:          proto.Int64(20),
			LearningModeDuration: proto.Int64(0),
		},
	}
}
Example #24
0
func (s *Scheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) {
	Logger.Debugf("[ResourceOffers] %s", offersString(offers))

	s.activeLock.Lock()
	defer s.activeLock.Unlock()

	if !s.active {
		Logger.Debug("Scheduler is inactive. Declining all offers.")
		for _, offer := range offers {
			driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(1)})
		}
		return
	}

	for _, offer := range offers {
		declineReason := s.acceptOffer(driver, offer)
		if declineReason != "" {
			driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(1)})
			Logger.Debugf("Declined offer: %s", declineReason)
		}
	}
}
Example #25
0
func TestValidateGetCapacityRequest(t *testing.T) {
	invalid := []*pb.GetCapacityRequest{
		// No ClientId.
		{
			ClientId: proto.String(""),
			Resource: nil,
		},
		// No ResourceId.
		{
			ClientId: proto.String("client"),
			Resource: []*pb.ResourceRequest{
				{
					ResourceId: proto.String(""),
					Priority:   proto.Int64(1),
					Has:        new(pb.Lease),
					Wants:      proto.Float64(1),
				},
			},
		},
		// Requests negative capacity.
		{
			ClientId: proto.String("client"),
			Resource: []*pb.ResourceRequest{
				{
					ResourceId: proto.String("resource"),
					Priority:   proto.Int64(1),
					Has:        new(pb.Lease),
					Wants:      proto.Float64(-10),
				},
			},
		},
	}

	for _, p := range invalid {
		if err := validateGetCapacityRequest(p); err == nil {
			t.Errorf("no validation error raised for invalid %v", p)
		}
	}
}
Example #26
0
func parseLine(str []string) (*userinfo.UserAddr, error) {
	//fmt.Println(str[0], str[1], str[2])
	addr := &userinfo.UserAddr{}
	if 3 != len(str) || "NULL" == str[1] || "NULL" == str[2] {
		return addr, errors.New("Error line!")
	}

	start := strings.Split(str[1], "#")
	end := strings.Split(str[2], "#")
	//fmt.Println(start[0], start[1], end[0], end[1])
	pid, _ := strconv.ParseInt(str[0], 10, 64)
	addr.Userid = proto.Int64(pid)
	slng, _ := strconv.ParseFloat(start[0], 64)
	addr.Homelng = proto.Float64(slng)
	slat, _ := strconv.ParseFloat(start[1], 64)
	addr.Homelat = proto.Float64(slat)
	elng, _ := strconv.ParseFloat(end[0], 64)
	addr.Corplng = proto.Float64(elng)
	elat, _ := strconv.ParseFloat(end[1], 64)
	addr.Corplat = proto.Float64(elat)
	return addr, nil
}
func (s *summary) Write(out *dto.Metric) error {
	sum := &dto.Summary{}
	qs := make([]*dto.Quantile, 0, len(s.objectives))

	s.bufMtx.Lock()
	s.mtx.Lock()
	// Swap bufs even if hotBuf is empty to set new hotBufExpTime.
	s.swapBufs(time.Now())
	s.bufMtx.Unlock()

	s.flushColdBuf()
	sum.SampleCount = proto.Uint64(s.cnt)
	sum.SampleSum = proto.Float64(s.sum)

	for _, rank := range s.sortedObjectives {
		var q float64
		if s.headStream.Count() == 0 {
			q = math.NaN()
		} else {
			q = s.headStream.Query(rank)
		}
		qs = append(qs, &dto.Quantile{
			Quantile: proto.Float64(rank),
			Value:    proto.Float64(q),
		})
	}

	s.mtx.Unlock()

	if len(qs) > 0 {
		sort.Sort(quantSort(qs))
	}
	sum.Quantile = qs

	out.Summary = sum
	out.Label = s.labelPairs
	return nil
}
func (s *Scheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) {
	Logger.Debugf("[ResourceOffers] %s", pretty.Offers(offers))

	for _, offer := range offers {
		declineReason := s.acceptOffer(driver, offer)
		if declineReason != "" {
			driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(10)})
			Logger.Debugf("Declined offer: %s", declineReason)
		}
	}

	s.reconcileTasks(false)
	s.cluster.Save()
}
Example #29
0
func interfaceToProto(iv interface{}) (p *pb.Value, errStr string) {
	val := new(pb.Value)
	switch v := iv.(type) {
	case int:
		val.IntegerValue = proto.Int64(int64(v))
	case int32:
		val.IntegerValue = proto.Int64(int64(v))
	case int64:
		val.IntegerValue = proto.Int64(v)
	case bool:
		val.BooleanValue = proto.Bool(v)
	case string:
		val.StringValue = proto.String(v)
	case float32:
		val.DoubleValue = proto.Float64(float64(v))
	case float64:
		val.DoubleValue = proto.Float64(v)
	case *Key:
		if v != nil {
			val.KeyValue = keyToProto(v)
		}
	case time.Time:
		if v.Before(minTime) || v.After(maxTime) {
			return nil, fmt.Sprintf("time value out of range")
		}
		val.TimestampMicrosecondsValue = proto.Int64(toUnixMicro(v))
	case []byte:
		val.BlobValue = v
	default:
		if iv != nil {
			return nil, fmt.Sprintf("invalid Value type %t", iv)
		}
	}
	// TODO(jbd): Support ListValue and EntityValue.
	// TODO(jbd): Support types whose underlying type is one of the types above.
	return val, ""
}
Example #30
0
func TestGetServerCapacity(t *testing.T) {
	fix, err := setUp()
	if err != nil {
		t.Errorf("setUp: %v", err)
	}

	defer fix.tearDown()

	// capacity is the maximum capacity of the resource.
	capacity := 100.0

	// Create a resource template.
	if err := fix.server.LoadConfig(context.Background(), &pb.ResourceRepository{
		Resources: []*pb.ResourceTemplate{
			{
				IdentifierGlob: proto.String("*"),
				Capacity:       proto.Float64(capacity),
				Algorithm: &pb.Algorithm{
					Kind:                 pb.Algorithm_FAIR_SHARE.Enum(),
					RefreshInterval:      proto.Int64(5),
					LeaseLength:          proto.Int64(20),
					LearningModeDuration: proto.Int64(0),
				},
			},
		},
	}, map[string]*time.Time{}); err != nil {
		t.Fatalf("fix.server.LoadConfig: %v", err)
	}

	subclients := 5
	wantsPerSubclient := 200.0
	var clients []clientWants
	// Form pairs of wants capacity and number of subclients.
	for s := 1; s <= subclients; s++ {
		clients = append(clients, clientWants{wantsPerSubclient, int64(s)})
	}

	out, err := makeServerRequest(fix, "resource", clients, 0)
	if err != nil {
		t.Fatalf("s.GetServerCapacity: %v", err)
	}

	// We expect to receive the maximum available capacity.
	lease := out.Response[0].GetGets()
	if got, want := lease.GetCapacity(), capacity; got != want {
		t.Errorf("lease.GetCapacity() = %v, want %v", got, want)
	}

}