Beispiel #1
0
func main() {
	sig := runOutput()

	on := fmt.Sprintf(":%d", comm.Port())

	cert, err := tls.X509KeyPair(comm.Cert(), comm.Key())
	if err != nil {
		log.Fatal("failed to load cert and key", err)
	}

	creds := credentials.NewServerTLSFromCert(&cert)
	s := grpc.NewServer(
		grpc.Creds(creds),
	)

	svr := &server{sig: sig}
	comm.RegisterGarageServer(s, svr)

	listener, err := net.Listen("tcp", on)
	if err != nil {
		log.Fatal("failed to listen", err)
	}

	err = s.Serve(listener)
	if err != nil {
		log.Fatal("failed to serve", err)
	}
}
Beispiel #2
0
func (vs *viewState) startConn() {
	certpool := x509.NewCertPool()
	if !certpool.AppendCertsFromPEM(comm.CA()) { // Add CA public cert.
		panic("failed to add cert")
	}
	creds := credentials.NewTLS(&tls.Config{
		RootCAs: certpool,
	})

	errClosed := errors.New("closed")
	backer := backoff.New(time.Millisecond*500, time.Millisecond*10)

	do := func() error {
		conn, err := grpc.Dial(fmt.Sprintf("%s:%d", comm.Host(), comm.Port()),
			grpc.WithTimeout(time.Second*3),
			grpc.FailOnNonTempDialError(true),
			grpc.WithTransportCredentials(creds),
		)
		if err != nil {
			return err
		}
		defer conn.Close()

		client := comm.NewGarageClient(conn)
		ctx := context.TODO()
		noop := &comm.Noop{}
		_, err = client.Ping(ctx, noop)
		if err != nil {
			return err
		}
		vs.mu.Lock()
		vs.connErr = nil
		vs.pingOk = true
		vs.mu.Unlock()

		ticker := time.NewTicker(time.Millisecond * 1500)
		defer ticker.Stop()

		for {
			select {
			case <-vs.onClose:
				return errClosed
			case tm := <-vs.toggle:
				if tm.Add(time.Second * 4).Before(time.Now()) {
					continue
				}
				_, err = client.Toggle(ctx, noop)
				if err != nil {
					return err
				}
			case <-ticker.C:
				_, err = client.Ping(ctx, noop)
				if err != nil {
					return err
				}
				vs.mu.Lock()
				vs.pingOk = true
				vs.mu.Unlock()
			}
		}
	}
	for {
		err := do()
		if err == errClosed {
			return
		}
		if err != nil {
			vs.mu.Lock()
			vs.connErr = err
			vs.pingOk = false
			vs.mu.Unlock()

			time.Sleep(backer.Duration())
			continue
		}
		backer.Reset()
		continue
	}
}