Descritores de arquivo e ponteiros para os arquivos

file_decriptor

Olá pessoal!

Neste post apenas replico uma informação que contém a definição de descritor de arquivos.  Este post será parte de outro post sobre Socket que está sendo elaborado.

Foi visto que o nó de indexação de um arquivo é a estrutura de identificação do arquivo dentro de um sistema. Quando um processo quiser manipular um arquivo, ele vai simplesmente utilizar um inteiro chamado descritor de arquivo. A associação desse descritor ao nó de indexação deste arquivo se faz durante a chamada da primitiva open() (ver 1.5.4), com o descritor tornando-se então o nome local de acesso desse arquivo no processo. Cada processo UNIX dispõe de 20 descritores de arquivo, numerados de 0 a 19. Por convenção, os três primeiros são sempre abertos no início da vida de um processo:

  • O descritor de arquivo 0 é a entrada padrão (geralmente o teclado);
  • O descritor de arquivo 1 é associado a saída padrão (normalmente a tela);
  • O descritor de arquivo 2 é a saída de erro padrão (normalmente a tela).

Os outros 17 descritores estão disponíveis para os arquivos. Esta noção de descritor de arquivo é usada para a interface de Entrada/Saída de baixo nível, especialmente com as primitivas open(), write(), etc. Por outro lado, quando as primitivas da biblioteca padrão de entrada/saída são usadas, os arquivos são encontrados através dos ponteiros para os objetos do tipo FILE (tipo definido dentro da <stdio.h>).

Existem três ponteiros definidos neste caso:

  • stdin que aponta para o buffer da saída padrão (geralmente o teclado);
  • stdout que aponta para o buffer da saída padrão (normalmente a tela);
  • stderr que aponta para o buffer da saída de erro padrão (normalmente a tela).

fonte: https://www.dca.ufrn.br/~adelardo/cursos/DCA409/node17.html

Anúncios

Java (Maven) – Erros Inesperados

Olá pessoal, boa noite.

Hoje vou deixar uma resolução básica para um daqueles erros que acontecem no Maven quando você está construindo suas dependências no Netbeans.

fonte: https://mastigado.wordpress.com

Se ao mandar executar o seu programa Java pelo Netbeans surgem algumas mensagens do tipo:

Getting 'java.lang.UnsatisfiedLinkError': no lwjgl in java.library.path

Ou

Failed to execute goal org.codehaus.mojo:exec-maven-plugin:1.2.1:exec

Sugiro a você conferir as configurações de seu projeto, pois no meu caso os arquivos da library de outro projeto que estava tentando copiar se localizava numa pasta chama native dentro do diretório raiz de meu projeto. Para fazer isso clique com o botão direito em cima do seu projeto Netbeans e siga em Propriedades. Após a janela que se abrirá vá até Construir > Executar e adicione a informação de onde está a sua classe principal. Em Opções de VM adicione a seguinte linha:

-Djava.library.path=.\native\

Confira com a imagem abaixo e mande executar novamente.

config_path_maven

fonte: https://mastigado.wordpress.com

Integrando o GitLab no Active Directory (LDAP)

gitlab

Olá pessoal, bom dia (bom dia num blog que pode ser lido em qualquer hora, francamente, tsc…).

Hoje vou deixar uma dica para quem quer integrar a ferramenta GitLab no Active Directory.

fonte: http://matigado.wordpress.com

Para quem não conhece o GitLab, deixarei uma breve citação sobre o mesmo:

O GitLab compete com várias outras plataformas de gerenciamento de código para equipes de desenvolvimento – como o GitHub e Atlassian – mas atraiu investidores devido à sua torção open source no repositório de código e no modelo de ferramenta de colaboração, que permite aos usuários adaptar a plataforma para melhor atender às suas necessidades.

O texto acima também quer dizer que você pode baixar a ferramenta e instalar na sua empresa tendo uma espécie de GitHub lá dentro, mas sua instalação não será abordada aqui porque depende de várias dependências online e que do meu ponto de vista podem variar, portanto para ter acesso ao passo da instalação do GitLab localmente aconselho procurar no próprio site do GitLab (lembrando que instalei no Linux Debian 8).

Definições para o arquivo de configuração

Para a nossa configuração junto ao Active Directory vamos supor que tenhamos um servidor com as seguintes informações:

  • Nome do servidor do AD: meu_servidor_do_ad
  • Nome do domínio: dominio.central
  • Local onde está localizado o usuário administrador do AD: CN=Users
  • Base onde estão os usuários do AD: OU=PESSOAS,OU=USUARIOS,OU=ATIVOS,DC=dominio,DC=central.
  • Meu usuário admin do AD: Jair Rodrigues.

Vale lembrar uma observação feita por um usuário no site do Viva o Linux de que você não deve tentar reidentar o código, mas apenas descomentar e alterar o conteúdo do que está dentro das aspas. Eis a observação feita por ele:

ATENÇÃO: este arquivo gitlab.rb tem indentação (yaml), sendo assim não mude os espaços, não use tab, cada linha que você descomentar, deixe os espaços exatamente como estavam, não tente deixar mais para esquerda, mais para direita, não mexa na formatação, apenas apague o “#”, mude os atributos e pronto.

Portanto depois de instalado o Gitlab devemos editar suas configurações para integrá-lo ao AD de acordo com o que está descrito abaixo.

   nano /etc/gitlab/gitlab.rb
   gitlab_rails['ldap_enabled'] = true

###! **remember to close this block with 'EOS' below**
   gitlab_rails['ldap_servers'] = YAML.load <<-'EOS'
      main: # 'main' is the GitLab 'provider ID' of this LDAP server
      label: 'LDAP'
      host: 'meu_servidor_do_ad.dominio.central'
      port: 389
      uid: 'sAMAccountName'
      method: 'plain' # "tls" or "ssl" or "plain"
      bind_dn: 'CN=Jair Rodrigues,CN=Users,DC=dominio,DC=central'
      password: 'xererenenen'
      active_directory: true
      allow_username_or_email_login: true
      block_auto_created_users: false
      base: 'OU=PESSOAS,OU=USUARIOS,OU=ATIVOS,DC=dominio,DC=central'
# user_filter: ''
      attributes:
         username: ['uid', 'userid', 'sAMAccountName']
         email: ['mail', 'email', 'userPrincipalName']
         name: 'cn'
         first_name: 'givenName'
         last_name: 'sn'
EOS

Algumas observações acerca desta configuração

Sobre o atributo base:

Na empresa que trabalho, os usuários do AD estão sob a seguinte hierarquia de pastas: ATIVOS > USUARIOS > PESSOAS, mas quando você utiliza um utilitário chamado ADSI (que está lá instalado no Active Directory) o programa te dá o caminho escrito ao contrário, portanto será assim mesmo, de trás de frente que você irá escrever na configuração do GitLab.


base: 'OU=PESSOAS,OU=USUARIOS,OU=ATIVOS,DC=dominio,DC=central'

Para entrar no aplicativo ADSI você deve seguir o caminho abaixo.

E para localizar o caminho dos seus usuários siga a árvore até ela lhe mostrar por completo.


Sobre o atributo bind_dn:

Uma das coisas que me confundiu bastante foi o fato de nessa configuração do Gitlab eu não ter de colocar o login do meu usuário administrador, mas sim o nome dele. Portanto preste atenção a isso porque meu usuário tem login jair.rodrigues, mas seu nome é Jair Rodrigues lá no AD.


bind_dn: 'CN=Jair Rodrigues,CN=Users,DC=dominio,DC=central'

Comandos úteis para ocasiões inesperadas ou desesperadas

Para caso você precise consultar as informações sobre sua versão do GitLab instalada


gitlab-rake gitlab:env:info

Para editar o arquivo de configuração do GitLab


nano /etc/gitlab/gitlab.rb

Para reconfigurar seu GitLab logo após ter editado o arquivo de configuração acima

gitlab-ctl reconfigure

Para reiniciar o serviço do Gitlab logo após tê-lo reconfigurado

service gitlab-runsvdir restart

Para abrir um console rails no intuito de alterar alguns parâmetros

gitlab-rails console

Para abrir um console rails e desbloquear um usuarío (o usuário pode ser bloqueado no GitLab após tentar logar digitando a senha errada repetidamente)

gitlab-rails console
user = User.find_by_email("myuser@example.com")
user.state = "active"
user.save
exit

fonte: http://matigado.wordpress.com

fonte: https://forum.gitlab.com/t/how-to-reset-the-admin-password-via-the-rails-console/223

fonte: https://gitlab.com/gitlab-org/gitlab-ce/issues/13179

fonte: https://www.vivaolinux.com.br/artigo/Instalacao-do-Gitlab-e-introducao-ao-Git?pagina=3

fonte: http://blog.dimaj.net/content/updated-howto-enable-ldap-filters-gitlab

Salva Vidas básico do Git (me ajude a entender git por favor!)

Hello!

Hoje vou deixar alguns comandos básicos do git para iniciantes e para caras como eu (iniciantes também).

Para quem não sabe, o Git é um versionador que controla a versão das coisas que você faz. E quando eu digo coisas, digo que não é somente códigos fonte de linguagens que estão sendo colocados, pois colocamos quaisquer tipos de arquivos aí dentro.

fonte: https://mastigado.wordpress.com

Este tutorial básico estava meio encostado e com o nome de “Comandos básicos do Git”, porém resolvi mudar por conta da necessidade que tive de trabalhar não apenas com os comandos básicos, mas também os passo a passo básicos e quando utilizá-los. Por isso listei-os abaixo da melhor forma que encontrei.

Vale deixar aqui registrado que este tutorial deverá aumentar de tamanho por conta de atualizações constantes que farei e quando achar que tá de bom tamanho retirei esta frase daqui.  Por enquanto é isso, pode esperar que tem mais.

Índice:

Preferencialmente para você que não sabe nada de git comece por aqui

Esclarecimentos básicos antes de você começar mesmo sem saber nada

Estrutura básica de um repositório git

Tente imaginar essa estrutura como camadas, andares de um prédio ou basicamente uma fase, estado ou um estágio que está acontecendo no momento.

– Quando você acabou de efetuar o comando git init, você acabou de criar um repositório e seus arquivos estão ali esperando serem versionados, eles são chamados nesse estado de untracked files. Você está no conhecido working directory (diretório de trabalho).

– Quando você executa o comando git add . (tem esse “.” aí mesmo) está querendo dizer que está retirando os seus arquivos de um working directory e passando para uma staged area.

– E para este último dizemos que quando você executa o comando commit -m “Meu Primeiro Commit” está retirando os seus arquivos de sua staged area e os colocando numa espécie de fichamento ou se assim posso dizer “uma marcação” daqueles arquivos que você separou com o comando git add . e que depois os colocou dentro de uma caixa de papelão com uma etiqueta chamada de “Meu Primeiro Commit”, lacrou e guardou lá no seu depósito. Ou melhor ainda, você acabou de criar uma versão destes arquivos que você marcou com o comando add e que depois executou o commit.

Contudo por conta deste último ítem veja bem, apesar de a grosso modo estarem “guardados”, estes arquivos continuam sempre no mesmo lugar desde o princípio onde sempre estiveram, eles apenas mudam de estado. Para transferir para a nossa realidade é como se você numa hora estivesse com febre, depois estivesse com a temperatura corporal normalizada, depois cansado após uma longa caminhada, depois dormindo e por aí vai, você sempre estará no planeta terra (seu planeta seria seu repositório git), mas o seu estado vez ou outra alternará.

Agora sim iniciaremos.

A – Comandos básicos de configuração do gitVoltar ao início

A-01 – Antes de começarmos a utilizar o git façamos as configurações globais locais.

Mas ainda antes, deixarei uma observação feita na documentação oficial do Git sobre configurações locais.

Caso você queira sobrepor estas com um nome ou endereço de e-mail diferentes para projetos específicos, você pode executar o comando sem a opção –global quando estiver no próprio projeto.

Repare que risquei o termo globais no título porque tive problemas ao tentar sobrepor estas configurações quando precisei utilizar múltiplos contextos do Git (explico melhor sobre o assunto adiante) e por isso somente recomendo utilizar configuração de repositório local. Portanto agora sim, prossiga.

O user name:


git config --local user.name "Meu Lindo Nome"

A-02 – E o email:


git config --local user.email meulindoemail@centraldeemailslindos.com

B – Criando um repositório local com o intuito de versioná-lo em um repositório remoto que já existeVoltar ao início

B-01 – Para iniciarmos o repositório que queremos trabalhar e depois empurrá-lo para nosso servidor git, primeiramente devemos iniciar o nosso repositório git. Por ora saberemos também que será criada a nossa branch master (mais à frente veremos o que são branches, como utilizar mais de uma ao mesmo tempo e o que você ganha fazendo isso).

git init

B-02 – Adicione a origem de seu repositório remoto que irá utilizar. Provavelmente este repositório remoto lhe informará qual o comando correto para você adicioná-lo e você vai ter de se informar sobre isso. Para te ajudar coloquei dois comandos abaixo de como podem se parecer.


git remote add origin https://github.com/blogmastigado/projetoandroid.git


git remote add origin ssh://github.com/blogmastigado/projetoandroid.git

B-03 – Depois de criado, podemos ver o que tem (e como está) dentro de nosso repositório como o comando abaixo.

git status

O comando git status nos mostra:

Mostra quais são os arquivos que estão fora do controle de versão do git (untracked files).

B-04 – Para adicionar os arquivos em meu controle de versão para que passem a ser “versionados” utilizamos o comando git add (git add nome_do_arquivo_a_ser_versionado). Com este comando, você adiciona as pastas que deseja ao controle de versão. Porém se você digita .(espaço e ponto) após o comando, ele pega tudo que está dentro do diretório em que você está se encontra no momento.

O git add significa que os seus arquivos estão preparados para serem comitados e ao invés de os arquivos estarem listados como untracked files, serão listados como new file(novo arquivo).

git add .

Se você der o comando git status (novamente) depois de git add, ele mudará de estado para mostrar os arquivos que estão para serem comitados.

B-05 – Commit! Logo após que você adiciona os seus arquivos para serem “comitados” com o comando git add é hora de utilizar o comando commit:


git commit -m "O meu primeiro commit no git"

E por que fazer o commit?

Toda a vez que você altera um arquivo, você “comita”, ou seja, você grava aquela versão.
Quando você digita git commit -m, você está informando que vai deixar uma mensagem de identificação sobre a versão que você está gerando.

Após executar o comando, ele irá gerar um código para este seu commit(algo como: master (root-commit) 4d68ec3] “O meu primeiro commit no git”).

Você também pode dar um git status para ver como as coisas estão saindo. Possivelmente ele irá dizer que não será preciso fazer mais nada porque tudo o que foi marcado para ser “comitado”, já foi comitado.

B-06 – E para colocar os meus arquivos lá no meu servidor git remoto?

Para empurrar os arquivos versionados pelo meu commit anterior utilizo-me dos comandos abaixo.

git push -u origin master

Caso Problemas de autenticação com erro 403

Repare que pode existir endereço com https ou http, porém as vezes você pode ser supreendido com um erro do tipo “remote: Access denied” junto com “The requested URL returned error: 403”.
Para resolver este tipo de problema alguns indicam seguir no diretório/caminho .git/config que está dentro da raiz do seu projeto git, abra o arquivo config e altera o parâmetro http ou https do atributo url para ssh, depois salve, feche o arquivo e tente novamente enviar para o servidor remoto.

CO que são branches e para que precisamos gerenciá-las! – Voltar ao início

Até agora só trabalhamos com uma branch chamada de master e ela é praticamente a branch padrão que todo repositório git cria quando ele é iniciado com o comando git init. Por vezes trabalhamos em equipe e deixar que todos modifiquem o mesmo código pode dar problema e por isso criamos outra branch além da master e precisamos gerenciá-las.

Gerenciar branches é necessário quando se trabalha em equipe porque cada um costuma ter uma responsabilidade distinta. E quando você cria uma branch você está dizendo que vai pegar tudo o que você fez naquela branch atual que está trabalhando (no nosso caso é a master) e colocar numa branch nova igualzinho, bonitinho e cheirozinho como já estava antes, sacou? Você faz um clone do estado atual de sua branch para uma outra e esse tipo de processo é o que chamamos de fork. E partir deste raciocínio você tem duas opções de começar a trabalhar em outra branch, são elas:

C-01 – A primeira opção é criarmos uma branch, mas você só consegue fazer isso se na sua branch atual já tiver adicionado alguns arquivos à sua staged área (se você não sabe o que é isso recomendo ler o tópico Estrutura básica do git logo no início deste tutorial) e logo em seguida ter dado um commit nesses arquivos. Então vamos lá, para criar uma branch executado o comando abaixo.


git branch novabranch

C-02 – A outra opção é você acessar um diretório remoto partindo do princípio que você seguiu os passos do item B-02 e adicionou um repositório remoto como a origin do nosso repositório git local. Portanto neste caso supomos que você tem uma branch neste repositório que você adicionou e queremos acessá-la. Para isso utilizamos o comando abaixo.

git checkout -b origin minhabranchremota

E em seguida pegar os arquivos contidos nela e trazer para o nosso repositório local.

git pull

C-03 – E para listar e trocar de branch?

Caso precisemos listar as branches que temos acesso localmente podemos utilizar do comando git branch. Desta forma:

git branch

Em seguida nos será listado as branchs que temos disponíveis. Algo como isso:

$ git branch
 master
* novabranc

ou

$ git branch
 master
* origin/minhabranchremota

E para trocarmos de branch utilizamos do comando git checkout nome_da_branch_que_quero_intercalar.

git checkout novabranch
git checkout minhabranchremota

D – Clonando repositórios remotos para trabalharmos em cima deles

Pois bem, sabe quando já criamos um repositório remoto e ele já contém algum arquivo lá dentro e queremos enviar nossas modificações para ele? Difícil né? Mais adiante falaremos sobre como mesclar, juntar, “merjar” essas diferenças entre o que está no nosso repositório local e o que foi colocado no repositório remoto após criarmos um repositório local sem antes ver o que já existia no remoto ou quando pegamos as últimas alterações de um remoto e nesse meio tempo alteramos ainda mais coisas lá no remoto enquanto ainda nem enviamos as alterações feitas no nosso repositório local. Então por ora iremos nos ater apenas a iniciar um repositório a partir de um clone de um remoto.

D-01 Quando formos começar a codificar algo a partir de um clone, esqueça as configurações iniciais do git, apenas utilize o comando para clonar o repositório e comece a trabalhar nele normalmente.

 
git clone https://github.com/blogmastigado/projetoandroid.git

E é isso.

DICAS DIVERSAS

Para caso aconteça um problema de autenticação (erro 403) seja nos repositórios do GitLab

01 – Verifique se já existe uma chave em seu SO.

Para Windows faça:

type %userprofile%\.ssh\id_rsa.pub

Ou pode utilizar o Git Bash no Windows, GNU/Linux, macOS, PowerShell:

type %userprofile%\.ssh\id_rsa.pub

O teste acima é meramente ilustrativo porque estou contando que esta chave já existe, por isso não vou deixar aqui como gerá-la (todas estas informações estão em http://seu_servidor_gitlab/help/ssh/README).

02 – Para copiar esta chave existente para o GitLab

No Windows:

type %userprofile%\.ssh\id_rsa.pub | clip

No Mac OS:

pbcopy &lt; ~/.ssh/id_rsa.pub

No GNU/Linux (requer que o pacote xclip esteja instalado):

xclip -sel clip &lt; ~/.ssh/id_rsa.pub

Para o Git Bash no Windows / Windows PowerShell:

cat ~/.ssh/id_rsa.pub | clip

03 – Depois siga para o Gitlab

Após executado os comandos acima siga para o Gitlab, Profile e Keys. Cole a chave lá e clique em Add Key.
Se ainda tiver problema no seu repositório, readicione-o com as informações contidas em seu repositório remoto no Gitlab.

Para apagar algumas configurações globais que podem te atrapalhar quando você trabalha com múltiplos contextos

Pois bem, por vezes trabalhamos com múltiplos contextos de git (mais precisamente múltiplas contas de email) e nessas horas podemos esbarrar em problemas de autenticação ao fazer push (unable to access, The requested URL returned error: 403) mesmo com o nosso repositório estando com configurações locais corretas. Então neste caso você pode executar os comandos abaixo.

Este primeiro para indicar que queremos que o usuário utilize-se apenas das configurações locais.

git config --global user.useConfigOnly true

A segunda para limpar as configurações globais se existirem

git config --global --unset user.name
git config --global --unset user.email

A terceira será para limpar as informações de credenciais globais guardadas

git config --global --unset credential.helper

E por fim, a última é para apagar as informações de credenciais contidas no sistema (este comando realmente resolveu meu problema), só que para executar este comando você deverá estar logado no Git Bash como usuário administrador.

git config --system --unset credential.helper

Pronto. Agora é só executar o git push normalmente que provavelmente será pedido login e senha.

Para listar as configurações do Git

 
git config --list

Ou

 
git config --list --show-origin

Lembrando que a parte das configurações locais listadas estão contidas no arquivo .git/config que está dentro do seu repositório local e portanto também podem serem editadas por um editor de texto como um Notepad.

Para checar a versão do seu Git

 
git --version

Para visualizar informações de seu repositório remoto

 
git remote -v 

Para remover o repositório origin

 
git remote remove origin 

Para armazenar suas credenciais de repositório

Digite o comando para armazenar a credencial localmente e depois para enviar os arquivos para o repositório remoto.

 
git config credential.helper store
git push http://example.com/repo.git 

Em seguida serão pedidos usuário e senha para seu repositório remoto apenas uma vez.

 
Username: <digite seu username>
Password: <digite seu password>

Para reconfigurar a url do seu repositório remoto

 
git remote set-url origin https://github.com/blogmastigado/projetoandroid.git

Para armazenar configurações de credenciais por um tempo definido

No caso abaio irá armazenar por 60 minutos.

 
git config credential.helper 'cache --timeout=3600'

Para forçar o envio do repositório local à sua origin

git push -u --force origin master

Para descobrir o local onde está o arquivo de configuração global

No Windows 7 comumente no caminho abaixo.

C:\Users\MyLogin\.gitconfig

Ou você pode executar o comando abaixo e observar onde está localizado o arquivo .gitconfig

git config --list --show-origin

A respeito deste comando (–force)

Em virtude do erro: “! [rejected] master -> master (fetch first) error: failed to push” é provável que o comando push não seja o adequado no momento.
A resposta está lá, o git está dizendo para você buscar primeiro (primeiro o pull). Provavelmente alguém mais já enviou para a origin (fez o push). Consequentemente você tem que buscar (fazer o pull), mesclar o changeset (fazer o merge), daí você poderá empurrar (fazer o push) outra vez.
Se você não conseguiu fazer normalmente o push e “forçou a barra para fazer” (se fizer usando a opção –force), você pode estragar o histórico de alterações (na verdade provavelmente você irá estragar esta linha do tempo).

Para maiores detalhes você pode consultar este post do StackOverflow que foi de onde retirei esta bela explicação sobre o uso forçar o push em um repositório.
fonte: http://stackoverflow.com/questions/28429819/rejected-master-master-fetch-first

Essa fonte abaixo foi uma das minhas fontes de inspiração e meu ajudou muito (dêem uma força para o canal do RB Tech)
fonte: https://www.youtube.com/playlist?list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0

fonte: https://mastigado.wordpress.com

fonte: https://blog.da2k.com.br/2015/02/04/git-e-github-do-clone-ao-pull-request/

fonte: https://git-scm.com/book/pt-br/v1/Git-Essencial-Obtendo-um-Reposit%C3%B3rio-Git

fonte: https://git-scm.com/book/pt-br/v2/Git-Branching-Branch-Management

fonte: https://git-scm.com/book/pt-br/v1/Primeiros-passos-Configura%C3%A7%C3%A3o-Inicial-do-Git

fonte: https://git-scm.com/docs/git-credential-store

fonte: https://collectiveidea.com/blog/archives/2016/04/04/multiple-personalities-in-git

fonte: https://stackoverflow.com/questions/15381198/remove-credentials-from-git

fonte: https://stackoverflow.com/questions/2114111/where-does-git-config-global-get-written-to

Instalar e configurar Spark e OpenFire 4.1.3 no Debian Linux com integração no AD do Windows utilizando SQL Server 2008 R2

Olá pessoal

Tendo observado que a maioria das pessoas que entram no blog querem saber como instalar o OpenFire 4.1.3 com integração no AD. Pois bem, vou tentar ser mais objetivo para aqueles que estão tendo dificuldade em instalar e integrá-los.

ESCLARECIMENTO SOBRE ESTE POST(LEIA ANTES DE TUDO).

  1. Quando você tiver instalado e integrado ao AD o seu OpenFire, não existirá mais a necessidade de adicionar usuários e grupos manualmente dentro do Spark, a partir daí, você precisará apenas criar um usuário no AD e colocá-lo no grupo spark. Somente isso bastará para aparecerem listados todos os usuários no Spark de todos os clientes.
  2. Leia devagar e com atenção o passo a passo para a instalação até o 18º ítem que dará tudo certo, pois detalhei muito bem. Devagar, por favor.
  3. Logo após o passo a passo, eu marquei de vermelho todos os ítens que considero fundamentais para o pós-instalação, então por favor novamente, leia-os com atenção. Se surgiu alguma dúvida no meio do caminho, leia até o final porque talvez posso tratá-la mais abaixo.

Hoje vamos configurar um servidor de mensagens instantâneas de nome OpenFire no Linux Debian 8.7.1

fonte: https://mastigado.wordpress.com

1º – Instalaremos o arquivo executável do OpenFire(não importa a versão). Baixamos o arquivo do site ;

Arquivo executável do OpenFire

2º – E no terminal do Linux, vamos até onde o executável está.

3º – Pelo fato de poder aparecer algum erro do tipo “java7-runtime-headless não está instalado”, instalaremos o pacote abaixo.

apt-get install default-jdk

4º – Em seguida executamos o comando para instalarmos o pacote Debian do Openfire.

dpkg -i openfire_4.1.3_all.deb

5º – Agora daremos início a nossa instalação pela web. Siga no navegador e digite http://o_ip_do_seu_servidor_onde_sera_instalado_o_openfire:9090 e veremos algo para já configurarmos a linguagem da aplicação.

6º – Agora, configuraremos o nosso domínio. No nome do Domínio o correto é ficar com empresa.local (que seria o nome do meu domínio) e no Server Host Name (FQDN) eu voltei atrás e coloquei o ip do meu servidor Linux, pois também funciona e é mais garantido quando você não tem um servidor que “resolve” os nomes de servidores Linux em sua rede.

Quanto as portas, só convém mudar se já existir algum serviço as utilizando neste host. Você também tem a opção de nessa versão definir o tipo de criptografia que irá usar, porém por enquanto eu não irei trabalhar com isso.

OpenFire configuração de domínio

7º – Agora, a conexão com os dados no OpenFire poderá ser feita por um banco de dados externo ou interno, contudo vou deixar minha impressão a respeito do banco de dados interno.

Minha primeira instalação do OpenFire foi utilizando seu próprio banco de dados e não tive uma boa experiência porque ao terminar a instalação, simplesmente não consegui me logar na área administrativa do OpenFire por conta, julgo eu, de um bug. Pesquisei na net sobre isso e descobri que na versão 3.7.0 existia sim este bug, mas que nesta versão que estou instalando(4.1.3) acredito que tenham corrigido.

Ainda pesquisando na net, descobri um site que ensinava uma maneira de corrigir este bug de não conseguir conectar o banco interno após a instalação(http://red5guide.com/install_openfire_on_windows_server.html#openfirepassword), só que ao ler o guia, percebi que eu tinha que ter acesso a base de dados do OpenFire para dar um UPDATE em tabela de usuário e não achei muito simples ou possível fazer isso utilizando o banco de dados interno, por isso optei por utilizar um externo. Mas quero deixar claro que não significa que não irá funcionar utilizando o interno, mas este tutorial irá tratar especificamente de conexão com um externo.

Seguindo então na primeira opção, Conexão Padrão do Banco de Dados.

Conexão com banco de dados no OpenFire

8º – Aqui abaixo tenho a opção de escolher vários bancos, mas neste caso aqui iremos apenas escolher o Microsoft SQL Server e efetuar uma pausa na instalação para podermos configurar o nosso banco de dados.

Tipo de Banco de Dados

9º- (importante) Agora faremos a configuração da nossa base de dados no SQL Server, porém antes crie um grupo no Active Directory (AD) com o nome que desejar dentro do diretório Users. Eu escolhi o nome spark para forçar quem for criar usuários no AD, lembrar que sempre devem acrescentar este grupo ao usuário.

Entenda que a criação deste grupo é para se ter a opção de controle de usuários que podem e que não podem ter acesso para utilizar o Spark, Pandion, Pidgin, etc (clientes de mensagens local) no servidor Openfire que estamos criando. Enfim, se desejar segregar alguém, não acrescente este grupo ao usuário que você acha que não deve bater papo com ninguém.

Criação de Grupo no AD

10º – Criei um usuário no AD que é membro dos grupos Administrators, Domain Admins, Domains Users e claro, também o tornei membro do grupo spark. Fiz um usuário neste nível porque não quis misturar o usuário administrador do AD utilizado por usuários avançados com o específico deste sistema que estamos instalando, até porque ele será utilizado mais adiante algumas vezes.

Criação de Usuário Administrador de AD

11º – E para quem não manja muito de SQL Server, abaixo descrevo como criei o banco.

Para criar uma nova base de dados, dentro do gerenciador de banco de dados SQL Server Management Studio, clique com o botão direito em cima de Databases e em seguida, New Database. Dei o nome de SPARKDB para a database , coloquei o banco inicial com 200 megabytes (uns vão achar que é muito, mas deixei assim mesmo) e com Autogrowth ligado em 50%, que quer dizer que toda a vez em que ele atingir seu tamanho máximo (o tamanho inicial é de 200 megas), ele aumentará 50% deste tamanho automaticamente. Coloquei 50% para que a base não fique tão fragmentada no hard disk. Vale lembrar que estou me baseando numa base de dados de 200 usuários utilizando o Spark.

Observação 1: Em uma nova implantação que fiz chamei esta base de dados de OPENFIREDB ao invés de SPARKDB porque na época eu não sabia diferenciar Spark de Openfire por conta da confusão que meu chefe fazia ao chamar tudo de Spark. E enfim, acho que nomear o banco de dados como OPENFIREDB fica coerente. porém neste tutorial seguirei com o nome de SPARKDB mesmo.

Criação do banco de dados

12º – Ainda dentro do SQL Server Management Studio, em Security, clique com o botão direito e em seguida New Login. Em Login Name, utilizei o mesmo nome do usuário do AD, openfire e marquei SQL Server Authentication utilizando a mesma senha do usuário do AD para não me confundir depois, pois quando tentei com o do AD não consegui me logar no SQL Server.

Desmarquei todas as opções de verificações de senha.

E fiz uma alteração do default Database porque entendo que este usuário deve controlar apenas o seu banco, que no nosso caso é o SPARKDB.

Configuração de Usuário para conexão no SQL Server

13º – Na opção Server Role, marquei diskadmin para este usuário porque da última vez que não marquei, deu pau.

Regra do Servidor

14º – Em User Mapping, escolhi a base SPARKDB em específico e marquei db_owner para também colocar como dono daquele banco. E por último, cliquei em OK e a partir daí posso até fechar o SQL Server Management Studio.

User Mapping

15º – Até que enfim, voltei para este carinha aqui. No nosso caso escolhi o SQL Server, coloquei o usuário openfire do banco de dados e alterei a linha da URL do Banco de Dados de:

jdbc:jtds:sqlserver://[host-name]/[database-name];appName=jive

para:

jdbc:jtds:sqlserver://nomeservidor:1433/SPARKDB;appName=jive

Repare que utilizei a porta do SQL Server que é 1433 junto com o nome do servidor.

Configuração do acesso da aplicação ao banco de dados

16º – Nesta tela escolhi a opção que utiliza LDAP porque quero me conectar no AD.

Openfire LDAP

17º – Bem, aqui tem que ser:

O Tipo de servidor tem que ser Active Directory;

Em Host, o nome do seu host. Vale lembrar que apesar de o ip também funcionar aqui(eu acho), uma pessoa que trabalha com AD me orientou colocar o nome do host mesmo.

Na Porta, pode deixar este 389 aí.

DN Base. Este cara você vai colocar desta forma: se seu domínio é aeroporto.cumbica, coloque dc=aeroporto,dc=cumbica;

DN Administrador: O nome daquele usuário que criamos, no caso o openfire(preferencialmente) com o seu domínio. Então ficaria assim:

openfire@aeroporto.cumbica

Configuração da Conexão com o AD

18º – Neste passo, onde está definido sAMAccountName deixei como está, e mantive a sugestão que o servidor me trouxe basicamente no formato abaixo:

(&(objectCategory=person)(objectClass=user) (memberOf=CN=grupo_de_usuarios_do_ad_que_vao_utilizar_o_spark, CN=pasta_onde_esta_meu_usuario_admin_no_ad, DC=meu_dominio,DC=continuacao_do_nome_do_meu_dominio))

Depois, só mando testar as configurações e se estiver tudo ok, é exibida para mim uma tela com o resultado do teste. No meu caso ele trouxe um usuário do AD de forma aleatória e deverá fazer isso com você também.

Mapeamento de usuário

Teste de Conexão com mapeamento de usuário

Vale lembrar que agora você pode também personalizar os valores no seu cliente mensageiro inserindo ou alterando os valores que vem do AD. Você pode pesquisar na net por Active Directory Attributes e se orientar por quais você pode utilizar (https://msdn.microsoft.com/en-us/library/ms675090(v=vs.85).aspx).

19º – Este cara aí abaixo, eu fui orientado para ignorá-lo e passar batido e foi isso o que fiz.

Mapeamento de Grupo

18º – Neste último passo, configuro a conta do administrador(Fui colocando vários usuários do AD que achei que deveriam ser admins do OpenFire).

Conta do Administrador

Pronto! Agora tente se logar no OpenFire com os usuários admins que você criou.

Já sabe, se der pau no login, utilize o procedimento do site abaixo. Claro, depois de ter parado e reiniciado tanto o serviço do aplicativo, quanto o pc que está instalado.

http://red5guide.com/install_openfire_on_windows_server.html#openfirepassword

Para configurar os grupos do AD no seu OpenFire, clique no link abaixo.

https://mastigado.wordpress.com/2013/05/21/adicionando-seus-grupos-do-ad-no-openfire/

Para aumentar a quantidade de memória do seu OpenFire caso note que o serviço esteja travando(isso acontece quando se tem muitos usuários logados).

https://mastigado.wordpress.com/2013/01/25/aumentando-a-memoria-do-java-do-openfire/

Para gerenciar o OpenFire  siga os passos abaixo.

Quando você instala o OpenFire no Linux  ele já roda como um serviço e para gerenciá-lo utilize os comandos abaixo.

Em resumo seria algo assim:


//Para iniciar o serviço

/etc/init.d/openfire start

//Para reiniciar o serviço

/etc/init.d/openfire restart

//Para forçar um reload

/etc/init.d/openfire force-reload

Contudo, quando tentei parar o serviço não consegui. O comando abaixo não funcionou comigo.

/etc/init.d/openfire stop

Então, uma alternativa que encontrei para paralisar este serviço foi consultar o processo do Openfire com o comando abaixo.

ps -ef | grep openfire

E com o resultado identifiquei o PID dele (Process ID), que no meu caso foi o número 8683 que está logo abaixo no começo da primeira linha.

openfire 8683 1 0 15:29 ? 00:00:08 /usr/local/jdk1.8.0_121/bin/java -server -DopenfireHome=/usr/share/openfire -Dopenfire.lib.dir=/usr/share/openfire/lib -classpath /usr/share/openfire/lib/startup.jar -jar /usr/share/openfire/lib/startup.jar
root 8839 788 0 15:52 pts/0 00:00:00 grep openfire

E depois de identificado o PID matei o processo utilizando o comando kill.

kill 8683

E pronto, desta maneira o processo do Openfire está parado. E para subir novamente utilize-se dos comandos que citei anteriormente.

Para desinstalar o Openfire no Debian Linux.

Por vezes precisamos reinstalar o Openfire e temos problemas por conta dos arquivos de configuração que ele guarda. Então para resolver este problema utilizamos o comando abaixo.

apt-get --purge remove openfire

Para que o Spark na versão 2.8.3 conecte no Openfire 4

Esta versão do Openfire traz algumas  alterações em relação a versão 3. Uma delas é o fato de que o uso de certificados válidos é necessário para conexão entre cliente e servidor, fato que irá fazer com que você não consiga se conectar utilizando mesmo nova versão do Spark caso não tenha o ambiente adequado implantado.

Para resolver este problema abra o Spark, siga na guia avançado e marque as opções Disable certificate hostname verification (not recommended) e Accept all certificates (self-signed/expired/hot trusted) como na figura abaixo e pronto. Conecte-se ao servidor.

 

Para alterar as informações pessoais no client Spark.

Quando você se integra no AD, surge um pequeno incoveniente na hora de os usuários poderem alterar suas informações pessoais(nome, telefone, avatar, etc), pois tudo vem do Active Directory automaticamente a partir de então.

O usuário pode se deparar em sua tela com a mensagem abaixo ao tentar realizar qualquer alteração.

server does not support cards unable to save your vcard

Para resolver este pequeno problema, o 1º e o 2º passos são questionáveis e por isso, entendo que somente o 3º é necessário.

  1. Baixar o plugin LDAP Vcard(ldapvcardavatar.jar). Pelo que andei lendo, este plugin ainda está beta e em sua documentação ele diz para que você o utilize por sua conta e risco(depois que instalei e configurei, tive a certeza de ele é beta), mas acho que não temos muitas opções, não? Fui no endereço http://community.igniterealtime.org/docs/DOC-1350 e o baixei.
  2. Em seguida, instalei o “bicho” no servidor.

    Plugin LDAP Vcard para Openfire

    Plugin LDAP Vcard para Openfire

  3. Mas sinceramente, o plugin está em estado depreceated e por isso, você pode ir direto em em Propriedades do Sistema, que fica dentro de Gerenciamento do Servidor e alterar o parâmetro false para true do atributo ldap.override.avatar.

    Propriedades do Sistema

    Propriedades do Sistema

AGORA, DUAS DICAS VALIOSAS QUE SÓ APRENDI NA PORRADA

  1. Caso seus usuários, mesmo estando no grupo específico para o Spark ainda assim não estiverem aparecendo na lista de pessoas do cliente Spark, você deve colocar o seu grupo principal sendo como Domain/Users, no Active Directory, feito isso, estes usuários irão aparecer na lista de usuários do Spark normalmente.
  2. Caso precise adicionar ou retirar administradores do OpenFire, o local correto para se fazer isso quando integrado no AD é Servidor > Gerenciamento do Servidor > Propriedades do Sistema > admin.authorizedJIDs e em seguida, editar esta propriedade.

Tá aí então, mastigado.

Tutorial para instalação do plugin Jappix que é um client de conversação para a web (ainda não testei nessa nova versão de Openfire).

https://mastigado.wordpress.com/2013/01/08/instalar-client-web-jappix-no-openfire-para-bater-papo-usando-o-navegador/

Tutorial para instalação do aplicativo Xabber que é um client de conversação para a Android.

https://mastigado.wordpress.com/2015/10/07/instalar-xabberspark-no-android-para-se-conectar-no-openfire/

fonte: https://mastigado.wordpress.com

Criando instância de classe, método e variável a partir de uma string em PHP

Olá pessoal!

1:00h da manhã! Que delícia lutar contra o sono numa sexta a noite só para programar! Ah! Nossa, delicious : (

fonte: https://mastigado.wordpress.com

Pois bem, vou deixar uma dica aqui de como instanciar métodos, classes ou variáveis a partir de uma string em PHP. Sim, eu acredito que isso vá no mesmo conceito de Reflection, mas não será isso que irei abordar hoje.

Por hora vamos lá!

“Tempo de conversa fiada acabou!”

Para instanciar uma classe a partir de uma string:


$class = "MinhaClasse";
$objeto = new $class();

Para capturar o conteúdo de uma variável a partir de uma string (isso está cheirando a ponteiro)


$valorPersonalizado = 123;
$nomevariavel = 'valorPersonalizado';
echo $$nomevariavel; // echo's 123

Para gerar e chamar uma função a partir de uma string


$funcao = 'minha_funcao';
$funcao('parametro1'); // chama minha_funcao('parametro1');

Para gerar e chamar um método a partir de uma string


$metodo = 'facaAlgumaCoisa';
$objeto = new MinhaClasse();
$objeto->$metodo(); // executa o método facaAlgumaCoisa de MinhaClasse->facaAlgumaCoisa()

fonte: http://stackoverflow.com/questions/4578335/creating-php-class-instance-with-a-string

fonte: https://mastigado.wordpress.com

fonte: http://php.net/manual/en/language.variables.variable.php

Instalando e configurando o Composer com a PSR-4

What-is-PHP-Composer-

Olá pessoal!

Este post vai para quem tem dificuldade (assim como eu) em instalar e configurar o Composer com a PSR-4.

fonte: https://mastigado.wordpress.com

Para quem não sabe as “PSRs” do PHP são a grosso modo um conjunto de boas práticas para padronizar frameworks e acredito que também sirva para nossos próprios apps. Esse conjunto de PSRs foi criado por uma organização chamada PHP-FIG (http://www.php-fig.org/) e existem até hoje cerca de 18 delas.

Neste post trato especificamente de como configurar o Composer e a inserção da PSR-4 que é responsável pelo autoload dos arquivos do PHP. Este “autoload” é útil para que carreguemos nossos arquivos sem ter de ficar utilizando o método require_once ou require do PHP. E por que utilizar a PSR-4? Bem, a PSR-4 substituiu a PSR-0 que também é responsável pelo autoload dos arquivos, mas que entrou em estado deprecated.

Pois bem e o Composer? Bem, o Composer é um gerenciador de dependências do PHP que funciona como um gerenciador de pacotes, assim como o nuget do C#, o Apt do Debian, o Yum do Fedora/Cent-OS e por aí vai.

Download do Composer

Para baixarmos o Composer podemos seguir as orientações de seu próprio site no endereço https://getcomposer.org/download/ e seguir as instruções caso as que eu coloquei abaixo estejam desatualizadas, porém antes, execute as seguintes instruções enumeradas abaixo.

  1. Se estiver no Linux abra o terminal, entre na raiz de seu projeto (se for no Windows, tente usando o prompt);
  2. Crie um diretório com o nome public;
  3. Coloque seu arquivo index.php dentro deste diretório public;
  4. Ainda na raiz do projeto crie dois diretórios, um chamado de vendor e outro de app;
  5. Dentro do diretório vendor crie de preferência um diretório com o nome de sua instituição, pode ser minhaempresa (ou pense em outro nome que caracterize essa idéia);
  6. E dentro do diretório app crie uma classe chamada de Init.php com o conteúdo abaixo.

Init.php

<?php

namespace app;
class Init {

    public function __construct() {
       echo "Ok. It works!";
    }
}

E agora, dentro da pasta raiz de seu projeto, execute as linhas abaixo no terminal (uma de cada vez). Lembrando que o comando php no início de cada linha está pressupondo que você já tem o seu diretório mapeado no PATH de sua máquina (se você não sabe o que é PATH, recomendo ler este post que fiz sobre isso e outro post que fiz sobre como configurá-lo), caso contrário escreva o caminho completo antes de executar o comando (no Linux pode ser algo assim: /opt/php7/bin/php e no Windows algo como isto: C:\Xampp\PHP7\bin\php.exe).

   php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
   php composer-setup.php
   php -r "unlink('composer-setup.php');"

Arquivo composer.json

Vou deixar algumas observações sobre o conteúdo deste arquivo que servirá de base para a configuração do Composer.

Basicamente esta área abaixo está reservada para que você defina a partir de qual versão do PHP será instalada em sua máquina, quais serão os pacotes que são requeridos na instalação e o mínimo de tipo de versão aceitável do aplicativo.

    "name": "meuapp",
    "require": {
       "php": ">=7.0.5"
    },
    "require-dev": {
       "phpunit/phpunit": "5.7@stable",
       "squizlabs/php_codesniffer": "dev-master"
    },
    "minimum-stability": "alpha",

Já a área onde tratamos da PSR-4, responsável pelo carregamento da estrutura de arquivos de nossa aplicação terá este raciocínio:

A raiz do meu projeto PHP é composta por um diretório que se chama meuapp e lá dentro tenho as pastas app, public e vendor, sendo que  dentro de vendor tenho um diretório chamado de minhaempresa. Portanto quando defino o mapeamento das minhas classes na definição da PSR-4 sempre tenho que me referir ao que está dentro da raiz de meu projeto (no caso a pasta meuapp).  Na primeira linha de mapeamento (do script abaixo) deixei o código assim: “minhaempresa\” : “vendor/minhaempresa” porque estou dizendo que quero mapear a pasta minhaempresa que está no caminho vendor -> minhaempresa e que por consequência está dentro de meuapp, contudo para ser mais específico, o mapeamento omite a pasta meuapp na nomenclatura, mas na prática ele quer dizer isso: meuapp/vendor/minhaempresa. O mesmo raciocínio se aplica para a linha de mapeamento do diretório app que em outras palavras que dizer meuapp/app. Tenham bastante atenção nisso, pois é algo simples que me fez perder um tempo considerável para entender (2 dias refletindo sob o calor da rua e do altamente gelado ar condicionado do meu serviço) , então se alguém tiver dúvida poste aqui.


      "autoload": {
         "psr-4": {
            "minhaempresa\\" : "vendor/minhaempresa",
            "app\\" : "app"
         }
      },

Agora, o próximo passo é criar na raiz de sua aplicação um arquivo chamado composer.json e coloque dentro dele o conteúdo abaixo.

{
      "name": "meuapp",
      "require": {
         "php": ">=7.0.5"
      },
      "require-dev": {
         "phpunit/phpunit": "5.7@stable",
         "squizlabs/php_codesniffer": "dev-master"
      },
      "minimum-stability": "alpha",
      "authors": [{
         "name": "Minha Empresa",
         "email": "developer@minhaempresa.com.br"
      }],
      "autoload": {
         "psr-4": {
            "minhaempresa\\" : "vendor/minhaempresa",
            "app\\" : "app"
         }
      },
      "config": {
         "bin-dir": "bin"
      }
}

Sobre o arquivo composer.phar

Após baixado o Composer, um arquivo de nome composer.phar é criado e é ele que iremos executar para a configuração do composer

   php composer.phar install

Os comandos abaixo são opcionais, portanto não precisam ser executados

   php composer.phar install --no-plugins --no-scripts ...
   php composer.phar update --no-plugins --no-scripts ...

Conteúdo do arquivo index.php

Dentro do arquivo index.php você deverá colocar o conteúdo abaixo:

<?php
   require_once '../vendor/autoload.php';
   use app\Init;
   $init = new Init;

A partir de uma única chamada para o arquivo autoload.php feita no index.php não precisaremos mais utilizar o comando require_once em nenhum lugar de nosso app quando precisarmos instanciar alguma classe ou outro contido na definição da PSR-4 no arquivo composer.json.

E para finalizar, execute o servidor PHP embutido (dentro do diretório onde está o seu arquivo index.php) que você já tem na sua instalação do PHP.

Se estiver rodando na máquina local use este comando:

    php -S 127.0.0.1:8080

Senão, coloque o ip dela, execute e acesse de outra máquina.

   php -S 192.168.92.128:8080

O resultado tem que ser a impressão na tela da mensagem contida no construtor da classe Init.

Pronto! Tá aí mastigado.

fonte: https://mastigado.wordpress.com

fonte: https://getcomposer.org/doc/04-schema.md

fonte: http://pt.stackoverflow.com/questions/19200/composer-autoload-e-psr-0-vs-psr-4

fonte: http://www.douglaspasqua.com/2015/01/26/php-autoload-psr-4psr-0-com-composer/

fonte: https://getcomposer.org/doc/01-basic-usage.md

fonte: https://seld.be/notes/psr-4-autoloading-support-in-composer

fonte: https://github.com/pavlakis/psr4-with-composer

fonte: http://www.php-fig.org/psr/psr-4/meta/

fonte: https://seld.be/notes/psr-4-autoloading-support-in-composer

fonte: https://getcomposer.org/doc/faqs/how-to-install-untrusted-packages-safely.md

//PSR-4 com Testes

fonte: http://culttt.com/2014/05/07/create-psr-4-php-package/

%d blogueiros gostam disto: