add catch operator, related to #141, closes #130

Note this implementation adds a second argument of the source observable to catch. See unit tests for details.

@trxcllnt ... please review?

@blesh 👍 overall, but two questions jump to mind:

the utility of the source Observable inside the catch selector is dubious imo
I'm wary of saving the Observable returned from the catch selector as the "last" selected Observable. I know they're not supposed to, but someone could return operations on the caught Observable, which would be remembered the next time the catch selector is invoked... but wouldn't have any insight into why the new caught Observable is dispatching different events than expected from the source Observable.

Do you have the same concerns? Do you have examples that can't be accomplished without scanning the caught Observable?

the utility of the source Observable inside the catch selector is dubious imo

I completely agree. We can probably remove that.

I'm wary of saving the Observable returned from the catch selector as the "last" selected Observable.

Yes, definitely, I actually changed that, it always pumps in the caught observable now. It no longer saves the "last" observable. However, there may be some interesting utility to pumping in the last observable. Mostly utility in the form of what you just mentioned. I'm not sure why someone would want to do that though... Again, it seems dubious...
How about this for the signature?
catch(handler: (err: any, caught: Observable<any>) => Observable<any>)

if we wanted to do the full monty:
catch(handler: (err: any, caught: Observable<any>, last: Observable<any>, source: Observable<T>) => Observable<any>)

My gut tells me the first option is the better one though.

@blesh Agreed, I like the first option better. seems like the second option would be better suited as a separate catchExpand operator or similar.

@trxcllnt okay, I'm going to go with that first option then...

@blesh LGTM


Flutter stream builder always received data when state changed.

I think it is a stream bug or something (at least it's not work as user expected).
I have a simple page, with a stream builder like this:
@override
Widget build(BuildContext context) {
  return new CupertinoPageScaffold(
    key: _scaffoldKey,
    navigationBar: CupertinoNavigationBar(

//            ),
        ),
    child: new StreamBuilder(
      stream: globalWsStream,
      builder: (context, snapshot) {
        // from snapshot we can get new data
        // add to globalData and start animation
        switch (snapshot.connectionState) {
          case ConnectionState.none:
            return new Text('none');
          case ConnectionState.waiting:
            return new Text('等待');
          default:
            if (snapshot.hasError) {
            } else if (snapshot.hasData) {
              if (snapshot.hasData) {
                print('--- why this called many times when state changed.');
                _solveReceivedMessage(snapshot.data);
                return new GestureDetector(
                    onTap: () {
                      print("点击了");
                      _hideKeyboard('');
                    },
                    child: new Stack(
                      children: <Widget>[
                        new Container(
                          padding: new EdgeInsets.all(0.0),
                          child: globalAppSettings.isBlurBk
                              ? new BackdropFilter(
                                  filter: new ImageFilter.blur(
                                      sigmaX: 5.0, sigmaY: 5.0),
                                  child: new Container(
                                    decoration: new BoxDecoration(
                                        color: Colors.white.withOpacity(0.0)),
                                  ),
                                )
                              : null,
                          decoration: new BoxDecoration(
                              image: new DecorationImage(
                                  // image: _getBkImage(),
                                  image: !_hasCustomBk
                                      // ? new AssetImage("assets/images/chat_bk_5.jpg")
                                      ? new AssetImage(
                                          'assets/images/chat_bk_6.jpg')
                                      : new FileImage(_chatBkFile),
                                  fit: BoxFit.cover)),
                        ),
                        new Container(
                          padding: new EdgeInsets.all(0.0),
                          child: new Container(child: _buildMsgList()),
                        ),
                        new Column(
                          mainAxisAlignment: MainAxisAlignment.end,
                          children: <Widget>[
                            new Container(
                                // color: Colors.white,
                                padding: new EdgeInsets.only(
                                    top: 15.0,
                                    bottom: 15.0,
                                    left: 5.0,
                                    right: 5.0),
                                child: _buildComposer2())
                          ],
                        ),
                      ],
                    ));
              } else {
                print('Chat 被锁住了不会进行任何操作');
              }
            }
        }
      },
    ),
  );
}

the child is a stream builder which listen to a globalStream which is as global variable and receive data from websockets. the logic for receive data is not in current page, so I must using a stream or something to get the data callback. But question is the stream can got data, but everytime state changes like input method popup or type something or click something, the previous data still received. I dont want that, I want a snapshot data can be receive only once. What should I do correctly anyway. Sorry for me not post in stackoverflow, but this maybe a bug.

When StreamBuilder is rebuilt, it subscribes again and receives a value if the stream emits one after subscription.
If you don't want that, you need to create the stream so that it doesn't emit a value or move the StreamBuilder higher up so it doesn't get rebuilt when setState() is called for this widget.
Please consider asking support questions in one of the other channels listed at http://flutter.io/support .

@zoechi What do you mean create the stream builder? the stream builder I created and its a custom stream, how to exactly avoid repeat construct the stream when setState called?

@zoechi Thanks for reply. Then how should I avoid that? As the stream used for update UI, it must write inside build, otherwise how to write the code?

I don't think I can help you here. You need to align your stream to behave like your stream consumer StreamBuilder needs it to update the view when you want.

I also encountered the same problem, how do you solve it?

@Magicskys I didn't solve it...................... it's still a problem.............. what do u got?>

@jinfagang Maybe you can try stream listen, this is a similar link.
https://stackoverflow.com/questions/50482557/flutter-how-to-make-websocket-stream-broadcast-to-many-other-pages

Please consider asking support questions in one of the other channels listed at http://flutter.io/support .

@jinfagang I tested it, it is a solution.
@override
void initState() {
// TODO: implement initState
      super.initState();
      widget.channel.stream.listen((onData){
        print(onData);
        ChatMessage message=new ChatMessage(
         text: onData,imgurl:null,flag: false
        );
        setState(() {
          _messages.insert(0, message);
        });
      });
    }

I am also facing the same issue...
I have a StreamBuilder with a stream attached to it. I have a progress bar which starts and wait for a particular task to be completed and change the UI using the setState(){}. Whenever the progress starts there is a flicker or a reload of all the widgets and this forces some of the images to reload.


Immediate Crash Happening 1.18.1

https://pastebin.com/cywdKWFz

duplicate of #7

Fixing now, sorry about this guys!

#7, check here for updates


Generate the initial migration for an entity from its model definition

Motivation
Creating an initial migration for a model can be quite tedious, especially if the model is complex. It would save a lot of time if the initial migration to create the table could be generated from the model definition.

Proposed Solutions
Expand on the functionality of sea-orm-cli.  Arguably create_table_from_entity already does the majority of the legwork in terms of creating the TableCreateStatement. The only thing that would need doing is dumping the generated code into a migrations file.

Current Workarounds

Convert the generated TableCreateStatement into a SQL string for the chosen backend.
Convert the SQL string into a StatementBuilder (can be done by playing around with the StatementBuilder trait and Statement::from_sql_and_values.
Use exec_stmt() to run this SQL.

Just a point to note, create_table_from_entity returns a raw SQL when executed, but not a generic SeaQuery statement. So if you are targeting multiple databases, this won't work unless we, embed three copies of the SQL, one for each backend.

Maybe serialising the generated TableCreateStatement pre-execution could work - though I haven't looked at it's inner workings to see how viable it would be


runtime: fatal error: sweep increased allocation count, go1.9.x

What version of Go are you using (go version)?
go version go1.9.2 linux/amd64
Does this issue reproduce with the latest release?
Yes
What operating system and processor architecture are you using (go env)?
Ubuntu Server 16.04.3 LTS with PostgreSQL 9.5.10 and OpenSSH_7.2p2 selected during install.
Intel(R) Core(TM) i5-6400 CPU
GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/home/pciet/go"
GORACE=""
GOROOT="/usr/local/go"
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0"
CXX="g++"
CGO_ENABLED="1"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"

What did you do?
Load testing by acting as 40 clients automatically without delays between actions playing my chess game implemented as a Go HTTP server with a postgres database, which should partially simulate a load of hundreds of players. Crash within 30 seconds as the number of active clients ramps up. The clients are making HTTP calls from a separate 2015 MacBook Pro on the local network.
What did you expect to see?
The load test should run indefinitely.
What did you see instead?
Crash with the signature "fatal error: sweep increased allocation count" reproducible within 30 seconds. The crash does not happen with a client count of eight or less. The crash does not happen with go1.6.4, go1.7.6, or go1.8.4, but does with go1.9, go1.9.1, and go1.9.2.
A race condition is warned with go build -race set, but the memory indicated should not have been shared between goroutines.
My investigation is detailed here, with stack traces (with and without GODEBUG=gccheckmark=1) and the race warnings: https://github.com/pciet/wichess/issues/19
My email to golang-nuts: https://groups.google.com/forum/#!topic/golang-nuts/7lcongdGOMM
I'll try to put together a case with less code and without the database.

A race condition is warned with go build -race set

If the code triggers a race condition warning, there's a race condition in the code and the program is not valid. Can you explain why do you believe that the reported race is not actually a race? Are you suggesting there's a bug in the race detector?

If the code triggers a race condition warning, then there's a race condition in the code and the program is not valid.

Nevertheless, Go tries not to crash just because there's a data race. (Go doesn't makes as many promises as Java in the face of a data race, but it does try not to crash.)

Read at 0x00c4201c4ef0 by goroutine 125:
  github.com/pciet/wichess/wichessing.Board.MovesFromPoint()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_moves.go:216 +0x538
...
Previous write at 0x00c4201c4ef0 by goroutine 49:
  [failed to restore the stack]

214	for movetype, unfilteredpaths := range TruncatedAbsPathsForKind(the.Piece.Kind, the.AbsPoint, the.Piece.Orientation) {
215		for path, _ := range b.ActualPaths(the, movetype, unfilteredpaths) {
216			for _, pt := range path.Points {
...
384 func (b Board) ActualPaths(the Point, movetype PathType, unfilteredpaths AbsPathSet) AbsPathSet {
...
388	actualPaths := make(AbsPathSet)
...
398			filteredPath := AbsPath{
399				Points: make([]AbsPoint, 0, len(path.Points)),
400			}
...
437				filteredPath.Points = append(filteredPath.Points, point)
438			}
439			if len(filteredPath.Points) > 0 {
440				actualPaths[filteredPath.Copy()] = struct{}{}
441			}

These path datatypes represent the moves a chess piece can make on the board. The function TruncatedAbsPathsForKind translates predefined move patterns relative from zero for a specific piece into a set of AbsPath made of AbsPoint (absolute path, absolute point) that fits in the range 0-7 (truncated means the edge of the board was detected before the RelPath could be completed).
Those path generating functions are called multiple times in these Board methods:
// Moves, Check, Checkmate.
func (b Board) Moves(active Orientation, previousFrom AbsPoint, previousTo AbsPoint) (map[AbsPoint]AbsPointSet, bool, bool) {
...
func (b Board) Checkmate(turn Orientation, previousFrom AbsPoint, previousTo AbsPoint) bool {
...
func (b Board) Check(turn Orientation, previousFrom AbsPoint, previousTo AbsPoint) bool {
...
func (b Board) Draw(turn Orientation, previousFrom AbsPoint, previousTo AbsPoint) bool {
...
func (b Board) AfterMove(from AbsPoint, to AbsPoint, turn Orientation, previousFrom AbsPoint, previousTo AbsPoint) Board {
...
// Diff, Taken Pieces
func (b Board) Move(from AbsPoint, to AbsPoint, turn Orientation, previousFrom AbsPoint, previousTo AbsPoint) (PointSet, map[AbsPoint]*Piece) {

The application code (such as what happens when a player requests what moves are currently available for all pieces via a HTTP GET request) calls into these methods after reading the latest representation of the board from the database without sharing these data structures - each request is one goroutine, and the only shared memory is the postgres database and game state diffs sent to a websocket goroutine for each player currently on the game page. This shared memory for sending diffs is not pointed to in these race conditions.
==================
WARNING: DATA RACE
Read at 0x00c4205df498 by goroutine 49:
  github.com/pciet/wichess/wichessing.Board.ActualPaths()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_moves.go:395 +0xde3
  github.com/pciet/wichess/wichessing.Board.MovesFromPoint()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_moves.go:215 +0x9bd
  github.com/pciet/wichess/wichessing.Board.Move()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_move.go:126 +0x12b1
  github.com/pciet/wichess/wichessing.Board.AfterMove()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_move.go:10 +0x18a
  github.com/pciet/wichess/wichessing.Board.Check()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_check.go:47 +0x2ae
  github.com/pciet/wichess/wichessing.Board.Moves()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_moves.go:50 +0x5ca
  main.game.moves()
      /home/pciet/go/src/github.com/pciet/wichess/game_moving.go:266 +0x862
  main.movesHandler()
      /home/pciet/go/src/github.com/pciet/wichess/web_moves.go:55 +0x4d0
  net/http.HandlerFunc.ServeHTTP()
      /usr/local/go/src/net/http/server.go:1918 +0x51
  net/http.(*ServeMux).ServeHTTP()
      /usr/local/go/src/net/http/server.go:2254 +0xa2
  net/http.serverHandler.ServeHTTP()
      /usr/local/go/src/net/http/server.go:2619 +0xbc
  net/http.(*conn).serve()
      /usr/local/go/src/net/http/server.go:1801 +0x83b

Previous write at 0x00c4205df498 by goroutine 125:
  github.com/pciet/wichess/wichessing.TruncatedAbsPathsForKind()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/path.go:19 +0x3d2
  github.com/pciet/wichess/wichessing.Board.MovesFromPoint()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_moves.go:214 +0x4a4
  github.com/pciet/wichess/wichessing.Board.AllNaiveMovesFor()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_moves.go:191 +0x1f1
  github.com/pciet/wichess/wichessing.Board.Check()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_check.go:39 +0xc4
  github.com/pciet/wichess/wichessing.Board.Checkmate()
      /home/pciet/go/src/github.com/pciet/wichess/wichessing/board_check.go:10 +0xb2
  main.listeningToGame.func2()
      /home/pciet/go/src/github.com/pciet/wichess/game_listening.go:114 +0x31b

Goroutine 49 (running) created at:
  net/http.(*Server).Serve()
      /usr/local/go/src/net/http/server.go:2720 +0x37c
  net/http.(*Server).ListenAndServe()
      /usr/local/go/src/net/http/server.go:2636 +0xc7
  net/http.ListenAndServe()
      /usr/local/go/src/net/http/server.go:2882 +0xfe
  main.main()
      /home/pciet/go/src/github.com/pciet/wichess/main.go:58 +0x5e6

Goroutine 125 (running) created at:
  main.listeningToGame()
      /home/pciet/go/src/github.com/pciet/wichess/game_listening.go:100 +0x7ec
  main.moveNotificationWebsocketHandler()
      /home/pciet/go/src/github.com/pciet/wichess/web_moven.go:74 +0x5e1
  net/http.HandlerFunc.ServeHTTP()
      /usr/local/go/src/net/http/server.go:1918 +0x51
  net/http.(*ServeMux).ServeHTTP()
      /usr/local/go/src/net/http/server.go:2254 +0xa2
  net/http.serverHandler.ServeHTTP()
      /usr/local/go/src/net/http/server.go:2619 +0xbc
  net/http.(*conn).serve()
      /usr/local/go/src/net/http/server.go:1801 +0x83b

path.go:
18		for path, _ := range paths {
19			availablepath := AbsPath{
20				Points: make([]AbsPoint, 0, len(*path)),
21			}
...
82 type AbsPath struct {
83 	Points    []AbsPoint
84 	Truncated bool
85 }

board_moves.go:
394		for path, _ := range unfilteredpaths {
395			if path.Truncated && the.MustEnd {
396				continue
397			}

The race is that an AbsPath was written into memory, then Truncated is read.
In this case the writing goroutine is one of those listening goroutines - it has put together a representation of all moves possible for the board state because it is determining if a checkmate state exists and would have returned if so (the goroutine received a notification that a move was made, or has just started and is checking initial conditions).
The reading goroutine is a player requesting what all moves are for the current game state, likely because they just moved and need the next move set.
There is no shared memory here besides the base representation of the moves for each piece, which is used to create new AbsPaths and is not referenced outside of TruncatedAbsPathsForKind. A Board instance is created from each database read and operated on in the reading goroutine - there are more database reads than necessary and more garbage memory created than necessary, but I'm getting it to work first before sharing memory via caching. The database interactions are mutex locked at the game level.

If the code triggers a race condition warning, then there's a race condition in the code and the program is not valid. Can you explain why do you believe that the reported race is not actually a race? Are you suggesting there's a bug in the race detector?

I've asked in the golang-nuts thread for a review of the TruncatedAbsPathsForKind function as it seems like a common source of the data races. But since these paths are created only for the calling goroutine I don't understand how different goroutines race on them. The crash indicates a pointer problem, which I've thought could be incorrect garbage collection or some sort of memory clobbering that tricks the race detector. Most likely I'm doing something wrong of course.

Nevertheless, Go tries not to crash just because there's a data race. (Go doesn't makes as many promises as Java in the face of a data race, but it does try not to crash.)

The server does not crash but does indicate a data race if I simulate four games or less (on a four core processor) but does crash within 30 seconds if the number of games increases. My test client is making moves and requesting available moves as fast as possible (~5 milliseconds per request) unsynchronized except for the interlock of playing the game.

The race detector has very very few false positives.  It is telling you that there is no synchronization between the code that creates the AbsPath value and the code that reads the Truncated field from it.  You should look carefully at your locking.

The GC keeps count of how many objects have been allocated since the last
GC and how many were live at the last GC. This puts an upper bound on the
number of live objects the GC expects to find live at the next GC. When the
GC sweeps the span it checks to see if this upper bound was exceeded. In
the past we have seen this check triggered by races resulting in pointers
being hidden from the GC. We have also seen it when there is unsafe casting
of pointers to uintptrs that the GC does not recognize as valid roots. And,
of course, due to bugs in the GC. The first step is to get a minimized race
free reproducer that doesn't use unsafe constructs.
On Sun, Nov 19, 2017 at 12:24 AM, Ian Lance Taylor<EMAIL_ADDRESS>
wrote:

The race detector has very very few false positives. It is telling you
that there is no synchronization between the code that creates the AbsPath
value and the code that reads the Truncated field from it. You should
look carefully at your locking.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/golang/go/issues/22781#issuecomment-345493161, or mute
the thread
https://github.com/notifications/unsubscribe-auth/AA7WnyIGablKVqaG1gkdtGQieWYjil7bks5s37uCgaJpZM4QiKdE
.

Here's a simplified program that removes the application code and triggers the race and crash readily. The package wichessing does not contain the keyword 'go' and is an exact duplicate of the code in the original repository - the computation should have no concurrency. The only shared memory are global variables that are read and not written. My understanding is that there are no unsafe constructs.
https://github.com/pciet/debuggo22781
package main

import (
	"github.com/pciet/debuggo22781/wichessing"
)

const clients = 6

func main() {
	for i := 0; i < clients; i++ {
		go simulateClient()
	}
	select {} // block forever
}

func simulateClient() {
	for {
		board := wichessing.Board{}
		for i := 0; i < 64; i++ {
			board[i] = wichessing.Point{
				AbsPoint: wichessing.AbsPoint{wichessing.FileFromIndex(uint8(i)), wichessing.RankFromIndex(uint8(i))},
			}
		}
		setChessStart(&board)
		_, _, _ = board.Moves(wichessing.White, wichessing.AbsPoint{0, 8}, wichessing.AbsPoint{0, 8})
	}
}

func setChessStart(b *wichessing.Board) {
	b[0].Piece = &wichessing.Piece{
		Kind:        wichessing.Rook,
		Orientation: wichessing.White,
		Base:        wichessing.Rook,
	}
	b[1].Piece = &wichessing.Piece{
		Kind:        wichessing.Knight,
		Orientation: wichessing.White,
		Base:        wichessing.Knight,
	}
	b[2].Piece = &wichessing.Piece{
		Kind:        wichessing.Bishop,
		Orientation: wichessing.White,
		Base:        wichessing.Bishop,
	}
	b[3].Piece = &wichessing.Piece{
		Kind:        wichessing.Queen,
		Orientation: wichessing.White,
		Base:        wichessing.Queen,
	}
	b[4].Piece = &wichessing.Piece{
		Kind:        wichessing.King,
		Orientation: wichessing.White,
		Base:        wichessing.King,
	}
	b[5].Piece = &wichessing.Piece{
		Kind:        wichessing.Bishop,
		Orientation: wichessing.White,
		Base:        wichessing.Bishop,
	}
	b[6].Piece = &wichessing.Piece{
		Kind:        wichessing.Knight,
		Orientation: wichessing.White,
		Base:        wichessing.Knight,
	}
	b[7].Piece = &wichessing.Piece{
		Kind:        wichessing.Rook,
		Orientation: wichessing.White,
		Base:        wichessing.Rook,
	}
	for i := 0; i < 8; i++ {
		b[8+i].Piece = &wichessing.Piece{
			Kind:        wichessing.Pawn,
			Orientation: wichessing.White,
			Base:        wichessing.Pawn,
		}
	}
	b[63].Piece = &wichessing.Piece{
		Kind:        wichessing.Rook,
		Orientation: wichessing.Black,
		Base:        wichessing.Rook,
	}
	b[62].Piece = &wichessing.Piece{
		Kind:        wichessing.Knight,
		Orientation: wichessing.Black,
		Base:        wichessing.Knight,
	}
	b[61].Piece = &wichessing.Piece{
		Kind:        wichessing.Bishop,
		Orientation: wichessing.Black,
		Base:        wichessing.Bishop,
	}
	b[60].Piece = &wichessing.Piece{
		Kind:        wichessing.King,
		Orientation: wichessing.Black,
		Base:        wichessing.King,
	}
	b[59].Piece = &wichessing.Piece{
		Kind:        wichessing.Queen,
		Orientation: wichessing.Black,
		Base:        wichessing.Queen,
	}
	b[58].Piece = &wichessing.Piece{
		Kind:        wichessing.Bishop,
		Orientation: wichessing.Black,
		Base:        wichessing.Bishop,
	}
	b[57].Piece = &wichessing.Piece{
		Kind:        wichessing.Knight,
		Orientation: wichessing.Black,
		Base:        wichessing.Knight,
	}
	b[56].Piece = &wichessing.Piece{
		Kind:        wichessing.Rook,
		Orientation: wichessing.Black,
		Base:        wichessing.Rook,
	}
	for i := 0; i < 8; i++ {
		b[63-16+i].Piece = &wichessing.Piece{
			Kind:        wichessing.Pawn,
			Orientation: wichessing.Black,
			Base:        wichessing.Pawn,
		}
	}
	for i := 0; i < 64; i++ {
		if b[i].Piece == nil {
			continue
		}
		p := b[i].Piece.SetKindFlags()
		b[i].Piece = &p
	}
}

The race and crash are easy to trigger on my machine, although the crash signature is different.
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x1 pc=0x10f9884]

Races and crash trace here: https://gist.github.com/pciet/9c2251324184adbe3fdd25e6ded9160b

The race should be fixed first to see if that resolves the issue. One bug
at a time.  The GC is concurrent and it is not hard to imagine that an
application race could hide pointers from the GC.
On Sun, Nov 19, 2017 at 1:18 PM, Matt Juran<EMAIL_ADDRESS>wrote:

Here's a simplified program that removes the application code and triggers
the race and crash readily. The package wichessing does not contain the
keyword 'go' and is an exact duplicate of the code in the original
repository - the computation should have no concurrency. The only shared
memory are global variables that are read and not written. My understanding
is that there are no unsafe constructs.
https://github.com/pciet/debuggo22781
package main
import (
"github.com/pciet/debuggo22781/wichessing"
)
const clients = 6
func main() {
for i := 0; i < clients; i++ {
go simulateClient()
}
select {} // block forever
}
func simulateClient() {
for {
board := wichessing.Board{}
for i := 0; i < 64; i++ {
board[i] = wichessing.Point{
AbsPoint: wichessing.AbsPoint{wichessing.FileFromIndex(uint8(i)), wichessing.RankFromIndex(uint8(i))},
}
}
setChessStart(&board)
_, _, _ = board.Moves(wichessing.White, wichessing.AbsPoint{0, 8}, wichessing.AbsPoint{0, 8})
}
}
func setChessStart(b *wichessing.Board) {
b[0].Piece = &wichessing.Piece{
Kind:        wichessing.Rook,
Orientation: wichessing.White,
Base:        wichessing.Rook,
}
b[1].Piece = &wichessing.Piece{
Kind:        wichessing.Knight,
Orientation: wichessing.White,
Base:        wichessing.Knight,
}
b[2].Piece = &wichessing.Piece{
Kind:        wichessing.Bishop,
Orientation: wichessing.White,
Base:        wichessing.Bishop,
}
b[3].Piece = &wichessing.Piece{
Kind:        wichessing.Queen,
Orientation: wichessing.White,
Base:        wichessing.Queen,
}
b[4].Piece = &wichessing.Piece{
Kind:        wichessing.King,
Orientation: wichessing.White,
Base:        wichessing.King,
}
b[5].Piece = &wichessing.Piece{
Kind:        wichessing.Bishop,
Orientation: wichessing.White,
Base:        wichessing.Bishop,
}
b[6].Piece = &wichessing.Piece{
Kind:        wichessing.Knight,
Orientation: wichessing.White,
Base:        wichessing.Knight,
}
b[7].Piece = &wichessing.Piece{
Kind:        wichessing.Rook,
Orientation: wichessing.White,
Base:        wichessing.Rook,
}
for i := 0; i < 8; i++ {
b[8+i].Piece = &wichessing.Piece{
Kind:        wichessing.Pawn,
Orientation: wichessing.White,
Base:        wichessing.Pawn,
}
}
b[63].Piece = &wichessing.Piece{
Kind:        wichessing.Rook,
Orientation: wichessing.Black,
Base:        wichessing.Rook,
}
b[62].Piece = &wichessing.Piece{
Kind:        wichessing.Knight,
Orientation: wichessing.Black,
Base:        wichessing.Knight,
}
b[61].Piece = &wichessing.Piece{
Kind:        wichessing.Bishop,
Orientation: wichessing.Black,
Base:        wichessing.Bishop,
}
b[60].Piece = &wichessing.Piece{
Kind:        wichessing.King,
Orientation: wichessing.Black,
Base:        wichessing.King,
}
b[59].Piece = &wichessing.Piece{
Kind:        wichessing.Queen,
Orientation: wichessing.Black,
Base:        wichessing.Queen,
}
b[58].Piece = &wichessing.Piece{
Kind:        wichessing.Bishop,
Orientation: wichessing.Black,
Base:        wichessing.Bishop,
}
b[57].Piece = &wichessing.Piece{
Kind:        wichessing.Knight,
Orientation: wichessing.Black,
Base:        wichessing.Knight,
}
b[56].Piece = &wichessing.Piece{
Kind:        wichessing.Rook,
Orientation: wichessing.Black,
Base:        wichessing.Rook,
}
for i := 0; i < 8; i++ {
b[63-16+i].Piece = &wichessing.Piece{
Kind:        wichessing.Pawn,
Orientation: wichessing.Black,
Base:        wichessing.Pawn,
}
}
for i := 0; i < 64; i++ {
if b[i].Piece == nil {
continue
}
p := b[i].Piece.SetKindFlags()
b[i].Piece = &p
}
}
The race and crash are easy to trigger on my machine, although the crash
signature is different.
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x1 pc=0x10f9884]
Races and crash trace here: https://gist.github.com/pciet/
9c2251324184adbe3fdd25e6ded9160b
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/golang/go/issues/22781#issuecomment-345537732, or mute
the thread
https://github.com/notifications/unsubscribe-auth/AA7Wn1XGYy7fUT0jTs-5hMBIgzOB_nEpks5s4HEIgaJpZM4QiKdE
.

I am making the claim that there is no fixable race in this program as each goroutine is independent by only reading from shared memory (no shared writes).
The shared reads are in the first two functions of wichessing/path.go where written memory is created independently for each calling goroutine (this is also where the race is indicated). The shared memory is read for the for loop computation and otherwise unused (len, addition, then an addition or subtraction). The written memory is not shared between goroutines.

Normally when somebody blames the race detector, we're all very skeptical (see @ianlancetaylor's comment earlier), and I admit (from looking at this a few minutes) that the race detector isn't super helpful here.
Notes: (all on Linux)
-- there is only one "go" statement in the code.
-- the shared memory is set up in inits in paths.go
-- no reported race with Go 1.8
-- races reported (with missing stacks) with Go1.9 and master.
The missing stacks are usually lost:
Previous write at 0x00c4200140a7 by goroutine 9:
  [failed to restore the stack]

When they're not lost, they point to:
Previous write at 0x00c420480a78 by goroutine 8:
  github.com/pciet/debuggo22781/wichessing.TruncatedAbsPathsForKind()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/path.go:19 +0x3d2
  github.com/pciet/debuggo22781/wichessing.Board.MovesFromPoint()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/board_moves.go:214 +0x4a4
  github.com/pciet/debuggo22781/wichessing.Board.Move()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/board_move.go:126 +0x12b1
  github.com/pciet/debuggo22781/wichessing.Board.AfterMove()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/board_move.go:10 +0x18a
  github.com/pciet/debuggo22781/wichessing.Board.Check()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/board_check.go:47 +0x2ae
  github.com/pciet/debuggo22781/wichessing.Board.Checkmate()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/board_check.go:10 +0xb2
  github.com/pciet/debuggo22781/wichessing.Board.Moves()
      /home/bradfitz/src/github.com/pciet/debuggo22781/wichessing/board_moves.go:12 +0xd3
  main.simulateClient()
      /home/bradfitz/src/github.com/pciet/debuggo22781/main.go:28 +0xc9

Where line 19 is:
// This function will truncate moves that leave the board and convert the defined relative points to actual board points but does \
not remove points with other pieces or other similar constraints.
func TruncatedAbsPathsForKind(the Kind, from AbsPoint, with Orientation) AbsPathSetMap {
        absmap := make(AbsPathSetMap)
        for movetype, paths := range RelPathMapForKind(the) {
                availablepaths := make(AbsPathSet)
                for path, _ := range paths {
                        availablepath := AbsPath{   // <---- Line 19
                                Points: make([]AbsPoint, 0, len(*path)),
                        }

I highly suspect the problem is this line:
         availablepath.Points = append(availablepath.Points, AbsPoint{File: uint8(absfile), Rank: uint8(absrank)})

Appends on shared memory are always a red flag in concurrent code.
I'm busy now for a few hours, but I can test that theory later unless others beat me to it.

Appends on shared memory are always a red flag in concurrent code.

(although I'm not convinced that memory is shared yet, either.)
The append was just my next area for investigation.

no reported race with Go 1.8

I also noticed this, so I started bisecting.
The first commit that triggers a race report on the reproducer above is  ec091b6af2ad6f33f3b36c39171d7ef65b12668b (runtime: add mapassign_fast*).
It's possible that the race is real, but it's triggered by bad code generation. Next step: investigate change in code generation introduced by the commit above.

Here's what's happening in that trace (reversed):
main.simulateClient()
wichessing.Board.Moves()
The main goroutine put together the initial chess board state and then asks for all available moves for both players on that board. Each of the goroutines created is working on an independent board.
wichessing.Board.Checkmate()
Before determining moves it looks for a checkmate state.
wichessing.Board.Check()
If the king is not in check then its not a checkmate.
			// board_check.go
46			// some cases cause reactions that remove the King, such as an enemy detonator move and friendly guard adjacent
47			_, has := b.AfterMove(orig, *pt, orientation, previousFrom, previousTo).KingLocationFor(turn)
48			if has == false {
49				return true
50			}

The loop this is in is looking at every move the opponent can make and returning true if the king can be taken directly or indirectly (check). This AfterMove call is used to look for indirect takes.
wichessing.Board.AfterMove()
What does the board look like after a move is executed? The caller of AfterMove iterates over this looking for the king location.
wichessing.Board.Move()
Execute the move for the board returned by AfterMove. The call in Move is verifying the requested move is legal. Everything computed in here is discarded:
	// board_move.go
126	if b.MovesFromPoint(fromPoint, previousFrom, previousTo).Has(to) == false {
127		return PointSet{}, pieceset
128	}

wichessing.Board.MovesFromPoint()
What moves are available from this square on the board?
wichessing.TruncatedAbsPathsForKind()
What actual paths are there for this kind of piece at this square on the board?

Appends on shared memory are always a red flag in concurrent code.

The written memory in TruncatedAbsPathsForKind is discarded after two returns in this case. I do not believe those global variables make it past the reads in this function - the returned memory (written serially by a number of appends) is isolated in this call stack.

This smaller program crashes but does not race:
package main

import (
	"github.com/pciet/debuggo22781/wichessing"
)

const clients = 6

func main() {
	for i := 0; i < clients; i++ {
		go func() {
			for {
				// in wichessing/path.go
				_ = wichessing.TruncatedAbsPathsForKind(wichessing.Pawn, wichessing.AbsPoint{0, 1}, wichessing.White)
			}
		}()
	}
	select {} // block forever
}

https://gist.github.com/pciet/8ad292c81bdae9046bf5484797b333f2
TruncatedAbsPathsForKind only calls RelPathMapForKind, but looping over RelPathMapForKind calls instead doesn't trigger a race or crash.
type AbsPathSet map[*AbsPath]struct{}

type AbsPath struct {
	Points    []AbsPoint
	Truncated bool
}

// Absolute Point represents a specific point on the board.
type AbsPoint struct {
	File uint8
	Rank uint8
}

// The PathType is used for pieces with varying moves; the pawn is the base chess example with different first move, take moves, and regular moves.
type PathType int

const (
	First PathType = iota
	Move
	Take
	RallyMove
)

type AbsPathSetMap map[PathType]AbsPathSet

type RelPathSetMap map[PathType]RelPathSet

// All relative paths for a piece, used to calculate actual paths for a board state.
type RelPathSet map[*RelPath]struct{}

type RelPath []RelPoint

type RelPoint struct {
	XOffset int8
	YOffset int8
}

// This function will truncate moves that leave the board and convert the defined relative points to actual board points but does not remove points with other pieces or other similar constraints.
func TruncatedAbsPathsForKind(the Kind, from AbsPoint, with Orientation) AbsPathSetMap {
	absmap := make(AbsPathSetMap)
	for movetype, paths := range RelPathMapForKind(the) {
		availablepaths := make(AbsPathSet)
		for path, _ := range paths {
			availablepath := AbsPath{
				Points: make([]AbsPoint, 0, len(*path)),
			}
			truncated := false
			for _, point := range *path {
				absfile := int8(from.File) + point.XOffset
				if (absfile > 7) || (absfile < 0) {
					truncated = true
					break
				}
				var absrank int8
				if with == White {
					absrank = int8(from.Rank) + point.YOffset
				} else {
					absrank = int8(from.Rank) - point.YOffset
				}
				if (absrank > 7) || (absrank < 0) {
					truncated = true
					break
				}
				availablepath.Points = append(availablepath.Points, AbsPoint{File: uint8(absfile), Rank: uint8(absrank)})
			}
			availablepath.Truncated = truncated
			if len(availablepath.Points) != 0 {
				availablepaths[&availablepath] = struct{}{}
			}
		}
		if len(availablepaths) != 0 {
			absmap[movetype] = availablepaths
		}
	}
	return absmap
}

clients = 1 and clients = 2 got my fan going but didn't crash. clients = 3 crashed after a few minutes (2-core MacBook Pro): https://gist.github.com/pciet/8ce5bf53455a22d09a06932ba4dc4f10

I got a slightly different crash message (always on 1.9.2):
runtime: pointer 0xc42023dfe0 to unused region of span idx=0x11e span.base()=0xc42023c000 span.limit=0xc42023df80 span.state=1
runtime: found in object at *(0xc420249cc0+0x8)
object=0xc420249cc0 k=0x6210124 s.base()=0xc420248000 s.limit=0xc420249fe0 s.spanclass=12 s.elemsize=80 s.state=_MSpanInUse
 *(object+0) = 0x6d
 *(object+8) = 0xc42023dfe0 <==
 *(object+16) = 0x0
 *(object+24) = 0x0
 *(object+32) = 0x0
 *(object+40) = 0x0
 *(object+48) = 0x0
 *(object+56) = 0x0
 *(object+64) = 0x0
 *(object+72) = 0x0
fatal error: found bad pointer in Go heap (incorrect use of unsafe or cgo?)

There no unsafe or cgo in the code, so there's definitely something fishy going on here.

Here's a small autocontained reproducer:
package main

type Path struct {
	P []int
}

type ZMap map[*Path]struct{}

func F() {
	zm := make(ZMap)
	for i := 0; i < 10; i++ {
		pp := Path{make([]int, 0, 8)}
		zm[&pp] = struct{}{}
	}
}

func main() {
	for i := 0; i < 16; i++ {
		go func() {
			for true {
				F()
			}
		}()
	}
	select {}
}

It crashes fairly quickly (usually within one minute) when running GOMAXPROCS=4 go run test.go on two different machines I tried. Both with go1.9.2.

Is the map key freed prematurely when the only reference is within mapassign_fast64?

If I disable mapassign_fast64 it does not crash.
If I add runtime.KeepAlive after assigning to the map, it does not crash.

@chlunde Thanks.  That makes this seem related to #21297.
CC @randall77

With 1.9 runtime.KeepAlive still crashes, but not on tip

It does certainly seem similar to #21297.  I have a core dump on a failure, and there is a map with a pointer key, where the referent has been GCd.
But #21297 has already been fixed.  We always write the keys in question with the correct write barrier code.
My current suspicion is that it's the method signature of mapassign_fast64.  The key is uint64 at that point, and if mapassign_fast64 is suspended mid-operation, maybe the key lives only there and as such can be GCd prematurely.
Maybe we need to separate the pointer and non-pointer versions of mapassign_fast64 and friends.

Looking at the generated code, the key pointer seems to be on the stack across the call to mapassign_fast64.

Ah, but according to the liveness information &pp is not live at the call to mapassign_fast64.

This does seem to roughly correspond to the original bug report, which also appears to be storing a pointer to a local variable into a map, where the local variable is defined in a loop.

Is this 1.9.X cherry-pick material? It seems quite easily triggered.

Is this 1.9.X cherry-pick material? It seems quite easily triggered.

Yes, this should definitely be considered for 1.9.x.

@pciet, can you file a separate bug for the race detector false positive, if that remains an issue?

With https://go-review.googlesource.com/c/go/+/79018 patched onto the latest in the repo my application does not crash or race under the test load that triggered the crash initially. I'll run it overnight to be sure.
Thanks for the help, I'm looking forward to the next release and will stick with 1.8.5 until then.

Confirmed that without the patch (go version devel +1e3f563) the race and crash happen readily. I'm ok to close this issue if the patch is accepted.

Reopening for 1.9.3.


doc: following web standards

Add double quotation marks on documents for following web standards.
https://www.w3.org/TR/html4/intro/sgmltut.html#h-3.2.2

That's not a standard, either works. Armin's style choice is to leave them off when unnecessary.

Just FYI, you linked to a rather ancient standard (HTML4). Read the HTML5 spec instead ;)


Support mac/ios native context textbox menu to support writing tools

Is your feature request related to a problem? Please describe.
Avalonia is not using native controls, and this allows for great flexibility and compatibility between different platforms. However, in some places, native UI is useful, i.e. file dialog pickers - there is nothing more annoying than custom file dialogs, so it is great that Avalonia uses the native API here.
I believe TextBox is another place where native look would be very handy. Especially with the introduction of writing tools. This Apple-specific feature is very useful, and supporting it in Avalonia would provide a consistent user experience.

Describe the solution you'd like
Ideally, we would just display the native context menu in textbox. However, programmer custom menus are a problem. Maybe just like with the NativeMenu, there could be a NativeContextMenu to allow native context menu customization?
Describe alternatives you've considered
No response
Additional context
According to https://developer.apple.com/videos/play/wwdc2024/10168/, native context menu with writing tools in custom text boxes can be achieved using NSServicesMenuRequestor.

This should be done like IME support I think.
I also don't think we should have the FULL textbox context menu supported. Just an ability to launch some platform-specific tools. In areas like this. However, having a NativeTextBoxContextMenu that devs optionally may use per-platform would likely also be fine.
In areas like this for framework consistency we generally have to support the least-common denominator of features across all platforms.

The more I think about the issue, the more I think this issue could be generalized to just support native context menu.
Especially on platforms like Android and iOS. There already is NativeMenuItem for global menus and tray menu. This could be extended to NativeContextMenu.

The NativeContextMenu in the image above has A LOT of functionality. I would be surprised if we can actually fully integrate Avalonia to support it in a reasonable way.
With NativeMenu we basically only support the least common denominator of functionality across all platforms. We just map to native controls like Maui. However, for a native TextBox context menu it would be much more involved I think. It's essentially going the other direction.
Bottom line: I'm hesitant this can be done in a cross-platform, maintainable way.

ContextFlyout is not tied to templated popups, and we can have both TextCommandBarFlyout and NativeTextCommandBarFlyout variations with extra menus - https://github.com/AvaloniaUI/Avalonia/discussions/8581.


Release 0.1.0

I will hold off on merging this until tomorrow.

I'm starting the hyp3_flood_monitoring user off with a quota of 1000 in the hyp3-watermap deployment.


Move on_each to Gate, and deprecate SupportsOnEachGate

Part of #4034. (See https://github.com/quantumlib/Cirq/issues/4034#issuecomment-832913708), moves the on_each functionality to cirq.Gate, and deprecates SupportsOnEachGate.
Note the tests that are deleted here had already been duplicated in raw_types_test.py by https://github.com/quantumlib/Cirq/pull/4281/files.

@mpharrigan @maffoo Here's the second part of the on_each change.


Implement block hardness/tool efficiency

I've added hardness values for each block and code to calculate tool efficiency in #247. There are a few exceptions I've noted there, but they can be fixed up afterwards.


Migrate to GRPC and the genomics v1 proto.

This change still needs some research to make the grpc dependencies work
on spark.

Hi @deflaux a first take on migrating to grpc, it consist basically of changing to the new utils and switching to the genomics v1 proto.
Still I have to figure out two things, 1) make the ALPN thing work with spark, which I don't know if is required or not but it seems so. 2) Make all the grpc netty dependencies not conflict with the spark netty deps, I'll take another look later in the week.
Thanks

The code changes for variants look good!  But I think this should be merged to a branch for now, not master.  It can be merged to master when gRPC is no longer behind a whitelist and reads have also been upgraded.

Sounds good, I'll create a branch when I got the dependency issues figured out and ready to merge.

Closing, will create a new PR a new branch.


Added Space Invaders Game

Title and Issue number
Space Invaders Game
Issue #1251
Close #1251
Checklist:

[X] I have mentioned the issue number in my Pull Request.
[X] I have commented my code, particularly in hard-to-understand areas
[X] I have created a helpful and easy to understand README.md

Please add the gssoc label also , if not there.


16 bit pointer fixes

These changes fix some crashes when trying to build programs for 16-bit targets.
Note: I'm not sure if there are any 16-bit pointer targets yet for Swift. I hope to add AVR in the near future.
The AVR architecture is extremely space constrained and will use the "embedded" compiler mode, which makes some of the fixes here not important for that platform, but they're included for completeness, in case someone wants to add other 16-bit platforms in the future where embedded mode is not used and where metadata is still important.

Quick comment, I moved over a change to this PR that was going to the AVR architecture branch, because it's actually more accurately a 16 bit pointer change (see discussion on https://github.com/swiftlang/swift/pull/74818 for details).

I think this is on the right track, but will need tests, but IIUC we can't really have any tests that target AVR until the target triple is accepted by the compiler (not even parse-only tests)? Let's then work on getting the target triple accepted first, I guess in https://github.com/swiftlang/swift/pull/74818 ?

LangOptions::setHasAtomicBitWidth() might need to set the 16-bit default:
https://github.com/swiftlang/swift/blob/0a611e8ded86d5effe0cc72f995b15a6b524650c/lib/Basic/LangOptions.cpp#L394-L405

LangOptions::setHasAtomicBitWidth() might need to set the 16-bit default:
https://github.com/swiftlang/swift/blob/0a611e8ded86d5effe0cc72f995b15a6b524650c/lib/Basic/LangOptions.cpp#L394-L405

makes sense, I'll add that

@kubamracek as I said on the call, some of these fixes may not be necessary for code compiled in embedded mode. But, theoretically, some 16-bit platforms may still want to use things like metadata and resilient classes some day. So it's really a question of whether we want to do these fixes now to help anyone in that situation? Or is it better to address this PR strictly for what's needed for AVR, and remove these fixes? It was a bit tiresome tracking down these issues and creating these fixes, but that might have been more my lack of experience than anything else.
emitClassResilientInstanceSizeAndAlignMask - I'm guessing resilient class layout isn't relevant for AVR
emitMetadataAccessByMangledName - the name suggests this isn't relevant for embedded mode AVR
TypeMetadataDemanglingCacheVariable - probably not necessary for embedded AVR?
If we omit all the above, that probably just leaves us with getExtraInhabitantIndex. Are extra inhabitants still used on embedded mode Swift, even without metadata or runtime?

some 16-bit platforms may still want to use things like metadata and resilient classes some day.

I think the metadata runtime will never even closely fit onto a 16-bit platform.

+1 I think we should not try to support full swift for 16bit triples. Related I think we need to improve our diagnostics when building with the wrong mode, see: https://github.com/swiftlang/swift/issues/75077


Codecov migration to marketplace app

Hi, Tom from Codecov here.
We noticed that you are using Codecov with fairly high frequency, and we’re so excited to see that! However, because you are not using our app, you may have experienced issues with uploading reports or viewing coverage information. This is due to rate-limiting issues from GitHub.
In order to prevent any future outages, we ask that you move over to our GitHub app integration.
The process is extremely simple and shouldn’t require more than a few clicks, and you should not expect any downtime. By moving to our app, you will no longer need an admin or separate account to manage the relationship with GitHub as the team bot.
Let me know if you have any questions, or if I can help at all with this process.

Let me close this for now, because we don't actively trigger the Codecov in this repo anymore, since Koalas is now in the maintenance mode.
Please feel free to comment if have any.


resource.resw issues

Dev Home version
No response
Windows build number
No response
Other software
No response
Steps to reproduce the bug

Settings_AboutDescription.Text <- not used in code.

Expected result
No response
Actual result
No response
Included System Information
No response
Included Extensions Information
No response

Fixed by #690


Panels create page

Description
[Describe what this change achieves]
Issues Resolved
[List any issues this PR will resolve]
Check List

[ ] New functionality includes testing.

[ ] All tests pass, including unit test, integration test and doctest

[ ] New functionality has been documented.

[ ] New functionality has javadoc added
[ ] New functionality has user manual doc added

[ ] Commits are signed per the DCO using --signoff

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
For more information on following Developer Certificate of Origin and signing off your commits, please check here.

Codecov Report

Merging #1368 (7229896) into 2.x (58a3838) will increase coverage by 28.21%.
The diff coverage is n/a.

@@              Coverage Diff              @@
##                2.x    #1368       +/-   ##
=============================================
+ Coverage     41.89%   70.10%   +28.21%
  Complexity      315      315
=============================================
  Files           302       46      -256
  Lines         17849     2482    -15367
  Branches       4290      253     -4037
=============================================
- Hits           7477     1740     -5737
+ Misses        10199      600     -9599
+ Partials        173      142       -31

Flag
Coverage Δ

dashboards-observability
?

opensearch-observability
70.10% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files
Coverage Δ

...ic/components/custom_panels/custom_panel_table.tsx

.../query_manager/antlr/output/OpenSearchPPLParser.ts

...ents_views/detail_table/table_row_btn_collapse.tsx

...ents/visualizations/charts/histogram/histogram.tsx

...tics/components/config_components/trace_config.tsx

...analytics/components/traces/span_detail_flyout.tsx

...ublic/components/visualizations/charts/bar/bar.tsx

...vent_analytics/redux/slices/visualization_slice.ts

...application_analytics/helpers/modal_containers.tsx

...oks/components/paragraph_components/para_input.tsx

... and 246 more

Help us with your feedback. Take ten seconds to tell us how you rate us. Have a feature suggestion? Share it here.


Update gl-300-fbo-multisample.cpp

Removed redundant calls

Thanks for contributing!

Thank you for all your samples!
Anyway, it'd be nice going forward, I did a small test in my own about compute shaders and variable group size here :)


Dockerfile for running neo-cli

This is an example of dockerfile I use in kubernetes. This one is tweaked a little for plain docker or docker-compose use.
The difference with kuber is in custom start-script

@lock9 I have absolutely no idea about this dockerfile that travis is testing: https://github.com/neo-project/neo-cli/blob/master/ci/Dockerfile
I just suggested to use this one: https://github.com/ksemaev/neo-cli/blob/dockerfile/Dockerfile

Sorry @ksemaev ! I saw that the error was related to Docker, that is why I thought it was caused by you. I guess we need to fix travis before.

Hi @ksemaev, thanks for this PR.
I am not sure if this needs to be merged here, because we already have this simply docker here: https://github.com/neo-project/neo-cli/blob/master/ci/Dockerfile
What do you think?
About the kubernets, I remember we discussed that in another thread. It would be good to have all the guidelines for everybody to run that. But maybe this could come in the docs. What do you think?
Maybe the docker file and all kubernets setup come be described around here: https://docs.neo.org/docs/en-us/node/cli/setup.html

@ksemaev, if that proceed, please close this PR and open a detailed description here: https://github.com/neo-project/docs
That would surely be a guidelines for many people.
If that goes well we could also update the README of this project pointing to the new description.

@ksemaev, as in the previous comment, I believe that we already have a similar docker.
But it would be great to have a complete guidelines for kubernets on the docs.
Let's leave it closed, but fell free to reopon.


fix(debug): construct untrusted message data using original frame url

Change Summary

Updates the submitOption method to construct the untrustedMessage data's url field using the frame's original url instead of the post url.

Merge Checklist

[x] PR has a Changeset
[x] PR includes documentation if necessary
[x] PR updates the boilerplates if necessary

build deployment is failing weirdly - always needs a redeploy to work - any ideas?

@davidfurlong are you having to bust the cache every time or no?


added gamma sdk and price quotes calculations

This PR adds

Gamma sdk as a local dep
getPriceQuotes to calculate the price quote of output token

How has this been tested?
Yes, verified for accuracy and values
Types of changes

[ ] Technical Debt (non-breaking change which removes unused code/assets)
[ ] Bug fix (non-breaking change which fixes an issue)
[ ] New feature (non-breaking change which adds functionality)
[ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)

Checklist:

[ ] The related ClickUp task has been linked to this PR
[ ] The person creating the pull request is listed in "Assignees"
[ ] Change requires updated documentation

TODO: replace the local gamma sdk dep when it is published


"*" properties do not work

When I write something like this:
div {
  margin: * auto;
}

Nothing happens. Everything else works fine.

This appears to be working in the latest version just fine. [demo]

@jonathantneal Thanks!


Index overflow during isosurface

https://github.com/bonej-org/BoneJ2/blob/9f24909be7c061ef8b64a69ef3e35ae2f2a4744b/Modern/wrapperPlugins/src/main/java/org/bonej/wrapperPlugins/IsosurfaceWrapper.java#L138
http://forum.imagej.net/t/bonej2-isosurface/11959/3

@dietzc Any insight into why DefaultChunker would throw an ArrayIndexOutOfBoundsException when converting a very large Img with ops.convert().bit(img)?

@rimadoma As I wrote here, we may want to add signatures to Ops that do the conversion lazily using the Converters utility class, instead of always pumping pixels upfront. In the meantime, have you tried calling Converters.convert to go from T to BitType?


Add yandex, reliable-mail, ymail to common domains.

Add new common domains to myna bird:

yandex
reliable-mail
ymail

cc @bschwartz

yandex.ru and ymail are already in the list I think...

WAT! oh f - yandex.ru is. Ah, a yandex.com is what came through. I'll merge these two into just yandex.

I think this is safe to 🚢


⚠ Fortnite has degraded performance

In 2363e72, Fortnite (https://fortnite.com) experienced degraded performance:

HTTP code: 200
Response time: 1609 ms

Resolved: Fortnite performance has improved in fbc6a5f.


Some settings for customizing the statusbar colors are missing

A couple of settings are missing:
statusBar.debuggingBorder
statusBar.noFolderBorder
This is what it would currently look like if I decided to have a red statusbar by default and a blue one while debugging:

To verify: I added

statusBar.debuggingBorder
statusBar.noFolderBorder

That's perfect, thanks.


Fixed tests

To fix the tests I had to do some refactoring:
index.js has to be a es6 module (import/export). That's why I created a ui.js with the JavaScript for the ui that imports the index.js.
I then had to change the esbuild so it builds a "browser-compatible" version (no import/export)
Now the tests can import the index.js and run as expected.

sorry I was working on this already. Please have a loot at what I did. (The files that are generated + package.json main section) to see if you think that it makes sense. I'd rather now have the demo js file in another file, since I want it to be as easy as possible to understand.


[FEATURE] [DRAFT] Add field to store event capacity

Is your feature request related to a problem? Please describe.
We need a field to store event capacity.
Describe the solution you'd like
Add an integer field (maxEventCapacity) to store event capacity (max. number of people who can attend an event).
Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.
Additional context
Add any other context or screenshots about the feature request here.

Closing as not needed.


Right clicking does nothing

You can't right click on the page. How annoying.
I'm betting this is probably some InputWritr configuration holdover from back when the game still supported right clicks.

Fixed in 1e1155e0a3f8b327b8469e5ae298c91827020d63.


feat: implement full set of named CSS colors

implements #103. I have some problems with esy install so I could not test this :(

Woah! Awesome, thank you @bgoscinski !

I have some problems with esy install so I could not test this :(

CI will do this for us - but let me know if you want help troubleshooting the esy install issues. Feel free to open an issue here w/ the error and I'll see if I can help 👍

Thanks for the details @bgoscinski ! Cool to see another Windows developer using Reason - I'm also on Win10.
I opened an issue on the esy repo (it does seem more general than revery).

In process manager I found out that esyCommand.exe spawns curl from C:\Windows\System32. Am I right that it should spawn the one which comes with cygwin?

Nice catch! I suspect this is the issue. Indeed when esy runs Curl, it's expecting the cygwin version, which has different semantics than the bundled Windows one.

woah! You're fast :D

Haha there's actually been a few other issues like this - we had the same problem with git, for example: https://github.com/esy/esy/pull/556/files
Thanks for the details / investigation!


[Feature Request] Wiki include subpages (recursion level parameter)

Is your feature request related to a problem? Please describe.
The REST API allows to fetch a wiki page including subpages. The wikiClient has this functionality already, but the main command does not expose this parameter and always passes "None" for recursion level.
Describe the solution you'd like
I'd like the --recursion-level parameter to be exposed, so that it is usable.
Additional context
Reference to the REST API documentation.

Closed by PR #1405


s/msc/psc/g

To be in line with yesterday's (?) update to the other thing. Caused an error, now it does not.

Pre-submit checklist:

Branch

[ ] Tests are provided (if possible)
[ ] Commit sequence broadly makes sense
[ ] Key commits have useful messages
[ ] Relevant tickets are mentioned in commit messages
[ ] Formatting, materialized Nix files, PNG optimization, etc. are updated

PR

[ ] Self-reviewed the diff
[ ] Useful pull request description
[ ] Reviewer requested

thanks @lemmon-714 !


Implement support for APM Server certificate pinning

See https://github.com/elastic/support-dev-help/issues/5800#issuecomment-462208728 and https://github.com/elastic/dev/issues/670 about standardising with the rest of the stack

For reference, here's other Agent's config values:

Go Agent: config-server-cert
Python Agent: config-server-cert
Ruby Agent: config-ssl-ca-cert

This is not yet implemented in Node.js / .NET


Correction for raw affiliation GRIPIC/Université Paris Sorbonne

Correction needed for raw affiliation GRIPIC/Université Paris Sorbonne
raw_affiliation_name: GRIPIC/Université Paris Sorbonne
new_rors: ;04p8das24
previous_rors:
works_examples: W3044937886;W4288330209
contact: f524bc605be612d53670e20ede7c2b4e:92c8054ae834ab0ef5ecd163d6 @ sorbonne-universite.fr

This issue was accepted and ingested by the OpenAlex team on 2024-11-01. The new affiliations should be visible within the next 7 days.


Add file_result to Network File Activity class

To support some O365 events which have the ObjectType value as a file path, we noticed that the file_result field should be added to adequately map the event.
This PR adds the file_result field to this extension event, which already exists in OCSF 1.x versions.

Since there was a change to this class, for good measure we verified that the Json schema exports as expected:

This is also up on the dev server for review prior to updating in production.

Confirmed file_result exists in objects and in dictionary.json; all LGTM :)


Setting the timezone

Hello,
How does the datepicker save the date? Is there a way to set the timezone?

there is not time zone for the entire date picker visually, but it can be an interesting one to add


Add backup link redirect

Prevents 404 issue for DTR web interface link still pointing to previous version (2.5)

Deploy preview for docsdocker ready!
Built with commit d7c1c40f255c0e31019a1790e3b0090d96a5f088
https://deploy-preview-7761--docsdocker.netlify.com

@L-Hudson can you please merge this PR ASAP? This relates to https://github.com/docker/docs-private/issues/887 and will cause a 404 for the backup link within DTR 2.6.0, so I'd like to get this redirect in before the next prod publishing cycle.

good to go!


Upload reports

First upload, more PRs will come when other members upload their own reports

All reports are uploaded. ✔


Support transient user demand return factor

Fixes #1230

I made some modifications to the test model so that:

The different user demand nodes abstract flow at different times so that they can be tested individually
The interpolations are not so steep that averaging flows makes testing hard


Provide an option to disable font smoothing

Related component

GOV.UK Typography (font smoothing)
Context

Currently, GOV.UK Typography is using the following settings taken from govuk-frontend/src/govuk/helpers/_typography.scss.
@mixin govuk-typography-common($font-family: $govuk-font-family) {
  font-family: $font-family;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  ...
}

It makes the text appear blurry on external monitors (1920x1200 or less). Updating these settings to disable font smooth makes the text appear sharp and clear on the external monitors. It would be good to have an option to allow us to disable font smoothing on a website. Please see the screenshot below. On the left hand side, the website has font smoothing enabled. On the right hand side, the website has font smoothing disabled.

Alternatives

There are no workarounds. Disabling anti-aliasing or font smoothing option in a browser does not affect a website using GOV.UK typography.
Additional information (if applicable)

A user doesn't like reading blurry text and copies the text from the website into a word processor to read instead of the website.

Hi @adityapahuja - thanks for the feedback.
We discussed this as a team and agreed that we wouldn't want to make this a configurable option for service teams, as it's unlikely to impact one service more or less than another.
As we've not had users complain about font smoothing before, we'll leave this for now, unless we get similar feedback in the future.
Thanks again

Hi @adityapahuja - thanks for the feedback.
We discussed this as a team and agreed that we wouldn't want to make this a configurable option for service teams, as it's unlikely to impact one service more or less than another.
As we've not had users complain about font smoothing before, we'll leave this for now, unless we get similar feedback in the future.
Thanks again


SBH search query and count queries don't match

In GitLab by @nwalczak on Jun 27, 2019, 16:25
When #47 was done, it didn't contain the SPARQL count query, so that query never got the same type filter.  This means currently the count of results differs from the actual results returned.

In GitLab by @nwalczak on Jun 27, 2019, 16:25
created branch 63-sbh-search-query-and-count-queries-don-t-match

In GitLab by @nwalczak on Jun 27, 2019, 16:25
mentioned in merge request !15

In GitLab by @nwalczak on Jun 28, 2019, 10:53
closed via commit bfeebb1d3525b74e4214357de675ee2cb96db0f9

In GitLab by @nwalczak on Jun 28, 2019, 10:53
closed via merge request !15

In GitLab by @nwalczak on Jun 28, 2019, 11:41
mentioned in commit bfeebb1d3525b74e4214357de675ee2cb96db0f9


Regression of #1441

#1441 isn't the actual problem, it's adf0e2cdafb6d16 by @lukesampson.
After scoop update today, when doing scoop which scoop, Scoop returns ~\scoop\apps\scoop\current\bin\scoop.ps1, which before merging #1441 used to be C:\Users\nosikil\scoop\apps\scoop\current\bin\scoop.ps1. Unfortunately, the newly returned path resolves to H:\scoop\apps\scoop\current\bin\scoop.ps1 on my machine. It seems that ~ != %USERPROFILE%.
When I do git revert adf0e2cdafb, Scoop works fine again.

I don't know what goes wrong here, adf0e2c should have the opposite effect of what I'm seeing.


Optimize jump-links for mobile (jump-links 2.0)

As a user I would like to see and access the table of contents aka jump links as I scroll even on mobile.

Demo before and after implementation of jump link for mobile


Code refactor for queries

Type of change

Refactoring

Description

Refactor garphql queries into separate file
Refactor query function and create separate function for filter, and sorting
Added code coverage configuration
Added new yarn/npm command to run unit test with code coverage i.e. test:coverage
Implemented absolute path for file system
Create constant file and moved hard code values into constant file
Changed folder name as camel case consistency

Checklist

[ ] Update/write design documentation in ./documentation/design
[ ] Write tests and make sure they pass
[ ] Update documentation
[ ] Check RBAC rights for Kubernetes / OpenShift roles
[ ] Try your changes from Pod inside your Kubernetes and OpenShift cluster, not just locally
[ ] Reference relevant issue(s) and close them after merging
[ ] Update CHANGELOG.md

Can one of the admins verify this patch? e.g. @enmasse-ci run tests profile=smoke

changes have implemented, please check.


The BreakPionts Not Work

Help me!The BreakPionts Not Work!
This my code:
using (var conariL = new ConariL(@".\x64\libcurl-x64.dll"))
{
var curl = conariL.DLR.curl_easy_init();
conariL.DLR.curl_easy_setopt(curl, 10002, "http://www.baidu.com");
var res = conariL.DLR.curl_easy_perform(curl);
}

What do you mean for "BreakPionts Not Work"?
To be sure,
cURL requires openssl libraries. For x64 (curl-7.67.0-win64-mingw) you need libcrypto-1_1-x64.dll and libssl-1_1-x64.dll
Also provide a return type if exists of course. For LuNari project I already mentioned about data types when string args (we need to consolidate info later), thus please also note: https://github.com/3F/LuNari/wiki/API#data-types
using(var l = new ConariL("libcurl-x64.dll"))
{
    var curl = l.DLR.curl_easy_init<IntPtr>(); // CURL *handle OK: ~0x000002080ea87e10

    //...

    l.DLR.curl_easy_setopt(curl, 10002, "http://example.com");
    var res = l.DLR.curl_easy_perform<long>(curl);
}

This is ok:
using (var l = new ConariL("libcurl-x64.dll"))
{
var curl = (IntPtr)l.DLR.curl_easy_init();
l.DLR.curl_easy_setopt(curl, 10002, "http://www.baidu.com");
var code = l.DLR.curl_easy_perform(curl);
}

This is ok:

Good to hear this!

(IntPtr)l.DLR.curl_easy_init();

I recommend exactly generic type because Conari will automatically adapt it for related requests at memory read instead of your example above when you're trying to cast result to IntPtr.
Wrong default type may corrupt processing in some cases. Because:
l.DLR.something<ret_type>() != (ret_type)l.DLR.something()
\-----------------------/                \-------------/

Thanks for using,


'Non-void function does not return a value in all control paths' error in CleverTap with Xcode 14.3.1

In Xcode 14.3.1, we are using the CleverTap ios sdk -3.9.2 and also tried with the 5.1.2,but the framework encounters an error message stating "Non-void function does not return a value in all control paths." This error indicates that a function in the sdk codebase is expected to return a value, but there are certain control paths where no value is being returned. Please let us know that whether the clevertap is able to integrated in xcode 14.3.1 or not.
Xcode- 14.3.1
iOS - 13.0
Your response will be highly appreciated.

Hi @Anoopkmr1
Can you share the screenshot of the file where you are getting this error?

Please find the Screen shot the error


General Tidy up of docs and fixes to some warning types - [merged]

Merges register -> main
All changes that this PR does are documented in the changelog.
Other misc changes have no user facing changes but tidy up RST and CI issues.

added 1 commit
32f1128d - [Fix?] Pad arrays that are 4094 when registered
Compare with previous version

added 1 commit
e9a5474e - test config option for CI
Compare with previous version

added 1 commit
a4d24595 - [Fix?] Pad arrays that are 4094 when registered
Compare with previous version

added 1 commit
1c092e2f - update error message and add tests for degradation
Compare with previous version

added 1 commit
2daf12a9 - pad with fill value
Compare with previous version

marked this merge request as ready

added 3 commits
69f2caad - Break API for degradationfa015a25 - changelogfffec36d - fix tests
Compare with previous version

In GitLab by @wtbarnes on Jan 12, 2023, 11:11
Commented on aiapy/calibrate/prep.py line 97
I think I am :thumbsdown: on this approach. Is there a particular reason that level 1.5 maps must always have dimensions (4096,4096)? Is this just to maintain consistency with what is done in IDL? (that is fine if that is the case).
If so, I think instead of special casing some particular shape, we should have some sort of cropping/padding operations that ensures that the centered, de-rotated, and scaled image always has a width and height of 4096 pixels.

In GitLab by @wtbarnes on Jan 12, 2023, 11:15
Commented on aiapy/calibrate/prep.py line 82
(This does not really relate to the changes made in this PR)
I don't think this if-else block is needed. The target scale should always be 0.6 "/pixel
    scale = 0.6 * u.arcsec

This function should also only be applied to level 1 maps (which by definition have not been rescaled).

In GitLab by @wtbarnes on Jan 12, 2023, 12:36
Commented on aiapy/calibrate/prep.py line 97
Ha well with my proposed padding approach in submap it will be :stuck_out_tongue:. Otherwise, no, I don't think so (not without reprojection at least).

I actually don't know what the IDL version does. I should check.
Is it possible to do that generally to ensure the image is always 4096?

I will remove it.

Ok, so I will remove this then. Add a note in the doc string or something.

Now removed.

changed this line in version 8 of the diff

added 1 commit
a9899652 - What a mess
Compare with previous version

changed this line in version 8 of the diff

Removed, added a warning to the docstring.

added 1 commit
e046c4a5 - What a mess
Compare with previous version

added 1 commit
00317003 - What a mess
Compare with previous version

added 1 commit
a4e70edb - What a mess
Compare with previous version

added 1 commit
7df375a5 - What a mess
Compare with previous version

In GitLab by @wtbarnes on Jan 13, 2023, 06:56
Sorry, but the scope of this PR has now become unclear to me and I'm having a hard time reviewing it. Could you move all the register-related commits to a separate PR? Or if it is easier, just remove them. If the latter, I can open a separate PR to deal with my suggested changes.
I think it is important to keep any changes to register in their own PRs and not buried amongst other changes, given its importance in the "prep" phase of analyzing AIA data.

added 1 commit
4cc39534 - What a mess
Compare with previous version

added 1 commit
dc312617 - What a mess
Compare with previous version

I updated the changelog to say that this PR does.

This PR now does 0 actual changes to register.

added 1 commit
b14323fe - update changelog
Compare with previous version

added 1 commit
3ff4b6dd - update changelog
Compare with previous version

added 1 commit
a1ab7498 - undo change to regsiter
Compare with previous version

resolved all threads

In GitLab by @wtbarnes on Jan 17, 2023, 11:52
Commented on aiapy/calibrate/tests/test_prep.py line 37
I would keep this comment. It links to the issue that explains why this is not checking for 4096

In GitLab by @wtbarnes on Jan 17, 2023, 11:55
approved this merge request

This has been reverted now.

changed this line in version 18 of the diff

added 1 commit
b9298a05 - Added back comments in unit test
Compare with previous version

mentioned in commit 8a23c715b552d0024f5421b3d76152c00a50c9ba

In GitLab by @wtbarnes on Jan 17, 2023, 11:55
resolved all threads


fix(label): Make label search case-insensitive.

Note: If there are pending changes to the PR, prefix the PR title with "WIP" and add the label "DO NOT MERGE"
Mandatory

[ ] What does this PR do?
Make label search case-insensitive in the quick preview.

[ ] What issue/task does this PR references?
https://github.com/openshiftio/openshift.io/issues/3640

[ ] Are the tests Included?

Optional

[ ] Is the documentation Included?

[ ] Are the Release Notes included?

[ ] @mention(s) to expected reviewer(s) included

Ike Plugins (test-keeper)
Thank you @vikram-raj for this contribution!

It appears that no tests have been added or updated in this PR.
Automated tests give us confidence in shipping reliable software. Please add some as part of this change.
If you are an admin or the reviewer of this PR and you are sure that no test is needed then you can use the command /ok-without-tests as a comment to make the status green.
For more information please head over to official documentation. You can find there how to configure the plugin.

@vikram-raj Your image is available in the registry. Run docker pull registry.devshift.net/fabric8-ui/fabric8-planner:SNAPSHOT-PR-2683 && docker run -it -p 5000:8080 registry.devshift.net/fabric8-ui/fabric8-planner:SNAPSHOT-PR-2683 and visit http://localhost:5000 to access it.

@vikram-raj Your image is available in the registry. Run docker pull registry.devshift.net/fabric8-ui/fabric8-planner:SNAPSHOT-PR-2683 && docker run -it -p 5000:8080 registry.devshift.net/fabric8-ui/fabric8-planner:SNAPSHOT-PR-2683 and visit http://localhost:5000 to access it.


Support trace deletion

It would probably be good to allow users to delete traces they have uploaded. This is probably a little tricky due to the fact that there's no login / auth mechanism to know who uploaded what, but it seems like a good feature to have regardless if you can solve that challenge.

@csharrison Yup. true.  I'd love to have this.
My storage layer is blissfully easy right now.. Just some JS uploading directly to a firebase store (gcs bucket). Some auth around that to ensure folks can write but not delete.
And sadly, while I could enable deletion, there aren't any built-in controls to only do it with some authenticated token. Thus, it'd be easy to delete anyone else's traces, assuming you know the URL.
Clearly this isn't your problem. I'm just writing it out for my future self (or some smarter firebase/gcs person who has an idea) :)


failed in the containerd-env-setup experiment

when I test containerd with nydus-snapshotter as the doc of this repository below:
https://github.com/dragonflyoss/image-service/blob/master/docs/containerd-env-setup.md
I have convert a nydus style image using:
nydusify convert --nydus-image /usr/local/bin/nydus-image --source docker.io/library/ubuntu:16.04 --target localhost:5000/ubuntu:16.04-nydus
and then the image was pushed into my local registry, I can find it:
>> curl "http://localhost:5000/v2/ubuntu/tags/list"
{"name":"ubuntu","tags":["16.04-nydus"]}

But, after I started nydus-snapshotter and containerd, I want to use crictl test the whole process:
crictl pull localhost:5000/ubuntu:16.04-nydus
crictl error happend, message:
FATA[0000] pulling image: rpc error: code = Unknown desc = failed to pull and unpack image "localhost:5000/ubuntu:16.04-nydus": failed to prepare extraction snapshot "extract-262457039-f1jQ sha256:6df557218c153a61f8d1901eb213a80413b18a6f789c9ed0b5bef6d3ec9e3679": failed to find image ref of snapshot 25, labels map[containerd.io/snapshot.ref:sha256:6df557218c153a61f8d1901eb213a80413b18a6f789c9ed0b5bef6d3ec9e3679 containerd.io/snapshot/nydus-bootstrap:true]: unknown

the nydus-snapshotter error message:
{"dir":"/var/lib/containerd/io.containerd.snapshotter.v1.nydus/snapshots/25","level":"info","msg":"cleanupSnapshotDirectory /var/lib/containerd/io.containerd.snapshotter.v1.nydus/snapshots/25","time":"2021-01-21T16:53:35.285184694+08:00"}

{"dir":"/var/lib/containerd/io.containerd.snapshotter.v1.nydus/snapshots/25","error":"failed to get daemon by snapshotID (25)","level":"error","msg":"failed to unmount","time":"2021-01-21T16:53:35.285204313+08:00"}

{"level":"info","msg":"umount nydus daemon of id 25, mountpoint /var/lib/containerd/io.containerd.snapshotter.v1.nydus/snapshots/25","time":"2021-01-21T16:53:35.285217642+08:00"}

{"dir":"/var/lib/containerd/io.containerd.snapshotter.v1.nydus/snapshots/25","error":"failed to get daemon by snapshotID (25)","level":"error","msg":"failed to unmount","time":"2021-01-21T16:53:35.285231057+08:00"}
........

nydus-snapshotter settings:
containerd-nydus-grpc --nydusd-path /usr/local/bin/nydusd     --config-path /etc/nydusd-config.json     --shared-daemon     --log-level debug     --root /var/lib/containerd/io.containerd.snapshotter.v1.nydus     --address /run/containerd/containerd-nydus-grpc.sock       --nydusimg-path /usr/local/bin/nydus-image

how to understand the problem and solve it?

Thanks for the report. There is a known issue in the --shared-daemon mode. Please remove it from the nydus-snapshotter settings and retry.
I've raised https://github.com/dragonflyoss/image-service/pull/49 to alter the setup guide as well.

Thanks for the report. There is a known issue in the --shared-daemon mode. Please remove it from the nydus-snapshotter settings and retry.
I've raised https://github.com/dragonflyoss/image-service/pull/49 to alter the setup guide as well.

Thanks for the report. There is a known issue in the --shared-daemon mode. Please remove it from the nydus-snapshotter settings and retry.
I've raised #49 to alter the setup guide as well.

Great!

Thanks for the report. There is a known issue in the --shared-daemon mode. Please remove it from the nydus-snapshotter settings and retry.
I've raised #49 to alter the setup guide as well.

Great!

Thanks for the report. There is a known issue in the --shared-daemon mode. Please remove it from the nydus-snapshotter settings and retry.
I've raised #49 to alter the setup guide as well.

Great !
I remove the --shared-daemon arg of nydus-snapshotter
AND set the containerd config file just keep the same as written in the doc (not modified the file got from containerd config default > /etc/containerd/config.toml ):

Thanks for the report. There is a known issue in the --shared-daemon mode. Please remove it from the nydus-snapshotter settings and retry.
I've raised #49 to alter the setup guide as well.

Great !
I remove the --shared-daemon arg of nydus-snapshotter
AND set the containerd config file just keep the same as written in the doc (not modified the file got from containerd config default > /etc/containerd/config.toml ):


Feat: Check if User is Online

What is your issue related to ?

[x] Code
[ ] Designing
[ ] Documentation
[ ] Testing/Research
[ ] Others[please specify]

Description
Users can check if their Partners are online or not.
Additional context
Add after Implementation.

Assigning this issue to you @Rohit-2602


Adding some help for the options in text-generation-benchmark.

What does this PR do?
Fixes https://github.com/huggingface/text-generation-inference/issues/420

Fixes # (issue)
Before submitting

[ ] This PR fixes a typo or improves the docs (you can dismiss the other checks if that's the case).
[ ] Did you read the contributor guideline,
Pull Request section?
[ ] Was this discussed/approved via a Github issue or the forum? Please add a link
to it if that's the case.
[ ] Did you make sure to update the documentation with your changes? Here are the
documentation guidelines, and
here are tips on formatting docstrings.
[ ] Did you write any new necessary tests?

Who can review?
Anyone in the community is free to review the PR once the tests have passed. Feel free to tag
members/contributors who may be interested in your PR.

@Narsil This documentation is helpful, but I think there are still some things that could be clarified.

Which parts of the transformer inference count as the pre-fill step versus the decode step?
Does sequence-length affect the length of the model's context window, or is the context window fixed at the default maximum for that model architecture?

You send request:
input_ids = [A, B, C, A]  #   Those are tokens
new_token_D, past  = forward(input_ids)

That's a prefill step.
Then we continue generating new tokens in what we call a decode step:
input_ids = [new_token_D]
new_token_F, past = forward(input_ids, past)

Does sequence-length affect the length of the model's context window, or is the context window fixed at the default maximum for that model architecture?

In this tool it means the prompt size. The context window is the context window, and text-generation-inference always uses the smallest possible window. Some models don't have a maximum window...

Great! Thanks for addressing those questions. My only remaining question is less related to the benchmark, but I'm curious what exactly you mean by the smallest possible window?
I understand that flash or sparse attention models won't use padding, but if the user generates a very long sequence, say thousands of tokens, how many of those tokens will a model in text-generation-inference attend to?

I understand that flash or sparse attention models won't use padding, but if the user generates a very long sequence, say thousands of tokens, how many of those tokens will a model in text-generation-inference attend to?

By default it will send everything and the model will attend to everything.
This will crash if the model has a fixed sized context window.
In that case you could also use truncate to drop every extra tokens to the left of the query (this is brutal, but there's no good way to make it cleverer in a general fashion)

but I'm curious what exactly you mean by the smallest possible window?

Let's say you have 3 queries:
Query1: Prompt 100 tokens, generating max 10 more

@Narsil Awesome, thanks for the explanation!

@OlivierDehaene Can we merge this ?


Memory ToString

Memory ToString shouldn't truncate; either return the string on multiple lines or throw an exception if the length is too long, but don't just stop at the 8th byte? as this could lead to confusion
...
public override string ToString()
{
var sb = new StringBuilder();
var data = Span;
sb.Append("[");
bool first = true;
for(int i=0; i<Length; i++) {
if (i > 7) break;

It should, in the debugger, show 64MiB of data rendered to a string, or nothing but that an exception happened while accessing the variable?
The current implementation sounds like a reasonable compromise.


fix backward compatible in delegate

Hi,
This PR fix that not backward compatible after add new structure TfLiteRegistrationExternal in TfLiteRegistration once use delegate case
Please check the changes.
Regards
Arvin

Hi @MeghnaNatraj Can you please review this PR ? Thank you!

@arvinjhou thanks for your contribution. Could you share if this PR is still needed with ToT TFLite?
If yes, could you elaborate your issue?

@arvinjhou Can you please check @terryheo's comments and resolve conflicts?. Thank you!

Hi @arvinjhou Any update on this PR? and please resolve conflicts. Thank you!

Hi @arvinjhou I'm going to go ahead and close this PR, because it seems to have stalled. If you're still interested in pursing this (and responding to my comments), please feel free to reopen! thank you for your contribution.

Just a brief comment on this issue: TF Lite has not promised binary backwards compatibility.
In particular for TFLiteRegistration, the structure was only documented as being "semi-ABI stable".
See the comment at the top of common.h:
// NOTE: The order of values in these structs are "semi-ABI stable". New values
// should be added only to the end of structs and never reordered.

So IMHO the proposed change in this issue should be considered as a feature request rather than a bug fix.
Also, I don't think the proposed patch would be sufficient to ensure binary backwards compatibility in all cases.
For example custom ops might not have version == 1.  Likewise for delegates not defined using SimpleDelegateInterface.
The patch also doesn't have any tests to ensure binary backwards compatibility would be preserved in the future.


Bump k3s version to v1.19.5+k3s2 And Release

Thanks for helping us to improve k3OS! We welcome all feature requests. Please fill out each area of the template so we can better understand the request. You can delete this message portion of the bug report.
Is your feature request related to a problem? Please describe.
The new release v0.2.0 of rancher/harvester will support HA.
This feature depends on the embedded etcd of k3s.
Since k3s v1.19.5+k3s1, the embedded etcd of k3s is already stable.
Describe the solution you'd like
dump k3s version to latest version v1.19.5+k3s2 and release
Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.
Additional context
Add any other context or screenshots about the feature request here.

Looks like it's already been bumped to v1.19.5+k3s2, just not released yet.
https://github.com/rancher/k3os/commit/7cb1c62fc9da14e7af25511af82f4611141fc73b
I'm eagerly awaiting this release so that I could test & deploy an HA environment based off of K3os.

Addressed via #636

Addressed via #636


large numbers of transactions can cause 'datarate is exceeded' errors in Jupyter

Intermittent issue when using an input CSV file containing 10,000+ transactions.
The work around is to start Jupyter from Anaconda Powershell: jupyter notebook --NotebookApp.iopub_data_rate_limit=1.0e10 or jupyter lab --NotebookApp.iopub_data_rate_limit=1.0e10

Workaround is documented in the README.md file


Upgrade webpack to v2.2.0

Upgraded to latest Webpack version, for dist generation: https://webpack.js.org/configuration/

Coverage remained the same at 100.0% when pulling f7dce208dc258b5c1bc2c951da075af05aa17f02 on webpack-upgrade into 59bb12cfaaf738987e316542b8e3a3197f8c1c69 on master.


Nimble Picker

😯 Problem to Solve
The PDV app in SLE was planned to use nimble-picker to display the selected axis for the plots.
We were able to find the designs available and some part of development being done in one of the pulls

Currently, as the component is not yet available, we decided to go with comma-separated values to display the selections, which has a questionable UX for removing a selection and handling errors if any of the selections becomes invalid due to the change in data
💁 Proposed Solution

Can we prioritize or continue the development of the picker component?
If not considered already, picker should be able to highlight the invalid values in different color

@ranjgith-ni thanks for providing your requirements! We actually have an existing picker issue so I'm going to move your notes over there and close this one as duplicate. I'll also respond there about where this fits in our priorities. #458


etcd backup operator TCP socket memory leak

We just found that create EtcdBackup custom resource will cause TCP socket memory leak which can be observed by watching the output of command cat /proc/net/sockstat.
In our case, each time we create a EtcdBackup custom resource backups to S3 bucket will leave ~3000 unit TCP memory. Eventually the TCP memory usage will hit the max (from /proc/sys/net/ipv4/tcp_mem) if we backup periodically (eg. via cronjob) and the system network performance becomes extremely slow.
Kubernetes 1.9.7 on AWS, created by kops 1.9.0
Both etcd-operator 0.8.4 and 0.9.2 have this issue.
etcd-backup-operator Deployment:
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  namespace: my-namespace
  name: etcd-backup-operator
spec:
  replicas: 1
  template:
    metadata:
      labels:
        name: etcd-backup-operator
    spec:
      containers:
      - name: etcd-backup-operator
        image: quay.io/coreos/etcd-operator:v0.9.2
        command:
        - etcd-backup-operator
        env:
        - name: MY_POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: MY_POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name

EtcdBackup custom resource:
apiVersion: etcd.database.coreos.com/v1beta2
kind: EtcdBackup
metadata:
    namespace: my-namespace
    name: etcd-backup-01
spec:
    etcdEndpoints: ["etcd-cluster-client:2379"]
    storageType: S3
    s3:
    path: etcd-backup/etcd.backup.01
    awsSecret: my-aws-secret

Can confirm the same issue on our cluster.

I have found at least one leak in the backup process.  see PR #1976 @CheyiLin @irfn


DOC-3774 DRAFT

DRAFT created per Henry Hughes' request
convert java-driver docs to asciidoc

Created fork


Match cnames in ipset

ipset module does not add ip to list when the specified domain is a CNAME

Thanks for this! I went ahead and made some further fixes and introduced an ipset test.


Greenkeeper/sinon 5.0.10

Coverage remained the same at 91.304% when pulling 609fda1ff32198428f5b211b55f79527a733ef10 on greenkeeper/sinon-5.0.10 into ebe2f34bb9b0987bb25183ff840997812855bc5e on master.


"div" custom element causes silent failures

Changing both occurences of "div1" to "div" (and also the third occurence in the test markdown) causes markdown rendering to silently fail (nothing is emitted).
Working remark scaffolding (clojurescript):
(def whitelist
  {"span" (fn [props] [:span (dissoc props :children :value) (:value props)])
   "div1" (fn [props] [:div (dissoc props :children :value) (:value props)])})

(defn markdown [value change! & [props]]
  (let [children
        (->
          (js/remark)
          (.use
            js/remarkGenericExtensions
            (clj->js
              {"elements"
               {"span" {"html" {"properties" {"value" "::content::"}}}
                "div1" {"html" {"properties" {"value" "::content::"}}}}}))
          (.use
            js/remarkReact
            (clj->js
              {"sanitize" false
               "remarkReactComponents" (util/map-values r/reactify-component whitelist)}))
          (.processSync value {"commonmark" true})
          .-contents)]
    [:div.markdown {:class (:class props)} children]))

Test markdown
# Test
!span[Hello World]{style="color: red;"}

div1:
::: Hello World :::
{style="color: yellow; font-size: 3em; "}

By the way, thank you for this plugin, very flexible and powerful, exactly what I was looking for, nice work!

I now see that the "div" custom component isn't even needed, you can just do this and the right stuff happens:
div:
::: Hello World :::
{style="color: yellow; font-size: 3em; "}


Add unit tests to model instance resource type

This resource type has no unit test currently.

Same as issue #571

Closing this one as it is a duplicate of #571


Add in support for edge driver

Currently there is no support for edge driver, it should be added in.

@rultor release, tag is 1.0.11

@rultor release, tag is 1.0.11

@ardesco OK, I will release it now. Please check the progress here

@rultor release, tag is 1.0.11

@ardesco Done! FYI, the full log is here (took me 4min)


pc/storage/kdtree: delete node

This PR adds method to remove node from the tree given a target point. (https://github.com/seqsense/pcgol/pull/20 opened again after some mistake in the commit history).

@at-wat PTAL when you have some time.

LGTM Thanks for taking time to revise

Thanks for the detailed review.


Set correct encoding for stdout

Correct encoding of stdout, so that it doesn't contain a string of gibberish.

I think encoding: binary is deprecated. Why isn't this encoding: utf8?
maxBuffer increase to 5MB looks fine.

Yes, it seems that binary encoding will be removed from Node.
Unfortunately, utf8 does not work, as it just treats stdout as text. utf8 is the default encoding for child_process.execFile.
A Buffer, however, does work.

I bumped the major version and then released.


Step Up/Down Dimming 3.005/3.007, 4 bit

Hi Nico,
Is there a way to send a 4bit telegram? For StepUp/Down dimming needs this but I can't see how..

... or am I missing something (again!)??
Pressing the KNX switch to dimUp/Down the lamp the monitor shows:
LPDU: BC 11 84 10 0E E1 00 89 A0 :L_Data low from 1.1.132 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 09
LPDU: BC 11 85 10 0E E1 00 88 A0 :L_Data low from 1.1.133 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 08

Writing 07, 08 or 09 values using writeBit() I get this:
LPDU: BC 11 C8 10 0E E1 00 81 E4 :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 01
LPDU: BC 11 C8 10 0E E1 00 81 E4 :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 01

Using write1ByteInt() the monitor shows:
LPDU: BC 11 C8 10 0E E2 00 80 09 EF :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 09
LPDU: BC 11 C8 10 0E E2 00 80 08 EE :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 08

I added this function:
void ESPKNXIP::send4Bit(address_t const &receiver, knx_command_type_t ct, uint8_t nible)
{
  uint8_t buf[] = {(uint8_t)nible};
  send(receiver, ct, 1, buf);
}

and now I can send telegrams with the right payload. The KNXD monitor shows:
LPDU: BC 11 C8 10 0E E1 00 87 E2 :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 07
LPDU: BC 11 C8 10 0E E1 00 88 ED :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 08
LPDU: BC 11 C8 10 0E E1 00 89 EC :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 09
LPDU: BC 11 C8 10 0E E1 00 88 ED :L_Data low from 1.1.200 to 2/0/14 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 08

Which is what it should be. Only a check for the values 0x00 to 0x0F should be added to the function (I think)...
If you approve, will you please add this function to this already great library?

Hi,
I probably forgot to add this, I will when I get home in a few hours.
Can you send me a link to the documentation you are using? I have the official spec at home but I doesn't look like what you showed.
Cheers, Nico

http://knx.com.ua/attachments/article/132/KNX-basic_course_full.pdf
Willem
gsm: 0653 - 499 551
www: http://willem.aandewiel.nl/

Thank God I'm Atheist
Verstuurd vanaf mijn iPad

Op 28 nov. 2017 om 14:36 heeft Nico Weichbrodt<EMAIL_ADDRESS>het volgende geschreven:
Hi,
I probably forgot to add this, I will when I get home in a few hours.
Can you send me a link to the documentation you are using? I have the official spec at home but I doesn't look like what you showed.
Cheers, Nico
—
You are receiving this because you authored the thread.
Reply to this email directly, view it on GitHub, or mute the thread.

Done. I also added a version for 2 bits, as the spec also specifies this.

Hi Nico,
This is great!
And lighting fast!
Regards,
Willem