Example #1
0
// setUpEnvironment sets the environment for the tests up.
func setUpEnvironment(param scenarioParam) (*Environment, *OrdersAndShipments) {
	applog.Infof("starting set-up of environment")
	rand.Seed(time.Now().Unix())

	env := NewEnvironment(Id(param.Id))
	oas := newOrdersAndShipments(param.Orders)
	bfm := BehaviorFactoryMap{
		"shop":         NewShopBehaviorFactory(oas),
		"supply":       SupplyBehaviorFactory,
		"distribution": NewDistributionBehaviorFactory(oas),
		"manufacturer": BroadcastBehaviorFactory,
	}
	manufacturerRange := param.Items / 10
	for i := 1; i < 11; i++ {
		manufacturerId := NewId("manufacturer", i-1)
		itemNoLow := (i - 1) * manufacturerRange
		itemNoHigh := i*manufacturerRange - 1
		packagingSize := (rand.Intn(99) + 1) * 10
		bfm[manufacturerId] = NewManufacturerBehaviorFactory(itemNoLow, itemNoHigh, packagingSize)

	}
	for itemNo := 0; itemNo <= param.Items; itemNo++ {
		stockCellId := NewId("stock", itemNo)
		bfm[stockCellId] = NewStockItemBehaviorFactory(itemNo)
	}
	sm := SubscriptionMap{
		"supply": {"manufacturer"},
		"manufacturer": {
			"manufacturer:0", "manufacturer:1", "manufacturer:2", "manufacturer:3", "manufacturer:4",
			"manufacturer:5", "manufacturer:6", "manufacturer:7", "manufacturer:8", "manufacturer:9",
		},
		"manufacturer:0": {"supply"},
		"manufacturer:1": {"supply"},
		"manufacturer:2": {"supply"},
		"manufacturer:3": {"supply"},
		"manufacturer:4": {"supply"},
		"manufacturer:5": {"supply"},
		"manufacturer:6": {"supply"},
		"manufacturer:7": {"supply"},
		"manufacturer:8": {"supply"},
		"manufacturer:9": {"supply"},
	}
	applog.Infof("adding cells, subscriptions and ticker")
	env.AddCells(bfm)
	env.SubscribeAll(sm)
	env.AddTicker("manufacturing", "supply", 500*time.Millisecond)
	env.AddTicker("shipment", "manufacturer", 100*time.Millisecond)
	applog.Infof("set-up of environment done")

	return env, oas
}
Example #2
0
func (a *ManufacturerAgent) Process(event ebus.Event) error {
	switch event.Topic() {
	case a.orderedTopic:
		// Store a new manufacturing order.
		var item OrderItem
		a.err = event.Payload(&item)
		if a.err != nil {
			return a.err
		}
		a.openOrders[item.ItemNo] += item.Quantity
	case a.manufacturedTopic:
		// Deliver random numbers of each item.
		a.shipmentNo++
		shipment := Shipment{a.shipmentNo, 0, make(map[int]ShipmentItem)}
		for itemNo, quantity := range a.openOrders {
			shipmentQuantity := rand.Intn(quantity) + 1
			if quantity == shipmentQuantity {
				delete(a.openOrders, itemNo)
			} else {
				a.openOrders[itemNo] = quantity - shipmentQuantity
			}
			shipment.ShipmentItems[itemNo] = ShipmentItem{a.shipmentNo, itemNo, shipmentQuantity}
		}
		ebus.Emit(shipment, "ManufacturingShipped")
	}
	if len(a.openOrders)%10 == 0 {
		applog.Infof("manufacturer: topic %q open orders are %d", event.Topic(), len(a.openOrders))
	}
	return nil
}
Example #3
0
func (a *DeliveryAgent) Process(event ebus.Event) error {
	switch event.Topic() {
	case a.receivedTopic:
		// Received a new order.
		var order Order
		a.err = event.Payload(&order)
		if a.err != nil {
			return a.err
		}
		a.openOrders[order.OrderNo] = true
	case a.packedTopic:
		// Deliver the packed order.
		var shipment Shipment
		a.err = event.Payload(&shipment)
		if a.err != nil {
			return a.err
		}
		delete(a.openOrders, shipment.OrderNo)
		ebus.Emit(len(a.openOrders), "OrderDelivered")
	}
	if len(a.openOrders)%10 == 0 {
		applog.Infof("delivery: topic %q open orders are %d", event.Topic(), len(a.openOrders))
	}
	return nil
}
Example #4
0
// runScenarioTest runs a test with the given number of orders
func runScenarioTest(assert *asserts.Asserts, param scenarioParam) {
	applog.Infof(param.String())
	monitoring.Reset()

	env, oas := setUpEnvironment(param)

	for on := 0; on < param.Orders; on++ {
		env.EmitSimple("shop", "order", generateOrder(on, param.Items))
	}

	oas.Wait(param.Orders)

	ol, sl := oas.Lengths()

	assert.Equal(ol, param.Orders, "All orders have been placed.")
	assert.Equal(sl, param.Orders, "All orders have been delivered.")
	assert.Equal(ol, sl, "The number of orders and shipments is equal.")

	time.Sleep(2 * time.Second)
	env.Shutdown()
	time.Sleep(2 * time.Second)

	monitoring.MeasuringPointsPrintAll()
	monitoring.StaySetVariablesPrintAll()
}
Example #5
0
// Dispatch the encapsulated request to the according handler methods
// depending on the HTTP method.
func dispatch(ctx *Context, h ResourceHandler) bool {
	defer func() {
		if err := recover(); err != nil {
			// Shit happens! TODO: Better error handling.
			msg := fmt.Sprintf("internal server error: '%v' in context: '%v'", err, ctx)
			applog.Criticalf(msg)
			http.Error(ctx.ResponseWriter, msg, http.StatusInternalServerError)
		}
	}()

	applog.Infof("dispatching %s", ctx)
	switch ctx.Request.Method {
	case "GET":
		return h.Get(ctx)
	case "PUT":
		if ph, ok := h.(PutResourceHandler); ok {
			return ph.Put(ctx)
		}
	case "POST":
		if ph, ok := h.(PostResourceHandler); ok {
			return ph.Post(ctx)
		}
	case "DELETE":
		if dh, ok := h.(DeleteResourceHandler); ok {
			return dh.Delete(ctx)
		}
	}
	applog.Errorf("method not allowed: %s", ctx)
	http.Error(ctx.ResponseWriter, "405 method not allowed", http.StatusMethodNotAllowed)
	return false
}
Example #6
0
// Stop the behavior.
func (b *supplyBehavior) Stop() {
	for itemNo, quantity := range b.itemQuantities {
		if quantity > 0 {
			applog.Infof("supply needs still %d pieces of item %d", quantity, itemNo)
		}
	}
}
Example #7
0
// Stop the behavior.
func (b *stockItemBehavior) Stop() {
	quantity := 0
	for _, orderItem := range b.orderItems {
		quantity += orderItem.Quantity
	}
	if quantity > 0 {
		applog.Infof("stock item %d needs %d items, has %d", b.itemNo, quantity, b.quantity)
	}
}
Example #8
0
// Test log at all levels.
func TestAllLevels(t *testing.T) {
	applog.SetLevel(applog.LevelDebug)

	applog.Debugf("Debug.")
	applog.Infof("Info.")
	applog.Warningf("Warning.")
	applog.Errorf("Error.")
	applog.Criticalf("Critical.")
}
Example #9
0
// Test logging from level warning and above.
func TestWarningAndAbove(t *testing.T) {
	applog.SetLevel(applog.LevelWarning)

	applog.Debugf("Debug.")
	applog.Infof("Info.")
	applog.Warningf("Warning.")
	applog.Errorf("Error.")
	applog.Criticalf("Critical.")
}
Example #10
0
func Main() {
	logLevel := flag.Int("log", applog.LevelDebug, "The Logging Level[0-4]")
	flag.Parse()
	setupLogger(*logLevel)

	world.Start()
	http.HandleFunc("/ws", serveWs)
	applog.Infof("Starting websocket listener on port 8888")
	http.ListenAndServe(":8888", nil)
}
Example #11
0
// Stop ends the collecting.
func (oas *OrdersAndShipments) Wait(orders int) {
	timeout := time.Duration(10*orders) * time.Millisecond
	applog.Infof("waiting for max %v", timeout)
	select {
	case <-oas.DoneChan:
		return
	case <-time.After(timeout):
		return
	}
}
Example #12
0
// Test getting a doc.
func TestGet(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	u, _ := url.Parse("http://www.rssboard.org/files/sample-rss-2.xml")
	r, err := rss.Get(u)
	assert.Nil(err, "Getting the RSS document returns no error.")
	err = r.Validate()
	assert.Nil(err, "Validating returns no error.")
	b := &bytes.Buffer{}
	err = rss.Encode(b, r)
	assert.Nil(err, "Encoding returns no error.")
	applog.Infof("--- RSS ---\n%s", b)
}
Example #13
0
// Test getting a feed.
func TestGet(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	u, _ := url.Parse("http://mue.tideland.biz/feeds/posts/default")
	f, err := atom.Get(u)
	assert.Nil(err, "Getting the Atom document returns no error.")
	err = f.Validate()
	assert.Nil(err, "Validating returns no error.")
	b := &bytes.Buffer{}
	err = atom.Encode(b, f)
	assert.Nil(err, "Encoding returns no error.")
	applog.Infof("--- Atom ---\n%s", b)
}
Example #14
0
func (a *WaitAgent) Process(event ebus.Event) error {
	var rest int
	a.err = event.Payload(&rest)
	if a.err != nil {
		return a.err
	}
	applog.Infof("wait: %d orders remaining", rest)
	if rest == 0 {
		a.done <- true
	}
	return nil
}
Example #15
0
// Test logging with the go logger.
func TestGoLogger(t *testing.T) {
	log.SetOutput(os.Stdout)

	applog.SetLevel(applog.LevelDebug)
	applog.SetLogger(applog.GoLogger{})

	applog.Debugf("Debug.")
	applog.Infof("Info.")
	applog.Warningf("Warning.")
	applog.Errorf("Error.")
	applog.Criticalf("Critical.")
}
Example #16
0
// runScenarioTest runs a test with the given number of orders
func runScenarioTest(assert *asserts.Asserts, param scenarioParam) {
	applog.Infof(param.String())
	monitoring.Reset()

	// Prepare test.
	done := make(chan bool)
	provider := config.NewMapConfigurationProvider()
	config := config.New(provider)

	config.Set("backend", "single")

	assert.Nil(ebus.Init(config), "single node backend started")

	StartShopAgent()
	StartWarehouseAgent()
	StartManufacturerAgent()
	StartDeliveryAgent()
	StartWaitAgent(done)

	// Run orders.
	for on := 0; on < param.Orders; on++ {
		order := generateOrder(on)
		err := ebus.Emit(order, "OrderReceived")
		assert.Nil(err, "order emitted")
	}

	select {
	case <-done:
		applog.Infof("order processing done")
	case <-time.After(param.Timeout):
		assert.Fail("timeout during wait for processed orders")
	}

	// Finalize test.
	err := ebus.Stop()
	assert.Nil(err, "stopped the bus")
	time.Sleep(time.Second)
	monitoring.MeasuringPointsPrintAll()
}
Example #17
0
// loop is the backend loop for the collector.
func (oas *OrdersAndShipments) loop() {
	for {
		select {
		case order := <-oas.OrderChan:
			oas.Orders[order.OrderNo] = order
		case shipment := <-oas.ShipmentChan:
			oas.Shipments[shipment.ShipmentNo] = shipment
		}
		if len(oas.Shipments) == oas.Count {
			applog.Infof("all shipments are done (%d = %d)", len(oas.Shipments), oas.Count)
			oas.DoneChan <- true
			return
		}
	}
}
Example #18
0
// Test logging with an own logger.
func TestOwnLogger(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	ownLogger := &testLogger{[]string{}}

	applog.SetLevel(applog.LevelDebug)
	applog.SetLogger(ownLogger)

	applog.Debugf("Debug.")
	applog.Infof("Info.")
	applog.Warningf("Warning.")
	applog.Errorf("Error.")
	applog.Criticalf("Critical.")

	assert.Length(ownLogger.logs, 5, "Everything logged.")
}
Example #19
0
// Test parsing and composing of date/times.
func TestParseComposeTime(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	nowOne := time.Now()
	nowStr := atom.ComposeTime(nowOne)

	applog.Infof("Now as string: %s", nowStr)

	year, month, day := nowOne.Date()
	hour, min, sec := nowOne.Clock()
	loc := nowOne.Location()
	nowCmp := time.Date(year, month, day, hour, min, sec, 0, loc)
	nowTwo, err := atom.ParseTime(nowStr)

	assert.Nil(err, "No error during time parsing.")
	assert.Equal(nowCmp, nowTwo, "Both times have to be equal.")
}
Example #20
0
// logCommand logs a command and its execution status.
func (urp *unifiedRequestProtocol) logCommand(ec *envCommand) {
	// Format the command for the log entry.
	formatCommand := func() string {
		var log string
		if ec.multi {
			log = "multi "
		}
		log += "command " + ec.command
		for _, arg := range ec.args {
			log = fmt.Sprintf("%s %v", log, arg)
		}
		return log
	}
	// Positive commands only if wanted, errors always.
	if ec.rs.IsOK() {
		if urp.database.configuration.LogCommands {
			applog.Infof("%s OK", formatCommand())
		}
	} else {
		applog.Errorf("%s ERROR %v", formatCommand(), ec.rs.err)
	}
}
Example #21
0
// Test parsing and composing of date/times.
func TestParseComposeTime(t *testing.T) {
	assert := asserts.NewTestingAsserts(t, true)
	nowOne := time.Now()
	nowStr := rss.ComposeTime(nowOne)

	applog.Infof("Now as string: %s", nowStr)

	year, month, day := nowOne.Date()
	hour, min, _ := nowOne.Clock()
	loc := nowOne.Location()
	nowCmp := time.Date(year, month, day, hour, min, 0, 0, loc)
	nowTwo, err := rss.ParseTime(nowStr)

	assert.Nil(err, "No error during time parsing.")
	assert.Equal(nowCmp, nowTwo, "Both times have to be equal.")

	// Now some tests with different date formats.
	_, err = rss.ParseTime("21 Jun 2012 23:00 CEST")
	assert.Nil(err, "No error during time parsing.")
	_, err = rss.ParseTime("Thu, 21 Jun 2012 23:00 CEST")
	assert.Nil(err, "No error during time parsing.")
	_, err = rss.ParseTime("Thu, 21 Jun 2012 23:00 +0100")
	assert.Nil(err, "No error during time parsing.")
}
Example #22
0
// Stop the behavior.
func (b *manufacturerBehavior) Stop() {
	if b.manufacturedQuantity > 0 {
		applog.Infof("manufacturer for %d to %d has %d unshipped items", b.itemNoLow, b.itemNoHigh, b.manufacturedQuantity)
	}
}
Example #23
0
// Process processes an event.
func (l *LogAgent) Process(event Event) error {
	applog.Infof("agent: %q event topic: %q", l.id, event.Topic())
	return nil
}
Example #24
0
// ProcessEvent processes an event.
func (b *logBehavior) ProcessEvent(e Event, emitter EventEmitter) {
	applog.Infof("cell: '%s' event topic: '%s' payload: '%v'", b.id, e.Topic(), e.Payload())
}
Example #25
0
// Stop the behavior.
func (b *orderBehavior) Stop() {
	for itemNo, item := range b.openItems {
		applog.Infof("order %d has item %d open, needs %d", b.orderNo, itemNo, item.Quantity)
	}
}