Example #1
0
func spawnCluster(userID string) {
	defer func() {
		if err := recover(); err != nil {
			globalCache.perUserID[userID].bufStream <- fmt.Sprintf("[cluster - panic] %+v", err)
			delete(globalCache.perUserID, userID)
			return
		}
	}()

	portPrefix := atomic.LoadInt32(&portStart)
	fs := make([]*etcdproc.Flags, 3)
	for i := range fs {
		df, err := etcdproc.NewFlags(fmt.Sprintf("etcd%d", i+1), globalPorts, int(portPrefix)+i, "etcd-cluster-token", "new", uuid.NewV4().String(), false, false, "", "", "")
		if err != nil {
			globalCache.perUserID[userID].bufStream <- fmt.Sprintf("[cluster - error] %+v", err)
			return
		}
		fs[i] = df
	}
	atomic.AddInt32(&portStart, 7)

	cs, err := etcdproc.CreateCluster(os.Stdout, globalCache.perUserID[userID].bufStream, etcdproc.ToHTML, cmdFlag.EtcdBinary, fs...)
	if err != nil {
		globalCache.perUserID[userID].bufStream <- fmt.Sprintf("[cluster - error] %+v", err)
		return
	}
	globalCache.mu.Lock()
	globalCache.perUserID[userID].cluster = cs
	globalCache.mu.Unlock()

	// this does not run with the program exits with os.Exit(0)
	defer func() {
		cs.RemoveAllDataDirs()
		globalCache.mu.Lock()
		globalCache.perUserID[userID].cluster = nil
		globalCache.mu.Unlock()
	}()

	errChan, done := make(chan error), make(chan struct{})
	go func() {
		globalCache.perUserID[userID].bufStream <- boldHTMLMsg("Starting all of those 3 nodes in default cluster group")
		if err := cs.StartAll(); err != nil {
			errChan <- err
			return
		}
		done <- struct{}{}
	}()

	select {
	case err := <-errChan:
		globalCache.perUserID[userID].bufStream <- fmt.Sprintf("[cluster - error] %+v", err)
	case <-done:
		globalCache.perUserID[userID].bufStream <- boldHTMLMsg("Cluster done!")
	case <-globalCache.perUserID[userID].donec:
		globalCache.perUserID[userID].bufStream <- boldHTMLMsg("Cluster done!")
	case <-time.After(cmdFlag.Timeout):
		globalCache.perUserID[userID].bufStream <- boldHTMLMsg("Cluster time out!")
	}
}
Example #2
0
func CommandFunc(cmd *cobra.Command, args []string) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Fprintln(os.Stdout, "[demo.CommandFunc - panic]", err)
			os.Exit(0)
		}
	}()

	fs := make([]*etcdproc.Flags, cmdFlag.ClusterSize)
	for i := range fs {
		df, err := etcdproc.NewFlags(fmt.Sprintf("etcd%d", i+1), globalPorts, 11+i, "etcd-cluster-token", "new", uuid.NewV4().String(), cmdFlag.IsClientTLS, cmdFlag.IsPeerTLS, cmdFlag.CertPath, cmdFlag.PrivateKeyPath, cmdFlag.CAPath)
		if err != nil {
			fmt.Fprintln(os.Stdout, "exiting with:", err)
			return
		}
		fs[i] = df
	}

	c, err := etcdproc.CreateCluster(os.Stdout, nil, etcdproc.ToTerminal, cmdFlag.EtcdBinary, fs...)
	if err != nil {
		fmt.Fprintln(os.Stdout, "exiting with:", err)
		return
	}

	if cmdFlag.ProcSave {
		f, err := openToOverwrite(cmdFlag.ProcPath)
		if err != nil {
			fmt.Fprintln(os.Stdout, "exiting with:", err)
			return
		}
		c.WriteProc(f)
		f.Close()
	}

	// this does not run with the program exits with os.Exit(0)
	defer c.RemoveAllDataDirs()

	fmt.Fprintf(os.Stdout, "\n")
	fmt.Fprintln(os.Stdout, "####### Starting all of those 3 nodes in default cluster group")
	clusterDone := make(chan struct{})
	go func() {
		defer func() {
			clusterDone <- struct{}{}
		}()
		if err := c.StartAll(); err != nil {
			fmt.Fprintln(os.Stdout, "exiting with:", err)
			return
		}
	}()

	operationDone := make(chan struct{})

	if cmdFlag.IsSimpleSimulation {

		go func() {
			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### Stress")
			if err := c.Stress(cmdFlag.ConnectionNumber, cmdFlag.ClientNumber, cmdFlag.StressNumber, 15, 15); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### SimpleStress")
			if err := c.SimpleStress(); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}
		}()

	} else if !cmdFlag.IsSimple {

		go func() {
			defer func() {
				operationDone <- struct{}{}
			}()

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### Terminate")
			if err := c.Terminate(nameToTerminate); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			// Stress here to trigger log compaction
			// (make terminated node fall behind)

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### Restart")
			if err := c.Restart(nameToTerminate); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			key, val := []byte("sample_key"), []byte("sample_value")
			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### Put")
			if err := c.Put(key, val); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### Range")
			if err := c.Range(key); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### Stress")
			if err := c.Stress(cmdFlag.ConnectionNumber, cmdFlag.ClientNumber, cmdFlag.StressNumber, 15, 15); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### SimpleStress")
			if err := c.SimpleStress(); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			time.Sleep(cmdFlag.Pause)
			fmt.Fprintf(os.Stdout, "\n")
			fmt.Fprintln(os.Stdout, "####### WatchAndPut")
			if err := c.WatchAndPut(cmdFlag.ConnectionNumber, cmdFlag.ClientNumber, cmdFlag.StressNumber); err != nil {
				fmt.Fprintln(os.Stdout, "exiting with:", err)
				return
			}

			if !cmdFlag.IsClientTLS { // TODO: not working for now
				time.Sleep(cmdFlag.Pause)
				fmt.Fprintf(os.Stdout, "\n")
				fmt.Fprintln(os.Stdout, "####### GetStats #1")
				vm, ne, err := c.GetStats()
				if err != nil {
					fmt.Fprintln(os.Stdout, "exiting with:", err)
					return
				} else {
					fmt.Fprintf(os.Stdout, "Endpoint To Stats: %+v\n", vm)
					fmt.Fprintf(os.Stdout, "Name To Endpoint : %+v\n", ne)

					fmt.Fprintf(os.Stdout, "\n")
					fmt.Fprintln(os.Stdout, "####### GetStats #2")
					endpoints := []string{}
					for _, endpoint := range ne {
						endpoints = append(endpoints, endpoint)
					}
					sort.Strings(endpoints)
					vm2, ne2, err := etcdproc.GetStats(endpoints...)
					if err != nil {
						fmt.Fprintln(os.Stdout, "exiting with:", err)
						return
					}
					fmt.Fprintf(os.Stdout, "Endpoint To Stats: %+v\n", vm2)
					fmt.Fprintf(os.Stdout, "Name To Endpoint : %+v\n", ne2)
				}

				time.Sleep(cmdFlag.Pause)
				fmt.Fprintf(os.Stdout, "\n")
				fmt.Fprintln(os.Stdout, "####### GetMetrics #1")
				{
					vm, ne, err := c.GetMetrics()
					if err != nil {
						fmt.Fprintln(os.Stdout, "exiting with:", err)
						return
					} else {
						for n, mm := range vm {
							var fb uint64
							if fv, ok := mm["etcd_storage_db_total_size_in_bytes"]; ok {
								fb = uint64(fv)
							}
							fmt.Fprintf(os.Stdout, "%s: etcd_storage_keys_total             = %f\n", n, mm["etcd_storage_keys_total"])
							fmt.Fprintf(os.Stdout, "%s: etcd_storage_db_total_size_in_bytes = %s\n", n, humanize.Bytes(fb))
						}
						fmt.Fprintf(os.Stdout, "Name To Endpoint: %+v\n", ne)

						fmt.Fprintf(os.Stdout, "\n")
						fmt.Fprintln(os.Stdout, "####### GetMetrics #2")
						endpoints := []string{}
						for _, endpoint := range ne {
							endpoints = append(endpoints, endpoint)
						}
						sort.Strings(endpoints)
						vm2, ne2, err := etcdproc.GetMetrics(endpoints...)
						if err != nil {
							fmt.Fprintln(os.Stdout, "exiting with:", err)
							return
						}
						for n, mm := range vm2 {
							var fb uint64
							if fv, ok := mm["etcd_storage_db_total_size_in_bytes"]; ok {
								fb = uint64(fv)
							}
							fmt.Fprintf(os.Stdout, "%s: etcd_storage_keys_total             = %f\n", n, mm["etcd_storage_keys_total"])
							fmt.Fprintf(os.Stdout, "%s: etcd_storage_db_total_size_in_bytes = %s\n", n, humanize.Bytes(fb))
						}
						fmt.Fprintf(os.Stdout, "Name To Endpoint : %+v\n", ne2)
					}
				}

				fmt.Println()
			}
		}()

	}

	select {
	case <-clusterDone:
		fmt.Fprintln(os.Stdout, "[demo.CommandFunc END] etcd cluster terminated!")
		return
	case <-operationDone:
		fmt.Fprintln(os.Stdout, "[demo.CommandFunc END] operation terminated!")
		return
	case <-time.After(cmdFlag.Timeout):
		fmt.Fprintln(os.Stdout, "[demo.CommandFunc END] timed out!")
		return
	}
}