port4me

PORT4ME - Obtenha a mesma porta TCP pessoal e pessoal repetidamente

A ferramenta Port4me :

• encontra uma porta TCP gratuita em [1024.65535] que o usuário pode abrir

• foi projetado para funcionar em ambientes multiusuário

• fornece usuários diferentes, portas diferentes

• dá ao usuário a mesma porta ao longo do tempo com alta probabilidade

• fornece portas diferentes para diferentes ferramentas de software

• não requer configuração

• pode ser reproduzido perfeitamente em todos os sistemas operacionais e em todas as linguagens de programação comuns

• Disponível para Bash, Python e R

Introdução

Existem muitas ferramentas para identificar uma porta TCP gratuita, onde a maioria delas retorna uma porta aleatória. Embora funcione tecnicamente, pode adicionar um pouco de atrito se um novo número de porta aleatório precisar ser inserido pelo usuário cada vez que precisar usar uma ferramenta específica.

Por outro lado, o Port4me tenta, com alta probabilidade, fornecer ao usuário a mesma porta a cada vez, mesmo quando usada em dias diferentes. Ele alcança isso digitalizando a mesma sequência determinística e pseudo-aleatória de portas e retorna a primeira porta livre detectada. Cada usuário recebe sua própria sequência de porta aleatória, reduzindo o risco de dois usuários solicitarem a mesma porta. A aleatoriedade é iniciada com uma semente aleatória que é uma função do nome do usuário ( USER ) e, opcionalmente, o nome do software em que usamos a porta.

O algoritmo PORT4ME pode ser implementado nas linguagens de programação mais conhecidas, produzindo seqüenciamento perfeitamente reproduzível, independentemente da linguagem de implementação.

Uma introdução rápida

Supondo que estamos conectados como usuário alice em um shell Bash, chamando port4me sem argumentos nos dá uma porta gratuita:

{alice}$ port4me
30845

Como veremos mais adiante, é provável que cada usuário do sistema obtenha sua própria porta exclusiva. Por esse motivo, pode ser usado para especificar uma porta que alguma ferramenta de software deve usar, por exemplo

{alice}$ jupyter notebook --port " $( port4me ) "

Enquanto esta porta estiver disponível, alice sempre obterá a mesma porta nas sessões de shell e com o tempo. Por exemplo, se eles voltarem na próxima semana e novamente novamente, é provável que ainda recebam:

{alice}$ port4me
30845
{alice}$ port4me
30845

No entanto, se a porta 30845 já estiver ocupada, a próxima porta na sequência pseudo-aleatom é considerada, por exemplo

{alice}$ port4me
19654

Para ver as cinco primeiras portas digitalizadas, execute:

{alice}$ port4me --list=5
30845
19654
32310
63992
15273

Sequência de porta específica para o usuário, determinística e pseudo-aleatom

Essa sequência aleatória é iniciada por uma semente aleatória que pode ser definida através do código de hash de uma corda de semente. Por padrão, é baseado no nome do usuário atual (por exemplo, variável de ambiente $USER ). Por exemplo, quando o usuário bob usa a ferramenta port4me , eles vêem outro conjunto de portas sendo digitalizadas:

{bob}$ port4me --list=5
54242
4930
42139
14723
55707

Para fins de teste e demonstração, pode -se emular outro usuário especificando --user , por exemplo

{alice}$ port4me
30845
{alice}$ port4me --user=bob
54242
{alice}$ port4me --user=carol
34307

Portas diferentes para diferentes ferramentas de software

Às vezes, um usuário gostaria de usar duas ou mais portas ao mesmo tempo, por exemplo, uma porta para o RStudio Server e outra para o Jupyter Notebook. Nesse caso, eles podem especificar a opção --tool , o que resulta em uma sequência de porta exclusiva do usuário e da ferramenta. Por exemplo,

{alice}$ port4me
30845
{alice}$ port4me --tool=rstudio
22486
{alice}$ port4me --tool=jupyter-notebook
29525

Por conveniência, se a primeira opção não for identificada, assume -se que especifica a opção --tool . Isso significa que também podemos usar o seguinte formulário de classificação:

{alice}$ port4me jupyter-notebook
47467

Isso nos permite obter portas diferentes para diferentes ferramentas de software, por exemplo

{alice}$ rserver --www-port " $( port4me rstudio ) "

e

{alice}$ jupyter notebook --port " $( port4me jupyter-notebook ) " 

Evite usar portas comumente usadas em outros lugares

Como existe um conjunto limitado de portas disponíveis (1024-65535), sempre existe o risco de outro processo ocupar qualquer porta. Quanto mais usuários houver na mesma máquina, maior o risco é que isso aconteça. Se um usuário tiver azar, pode experimentar isso com frequência. Por exemplo, alice pode achar que a primeira porta (30845) funciona apenas uma saída 10 vezes, a segunda porta (19654) funciona 99 fora 100 vezes, e o terceiro (32310) funciona raramente. Nesse caso, eles podem optar por excluir as portas com maior probabilidade de serem ocupadas especificando-as como um valores separados por vírgula via opção --exclude , por exemplo,

{alice}$ port4me --exclude=30845,32310
19654

Uma alternativa para especificá-los por meio de uma opção de linha de comando é especificá-los através da variável de ambiente PORT4ME_EXCLUDE , por exemplo,

{alice}$ PORT4ME_EXCLUDE=30845,32310 port4me
19654

Para definir isso permanentemente, anexar:

 # # port4me customization
# # https://github.com/HenrikBengtsson/port4me
PORT4ME_EXCLUDE=30845,32310
export PORT4ME_EXCLUDE

Para o script de inicialização do shell, por exemplo ~/.bashrc .

Isso aumenta as chances de o usuário acabar com a mesma porta ao longo do tempo, o que é conveniente, porque eles podem reutilizar a mesma chamada, que está disponível no histórico da linha de comando, cada vez sem precisar alterar o parâmetro da porta.

A variável de ambiente PORT4ME_EXCLUDE deve ser usada pelo usuário individual. Para especificar um conjunto de portas a serem excluídas independentemente do usuário, defina PORT4ME_EXCLUDE_SITE . Por exemplo, o administrador de sistemas pode optar por excluir um conjunto adicional de portas adicionando o seguinte ao arquivo /etc/profile.d/port4me.sh :

 # # port4me: always exclude commonly used ports
# # https://github.com/HenrikBengtsson/port4me

PORT4ME_EXCLUDE_SITE=

# # MySQL
PORT4ME_EXCLUDE_SITE= $PORT4ME_EXCLUDE_SITE ,3306

# # ZeroMQ
PORT4ME_EXCLUDE_SITE= $PORT4ME_EXCLUDE_SITE ,5670

# # Redis
PORT4ME_EXCLUDE_SITE= $PORT4ME_EXCLUDE_SITE ,6379

# # Jupyter
PORT4ME_EXCLUDE_SITE= $PORT4ME_EXCLUDE_SITE ,8888

export PORT4ME_EXCLUDE_SITE

Além das portas excluídas por mecanismos acima, o Port4Me exclui as portas que são consideradas inseguras pelos navegadores da Web Chrome e Firefox. Esse comportamento pode ser controlado pela variável de ambiente PORT4ME_EXCLUDE_UNSAFE , que padroniza para {chrome},{firefox} . Token {chrome} se expande para o valor de PORT4ME_EXCLUDE_UNSAFE_CHROME , que padroniza o conjunto de portas que o Chrome bloqueia e {firefox} se expande para o valor do PORT4ME_EXCLUDE_UNSAFE_FIREFOX .

Analogamente para excluir um conjunto de portas, pode-se limitar o conjunto de portas a serem digitalizadas especificando a opção de linha de comando --include , por exemplo,

{alice}$ port4me --include=2000-2123,4321,10000-10999
10451

onde o padrão corresponde a --include=1024-65535 . Analogamente a --exclude , --include pode ser especificado através de variáveis ​​de ambiente PORT4ME_INCLUDE e PORT4ME_INCLUDE_SITE .

Digitalize um conjunto predefinido de portas antes de pseudo-aleatom

Além de digitalizar a sequência de portas pseudo-aleatória específica do usuário para uma porta gratuita, é possível considerar também um conjunto predefinido de portas antes das aleatórias, especificando a opção de linha de comando --prepend , por exemplo,

{alice}$ port4me --prepend=4321,11001 --list=5
4321
11001
30845
19654
32310

Uma alternativa para especificá-los por meio de uma opção de linha de comando é especificá-los através da variável de ambiente PORT4ME_PREPEND , por exemplo,

{alice}$ PORT4ME_PREPEND=4321,11001 port4me --list=5
4321
11001
30845
19654
32310

A variável de ambiente PORT4ME_PREPEND deve ser usada pelo usuário individual. Para especificar um conjunto de portas a serem antecipadas, independentemente do usuário, defina PORT4ME_PREPEND_SITE .

Dicas e truques

Todas as implementações da porta 4ME produzem a porta identificada para saída padrão (STDOUT). Isso facilita a captura de métodos de shell padrão, por exemplo, port="$(port4me)" . Se você quiser ver qual número da porta foi gerado, use tee para enviar a porta também para o erro padrão (STDERR), que pode ser visto no terminal. Por exemplo,

{alice}$ jupyter notebook --port " $( port4me --tool=jupyter-notebook | tee /dev/stderr ) "
29525

Instalação

Bash, ferramenta de linha de comando

Para instalar a versão Bash do PortMe , faça:

VERSION=0.7.1
curl -L -O https://github.com/HenrikBengtsson/port4me/archive/refs/tags/ " ${VERSION} .tar.gz "
tar -x -f " ${VERSION} .tar.gz "
export PREFIX=/path/to/port4me/   # # must be an absolute path to a folder
(cd " port4me- ${VERSION} /bash " ; make install)

Em seguida, execute -o como:

$ export PATH=/path/to/port4me/bin: $PATH
$ port4me --version
0.7.1

Pacote r

Para instalar o pacote R PortMe , disponível em Cran, ligue para o seguinte de dentro de R:

install.packages( " port4me " )

Para experimentar, ligue:

 > port4me :: port4me( " jupyter-notebook " )
[ 1 ] 47467

ou

$ Rscript -e port4me::port4me jupyter-notebook
29525

Pacote python

A porta do pacote Python está disponível Pypi. Para instalar o pacote Python PortMe na sua biblioteca de pacotes Python pessoal, ligue para o seguinte na linha de comando:

$ pip install --user port4me

Para instalá -lo em um ambiente virtual do Python, opção de soltar --user .

Para experimentar, ligue:

 >>> from port4me import port4me
>>> port4me( " jupyter-notebook " )
29525

ou

$ python -m port4me --tool=jupyter-notebook
29525

O algoritmo Port4me

Requisitos

• Deve ser possível implementar o algoritmo usando aritmética inteira não assinada de 32 bits. Não se deve assumir que o maior número inteiro representado pode exceder $ 2^{32} - 1 $ .

• A sequência de portas pseudo-randomizada deve amostrar portas uniformemente $ [1024, 65535] $ .

• No mínimo, deve ser possível implementar o algoritmo em baunilha sh*, csh, bash, c, c ++, fortran, lua, python, r e ruby, sem necessidade de pacotes complementares além do que está disponível na distribuição principal. (*) As conchas que não suportam aritmética inteira podem usar ferramentas como expr , dc , bc e awk para esses cálculos.

• Todas as linguagens de programação devem produzir exatamente as mesmas seqüências de portas pseudo-aleatórias, com a mesma semente aleatória.

• As implementações devem ser escritas de modo que elas também funcionem quando obtidas ou copiadas e estabelecidas no código -fonte em outro lugar, por exemplo, nos scripts R e Python.

• A porta livre identificada deve ser emitida apenas para a saída padrão (STDOUT) como dígitos, sem nenhum símbolo de prefixo ou sufixo.

• O usuário deve poder excluir um conjunto de portas predefinido especificando PORT4ME_EXCLUDE , por exemplo, PORT4ME_EXCLUDE=8080,4321 .

• O administrador do sistema deve poder especificar um conjunto predefinido de portas a ser excluído especificando PORT4ME_EXCLUDE_SITE , por exemplo, PORT4ME_EXCLUDE_SITE=8080,4321 . Isso funciona complementar ao PORT4ME_EXCLUDE .

• O usuário deve poder pular um certo número de portas aleatórias à sua vontade especificando PORT4ME_SKIP , por exemplo, PORT4ME_SKIP=5 . O padrão é não pular, o que corresponde a PORT4ME_SKIP=0 . O pular deve ser aplicado após a exclusão de portas por PORT4ME_EXCLUDE e PORT4ME_EXCLUDE_SITE .

• Novas implementações devem reproduzir perfeitamente as seqüências de portas produzidas pelas implementações já existentes.

Projeto

• Um gerador congruente linear (LCG) será usado para gerar a sequência da porta pseudo-aleatória

  • a próxima semente, $ s_ {n+1} $ é calculado com base na semente atual $ s_n $ e parâmetros $ A, C, M&G; 1 $ como $ s_ {n + 1} = (a * s_ {n} + c) % m $

  • O algoritmo LCG não deve assumir que a semente LCG atual está dentro $ [0, M-1] $ , ou seja, deve aplicar módulo $ m $ na semente primeiro para evitar transbordamento inteiro

  • O algoritmo LCG pode produzir a mesma semente de saída que a semente de entrada, o que pode acontecer quando a semente é $ s_n = m - (a - c) $ . Para evitar isso resultando em um fluxo constante de LCG, incrementam a semente por um e recalcule sempre que isso acontecer

  • Os parâmetros LCG devem ser $ m = 2^{16} + 1 $ , Assim, $ a = 75 $ , e $ c = 74 $ ("ZX81")

    • Isso requer apenas aritmética inteira de 32 bits, porque $ m & lt; 2^{32} $

    • Se a semente inicial for $ s_0 = m - (a - c) $ , que aqui está $ m - 1 = 2^{16} $ , então a próxima semente LCG será a mesma, que é então tratada pela solução alternativa acima do incremento por um

• Um hashcode de string inteiro de 32 bits será usado para gerar um número inteiro em $ [0,2^{32} -1] $ de uma sequência ASCII com qualquer número de caracteres. O algoritmo HashCode é baseado no algoritmo Java Hashcode, mas usa números inteiros de 32 bits não assinados em $ [0,2^{32} -1] $ , em vez de assinar os em $ [-2^{31}, 2^{31} -1] $

• O String HashCode é usado como a semente LCG inicial:

  • A semente LCG deve estar em $ [0, M-1] $

  • dado hashcode $ h $ , podemos gerar a semente LCG inicial como $ h $ Modulo $ m $