func main() {
	fmt.Println("running...")

	_, err := service.CallService("concatenate", "isprime", "random", "isrndprime")
	if err != nil {
		fmt.Println("error: CallService()")
	}

	for {
		time.Sleep(time.Millisecond * 2000)

		/*rnd, err := service.CallService("random")
		if err == nil {
			fmt.Println("random():", rnd)
		} else {
			fmt.Println("error: CallService()")
		}*/

		isprime, err := service.CallService("isrndprime")
		if err == nil {
			fmt.Println(isprime)
		} else {
			fmt.Println("error: CallService()")
		}

	}
}
Beispiel #2
0
// Wenn der Punkt zum ausführen eines Services aus dem Menü
// ausgewählt wurde, wird diese Funktion aufgerufen.
// Diese fragt nach, welcher Service gestartet werden soll
// und verarbeitet alle Informationen zum starten des Services.
func aufrufenService() {
	var serviceName string
	var serviceAusgabe string
	var err error
	fmt.Println(ZEILENUMBRUCH + AUFRUFEN_SERVICE_VORGEHEN)
	fmt.Print(EINGABE_SERVICE_NAME)
	fmt.Scan(&serviceName)
	serviceInformation, err := service.GetServiceInfo(serviceName)
	if err != nil {
		informationenAusgeben(err.Error(), true)
		return
	}
	if serviceInformation.Address == "" {
		informationenAusgeben("Der angegebene Service existiert nicht.", true)
		return
	}
	if serviceInformation.Info.Arguments[0].Type != "void" {
		//informationenAusgeben("Service hat mehrere Parameter.\nDies wird noch nicht unterstützt.", true)
		anzahlParameter := len(serviceInformation.Info.Arguments)
		parameter := make([]string, anzahlParameter)
		fmt.Println(ZEILENUMBRUCH)
		fmt.Println(AUFRUFEN_SERVICE_PARAMETER_INFO)
		fmt.Println(ZEILENUMBRUCH)
		for i := 0; i < len(serviceInformation.Info.Arguments); i++ {
			fmt.Printf("Der %d te Parameter ist vom Typ:\t\t%s\n", (i + 1), serviceInformation.Info.Arguments[i].Type)
			fmt.Println("Dazu gehört folgende Beschreibung:\t" + serviceInformation.Info.Arguments[i].Description)
			fmt.Printf("Parameter %d eingeben: ", (i + 1))
			fmt.Scan(&parameter[i])
			fmt.Println(ZEILENUMBRUCH)
		}
		switch len(serviceInformation.Info.Arguments) {
		case 1:
			serviceAusgabe, err = service.CallService(serviceName, parameter[0])
		case 2:
			serviceAusgabe, err = service.CallService(serviceName, parameter[0], parameter[1])
		case 3:
			serviceAusgabe, err = service.CallService(serviceName, parameter[0], parameter[1], parameter[2])
		default:
			informationenAusgeben("Unbekannte Anzahl Parameter", true)
			return
		}
	} else {
		serviceAusgabe, err = service.CallService(serviceName)
	}
	if err != nil {
		informationenAusgeben(err.Error(), true)
	}
	informationenAusgeben(serviceAusgabe, false)
}
// Create composite service service1(service2()) as servicenew
func createCompositeService(service1, service2, servicenew string) {
	desc := service1 + "(" + service2 + "())."
	serviceInfo := service.ServiceInfo{
		servicenew,
		"string",
		desc,
		[]service.ArgumentInfo{
			{"void", "void", "void"},
		},
	}

	service.RunService(&serviceInfo, func(servicecall *service.ServiceCall) string {
		result, _ := service.CallService(service2)
		result, _ = service.CallService(service1, result)
		return result
	})
}