This week AT&T will release detailed specs to the Open Compute Project for building white box cell site gateway routers for 5G. Over the next few years, more than 60,000 white box routers built by a variety of manufacturers will be deployed as 5G routers in AT&T’s network.

In its Oct. 1 announcement, AT&T said it will load the routers with its Debian Linux based Vyatta Network Operating System (NOS) stack. Vyatta NOS forms the basis for AT&T’s open source dNOS platform, which in turn is the basis for a new Linux Foundation open source NOS project called DANOS, which similarly stands for Disaggregated Network Operating System (see below).

AT&T’s white box blueprint “decouples hardware from software” so any organization can build its own compliant systems running other software. This will provide the cellular gateway industry with flexibility as well as the security of building on an interoperable, long-lifecycle platform. The white box spec appears to OS agnostic. However, routers typically run Linux-based NOS stacks, and that does not appear to be changing with 5G.

The release of specs to the Open Compute Project — an organization that helps standardize open white box designs — departs from the traditional practice of contracting a few vendors to build proprietary solutions for cellular routers. AT&T’s next-gen router blueprint will enable any hardware manufacturer willing to build to spec to compete for the orders. By attracting more manufacturers, AT&T aims to reduce costs, spur innovation, and more quickly meet the “surging data demands” for 5G.

“We now carry more than 222 petabytes of data on an average business day,” stated Chris Rice, SVP, Network Cloud and Infrastructure at AT&T. “The old hardware model simply can’t keep up, and we need to get faster and more efficient.”

The reference design blueprint is said to be flexible enough to enable manufacturers to offer custom platforms for different use cases. In addition to offering faster mobile services, AT&T’s 5G services will enable new applications in “autonomous cars, drones, augmented reality and virtual reality systems, smart factories, and more,” says AT&T.

5G technology will not only provide a major boost in bandwidth for mobile customers, it should also enable wireless services to better compete with the cable providers’ wired broadband Internet services for the home. This week, AT&T rival Verizon opened pre-orders for consumer customers to sign up for 5G home internet service targeted for a launch in 2019.

At publication time, neither AT&T or the Open Compute Project had not yet published the white box specs, but AT&T offered a few details:

• Supports a wide range of client-side speeds including “100M/1G needed for legacy Baseband Unit systems and next generation 5G Baseband Unit systems operating at 10G/25G and backhaul speeds up to 100G”

• Supports industrial temperature ranges (-40 to 65°C)

• Integrates the Broadcom Qumran-AX switching chip with deep buffers to support advanced features and QOS

• Integrates a baseboard management controller (BMC) for platform health status monitoring and recovery

• Include a “powerful CPU for network operating software”

• Provides timing circuitry that supports a variety of I/O</ul>

Vyatta NOS to dNOS to DANOS

Vyatta launched the Debian based, OpenVPN compliant Vyatta Community Edition over a decade ago. The distribution, which later added features like Quagga support and a standardized management console, was available in both subscription-based and open source Vyatta Core versions.

When Brocade acquired Vyatta in 2012, it discontinued the open source version. However, independent developers forked Vyatta Core to create an open source VyOS platform. Last year, Brocade sold its proprietary Vyatta assets to AT&T, which developed it as Vyatta NOS.

AT&T will initially load the proprietary, “production-hardened” Vyatta NOS on the white box routers it purchases. However, the goal appears to be to eventually replace this with AT&T’s dNOS stack under the emerging DANOS framework.

Robert Bays, assistant VP of Vyatta Development at AT&T Labs, stated: “Consistent with our previous announcements to create the DANOS open source project, hosted by the Linux Foundation, we are now sorting out which components of the open cell site gateway router NOS we will be contributing to open source.”

dNOS/DANOS aims to be the world’s first open source, carrier-grade operating system for wide area networks. The software is designed to interoperate with the widely endorsed ONAP (Open Network Automation Platform), a Linux Foundation project for standardizing open source cloud networking software. In AT&T’s dNOS announcement in January, which preceded the DANOS project launch in March, the company stated: “Just as the ONAP platform has become the open network operating system for the network cloud, the dNOS project aims to be the open operating system for white box.”

The DANOS project is also aligned with Linux Foundation projects like FRRouting, OpenSwitch, and the AT&T-derived Akraino Edge Stack. The Akraino project aims to standardize open source edge computing software for basestations and will also support telecom, enterprise networking, and IoT edge platforms.

Different Akraino blueprints will target technologies and standards such as DANOS, Ceph, Kata Containers, Kubernetes, StarlingX, OpenStack, Acumos AI, and EdgeX Foundry. In a few years, we will likely see DANOS-based white box gateway routers running Akraino software to enable 5G applications ranging from autonomous car communications to augmented reality.

Join us at Open Source Summit + Embedded Linux Conference Europe in Edinburgh, UK on October 22-24, 2018, for 100+ sessions on Linux, Cloud, Containers, AI, Community, and more.

You may have already seen the article here in the Magazine about upscaling bitmap images with better quality. That article covered a few utilities to achieve good results, but there’s always room for enhancement. Meet Waifu2x, a sophisticated tool that uses deep convolutional neural networks, or machine learning for short. Therefore it benefits from trained model data sets. Read on to see how well it performs to upscale your images, and how to get the same benefits even without an Nvidia card.

Here are some examples. First, a character that will be familiar to Fedora fans:

Making the Beefy Miracle hot dog four times larger keeps it nearly perfect!

Here’s another example:

Upscaling a drawing from an old book delivers really outstanding results.

Because Waifu2x performs the calculations using Nvidia CUDA computing platform, it requires an Nvidia graphics card. This article, however, covers a more portable version called Waifu2x-converter-cpp that runs everywhere.

Waifu2x-converter-cpp doesn’t require a dedicated Nvidia GPU. Instead, it leverages the OpenCV and OpenCL libraries. Although the overall performance is slower compared to the original code, it’s portable and more people are able to use it. And of course it runs on Fedora!

Follow the directions below to give it a spin.

Installing Waifu2x-converter-cpp in Fedora

To build the application from source, first install build dependencies:

sudo dnf install -y gcc-c++ cmake opencv-devel opencl-utils-devel

Then grab the source code, build it and install the files:

git clone https://github.com/DeadSix27/waifu2x-converter-cpp.git cd waifu2x-converter-cpp/build cmake -DLIB_SUFFIX=64 ../ make sudo make install

Tell the dynamic library linker to index the directory with locally installed libraries:

sudo ldconfig /usr/local/lib64

Now everything is ready for upscaling. The example command for processing an image is as follows:

waifu2x-converter-cpp --scale_ratio 2 -i /path/to/input_file -o /path/to/output_file

Don’t miss this very helpful command for extras, such as switching OpenCL on/off, playing with noise level, and so on:

waifu2x-converter-cpp --help

Using a graphical front-end for Waifu2x

Another step forward is to install Qtwaifu2x, a graphical tool that lets you escape Fedora terminal and process images with comfort and convenience.

Practically all you have to do is hit Browse and Start to launch the upscaling task.

Installing Qtwaifu2x in Fedora

First, install the main build dependency:

sudo dnf install -y qt5-qtbase-devel

Then get the code and build it:

git clone https://github.com/cmdrkotori/qtwaifu2x.git cd qtwaifu2x qmake-qt5 && make

To run the application from the current directory:

./qtwaifu2x

The main window has quite a few options, but it’s usually enough to provide the input file and hit the Start button.

Brew yourself a cup of tea and come back in a while to enjoy the perfectly upscaled image!

I must admit that a game based on the stock market doesn’t really float my shares. In fact, it sounds drier than a scrunched-up ball of The Financial Times tumbling through Death Valley. However, the original board game was very well received, so a digital version by those experienced guys at Digidiced is certainly something worth further investigation.

In Stockpile players are striving to become the richest stockbroker by dealing shares and manipulating the market to their advantage. Each round players will bid for stocks and action cards, sell shares and adjust the markets. In a standard game, players begin with a starting capital of $20,000 and a single share in one of the six different companies that make up the stock exchange. At the beginning of every round, some public information about one of the six companies will be revealed. In addition, each player receives some secret insider information. Both sets of information will show which of the companies will increase or decrease in stock value and announce any dividend payments.

Next up, each player is dealt two market cards. There are various card types that offer additional shares, trading fees or adjustments to stock value. Players take it in turns to place these cards into piles on the board, preparing them for auction. The only restrictions are that there can only be as many piles as there are players and that one action card must be placed face up and the other face down. Each stack has a bidding ladder that is marked out with values from 0 to 25 and players take it in turns to place or increase their bids. The auction finishes as soon as all players have bid on different stacks. They now claim the stack that they have bid on; paying the cost that may include additional trading fee cards that are often hidden in the stack by your crafty opponents. In the final stage of the round, players have the option to sell any of their shares for the current market value. The insider information that players received at the start of the round is now revealed and the markets are adjusted accordingly.

In the basic game, each of the six companies has the same standard track to record their value. Hit the bottom of the track and the company goes bankrupt, rendering all shares worthless. Reach the top of the track and the shares split, adding even more to their value. The advanced game introduces a more volatile trading environment by having tracks of different lengths. This means that some companies will have longer tracks leading to more stable values, whilst others have short tracks with the potential for wild swings from big profits to bankruptcy. There are also four different expansion modules that can be added to the game. The forecast dice make the market more unpredictable, whilst bonds offer a safe investment but tie up your money until the end of the game. Adding commodity trading and taxes to the stockpiles brings even more tension, whilst the investor cards give each player extra cash or a unique ability which they can use throughout the game.

At the time of writing there does appear to be a nasty intermittent bug that makes selecting and selling shares unresponsive. It’s a pretty major fault that should have been spotted before release, but I’m sure that we can rely on Digidiced to resolve this issue quickly. Other than that, the developers have done a decent job, but, as you can no doubt tell from the screenshots, the game does look rather boring. To be fair, there is little room for graphical flair when the whole game is basically just a spreadsheet. The music is also instantly forgettable and destined to be turned off at the first opportunity. Stockpile isn’t that difficult to grasp, and the tutorials teach the game in a clear humorous way. The screen layout is generally clear and comprehensive. However, it is a bit annoying that in the auction phase the stockpiles of cards are superimposed over the market table. This means that you have to keep switching screens. At the highest difficulty level the AI opponents provide a decent challenge but the game cries out for human interaction.  That leaves us with pass and play or online matches, both work well, although the secret information does mean that extra care needs to be taken when your opponents are sitting next to you.

Despite my reservations, I found Stockpile to be an interesting and cleverly designed game. The auction works really well; adding cards to the various stacks makes for some interesting choices and leads to a range of sneaky manoeuvrings. Since players only have one active bid at any one time, the auction can end abruptly, which leads to some delightfully tension filled wrangling. The cunning mix of public and private information promotes player interaction, with bluff and double bluff being essential tools of the trade. Things can get very ruthless, as players gang up to bring down successful companies, wiping out the value of their shares and leaving you cursing and regretting that you didn’t sell when you had the chance. At the end of the game you will earn a bonus for each company that you are the majority shareholder in, so sometimes it can be prudent to hang on to those shares rather than cashing them in. There is some nice variety with standard and advanced games and the expansion modules, all being provided in the package at no extra cost.

Unfortunately, Stockpile does such a great job of promoting player interaction that the digital version ends up falling somewhat short. The bluffing needs that eye to eye contact, the insider information demands smug and knowing smiles. What you are left with is a rather dry and mathematical game that although initially interesting, ends up feeling like it is missing an essential element.

How about using a similar method to create an index of files below a start directory to perform quick queries such as: “Which files have recently been modified?” “Which are the biggest wasters of space?” Or “Which file names match the following pattern?”

Unix filesystems store metadata in inodes, which reside in flattened structures on disk that cause database-style queries to run at a snail’s pace. To take a look at a file’s metadata, run the statcommand on it and take a look at the file size and timestamps, such as the time of the last modification (Figure 2).

Figure 2: Inode metadata of a file, here determined by stat, can be used to build an index.

Newer filesystems like ZFS or Btrfs take a more database-like approach in the way they organize the files they contain but do not go far enough to be able to support meaningful queries from userspace.

Fast Forward Instead of Pause

For example, if you want to find all files over 100MB on the disk, you can do this with a find call like:

find / -type f -size +100M

If you are running the search on a traditional hard disk, take a coffee break. Even on a fast SSD, you need to prepare yourself for long search times in the minute range. The reason for this is that the data is scattered in a query-unfriendly way across the sectors of the disk.

Read more at Linux Pro Magazine

Blazor 0.6.0 is now available! This release includes new features for authoring templated components and enables using server-side Blazor with the Azure SignalR Service. We’re also excited to announce our plans to ship the server-side Blazor model as Razor Components in .NET Core 3.0!

Here’s what’s new in the Blazor 0.6.0 release:

• Templated components
  
  • Define components with one or more template parameters
  • Specify template arguments using child elements
  • Generic typed components with type inference
  • Razor templates
• Refactored server-side Blazor startup code to support the Azure SignalR Service

A full list of the changes in this release can be found in the Blazor 0.6.0 release notes.

Get Blazor 0.6.0

Install the following:

1. .NET Core 2.1 SDK (2.1.402 or later).
2. Visual Studio 2017 (15.8 or later) with the ASP.NET and web development workload selected.
3. The latest Blazor Language Services extension from the Visual Studio Marketplace.

4. The Blazor templates on the command-line:

   dotnet new -i Microsoft.AspNetCore.Blazor.Templates
   
   
   

You can find getting started instructions, docs, and tutorials for Blazor at https://blazor.net.

Upgrade an existing project to Blazor 0.6.0

To upgrade a Blazor 0.5.x project to 0.6.0:

• Install the prerequisites listed above.

• Update the Blazor package and .NET CLI tool references to 0.6.0. The upgraded Blazor project file should look like this:

  <Project Sdk="Microsoft.NET.Sdk.Web">
  
  
  
  
  
  <PropertyGroup>
   <TargetFramework>netstandard2.0</TargetFramework>
   <RunCommand>dotnet</RunCommand>
   <RunArguments>blazor serve</RunArguments>
   <LangVersion>7.3</LangVersion>
  
  
  </PropertyGroup>
  
  
  
  
  
  <ItemGroup>
   <PackageReference Include="Microsoft.AspNetCore.Blazor.Browser" Version="0.6.0" />
   <PackageReference Include="Microsoft.AspNetCore.Blazor.Build" Version="0.6.0" />
   <DotNetCliToolReference Include="Microsoft.AspNetCore.Blazor.Cli" Version="0.6.0" />
  
  
  </ItemGroup>
  
  
  
  
  
  </Project>
  
  
  

That’s it! You’re now ready to try out the latest Blazor features.

Templated components

Blazor 0.6.0 adds support for templated components. Templated components are components that accept one or more UI templates as parameters, which can then be used as part of the component’s rendering logic. Templated components allow you to author higher-level components that are more reusable than what was possible before. For example, a list view component could allow the user to specify a template for rending items in the list, or a grid component could allow the user to specify templates for the grid header and for each row.

Template parameters

A templated component is defined by specifying one or more component parameters of type RenderFragment or RenderFragment<T>. A render fragment represents a segment of UI that is rendered by the component. A render fragment optionally take a parameter that can be specified when the render fragment is invoked.

TemplatedTable.cshtml

@typeparam TItem





<table>
 <thead>
 <tr>@TableHeader</tr>
 </thead>
 <tbody>
 @foreach (var item in Items)
 {
 @RowTemplate(item)
 }
 </tbody>
 <tfoot>
 <tr>@TableFooter</tr>
 </tfoot>


</table>





@functions {
 [Parameter] RenderFragment TableHeader { get; set; }
 [Parameter] RenderFragment<TItem> RowTemplate { get; set; }
 [Parameter] RenderFragment TableFooter { get; set; }
 [Parameter] IReadOnlyList<TItem> Items { get; set; }


}

When using a templated component, the template parameters can be specified using child elements that match the names of the parameters.

<TemplatedTable Items="@pets">
 <TableHeader>
 <th>ID</th>
 <th>Name</th>
 <th>Species</th>
 </TableHeader>
 <RowTemplate>
 <td>@context.PetId</td>
 <td>@context.Name</td>
 <td>@context.Species</td>
 </RowTemplate>


</TemplatedTable>

Template context parameters

Component arguments of type RenderFragment<T> passed as elements have an implicit parameter named context, but you can change the parameter name using the Context attribute on the child element.

<TemplatedTable Items="@pets">
 <TableHeader>
 <th>ID</th>
 <th>Name</th>
 <th>Species</th>
 </TableHeader>
 <RowTemplate Context="pet">
 <td>@pet.PetId</td>
 <td>@pet.Name</td>
 <td>@pet.Species</td>
 </RowTemplate>


</TemplatedTable>

Alternatively, you can specify the Context attribute on the component element (e.g., <TemplatedTable Context="pet">). The specified Context attribute applies to all specified template parameters. This can be useful when you want to specify the content parameter name for implicit child content (without any wrapping child element).

Generic-typed components

Templated components are often generically typed. For example, a generic ListView component could be used to render IEnumerable<T> values. To define a generic component use the new @typeparam directive to specify type parameters.

GenericComponent.cshtml

@typeparam TItem





@foreach (var item in Items)


{
 @ItemTemplate(item)


}





@functions {
 [Parameter] RenderFragment<TItem> ItemTemplate { get; set; }
 [Parameter] IReadOnlyList<TItem> Items { get; set; }


}

When using generic-typed components the type parameter will be inferred if possible. Otherwise, it must be explicitly specified using an attribute that matches the name of the type parameter:

<GenericComponent Items="@pets" TItem="Pet">
 ...


</GenericComponent>

Razor templates

Render fragments can be defined using Razor template syntax. Razor templates are a way to define a UI snippet. They look like the following:

@<tag>...<tag>

You can now use Razor templates to define RenderFragment and RenderFragment<T> values like this:

@{ 
 RenderFragment template = @<p>The time is @DateTime.Now.</p>;
 RenderFragment<Pet> petTemplate = (pet) => @<p>Your pet's name is @pet.Name.</p>


}

Render fragments defined using Razor templates can be passed as arguments to templated components or rendered directly. For example, you can render the previous templates directly like this:

@template





@petTemplate(new Pet { Name = "Fido" })

Use server-side Blazor with the Azure SignalR Service

In the previous Blazor release we added support for running Blazor on the server where UI interactions and DOM updates are handled over a SignalR connection. In this release we refactored the server-side Blazor support to enable using server-side Blazor with the Azure SignalR Service. The Azure SignalR Service handles connection scale out for SignalR based apps, scaling up to handle thousands of persistent connections so that you don’t have to.

To use the Azure SignalR Service with a server-side Blazor application:

1. Create a new server-side Blazor app.

   dotnet new blazorserverside -o BlazorServerSideApp1
   
   
   

2. Add the Azure SignalR Server SDK to the server project.

   dotnet add BlazorServerSideApp1/BlazorServerSideApp1.Server package Microsoft.Azure.SignalR
   
   
   

3. Create an Azure SignalR Service resource for your app and copy the primary connection string.

4. Add a UserSecretsId property to the BlazorServerSideApp1.Server.csproj project file.

   <PropertyGroup>
    <UserSecretsId>BlazorServerSideApp1.Server.UserSecretsId</UserSecretsId>
   
   
   <PropertyGroup>
   
   
   

5. Configure the connection string as a user secret for your app.

   dotnet user-secret -p BlazorServerSideApp1/BlazorServerSideApp1.Server set Azure:SignalR:ConnectionString <Your-Connection-String>
   
   
   

   NOTE: When deploying the app you’ll need to configure the Azure SignalR Service connection string in the target environment. For example, in Azure App Service configure the connection string using an app setting.

6. In the Startup class for the server project, replace the call to app.UseServerSideBlazor<App.Startup>() with the following code:

   app.UseAzureSignalR(route => route.MapHub<BlazorHub>(BlazorHub.DefaultPath));
   
   
   app.UseBlazor<App.Startup>();
   
   
   

7. Run the app.

   If you look at the network trace for the app in the browser dev tools you see that the SignalR traffic is now being routed through the Azure SignalR Service. Congratulations!

Razor Components to ship with ASP.NET Core in .NET Core 3.0

We announced last month at .NET Conf that we’ve decided to move forward with shipping the Blazor server-side model as part of ASP.NET Core in .NET Core 3.0. About half of Blazor users have indicated they would use the Blazor server-side model, and shipping it in .NET Core 3.0 will make it available for production use. As part of integrating the Blazor component model into the ASP.NET Core we’ve decided to give it a new name to differentiate it from the ability to run .NET in the browser: Razor Components. We are now working towards shipping Razor Components and the editing in .NET Core 3.0. This includes integrating Razor Components into ASP.NET Core so that it can be used from MVC. We expect to have a preview of this support early next year after the ASP.NET Core 2.2 release has wrapped up.

Our primary goal remains to ship support for running Blazor client-side in the browser. Work on running Blazor client-side on WebAssembly will continue in parallel with the Razor Components work, although it will remain experimental for a while longer while we work through the issues of running .NET on WebAssembly. We will however keep the component model the same regardless of whether you are running on the server or the client. You can switch your Blazor app to run on the client or the server by changing a single line of code. See the Blazor .NET Conf talk to see this in action and to learn more about our plans for Razor Components:

Give feedback

We hope you enjoy this latest preview release of Blazor. As with previous releases, your feedback is important to us. If you run into issues or have questions while trying out Blazor, file issues on GitHub. You can also chat with us and the Blazor community on Gitter if you get stuck or to share how Blazor is working for you. After you’ve tried out Blazor for a while please let us know what you think by taking our in-product survey. Click the survey link shown on the app home page when running one of the Blazor project templates:

Thanks for trying out Blazor!

There’s a rumor among explorers
About a monolithic lair
Home to terrifying horrors
Heroes, how will you prepare? pic.twitter.com/XK7W7e0SKA

— Overwatch (@OverwatchEU) October 1, 2018

Click Here!