Beispiel #1
0
func ExampleRegister_Cluster() {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		response := Response{Message: "Factory was succesfully registered"}
		params, _ := json.Marshal(response)

		fmt.Fprintln(w, string(params))
	}))

	defer ts.Close()
	conf["Clsuter"] = ts.URL

	address := map[string]string{"Host": ts.URL}
	params, _ := marshaller.IoReader(address)

	req, err := http.NewRequest("POST", "http://www.datagentleman.io/cluster/", params)

	if err != nil {
		log.Fatal(err)
	}

	w := httptest.NewRecorder()

	cluster := &api.ClusterHandler{"", ""}
	cluster.Register(w, req, nil)

	fmt.Printf("%d", w.Code)

	// Output:
	// 200
}
Beispiel #2
0
func ExampleAccept_Job() {
	stream, err := stream.New("jobs", conf)
	if err != nil {
		fmt.Printf("ERROR:  %s\n", err)
		return
	}

	stream.Clean()

	job := &Job{Id: "1"}
	params, _ := marshaller.IoReader(job)
	req, _ := http.NewRequest("POST", "/job/1", params)

	newJob := &api.JobHandler{stream}
	resp := httptest.NewRecorder()

	ps := httprouter.Params{
		httprouter.Param{"id", "1"},
	}

	newJob.Create(resp, req, ps)

	qsize := stream.Size()

	fmt.Printf("Resonse code: %d\n", resp.Code)
	fmt.Printf("Jobs in queue: %d\n", qsize)

	// Output:
	// Resonse code: 200
	// Jobs in queue: 1
}
Beispiel #3
0
func ExampleJob_Create() {
	job := &models.Job{}
	body, _ := marshaller.IoReader(job)

	req, err := http.NewRequest("POST", "http://example.com/factories", body)
	if err != nil {
		log.Fatal(err)
	}

	w := httptest.NewRecorder()

	db, err := redis.NewDB(config)
	if err != nil {
		fmt.Printf("ERROR: %s\n", err)
		return
	}

	newCluster := cluster.NewCluster("test", db)
	newCluster.Jobs.Clean()

	newJob := api.JobHandler{newCluster}
	newJob.Create(w, req, nil)

	fmt.Printf("%d\n", newCluster.Jobs.Size())

	// Output:
	// 1
}
Beispiel #4
0
func joinCluster(name, addr string) error {
	factory := &models.Factory{Name: name}

	params, err := marshaller.IoReader(factory)
	if err != nil {
		return err
	}

	if _, err := http.Post(addr, "text/html", params); err != nil {
		return err
	}

	return nil
}
Beispiel #5
0
func (w *Warehouse) CreateCollection(col *collections.Collection) error {
	addr := w.address + DATASETS + w.Dataset + COLLECTIONS

	params, err := marshaller.IoReader(col)
	if err != nil {
		return err
	}

	_, err = http.Post(addr, "text/html", params)
	if err != nil {
		return err
	}

	return nil
}
Beispiel #6
0
func (w *Warehouse) CreateDataset(ds *storage.Dataset) error {
	addr := w.address + DATASETS

	params, err := marshaller.IoReader(ds)
	if err != nil {
		return err
	}

	_, err = http.Post(addr, "text/html", params)
	if err != nil {
		return err
	}

	return nil
}
Beispiel #7
0
// Insert(instance)
//
func (w *Warehouse) Insert(item *instance.Attributes) error {
	path := DATASETS + w.Dataset + COLLECTIONS + w.Collection + ITEMS
	addr := w.address + path

	params, err := marshaller.IoReader(item)
	if err != nil {
		return err
	}

	_, err = http.Post(addr, "text/html", params)
	if err != nil {
		return err
	}

	return nil
}
Beispiel #8
0
func ExampleDataset_Create() {
	ds := &storage.Dataset{Name: "Iris"}
	params, _ := marshaller.IoReader(ds)
	req, _ := http.NewRequest("POST", "/datasets/", params)

	db, _ := redis.NewDB(config)
	storage := storage.New(db)
	dataset := &api.DatasetHandler{storage}

	resp := httptest.NewRecorder()
	dataset.Create(resp, req, nil)

	fmt.Printf("%d", resp.Code)

	// Output:
	// 200
}
Beispiel #9
0
//
// /nodes/ => POST => register new node
//
func ExampleFactories_Register() {
	fa := models.Factory{
		Name: "factory_1",
		Host: "localhost:9001",
	}

	body, _ := marshaller.IoReader(fa)

	req, err := http.NewRequest("POST", "http://example.com/nodes", body)

	if err != nil {
		log.Fatal(err)
	}

	w := httptest.NewRecorder()

	db, _ := redis.NewDB(config)
	storage := storage.New(db)

	if err != nil {
		fmt.Printf("%s\n", err)
		return
	}

	dataset := storage.NewDataset("puaro")
	storage.Insert(dataset)

	newCluster := cluster.NewCluster("test", db)

	factory := api.FactoryHandler{newCluster}
	factory.Register(w, req, nil)

	fmt.Printf("%d", w.Code)

	newCluster.Factories.Clean()

	// Output:
	// 200
}
Beispiel #10
0
func ExampleFactories_Index() {
	factory1 := &models.Factory{Name: "factory_1"}
	factory2 := &models.Factory{Name: "factory_2"}
	factory3 := &models.Factory{Name: "factory_3"}

	body, _ := marshaller.IoReader(factory1)

	req, err := http.NewRequest("POST", "http://example.com/factories", body)
	if err != nil {
		log.Fatal(err)
	}

	w := httptest.NewRecorder()

	db, _ := redis.NewDB(config)
	storage := storage.New(db)

	dataset := storage.NewDataset("puaro")
	storage.Insert(dataset)

	newCluster := cluster.NewCluster("test", db)

	newCluster.Register(factory1)
	newCluster.Register(factory2)
	newCluster.Register(factory3)

	factory := api.FactoryHandler{newCluster}
	factory.Index(w, req, nil)

	factoriesResponse := []string{}

	json.Unmarshal([]byte(w.Body.String()), &factoriesResponse)

	fmt.Printf("%d - %d", w.Code, len(factoriesResponse))

	// Output:
	// 200 - 3
}
Beispiel #11
0
func ExampleInstance_Create() {
	config, _ := puaro.ConfigFromFile("../../configs/test.json")
	ds := &storage.Dataset{Name: "Iris"}

	attrs := &instance.Attributes{
		"attr1": "value1",
		"attr2": "value2",
		"attr3": "value3",
	}

	ps := httprouter.Params{
		httprouter.Param{"dataset", "iris"},
		httprouter.Param{"collection", "satosa"},
	}

	params, _ := marshaller.IoReader(attrs)
	req, _ := http.NewRequest("POST", "/", params)

	db, _ := redis.NewDB(config)
	storage := storage.New(db)

	storage.Clean()

	if err := storage.Insert(ds); err != nil {
		fmt.Printf("%s\n", err)
		return
	}

	instance := api.InstanceHandler{storage}
	resp := httptest.NewRecorder()
	instance.Create(resp, req, ps)

	fmt.Printf("RESPONSE CODE: %d\n", resp.Code)

	// Output:
	// RESPONSE CODE: 200
}