julho 2021

docker Sem categoria

Marcelo Martins comandos, docker, images

Comandos do DOCKER

Segue aqui alguns dos comandos do docker, para referencia técnica.

Definições

Imagem – Pacote de instalação

Container = Imagem + dados modificados

Pesquisa de repositório de imagem

https://hub.docker.com/

Comandos

Listar imagens

Listar imagens de containers, lista todos os containers instalados na sua maquina.

docker images [nome_imagem]

Baixar imagens

Baixar imagem de container

docker pull <nome_imagem>

exemplo:

docker pull ubuntu:18.04

Execução do container

docker run [opcional] <nome_imagem> [argumentos]

opcional

-i (interação com o container)
-t (iniciar com um terminal de comando)
-d (iniciar container em segundo plano [exit)
–rm (remove container apos o termino)
–name (nomear)
-it (interacao + em terminal)

* Enviando comandos em container

Para enviar comandos p containers ja iniciados

docker exec <nome_container> <comandos>

Consulta de consumo

docker ps -a

* Pesquisa de Imagens

Pesquisa imagens do repositório

docker search <nome_imagem>

* Envia para o repositório

Para criar uma nova imagem criada, use o comando:

docker push <nome_imagem>

* Criar uma imagem

Para criar uma nova imagem

docker build <nome_imagem>

Necessário criar o arquivo DOCKERFILE

Remoção de container

A remoção do container, pode ser feita, através do comando:

docker rm <nome_container>

Outro comando é o RMI, apaga a imagem da maquina

docker rmi <options> IMAGE [repository:tag]

Este é diferente pois apaga a imagem baixada, no caso do rm, ele tem atuação diferente.

Para execução de container

Para parar a execução de um container em execução dê o comando:

docker stop <nome_container>

Pausar execução de container

Para pausar a execução execute o comando:

docker pause <nome_container>

Continuar a partir de uma pausa

Para “despausar” use o comando:

docker unpause <nome_container>

Reiniciar um container

O Reinicio faz o reset da execução do container

docker restart <nome_container>

* Voltando a operar em primeiro plano

O docker pode trabalhar em segundo plano e posteriormente voltar a ser tratado em primeiro plano, para isso, use o comando.

docker attach <nome_imagem>

* Commit mudanças de imagem

Para este comando, faz a alteração dos padrões do container, criando uma imagem

docker commit <nome_imagem>

Backup do Container/Imagem

Os comandos SAVE/LOAD – Fazem o backup da Imagem

Os comandos EXPORT/IMPORT – Fazem o backup do container

Informações

Estado do docker

docker state

Informações do estado geral

docker info

Versões

docker version

Atenção

Os comandos com * ainda estou finalizando a escrita do documento, por isso se houver erros peço perdão, mas em breve corrigirei.

Dicas docker

Marcelo Martins docker

Instalando o DOCKER no Ubuntu

Este tutorial foi baseado no seguinte link:

https://docs.docker.com/engine/installation/linux/ubuntu/

Pré requisito:

Plataforma 64bits e kernel superior ao 3.10

Procedimento de instalação

Para instalar o DOCKER no Ubuntu o procedimento é bem simples.

Passo 1

Digite os seguintes comandos

sudo apt-get update
sudo apt-get install linux-image-extra-$(uname -r) linux-image-extra-virtual
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

Passo 2

Adicionando chave GPG Docker Oficial

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –

Passo 3

Verificação da Chave, a chave tem que ser como se segue:

key fingerprint = 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88

Para isso digite o seguinte comando:

sudo apt-key fingerprint 0EBFCD88

Passo 4

Adicione o repositório no seu apt

sudo add-apt-repository “deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable”

Passo 5

Atualização e instalação do docker-CE

sudo apt-get update
sudo apt-get install docker-ce

Passo 6

Inicializar o servico do Docker

Para isso rode o seguinte serviço:

sudo service docker start

Testando docker

Para testar o docker, execute o seguinte comando:

docker images

O resultado, tem que ser como se segue:

C/C++

Marcelo Martins C, cmake, ninja

Inclusão de libs no CMAKE

Muitas vezes temos que incluir libs e fontes no nosso projeto no CMAKE.

Irei mostrar como faze-lo.

Crie seu código CMakeLists.txt

cmake_minimum_required (VERSION 3.8)
project(projeto VERSION 1.0)
include_directories("."	"./include")
set(CMAKE_CXX_STANDARD 14)

#adicionando libs
add_library(lib1 SHARED IMPORTED)
set_property(TARGET lib1 PROPERTY IMPORTED_LOCATION "./libs")

add_library(lib2 SHARED IMPORTED)
set_property(TARGET lib2 PROPERTY IMPORTED_LOCATION "./libs2")

add_executable(projeto mainsource.c source1.c)

Pronto vc incluiu libs

C/C++ Sem categoria

Marcelo Martins libusb, usb

LIB libusb

Quem tem um PC, sabe que praticamente qualquer dispositivo atualmente esta conectado na USB.

Os dispositivos USB são cada vez mais populares, por sua praticidade e simplicidade.

O desenvolvimento e integração no linux, sempre foi um caminho tortuoso, neste post estarei desvendando um pouco de como funciona o desenvolvimento e o caminho a ser traçado.

O projeto libusb, é uma lib desenvolvida em C, para Linux, ela permite utilizar o protocolo USB da versão 1.0 até a 3.1.

O site do projeto pode ser visto:

https://libusb.info/

O git do projeto pode ser baixado facilmente através do seguinte repositório:

https://github.com/libusb/libusb/releases

Instalação no linux

A instalação da libusb pode ser feita de duas formas:

Compilação do fonte através da baixa e compilação manual.
Baixar os pacotes no linux

Estaremos tratando aqui, do segundo método, pois é o mais prático e direto.

Existem dois pacotes da lib usb:

Uma uso e distribuição (libusb-1.0-0), não permite compilar.
Lib destinada ao desenvolvimento e compilação. (libusb-1.0-0-dev)

Desenvolvimento em C

Para desenvolver em C, primeiramente precisaremos instalar as seguintes dependencias.

apt install libusb-1.0-0-dev libusb-1.0-0
Dependências para compilação

O pacote -dev, incluirá na pasta /usr/local/include os headers que permitem a compilação da lib.

No projeto fonte: https://github.com/libusb/libusb/archive/refs/tags/v1.0.24.zip

Você encontra uma pasta com uma série de fontes, exemplos (exemples).

Entre os exemplos estão o listdevs.c, que vemos no código abaixo:

/*
 * libusb example program to list devices on the bus
 * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>

#include "libusb.h"

static void print_devs(libusb_device **devs)
{
	libusb_device *dev;
	int i = 0, j = 0;
	uint8_t path[8];

	while ((dev = devs[i++]) != NULL) {
		struct libusb_device_descriptor desc;
		int r = libusb_get_device_descriptor(dev, &desc);
		if (r < 0) {
			fprintf(stderr, "failed to get device descriptor");
			return;
		}

		printf("%04x:%04x (bus %d, device %d)",
			desc.idVendor, desc.idProduct,
			libusb_get_bus_number(dev), libusb_get_device_address(dev));

		r = libusb_get_port_numbers(dev, path, sizeof(path));
		if (r > 0) {
			printf(" path: %d", path[0]);
			for (j = 1; j < r; j++)
				printf(".%d", path[j]);
		}
		printf("\n");
	}
}

int main(void)
{
	libusb_device **devs;
	int r;
	ssize_t cnt;

	r = libusb_init(NULL);
	if (r < 0)
		return r;

	cnt = libusb_get_device_list(NULL, &devs);
	if (cnt < 0){
		libusb_exit(NULL);
		return (int) cnt;
	}

	print_devs(devs);
	libusb_free_device_list(devs, 1);

	libusb_exit(NULL);
	return 0;
}

No código acima, irei apresentar apenas alguns poucos pontos, que acredito serem chaves para o entendimento desta api.

O include #include “libusb.h”, permite usar a api do c, este é um passo importante que apesar de notório, achei bom comentar.

A criação da variavel dev, conforme segue:

libusb_device *dev;

É importante, pois este, guardará as informações dos dispositivos.

A chamada da função libusb_get_device_descriptor, coleta as informações do device alvo. Lembrando que dispositivos usb no linux

int r = libusb_get_device_descriptor(dev, &desc);

O dispositivo e suas propriedades, podem ser visualizados, através da chamada de suas propriedades, como segue desc.idVendor .

Por fim, a listagem dos dispositivos conectados, pode ser obtida, pela função:

cnt = libusb_get_device_list(NULL, &devs);

Podemos notar a simplicidade desta api.

Espero ter ajudado a entender um pouco mais sobre USB e acesso a dispositivos.

Blog C/C++ Dicas Sem categoria

Marcelo Martins

Instalação CEF no Linux

CEF é o anacrônico de Chromium Embedded Framework, é uma interface para o Chromium em outras aplicações.

Estaremos tratando aqui, como realizar a instalação deste frame work.

Existem dois caminhos para realizar tal feito, o primeiro e mais complicado é através do procedimento de compilação total, o segundo é através da baixa dos binários já montados.

Compilação total

O Passo a passo que se segue foi tirado em pesquisa da web e consta entre outros links:

https://bitbucket.org/chromiumembedded/cef/wiki/MasterBuildQuickStart#markdown-header-mac-os-x-setup

Baixe os repositórios dos projetos no seguinte repositório GIT:

https://bitbucket.org/%7Bdc443723-7652-4c63-b340-033e522146db%7D/

Para tanto, existem 3 repositórios:

CEF
CEF-PROJECT
Java-cef

Conforme imagem abaixo:

Como o projeto Java, não esta em nosso alvo, ignoraremos este ultimo.

Baixando do CEF

Primeiramente precisamos baixar o projeto

git clone https://bitbucket.org/chromiumembedded/cef.git

Digite o comando acima no seu console.

Instalação do projeto CEF

No site do desenvolvedor este recomenda uma super máquina, com 16 núcleos de processador, e conexão de internet de 100mbits.
Este procedimento deve ser realizado em um Ubuntu 18.04, pois tive problemas em ambientes diferentes.

Realmente o processo é um pouco demorado, e recomendo fortemente que pelo menos a conexão seja de boa qualidade, para que não sofram com o processo.

Siga os passos abaixo para realizar a instalação do CEF:

Passo 1

Entre na pasta cef, e crie os diretórios:

mkdir ./code
mkdir ./code/automate
mkdir ./code/chromium_git
criação das pastas

Passo 2

Baixe e execute o arquivo install0buuild-deps.sh

Este arquivo irá instalar todas as dependências do cef.

cd ./code
sudo apt install curl
curl ‘https://chromium.googlesource.com/chromium/src/+/master/build/install-build-deps.sh?format=TEXT’ | base64 -d > install-build-deps.sh
chmod 755 install-build-deps.sh
sudo ./install-build-deps.sh –no-arm –no-chromeos-fontes –no-nacl
Dependências para instalação do CEF

Passo 3

Baixe os repositórios de ferramentas

cd ./code
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git

Passo 4

Agora voce precisa incluir o caminho absoluto da sua pasta.

Para isso primeiro vá a pasta do cef, indo e digite o comando

export PATH=`dirs | cut -d' ' -f2`/code/depot_tools:$PATH
Pega o caminho da pasta atual e inclui no repositório

Passo 5

Agora é necessário baixar o automate.

cd ~/code/automate
wget https://bitbucket.org/chromiumembedded/cef/raw/master/tools/automate/automate-git.py

Passo 6

Agora vamos baixar o chromium_git, para isso vamos seguir o seguinte passo.

Crie o arquivo update.sh, na pasta ./code/chromium_git

cd ..

cd ./chromium_git

vim update.sh

Edite o seguinte fragmento:

#!/bin/bash
CAMINHO=`dirs | cut -d' ' -f2`
echo $CAMINHO
python ../automate/automate-git.py --download-dir=$CAMINHO/../chromium_git --depot-tools-dir=$CAMINHO/../depot_tools --no-distrib --no-build

Agora dê permissão ao script:

chmod +755 update.sh

Agora rode o script e aguarde.

./update.sh

Passo 7

Neste passo, iremos gerar os defines para configurar o ambiente.

O Chromium usa o usuário root para build da aplicação, porem temos a opção de usuários não root.

GN_DEFINE ROOT

export GN_DEFINES="use_sysroot=true use_allocator=none symbol_level=1 is_cfi=false use_thin_lto=false"

GN_DEFINE NOROOT

export GN_DEFINES="use_sysroot=false use_allocator=none symbol_level=1 is_cfi=false use_thin_lto=false use_vaapi=false"

Passo 8

Rode o script, em ./code/chromium_git/chromium/src/cef/

cd ./code/chromium_git/chromium/src/cef/

./cef_create_projects.sh

Passo 9

Gera o binario com Debug usando Ninja

cd ~/code/chromium_git/chromium/src
ninja -C out/Debug_GN_x64 cefclient cefsimple ceftests chrome_sandbox

Caso queira versão final, substitua a palavra Debug por Release.

Passo 10

Configure o Linux SUID Caixa de areia, se voce esta usando um kernel antigo, versão inferior a 3.8.

# This environment variable should be set at all times.
export CHROME_DEVEL_SANDBOX=/usr/local/sbin/chrome-devel-sandbox

# This command only needs to be run a single time.
cd ~/code/chromium_git/chromium/src
sudo BUILDTYPE=Debug_GN_x64 ./build/update-linux-sandbox.sh

Passo 11

Rode o cefclient, cefsimple e ou ceftests. Note que o cefclient somente compilará se voce estiver usando um parametro nao root, no passo 7.

cd ~/code/chromium_git/chromium/src
./out/Debug_GN_x64/cefclient

Instalação através de Baixa de Binários

Neste processo não há de fato a compilação, apenas a etapa de linkagem dos binários.

Este é o processo que recomendo, pois além de ser mais rápido é mais fácil e dá menos problema na hora da instalação.

Passo 1 – Baixa dos Binários

O primeiro passo é baixar os binários através do site abaixo:

https://cef-builds.spotifycdn.com/index.html

Nele existem diversas distribuições que podem ser vistas, é importante observar qual será o alvo da sua instalação. Para não baixar a distribuição errada, e eventualmente ter problemas com isso.

Lembrando que não é possível compilar um linux 32 com uma distribuição 64, pois a lib terá problemas na linkagem do mesmo. Então sempre escolha a versão que coincide com seu sistema operacional.

Caso não saiba qual é sua distribuição, recomendo, que use o comando,

uname -a

Conforme figura abaixo, podemos ver que meu linux é 64 bits, desta forma recomenda-se o uso da lib 64 bits.

Desta forma seguiremos, com o padrão, conforme passado:

Agora baixe o binário, e instale na sua maquina linux descompactado.

Renomeie o arquivo para apenas cef, conforme figura abaixo.

Apenas para elucidar, estou usando o samba, que permite eu acessar as pastas do linux na minha maquina windows. Isso facilita a edição dos fontes.

Passo 2 – Preparação e Dependências.

Entre no linux pela console, entrando na pasta do cef. Digite o seguinte comando:

cmake .
Preparação para o make, onde irá peparar o makefile

Se não houver problemas de dependências, ele irá estar pronto para linkagem.

Caso dê problema, consulte a documentação, no link abaixo:

https://bitbucket.org/chromiumembedded/cef/wiki/MasterBuildQuickStart#markdown-header-ma

Passo 3 – Linkagem dos binários

Nesta etapa iremos montar a lib, pegando os binários pré compilados e juntando na .so

Para concluir esta etapa, basta digitar na console

make
Monta a lib

Ao fim, será mostrado, o resultado, como segue:

A lib estará disponivel, no caminho .\cef\Release, conforme figura abaixo:

Includes de distribuição,

Ficam em .\cef\include conforme figura abaixo:

C/C++ cmusphinx IA

Marcelo Martins C++, cmake, ninja

Montagem de código em C com Ninja

Definição

Ninja é um pequeno conjunto de ferramentas, desenvolvido por Evan Martin, um empregado da Google. Ninja foi usado em diversas construções de aplicações.

Entre suas vantagens estão a facilidade de montagem de aplicação, a velocidade e rapidez.

Outra vantagem é a capacidade de construir aplicações em multiplos SOs. (Windows, Linux, MacOS).

Referência:

https://en.wikipedia.org/wiki/Ninja_(build_system)

Construção

Iremos apresentar um pequeno projeto construído com NINJA.

O srvOuve é um projeto que visa integrar o CMU sphinx, estaremos construindo uma build com ninja.

Primeiramente precisamos criar o arquivo CMakeLists.txt , que fará a magica acontecer.

Criamos o arquivo conforme aparece no fragmento abaixo:

cmake_minimum_required (VERSION 3.8)

#Define o projeto
project(srvOuve VERSION 1.0)

#Diretorios de Include
include_directories(	   "/usr/local/include/pocketsphinx"
						   "/usr/local/include/sphinxbase"
                          )

set(CMAKE_CXX_STANDARD 14)

add_executable(srvOuve ouve.cpp)

Agora precisaremos dizer ao sistema para gerar os arquivos do ninja, para tanto chamamos o cmake, conforme a sintaxe abaixo:

$ cmake -G Ninja
Execução na console

Com este passo o cmake criará dois arquivos:

build.ninja – Este arquivo contem as configurações de compilação (build)

O build.ninja conterá as regras de construção da aplicação.

# CMAKE generated file: DO NOT EDIT!
# Generated by "Ninja" Generator, CMake Version 3.10

# This file contains all the build statements describing the
# compilation DAG.

# =============================================================================
# Write statements declared in CMakeLists.txt:
#
# Which is the root file.
# =============================================================================

# =============================================================================
# Project: srvOuve
# Configuration:
# =============================================================================

#############################################
# Minimal version of Ninja required by this file

ninja_required_version = 1.5

# =============================================================================
# Include auxiliary files.


#############################################
# Include rules file.

include rules.ninja


#############################################
# Utility command for rebuild_cache

build CMakeFiles/rebuild_cache.util: CUSTOM_COMMAND
  COMMAND = cd /home/maurinsoft/projetos/srvOuve/srv && /usr/bin/cmake -H/home/maurinsoft/projetos/srvOuve/srv -B/home/maurinsoft/projetos/srvOuve/srv
  DESC = Running CMake to regenerate build system...
  pool = console
  restat = 1
build rebuild_cache: phony CMakeFiles/rebuild_cache.util
# =============================================================================
# Object build statements for EXECUTABLE target srvOuve


#############################################
# Order-only phony target for srvOuve

build cmake_object_order_depends_target_srvOuve: phony
build CMakeFiles/srvOuve.dir/ouve.cpp.o: CXX_COMPILER__srvOuve ouve.cpp || cmake_object_order_depends_target_srvOuve
  DEP_FILE = CMakeFiles/srvOuve.dir/ouve.cpp.o.d
  FLAGS = -std=gnu++14
  INCLUDES = -I/usr/local/include/pocketsphinx -I/usr/local/include/sphinxbase
  OBJECT_DIR = CMakeFiles/srvOuve.dir
  OBJECT_FILE_DIR = CMakeFiles/srvOuve.dir

# =============================================================================
# Link build statements for EXECUTABLE target srvOuve


#############################################
# Link the executable srvOuve

build srvOuve: CXX_EXECUTABLE_LINKER__srvOuve CMakeFiles/srvOuve.dir/ouve.cpp.o
  OBJECT_DIR = CMakeFiles/srvOuve.dir
  POST_BUILD = :
  PRE_LINK = :
  TARGET_FILE = srvOuve
  TARGET_PDB = srvOuve.dbg

#############################################
# Utility command for edit_cache

build CMakeFiles/edit_cache.util: CUSTOM_COMMAND
  COMMAND = cd /home/maurinsoft/projetos/srvOuve/srv && /usr/bin/cmake-gui -H/home/maurinsoft/projetos/srvOuve/srv -B/home/maurinsoft/projetos/srvOuve/srv
  DESC = Running CMake cache editor...
  pool = console
  restat = 1
build edit_cache: phony CMakeFiles/edit_cache.util
# =============================================================================
# Target aliases.

# =============================================================================
# Folder targets.

# =============================================================================
# =============================================================================
# Built-in targets


#############################################
# The main all target.

build all: phony srvOuve

#############################################
# Make the all target the default.

default all

#############################################
# Re-run CMake if any of its inputs changed.

build build.ninja: RERUN_CMAKE | /usr/share/cmake-3.10/Modules/CMakeCInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCXXInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake-3.10/Modules/CMakeGenericSystem.cmake /usr/share/cmake-3.10/Modules/CMakeLanguageInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake-3.10/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-C.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-C.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux.cmake /usr/share/cmake-3.10/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/3.10.2/CMakeCCompiler.cmake CMakeFiles/3.10.2/CMakeCXXCompiler.cmake CMakeFiles/3.10.2/CMakeSystem.cmake CMakeLists.txt
  pool = console

#############################################
# A missing CMake input file is not an error.

build /usr/share/cmake-3.10/Modules/CMakeCInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCXXInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake-3.10/Modules/CMakeGenericSystem.cmake /usr/share/cmake-3.10/Modules/CMakeLanguageInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake-3.10/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-C.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-C.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux.cmake /usr/share/cmake-3.10/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/3.10.2/CMakeCCompiler.cmake CMakeFiles/3.10.2/CMakeCXXCompiler.cmake CMakeFiles/3.10.2/CMakeSystem.cmake CMakeLists.txt: phony

#############################################
# Clean all the built files.

build clean: CLEAN

#############################################
# Print all primary targets available.

build help: HELP

O cmake tambem cria o arquivo rules.ninja, responsável pelas regras de compilação.

# CMAKE generated file: DO NOT EDIT!
# Generated by "Ninja" Generator, CMake Version 3.10

# This file contains all the rules used to get the outputs files
# built from the input files.
# It is included in the main 'build.ninja'.

# =============================================================================
# Project: srvOuve
# Configuration:
# =============================================================================
# =============================================================================

#############################################
# Rule for running custom commands.

rule CUSTOM_COMMAND
  command = $COMMAND
  description = $DESC


#############################################
# Rule for compiling CXX files.

rule CXX_COMPILER__srvOuve
  depfile = $DEP_FILE
  deps = gcc
  command = /usr/bin/c++  $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in
  description = Building CXX object $out


#############################################
# Rule for linking CXX executable.

rule CXX_EXECUTABLE_LINKER__srvOuve
  command = $PRE_LINK && /usr/bin/c++  $FLAGS  $LINK_FLAGS $in  -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES && $POST_BUILD
  description = Linking CXX executable $TARGET_FILE
  restat = $RESTAT


#############################################
# Rule for re-running cmake.

rule RERUN_CMAKE
  command = /usr/bin/cmake -H/home/maurinsoft/projetos/srvOuve/srv -B/home/maurinsoft/projetos/srvOuve/srv
  description = Re-running CMake...
  generator = 1


#############################################
# Rule for cleaning all built files.

rule CLEAN
  command = /usr/bin/ninja -t clean
  description = Cleaning all built files...


#############################################
# Rule for printing all primary targets available.

rule HELP
  command = /usr/bin/ninja -t targets
  description = All primary targets available:

Para processar o ninja precisamos fazer uma pequena mudança, alterar as extensões de .c para .cpp, para que o sistema identifique que se trata de compilador C.

Incluindo dependências

Para incluir diretorios para Include, basta incluir a linha

Diretórios de Include

include_directories( “/usr/local/include/pocketsphinx”
“/usr/local/include/sphinxbase”
)
Include adicional

Gerando binário

Por fim precisaremos dar o comando ninja para compilar os scripts.

$ ninja

Pronto você montou um Montador em Ninja! Parabéns!

Blog C/C++ Dicas

Marcelo Martins IDE Online, Web

Testando código em C

As vezes precisamos testar um codigo em C de forma bem pontual.

E não temos uma maquina com tudo instalado, Compilador, ambiente.

Existe uma ferramenta Online:

https://ideone.com/

O atributo alt desta imagem está vazio. O nome do arquivo é image-1.png

Com ela, é possível testar códigos e compilar de forma rápida e pontual.

Arquivo mensal: julho 2021

Comandos do DOCKER

Definições

Pesquisa de repositório de imagem

Comandos

Listar imagens

Baixar imagens

Execução do container

* Enviando comandos em container

Consulta de consumo

* Pesquisa de Imagens

* Envia para o repositório

* Criar uma imagem

Remoção de container

Para execução de container

Pausar execução de container

Continuar a partir de uma pausa

Reiniciar um container

* Voltando a operar em primeiro plano

* Commit mudanças de imagem

Backup do Container/Imagem

Informações

Estado do docker

Informações do estado geral

Versões

Atenção

Instalando o DOCKER no Ubuntu

Pré requisito:

Procedimento de instalação

Passo 1

Passo 2

Passo 3

Passo 4

Passo 5

Passo 6

Testando docker

Inclusão de libs no CMAKE

LIB libusb

Instalação no linux

Desenvolvimento em C

Instalação CEF no Linux

Compilação total

Baixando do CEF

Instalação do projeto CEF

Passo 1

Passo 2

Passo 3

Passo 4

Passo 5

Passo 6

Passo 7

Passo 8

Passo 9

Passo 10

Passo 11

Instalação através de Baixa de Binários

Passo 1 – Baixa dos Binários

Passo 2 – Preparação e Dependências.

Passo 3 – Linkagem dos binários

Montagem de código em C com Ninja

Definição

Construção

Incluindo dependências

Gerando binário

Testando código em C