Žinynas - Naudotojo indėlis [lt]

Nut-upsd-fake

2026-03-22T22:25:23Z

\dev\null: Naujas puslapis: Jeigu taip atsitiko ir network ups'as sugrybavo, arba dėl kažkokių priežaščių reikia raportuoti, kad upsas gyvas ir online, galima pasinaudoti šiuo fake nut-upsd daemonu....

Jeigu taip atsitiko ir network ups'as sugrybavo, arba dėl kažkokių priežaščių reikia raportuoti, kad upsas gyvas ir online, galima pasinaudoti šiuo fake nut-upsd daemonu...

<syntaxhighlight lang="python>
#!/usr/bin/env python3
import socket
import threading
import datetime

HOST = "0.0.0.0"
PORT = 3493

PRIMARY_UPSNAME = "qnapups"
UPS_ALIASES = {"qnapups", "ups"}

USERNAME = "monuser"
PASSWORD = "secret"

VARS = {
"ups.status": "OL",
"battery.charge": "100",
"battery.charge.low": "10",
"battery.charge.warning": "20",
"battery.runtime": "3600",
"battery.runtime.low": "300",
"battery.voltage": "26.9",
"battery.voltage.nominal": "24",
"input.voltage": "230.0",
"input.voltage.nominal": "230",
"output.voltage": "230.0",
"ups.load": "25",
"ups.mfr": "FakeNUT",
"ups.model": "FakeQNAPUPS",
"device.type": "ups",
"device.model": "FakeQNAPUPS",
"driver.name": "dummy-ups",
}

def ts():
return datetime.datetime.now().strftime("%H:%M:%S")

def log(msg):
print(f"[{ts()}] {msg}", flush=True)

def send_line(conn, addr, line):
log(f"{addr} << {line}")
conn.sendall((line + "\n").encode())

def normalize_ups_name(name: str) -> str:
if name in UPS_ALIASES:
return name
return PRIMARY_UPSNAME

def handle_client(conn, addr_tuple):
addr = f"{addr_tuple[0]}:{addr_tuple[1]}"
log(f"[+] CONNECT {addr}")

authed_user = None
authed_pass = None
logged_in = False
tls_started = False

f = conn.makefile("r", encoding="utf-8", newline="\n")

try:
for raw in f:
line = raw.strip()
if not line:
continue

log(f"{addr} >> {line}")
parts = line.split()
cmd = parts[0].upper()

if cmd == "VER":
send_line(conn, addr, "Network UPS Tools upsd 2.8.0")

elif cmd == "NETVER":
send_line(conn, addr, "2.8.0")

elif cmd == "PROTVER":
send_line(conn, addr, "1.3")

elif cmd == "STARTTLS":
tls_started = True
send_line(conn, addr, "ERR FEATURE-NOT-CONFIGURED")

elif cmd == "LIST" and len(parts) >= 2 and parts[1].upper() == "UPS":
send_line(conn, addr, "BEGIN LIST UPS")
send_line(conn, addr, f'UPS qnapups "Fake QNAP UPS"')
send_line(conn, addr, f'UPS ups "Fake Synology Default UPS"')
send_line(conn, addr, "END LIST UPS")

elif cmd == "USERNAME" and len(parts) >= 2:
authed_user = parts[1]
send_line(conn, addr, "OK")

elif cmd == "PASSWORD" and len(parts) >= 2:
authed_pass = parts[1]
send_line(conn, addr, "OK")

elif cmd == "LOGIN" and len(parts) >= 2:
upsname = parts[1]
if upsname in UPS_ALIASES and authed_user == USERNAME and authed_pass == PASSWORD:
logged_in = True
send_line(conn, addr, "OK")
else:
send_line(conn, addr, "ERR ACCESS-DENIED")

elif cmd in ("MASTER", "PRIMARY") and len(parts) >= 2:
upsname = parts[1]
if logged_in and upsname in UPS_ALIASES:
send_line(conn, addr, "OK")
else:
send_line(conn, addr, "ERR ACCESS-DENIED")

elif cmd == "GET" and len(parts) >= 4 and parts[1].upper() == "VAR":
ups = parts[2]
var = " ".join(parts[3:])

if ups not in UPS_ALIASES:
send_line(conn, addr, "ERR UNKNOWN-UPS")
elif var in VARS:
resp_ups = normalize_ups_name(ups)
send_line(conn, addr, f'VAR {resp_ups} {var} "{VARS[var]}"')
else:
send_line(conn, addr, "ERR VAR-NOT-SUPPORTED")

elif cmd == "LIST" and len(parts) >= 3 and parts[1].upper() == "VAR":
ups = parts[2]

if ups not in UPS_ALIASES:
send_line(conn, addr, "ERR UNKNOWN-UPS")
else:
resp_ups = normalize_ups_name(ups)
send_line(conn, addr, f"BEGIN LIST VAR {resp_ups}")
for k, v in VARS.items():
send_line(conn, addr, f'VAR {resp_ups} {k} "{v}"')
send_line(conn, addr, f"END LIST VAR {resp_ups}")

elif cmd == "HELP":
send_line(conn, addr, "OK Commands: VER NETVER PROTVER STARTTLS LIST USERNAME PASSWORD LOGIN GET LOGOUT")

elif cmd == "LOGOUT":
send_line(conn, addr, "OK Goodbye")
break

else:
send_line(conn, addr, "ERR UNKNOWN-COMMAND")

except Exception as e:
log(f"[!] ERROR {addr}: {e}")
finally:
log(f"[-] DISCONNECT {addr} tls={tls_started} logged_in={logged_in}")
try:
conn.close()
except Exception:
pass

def main():
log(f"Starting Fake NUT DEBUG server on {HOST}:{PORT}")
log(f"Accepted UPS names: {', '.join(sorted(UPS_ALIASES))}")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
s.listen(20)

while True:
conn, addr = s.accept()
threading.Thread(target=handle_client, args=(conn, addr), daemon=True).start()

if __name__ == "__main__":
main()
</syntaxhighlight>

[[Category:Scripts]]

MacPro 6,1

2026-03-13T22:16:43Z

\dev\null: Naujas puslapis: = MacPro 6,1 Trashcan = == Auto power on power loss == Skirta Linux: setpci -v -s 00:1f.0 0xa4.b=0:1 Category:Apple Category:Mac OS X Category:Linux {{Template:...

= MacPro 6,1 Trashcan =

== Auto power on power loss ==

Skirta Linux:
setpci -v -s 00:1f.0 0xa4.b=0:1

[[Category:Apple]]
[[Category:Mac OS X]]
[[Category:Linux]]
{{Template:Distributions}}

G-RAID Studio

2026-03-13T22:10:26Z

\dev\null:

[[Vaizdas:Screenshot 2026-03-11 at 00.45.20.png]]

G-Technology G-RAID Studio Thunderbolt 2

= Prijungimas Linux'e =

Į '''/etc/default/grub''' GRUB_CMDLINE_LINUX_DEFAULT eilutės galą arba '''/etc/kernel/cmdline''' (jeigu naudojamas [[EFI]] boot pvz ant Proxmox) reikia pridėti
iommu=pt

Pririšam thunderbolt'ą:
boltctl list
boltctl enroll <UUID>
Pvz.:
boltctl enroll 00000000-0000-0018-0004-d4032e54e050
Žiūrim ar atsiranda devaisas:
dmesg -w
Jeigu viskas ok ir buvo pakonfigytas ant JBOD, turėtų atsirasti diskai:
lsblk
Jeigu neatsirado toliau žiūrime dmesg kodėl..

== Papildoma info ==

c9:00.0 SATA controller: Marvell Technology Group Ltd. 88SE9230 PCIe 2.0 x2 4-port SATA 6 Gb/s RAID Controller (rev 11)
Controlleris taip pat exposina management console, kurios dar nepriveikiau...
lsscsi -g
[2:0:0:0] process Marvell Console 1.01 - /dev/sg2
apt install sg3-utils
sg_inq /dev/sg2

Standarinės siunčiamos komandos grąžina statusą failed. Reikia tolimesnio tyrimo.

= Auto power on hack'as =

Aparatas nepalaiko '''auto power on after power loss''', ar pan. konfigūracijos, todėl po elektros dingimo jį reikia įjungti rankiniu būdu kas labai nervuoja. Bet išeitis yra! Galima apgauti įjungimo mygtuką, kadangi jis yra aktyvus ir schema taip pat turi 5V išvestį, panaudojus [[esp8266]] mikrokontrolerį, galima jį įjungti automatiškai...

[[Vaizdas:Graid-auto-power-hack-IMG 8316.jpg|700px]]

{| class="wikitable"
|+ Sujungimas
|-
! Board !! esp8266 !! Info
|-
| 5V || 5V ||
|-
| GND || GND ||
|-
| Power button || D1 || Gpio 5
|}

Supaprastinti kodą, panaudosime [https://esphome.io esphome]..

'''ESPHome''' konfigūracija:
<syntaxhighlight lang="yaml">
esphome:
name: graid-power
on_boot:
priority: -100
then:
- delay: 1500ms
- output.turn_on: pwrbtn
- delay: 300ms
- output.turn_off: pwrbtn

esp8266:
board: d1_mini

logger:

output:
- platform: gpio
id: pwrbtn
pin:
number: GPIO5
mode:
output: true
open_drain: true
inverted: true
</syntaxhighlight>

== Rezultatas ==

Gal ir nekaip atrodo bet veikia !

[[Vaizdas:Graid-auto-power-hack-IMG 8351.jpg|600px]]
[[Vaizdas:Graid-auto-power-hack-IMG 8352.jpg|600px]]
[[Vaizdas:Graid-auto-power-hack-IMG 8350.jpg|600px]]

= Reverse Engineered info =

Standartinis softas veikia kaip web aplikacija bet turi įrankį, kuris yra pacompilintas ant i386 ir tikrai ant naujų macOS neveiks, nebent turint seną macOS relyzą su mac'u kuriame yra TB2 portai galima pajungti ir išsiaškinti. Tas įrankis naudojamas backende atlikti visus juodus darbus, kuriuos vartotojas nurodo per tą web ui:
G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod: Mach-O executable i386

'''Atvirkštine inžinerija išsiaiškinta šios detalės:'''

== G-SPEED Studio CLI Notes ==

This document explains how to use the bundled Promise/G-SPEED command line utility to:

* identify physical disks
* list physical disks
* map UI disk labels to CLI disk IDs
* change disk mode between ''unconfig'' and ''passthru''
* perform a few related physical-drive operations

It is based on the software bundle in this repository, especially:

* ''G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod''
* the web UI code that calls physical-drive APIs

== Important terms ==

* '''PD ID''': Physical Drive ID used by backend/API/CLI operations.
* '''pdi_FlatId''': Internal drive ID field used by the web UI data model.
* '''PassThru''': What this software uses as the JBOD-like mode for a drive.
* '''Unconfigured''': A drive that is not currently passed through and not in an array.

== Important warning about numbering ==

There are two different representations in this software:

* Internal/backend ID: ''pdi_FlatId''
* Human-facing detail label: ''PD <id+1>''

That means:

* if the UI detail page says ''PD 1'', the backend ID may actually be ''0''
* if the physical drive list shows a raw numeric ID column, that raw numeric value is the one to trust for backend and CLI work

The web UI code confirms this:

* the physical drive list uses ''item.pdi_FlatId''
* the detail view displays ''PD '' plus ''getId()+1''

== Utility location ==

Bundled CLI binary:

<code bash>
"/Users/devnull/Projects/G-Drive/G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod"
</code>

Short shell variable for convenience:

<code bash>
CLI="/Users/devnull/Projects/G-Drive/G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod"
</code>

== Platform note ==

The bundled ''cli_exeMod'' in this repository is a Mach-O ''i386'' binary. On an ''arm64'' Mac it may not run directly unless the proper compatibility layer is available. The commands below document the intended usage from the bundled help text and the surrounding application code.

== How the software changes JBOD mode ==

The web UI does not call a special ''jbod'' command.

It changes a physical drive's configuration state through the backend method:

* ''setPhyDrvSettings''

When switching a drive into JBOD-like mode, it sets:

* ''pdsp_Flags = "PassThru"''

The equivalent CLI operation is:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=passthru"
</code>

To switch back:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=unconfig"
</code>

== Basic discovery workflow ==

Recommended order:

- List physical drives.
- Identify the correct ''PD ID''.
- Confirm whether the drive is already ''Unconfigured'' or ''PassThru''.
- Change the mode only for the target drive.
- Re-list drives to verify the new state.

== List physical drives ==

Basic listing:

<code bash>
$CLI phydrv
</code>

Explicit list action:

<code bash>
$CLI phydrv -a list
</code>

Verbose listing:

<code bash>
$CLI phydrv -v
</code>

List all SCSI devices instead of only disks:

<code bash>
$CLI phydrv -a list -l all
</code>

What to look for in output:

* Physical Drive ID
* model
* slot/location
* current status
* array membership
* current configuration status such as ''Unconfigured'' or ''PassThru''

== Identify the correct PD ID ==

=== From the web UI ===

Use the ''Physical Drives'' page.

The first numeric ID column comes from the raw internal field:

* ''pdi_FlatId''

That is the best candidate for CLI/API work.

Do not rely only on a detail screen label like ''PD 1'', because the detail screen may display ''id+1'' for humans.

=== From CLI output ===

Use:

<code bash>
$CLI phydrv -v
</code>

The bundled help text indicates the output includes physical drive information and refers to ''Physical Drive Id''.

Once you have the printed Physical Drive ID, use that exact number with ''-p''.

== Locate a drive physically ==

Blink the LED for one disk:

<code bash>
$CLI phydrv -a locate -p <PD_ID>
</code>

Example from the bundled help:

<code bash>
$CLI phydrv -a locate -p 9
</code>

Use this before changing mode if you need to confirm the exact tray/slot.

== Change a drive to JBOD-like mode ==

In this software, JBOD-like mode means ''PassThru''.

Command:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=passthru"
</code>

Example:

<code bash>
$CLI phydrv -a mod -p 9 -s "config=passthru"
</code>

Expected use:

* drive should currently be ''Unconfigured''
* drive should not be part of an active array

After changing mode, verify:

<code bash>
$CLI phydrv -v
</code>

== Change a drive back from PassThru ==

To return a passed-through drive to ''Unconfigured'':

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=unconfig"
</code>

Example:

<code bash>
$CLI phydrv -a mod -p 9 -s "config=unconfig"
</code>

This is also what the web UI does when converting a ''PassThru'' disk back to ''Unconfigured''.

== Change drive alias ==

The CLI help says ''alias'' can only be set on a configured drive.

Example:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "alias=MyDisk"
</code>

Do not assume alias changes are allowed in ''Unconfigured'' or ''PassThru'' state.

== Other physical-drive operations ==

Force a drive offline:

<code bash>
$CLI phydrv -a offline -p <PD_ID>
</code>

Force a drive online:

<code bash>
$CLI phydrv -a online -p <PD_ID>
</code>

Clear PFA:

<code bash>
$CLI phydrv -a clear -p <PD_ID> -t pfa
</code>

Clear stale config:

<code bash>
$CLI phydrv -a clear -p <PD_ID> -t staleconfig
</code>

These are riskier than listing/locating and should be used only when you are sure about the drive state.

== Global SATA/SAS drive settings ==

The CLI also supports global settings on SATA/SAS drives through ''phydrv -a mod'', for example:

<code bash>
$CLI phydrv -a mod -s "writecache=enable,rlacache=enable"
</code>

Drive-type-specific scope:

* ''-d sata''
* ''-d sas''
* ''-d all''

Examples:

<code bash>
$CLI phydrv -a mod -d sata -s "writecache=enable"
$CLI phydrv -a mod -d sas -s "readcache=enable,multipath=enable"
</code>

These are global settings for drives of that type, not a single-disk mode switch.

== Arrays and PD IDs ==

The CLI help for array creation uses PD IDs directly:

<code bash>
$CLI array -a add -p 1,3,5~9 -l "raid=5,capacity=50gb,stripe=256kb"
</code>

This matters because it confirms that:

* the same PD ID namespace is used across physical-drive and array commands
* the IDs you discover in ''phydrv'' are the IDs you would use when creating arrays

== Safe operating procedure ==

Before changing a disk to ''PassThru'':

- List all drives with ''phydrv -v''.
- Record the target drive's PD ID, slot, model, and current config state.
- If needed, run ''phydrv -a locate -p <PD_ID>'' to confirm the tray.
- Ensure the drive is not part of an active array you care about.
- Run ''phydrv -a mod -p <PD_ID> -s "config=passthru"''.
- Re-run ''phydrv -v'' and confirm the new state.

== Common examples ==

List drives:

<code bash>
$CLI phydrv -v
</code>

Locate drive 4:

<code bash>
$CLI phydrv -a locate -p 4
</code>

Convert drive 4 to PassThru:

<code bash>
$CLI phydrv -a mod -p 4 -s "config=passthru"
</code>

Convert drive 4 back to Unconfigured:

<code bash>
$CLI phydrv -a mod -p 4 -s "config=unconfig"
</code>

Clear stale configuration on drive 4:

<code bash>
$CLI phydrv -a clear -p 4 -t staleconfig
</code>

== What the web app code confirms ==

Relevant behavior found in the application code:

* Physical drive IDs come from ''pdi_FlatId''.
* UI detail display uses ''PD <id+1>''.
* The physical-drive settings panel offers ''Unconfigured'' and ''PassThru''.
* Saving those settings issues backend ''setPhyDrvSettings''.
* Advanced configuration code also toggles drives through ''setPhyDrvSettings''.

== Limitations of this note ==

* This document is based on bundled help text and code inspection.
* The ''cli_exeMod'' binary in this repository was not executed successfully on the current ''arm64'' host during this review.
* If you run this on the original supported platform, verify syntax with:

<code bash>
$CLI help phydrv
</code>

or:

<code bash>
$CLI phydrv -h
</code>

[[Category:Hardware]]
[[Category:Linux]]
[[Category:Mac OS X]]
[[Category:ESP8266]]

G-RAID Studio

2026-03-13T22:08:45Z

\dev\null:

Vaizdas:Graid-auto-power-hack-IMG 8350.jpg

2026-03-13T22:02:40Z

\dev\null:

Vaizdas:Graid-auto-power-hack-IMG 8352.jpg

2026-03-13T22:02:18Z

\dev\null:

Vaizdas:Graid-auto-power-hack-IMG 8351.jpg

2026-03-13T22:01:50Z

\dev\null:

Vaizdas:Graid-auto-power-hack-IMG 8316.jpg

2026-03-13T22:01:10Z

\dev\null:

G-RAID Studio

2026-03-10T22:48:04Z

\dev\null: /* Prijungimas Linux'e */

[[Vaizdas:Screenshot 2026-03-11 at 00.45.20.png]]

G-Technology G-RAID Studio Thunderbolt 2

= Prijungimas Linux'e =

Į '''/etc/default/grub''' GRUB_CMDLINE_LINUX_DEFAULT eilutės galą arba '''/etc/kernel/cmdline''' (jeigu naudojamas [[EFI]] boot pvz ant Proxmox) reikia pridėti
iommu=pt

Pririšam thunderbolt'ą:
boltctl list
boltctl enroll <UUID>
Pvz.:
boltctl enroll 00000000-0000-0018-0004-d4032e54e050
Žiūrim ar atsiranda devaisas:
dmesg -w
Jeigu viskas ok ir buvo pakonfigytas ant JBOD, turėtų atsirasti diskai:
lsblk
Jeigu neatsirado toliau žiūrime dmesg kodėl..

== Papildoma info ==

c9:00.0 SATA controller: Marvell Technology Group Ltd. 88SE9230 PCIe 2.0 x2 4-port SATA 6 Gb/s RAID Controller (rev 11)
Controlleris taip pat exposina management console, kurios dar nepriveikiau...
lsscsi -g
[2:0:0:0] process Marvell Console 1.01 - /dev/sg2
apt install sg3-utils
sg_inq /dev/sg2

Standarinės siunčiamos komandos grąžina statusą failed. Reikia tolimesnio tyrimo.

= Reverse Engineered info =

Standartinis softas veikia kaip web aplikacija bet turi įrankį, kuris yra pacompilintas ant i386 ir tikrai ant naujų macOS neveiks, nebent turint seną macOS relyzą su mac'u kuriame yra TB2 portai galima pajungti ir išsiaškinti. Tas įrankis naudojamas backende atlikti visus juodus darbus, kuriuos vartotojas nurodo per tą web ui:
G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod: Mach-O executable i386

'''Atvirkštine inžinerija išsiaiškinta šios detalės:'''

== G-SPEED Studio CLI Notes ==

This document explains how to use the bundled Promise/G-SPEED command line utility to:

* identify physical disks
* list physical disks
* map UI disk labels to CLI disk IDs
* change disk mode between ''unconfig'' and ''passthru''
* perform a few related physical-drive operations

It is based on the software bundle in this repository, especially:

* ''G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod''
* the web UI code that calls physical-drive APIs

== Important terms ==

* '''PD ID''': Physical Drive ID used by backend/API/CLI operations.
* '''pdi_FlatId''': Internal drive ID field used by the web UI data model.
* '''PassThru''': What this software uses as the JBOD-like mode for a drive.
* '''Unconfigured''': A drive that is not currently passed through and not in an array.

== Important warning about numbering ==

There are two different representations in this software:

* Internal/backend ID: ''pdi_FlatId''
* Human-facing detail label: ''PD <id+1>''

That means:

* if the UI detail page says ''PD 1'', the backend ID may actually be ''0''
* if the physical drive list shows a raw numeric ID column, that raw numeric value is the one to trust for backend and CLI work

The web UI code confirms this:

* the physical drive list uses ''item.pdi_FlatId''
* the detail view displays ''PD '' plus ''getId()+1''

== Utility location ==

Bundled CLI binary:

<code bash>
"/Users/devnull/Projects/G-Drive/G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod"
</code>

Short shell variable for convenience:

<code bash>
CLI="/Users/devnull/Projects/G-Drive/G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod"
</code>

== Platform note ==

The bundled ''cli_exeMod'' in this repository is a Mach-O ''i386'' binary. On an ''arm64'' Mac it may not run directly unless the proper compatibility layer is available. The commands below document the intended usage from the bundled help text and the surrounding application code.

== How the software changes JBOD mode ==

The web UI does not call a special ''jbod'' command.

It changes a physical drive's configuration state through the backend method:

* ''setPhyDrvSettings''

When switching a drive into JBOD-like mode, it sets:

* ''pdsp_Flags = "PassThru"''

The equivalent CLI operation is:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=passthru"
</code>

To switch back:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=unconfig"
</code>

== Basic discovery workflow ==

Recommended order:

- List physical drives.
- Identify the correct ''PD ID''.
- Confirm whether the drive is already ''Unconfigured'' or ''PassThru''.
- Change the mode only for the target drive.
- Re-list drives to verify the new state.

== List physical drives ==

Basic listing:

<code bash>
$CLI phydrv
</code>

Explicit list action:

<code bash>
$CLI phydrv -a list
</code>

Verbose listing:

<code bash>
$CLI phydrv -v
</code>

List all SCSI devices instead of only disks:

<code bash>
$CLI phydrv -a list -l all
</code>

What to look for in output:

* Physical Drive ID
* model
* slot/location
* current status
* array membership
* current configuration status such as ''Unconfigured'' or ''PassThru''

== Identify the correct PD ID ==

=== From the web UI ===

Use the ''Physical Drives'' page.

The first numeric ID column comes from the raw internal field:

* ''pdi_FlatId''

That is the best candidate for CLI/API work.

Do not rely only on a detail screen label like ''PD 1'', because the detail screen may display ''id+1'' for humans.

=== From CLI output ===

Use:

<code bash>
$CLI phydrv -v
</code>

The bundled help text indicates the output includes physical drive information and refers to ''Physical Drive Id''.

Once you have the printed Physical Drive ID, use that exact number with ''-p''.

== Locate a drive physically ==

Blink the LED for one disk:

<code bash>
$CLI phydrv -a locate -p <PD_ID>
</code>

Example from the bundled help:

<code bash>
$CLI phydrv -a locate -p 9
</code>

Use this before changing mode if you need to confirm the exact tray/slot.

== Change a drive to JBOD-like mode ==

In this software, JBOD-like mode means ''PassThru''.

Command:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=passthru"
</code>

Example:

<code bash>
$CLI phydrv -a mod -p 9 -s "config=passthru"
</code>

Expected use:

* drive should currently be ''Unconfigured''
* drive should not be part of an active array

After changing mode, verify:

<code bash>
$CLI phydrv -v
</code>

== Change a drive back from PassThru ==

To return a passed-through drive to ''Unconfigured'':

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=unconfig"
</code>

Example:

<code bash>
$CLI phydrv -a mod -p 9 -s "config=unconfig"
</code>

This is also what the web UI does when converting a ''PassThru'' disk back to ''Unconfigured''.

== Change drive alias ==

The CLI help says ''alias'' can only be set on a configured drive.

Example:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "alias=MyDisk"
</code>

Do not assume alias changes are allowed in ''Unconfigured'' or ''PassThru'' state.

== Other physical-drive operations ==

Force a drive offline:

<code bash>
$CLI phydrv -a offline -p <PD_ID>
</code>

Force a drive online:

<code bash>
$CLI phydrv -a online -p <PD_ID>
</code>

Clear PFA:

<code bash>
$CLI phydrv -a clear -p <PD_ID> -t pfa
</code>

Clear stale config:

<code bash>
$CLI phydrv -a clear -p <PD_ID> -t staleconfig
</code>

These are riskier than listing/locating and should be used only when you are sure about the drive state.

== Global SATA/SAS drive settings ==

The CLI also supports global settings on SATA/SAS drives through ''phydrv -a mod'', for example:

<code bash>
$CLI phydrv -a mod -s "writecache=enable,rlacache=enable"
</code>

Drive-type-specific scope:

* ''-d sata''
* ''-d sas''
* ''-d all''

Examples:

<code bash>
$CLI phydrv -a mod -d sata -s "writecache=enable"
$CLI phydrv -a mod -d sas -s "readcache=enable,multipath=enable"
</code>

These are global settings for drives of that type, not a single-disk mode switch.

== Arrays and PD IDs ==

The CLI help for array creation uses PD IDs directly:

<code bash>
$CLI array -a add -p 1,3,5~9 -l "raid=5,capacity=50gb,stripe=256kb"
</code>

This matters because it confirms that:

* the same PD ID namespace is used across physical-drive and array commands
* the IDs you discover in ''phydrv'' are the IDs you would use when creating arrays

== Safe operating procedure ==

Before changing a disk to ''PassThru'':

- List all drives with ''phydrv -v''.
- Record the target drive's PD ID, slot, model, and current config state.
- If needed, run ''phydrv -a locate -p <PD_ID>'' to confirm the tray.
- Ensure the drive is not part of an active array you care about.
- Run ''phydrv -a mod -p <PD_ID> -s "config=passthru"''.
- Re-run ''phydrv -v'' and confirm the new state.

== Common examples ==

List drives:

<code bash>
$CLI phydrv -v
</code>

Locate drive 4:

<code bash>
$CLI phydrv -a locate -p 4
</code>

Convert drive 4 to PassThru:

<code bash>
$CLI phydrv -a mod -p 4 -s "config=passthru"
</code>

Convert drive 4 back to Unconfigured:

<code bash>
$CLI phydrv -a mod -p 4 -s "config=unconfig"
</code>

Clear stale configuration on drive 4:

<code bash>
$CLI phydrv -a clear -p 4 -t staleconfig
</code>

== What the web app code confirms ==

Relevant behavior found in the application code:

* Physical drive IDs come from ''pdi_FlatId''.
* UI detail display uses ''PD <id+1>''.
* The physical-drive settings panel offers ''Unconfigured'' and ''PassThru''.
* Saving those settings issues backend ''setPhyDrvSettings''.
* Advanced configuration code also toggles drives through ''setPhyDrvSettings''.

== Limitations of this note ==

* This document is based on bundled help text and code inspection.
* The ''cli_exeMod'' binary in this repository was not executed successfully on the current ''arm64'' host during this review.
* If you run this on the original supported platform, verify syntax with:

<code bash>
$CLI help phydrv
</code>

or:

<code bash>
$CLI phydrv -h
</code>

[[Category:Hardware]]
[[Category:Linux]]
[[Category:Mac OS X]]

G-RAID Studio

2026-03-10T22:46:42Z

\dev\null: Naujas puslapis: Vaizdas:Screenshot 2026-03-11 at 00.45.20.png G-Technology G-RAID Studio Thunderbolt 2 = Prijungimas Linux'e = Į /etc/default/grub GRUB_CMDLINE_LINUX_DEFAULT arba /etc/k...

[[Vaizdas:Screenshot 2026-03-11 at 00.45.20.png]]

G-Technology G-RAID Studio Thunderbolt 2

= Prijungimas Linux'e =

Į /etc/default/grub GRUB_CMDLINE_LINUX_DEFAULT arba /etc/kernel/cmdline rekia pridėti
iommu=pt

Pririšam thunderbolt'ą:
boltctl list
boltctl enroll <UUID>
Pvz.:
boltctl enroll 00000000-0000-0018-0004-d4032e54e050
Žiūrim ar atsiranda devaisas:
dmesg -w
Jeigu viskas ok ir buvo pakonfigytas ant JBOD, turėtų atsirasti diskai:
lsblk
Jeigu neatsirado toliau žiūrime dmesg kodėl..

== Papildoma info ==

c9:00.0 SATA controller: Marvell Technology Group Ltd. 88SE9230 PCIe 2.0 x2 4-port SATA 6 Gb/s RAID Controller (rev 11)
Controlleris taip pat exposina management console, kurios dar nepriveikiau...
lsscsi -g
[2:0:0:0] process Marvell Console 1.01 - /dev/sg2
apt install sg3-utils
sg_inq /dev/sg2

Standarinės siunčiamos komandos grąžina statusą failed. Reikia tolimesnio tyrimo.

= Reverse Engineered info =

Standartinis softas veikia kaip web aplikacija bet turi įrankį, kuris yra pacompilintas ant i386 ir tikrai ant naujų macOS neveiks, nebent turint seną macOS relyzą su mac'u kuriame yra TB2 portai galima pajungti ir išsiaškinti. Tas įrankis naudojamas backende atlikti visus juodus darbus, kuriuos vartotojas nurodo per tą web ui:
G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod: Mach-O executable i386

'''Atvirkštine inžinerija išsiaiškinta šios detalės:'''

== G-SPEED Studio CLI Notes ==

This document explains how to use the bundled Promise/G-SPEED command line utility to:

* identify physical disks
* list physical disks
* map UI disk labels to CLI disk IDs
* change disk mode between ''unconfig'' and ''passthru''
* perform a few related physical-drive operations

It is based on the software bundle in this repository, especially:

* ''G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod''
* the web UI code that calls physical-drive APIs

== Important terms ==

* '''PD ID''': Physical Drive ID used by backend/API/CLI operations.
* '''pdi_FlatId''': Internal drive ID field used by the web UI data model.
* '''PassThru''': What this software uses as the JBOD-like mode for a drive.
* '''Unconfigured''': A drive that is not currently passed through and not in an array.

== Important warning about numbering ==

There are two different representations in this software:

* Internal/backend ID: ''pdi_FlatId''
* Human-facing detail label: ''PD <id+1>''

That means:

* if the UI detail page says ''PD 1'', the backend ID may actually be ''0''
* if the physical drive list shows a raw numeric ID column, that raw numeric value is the one to trust for backend and CLI work

The web UI code confirms this:

* the physical drive list uses ''item.pdi_FlatId''
* the detail view displays ''PD '' plus ''getId()+1''

== Utility location ==

Bundled CLI binary:

<code bash>
"/Users/devnull/Projects/G-Drive/G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod"
</code>

Short shell variable for convenience:

<code bash>
CLI="/Users/devnull/Projects/G-Drive/G-SPEED Studio Software Utility.app/Contents/Resources/XMLBase/cli_exeMod"
</code>

== Platform note ==

The bundled ''cli_exeMod'' in this repository is a Mach-O ''i386'' binary. On an ''arm64'' Mac it may not run directly unless the proper compatibility layer is available. The commands below document the intended usage from the bundled help text and the surrounding application code.

== How the software changes JBOD mode ==

The web UI does not call a special ''jbod'' command.

It changes a physical drive's configuration state through the backend method:

* ''setPhyDrvSettings''

When switching a drive into JBOD-like mode, it sets:

* ''pdsp_Flags = "PassThru"''

The equivalent CLI operation is:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=passthru"
</code>

To switch back:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=unconfig"
</code>

== Basic discovery workflow ==

Recommended order:

- List physical drives.
- Identify the correct ''PD ID''.
- Confirm whether the drive is already ''Unconfigured'' or ''PassThru''.
- Change the mode only for the target drive.
- Re-list drives to verify the new state.

== List physical drives ==

Basic listing:

<code bash>
$CLI phydrv
</code>

Explicit list action:

<code bash>
$CLI phydrv -a list
</code>

Verbose listing:

<code bash>
$CLI phydrv -v
</code>

List all SCSI devices instead of only disks:

<code bash>
$CLI phydrv -a list -l all
</code>

What to look for in output:

* Physical Drive ID
* model
* slot/location
* current status
* array membership
* current configuration status such as ''Unconfigured'' or ''PassThru''

== Identify the correct PD ID ==

=== From the web UI ===

Use the ''Physical Drives'' page.

The first numeric ID column comes from the raw internal field:

* ''pdi_FlatId''

That is the best candidate for CLI/API work.

Do not rely only on a detail screen label like ''PD 1'', because the detail screen may display ''id+1'' for humans.

=== From CLI output ===

Use:

<code bash>
$CLI phydrv -v
</code>

The bundled help text indicates the output includes physical drive information and refers to ''Physical Drive Id''.

Once you have the printed Physical Drive ID, use that exact number with ''-p''.

== Locate a drive physically ==

Blink the LED for one disk:

<code bash>
$CLI phydrv -a locate -p <PD_ID>
</code>

Example from the bundled help:

<code bash>
$CLI phydrv -a locate -p 9
</code>

Use this before changing mode if you need to confirm the exact tray/slot.

== Change a drive to JBOD-like mode ==

In this software, JBOD-like mode means ''PassThru''.

Command:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=passthru"
</code>

Example:

<code bash>
$CLI phydrv -a mod -p 9 -s "config=passthru"
</code>

Expected use:

* drive should currently be ''Unconfigured''
* drive should not be part of an active array

After changing mode, verify:

<code bash>
$CLI phydrv -v
</code>

== Change a drive back from PassThru ==

To return a passed-through drive to ''Unconfigured'':

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "config=unconfig"
</code>

Example:

<code bash>
$CLI phydrv -a mod -p 9 -s "config=unconfig"
</code>

This is also what the web UI does when converting a ''PassThru'' disk back to ''Unconfigured''.

== Change drive alias ==

The CLI help says ''alias'' can only be set on a configured drive.

Example:

<code bash>
$CLI phydrv -a mod -p <PD_ID> -s "alias=MyDisk"
</code>

Do not assume alias changes are allowed in ''Unconfigured'' or ''PassThru'' state.

== Other physical-drive operations ==

Force a drive offline:

<code bash>
$CLI phydrv -a offline -p <PD_ID>
</code>

Force a drive online:

<code bash>
$CLI phydrv -a online -p <PD_ID>
</code>

Clear PFA:

<code bash>
$CLI phydrv -a clear -p <PD_ID> -t pfa
</code>

Clear stale config:

<code bash>
$CLI phydrv -a clear -p <PD_ID> -t staleconfig
</code>

These are riskier than listing/locating and should be used only when you are sure about the drive state.

== Global SATA/SAS drive settings ==

The CLI also supports global settings on SATA/SAS drives through ''phydrv -a mod'', for example:

<code bash>
$CLI phydrv -a mod -s "writecache=enable,rlacache=enable"
</code>

Drive-type-specific scope:

* ''-d sata''
* ''-d sas''
* ''-d all''

Examples:

<code bash>
$CLI phydrv -a mod -d sata -s "writecache=enable"
$CLI phydrv -a mod -d sas -s "readcache=enable,multipath=enable"
</code>

These are global settings for drives of that type, not a single-disk mode switch.

== Arrays and PD IDs ==

The CLI help for array creation uses PD IDs directly:

<code bash>
$CLI array -a add -p 1,3,5~9 -l "raid=5,capacity=50gb,stripe=256kb"
</code>

This matters because it confirms that:

* the same PD ID namespace is used across physical-drive and array commands
* the IDs you discover in ''phydrv'' are the IDs you would use when creating arrays

== Safe operating procedure ==

Before changing a disk to ''PassThru'':

- List all drives with ''phydrv -v''.
- Record the target drive's PD ID, slot, model, and current config state.
- If needed, run ''phydrv -a locate -p <PD_ID>'' to confirm the tray.
- Ensure the drive is not part of an active array you care about.
- Run ''phydrv -a mod -p <PD_ID> -s "config=passthru"''.
- Re-run ''phydrv -v'' and confirm the new state.

== Common examples ==

List drives:

<code bash>
$CLI phydrv -v
</code>

Locate drive 4:

<code bash>
$CLI phydrv -a locate -p 4
</code>

Convert drive 4 to PassThru:

<code bash>
$CLI phydrv -a mod -p 4 -s "config=passthru"
</code>

Convert drive 4 back to Unconfigured:

<code bash>
$CLI phydrv -a mod -p 4 -s "config=unconfig"
</code>

Clear stale configuration on drive 4:

<code bash>
$CLI phydrv -a clear -p 4 -t staleconfig
</code>

== What the web app code confirms ==

Relevant behavior found in the application code:

* Physical drive IDs come from ''pdi_FlatId''.
* UI detail display uses ''PD <id+1>''.
* The physical-drive settings panel offers ''Unconfigured'' and ''PassThru''.
* Saving those settings issues backend ''setPhyDrvSettings''.
* Advanced configuration code also toggles drives through ''setPhyDrvSettings''.

== Limitations of this note ==

* This document is based on bundled help text and code inspection.
* The ''cli_exeMod'' binary in this repository was not executed successfully on the current ''arm64'' host during this review.
* If you run this on the original supported platform, verify syntax with:

<code bash>
$CLI help phydrv
</code>

or:

<code bash>
$CLI phydrv -h
</code>

[[Category:Hardware]]
[[Category:Linux]]
[[Category:Mac OS X]]

Vaizdas:Screenshot 2026-03-11 at 00.45.20.png

2026-03-10T22:45:50Z

\dev\null:

Cpu killer

2025-11-08T20:45:46Z

\dev\null: v2 - pervadina tik procesus kurie yra /home prefix'e taip pat atskiria ar tai binarikas ar scriptas, patikrina ar yra shebangas, t.y jeigu cmdline matosi priekyje interpretatorius

Scriptas skirtas automatiškai killinti userių procesus kurie pastoviai ėda >90% cpu time. Naudoju Free Shells projektui jau eilę metų, čia jau antra scripto iteracija, pirmoji buvo parašyta ant bash.. Scriptas taip pat "decloakina" hidden procesus, t.y pakeistais pavadinimais, pervadina procesą su prefix'u "_too_much_cpu_time". Pervadintas nepasileis automatiškai, jeigu uždėtas ant cron ar kokio kito auto paleisties mechanizmo t.y systemd-user.

<syntaxhighlight lang="python">
#!/usr/bin/env python3
"""
CPU Killer Daemon
- Continuously monitors processes
- Kills if >90% CPU for 10+ minutes
- Renames real binary
- Runs as background service
"""
import os
import sys
import psutil
import shutil
import time
import stat
from datetime import datetime
from pathlib import Path
from collections import defaultdict

# ============================= CONFIG =============================
CPU_THRESHOLD = 90.0 # % CPU usage
TIME_THRESHOLD = 600 # seconds (10 minutes)
CHECK_INTERVAL = 30 # check every 30 sec
EXCEPTION_USERS = {'root', 'polkitd', '_chrony', 'postgres', 'nginx', 'devnull', 'zabbix', 'www-data', 'systemd-network', 'systemd-timesync', 'systemd-resolve'} # <--- ADD YOUR USERS HERE
SAFE_RENAME_PREFIXES = ('/home/',) # Only rename files living under these prefixes
LOG_FILE = "/root/tools/cpu_killer.log"
DRY_RUN = False # Set to True for testing (no kill/rename)
PID_FILE = "/root/tools/cpu_killer.pid"
# ==================================================================

def _is_under_safe_prefix(p: str) -> bool:
try:
rp = Path(p).resolve().as_posix()
except Exception:
return False
return any(rp.startswith(prefix) for prefix in SAFE_RENAME_PREFIXES)

def _abs_from_proc_cwd(proc: psutil.Process, path: str) -> str:
"""Make path absolute using the process' cwd if it's relative."""
if os.path.isabs(path):
return path
try:
cwd = os.readlink(f"/proc/{proc.pid}/cwd")
return os.path.normpath(os.path.join(cwd, path))
except Exception:
return path

def get_safe_rename_target(proc: psutil.Process) -> str | None:
"""
Return a file path that is safe to rename:
- Prefer the launched script (for Python or shebang scripts)
- Must be under /home/
- Never return the interpreter/binary in /usr, /bin, etc.
"""
try:
cmd = proc.cmdline()
if not cmd:
return None

candidates = []

# If invoked as: python /home/user/app.py ...
exe_base = os.path.basename(cmd[0])
if 'python' in exe_base.lower() and len(cmd) >= 2:
candidates.append(cmd[1])

# If invoked directly: /home/user/app.py (shebang)
candidates.append(cmd[0])

# Consider only first existing file under /home/
for c in candidates:
c_abs = _abs_from_proc_cwd(proc, c)
if not c_abs:
continue
try:
st = os.stat(c_abs)
if not stat.S_ISREG(st.st_mode):
continue
except Exception:
continue
if _is_under_safe_prefix(c_abs):
return c_abs

# As a last resort, fall back to real binary only if it's under /home/
real_bin = get_real_binary(proc)
if real_bin and _is_under_safe_prefix(real_bin):
return real_bin

return None
except Exception:
return None

def log(msg):
ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
line = f"[{ts}] {msg}"
print(line)
try:
with open(LOG_FILE, "a") as f:
f.write(line + "\n")
except:
pass

def daemonize():
if os.fork(): sys.exit(0)
os.setsid()
if os.fork(): sys.exit(0)
sys.stdout.flush()
sys.stderr.flush()
with open('/dev/null', 'r') as dev_null:
os.dup2(dev_null.fileno(), sys.stdin.fileno())
with open(LOG_FILE, "a") as f:
os.dup2(f.fileno(), sys.stdout.fileno())
os.dup2(f.fileno(), sys.stderr.fileno())

# Write PID
with open(PID_FILE, "w") as f:
f.write(str(os.getpid()))

class ProcessTracker:
def __init__(self):
self.tracked = {} # pid -> {start_time, cpu_samples}

def update(self, proc):
pid = proc.pid
if pid not in self.tracked:
self.tracked[pid] = {
'start_time': time.time(),
'cpu_samples': []
}
self.tracked[pid]['cpu_samples'].append(proc.cpu_percent())
# Keep last 20 samples (~10 min at 30s interval)
if len(self.tracked[pid]['cpu_samples']) > 20:
self.tracked[pid]['cpu_samples'].pop(0)

def is_offender(self, pid):
data = self.tracked.get(pid)
if not data or len(data['cpu_samples']) < 10:
return False
# Average CPU over last ~5-10 min
avg_cpu = sum(data['cpu_samples']) / len(data['cpu_samples'])
runtime = time.time() - data['start_time']
return avg_cpu >= CPU_THRESHOLD and runtime >= TIME_THRESHOLD

def cleanup(self, pid):
self.tracked.pop(pid, None)

tracker = ProcessTracker()

def get_real_binary(proc):
try:
exe = f"/proc/{proc.pid}/exe"
if not os.path.exists(exe):
return None
path = os.readlink(exe)
if "(deleted)" in path:
path = path.replace(" (deleted)", "").strip()
return path if os.path.exists(path) else None
except:
return None

def rename_binary(bin_path):
if not bin_path or not os.path.exists(bin_path):
return
if not _is_under_safe_prefix(bin_path):
log(f" -> Skip rename (outside safe prefixes): {bin_path}")
return

path = Path(bin_path)
# keep suffix for .py, .sh, etc.
suffix = path.suffix
stem = path.stem
new_name = path.parent / f"{stem}_too_much_cpu_time{suffix}"

i = 1
while new_name.exists():
new_name = path.parent / f"{stem}_too_much_cpu_time.{i}{suffix}"
i += 1

log(f" -> Renaming: {path} → {new_name}")
if not DRY_RUN:
try:
shutil.move(str(path), str(new_name))
except Exception as e:
log(f" -> Rename failed: {e}")

def kill_process(proc):
try:
cmd = " ".join(proc.cmdline()[:3]) + ("..." if len(proc.cmdline()) > 3 else "")
log(f"KILLING PID {proc.pid} ({cmd}) | User: {proc.username()} | CPU: ~{proc.cpu_percent():.1f}%")
if not DRY_RUN:
proc.terminate()
try:
gone, alive = psutil.wait_procs([proc], timeout=5)
if alive:
log(f" -> Force kill")
for p in alive:
p.kill()
except:
pass
return True
except Exception as e:
log(f" -> Kill failed: {e}")
return False

def main_loop():
log("CPU Killer started (daemon mode)")
seen_pids = set()

while True:
try:
current_pids = {p.pid for p in psutil.process_iter()}
# Cleanup dead
for pid in list(tracker.tracked.keys()):
if pid not in current_pids:
tracker.cleanup(pid)

for proc in psutil.process_iter(['pid', 'name', 'username', 'cpu_percent', 'create_time', 'cmdline']):
try:
username = proc.info['username']
if not username or username in EXCEPTION_USERS or username.startswith('_'):
continue
if proc.pid < 100:
continue

# Measure CPU (short interval)
cpu = proc.cpu_percent(interval=0.1)
if cpu <= 0:
continue

tracker.update(proc)

if tracker.is_offender(proc.pid):
target = get_safe_rename_target(proc)
bin_path = get_real_binary(proc)
log_bin = bin_path if bin_path else "[IN-MEMORY]"
log(f"OFFENDER DETECTED: PID {proc.pid} | User: {username} | Exe: {log_bin} | Target: {target or '[none]'}")

if kill_process(proc):
if target:
rename_binary(target)
else:
log(" -> No safe /home/ target to rename; skipping rename.")
tracker.cleanup(proc.pid)

except (psutil.NoSuchProcess, psutil.AccessDenied):
continue

time.sleep(CHECK_INTERVAL)

except KeyboardInterrupt:
log("CPU Killer stopped by user")
break
except Exception as e:
log(f"Unexpected error: {e}")
time.sleep(CHECK_INTERVAL)

if os.path.exists(PID_FILE):
os.remove(PID_FILE)

if __name__ == "__main__":
if len(sys.argv) > 1 and sys.argv[1] == "stop":
if os.path.exists(PID_FILE):
with open(PID_FILE) as f:
pid = int(f.read().strip())
try:
os.kill(pid, 15)
log(f"Stopped CPU Killer (PID {pid})")
except:
log("Failed to stop (not running?)")
os.remove(PID_FILE)
else:
log("Not running")
sys.exit(0)

if os.path.exists(PID_FILE):
log("Already running!")
sys.exit(1)

daemonize()
main_loop()

</syntaxhighlight>

Systemd unit'as:
<syntaxhighlight lang="text">
[Unit]
Description=CPU Killer Daemon
After=network.target

[Service]
Type=simple
ExecStart=/root/tools/cpu_killer.py
ExecStop=/root/tools/cpu_killer.py stop
Restart=always
RestartSec=10
StandardOutput=null
StandardError=journal
User=root
PIDFile=/root/tools/cpu_killer.pid

[Install]
WantedBy=multi-user.target
</syntaxhighlight>

[[Category:Scripts]]

Pagrindinis puslapis

2025-11-06T21:10:32Z

\dev\null:

[[Vaizdas:Logo-full-freebsd.png|150px|link=Category:FreeBSD]] [[Vaizdas:OpenBSD-logo.png|150px|link=Category:OpenBSD]] [[Vaizdas:NetBSD-tb.png|50px|link=Category:NetBSD]]
[[Vaizdas:Linux u2.png|100px|link=Category:Linux]] [[Vaizdas:Windows-logo.png|60px|link=Category:Windows]] [[Vaizdas:Logo-mac-transparent.gif|100px|link=Category:Mac OS X]] [[Vaizdas:Programming languages.png|150px|link=Category:Programavimas]] [[Vaizdas:MultimediaIcons rev2.png|150px|link=Category:Multimedia]]
[[Vaizdas:Servers.png|100px|link=Category:Tinklas]] [[Vaizdas:Black-cellphone-icon.png|100px|link=Category:Telefonai]]
[[Vaizdas:Apple-tablet-concept4.png|80px|link=Category:Tablets]] [[Vaizdas:Bendruomene.png|100px|link=Category:Bendruomenė]]
<div class="imagelink_backgroundas">

'''Sveiki!'''

Šis puslapis skirtas visiems tiems kurie ieško informacijos.

Čia rasite patarimų bei kitos naudingos informacijos skirtos sistemų administravimui/panaudojimui, tinklų administravimui/projektavimui, programavimui bei kitiems su IT susijusiems dalykams.

<tagcloud style="background: transparent; padding:0; border:0;">exclude=templates,Wikipedia_pages_with_incorrect_protection,Wikipedia_protected_templates,Protection_templates,Latest_stable_software_release_templates,Wikipedia_pages_with_incorrect_protection_templates,Citation_templates,Computing_templates,File_message_boxes,Internet_Relay_Chat_templates,People_infobox_templates,Protected_main_page_images,Protected_redirects,Puslapiai_su neteisingomis_nuorodomis_į_failus,Statybininkas,Template_sandboxes,Templates_generating_hCards,User_soft_redirects,Wikipedia_message_box_parameter_needs_fixing, Wikipedia_non-empty_soft_redirected_categories, Wikipedia_shortcut_box_first_parameter_needs_fixing, Wikipedia_soft_redirected_categories,Wikipedia_soft_redirected_project_pages,Wikipedia_soft_redirected_talk_pages,Wikipedia_soft_redirected_templates,Wikipedia_soft_redirects,Šablonas_documentation,Wikipedia_message_box_parameter_needs_fixing,Wikipedia_non-empty_soft_redirected_categories,Wikipedia_shortcut_box_first_parameter_needs_fixing,Wikipedia_soft_redirected_categories,Puslapiai_su_neteisingomis_nuorodomis_į_failus</tagcloud>

'''''Naujienos'''''

* 2020.04.03 - Atnaujinta wiki programinė įranga.

== Naujausi įrašai ==

{{Special:NewPages/20}}
</div>
'''Property of [http://www.eofnet.lt EofNET] Networks. 2005-2020.'''

Netcat

2025-11-06T21:09:53Z

\dev\null:

'''Netcat''' yra kompiuterinių tinklų įrankis skirtas skaityti ir į juos rašyti panaudojant [[TCP]] arba [[UDP]] tinklo jungtis. Netcat praktiškai skirtas daugiau skriptų rašymo pritaikymui, dėl jo ypač gausių galimybių. Jis pritaikomas įvairioms su kompiuteriniais tinklais ar serveriais iškilusioms problemoms pręsti. Tai ypač naudingas įrankis tiek sistemų administratoriams tiek tinklo audito ekspertams ir pradžiamoksliams kurie nagrinėja [[TCP/IP]] protokolo veikimą.

'''Netcat''' taip pat vadinamas "Armijos daugiafunkciniu peiliuku skirtu TCP/IP", dėl savo turimų galimybių įskaitant, prievadų skanavimą, failų siuntimą ir klausyma, taip pat jis gali būti naudojamas ir kaip "backdooras".

== Visu interface klausymasis ==
nc -l -p 8080 -s 0.0.0.0
Arba
nc -l -p 8080 0.0.0.0
== Niekada neuždaryti ==
while :; do nc -l -p 8080 -k -q -1 -s 0.0.0.0; done

== Jungtis su tam tikru ip ==
Jeigu mašinoje turime daug ip ir norime, kad prie nuotolinio serverio jungtumėmės nurodytu ip, pridedame parametrą -s, atrodys taip:
nc -s lokalus_ip nutoles_adres.as 21

== Backup over lan naudojant netcat ==

Situacija, kai pradeda failinti ssd diskas ir reikia padaryti jo atsarginę kopiją į [[NAS]], tuomet užkrovus [[live cd]] ir įdėjus naują diską "supushinti" viską atgal..

Sąvokos:
* '''nas.lan''' -> [[NAS]] kuriame bus laikoma atsarginė kopija
* '''pc.lan''' -> [[PC]] kuriame failina diskas ir keičiame jį nauju...
* '''pc.lan.img.gz''' -> Daromo backup archyvo failas

Reikalinga, kad abiejuose pc būtų įdiegti įrankiai: '''netcat, pv, gzip'''. Duomenų suspaudimą/atspaudimą taikysime tiktai '''pc.lan''', kad bereikalingai neapkrautime '''nas.lan'''.

=== Backup ===

Prisijungiame prie '''nas.lan''' ir paleidžiame '''netcat''' (klausimosi režimu):
nc -l -p 9000 > ./pc.lan.img.gz
Iš '''pc.lan''' pushiname disko atvaizdą į '''nas.lan''':
dd if=/dev/sda bs=4M status=progress conv=noerror,sync | pv | gzip | nc nas.lan 9000
Abu procesai abėjose pusėse pabaigoje turėtų išsijungti automatiškai.
Vėliau galima patikrinti backup archyvą:
gzip -t ./pc.lan.img.gz && echo "Backup OK"
=== Restore ===

Išimame iš '''pc.lan''' senajį diską ir įdedame naują, užsikrauname kokį nors [[Linux]] [[live cd]], pvz.: [[Gentoo]], [[ArchLinux]] ar kt. Susitvarkome tinklą ir paleidžiame netcat (klausimosi režimas lauks kol '''nas.lan''' pradės siųsti backup archyvą):
nc -l -p 9000 | pv | gzip -dc | dd of=/dev/sda bs=4M status=progress
Prisijungiame prie '''nas.lan''' ir siunčiame backup archyvą:
cat ./pc.lan.img.gz | nc pc.lan 9000

[[Category:Windows]]
[[Category:Linux]]
[[Category:Archlinux]]
[[Category:Gentoo]]
[[Category:CentOS]]
[[Category:Debian]]
[[Category:Ubuntu]]
[[Category:Slackware]]
[[Category:Tinklas]]

Netcat

2025-11-06T20:40:36Z

\dev\null: dd backup naudojimas backupinti disko atvaizdą į išorinį serverį

'''Netcat''' yra kompiuterinių tinklų įrankis skirtas skaityti ir į juos rašyti panaudojant [[TCP]] arba [[UDP]] tinklo jungtis. Netcat praktiškai skirtas daugiau skriptų rašymo pritaikymui, dėl jo ypač gausių galimybių. Jis pritaikomas įvairioms su kompiuteriniais tinklais ar serveriais iškilusioms problemoms pręsti. Tai ypač naudingas įrankis tiek sistemų administratoriams tiek tinklo audito ekspertams ir pradžiamoksliams kurie nagrinėja [[TCP/IP]] protokolo veikimą.

'''Netcat''' taip pat vadinamas "Armijos daugiafunkciniu peiliuku skirtu TCP/IP", dėl savo turimų galimybių įskaitant, prievadų skanavimą, failų siuntimą ir klausyma, taip pat jis gali būti naudojamas ir kaip "backdooras".

== Visu interface klausymasis ==
nc -l -p 8080 -s 0.0.0.0
Arba
nc -l -p 8080 0.0.0.0
== Niekada neuždaryti ==
while :; do nc -l -p 8080 -k -q -1 -s 0.0.0.0; done

== Jungtis su tam tikru ip ==
Jeigu mašinoje turime daug ip ir norime, kad prie nuotolinio serverio jungtumėmės nurodytu ip, pridedame parametrą -s, atrodys taip:
nc -s lokalus_ip nutoles_adres.as 21

== Backup over lan naudojant netcat ==

Situacija, kai pradeda failinti ssd diskas ir reikia padaryti jo atsarginę kopiją į [[NAS]], tuomet užkrovus [[live cd]] ir įdėjus naują diską "supushinti" viską atgal..

Sąvokos:
* '''nas.lan''' -> [[NAS]] kuriame bus laikoma atsarginė kopija
* '''pc.lan''' -> [[PC]] kuriame failina diskas ir keičiame jį nauju...
* '''pc.lan.img.gz''' -> Daromo backup archyvo failas

Reikalinga, kad abiejuose pc būtų įdiegti įrankiai: '''netcat, pv, gzip'''. Duomenų suspaudimą/atspaudimą taikysime tiktai '''pc.lan''', kad bereikalingai neapkrautime '''nas.lan'''.

=== Backup ===

Prisijungiame prie '''nas.lan''' ir paleidžiame '''netcat''' (klausimosi režimu):
nc -l -p 9000 > ./pc.lan.img.gz
Iš '''pc.lan''' pushiname disko atvaizdą į '''nas.lan''':
dd if=/dev/sda bs=4M status=progress conv=noerror,sync | pv | gzip | nc nas.lan 9000
Abu procesai abėjose pusėse pabaigoje turėtų išsijungti automatiškai.

=== Restore ===

Išimame iš '''pc.lan''' senajį diską ir įdedame naują, užsikrauname kokį nors [[Linux]] [[live cd]], pvz.: [[Gentoo]], [[ArchLinux]] ar kt. Susitvarkome tinklą ir paleidžiame netcat (klausimosi režimas lauks kol '''nas.lan''' pradės siųsti backup archyvą):
nc -l -p 9000 | pv | gzip -dc | dd of=/dev/sda bs=4M status=progress
Prisijungiame prie '''nas.lan''' ir siunčiame backup archyvą:
cat ./pc.lan.img.gz | nc pc.lan 9000

[[Category:Windows]]
[[Category:Linux]]
[[Category:Archlinux]]
[[Category:Gentoo]]
[[Category:CentOS]]
[[Category:Debian]]
[[Category:Ubuntu]]
[[Category:Slackware]]
[[Category:Tinklas]]

Cpu killer

2025-11-02T20:45:17Z

\dev\null: Naujas puslapis: Scriptas skirtas automatiškai killinti userių procesus kurie pastoviai ėda >90% cpu time. Naudoju Free Shells projektui jau eilę metų, čia jau antra scripto iteracija, pirm...

Scriptas skirtas automatiškai killinti userių procesus kurie pastoviai ėda >90% cpu time. Naudoju Free Shells projektui jau eilę metų, čia jau antra scripto iteracija, pirmoji buvo parašyta ant bash.. Scriptas taip pat "decloakina" hidden procesus, t.y pakeistais pavadinimais, pervadina procesą su prefix'u "_too_much_cpu_time". Pervadintas nepasileis automatiškai, jeigu uždėtas ant cron ar kokio kito auto paleisties mechanizmo t.y systemd-user.

<syntaxhighlight lang="python">
#!/usr/bin/env python3
"""
CPU Killer Daemon
- Continuously monitors processes
- Kills if >90% CPU for 10+ minutes
- Renames real binary
- Runs as background service
"""
import os
import sys
import psutil
import shutil
import time
from datetime import datetime
from pathlib import Path
from collections import defaultdict

# ============================= CONFIG =============================
CPU_THRESHOLD = 90.0 # % CPU usage
TIME_THRESHOLD = 600 # seconds (10 minutes)
CHECK_INTERVAL = 30 # check every 30 sec
EXCEPTION_USERS = {'root', 'polkitd', '_chrony', 'postgres', 'nginx', 'devnull', 'zabbix', 'www-data', 'systemd-network', 'systemd-timesync', 'systemd-resolve'} # <--- ADD YOUR USERS HERE
LOG_FILE = "/root/tools/cpu_killer.log"
DRY_RUN = False # Set to True for testing (no kill/rename)
PID_FILE = "/root/tools/cpu_killer.pid"
# ==================================================================

def log(msg):
ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
line = f"[{ts}] {msg}"
print(line)
try:
with open(LOG_FILE, "a") as f:
f.write(line + "\n")
except:
pass

def daemonize():
if os.fork(): sys.exit(0)
os.setsid()
if os.fork(): sys.exit(0)
sys.stdout.flush()
sys.stderr.flush()
with open('/dev/null', 'r') as dev_null:
os.dup2(dev_null.fileno(), sys.stdin.fileno())
with open(LOG_FILE, "a") as f:
os.dup2(f.fileno(), sys.stdout.fileno())
os.dup2(f.fileno(), sys.stderr.fileno())

# Write PID
with open(PID_FILE, "w") as f:
f.write(str(os.getpid()))

class ProcessTracker:
def __init__(self):
self.tracked = {} # pid -> {start_time, cpu_samples}

def update(self, proc):
pid = proc.pid
if pid not in self.tracked:
self.tracked[pid] = {
'start_time': time.time(),
'cpu_samples': []
}
self.tracked[pid]['cpu_samples'].append(proc.cpu_percent())
# Keep last 20 samples (~10 min at 30s interval)
if len(self.tracked[pid]['cpu_samples']) > 20:
self.tracked[pid]['cpu_samples'].pop(0)

def is_offender(self, pid):
data = self.tracked.get(pid)
if not data or len(data['cpu_samples']) < 10:
return False
# Average CPU over last ~5-10 min
avg_cpu = sum(data['cpu_samples']) / len(data['cpu_samples'])
runtime = time.time() - data['start_time']
return avg_cpu >= CPU_THRESHOLD and runtime >= TIME_THRESHOLD

def cleanup(self, pid):
self.tracked.pop(pid, None)

tracker = ProcessTracker()

def get_real_binary(proc):
try:
exe = f"/proc/{proc.pid}/exe"
if not os.path.exists(exe):
return None
path = os.readlink(exe)
if "(deleted)" in path:
path = path.replace(" (deleted)", "").strip()
return path if os.path.exists(path) else None
except:
return None

def rename_binary(bin_path):
if not bin_path or not os.path.exists(bin_path):
return
path = Path(bin_path)
new_name = path.parent / f"{path.stem}_too_much_cpu_time{path.suffix}"
i = 1
while new_name.exists():
new_name = path.parent / f"{path.stem}_too_much_cpu_time.{i}{path.suffix}"
i += 1
log(f" -> Renaming: {path.name} → {new_name.name}")
if not DRY_RUN:
try:
shutil.move(str(path), str(new_name))
except Exception as e:
log(f" -> Rename failed: {e}")

def kill_process(proc):
try:
cmd = " ".join(proc.cmdline()[:3]) + ("..." if len(proc.cmdline()) > 3 else "")
log(f"KILLING PID {proc.pid} ({cmd}) | User: {proc.username()} | CPU: ~{proc.cpu_percent():.1f}%")
if not DRY_RUN:
proc.terminate()
try:
gone, alive = psutil.wait_procs([proc], timeout=5)
if alive:
log(f" -> Force kill")
for p in alive:
p.kill()
except:
pass
return True
except Exception as e:
log(f" -> Kill failed: {e}")
return False

def main_loop():
log("CPU Killer started (daemon mode)")
seen_pids = set()

while True:
try:
current_pids = {p.pid for p in psutil.process_iter()}
# Cleanup dead
for pid in list(tracker.tracked.keys()):
if pid not in current_pids:
tracker.cleanup(pid)

for proc in psutil.process_iter(['pid', 'name', 'username', 'cpu_percent', 'create_time', 'cmdline']):
try:
username = proc.info['username']
if not username or username in EXCEPTION_USERS or username.startswith('_'):
continue
if proc.pid < 100:
continue

# Measure CPU (short interval)
cpu = proc.cpu_percent(interval=0.1)
if cpu <= 0:
continue

tracker.update(proc)

if tracker.is_offender(proc.pid):
bin_path = get_real_binary(proc)
if bin_path:
log(f"OFFENDER DETECTED: PID {proc.pid} | User: {username} | Binary: {bin_path}")
else:
log(f"OFFENDER DETECTED: PID {proc.pid} | User: {username} | Binary: [IN-MEMORY]")

if kill_process(proc):
if bin_path:
rename_binary(bin_path)
tracker.cleanup(proc.pid)

except (psutil.NoSuchProcess, psutil.AccessDenied):
continue

time.sleep(CHECK_INTERVAL)

except KeyboardInterrupt:
log("CPU Killer stopped by user")
break
except Exception as e:
log(f"Unexpected error: {e}")
time.sleep(CHECK_INTERVAL)

if os.path.exists(PID_FILE):
os.remove(PID_FILE)

if __name__ == "__main__":
if len(sys.argv) > 1 and sys.argv[1] == "stop":
if os.path.exists(PID_FILE):
with open(PID_FILE) as f:
pid = int(f.read().strip())
try:
os.kill(pid, 15)
log(f"Stopped CPU Killer (PID {pid})")
except:
log("Failed to stop (not running?)")
os.remove(PID_FILE)
else:
log("Not running")
sys.exit(0)

if os.path.exists(PID_FILE):
log("Already running!")
sys.exit(1)

daemonize()
main_loop()

</syntaxhighlight>

Systemd unit'as:
<syntaxhighlight lang="text">
[Unit]
Description=CPU Killer Daemon
After=network.target

[Service]
Type=simple
ExecStart=/root/tools/cpu_killer.py
ExecStop=/root/tools/cpu_killer.py stop
Restart=always
RestartSec=10
StandardOutput=null
StandardError=journal
User=root
PIDFile=/root/tools/cpu_killer.pid

[Install]
WantedBy=multi-user.target
</syntaxhighlight>

[[Category:Scripts]]

UConsole

2025-10-28T21:25:37Z

\dev\null:

== Vidinis USB ==

Hackas kuris leidžia pasidaryti vidinį usb portą, skirtą pvz.: papildomam vidiniam [[wifi]], [[sdr]] ar [[LoRa]] įrenginiui.

[[Vaizdas:Screenshot 20251025 124247-2.png|1200px|frameless]]

[[Vaizdas:Usb-3-pinout.webp|400px]]

=== Kaip atrodo ===

[[Vaizdas:Uconsole internal usb hack1.jpg|400px]]

[[Vaizdas:Uconsole internal usb hack2.jpg|800px]]

[[Vaizdas:Uconsole internal usb hack3.jpg|800px]]

[[Category:Hardware]]

RTL8812AU

2025-10-28T21:25:09Z

\dev\null:

== Linux Drivers ==

* [https://github.com/morrownr/8812au-20210820 Linux Driver for USB WiFi Adapters that are based on the RTL8812AU Chipset]

== RTL8812AU/21AU and RTL8814AU driver with monitor mode and frame injection ==

Sistemoje jau turėtų būti esamo kernelio headeriai.

sudo apt-get install dkms build-essential
git clone https://github.com/aircrack-ng/rtl8812au.git
cd rtl8812au
sudo make dkms_install

[[Category:Tinklas]]
[[Category:Hardware]]
{{Template:Distributions}}

RTL8812AU

2025-10-28T21:24:55Z

\dev\null:

== Linux Drivers ==

* [https://github.com/morrownr/8812au-20210820 Linux Driver for USB WiFi Adapters that are based on the RTL8812AU Chipset]

== RTL8812AU/21AU and RTL8814AU driver with monitor mode and frame injection ==

Sistemoje jau turėtų būti esamo kernelio headeriai.

sudo apt-get install dkms build-essential
git clone https://github.com/aircrack-ng/rtl8812au.git
cd rtl8812au
sudo make dkms_install

[[Category:Tinkas]]
[[Category:Hardware]]
{{Template:Distributions}}

UConsole

2025-10-25T13:37:34Z

\dev\null:

== Vidinis USB ==

Hackas kuris leidžia pasidaryti vidinį usb portą, skirtą pvz.: papildomam vidiniam [[wifi[[, [[sdr]] ar [[LoRa]] įrenginiui.

[[Vaizdas:Screenshot 20251025 124247-2.png|1200px|frameless]]

[[Vaizdas:Usb-3-pinout.webp|400px]]

=== Kaip atrodo ===

[[Vaizdas:Uconsole internal usb hack1.jpg|400px]]

[[Vaizdas:Uconsole internal usb hack2.jpg|800px]]

[[Vaizdas:Uconsole internal usb hack3.jpg|800px]]

[[Category:Hardware]]

Vaizdas:Uconsole internal usb hack3.jpg

2025-10-25T13:34:20Z

\dev\null:

Vaizdas:Uconsole internal usb hack2.jpg

2025-10-25T13:33:53Z

\dev\null:

Vaizdas:Uconsole internal usb hack1.jpg

2025-10-25T13:33:27Z

\dev\null:

UConsole

2025-10-25T11:57:31Z

\dev\null:

== Vidinis USB ==

[[Vaizdas:Screenshot 20251025 124247-2.png|1200px|frameless]]

[[Vaizdas:Usb-3-pinout.webp|400px]]

[[Category:Hardware]]

Vaizdas:Usb-3-pinout.webp

2025-10-25T11:57:13Z

\dev\null:

UConsole

2025-10-25T11:05:12Z

\dev\null: Naujas puslapis: == Vidinis USB == frameless Category:Hardware

== Vidinis USB ==

[[Vaizdas:Screenshot 20251025 124247-2.png|1200px|frameless]]

[[Category:Hardware]]

Vaizdas:Screenshot 20251025 124247-2.png

2025-10-25T11:03:48Z

\dev\null:

Aiva

2025-10-18T17:35:54Z

\dev\null:

Kaip paleisti ant Linux naudojant Wine aprašyta [[Aiva wine|čia]].

== Naujas deploymentas ==

Paredaguojam db parametrus '''api/db.php''' ir '''vb1/config.php''' failuose, taip pat mysql'e reikia pakeisti įrašus odbc connectoriaus ir ftp loginų:
update catalogue_login set url='aiva.domenas.lt', odbc_par = 'duombazes_name;duombazes_user;duombazes_pass;aiva.domenas.lt', xftpserv = 'aiva.domenas.lt', xftpserv_par = 'ftpuser;ftppass', ximgadr = '<nowiki>http://aiva.domenas.lt/images/goods</nowiki>' where id = 1;

Kliente keičiamas '''config.ini''' ir ten įrašomas api endpointo hostas:
[MAIN]
IP=aiva.domenas.lt

== Klaida neautorizuota darbo vieta ==

Pažiūrim įjunge MySQL log:
SET GLOBAL general_log = ON;
tail -f /var/log/mysql/mysql.log |grep select|grep -vE "scg|tiekejai|pg_seima|goods_v|scdkiek"
Rodys kažką panašaus į
select v_id,akt_date,akt_ip,akt_host,akt_nr from admin_dvietos where protect='51096786716' and del_date is NULL
Reikia atnaujinti esamą įrašą arba įrašyti naują su '''protect''' kintamuoju kurio ieško:
update admin_dvietos set akt_ip = '192.168.20', akt_host = 'legion7', protect='51096786716' where v_id = 56;

Aiva

2025-10-18T17:26:55Z

\dev\null: Naujas puslapis: Kaip paleisti ant Linux naudojant Wine aprašyta čia. == Klaida neautorizuota darbo vieta == Pažiūrim įjunge MySQL log: SET GLOBAL general_log = ON; tail...

Kaip paleisti ant Linux naudojant Wine aprašyta [[Aiva wine|čia]].

== Klaida neautorizuota darbo vieta ==

Pažiūrim įjunge MySQL log:
SET GLOBAL general_log = ON;
tail -f /var/log/mysql/mysql.log |grep select|grep -vE "scg|tiekejai|pg_seima|goods_v|scdkiek"
Rodys kažką panašaus į
select v_id,akt_date,akt_ip,akt_host,akt_nr from admin_dvietos where protect='51096786716' and del_date is NULL
Reikia atnaujinti esamą įrašą arba įrašyti naują su '''protect''' kintamuoju kurio ieško:
update admin_dvietos set akt_ip = '192.168.20', akt_host = 'legion7', protect='51096786716' where v_id = 56;

Jumpserver

2025-10-17T12:57:17Z

\dev\null: Naujas puslapis: mkdir -p /srv/dockers/jumpserver/dbdata mkdir -p /srv/dockers/jumpserver/jsdata Susigeneruojame '''SECRET_KEY''' ir '''BOOTSTRAP_TOKEN''': openssl rand -base64 48 <syntaxhi...

mkdir -p /srv/dockers/jumpserver/dbdata
mkdir -p /srv/dockers/jumpserver/jsdata

Susigeneruojame '''SECRET_KEY''' ir '''BOOTSTRAP_TOKEN''':
openssl rand -base64 48

<syntaxhighlight lang="yaml">
# https://github.com/jumpserver/Dockerfile/tree/master/allinone
services:
jumpserver:
container_name: jumpserver
image: jumpserver/jms_all
volumes:
- jsdata:/opt/data
- pgdata:/var/lib/postgresql
networks:
- traefik
ports:
- 2222:2222
environment:
TZ: "Europe/Vilnius"
SECRET_KEY: "xxx"
BOOTSTRAP_TOKEN: "xxx"
restart: unless-stopped
labels:
- traefik.enable=true
- traefik.docker.network=traefik
- "traefik.http.routers.jumpserver.rule=Host(`jumpserver.domenas.lt`)"
- "traefik.http.services.jumpserver.loadbalancer.server.port=80"
# resources limit
mem_limit: 2G
cpus: 3.0

networks:
traefik:
external: true

volumes:
pgdata:
driver: local
driver_opts:
type: none
o: bind
device: /srv/dockers/jumpserver/dbdata
jsdata:
driver: local
driver_opts:
type: none
o: bind
device: /srv/dockers/jumpserver/jsdata
</syntaxhighlight>

[[Category:Docker]]

Water level QDY30B

2025-10-07T19:39:03Z

\dev\null: /* Rezultatas */

Vandens lygio matuoklis paremtas '''QDY30B''' sensoriumi. '''Pagrindinė sprendžiama problema:''' hidroforo išjungimas pasiekus kritinį vandens lygio tašką, t.y kai hidroforo įėimo vamzdis nepasiekia vandens išjungti jam maitinimą. Taip pat papildomai integracija į MQTT/Home Assistant vandens lygio matavimams centimetrais/metrais.

== Reikalingos medžiagos ==

* [https://www.aliexpress.com/item/1005007266883113.html Submersible Liquid Level Sensor Water Tank Pressure Transmitter 4-20mA 0-10V RS485 Water River Level Transmitter] šiame aprašyme naudojamas '''4-20mA output, 5M range 10m cable'''
* [https://www.aliexpress.com/item/1005003692342096.html Hi-Link 30W 24 AC DC Single Output Power Supply Module HLK-30M24C]
* [https://www.aliexpress.com/item/1005001906090486.html ESP8266 WIFI Wireless Relay Module ESP-12F AC 220V DC 5V 12V Power Supply ESP 12F Development Board Remote Control Smart Home] modulis su '''ESP-12F'''
* [https://www.aliexpress.com/item/1005006264135776.html Metal Film Resistor 2W 47R] tipas '''2W 47R'''
* [https://www.aliexpress.com/item/1005007929336683.html Ceramic Capacitor 104 0.1uF 100NF 50V] tipas 104
* Bet kokia elektros paskirstymo hermetinė IP66 dėžutė iš Senukų arba Ermitažo (kad tilptų viskas sugrūsti).

=== Kaip atrodo medžiagos ===

[[Vaizdas:Screenshot 2025-10-06 at 22.20.34.png|300px]]
[[Vaizdas:Screenshot 2025-10-06 at 22.20.58.png|300px]]
[[Vaizdas:Screenshot 2025-10-06 at 22.21.14.png|300px]]
[[Vaizdas:100-pcs-50-ohm-0-25w-metal-film-resistor-1-4w-mfr-emerging-original-imafwyhbdnhmgex3.jpeg-2.webp|300px]]
[[Vaizdas:0011952 01f-50v-disc-ceramic-capacitor 550-2.jpg|300px]]

== Sujungimo schema ==

<code>
From Sensor (Blue wire, 4–20 mA −)
│
│
├───────> To ESP8266 ADC0 (A0) ← sense wire
│
│
[===] ← 47 Ω resistor (shunt)
[ ]
│
│
GND (shared with 24 V PSU and ESP8266)
</code>

'''Sujungimas:'''
* Prijungiame mėlyną sensoriaus laidą prie vienos 50R rezistoriaus kojos.
* Kitą rezistoriaus koją prijungiame prie žemės (GND).
* Prilituojame keramikinį kondensatorių tiesiai per abi rezistoriaus kojas (lygiagrečiai).
* Nuo mėlyno laido pusės (kur prijungtas prie rezistoriaus) išvedame trumpą laidą į ESP8266 ADC0 (A0) įėjimą.
* Įsitikiname, kad maitinimo šaltinis (PSU) ir ESP8266 turi bendrą žemę (GND).

=== Kaip atrodo sujungimas ===

[[Vaizdas:Water level scheme in action1.png|600px]]

[[Vaizdas:Water level scheme in action2.png|600px]]

== ESPHome Firmware kodas ==

=== water_level.yaml ===

Pagrindinis esphome aprašas/kodas:
<syntaxhighlight lang="yaml">
substitutions:
device_name: waterlevel-qdy30b
friendly_name: "Water Level"
r_shunt_ohm: "47.0" # 47 Ω
max_depth_m: "5.0" # probe range max (meters)
zero_offset_cm: "-6.0" # offset calibration: 33 → 27 cm, so -6 cm
threshold_max_cm: "500.0" # 5.0 m × 100 = 500 cm
relay_gpio: GPIO15 # Board relay pin which is soldered to

esphome:
name: ${device_name}
on_boot:
priority: 800
then:
- delay: 500ms
- lambda: |-
id(apply_control).execute();
preferences:
flash_write_interval: 10s

esp8266:
board: esp12e
restore_from_flash: true # restore states after power off

wifi:
ssid: !secret wifi_ap
password: !secret wifi_password
ap: # fallback AP if Wi-Fi fails
ssid: "${device_name}_AP"
password: !secret wifi_direct

mqtt:
broker: !secret mqtt_broker
client_id: ${device_name}-client
username: water_level
password: MyMQTTPassword
discovery: true

logger:
ota:
- platform: esphome
web_server: # small built-in web page for quick checks
port: 80

# --- RELAY (physical output) ---
switch:
- platform: gpio
id: pump_relay
name: "${friendly_name} Relay"
pin:
number: ${relay_gpio}
inverted: false # set to true if your relay is active-LOW
restore_mode: RESTORE_DEFAULT_OFF # restores last known state (if none saved, default OFF)

- platform: template
id: auto_enable
name: "${friendly_name} Pump Automation"
optimistic: true
restore_mode: RESTORE_DEFAULT_OFF # restores last saved; defaults OFF if none yet
turn_on_action:
- lambda: |-
id(apply_control).execute();
turn_off_action:
- logger.log: "Automation disabled — relay left unchanged."

# --- SENSORS ---
sensor:
# Raw voltage across the shunt (A0 is 0..1.0 V on ESP12F)
- platform: adc
pin: A0
id: loop_voltage
name: "${friendly_name} Loop Voltage"
unit_of_measurement: "V"
accuracy_decimals: 3
update_interval: 1s
filters:
# light smoothing; A0 can be a bit noisy
- median:
window_size: 7
send_every: 3
send_first_at: 1

# Convert V -> current (mA): I = V / R * 1000
- platform: template
id: loop_current
name: "${friendly_name} Loop Current"
unit_of_measurement: "mA"
accuracy_decimals: 2
update_interval: 1s
lambda: |-
return (id(loop_voltage).state / ${r_shunt_ohm}) * 1000.0;
filters:
# keep values in a sane range
- clamp:
min_value: 0.0
max_value: 30.0

- platform: wifi_signal
name: "${friendly_name} WiFi RSSI"
update_interval: 30s
- platform: uptime
name: "${friendly_name} Uptime"

# Depth in centimeters (from the computed meters)
- platform: template
id: water_depth_cm
name: "${friendly_name} Depth CM"
unit_of_measurement: "cm"
device_class: distance
state_class: measurement
accuracy_decimals: 0 # whole centimeters; set 1 if you want 0.1 cm
update_interval: 1s
lambda: |-
// reuse the meters reading we already compute
return id(water_depth).state * 100.0;
on_value:
then:
- lambda: |-
id(apply_control).execute();

# Map 4–20 mA to 0–MAX_DEPTH meters
- platform: template
id: water_depth
name: "${friendly_name} Depth"
unit_of_measurement: "m"
accuracy_decimals: 2
update_interval: 1s
lambda: |-
const float I = id(loop_current).state; // mA
float d = (I - 4.0f) / 16.0f * ${max_depth_m}; // ideal meters
d += (${zero_offset_cm} / 100.0f); // apply offset in meters
if (d < 0.0f) d = 0.0f;
if (d > ${max_depth_m}) d = ${max_depth_m};
return d;
filters:
- throttle: 1s

number:
- platform: template
id: threshold_cm
name: "${friendly_name} Threshold (cm)"
min_value: 0.0
max_value: ${threshold_max_cm} # must be a number, not a lambda
step: 1.0
optimistic: true
restore_value: true
initial_value: 30.0
set_action:
- lambda: |-
id(apply_control).execute();

# Optional: handy extras
text_sensor:
- platform: wifi_info
ip_address:
name: "${friendly_name} IP"

script:
- id: apply_control
mode: restart
then:
- if:
condition:
switch.is_on: auto_enable
then:
- if:
condition:
lambda: |-
return id(water_depth_cm).state > id(threshold_cm).state;
then:
- if:
condition:
switch.is_off: pump_relay
then:
- logger.log: "Automation: depth > threshold → Relay ON"
- switch.turn_on: pump_relay
else:
- if:
condition:
switch.is_on: pump_relay
then:
- logger.log: "Automation: depth ≤ threshold → Relay OFF"
- switch.turn_off: pump_relay
else:
- logger.log: "Automation disabled — no action taken."
</syntaxhighlight>

=== secrets.yaml ===

Šiame faile aprašoma wifi/mqtt/slaptažodžiai.
<syntaxhighlight lang="yaml">
wifi_ap: SSID
wifi_password: 123456789
wifi_direct: 123456789
mqtt_broker: 192.168.1.1
</syntaxhighlight>

== Flashinimas ==

Pirmiausia reiktų susidiegti esphome python3 modulį:
pip3 install esphome

Flashinti reikia per relės UART interfeisą, micro USB interfeisas tam reikalui neskirtas. Pajungiame USB Serial TTL adapterį, sujungiame RX/TX/GND/5V ir galime flashinti, pirmam kartui taip pat būtina užtrumpinti GND + 101 prieš įjungiant įrenginį (randasi tame pačiame UART layoute).

Norint, kad veiktų rėlė taip pat reikia sulituoti kartu pinus: '''Relay + 1015'''.

Kompiluojame ir flashiname:
python3 -m esphome compile water_level.yaml
python3 -m esphome upload water_level.yaml

Vėliau galime flashinti over the air (per tinklą) metodu:
python3 -m esphome upload --device DEVICE_IP water_level.yaml

== Rezultatas ==

[[Vaizdas:Water level monitoring box1.jpg|300px]]

[[Vaizdas:Water level monitoring box2.jpg|300px]]

[[Vaizdas:Screenshot 2025-10-06 at 22.50.23.png|600px]]

Kaip matome galime nustatyti kiek CM yra kritinis taškas, žemiau jo relė išsijungia, taip pat galima šią automatiką išjungti arba įjungti. Įjungimo išjungimo būsenos tai pat saugomos po power loss ar atsitiktinių elektros atjungimų, kas yra būtina išlaikant testinumą. Taipogi galima rankiniu būdu valdyti rėlę prieš tai išjungus automatiką. Pagal nutylėjimą pirmam leidimui visos pozicijos yra išjungtos.

[[Category:Hardware]]
[[Category:IoT]]
[[Category:ESP8266]]
[[Category:Microcontrollers]]

Vaizdas:Water level monitoring box2.jpg

2025-10-07T19:38:46Z

\dev\null:

Vaizdas:Water level monitoring box1.jpg

2025-10-07T19:38:26Z

\dev\null:

Water level QDY30B

2025-10-06T20:15:46Z

\dev\null:

Vandens lygio matuoklis paremtas '''QDY30B''' sensoriumi. '''Pagrindinė sprendžiama problema:''' hidroforo išjungimas pasiekus kritinį vandens lygio tašką, t.y kai hidroforo įėimo vamzdis nepasiekia vandens išjungti jam maitinimą. Taip pat papildomai integracija į MQTT/Home Assistant vandens lygio matavimams centimetrais/metrais.

== Reikalingos medžiagos ==

* [https://www.aliexpress.com/item/1005007266883113.html Submersible Liquid Level Sensor Water Tank Pressure Transmitter 4-20mA 0-10V RS485 Water River Level Transmitter] šiame aprašyme naudojamas '''4-20mA output, 5M range 10m cable'''
* [https://www.aliexpress.com/item/1005003692342096.html Hi-Link 30W 24 AC DC Single Output Power Supply Module HLK-30M24C]
* [https://www.aliexpress.com/item/1005001906090486.html ESP8266 WIFI Wireless Relay Module ESP-12F AC 220V DC 5V 12V Power Supply ESP 12F Development Board Remote Control Smart Home] modulis su '''ESP-12F'''
* [https://www.aliexpress.com/item/1005006264135776.html Metal Film Resistor 2W 47R] tipas '''2W 47R'''
* [https://www.aliexpress.com/item/1005007929336683.html Ceramic Capacitor 104 0.1uF 100NF 50V] tipas 104
* Bet kokia elektros paskirstymo hermetinė IP66 dėžutė iš Senukų arba Ermitažo (kad tilptų viskas sugrūsti).

=== Kaip atrodo medžiagos ===

[[Vaizdas:Screenshot 2025-10-06 at 22.20.34.png|300px]]
[[Vaizdas:Screenshot 2025-10-06 at 22.20.58.png|300px]]
[[Vaizdas:Screenshot 2025-10-06 at 22.21.14.png|300px]]
[[Vaizdas:100-pcs-50-ohm-0-25w-metal-film-resistor-1-4w-mfr-emerging-original-imafwyhbdnhmgex3.jpeg-2.webp|300px]]
[[Vaizdas:0011952 01f-50v-disc-ceramic-capacitor 550-2.jpg|300px]]

== Sujungimo schema ==

<code>
From Sensor (Blue wire, 4–20 mA −)
│
│
├───────> To ESP8266 ADC0 (A0) ← sense wire
│
│
[===] ← 47 Ω resistor (shunt)
[ ]
│
│
GND (shared with 24 V PSU and ESP8266)
</code>

'''Sujungimas:'''
* Prijungiame mėlyną sensoriaus laidą prie vienos 50R rezistoriaus kojos.
* Kitą rezistoriaus koją prijungiame prie žemės (GND).
* Prilituojame keramikinį kondensatorių tiesiai per abi rezistoriaus kojas (lygiagrečiai).
* Nuo mėlyno laido pusės (kur prijungtas prie rezistoriaus) išvedame trumpą laidą į ESP8266 ADC0 (A0) įėjimą.
* Įsitikiname, kad maitinimo šaltinis (PSU) ir ESP8266 turi bendrą žemę (GND).

=== Kaip atrodo sujungimas ===

[[Vaizdas:Water level scheme in action1.png|600px]]

[[Vaizdas:Water level scheme in action2.png|600px]]

== ESPHome Firmware kodas ==

=== water_level.yaml ===

Pagrindinis esphome aprašas/kodas:
<syntaxhighlight lang="yaml">
substitutions:
device_name: waterlevel-qdy30b
friendly_name: "Water Level"
r_shunt_ohm: "47.0" # 47 Ω
max_depth_m: "5.0" # probe range max (meters)
zero_offset_cm: "-6.0" # offset calibration: 33 → 27 cm, so -6 cm
threshold_max_cm: "500.0" # 5.0 m × 100 = 500 cm
relay_gpio: GPIO15 # Board relay pin which is soldered to

esphome:
name: ${device_name}
on_boot:
priority: 800
then:
- delay: 500ms
- lambda: |-
id(apply_control).execute();
preferences:
flash_write_interval: 10s

esp8266:
board: esp12e
restore_from_flash: true # restore states after power off

wifi:
ssid: !secret wifi_ap
password: !secret wifi_password
ap: # fallback AP if Wi-Fi fails
ssid: "${device_name}_AP"
password: !secret wifi_direct

mqtt:
broker: !secret mqtt_broker
client_id: ${device_name}-client
username: water_level
password: MyMQTTPassword
discovery: true

logger:
ota:
- platform: esphome
web_server: # small built-in web page for quick checks
port: 80

# --- RELAY (physical output) ---
switch:
- platform: gpio
id: pump_relay
name: "${friendly_name} Relay"
pin:
number: ${relay_gpio}
inverted: false # set to true if your relay is active-LOW
restore_mode: RESTORE_DEFAULT_OFF # restores last known state (if none saved, default OFF)

- platform: template
id: auto_enable
name: "${friendly_name} Pump Automation"
optimistic: true
restore_mode: RESTORE_DEFAULT_OFF # restores last saved; defaults OFF if none yet
turn_on_action:
- lambda: |-
id(apply_control).execute();
turn_off_action:
- logger.log: "Automation disabled — relay left unchanged."

# --- SENSORS ---
sensor:
# Raw voltage across the shunt (A0 is 0..1.0 V on ESP12F)
- platform: adc
pin: A0
id: loop_voltage
name: "${friendly_name} Loop Voltage"
unit_of_measurement: "V"
accuracy_decimals: 3
update_interval: 1s
filters:
# light smoothing; A0 can be a bit noisy
- median:
window_size: 7
send_every: 3
send_first_at: 1

# Convert V -> current (mA): I = V / R * 1000
- platform: template
id: loop_current
name: "${friendly_name} Loop Current"
unit_of_measurement: "mA"
accuracy_decimals: 2
update_interval: 1s
lambda: |-
return (id(loop_voltage).state / ${r_shunt_ohm}) * 1000.0;
filters:
# keep values in a sane range
- clamp:
min_value: 0.0
max_value: 30.0

- platform: wifi_signal
name: "${friendly_name} WiFi RSSI"
update_interval: 30s
- platform: uptime
name: "${friendly_name} Uptime"

# Depth in centimeters (from the computed meters)
- platform: template
id: water_depth_cm
name: "${friendly_name} Depth CM"
unit_of_measurement: "cm"
device_class: distance
state_class: measurement
accuracy_decimals: 0 # whole centimeters; set 1 if you want 0.1 cm
update_interval: 1s
lambda: |-
// reuse the meters reading we already compute
return id(water_depth).state * 100.0;
on_value:
then:
- lambda: |-
id(apply_control).execute();

# Map 4–20 mA to 0–MAX_DEPTH meters
- platform: template
id: water_depth
name: "${friendly_name} Depth"
unit_of_measurement: "m"
accuracy_decimals: 2
update_interval: 1s
lambda: |-
const float I = id(loop_current).state; // mA
float d = (I - 4.0f) / 16.0f * ${max_depth_m}; // ideal meters
d += (${zero_offset_cm} / 100.0f); // apply offset in meters
if (d < 0.0f) d = 0.0f;
if (d > ${max_depth_m}) d = ${max_depth_m};
return d;
filters:
- throttle: 1s

number:
- platform: template
id: threshold_cm
name: "${friendly_name} Threshold (cm)"
min_value: 0.0
max_value: ${threshold_max_cm} # must be a number, not a lambda
step: 1.0
optimistic: true
restore_value: true
initial_value: 30.0
set_action:
- lambda: |-
id(apply_control).execute();

# Optional: handy extras
text_sensor:
- platform: wifi_info
ip_address:
name: "${friendly_name} IP"

script:
- id: apply_control
mode: restart
then:
- if:
condition:
switch.is_on: auto_enable
then:
- if:
condition:
lambda: |-
return id(water_depth_cm).state > id(threshold_cm).state;
then:
- if:
condition:
switch.is_off: pump_relay
then:
- logger.log: "Automation: depth > threshold → Relay ON"
- switch.turn_on: pump_relay
else:
- if:
condition:
switch.is_on: pump_relay
then:
- logger.log: "Automation: depth ≤ threshold → Relay OFF"
- switch.turn_off: pump_relay
else:
- logger.log: "Automation disabled — no action taken."
</syntaxhighlight>

=== secrets.yaml ===

Šiame faile aprašoma wifi/mqtt/slaptažodžiai.
<syntaxhighlight lang="yaml">
wifi_ap: SSID
wifi_password: 123456789
wifi_direct: 123456789
mqtt_broker: 192.168.1.1
</syntaxhighlight>

== Flashinimas ==

Pirmiausia reiktų susidiegti esphome python3 modulį:
pip3 install esphome

Flashinti reikia per relės UART interfeisą, micro USB interfeisas tam reikalui neskirtas. Pajungiame USB Serial TTL adapterį, sujungiame RX/TX/GND/5V ir galime flashinti, pirmam kartui taip pat būtina užtrumpinti GND + 101 prieš įjungiant įrenginį (randasi tame pačiame UART layoute).

Norint, kad veiktų rėlė taip pat reikia sulituoti kartu pinus: '''Relay + 1015'''.

Kompiluojame ir flashiname:
python3 -m esphome compile water_level.yaml
python3 -m esphome upload water_level.yaml

Vėliau galime flashinti over the air (per tinklą) metodu:
python3 -m esphome upload --device DEVICE_IP water_level.yaml

== Rezultatas ==

[[Vaizdas:Screenshot 2025-10-06 at 22.50.23.png|600px]]

Kaip matome galime nustatyti kiek CM yra kritinis taškas, žemiau jo relė išsijungia, taip pat galima šią automatiką išjungti arba įjungti. Įjungimo išjungimo būsenos tai pat saugomos po power loss ar atsitiktinių elektros atjungimų, kas yra būtina išlaikant testinumą. Taipogi galima rankiniu būdu valdyti rėlę prieš tai išjungus automatiką. Pagal nutylėjimą pirmam leidimui visos pozicijos yra išjungtos.

[[Category:Hardware]]
[[Category:IoT]]
[[Category:ESP8266]]
[[Category:Microcontrollers]]

Water level QDY30B

2025-10-06T19:58:52Z

\dev\null: /* Sujungimo schema */

Water level QDY30B

2025-10-06T19:55:25Z

\dev\null:

Water level QDY30B

2025-10-06T19:54:53Z

\dev\null:

Vaizdas:Screenshot 2025-10-06 at 22.50.23.png

2025-10-06T19:51:19Z

\dev\null:

Water level QDY30B

2025-10-06T19:48:54Z

\dev\null:

Vaizdas:Water level scheme in action2.png

2025-10-06T19:43:45Z

\dev\null:

Vaizdas:Water level scheme in action1.png

2025-10-06T19:43:23Z

\dev\null:

Vaizdas:0011952 01f-50v-disc-ceramic-capacitor 550-2.jpg

2025-10-06T19:31:58Z

\dev\null:

Vaizdas:100-pcs-50-ohm-0-25w-metal-film-resistor-1-4w-mfr-emerging-original-imafwyhbdnhmgex3.jpeg-2.webp

2025-10-06T19:31:36Z

\dev\null:

Vaizdas:Screenshot 2025-10-06 at 22.21.14.png

2025-10-06T19:24:52Z

\dev\null:

Vaizdas:Screenshot 2025-10-06 at 22.20.58.png

2025-10-06T19:24:23Z

\dev\null:

Vaizdas:Screenshot 2025-10-06 at 22.20.34.png

2025-10-06T19:23:32Z

\dev\null:

Water level QDY30B

2025-10-06T19:21:27Z

\dev\null: Naujas puslapis: Vandens lygio matuoklis paremtas '''QDY30B''' sensorium. '''Pagrindinė sprendžiama problema:''' hidroforo išjungimas pasiekus kritinį vandens lygio tašką, t.y kai hidroforo...

Vandens lygio matuoklis paremtas '''QDY30B''' sensorium. '''Pagrindinė sprendžiama problema:''' hidroforo išjungimas pasiekus kritinį vandens lygio tašką, t.y kai hidroforo įėimo vamzdis nepasiekia vandens išjungti jam maitinimą.

== Reikalingos medžiagos ==

* [https://www.aliexpress.com/item/1005007266883113.html Submersible Liquid Level Sensor Water Tank Pressure Transmitter 4-20mA 0-10V RS485 Water River Level Transmitter] šiame aprašyme naudojamas '''4-20mA output, 5M range 10m cable'''
* [https://www.aliexpress.com/item/1005003692342096.html Hi-Link 30W 24 AC DC Single Output Power Supply Module HLK-30M24C]
* [https://www.aliexpress.com/item/1005001906090486.html ESP8266 WIFI Wireless Relay Module ESP-12F AC 220V DC 5V 12V Power Supply ESP 12F Development Board Remote Control Smart Home] modulis su '''ESP-12F'''
* Bet kokia elektros paskirstymo hermetinė IP66 dežutė iš senukų arba ermitažo (kad tilptų viskas sugrūsti).

=== Kaip atrodo medžiagos ===

[[Category:Hardware]]
[[Category:IoT]]
[[Category:ESP8266]]
[[Category:Microcontrollers]]

Docker

2025-09-24T20:14:03Z

\dev\null: /* Tinklas */

'''Docker''' yra atviro kodo projektas skirtas automatizuoti programinės įrangos projektams iš programinės įrangos lygmens konteinerių. Docker konteineriai su failų sistemos palaikymu, sisteminėmis programomis bei bibliotekomis - viskas ko jums reikia paleisti serverį. Garantuotai paleisite tai ką ir turite paleisti, nepriklausant nuo sistemos aplinkos kur tai darote.

Docker suteikia papildomą virtualizacijos, automatikos lygmenį operacijų sistemos lygmenyje pačiame Linux. Docker naudoja Linux resursų izoliavimą [[cgroups]], branduolio vardinius susiejimus, ir [[aufs]] (angl. union-capable filesystem). Tai leidžia nepriklausomai valdyti kelis konteinerius vienoje Linux sistemoje, neužkraunant jos dideliomis apkrovomis kurių reikalauja virtualios mašinos. Linux branduolio vardinių sąsajų palaikymas izoliuoja kaip programos mato pačia operacijų sistemą, izoliuojami procesai, tinklas, vartotojo id, primontuotos failų sistemos, taip pat neprarandamas [[cgroups]] resursų ribojimas (CPU, atmintis, I/O, Tinklas). Nuo docker 0.9 versijos įtraukiama libcontainer biblioteka kuri tiesiogiai bendrauja su virtualizacijos sistemomis esančiomis Linux branduolyje, priedo tai apdorojama per virtualizacijos sąsajas [[libvirt]], [[LXC]] (Linux Containers) ir [[systemd-nspawn]].

== Docker diegimas Debian sistemose ==

sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg2 \
software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
sudo apt-key fingerprint 0EBFCD88
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/debian \
$(lsb_release -cs) \
stable"
sudo apt-get update
sudo apt-get install docker-ce

== Komandų vykdymas dockeryje ==

Vykdyti komandas
docker exec -it <docker_pavadinimas> id
Įjungti shellą
docker exec -it <docker_pavadinimas> bash

== Konkretaus konteinerio logų pravalymas ==

truncate -s 0 $(docker inspect --format='<nowiki>{{.LogPath}}</nowiki>' <container_name_or_id>)
arba
echo "" > $(docker inspect --format='<nowiki>{{.LogPath}}</nowiki>' <container_name_or_id>)
Kuriant konteinerį logų limito nurodymas
docker run --log-driver json-file --log-opt max-size=10m --log-opt max-file=3 ...

== Tinklas ==

=== Macvlan (ip tame pačiame tinkle) ===

<syntaxhighlight lang="bash">
docker network create -d macvlan --subnet=192.1.14.0/24 --ip-range 192.1.14.240/28 --gateway 192.1.14.254 -o parent=eth0 local-lan
docker run -itd --name Alpine --ip=192.1.14.241 --net=local-lan alpine /bin/sh
docker exec -it Alpine ip addr
exec -it Alpine ping 192.1.14.254
</syntaxhighlight>

=== Visų tinklų gateway ===

<syntaxhighlight lang="bash">
for n in $(docker network ls --format '{{.Name}}'); do
docker network inspect "$n" --format '{{.Name}} {{range .IPAM.Config}}{{.Gateway}} {{end}}'
done
</syntaxhighlight>

=== Randam kuris tinklas naudoja konkretų gateway ===

<syntaxhighlight lang="bash">
for id in $(docker network ls -q); do
gw="$(docker network inspect "$id" -f '{{range .IPAM.Config}}{{.Gateway}} {{end}}')"
if grep -qw '192.168.1.1' <<<"$gw"; then
docker network inspect "$id" -f '{{.Name}} ({{.Id}})'
fi
done
</syntaxhighlight>

[[Category:Virtualizacija]]
[[Category:Linux]]
[[Category:Tinklas]]
{{Template:Distributions}}
[[Category:Docker]]

Docker

2025-09-24T20:13:47Z

\dev\null:

'''Docker''' yra atviro kodo projektas skirtas automatizuoti programinės įrangos projektams iš programinės įrangos lygmens konteinerių. Docker konteineriai su failų sistemos palaikymu, sisteminėmis programomis bei bibliotekomis - viskas ko jums reikia paleisti serverį. Garantuotai paleisite tai ką ir turite paleisti, nepriklausant nuo sistemos aplinkos kur tai darote.

Docker suteikia papildomą virtualizacijos, automatikos lygmenį operacijų sistemos lygmenyje pačiame Linux. Docker naudoja Linux resursų izoliavimą [[cgroups]], branduolio vardinius susiejimus, ir [[aufs]] (angl. union-capable filesystem). Tai leidžia nepriklausomai valdyti kelis konteinerius vienoje Linux sistemoje, neužkraunant jos dideliomis apkrovomis kurių reikalauja virtualios mašinos. Linux branduolio vardinių sąsajų palaikymas izoliuoja kaip programos mato pačia operacijų sistemą, izoliuojami procesai, tinklas, vartotojo id, primontuotos failų sistemos, taip pat neprarandamas [[cgroups]] resursų ribojimas (CPU, atmintis, I/O, Tinklas). Nuo docker 0.9 versijos įtraukiama libcontainer biblioteka kuri tiesiogiai bendrauja su virtualizacijos sistemomis esančiomis Linux branduolyje, priedo tai apdorojama per virtualizacijos sąsajas [[libvirt]], [[LXC]] (Linux Containers) ir [[systemd-nspawn]].

== Docker diegimas Debian sistemose ==

sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg2 \
software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
sudo apt-key fingerprint 0EBFCD88
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/debian \
$(lsb_release -cs) \
stable"
sudo apt-get update
sudo apt-get install docker-ce

== Komandų vykdymas dockeryje ==

Vykdyti komandas
docker exec -it <docker_pavadinimas> id
Įjungti shellą
docker exec -it <docker_pavadinimas> bash

== Konkretaus konteinerio logų pravalymas ==

truncate -s 0 $(docker inspect --format='<nowiki>{{.LogPath}}</nowiki>' <container_name_or_id>)
arba
echo "" > $(docker inspect --format='<nowiki>{{.LogPath}}</nowiki>' <container_name_or_id>)
Kuriant konteinerį logų limito nurodymas
docker run --log-driver json-file --log-opt max-size=10m --log-opt max-file=3 ...

== Tinklas ==

=== Macvlan (ip tame pačiame tinkle ===

<syntaxhighlight lang="bash">
docker network create -d macvlan --subnet=192.1.14.0/24 --ip-range 192.1.14.240/28 --gateway 192.1.14.254 -o parent=eth0 local-lan
docker run -itd --name Alpine --ip=192.1.14.241 --net=local-lan alpine /bin/sh
docker exec -it Alpine ip addr
exec -it Alpine ping 192.1.14.254
</syntaxhighlight>

=== Visų tinklų gateway ===

<syntaxhighlight lang="bash">
for n in $(docker network ls --format '{{.Name}}'); do
docker network inspect "$n" --format '{{.Name}} {{range .IPAM.Config}}{{.Gateway}} {{end}}'
done
</syntaxhighlight>

=== Randam kuris tinklas naudoja konkretų gateway ===

<syntaxhighlight lang="bash">
for id in $(docker network ls -q); do
gw="$(docker network inspect "$id" -f '{{range .IPAM.Config}}{{.Gateway}} {{end}}')"
if grep -qw '192.168.1.1' <<<"$gw"; then
docker network inspect "$id" -f '{{.Name}} ({{.Id}})'
fi
done
</syntaxhighlight>

[[Category:Virtualizacija]]
[[Category:Linux]]
[[Category:Tinklas]]
{{Template:Distributions}}
[[Category:Docker]]

Docker

2025-09-24T19:29:11Z

\dev\null:

'''Docker''' yra atviro kodo projektas skirtas automatizuoti programinės įrangos projektams iš programinės įrangos lygmens konteinerių. Docker konteineriai su failų sistemos palaikymu, sisteminėmis programomis bei bibliotekomis - viskas ko jums reikia paleisti serverį. Garantuotai paleisite tai ką ir turite paleisti, nepriklausant nuo sistemos aplinkos kur tai darote.

Docker suteikia papildomą virtualizacijos, automatikos lygmenį operacijų sistemos lygmenyje pačiame Linux. Docker naudoja Linux resursų izoliavimą [[cgroups]], branduolio vardinius susiejimus, ir [[aufs]] (angl. union-capable filesystem). Tai leidžia nepriklausomai valdyti kelis konteinerius vienoje Linux sistemoje, neužkraunant jos dideliomis apkrovomis kurių reikalauja virtualios mašinos. Linux branduolio vardinių sąsajų palaikymas izoliuoja kaip programos mato pačia operacijų sistemą, izoliuojami procesai, tinklas, vartotojo id, primontuotos failų sistemos, taip pat neprarandamas [[cgroups]] resursų ribojimas (CPU, atmintis, I/O, Tinklas). Nuo docker 0.9 versijos įtraukiama libcontainer biblioteka kuri tiesiogiai bendrauja su virtualizacijos sistemomis esančiomis Linux branduolyje, priedo tai apdorojama per virtualizacijos sąsajas [[libvirt]], [[LXC]] (Linux Containers) ir [[systemd-nspawn]].

== Docker diegimas Debian sistemose ==

sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg2 \
software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
sudo apt-key fingerprint 0EBFCD88
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/debian \
$(lsb_release -cs) \
stable"
sudo apt-get update
sudo apt-get install docker-ce

== Komandų vykdymas dockeryje ==

Vykdyti komandas
docker exec -it <docker_pavadinimas> id
Įjungti shellą
docker exec -it <docker_pavadinimas> bash

== Konkretaus konteinerio logų pravalymas ==

truncate -s 0 $(docker inspect --format='<nowiki>{{.LogPath}}</nowiki>' <container_name_or_id>)
arba
echo "" > $(docker inspect --format='<nowiki>{{.LogPath}}</nowiki>' <container_name_or_id>)
Kuriant konteinerį logų limito nurodymas
docker run --log-driver json-file --log-opt max-size=10m --log-opt max-file=3 ...

== Tinklas ==

=== Visų tinklų gateway ===

<syntaxhighlight lang="bash">
for n in $(docker network ls --format '{{.Name}}'); do
docker network inspect "$n" --format '{{.Name}} {{range .IPAM.Config}}{{.Gateway}} {{end}}'
done
</syntaxhighlight>

=== Randam kuris tinklas naudoja konkretų gateway ===

<syntaxhighlight lang="bash">
for id in $(docker network ls -q); do
gw="$(docker network inspect "$id" -f '{{range .IPAM.Config}}{{.Gateway}} {{end}}')"
if grep -qw '192.168.1.1' <<<"$gw"; then
docker network inspect "$id" -f '{{.Name}} ({{.Id}})'
fi
done
</syntaxhighlight>

[[Category:Virtualizacija]]
[[Category:Linux]]
[[Category:Tinklas]]
{{Template:Distributions}}
[[Category:Docker]]