src/jobs.go

   1 /*
   2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   3 Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package nncp
  19
  20 import (
  21         "bytes"
  22         "fmt"
  23         "os"
  24         "path/filepath"
  25         "strings"
  26
  27         xdr "github.com/davecgh/go-xdr/xdr2"
  28         "github.com/dustin/go-humanize"
  29 )
  30
  31 type TRxTx string
  32
  33 const (
  34         TRx TRxTx = "rx"
  35         TTx TRxTx = "tx"
  36
  37         HdrSuffix = ".hdr"
  38 )
  39
  40 type Job struct {
  41         PktEnc   *PktEnc
  42         Path     string
  43         Size     int64
  44         HshValue *[MTHSize]byte
  45 }
  46
  47 func (ctx *Ctx) HdrRead(fd *os.File) (*PktEnc, []byte, error) {
  48         var pktEnc PktEnc
  49         _, err := xdr.Unmarshal(fd, &pktEnc)
  50         if err != nil {
  51                 return nil, nil, err
  52         }
  53         var raw bytes.Buffer
  54         if _, err = xdr.Marshal(&raw, pktEnc); err != nil {
  55                 panic(err)
  56         }
  57         return &pktEnc, raw.Bytes(), nil
  58 }
  59
  60 func (ctx *Ctx) HdrWrite(pktEncRaw []byte, tgt string) error {
  61         tmpHdr, err := ctx.NewTmpFile()
  62         if err != nil {
  63                 ctx.LogE("hdr-write-tmp-new", nil, err, func(les LEs) string {
  64                         return "Header writing: new temporary file"
  65                 })
  66                 return err
  67         }
  68         if _, err = tmpHdr.Write(pktEncRaw); err != nil {
  69                 ctx.LogE("hdr-write-write", nil, err, func(les LEs) string {
  70                         return "Header writing: writing"
  71                 })
  72                 os.Remove(tmpHdr.Name())
  73                 return err
  74         }
  75         if err = tmpHdr.Close(); err != nil {
  76                 ctx.LogE("hdr-write-close", nil, err, func(les LEs) string {
  77                         return "Header writing: closing"
  78                 })
  79                 os.Remove(tmpHdr.Name())
  80                 return err
  81         }
  82         if err = os.Rename(tmpHdr.Name(), tgt+HdrSuffix); err != nil {
  83                 ctx.LogE("hdr-write-rename", nil, err, func(les LEs) string {
  84                         return "Header writing: renaming"
  85                 })
  86                 return err
  87         }
  88         return err
  89 }
  90
  91 func (ctx *Ctx) jobsFind(nodeId *NodeId, xx TRxTx, nock, part bool) chan Job {
  92         rxPath := filepath.Join(ctx.Spool, nodeId.String(), string(xx))
  93         jobs := make(chan Job, 16)
  94         go func() {
  95                 defer close(jobs)
  96                 dir, err := os.Open(rxPath)
  97                 if err != nil {
  98                         return
  99                 }
 100                 fis, err := dir.Readdir(0)
 101                 dir.Close() // #nosec G104
 102                 if err != nil {
 103                         return
 104                 }
 105                 for _, fi := range fis {
 106                         name := fi.Name()
 107                         var hshValue []byte
 108                         if nock {
 109                                 if !strings.HasSuffix(name, NoCKSuffix) ||
 110                                         len(name) != Base32Encoded32Len+len(NoCKSuffix) {
 111                                         continue
 112                                 }
 113                                 hshValue, err = Base32Codec.DecodeString(
 114                                         strings.TrimSuffix(name, NoCKSuffix),
 115                                 )
 116                         } else if part {
 117                                 if !strings.HasSuffix(name, PartSuffix) ||
 118                                         len(name) != Base32Encoded32Len+len(PartSuffix) {
 119                                         continue
 120                                 }
 121                                 hshValue, err = Base32Codec.DecodeString(
 122                                         strings.TrimSuffix(name, PartSuffix),
 123                                 )
 124                         } else {
 125                                 if len(name) != Base32Encoded32Len {
 126                                         continue
 127                                 }
 128                                 hshValue, err = Base32Codec.DecodeString(name)
 129                         }
 130                         if err != nil {
 131                                 continue
 132                         }
 133                         pth := filepath.Join(rxPath, name)
 134                         hdrExists := true
 135                         var fd *os.File
 136                         if nock || part {
 137                                 fd, err = os.Open(pth)
 138                         } else {
 139                                 fd, err = os.Open(pth + HdrSuffix)
 140                                 if err != nil && os.IsNotExist(err) {
 141                                         hdrExists = false
 142                                         fd, err = os.Open(pth)
 143                                 }
 144                         }
 145                         if err != nil {
 146                                 continue
 147                         }
 148                         if part {
 149                                 job := Job{
 150                                         Path:     pth,
 151                                         Size:     fi.Size(),
 152                                         HshValue: new([MTHSize]byte),
 153                                 }
 154                                 copy(job.HshValue[:], hshValue)
 155                                 jobs <- job
 156                                 continue
 157                         }
 158                         pktEnc, pktEncRaw, err := ctx.HdrRead(fd)
 159                         fd.Close()
 160                         if err != nil {
 161                                 continue
 162                         }
 163                         switch pktEnc.Magic {
 164                         case MagicNNCPEv1.B:
 165                                 err = MagicNNCPEv1.TooOld()
 166                         case MagicNNCPEv2.B:
 167                                 err = MagicNNCPEv2.TooOld()
 168                         case MagicNNCPEv3.B:
 169                                 err = MagicNNCPEv3.TooOld()
 170                         case MagicNNCPEv4.B:
 171                                 err = MagicNNCPEv4.TooOld()
 172                         case MagicNNCPEv5.B:
 173                         default:
 174                                 err = BadMagic
 175                         }
 176                         if err != nil {
 177                                 ctx.LogE("job", LEs{
 178                                         {"XX", string(xx)},
 179                                         {"Name", name},
 180                                         {"Size", fi.Size()},
 181                                 }, err, func(les LEs) string {
 182                                         return fmt.Sprintf(
 183                                                 "Job %s/%s size: %s",
 184                                                 string(xx), name,
 185                                                 humanize.IBytes(uint64(fi.Size())),
 186                                         )
 187                                 })
 188                                 continue
 189                         }
 190                         ctx.LogD("job", LEs{
 191                                 {"XX", string(xx)},
 192                                 {"Node", pktEnc.Sender},
 193                                 {"Name", name},
 194                                 {"Nice", int(pktEnc.Nice)},
 195                                 {"Size", fi.Size()},
 196                         }, func(les LEs) string {
 197                                 return fmt.Sprintf(
 198                                         "Job %s/%s/%s nice: %s size: %s",
 199                                         pktEnc.Sender, string(xx), name,
 200                                         NicenessFmt(pktEnc.Nice),
 201                                         humanize.IBytes(uint64(fi.Size())),
 202                                 )
 203                         })
 204                         if !hdrExists && ctx.HdrUsage {
 205                                 ctx.HdrWrite(pktEncRaw, pth)
 206                         }
 207                         job := Job{
 208                                 PktEnc:   pktEnc,
 209                                 Path:     pth,
 210                                 Size:     fi.Size(),
 211                                 HshValue: new([MTHSize]byte),
 212                         }
 213                         copy(job.HshValue[:], hshValue)
 214                         jobs <- job
 215                 }
 216         }()
 217         return jobs
 218 }
 219
 220 func (ctx *Ctx) Jobs(nodeId *NodeId, xx TRxTx) chan Job {
 221         return ctx.jobsFind(nodeId, xx, false, false)
 222 }
 223
 224 func (ctx *Ctx) JobsNoCK(nodeId *NodeId) chan Job {
 225         return ctx.jobsFind(nodeId, TRx, true, false)
 226 }
 227
 228 func (ctx *Ctx) JobsPart(nodeId *NodeId) chan Job {
 229         return ctx.jobsFind(nodeId, TRx, false, true)
 230 }