All perguntas(unix)

...ou seja, há um meio pelo qual eu possa ler o comando completo que está sendo avaliado À MEDIDA que está acontecendo? Aqui está um exemplo artificial, mas que eu sinto que deixa a questão clara:

function showOwnEvaluation {
    local evaluatingCommand=????
    [[ "$evaluatingCommand" =~ ^showOwnEvaluation ]] && echo "Original Function"
}

alias sOE='showOwnEvaluation'

$ showOwnEvaluation 123
# Output: Original Function

$ sOE 123
# Output: 

Basicamente a habilidade de correr echo "$(!-1)"para o comando atual, ativo? Um echo "$(!0)", se preferir?

O que eu gostaria de fazer aqui é isto: se eu estiver atribuindo o resultado de uma expansão a uma variável:

someVar=$(myFunc)

...Eu gostaria de poder alterar a resposta com myFunc base no nome da variável para a qual ela está sendo definida . Eu simplesmente não consigo descobrir como obter a someVar=parte da expressão, se é que é possível FAZER tal coisa (sem aplicar uma emulação completa no terminal e monitorar todas as E/S, é claro).

Sei que isso pode parecer um desejo sem sentido, aqui, mas eu realmente tenho um caso de uso válido. Só não tenho certeza se é mesmo viável.

Existe algum script de shell que atualize meus arquivos para mim?

# apt update
Notice: Missing Signed-By in the sources.list(5) entry for 'https://storage.googleapis.com/cros-packages/133'
Notice: Missing Signed-By in the sources.list(5) entry for 'http://opensource.nchc.org.tw/debian'
Notice: Consider migrating all sources.list(5) entries to the deb822 .sources format
Notice: The deb822 .sources format supports both embedded as well as external OpenPGP keys
Notice: See apt-secure(7) for best practices in configuring repository signing.

Passei horas tentando descobrir isso e simplesmente desisti.

Meus arquivos só têm linhas "deb...".

E aqui está

$ cd /usr/share/keyrings && ls
cros.gpg                                        debian-archive-bullseye-stable.gpg
debian-archive-bookworm-automatic.gpg           debian-archive-buster-automatic.gpg
debian-archive-bookworm-security-automatic.gpg  debian-archive-buster-security-automatic.gpg
debian-archive-bookworm-stable.gpg              debian-archive-buster-stable.gpg
debian-archive-bullseye-automatic.gpg           debian-archive-keyring.gpg
debian-archive-bullseye-security-automatic.gpg  debian-archive-removed-keys.gpg

Também registrei https://issues.chromium.org/issues/392237686 porque /etc/apt/sources.list.d/cros.list não deveria ser responsabilidade da equipe do Chrome atualizar, e não minha?

Estou usando Linux (Ubuntu).

Quando digito man 7 signal(manual 2020-12-21) no meu terminal, encontro o seguinte para o SIGCHLD:

SIGCHLD      P1990      Ign     Child stopped or terminated

Então, ele afirma que o SIGCHLDsinal é gerado somente nesses dois casos. Ele não diz nada sobre quando o processo filho continua.

Entretanto, no POSIX, é afirmado o seguinte:

SIGCHLD Child process terminated, stopped,

[XSI] or continued.

Assim, quando o SO suporta XSI, esse sinal também é gerado quando o filho continua. Eu também escrevo alguns programas filho/pai simples e posso confirmar isso. Já que o Linux suporta XSI, por que o manual não inclui o cenário "continue" para o SIGCHLD também? Qual é o propósito do manual quando ele está incompleto (ou estou perdendo seu propósito?)

Também encontrei as seguintes respostas para SIGCHLD incompletas.

Abaixo está o código. É um código golang simples. O pai inicia o filho por meio do clássico fork/exec. Ele então registra um manipulador para o sinal SIGCHLD e pronto. Tanto o pai quanto o filho imprimem uma mensagem a cada 10 segundos. Depois de construir os dois programas, eu os executo via ./parentcomando. Eu controlo o comportamento ( T<-> R/Sestado) do processo filho por meio de kill -SISTOP child_process_idand kill -SIGCONT child_process_id.

Pai:

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    attr := &syscall.ProcAttr{
        Files: []uintptr{0, 1, 2},
    }

    _, err := syscall.ForkExec("./child/child", []string{"child"}, attr)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    ch := make(chan os.Signal, 1)
    signal.Notify(ch, syscall.SIGCHLD)

    go func() {
        for {
            select {
            case <-ch:
                fmt.Println("SIGNAL")
            }
        }
    }()

    for {
        fmt.Println("Parent is live")
        time.Sleep(10 * time.Second)
    }
}

Criança:

package main

import (
    "fmt"
    "time"
)

func main() {
    for {
        fmt.Println("hi from child")
        time.Sleep(time.Second * 10)
    }
}

Minha máquina é uma VM sem hardware wifi. Ela está conectada com eth0 e tudo funciona como deveria, exceto por nmcli g status, que mostra "CONNECTIVITY" como "unknown" e "WIFI-HW" como "missing".

Como faço para entender que não há hardware WIFI e que isso é totalmente aceitável e que deve mostrar que estou totalmente conectado?

Todas as minhas pesquisas trazem sugestões sobre como depurar o WIFI. Não o tenho instalado e quero que ele reconheça que, no que diz respeito às conexões de rede, o mundo está um caos.

Este é o Debian GNU/Linux 12 (bookworm).

Atualmente, tenho uma marca d'água que salta dentro do vídeo com esse pedaço horrível de código dentro de umfilter_complex

overlay=x='if(gte(mod(t*100, (W-w)*2), W-w), (W-w)*2 - mod(t*100, (W-w)*2), mod(t*100, (W-w)*2))'
       :y='if(gte(mod(t*100, (H-h)*2), H-h), (H-h)*2 - mod(t*100, (H-h)*2), mod(t*100, (H-h)*2))'

Eu gostaria que ele girasse em relação ao tempo também.

Descobri que quando defino o elemento de sobreposição, posso aplicar 'rotate=2' ou algo assim para girá-lo uma vez, e ele permanece assim enquanto salta.

Se eu tentar rotate='PI*t', não faz nada (mas surpreendentemente NÃO me dá um erro sobre t). Acho que não estou surpreso que não funcione, mas estou surpreso que não reclame sobre meu t.

Se eu tentar adicionar rotate='PI*t'na mesma seção que estou dizendo à sobreposição o que xe yo que ter (onde eu poderia esperar que funcionasse, como testá claramente entendido lá), ele DÁ erro -Option 'rotate' not found

É possível fazer isso em um comando ffmpeg ou preciso criar um arquivo de marca d'água apng/avif animado?

(Estou usando uma versão relativamente antiga do ffmpeg, 5.1.6. Ficarei feliz em migrar para uma versão mais recente se for relativamente fácil fazê-lo - estou executando o CentOS Stream 9.)

editar

É isso que estou tentando agora @Gyan

ffmpeg
-y
-i input.mp4
-loop 1 -i logo.png
-filter_complex "
    [0:v]
        scale=960:540[video];
    [1]
        scale=100:-1,colorchannelmixer=aa=0.6,rotate=a='PI/50*t':fillcolor=none[logo];
    [video][logo]
        overlay=x='if(gte(mod(t*100, (W-w)*2), W-w), (W-w)*2 - mod(t*100, (W-w)*2), mod(t*100, (W-w)*2))'
               :y='if(gte(mod(t*100, (H-h)*2), H-h), (H-h)*2 - mod(t*100, (H-h)*2), mod(t*100, (H-h)*2))'
"
-c:a aac
-c:v libx264
output.mp4

Sem -loop 1isso, demora de 1 a 2 segundos. Com isso, fiquei entediado e ctrl-Cfiz isso depois de 30 segundos.

editar dois

OK, removi -loop 1e alterei a linha relevante para

[1]loop=100:1:0,scale=100:-1,colorchannelmixer=aa=0.6,rotate=a='PI/5*t':ow=iw*1.5:oh=ih*1.5:fillcolor=none[logo];

E isso parece fazer o trabalho bem. Mas apenas para 100 quadros. Se eu colocar -1lá, parece gerar um fluxo infinito, em vez de corresponder ao comprimento de input.mp4. Acho que a resposta envolve a palavra-chave shortest, mas não tenho certeza de onde ela deve ficar? Adicioná-la -shortestcomo uma opção logo antes output.mp4não funcionou.

Pergunta bônus: aparece uma borda circular branca ao redor da imagem conforme ela gira. Como posso corrigir isso?

O que estou fazendo errado?

Obrigado!

Estou usando Linux (Ubuntu) e Bash.

Eu fiz um programa simples em Go. Um for-loop literalmente infinito que imprime texto a cada 20 segundos.

package main

import (
    "fmt"
    "time"
)

func main() {
    for {
        fmt.Println("Hi from program 1")
        time.Sleep(time.Second * 20)
    }
}

Primeiro, registro uma armadilha para o SIGCHLDsinal usando o comando:

trap 'echo "hi you"' SIGCHLD

Em seguida, inicio um programa de forma assíncrona (em segundo plano) com:

./program &

Eu comecei como um trabalho de segundo plano para que o bash possa usar o terminal. Quando eu executo o comando:

kill -SIGSTOP process_id

a armadilha é acionada, e a mensagem "hi you" é exibida como esperado. No entanto, quando eu executo:

kill -SIGCONT process_id

para retomar o processo, o processo continua em execução (imprimindo "Hi from program 1"), mas a mensagem de trap ("hi you") não é exibida. Eu invoco esses killcomandos de outro terminal.

Encontrei na documentação do bash o seguinte:

Qualquer armadilha em SIGCHLD é executada para cada processo filho que sai.

Eu poderia entender como exclusivo. Em outras palavras, que a SIGCHLDarmadilha é ativada somente quando o processo filho sai. Se for assim, ficaria claro para mim por que meu exemplo não funciona. No entanto, a SIGCHLDarmadilha também é ativada quando o processo filho é suspenso.

Por que isso está acontecendo? Retomar o processo também gera um SIGCHLDsinal, então por que a armadilha não dispara nesse caso?

Pergunta relacionada .

Estou tentando configurar o UFW para permitir DHCP e DNS para os clientes conectados ao hotspot Wi-Fi criado usando nmcli. Quero que a configuração seja o mais restritiva possível para evitar quaisquer conflitos de DHCP na eth0interface com fio ( ) -- ou seja, "internet" -- etc. Em poucas palavras:

• os clientes do hotspot wlan0devem estar atrás do NAT e devem ser capazes de obter a configuração de IP e DNS do respectivo DHCP do hotspot,
• os clientes do hotspot wlan0devem conseguir acessar a internet fornecida pela interface com fio ( eth0),
• outros dispositivos na rede com fio ( eth0) devem ignorar o fato de que um de seus "vizinhos" atua como um gateway, fornece DHCP/DNS, etc.

Eu já configurei NAT e encaminhamento via iptables, e tudo funciona bem desde que os dispositivos clientes usem configuração de IP estático. No entanto, quando configurados para usar DHCP, os dispositivos clientes falham em obter essas informações e, consequentemente, falham em se conectar ao hotspot.

A sub-rede usada pelo hotspot é 10.42.0.0/24 com o gateway sendo 10.42.0.1 (os padrões do NetworkManager). Quando tento permitir portas DHCP e DNS wlan0usando

# DHCP
ufw allow in on wlan0 from 10.42.0.0/24 to 10.42.0.1 port 67 proto udp
ufw allow out on wlan0 from 10.42.0.1 to 10.42.0.0/24 port 68 proto udp
# DNS
ufw allow in on wlan0 from 10.42.0.0/24 to 10.42.0.1 port 53
ufw allow out on wlan0 from 10.42.0.1 to 10.42.0.0/24 port 53

minha configuração UFW se torna (ou seja, apenas essas quatro regras extras existem):

$ ufw status verbose
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
10.42.0.1 67/udp on wlan0  ALLOW IN    10.42.0.0/24              
10.42.0.1 53 on wlan0      ALLOW IN    10.42.0.0/24              

10.42.0.0/24 68/udp        ALLOW OUT   10.42.0.1 on wlan0        
10.42.0.0/24 53            ALLOW OUT   10.42.0.1 on wlan0

Mas: mesmo com essas regras, os clientes de hotspot falham em obter a configuração IP/DNS do DHCP. Nem preciso dizer que não há tais problemas quando desabilito temporariamente o UFW...

Em um comentário do usuário "telcoM" neste post , descobri que pode ser necessário permitir os protocolos bootpse bootpcem vez das portas 67 e 68, respectivamente. No entanto, não consigo encontrar a sintaxe UFW necessária para fazer isso -- todas as tentativas feitas até agora (por exemplo, ufw allow in on wlan0 from 10.42.0.0/24 to 10.42.0.1 bootps) resultaram em reclamações do UFW (geralmente ERROR: Wrong number of arguments).

O que estou fazendo errado?

Obrigado.

Preciso que todas as combinações de teclas de função ALT/CTL/SHF sejam enviadas para um aplicativo (um emulador IBM 5250). Como desvinculo os mapeamentos de sistema para eles? Não consigo encontrá-los nas configurações de teclado para atalhos. (As primeiras vezes que pressionei ALT+CTL+F10, pensei que meu sistema tinha travado e o Fedora estava instável.)

Não importa se elas não estão mapeadas ou estão mapeadas para alguma combinação SUPER, mas elas devem ser desvinculadas para teclas shift normais.

Tenho dois monitores lado a lado no meu escritório, no meu desktop Ubuntu. Tenho aliases para diferentes configurações de monitor. É importante ressaltar que às vezes quero espelhar os monitores (para discussões com alunos no meu laboratório) e às vezes quero permitir que um aluno use o segundo monitor como dispositivo de apresentação.

Quando executo o alias "mirror" depois de "landscape" ou "portrait", xrandraparece a mensagem de que a tela não é grande o suficiente devido às configurações anteriores. Se eu executar o alias "student" primeiro (o que desliga o segundo monitor), consigo executar o "mirror" com sucesso.

Já fiz várias edições diferentes, mas nada parece surtir o efeito desejado. O que estou fazendo de errado com xrandr?

Aqui está a saída na linha de comando.

[~] source ~/src/dotfiles/hosts/gtkoffice_rc 
[~] landscape 
[~] mirror
xrandr: specified screen 1920x1200 not large enough for output DP-2 (1920x1200+1920+0)
xrandr: Configure crtc 1 failed
X Error of failed request:  BadValue (integer parameter out of range for operation)
  Major opcode of failed request:  140 (RANDR)
  Minor opcode of failed request:  21 (RRSetCrtcConfig)
  Value in failed request:  0x0
  Serial number of failed request:  54
  Current serial number in output stream:  54
[~] landscape 
[~] student
[~] mirror
[~] 

E aqui estão os materiais de~/src/dotfiles/hosts/gtkoffice_rc

export RIGHT_DISPLAY="DP-2"
export LEFT_DISPLAY="DP-3"
# for editing manuscripts
alias portrait='xrandr --fb 3120x1920  --output $LEFT_DISPLAY --mode 1920x1200 --panning 1920x1200+0+0 --output $RIGHT_DISPLAY --mode 1920x1200 --panning  1200x1920+1920+0 --rotate left'
# for normal work
alias landscape='xrandr --fb  3840x1200 --output $LEFT_DISPLAY --mode 1920x1200 --panning 1920x1200+0+0 --output $RIGHT_DISPLAY --mode 1920x1200 --panning 1920x1200+1920+0 --rotate normal'
# for discussions
alias mirror='xrandr --fb 1920x1200 --output $LEFT_DISPLAY --mode 1920x1200 --panning 1920x1200+0+0 --output $RIGHT_DISPLAY --mode 1920x1200 --panning 1920x1200+0+0 --rotate normal'
# student using 2nd monitor
alias student='xrandr --fb 1920x1200 --output $LEFT_DISPLAY --mode 1920x1200 --panning 1920x1200+0+0 --output $RIGHT_DISPLAY --off'

Tenho lido sobre a "parte pegajosa" e é quase o que eu quero... mas não exatamente.

Fundo

Estou gerenciando uma pequena instância do JupyterHub com três cursos e um instrutor para cada curso. Gostaria de ter uma pasta no servidor para envios de arquivos.

Os alunos (no jupyterhub-usersgrupo) devem ser capazes de colocar seus próprios arquivos na pasta, mas não devem ser capazes de mover ou visualizar outros arquivos na pasta. Idealmente, eles devem manter a capacidade de mover ou editar seus próprios arquivos.

Os instrutores do curso (no jupyterhub-instructorsgrupo) devem ter acesso total aos arquivos e pastas na submissionspasta para que possam mover os envios dos alunos conforme acharem adequado.

Minha compreensão atual

Estou ciente do sticky bit… meu problema com ele é que ele deixa os outros instrutores incapazes de modificar o conteúdo da pasta. Existe uma versão do sticky bit que permite que o grupo edite a pasta? Nesse caso, posso definir ACLs de modo que jupyterhub-userstenham rwxpermissões na pasta (permitindo que eles enviem arquivos para a pasta e vejam o conteúdo dela) e definir o proprietário da pasta para root:jupyterhub-instructorsque os instrutores possam controlar o conteúdo da pasta.

Se tudo mais falhar, suponho que posso criar subpastas na submissionspasta de propriedade de cada instrutor e, em seguida, definir o sticky bit em cada subpasta. Gostaria de evitar a futura manutenção associada a isso, já que terei que ser o único a lembrar de configurar uma nova pasta no próximo semestre para cada instrutor.