cmd

Documentation

Index

• Constants
• Variables

Constants

const TimeOut = 50 * time.Millisecond

Variables

var GRPCClientCmd = &cobra.Command{
	Use:   "grpc_client",
	Short: "Run grpc client",
	Run: func(cmd *cobra.Command, args []string) {
		conn, err := grpc.Dial(server, grpc.WithInsecure())
		if err != nil {
			log.Fatal(err)
		}
		client := api.NewCalendarServiceClient(conn)
		st, err := parseTs(startTime)
		if err != nil {
			log.Fatal(err)
		}
		et, err := parseTs(endTime)
		if err != nil {
			log.Fatal(err)
		}
		req := &api.CreateEventRequest{
			Title:     title,
			Text:      text,
			StartTime: st,
			EndTime:   et,
		}
		resp, err := client.CreateEvent(context.Background(), req)
		if err != nil {
			log.Fatal(err)
		}
		if resp.GetError() != "" {
			log.Fatal(resp.GetError())
		} else {
			log.Println(resp.GetEvent().ID)
		}
	},
}

var GRPCServerCmd = &cobra.Command{
	Use:   "grpc_server",
	Short: "Run grpc server",
	Run: func(cmd *cobra.Command, args []string) {
		server, err := construct(dsn)
		if err != nil {
			log.Fatal(err)
		}
		err = server.Serve(addrGRPC)
		if err != nil {
			log.Fatal(err)
		}
	},
}

var HTTPServerCmd = &cobra.Command{
	Use:   "http_server",
	Short: "Run http server",
	Run: func(cmd *cobra.Command, args []string) {
		config.Init(addr)
		logger.InitLogger()

		var serverAddr strings.Builder
		serverAddr.WriteString(viper.GetString("http_listen.ip"))
		serverAddr.WriteString(":")
		serverAddr.WriteString(viper.GetString("http_listen.port"))

		logger.ContextLogger.Infof("Starting http server", viper.GetString("http_listen.ip"), viper.GetString("http_listen.port"))
		router := &handlers.Handler{}
		router.InitDB()
		mux := http.NewServeMux()
		mux.HandleFunc("/events_for_day", mw.HTTPLogger(mw.WithTimeout(router.GetEventsByDay, TimeOut)))
		mux.HandleFunc("/events_for_week", mw.HTTPLogger(mw.WithTimeout(router.GetEventsByWeek, TimeOut)))
		mux.HandleFunc("/events_for_month", mw.HTTPLogger(mw.WithTimeout(router.GetEventsByMonth, TimeOut)))
		mux.HandleFunc("/create_event", mw.HTTPLogger(mw.WithTimeout(router.CreateEvent, TimeOut)))
		mux.HandleFunc("/update_event", mw.HTTPLogger(mw.WithTimeout(router.UpdateEvent, TimeOut)))
		mux.HandleFunc("/delete_event", mw.HTTPLogger(mw.WithTimeout(router.DeleteEvent, TimeOut)))

		server := &http.Server{
			Addr:           serverAddr.String(),
			Handler:        mux,
			ReadTimeout:    10 * time.Second,
			WriteTimeout:   10 * time.Second,
			MaxHeaderBytes: 1 << 20,
		}
		server.ListenAndServe()
	},
}

HTTPServerCmd init

var RabbitRecieveCmd = &cobra.Command{
	Use:   "rabbit_recieve",
	Short: "Run rabbit recieve",
	Run: func(cmd *cobra.Command, args []string) {
		config.Init(addr)
		logger.InitLogger()
		startRecieve()
	},
}

var RabbitSendCmd = &cobra.Command{
	Use:   "rabbit_send",
	Short: "Run rabbit send",
	Run: func(cmd *cobra.Command, args []string) {
		config.Init(addr)
		logger.InitLogger()
		startSend()
	},
}

var RootCmd = &cobra.Command{
	Use:   "clncnd",
	Short: "CleanCalendar is a calendar micorservice demo",
}

RootCmd asdf

var TestCmd = &cobra.Command{
	Use:   "test",
	Short: "A brief description of your command",
	Long:  `A longer description for the delete command.`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("This is the Test command!")
		eventStorage := memory.NewMemEventStorage()

		eventService := &services.EventService{
			EventStorage: eventStorage,
		}
		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
		defer cancel()
		tSt, _ := time.Parse("2006-01-02 15:04", "2019-11-01 20:00")
		tEn, _ := time.Parse("2006-01-02 15:04", "2019-11-21 20:59")
		eventService.CreateEvent(ctx, 1, `a`, `b`, `c`, tSt, tEn)
		_, err := eventService.CreateEvent(ctx, 1, `a`, `b`, `c`, tSt, tEn)
		fmt.Printf("%s\n", err)
		test, _ := eventService.GetEvents(ctx)
		fmt.Println(test[0].Owner)
		eventService.UpdateEvent(ctx, 1, `b`, `a`, `a`, tSt, tEn)
		test2, _ := eventService.GetEvents(ctx)
		fmt.Println(test2[0].Owner)

		test5, _ := eventService.GetEventsByTime(ctx, "month")
		fmt.Println(test5[0].Owner)
		_, err = eventService.UpdateEvent(ctx, 5, `b5`, `a`, `a`, tSt, tEn)
		fmt.Printf("%s\n", err)
		err = eventService.DeleteEvent(ctx, 1)
		fmt.Printf("%s\n", err)
		err = eventService.DeleteEvent(ctx, 2)
		fmt.Printf("%s\n", err)
	},
}

TestCmd asdf