Best match

Most recent

Out of Office: why month-long holidays are the key to Swedish unicorn ...

Future of Cities Debate: building world class urban innovation centres for the future

businessleader

Get the most recent info and news about Incuto on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Incuto

Once, I had a requirement to implement server-side logging for GRPC requests. GRPC has an interceptor mechanism that can be used for logging, GRPC request verification, authentication, etc. To intercept requests on the server side, it is necessary to implement ServerInterceptor. And inherit two abstract classes, ServerCall and ServerCall.Listener. First, let’s make our implementation of ServerCall.Listener. There is ForwardingServerCallListener that gives calls to the next listener in the chain. We will extend this class and override the method onMessage. We will use the ConcurrentLinkedQueue for storing received requests. This method might be invoked more than one time if using client-side streaming. Also, there are the onComplete and onCancel methods that will be invoked after completing the GRPC request or after the client’s cancelation. Our implementation uses the queue for storing sent requests. class LoggingServerCallListener<ReqT>(
    private val delegate: ServerCall.Listener<ReqT>,
    private val input: ConcurrentLinkedQueue<ReqT>
) : ForwardingServerCallListener<ReqT>() {

    override fun delegate(): ServerCall.Listener<ReqT> {
        return delegate
    }

    override fun onMessage(message: ReqT) {
        super.onMessage(message)
        input.offer(message)
    }
} Next, we need to implement the ServerCall class. There is the implementation SimpleForwardingServerCall that works as ForwardingServerCallListener for ServerCall.Listener. We will use the same instance of ConcurrentLinkedQueue for getting received requests. Also, we will use another instance of the queue for storing sent responses. We will implement the sendMessage method that invokes before a response is sent to a client. This method can be invoked more than once if the result is server-side streaming. We will also override the close method, which will be called after all data has been sent to the client or an error occurs. The method ensures that there will be no further calls to onMessage or sendMessage. import com.google.protobuf.GeneratedMessageV3
import com.google.protobuf.util.JsonFormat
import io.grpc.ForwardingServerCall.SimpleForwardingServerCall
import io.grpc.Metadata
import io.grpc.ServerCall
import io.grpc.Status
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentLinkedQueue

class LoggingServerCall<RequestType, ResponseType>(
    delegate: ServerCall<RequestType, ResponseType>,
    private val metadata: Metadata,
    private val input: ConcurrentLinkedQueue<RequestType>,
    private val output: ConcurrentLinkedQueue<ResponseType>
) : SimpleForwardingServerCall<RequestType, ResponseType>(delegate) {

    override fun sendMessage(message: ResponseType) {
        output.offer(message)
        super.sendMessage(message)
    }

    override fun close(status: Status, trailers: Metadata) {
        if (status.isOk) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)

            val printer = JsonFormat.printer()

            val request = input
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            val response = output
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            logger.info("The request with id: $requestId and request data $request returns $response")

        } else if (listOf(Status.INTERNAL.code, Status.NOT_FOUND.code, Status.INVALID_ARGUMENT.code).contains(status.code)) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)
            logger.error("An error occurred while processing the request with request-id $requestId", status.asRuntimeException())
        }

        super.close(status, trailers)
    }

    companion object {
        private val logger = LoggerFactory.getLogger(LoggingServerCall::class.java)
        private val REQUEST_ID_METADATA_KEY = Metadata.Key.of("x-request-id", Metadata.ASCII_STRING_MARSHALLER)
    }
} Our implementation is very simple. We use JsonFormater for converting protobuf to JSON and joining to the string. Also, we take a request ID from the metadata for emulating real logging situations. Then we log the message into the system out. If an error occurs, we will log it. After that, the onComplete/onCancel methods of the listener will be called. Next, we must implement our ServerInterceptor which uses both our ServerCall and ServerCall.Listener. class LoggingInterceptor : ServerInterceptor {
    override fun <ReqT : Any, RespT : Any?> interceptCall(
        call: ServerCall<ReqT, RespT>,
        headers: Metadata,
        next: ServerCallHandler<ReqT, RespT>
    ): ServerCall.Listener<ReqT> {
        val input = ConcurrentLinkedQueue<ReqT>()
        val output = ConcurrentLinkedQueue<RespT>()
        val loggingServerCall = LoggingServerCall(call, headers, input, output)
        return LoggingServerCallListener(next.startCall(loggingServerCall, headers), input)
    }
} To start the processing request, we must call the startCall method of the ServerCallHandler class. After that, we must register our server interceptor. fun main(args: Array<String>) {
	val server = ServerBuilder
        .forPort(8080)
		.addService(OurGrpcService())
		.intercept(LoggingInterceptor())
		.build()
	
	server.start()
} In the second part, we consider how to work with client interceptors. I hope the article can help you with how to work with the server-side interceptors in GRPC.

How to Implement Server-Side Interceptors for Logging GRPC Requests

Real Time Data Processing: Easily Processing 10 Million Messages With Golang, Kafka and MongoDB

How to Use Next.js to Implement the Backends-for-Frontends Pattern

The world of NFTs is vast and although this type of asset has been in circulation for several years now, the news and developments related to them have not stopped, bringing novelty and innovation in the creation and in providing additional previously unthinkable features. Apparently, this trend that has launched the various blockchains to be more used, thanks to the simplicity of creating NFTs, has led to some blockchains achieving greater success than others, with some remaining behind, such as that of Bitcoin, which, due to its structure and characteristics focused more on security than on speed or cost, is not configured as an optimal blockchain for NFT minting. Despite this, it doesn't mean that we cannot create NFTs on this blockchain, however by paying high fees and obviously also clogging up the related blockchain, creating heavy blocks containing information other than those for which the blockchain was designed. We will go into detail about how to create NFTs on Bitcoin and what the process is for creating both a compatible wallet and the NFTs themselves. NFT with the Ordinals protocol Some of you may know that 1 bitcoin is made up of 100 million units, called satoshis or sat for short, and these satoshis are numbered in order starting from 0. In fact, these numbers are “ordinal numbers”, and because of this, it is possible to exploit them to create NFTs. For those who want to learn more about this protocol, we recommend , instead below there is the algorithm that was created: checking here # subsidy of block at given height
def subsidy(height):
return 50 * 100_000_000 >> height // 210_000
# first ordinal of subsidy of block at given height
def first_ordinal(height):
start = 0
for height in range(height):
start += subsidy(height)
return start
# assign ordinals in given block
def assign_ordinals(block):
first = first_ordinal(block.height)
last = first + subsidy(block.height)
coinbase_ordinals = list(range(first, last))
for transaction in block.transactions[1:]:
ordinals = []
for input in transaction.inputs:
ordinals.extend(input.ordinals)
for output in transaction.outputs:
output.ordinals = ordinals[:output.value]
of ordinals[:output.value]
coinbase_ordinals.extend(ordinals)
for output in block.transaction[0].outputs:
output.ordinals = coinbase_ordinals[:output.value]
from coinbase_ordinals[:output.value] How to create a Bitcoin address for NFTs These NFTs exploit the satoshis and since the satoshis themselves are fungible, if we don't take precautions, we could end up transferring in a transaction even those satoshis to which the NFTs we have created are connected. We need to create a new address and wallet that allows us to have greater control over the movements of the satoshis in our address, and a useful tool for this purpose is certainly . Sparrow Wallet The first step is to download Sparrow wallet and create a new bitcoin address. After installing the wallet, we will have to create a new wallet and to do this we go to File and New Wallet: In the next screen, we will have to set a new address and to do it in the "Address" section we must choose "Taproot (P2TR)": Then we will need to click on the "New or Imported Bitcoin Address" button below to create a new Bitcoin address with those characteristics: At this point we should create the words relating to our address and we opt to use the number of words we prefer, in our case 12 words and press the "Generate New" button: Let's remember to type these words into the next step we will have to insert them and then press the "Create Keystore" button: Now we can import the keystore we created earlier, by clicking on the Import button: Finally, after we have created everything, we will have to press the "Apply" button: How to receive Bitcoin NFTs Using this wallet, we can also receive NFTs and we must remember to always create a new account to receive the different NFTs, and to do so, in the "Receive" menu, we find the button below to create a new address "Get Next Address" and use the address shown to us: To receive Bitcoin NFTs, we should freeze the UTXOs related to the NFTs and do so, we should right-click on the related transaction, then click the "Freeze UTXO" item. This will ensure that we will not send these NFTs by mistake. When we should transfer them, just do the reverse process and click on "Unfreze UTXO". How to mint an NFT on Bitcoin Now that we have all the tools to receive and avoid losing NFTs by mistake, it's time to see how to create our NFTs and do this we have two solutions, either by taking advantage of the related algorithm created and therefore all at the command line, or take advantage of some convenient and practical services. For those more geeks, they can check out the code directly on GitHub , instead for those who want the simplest approach we can take advantage of or , also because the procedure is simple and the steps are similar. here this service this other The first thing you need to do is load the image we want to transform into an NFT: After that, we have to enter our address where our NFT will be sent: At this point, we just have to pay the lee fee and wait for the transaction to arrive at our address, and in this case, we see that we are going to spend just under $13 and wait over 24 hours, while if we want the transaction to be processed in 30 minutes, then we should pay more around $70: How to see Bitcoin NFTs Once we have created the NFT, we can see it through some platforms , and just enter the hash of the transaction relating to the NFT to see all the information relating to it: like this Conclusions Bitcoin-based tokens are possible even if they are a little complicated and require a higher investment than on other platforms. Additionally, the cost of creating them is not as cheap as on other platforms. Finally I conclude with a video of the process: https://youtu.be/4losgVDBxIE?embedable=true

Creating NFTs on the Bitcoin Network

Doubtful Points and Criticism

Difficulties and Preliminary Approach

When I decided to build an open-source earlier this year and to build it in C# I needed a template for building the transport layer of the server. I was particularly happy when I checked out the TechEmpower benchmarks in which ASP.NET Kestrel currently ranks 3rd in plaintext benchmark scores with 7,023,107 responses per second. In this post, I will demonstrate how a high-performance TCP server can be built and I will do so by borrowing some ideas from Kestrel. Telegram Server The code presented leverages low allocation asynchronous programming patterns and pooling to be blazing fast. Socket operations in .NET are described by which is a reusable object that provides a callback-based asynchronous pattern. First this pattern needs to be wrapped with an async one by implementing the interface so that allocations for the asynchronous path can be avoided. SocketAsyncEventArgs IValueTaskSource AwaitableEventArgs.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketAwaitableEventArgs.cs#L10-L77
public class AwaitableEventArgs : SocketAsyncEventArgs, IValueTaskSource<int>
{
    private ManualResetValueTaskSourceCore<int> _source;

    public AwaitableEventArgs() :
        base(unsafeSuppressExecutionContextFlow: true)
    {
    }

    protected override void OnCompleted(SocketAsyncEventArgs args)
    {
        if (SocketError != SocketError.Success)
        {
            _source.SetException(new SocketException((int)SocketError));
        }

        _source.SetResult(BytesTransferred);
    }

    public int GetResult(short token)
    {
        int result = _source.GetResult(token);
        _source.Reset();
        return result;
    }

    public ValueTaskSourceStatus GetStatus(short token)
    {
        return _source.GetStatus(token);
    }

    public void OnCompleted(Action<object?> continuation, object? state, short token,
        ValueTaskSourceOnCompletedFlags flags)
    {
        _source.OnCompleted(continuation, state, token, flags);
    }
} This is rewritten from the original implementation and the main difference is this version uses for the sake of simplicity while the original one uses a thinner custom implementation of the interface. here ManualResetValueTaskSourceCore IValueTaskSource Needed and implementations are derived from the above. They first set the buffer for the and then call the respective or method of the which returns true if the I/O operation is pending in which case can be the for the returned as the base class implements the interface. When is fired, awaited will either return the bytes received/sent or throw an . However if the above call returns false it means the I/O operation completed synchronously and synchronous path needs to be handled. Receiver Sender AwaitableEventArgs SocketAsyncEventArgs SendAsync ReceiveAsync Socket Receiver/Sender source ValueTask OnCompleted(SocketAsyncEventArgs args) ValueTask Exception Receiver.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketReceiver.cs
public class Receiver : AwaitableEventArgs
{
   private short _token;
   public ValueTask<int> ReceiveAsync(Socket socket, Memory<byte> memory)
   {
      SetBuffer(memory);
      if (socket.ReceiveAsync(this))
      {
         return new ValueTask<int>(this, _token++);
      }

      var transferred = BytesTransferred;
      var err = SocketError;
      return err == SocketError.Success
         ? new ValueTask<int>(transferred)
         : ValueTask.FromException<int>(new SocketException((int)err));
   }
} also needs to handle the buffer being a as it will be the case. Sender ReadOnlySequence<byte> Sender.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketSender.cs
public class Sender: AwaitableEventArgs
{
    private short _token;
    private List<ArraySegment<byte>>? _buffers;
    public ValueTask<int> SendAsync(Socket socket, in ReadOnlyMemory<byte> data)
    {
        SetBuffer(MemoryMarshal.AsMemory(data));
        if (socket.SendAsync(this))
        {
            return new ValueTask<int>(this, _token++);
        }

        var transferred = BytesTransferred;
        var err = SocketError;
        return err == SocketError.Success
            ? new ValueTask<int>(transferred)
            : ValueTask.FromException<int>(new SocketException((int)err));
    }
    public ValueTask<int> SendAsync(Socket socket, in ReadOnlySequence<byte> data)
    {
        if (data.IsSingleSegment)
        {
            return SendAsync(socket, data.First);
        }
        _buffers ??= new List<ArraySegment<byte>>();
        foreach (var buff in data)
        {
            if (!MemoryMarshal.TryGetArray(buff, out var array))
            {
                throw new InvalidOperationException("Buffer is not backed by an array.");
            }

            _buffers.Add(array);
        }

        BufferList = _buffers;

        if (socket.SendAsync(this))
        {
            return new ValueTask<int>(this, _token++);
        }

        var transferred = BytesTransferred;
        var err = SocketError;
        return err == SocketError.Success
            ? new ValueTask<int>(transferred)
            : ValueTask.FromException<int>(new SocketException((int)err));
    }
    public void Reset()
    {
        if (BufferList != null)
        {
            BufferList = null;

            _buffers?.Clear();
        }
        else
        {
            SetBuffer(null, 0, 0);
        }
    }
} A lightweight implementation is also needed. This is backed by a and leverages for keeping a cheaper atomic count. SenderPool ConcurrentQueue Interlocked SenderPool.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketSenderPool.cs
public class SenderPool : IDisposable
{
    private readonly int MaxNumberOfSenders;
    private int _count;
    private readonly ConcurrentQueue<Sender> _senders = new();
    private bool _disposed = false;

    public SenderPool(int maxNumberOfSenders = 128)
    {
        MaxNumberOfSenders = maxNumberOfSenders;
    }

    public Sender Rent()
    {
        if (_senders.TryDequeue(out var sender))
        {
            Interlocked.Decrement(ref _count);
            sender.Reset();
            return sender;
        }

        return new Sender();
    }

    public void Return(Sender sender)
    {
        if (_disposed || _count >= MaxNumberOfSenders)
        {
            sender.Dispose();
        }
        else
        {
            Interlocked.Increment(ref _count);
            _senders.Enqueue(sender);
        }
    }

    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;
        while (_senders.TryDequeue(out var sender))
        {
            sender.Dispose();
        }
    }
} Now this is the part things start to get more fun. Writing a TCP server requires buffering and parsing streaming data which is a complex task and can be tedious and hard to get right the first time around. Luckily is designed exactly for this problem. It reduces code complexity and allows high performance parsing of streaming data. I highly recommend anyone reading this to read the original as well to get a better grasp. Next piece of code will leverage this library. System.IO.Pipelines article Connection.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketConnection.cs
public class Connection : IAsyncDisposable
{
    private const int MinBuffSize = 1024;
    private readonly Socket _socket;
    private readonly Receiver _receiver;
    private Sender? _sender;
    private readonly SenderPool _senderPool;
    private Task? _receiveTask;
    private Task? _sendTask;
    private readonly Pipe _transportPipe;
    private readonly Pipe _applicationPipe;
    private readonly object _shutdownLock = new object();
    private volatile bool _socketDisposed;
    public PipeWriter Output { get;}
    public PipeReader Input { get;}

    public Connection(Socket socket, SenderPool senderPool)
    {
        _socket = socket;
        _receiver = new Receiver();
        _senderPool = senderPool;
        _transportPipe = new Pipe();
        Output = _transportPipe.Writer;
        _applicationPipe = new Pipe();
        Input = _applicationPipe.Reader;
    }

    public void Start()
    {
        try
        {
            _sendTask = SendLoop();
            _receiveTask = ReceiveLoop();
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
    }
    private async Task SendLoop()
    {
        try
        {
            while (true)
            {
                var result = await _transportPipe.Reader.ReadAsync();
                if (result.IsCanceled)
                {
                    break;
                }
                var buff = result.Buffer;
                if (!buff.IsEmpty)
                {
                    _sender = _senderPool.Rent();
                    await _sender.SendAsync(_socket, result.Buffer);
                    _senderPool.Return(_sender);
                    _sender = null;
                }
                _transportPipe.Reader.AdvanceTo(buff.End);
                if (result.IsCompleted)
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
        finally
        {
            _applicationPipe.Writer.Complete();
            Shutdown();
        }
    }
    private async Task ReceiveLoop()
    {
        try
        {
            while (true)
            {
                var buff = _applicationPipe.Writer.GetMemory(MinBuffSize);
                var bytes = await _receiver.ReceiveAsync(_socket, buff);
                if (bytes == 0)
                {
                    break;
                }
                _applicationPipe.Writer.Advance(bytes);
                var result = await _applicationPipe.Writer.FlushAsync();
                if (result.IsCanceled || result.IsCompleted)
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
        finally
        {
            _applicationPipe.Writer.Complete();
            Shutdown();
        }
    }

    public async ValueTask DisposeAsync()
    {
        _transportPipe.Reader.Complete();
        _applicationPipe.Writer.Complete();
        try
        {
            if (_receiveTask != null)
            {
                await _receiveTask;
            }

            if (_sendTask != null)
            {
                await _sendTask;
            }
        }
        finally
        {
            _receiver.Dispose();
            _sender?.Dispose();
        }
    }
    public void Shutdown()
    {
        lock (_shutdownLock)
        {
            if (_socketDisposed)
            {
                return;
            }
            _socketDisposed = true;
            try
            {
                _socket.Shutdown(SocketShutdown.Both);
            }
            finally
            {
                _socket.Dispose();
            }
        }
    }
} The class has: Connection a for the connection Receiver references to the and the Socket SenderPool a for transport and another one for the application Pipe and finally two loops for sending and receiving. So how do we send/receive data? The for the transport pipe is exposed as the public property and the polls for data written to this pipe renting a before every send operation returning it to the pool after completion. The for the application pipe is exposed as the public property and the basically gets a buffer from this pipe and receives into it. Then there is some cleanup code. This again is a simplified version of the original Kestrel implementation. PipeWriter Output SendLoop Sender PipeReader Input ReceiveLoop TCP Echo At this point a TCP Echo server needs just a few more lines of code. Following simply copies back the received bytes: Program.cs var senderPool = new SenderPool(1024);
var listenSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 8989));
listenSocket.Listen(128);
while (true)
{
    var socket = await listenSocket.AcceptAsync();
    var connection = new Connection(socket, senderPool);
    _ = ProcessConnection(connection);
}

static async Task ProcessConnection(Connection connection)
{
    connection.Start();
    while (true)
    {
        var result = await connection.Input.ReadAsync();
        if (result.IsCanceled)
        {
            break;
        }
        var buff = result.Buffer;
        if (!buff.IsEmpty)
        {
            if (buff.IsSingleSegment)
            {
                await connection.Output.WriteAsync(buff.First);
            }
            else
            {
                foreach (var mem in buff)
                {
                    await connection.Output.WriteAsync(mem);
                }
            }
        }
        connection.Input.AdvanceTo(buff.End, buff.End);
        if (result.IsCompleted)
        {
            break;
        }
    }
    connection.Shutdown();
    await connection.DisposeAsync();
} This will serve as a base for a High Performance TCP Server but of course more measurements and optimizations might be necessary. Code above omits some more advanced implementation details for the sake of simplicity. Some of them are outlined below. schedule-me-not When creating a , it’s possible to specify a and ‘s for the reader and the writer via the and Kestrel uses a custom here along with a lock-free . implementation as well supports a as to have fine-grained control where the I/O happens. Following pseudo-code tries to simplify and outline how Kestrel utilizes schedulers. Pipe MemoryPool<byte> PipeScheduler PipeOptions PinnedBlockMemoryPool IOQueue SocketAwaitableEventArgs PipeScheduler var memoryPool = new PinnedBlockMemoryPool();
var applicationScheduler = PipeScheduler.ThreadPool;
var transportScheduler = new IOQueue();
var socketScheduler = transportScheduler;

var receiver = new SocketReceiver(socketScheduler);

var InputOptions = new PipeOptions(memoryPool, 
        applicationScheduler, transportScheduler, 
        maxReadBufferSize, maxReadBufferSize / 2, 
        useSynchronizationContext: false),

var OutputOptions = new PipeOptions(memoryPool, 
        transportScheduler, applicationScheduler, 
        maxWriteBufferSize, maxWriteBufferSize / 2, 
        useSynchronizationContext: false),

var SocketSenderPool = new SocketSenderPool(PipeScheduler.Inline), It can also be seen above and is used for flow control. This is when processing data is more complicated than simply sending it back in which case the reader would allocate more and more memory. When is set however and if the amount of data in the pipe is more than set value will not be completed until it is less than again. PauseWriterThreshold ResumeWriterThreshold PauseWriterThreshold PipeWriter.FlushAsync ResumeWriterThreshold Where to go from here? As I was writing the code for this post some preliminary benchmarks showed that the code presented is actually somewhat slower than a basic Echo Server. Netty would reach 115000 requests per second while code above would reach 110000. It however is a well-established framework, so it shouldn’t be too surprising. This just shows that some proper benchmarks are needed along with profiling and optimization. Netty The full source can be viewed at . the GitHub repo

Building a High Performance TCP Server in C#

REST has long been a popular architectural paradigm for creating , but in recent years has put REST's reign in jeopardy. APIs GraphQL's rise in popularity When it comes to establishing or leveraging API architecture design, the debate between GraphQL and REST is raging, and most firms are split between the two. While REST is generally recognized as the industry standard for creating APIs, GraphQL has been heralded as a new technology capable of overcoming REST's limitations. REST and GraphQL are two data retrieval technologies. The main distinction between GraphQL and RestAPIs is that GraphQL is a query language standard, whereas REST is an architectural idea for network-based computing. We'll walk you through the working process with both options, and you’ll be able to compare which one is more fit for you: GraphQL vs REST. But first, let’s define the terms. GraphQL Explanation GraphQL is a runtime for satisfying queries with existing data, as well as an open-source data query and manipulation language for APIs. GraphQL, which is largely maintained and developed by the GraphQL Foundation, has seen tremendous acceptance across a wide range of verticals and use cases, including companies such as Twitter, Expedia, Shopify, and GraphCMS, to mention a few. By allowing the user to receive just the data they expressly requested, this API architecture design eliminates any performance difficulties caused by extra fetching. Furthermore, many entities can be merged into a single query. GraphQL offers the advantage of tolerating client-side changes without affecting the server, allowing for quick front-end product updates. Developers that utilize GraphQL on the backend obtain a lot of information about any data request and how the available data is being used. You may also be interested in the Graph Database Examples outlook. RestAPI Definition RestAPI today is a much easier technique to enable stateless and type-free machine-to-machine communication using only the ubiquitous HTTP protocol and no other layers. This made it possible for systems to be loosely connected and more tolerant of contract changes between systems, such as between businesses. For firms delivering API architecture design and developing developer platforms, RestAPI has become the de facto norm. The benefit of REST is that it eliminates the need for any specific setup or libraries when interacting with someone else's API. Common tools such as cURL and web browsers can be used to send requests. REST's key advantage is that it is scalable and decouples client and server, enabling developers to work independently on products and applications. It is adaptable to a wide number of forms and can suit a wide range of requirements. Getting Started Now, we can compare both API architecture designs in practice. But, before we start with installation descriptions, you need to install a typical Django project, connect it to PostgreSQL and make migrations. For the following work you also need to provide simple Django models: GraphQL vs REST Store in models.py from django.db import models


class Store(models.Model):
   name = models.CharField(max_length=256, verbose_name='Store name')
   address = models.CharField(max_length=256)
   email = models.EmailField()
   opening_hours = models.TimeField(verbose_name='Opening hours')
   closing_hours = models.TimeField(verbose_name='Closing hours') And Product in another file: models.py from django.db import models
from django.core.validators import MaxValueValidator, MinValueValidator


class Product(models.Model):
   title = models.CharField(max_length=256, verbose_name='Product title')
   description = models.TextField(max_length=5000)
   price = models.FloatField(
       validators=[MinValueValidator(0.0), MaxValueValidator(10000.0)],
   )
   amount = models.SmallIntegerField()
   store = models.ForeignKey('stores.Store', on_delete=models.CASCADE) GraphQL In Django Installation process: pip install graphene-django In file: settings.py INSTALLED_APPS = [
    ...
    "django.contrib.staticfiles", # Required for GraphiQL
    "graphene_django"
]

GRAPHENE = {
    "SCHEMA": "app.schema.schema"
} We need to add a graphql URL to the of your Django project: urls.py from graphene_django.views import GraphQLView

from django.contrib import admin
from django.urls import path
from django.views.decorators.csrf import csrf_exempt

from app.schema import schema

urlpatterns = [
   path('admin/', admin.site.urls),
   path("graphql", csrf_exempt(GraphQLView.as_view(graphiql=True, schema=schema))),
] For querying process (like use GET) you need to provide object types and resolvers: import graphene
from graphene_django import DjangoObjectType
from app.stores.models import Store
from app.products.models import Product

class StoreType(DjangoObjectType):
   class Meta:
       model = Store
       fields = (
           'id', 'name', 'address', 'email', 'opening_hours', 'closing_hours',
       )


class ProductType(DjangoObjectType):
   class Meta:
       model = Product
       fields = (
           'id', 'title', 'description', 'price', 'amount', 'store',
       )


class Query(graphene.ObjectType):
   stores = graphene.List(StoreType)
   products = graphene.List(ProductType)

   def resolve_stores(root, info, **kwargs):
       # Querying a list
       return Store.objects.all()

   def resolve_products(root, info, **kwargs):
       # Querying a list
       return Product.objects.all()

schema = graphene.Schema(query=Query) GraphQL Testing For testing you can just type in your browser: http://127.0.0.1:8000/graphql If you want something to change (create or update) you need to provide inputs and create/update class with arguments and mutation methods: class StoreInput(graphene.InputObjectType):
   name = graphene.String()
   address = graphene.String()
   email = graphene.String()
   opening_hours = graphene.Time()
   closing_hours = graphene.Time()


class CreateStore(graphene.Mutation):
   class Arguments:
       input = StoreInput(required=True)

   store = graphene.Field(StoreType)

   @classmethod
   def mutate(cls, root, info, input):
       store = Store()
       store.name = input.name
       store.address = input.address
       store.email = input.email
       store.opening_hours = input.opening_hours
       store.closing_hours = input.closing_hours
       store.save()
       return CreateStore(store=store)

class UpdateStore(graphene.Mutation):
   class Arguments:
       input = StoreInput(required=True)
       id = graphene.ID()

   store = graphene.Field(StoreType)

   @classmethod
   def mutate(cls, root, info, input, id):
       store = Store.objects.get(pk=id)
       store.name = input.name
       store.address = input.address
       store.email = input.email
       store.opening_hours = input.opening_hours
       store.closing_hours = input.closing_hours
       store.save()
       return UpdateStore(store=store)


class ProductInput(graphene.InputObjectType):
   title = graphene.String()
   description = graphene.String()
   price = graphene.Float()
   amount = graphene.Int()
   store = graphene.ID()


class CreateProduct(graphene.Mutation):
   class Arguments:
       input = ProductInput(required=True)

   product = graphene.Field(ProductType)

   @classmethod
   def mutate(cls, root, info, input):
       product = Product()
       product.title = input.title
       product.description = input.description
       product.price = input.price
       product.amount = input.amount
       product.store = input.store
       product.save()
       return CreateProduct(product=product)

class UpdateProduct(graphene.Mutation):
   class Arguments:
       input = ProductInput(required=True)
       id = graphene.ID()

   product = graphene.Field(ProductType)

   @classmethod
   def mutate(cls, root, info, input, id):
       product = Product.objects.get(pk=id)
       product.title = input.title
       product.description = input.description
       product.price = input.price
       product.amount = input.amount
       product.store = input.store
       product.save()
       return UpdateProduct(product=product)

class Mutation(graphene.ObjectType):
   create_store = CreateStore.Field()
   update_store = UpdateStore.Field()
   update_product = CreateProduct.Field()
   create_product = UpdateProduct.Field()

schema = graphene.Schema(query=Query, mutation=Mutation) Also, you can test creation in the browser: RestAPI In Django Installation process: pip install djangorestframework In file: settings.py INSTALLED_APPS = [
   ...
   'rest_framework',
]

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10
} You should make serializers in : products/serializers.py from rest_framework import serializers

from .models import Product


class ProductSerializer(serializers.ModelSerializer):
   class Meta:
       model = Product
       fields = '__all__' And also, in : stores/serializers.py from rest_framework import serializers

from .models import Store


class StoreSerializer(serializers.ModelSerializer):
   class Meta:
       model = Store
       fields = '__all__' After this you need to make your views: from rest_framework import generics
from rest_framework.permissions import AllowAny

from .serializers import ProductSerializer
from .models import Product


class RetriveUpdateDestroyProductView(generics.RetrieveUpdateDestroyAPIView):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer
   permission_classes = [AllowAny]


class ListCreateProductView(generics.ListCreateAPIView):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer
   permission_classes = [AllowAny] from rest_framework import generics
from rest_framework.permissions import AllowAny

from .serializers import StoreSerializer
from .models import Store


class RetriveUpdateDestroyStoreView(generics.RetrieveUpdateDestroyAPIView):
   queryset = Store.objects.all()
   serializer_class = StoreSerializer
   permission_classes = [AllowAny]


class ListCreateStoreView(generics.ListCreateAPIView):
   queryset = Store.objects.all()
   serializer_class = StoreSerializer
   permission_classes = [AllowAny] And connect it in file: urls.py In app/stores/urls.py from django.urls import path
from .views import ListCreateStoreView, RetriveUpdateDestroyStoreView


urlpatterns = [
   path('<int:pk>/', RetriveUpdateDestroyStoreView.as_view(), name='store-get-update-delete'),
   path('', ListCreateStoreView.as_view(), name='store-post-list'),
] In app/products/urls.py from django.urls import path
from .views import ListCreateProductView, RetriveUpdateDestroyProductView


urlpatterns = [
   path('<int:pk>/', RetriveUpdateDestroyProductView.as_view(), name='product-get-update-delete'),
   path('', ListCreateProductView.as_view(), name='product-post-list'),
] And in app/urls.py from django.contrib import admin
from django.urls import path, include

urlpatterns = [
   path('admin/', admin.site.urls),
   path('store/', include('app.stores.urls')),
   path('product/', include('app.products.urls')),
] RestAPI Testing After this, you can test it in Postman. For getting products: And creating a new store: GraphQL Vs REST If we compare the examples of the two API integration designs, we can see that the implementation of GraphQL requires more description of the logic of creating new objects, and in the RestAPI there are many ready-made solutions out of the box. That is, GraphQL requires a more complex implementation. Instead, GraphQL adds usability. For example, to make a query and get additional fields you need to register them when querying. At the same time for RestAPI, if you need new fields, then the backend needs to implement new serializers. Also, using GraphQL requires fewer queries to get the information you need. This is important when the Internet may not be good enough (for example, on mobile devices that use a mobile network). GraphQL is more focused on the client-side than well-created documentation, which is created independently. However, among the negatives can be called incompatibility with HTTP. You cannot use statuses (only 200 and 500 are used) and methods (POST only). That takes away flexibility in the processing of errors on a client's part. It is also quite problematic to implement caching in GraphQL due to the use of a single endpoint in different queries. As for security, GraphQL needs to be worked on further, because with the help of queries to different graphs, you can make a query to another user through the rock store to which they belong. In REST there is no such problem as the client receives only what is registered in the endpoint. Summary: How To Choose? GraphQL is fairly new compared to RestAPI, and it's easy to use. Its flexibility and high query speed make it a great alternative to RestAPI. GraphQL will be brilliant when you need a quick interface development, and you expect the program to respond quickly and in a short amount of time. REST, on the other hand, is a more suitable solution for more complex programs with more caching and bug reports. It all comes down to your needs. Some APIs, such as analytics APIs, may not be suitable for GraphQL since they have a small number of entities and connections between them. GraphQL may be more useful in applications with a large number of domain objects, such as e-commerce, where you have goods, users, orders, payments, and so on. However, obviously, to make a decision that won’t affect your app’s performance lately in a bad way, it’s better to confide in software development experts. First published . here

Incuto

incuto.com

-- employees

Since n.d.

COMPANY RANKING

Incuto

EVERGREEN INDEX #1323

See more notable links about Incuto

Apply to get your Tech Company News Page live on HackerNoon.com today!

Read More Tech Stories Related to #Incuto

Incuto

Incuto

incuto.com

-- employees

Since n.d.

COMPANY RANKING

Incuto

EVERGREEN INDEX #1323

Related CompaniesRank

Incuto Story MentionsComplete List

See more notable links about Incuto

Apply to get your Tech Company News Page live on HackerNoon.com today!

Read More Tech Stories Related to #Incuto

Incuto