grep a block of lines into a shell variable based on matching pattern

I'm not sure you can accomplish what you want using grep by itself, but you can use the sed and grep commands together to get your desired output.

sed -n '/dev {/,/}/p' src_file

will give you the following output:

location /dev {
  proxy_set_header X-Forwarded-Host $host;
  proxy_set_header X-Forwarded-Server $host;
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  proxy_set_header Host $http_host;
  proxy_read_timeout 5m;
  proxy_send_timeout 5m;
  proxy_pass http://xyz.9202.com;

           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection "upgrade";
  }

And if you want to remove the dev { and } lines, you can combine the sed command with grep -v like this:

sed -n '/dev {/,/}/p' src_file | grep -v "}" | grep -v "{"

which will give you the output that you desire:

proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_read_timeout 5m;
proxy_send_timeout 5m;
proxy_pass http://xyz.9202.com;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection "upgrade";

Trying to parse block-based files with line-based tools is a dicey proposition with no guarantees. Most solutions will fail if there's another {...} block nested within the outer location block (by stopping after the first } instead of the matching one). That may not be an issue with your particular file, but this solution would handle it correctly:

awk '(inside && /{/)  { inside++ };
     (inside && /}/)  { --inside; if (!inside) { exit } };
     (inside) {print};
     /location \/dev[ \/{]/ { inside=1; }' src_file

There are still plenty of ways to break this, though. An actual parser library designed for (or configurable for) the syntax in question will give you more reliable results if this is going to be more than a one-off job.

Explanation: the design of this program uses a state variable called inside that, if nonzero, means the current line being processed is inside the stanza. Every new open-brace { causes the value to increase, while every close-brace } causes it to decrease. So once it hits zero after having been nonzero, we know we're done with the target stanza and can exit.

The stanzas are processed in order, so that order is very important. The very last stanza looks for the starting location line and sets our state variable to 1; if that stanza were first, then the starting location line would itself be printed by the subsequent stanzas. But as it is, the printing doesn't take effect until the next line of the file.

So: if we are inside the stanza and see another {, increment inside. if we are inside the stanza and see a }, decrement inside. If it's now zero, that means we're done, so exit. If we are inside (whether or not we just saw a { or }, as long as we didn't exit), then print the current line. If we see location /dev ... followed by either a space, a slash, or a curly brace, so a different location that just starts with /dev won't match ... set inside to 1 indicating we should start printing with the next line.

Note that as written, the program assumes that the opening { for the whole stanza is on the same line as the location directive itself. If the the brace is on the next line instead, the nesting logic will mean it will print the whole file from that point. That's just an example of the fragility of this sort of approach.

This might work for you (GNU sed):

sed -n '/^\s*location .*{$/h;/^\s*$\|[{}]/b;G;/location \/dev/P' file

Make a copy of every line beginning location and ending with a {. Append the current copy to each line and if the double line contains location /dev print only the first of them.

N.B. Empty lines and lines containing { and } can be deleted beforehand.