One place for hosting & domains

      Github

      Como Criar um Pull Request no GitHub


      Introdução

      Livre e open-source, o Git é um sistema de controle de versão distribuído que torna os projetos de software colaborativo mais gerenciáveis. Muitos projetos mantém seus arquivos em um repositório Git, e sites como o Github tornaram o compartilhamento e a contribuição para o código simples e efetiva.

      Projetos open-source que são hospedados em repositórios públicos beneficiam-se de contribuições feitas pela ampla comunidade de desenvolvedores através de pull requests, que solicitam que um projeto aceite as alterações feitas em seu repositório de código.

      Este tutorial vai guiá-lo no processo de realizar um pull request para um repositório Git através da linha de comando para que você possa contibuir com projetos de software open-source.

      Pré-requisitos

      Você deve ter o Git instalado em sua máquina local. Você pode verificar se o Git está instalado em seu computador e passar pelo processo de instalação para o seu sistema operacional, seguindo este guia.

      Você também precisará ter ou criar uma conta no GitHub. Você pode fazer isso através do website do GitHub, github.com, e pode ou efetuar login ou criar sua conta.

      Finalmente, você deve identificar um projeto de software open-source para contribuir. Você pode se familiarizar mais com os projetos open-source lendo essa introdução.

      Crie uma Cópia do Repositório

      Um repositório, ou repo para abreviar, é essencialmente a pasta principal do projeto. O repositório contém todos os arquivos relevantes do projeto, incluindo documentação, e também armazena o histórico de revisão para cada arquivo. No GitHub, os repositórios podem ter vários colaboradores e podem ser públicos ou privados.

      Para trabalhar em um projeto open-source, primeiro você precisará criar sua própria cópia do repositório. Para fazer isso, você deve fazer um fork do repositório e então fazer a clonagem dele para que você tenha uma cópia de trabalho local.

      Faça o Fork do Repositório

      Você pode fazer um fork de um repositório navegando até a URL GitHub do projeto open-source que você gostaria de contribuir.

      As URLs de repositórios GitHub irão referenciar o nome do usuário associado com o proprietário do repositório, bem como o nome do repositório. Por exemplo, DigitalOcean Community é o proprietário do repositório do projeto cloud_haiku, assim a URL GitHub para esse projeto é:

      https://github.com/do-community/cloud_haiku
      

      No exemplo acima, do-community é o nome do usuário e cloud_haiku é o nome do repositório.

      Um vez que você identificou o projeto que você gostaria de contribuir, você pode navegar até a URL, que estará formatada da seguinte forma:

      https://github.com/nome-do-usuário/repositório
      

      Ou você pode procurar o projeto usando a barra de pesquisa do GitHub.

      Quando você estiver na página principal do repositório, você verá um botão “Fork” no seu lado superior direito da página, abaixo do seu ícone de usuário:

      Clique no botão fork para iniciar o processo de fork. Dentro da janela do seu navegador, você receberá um feedback assim:

      Quando o processo estiver concluído, o seu navegador irá para uma tela semelhante à imagem do repositório acima, exceto que no topo você verá seu nome de usuário antes do nome do repositório, e na URL ela também mostrará seu nome de usuário antes do nome do repositório.

      Então, no exemplo acima, em vez de do-community / cloud_haiku na parte superior da página, você verá seu-nome-de-usuário / cloud_haiku, e a nova URL será parecida com isto:

      https://github.com/seu-nome-de-usuário/cloud_haiku
      

      Com o fork do repositório realizado, você está pronto para cloná-lo para que você tenha uma cópia de trabalho local da base de código.

      Clone o Repositório

      Para criar sua própria cópia local do repositório com o qual você gostaria de contribuir, primeiro vamos abrir uma janela de terminal.

      Vamos utilizar o comando git clone juntamente com a URL que aponta para o seu fork do repositório.

      Esta URL será semelhante à URL acima, exceto que agora ela irá terminar com .git. No exemplo do cloud_haiku acima, a URL ficará assim:

      https://github.com/seu-nome-de-usuário/cloud_haiku.git
      

      Você pode, alternativamente, copiar a URL usando o botão verde “Clone or download” da página do seu repositório que você acabou de fazer fork. Depois de clicar no botão, você poderá copiar a URL clicando no botão do fichário ao lado da URL:

      Uma vez que tenhamos a URL, estamos prontos para clonar o repositório. Para fazer isto, vamos combinar o comando git clone com a URL do repositório a partir da linha de comando em uma janela de terminal:

      • git clone https://github.com/seu-nome-de-usuário/repositório.git

      Agora que você tem uma cópia local do código, podemos passar para a criação de uma nova branch ou ramificação na qual iremos trabalhar com o código.

      Crie uma Nova Branch

      Sempre que você trabalha em um projeto colaborativo, você e outros programadores que contribuem para o repositório terão ideias diferentes para novos recursos ou correções de uma só vez. Alguns desses novos recursos não levarão tempo significativo para serem implementados, mas alguns deles estarão em andamento. Por isso, é importante ramificar o repositório para que você possa gerenciar o fluxo de trabalho, isolar seu código e controlar quais recursos serão retornados à branch principal do repositório do projeto.

      A branch principal padrão de um repositório de projeto é geralmente chamada de master branch. Uma prática comum recomendada é considerar qualquer coisa na branch master como sendo passível de se fazer o deploy para outras pessoas usarem a qualquer momento.

      Ao criar uma nova branch, é muito importante que você a crie fora da branch master. Você também deve se certificar de que o nome da sua branch é descritivo. Em vez de chamá-la de minha-branch, você deve usar frontend-hook-migration ou Corrigir erros de digitação na documentação.

      Para criar nossa branch, na nossa janela de terminal, vamos mudar nosso diretório para que estejamos trabalhando no diretório do repositório. Certifique-se de usar o nome real do repositório (como cloud_haiku) para mudar para esse diretório.

      Agora, vamos criar nossa nova branch com o comando git branch. Certifique-se de nomeá-la de maneira descritiva para que outras pessoas trabalhando no projeto entendam no que você está trabalhando.

      Agora que nossa nova branch está criada, podemos mudar para nos certificar de que estamos trabalhando nessa branch usando o comando git checkout:

      Depois de inserir o comando git checkout, você receberá a seguinte saída:

      Output

      Switched to branch nova-branch

      Alternativamente, você pode condensar os dois comandos acima, criando e mudando para a nova branch, com o seguinte comando e com a flag -b:

      • git checkout -b nova-branch

      Se você quiser mudar de volta para o master, você irá usar o comando checkout com o nome da branch master:

      O comando checkout vai lhe permitir alternar entre várias branches, para que você possa trabalhar em vários recursos de uma só vez.

      Neste ponto, agora você pode modificar arquivos existentes ou adicionar novos arquivos ao projeto em sua própria branch.

      Faça Alterações Localmente

      Depois de modificar os arquivos existentes ou adicionar novos arquivos ao projeto, você pode adicioná-los ao seu repositório local, o que podemos fazer com o comando git add. Vamos adicionar a flag -A para adicionar todas as alterações que fizemos:

      Em seguida, queremos registrar as alterações que fizemos no repositório com o comando git commit.

      A mensagem de commit é um aspecto importante da sua contribuição de código; ela ajuda os outros contribuidores a entenderem completamente a mudança que você fez, por que você fez e o quanto é importante. Adicionalmente, as mensagens de commit fornecem um registro histórico das mudanças para o projeto em geral, ajudando os futuros contribuidores ao longo do caminho.

      Se tivermos uma mensagem muito curta, podemos gravar isso com a flag -m e a mensagem entre aspas:

      • git commit -m "Corrigidos erros de digitação na documentação"

      Mas, a menos que seja uma mudança muito pequena, é bem provável que incluiremos uma mensagem de confirmação mais longa para que nossos colaboradores estejam totalmente atualizados com nossa contribuição. Para gravar esta mensagem maior, vamos executar o comando git commit que abrirá o editor de texto padrão:

      Se você gostaria de configurar seu editor de texto padrão, você pode fazê-lo com o comando git config e definir o nano como editor padrão, por exemplo:

      git config --global core.editor "nano"
      

      Ou o vim:

      • git config --global core.editor "vim"

      Depois de executar o comando git commit, dependendo do editor de texto padrão que você está usando, sua janela de terminal deve exibir um documento pronto para edição que será semelhante a este:

      GNU nano 2.0.6 File: …username/repository/.git/COMMIT_EDITMSG

      
      # Please enter the commit message for your changes. Lines starting
      # with '#' will be ignored, and an empty message aborts the commit.
      # On branch nova-branch
      # Your branch is up-to-date with 'origin/new-branch'.
      #
      # Changes to be committed:
      #       modified:   novo-recurso.py
      #
      

      Abaixo dos comentários introdutórios, você deve adicionar a mensagem de commit ao arquivo de texto.

      Para escrever uma mensagem útil no commit, você deve incluir um sumário na primeira linha com cerca de 50 caracteres. Abaixo disso, e dividido em seções de fácil entendimento, você deve incluir uma descrição que indique o motivo pelo qual você fez essa alteração, como o código funciona, e informações adicionais que irão contextualizar e esclarecer o código para que outras pessoas revisem o trabalho ao mesclá-lo. Tente ser o mais útil e proativo possível para garantir que os responsáveis pela manutenção do projeto possam entender totalmente sua contribuição.

      Depois de salvar e sair do arquivo de texto da mensagem de commit, você poderá verificar o commit que o git estará fazendo com o seguinte comando:

      Dependendo das alterações que você fez, você receberá uma saída parecida com esta:

      Output

      On branch nova-branch Your branch is ahead of 'origin/nova-branch' by 1 commit. (use "git push" to publish your local commits) nothing to commit, working directory clean

      Nesse ponto você pode usar o comando git push para fazer o push das alterações para a branch atual do repositório que você fez o fork:

      • git push --set-upstream origin nova-branch

      O comando irá lhe fornecer uma saída para que você saiba do progresso e será semelhante ao seguinte:

      Output

      Counting objects: 3, done. Delta compression using up to 4 threads. Compressing objects: 100% (2/2), done. Writing objects: 100% (3/3), 336 bytes | 0 bytes/s, done. Total 3 (delta 0), reused 0 (delta 0) To https://github.com/seu-nome-de-usuário /repositório .git a1f29a6..79c0e80 nova-branch -> <^>nova-branch< Branch nova-branch set up to track remote branch nova-branch from origin.

      Agora você pode navegar até o repositório que você fez o fork na sua página web do GitHub e alternar para a branch que você acabou de fazer push para ver as alterações que você fez diretamente no navegador.

      Nesse ponto, é possível fazer um pull request para o repositório original, mas se ainda não o fez, certifique-se de que seu repositório local esteja atualizado com o repositório upstream.

      Atualize o Repositório Local

      Enquanto você estiver trabalhando em um projeto ao lado de outros colaboradores, é importante que você mantenha seu repositório local atualizado com o projeto, pois você não deseja fazer um pull request de um código que cause conflitos. Para manter sua cópia local da base de código atualizada, você precisará sincronizar as alterações.

      Primeiro vamos passar pela configuração de um repositório remoto para o fork, e então, sincronizar o fork.

      Configure um Repositório Remoto para o Fork

      Repositórios remotos permitem que você colabore com outras pessoas em um projeto Git. Cada repositório remoto é uma versão do projeto que está hospedada na Internet ou em uma rede à qual você tem acesso. Cada repositório remoto deve ser acessível a você como somente leitura ou como leitura-gravação, dependendo dos seus privilégios de usuário.

      Para poder sincronizar as alterações feitas em um fork com o repositório original com o qual você está trabalhando, você precisa configurar um repositório remoto que faça referência ao repositório upstream. Você deve configurar o repositório remoto para o repositório upstream apenas uma vez.

      Primeiro, vamos verificar quais servidores remotos você configurou. O comando git remote listará qualquer repositório remoto que você já tenha especificado, então se você clonou seu repositório como fizemos acima, você verá pelo menos o repositório origin, que é o nome padrão fornecido pelo Git para o diretório clonado.

      A partir do diretório do repositório em nossa janela de terminal, vamos usar o comando git remote juntamente com a flag -v para exibir as URLs que o Git armazenou junto com os nomes curtos dos repositórios remotos relevantes (como em "origin"):

      Como clonamos um repositório, nossa saída deve ser semelhante a isso:

      Output

      origin https://github.com/seu-nome-de-usuário/repositório-forked.git (fetch) origin https://github.com/seu-nome-de-usuário/repositório-forked.git (push)

      Se você configurou anteriormente mais de um repositório remoto, o comando git remote -v fornecerá uma lista de todos eles.

      Em seguida, vamos especificar um novo repositório remoto upstream para sincronizarmos com o fork. Este será o repositório original do qual fizemos o fork. Faremos isso com o comando git remote add.

      • git remote add upstream https://github.com/nome-de-usuário-do-proprietário-original/repositório-original.git

      Nesse exemplo, upstream é o nome abreviado que fornecemos para o repositório remoto, já que em termos do Git, “Upstream” refere-se ao repositório do qual nós clonamos. Se quisermos adicionar um ponteiro remoto ao repositório de um colaborador, podemos fornecer o nome de usuário desse colaborador ou um apelido abreviado para o nome abreviado.

      Podemos verificar que nosso ponteiro remoto para o repositório upstream foi adicionado corretamente usando o comando git remote -v novamente a partir do diretório do repositório:

      Output

      origin https://github.com/seu-nome-de-usuário/repositório-forked.git (fetch) origin https://github.com/seu-nome-de-usuário/repositório-forked.git (push) upstream https://github.com/nome-de-usuário-do-proprietário-original/repositório-original.git (fetch) upstream https://github.com/nome-de-usuário-do-proprietário-original/repositório-original.git (push)

      Agora você pode se referir ao upstream na linha de comando em vez de escrever a URL inteira, e você está pronto para sincronizar seu fork com o repositório original.

      Sincronizando o Fork

      Depois de configurarmos um repositório remoto que faça referência ao upstream e ao repositório original no GitHub, estamos prontos para sincronizar nosso fork do repositório para mantê-lo atualizado.

      Para sincronizar nosso fork, a partir do diretório do nosso repositório local em uma janela de terminal, vamos utilizar o comando git fetch para buscar as branches juntamente com seus respectivos commits do repositório upstream. Como usamos o nome abreviado "upstream" para nos referirmos ao repositório upstream, passaremos o mesmo para o comando:

      Dependendo de quantas alterações foram feitas desde que fizemos o fork do repositório, sua saída pode ser diferente, e pode incluir algumas linhas de contagem, compactação e descompactação de objetos. Sua saída terminará de forma semelhante às seguintes linhas, mas pode variar dependendo de quantas branches fazem parte do projeto:

      Output

      From https://github.com/nome-de-usuário-do-proprietário-original/repositório-original * [new branch] master -> upstream/master

      Agora, os commits para o branch master serão armazenados em uma branch local chamada upstream/master.

      Vamos mudar para a branch master local do nosso repositório:

      Output

      Switched to branch 'master'

      Agora mesclaremos todas as alterações feitas na branch master do repositório original, que vamos acessar através de nossa branch upstream/master local, com a nossa branch master local:

      • git merge upstream/master

      A saída aqui vai variar, mas começará com Updating se tiverem sido feitas alterações, ou Already up-to-date, se nenhuma alteração foi feita desde que você fez o fork do repositório.

      A branch master do seu fork agora está em sincronia com o repositório upstream, e as alterações locais que você fez não foram perdidas.

      Dependendo do seu fluxo de trabalho e da quantidade de tempo que você gasta para fazer alterações, você pode sincronizar seu fork com o código upstream do repositório original quantas vezes isso fizer sentido para você. No entanto, você certamente deve sincronizar seu fork antes de fazer um pull request para garantir que não contribuirá com código conflitante.

      Crie um Pull Request

      Neste ponto, você está pronto para fazer um pull request para o repositório original.

      Você deve navegar até o seu repositório onde você fez o fork e pressionar o botão "New pull request" no lado esquerdo da página.

      Você pode modificar a branch na próxima tela. Em qualquer site, você pode selecionar o repositório apropriado no menu suspenso e a branch apropriada.

      Depois de ter escolhido, por exemplo, a branch master do repositório original no lado esquerdo, e a nova-branch do seu fork do lado direito, você deve ver uma tela assim:

      O GitHub vai lhe alertar de que é possível mesclar as duas branches porque não há código concorrente. Você deve adicionar um título, um comentário e, em seguida, pressionar o botão "Create pull request".

      Neste ponto, os mantenedores do repositório original decidirão se aceitam ou não o seu pull request. Eles podem solicitar que você edite ou revise seu código antes de aceitar o pull request.

      Conclusão

      Neste ponto, você enviou com êxito um pull request para um repositório de software open-source. Depois disso, você deve se certificar de atualizar e fazer um rebase do seu código enquanto espera que ele seja revisado. Os mantenedores do projeto podem pedir que você refaça seu código, então você deve estar preparado para isso.

      Contribuir para projetos de open-source - e se tornar um desenvolvedor ativo de open-source - pode ser uma experiência gratificante. Fazer contribuições regulares para o software que você usa com frequência lhe permite certificar-se de que esse software seja tão valioso para outros usuários finais quanto possível.

      Se você estiver interessado em aprender mais sobre o Git e colaborar com open-source, leia nossa série de tutoriais intitulada An Introduction to Open Source. Se você já conhece o Git e gostaria de um guia de consulta rápida, consulte “Como Usar o Git: Um Guia de Consulta Rápida.”

      Por Lisa Tagliaferri



      Source link

      How to Use Node.js and Github Webhooks to Keep Remote Projects in Sync


      Introduction

      When working on a project with multiple developers, it can be frustrating when one person pushes to a repository and then another begins making changes on an outdated version of the code. Mistakes like these cost time, which makes it worthwhile to set up a script to keep your repositories in sync. You can also apply this method in a production environment to push hotfixes and other changes quickly.

      While other solutions exist to complete this specific task, writing your own script is a flexible option that leaves room for customization in the future.

      GitHub lets you configure webhooks for your repositories, which are events that send HTTP requests when events happen. For example, you can use a webhook to notify you when someone creates a pull request or pushes new code.

      In this guide you will develop a Node.js server that listens for a GitHub webhook notification whenever you or someone else pushes code to GitHub. This script will automatically update a repository on a remote server with the most recent version of the code, eliminating the need to log in to a server to pull new commits.

      Prerequisites

      To complete this tutorial, you will need:

      • One Ubuntu 16.04 server set up by following the Ubuntu 16.04 initial server setup guide, including a non-root user with sudo privileges and a firewall.
      • Git installed on your local machine. You can follow the tutorial Contributing to Open Source: Getting Started with Git to install and set up Git on your computer.
      • Node.js and npm installed on the remote server using the official PPA, as explained explained in How To Install Node.js on Ubuntu 16.04. Installing the distro-stable version is sufficient as it provides us with the recommended version without any additional configuration.
      • A repository on Github that contains your project code. If you don’t have a project in mind, feel free to fork this example which we’ll use in the rest of the tutorial.

      Step 1 — Setting Up a Webhook

      We’ll start by configuring a webhook for your repository. This step is important because without it, Github doesn’t know what events to send when things happen, or where to send them. We’ll create the webhook first, and then create the server that will respond to its requests.

      Sign in to your GitHub account and navigate to the repository you wish to monitor. Click on the Settings tab in the top menu bar on your repository’s page, then click Webhooks in the left navigation menu. Click Add Webhook in the right corner and enter your account password if prompted. You’ll see a page that looks like this:

      Webhooks Page

      • In the Payload URL field, enter http://your_server_ip:8080. This is the address and port of the Node.js server we’ll write soon.
      • Change the Content type to application/json. The script we will write will expect JSON data and won’t be able to understand other data types.
      • For Secret, enter a secret password for this webhook. You’ll use this secret in your Node.js server to validate requests and make sure they came from GitHub.
      • For Which events would you like to trigger this webhook, select just the push event. We only need the push event since that is when code is updated and needs to be synced to our server.
      • Select the Active checkbox.
      • Review the fields and click Add webhook to create it.

      The ping will fail at first, but rest assured your webhook is now configured. Now let’s get the repository cloned to the server.

      Step 2 — Cloning the Repository to the Server

      Our script can update a repository, but it cannot handle setting up the repository initially, so we’ll do that now. Log in to your server:

      Ensure you're in your home directory. Then use Git to clone your repository. Be sure to replace sammy with your GitHub username and hello_hapi with the name of your Github project.

      • cd
      • git clone https://github.com/sammy/hello_hapi.git

      This will create a new directory containing your project. You'll use this directory in the next step.

      With your project cloned, you can create the webhook script.

      Step 3 — Creating the Webhook Script

      Let's create our server to listen for those webhook requests from GitHub. We'll write a Node.js script that launches a web server on port 8080. The server will listen for requests from the webhook, verify the secret we specified, and pull the latest version of the code from GitHub.

      Navigate to your home directory:

      Create a new directory for your webhook script called NodeWebhooks:

      Then navigate to the new directory:

      Create a new file called webhook.js inside of the NodeWebhooks directory.

      Add these two lines to the script:

      webhook.js

      var secret = "your_secret_here";
      var repo = "/home/sammy/hello_hapi";
      

      The first line defines a variable to hold the secret you created in Step 1 which verifies that requests come from GitHub. The second line defines a variable that holds the full path to the repository you want to update on your local disk. This should point to the repository you checked out in Step 2.

      Next, add these lines which import the http and crypto libaries into the script. We'll use these to create our web server and hash the secret so we can compare it with what we receive from GitHub:

      webhook.js

      let http = require('http');
      let crypto = require('crypto');
      

      Next, include the child_process library so you can execute shell commands from your script:

      webhook.js

      const exec = require('child_process').exec;
      

      Next, add this code to define a new web server that handles GitHub webhook requests and pulls down the new version of the code if it's an authentic request:

      webhook.js

      http.createServer(function (req, res) {
          req.on('data', function(chunk) {
              let sig = "sha1=" + crypto.createHmac('sha1', secret).update(chunk.toString()).digest('hex');
      
              if (req.headers['x-hub-signature'] == sig) {
                  exec('cd ' + repo + ' && git pull');
              }
          });
      
          res.end();
      }).listen(8080);
      

      The http.createServer() function starts a web server on port 8080 which listens for incoming requests from Github. For security purposes, we validate that the secret included in the request matches the one we specified when creating the webhook in Step 1. The secret is passed in the x-hub-signature header as an SHA1-hashed string, so we hash our secret and compare it to what GitHub sends us.

      If the request is authentic, we execute a shell command to update our local repository using git pull.

      The completed script looks like this:

      webhook.js

      const secret = "your_secret_here";
      const repo = "~/your_repo_path_here/";
      
      const http = require('http');
      const crypto = require('crypto');
      const exec = require('child_process').exec;
      
      http.createServer(function (req, res) {
          req.on('data', function(chunk) {
              let sig = "sha1=" + crypto.createHmac('sha1', secret).update(chunk.toString()).digest('hex');
      
              if (req.headers['x-hub-signature'] == sig) {
                  exec('cd ' + repo + ' && git pull');
              }
          });
      
          res.end();
      }).listen(8080);
      

      If you followed the initial server setup guide, you will need to allow this web server to communicate with the outside web by allowing traffic on port 8080:

      Now that our script is in place, let's make sure that it is working properly.

      Step 4 - Testing the Webhook

      We can test our webhook by using node to run it in the command line. Start the script and leave the process open in your terminal:

      • cd ~/NodeWebhooks
      • nodejs webhook.js

      Return to your project's page on Github.com. Click on the Settings tab in the top menu bar on your repository's page, followed by clicking Webhooks in the left navigation menu. Click Edit next to the webhook you set up in Step 1. Scroll down until you see the Recent Deliveries section, as shown in the following image:

      Edit Webhook

      Press the three dots to the far right to reveal the Redeliver button. With the node server running, click Redeliver to send the request again. Once you confirm you want to send the request, you'll see a successful response. This is indicated by a 200 OK response code after redelivering the ping.

      We can now move on to making sure our script runs in the background and starts at boot. Use CTRL+C stops the node webhook server.

      Step 5 — Installing the Webhook as a Systemd Service

      systemd is the task manager Ubuntu uses to control services. We will set up a service that will allow us to start our webhook script at boot and use systemd commands to manage it like we would with any other service.

      Start by creating a new service file:

      • sudo nano /etc/systemd/system/webhook.service

      Add the following configuration to the service file which tells systemd how to run the script. This tells Systemd where to find our node script and describes our service.

      Make sure to replace sammy with your username.

      /etc/systemd/system/webhook.service

      [Unit]
      Description=Github webhook
      After=network.target
      
      [Service]
      Environment=NODE_PORT=8080
      Type=simple
      User=sammy
      ExecStart=/usr/bin/nodejs /home/sammy/NodeWebhooks/webhook.js
      Restart=on-failure
      
      [Install]
      WantedBy=multi-user.target
      

      Enable the new service so it starts when the system boots:

      • sudo systemctl enable webhook.service

      Now start the service:

      • sudo systemctl start webhook

      Ensure the service is started:

      • sudo systemctl status webhook

      You'll see the following output indicating that the service is active:

      Output

      ● webhook.service - Github webhook Loaded: loaded (/etc/systemd/system/webhook.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2018-08-17 19:28:41 UTC; 6s ago Main PID: 9912 (nodejs) Tasks: 6 Memory: 7.6M CPU: 95ms CGroup: /system.slice/webhook.service └─9912 /usr/bin/nodejs /home/sammy/NodeWebhooks/webhook.js

      You are now able to push new commits to your repository and see the changes on your server.

      From your desktop machine, clone the repository:

      • git clone https://github.com/sammy/hello_hapi.git

      Make a change to one of the files in the repository. Then commit the file and push your code to GitHub.

      • git add index.js
      • git commit -m "Update index file"
      • git push origin master

      The webhook will fire and your changes will appear on your server.

      Conclusion

      You have set up a Node.js script which will automatically deploy new commits to a remote repository. You can use this process to set up additional repositories that you'd like to monitor. You could even configure it to deploy a website or application to production when you push your repository.



      Source link