publish.go 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314
  1. package cmd
  2. import (
  3. "errors"
  4. "fmt"
  5. "github.com/urfave/cli/v2"
  6. "heckel.io/ntfy/client"
  7. "heckel.io/ntfy/log"
  8. "heckel.io/ntfy/util"
  9. "io"
  10. "os"
  11. "os/exec"
  12. "path/filepath"
  13. "strings"
  14. "time"
  15. )
  16. func init() {
  17. commands = append(commands, cmdPublish)
  18. }
  19. var flagsPublish = append(
  20. append([]cli.Flag{}, flagsDefault...),
  21. &cli.StringFlag{Name: "config", Aliases: []string{"c"}, EnvVars: []string{"NTFY_CONFIG"}, Usage: "client config file"},
  22. &cli.StringFlag{Name: "title", Aliases: []string{"t"}, EnvVars: []string{"NTFY_TITLE"}, Usage: "message title"},
  23. &cli.StringFlag{Name: "message", Aliases: []string{"m"}, EnvVars: []string{"NTFY_MESSAGE"}, Usage: "message body"},
  24. &cli.StringFlag{Name: "priority", Aliases: []string{"p"}, EnvVars: []string{"NTFY_PRIORITY"}, Usage: "priority of the message (1=min, 2=low, 3=default, 4=high, 5=max)"},
  25. &cli.StringFlag{Name: "tags", Aliases: []string{"tag", "T"}, EnvVars: []string{"NTFY_TAGS"}, Usage: "comma separated list of tags and emojis"},
  26. &cli.StringFlag{Name: "delay", Aliases: []string{"at", "in", "D"}, EnvVars: []string{"NTFY_DELAY"}, Usage: "delay/schedule message"},
  27. &cli.StringFlag{Name: "click", Aliases: []string{"U"}, EnvVars: []string{"NTFY_CLICK"}, Usage: "URL to open when notification is clicked"},
  28. &cli.StringFlag{Name: "icon", Aliases: []string{"i"}, EnvVars: []string{"NTFY_ICON"}, Usage: "URL to use as notification icon"},
  29. &cli.StringFlag{Name: "actions", Aliases: []string{"A"}, EnvVars: []string{"NTFY_ACTIONS"}, Usage: "actions JSON array or simple definition"},
  30. &cli.StringFlag{Name: "attach", Aliases: []string{"a"}, EnvVars: []string{"NTFY_ATTACH"}, Usage: "URL to send as an external attachment"},
  31. &cli.BoolFlag{Name: "markdown", Aliases: []string{"md"}, EnvVars: []string{"NTFY_MARKDOWN"}, Usage: "Message is formatted as Markdown"},
  32. &cli.StringFlag{Name: "filename", Aliases: []string{"name", "n"}, EnvVars: []string{"NTFY_FILENAME"}, Usage: "filename for the attachment"},
  33. &cli.StringFlag{Name: "file", Aliases: []string{"f"}, EnvVars: []string{"NTFY_FILE"}, Usage: "file to upload as an attachment"},
  34. &cli.StringFlag{Name: "email", Aliases: []string{"mail", "e"}, EnvVars: []string{"NTFY_EMAIL"}, Usage: "also send to e-mail address"},
  35. &cli.StringFlag{Name: "user", Aliases: []string{"u"}, EnvVars: []string{"NTFY_USER"}, Usage: "username[:password] used to auth against the server"},
  36. &cli.StringFlag{Name: "token", Aliases: []string{"k"}, EnvVars: []string{"NTFY_TOKEN"}, Usage: "access token used to auth against the server"},
  37. &cli.IntFlag{Name: "wait-pid", Aliases: []string{"wait_pid", "pid"}, EnvVars: []string{"NTFY_WAIT_PID"}, Usage: "wait until PID exits before publishing"},
  38. &cli.BoolFlag{Name: "wait-cmd", Aliases: []string{"wait_cmd", "cmd", "done"}, EnvVars: []string{"NTFY_WAIT_CMD"}, Usage: "run command and wait until it finishes before publishing"},
  39. &cli.BoolFlag{Name: "no-cache", Aliases: []string{"no_cache", "C"}, EnvVars: []string{"NTFY_NO_CACHE"}, Usage: "do not cache message server-side"},
  40. &cli.BoolFlag{Name: "no-firebase", Aliases: []string{"no_firebase", "F"}, EnvVars: []string{"NTFY_NO_FIREBASE"}, Usage: "do not forward message to Firebase"},
  41. &cli.BoolFlag{Name: "quiet", Aliases: []string{"q"}, EnvVars: []string{"NTFY_QUIET"}, Usage: "do not print message"},
  42. )
  43. var cmdPublish = &cli.Command{
  44. Name: "publish",
  45. Aliases: []string{"pub", "send", "trigger"},
  46. Usage: "Send message via a ntfy server",
  47. UsageText: `ntfy publish [OPTIONS..] TOPIC [MESSAGE...]
  48. ntfy publish [OPTIONS..] --wait-cmd COMMAND...
  49. NTFY_TOPIC=.. ntfy publish [OPTIONS..] [MESSAGE...]`,
  50. Action: execPublish,
  51. Category: categoryClient,
  52. Flags: flagsPublish,
  53. Before: initLogFunc,
  54. Description: `Publish a message to a ntfy server.
  55. Examples:
  56. ntfy publish mytopic This is my message # Send simple message
  57. ntfy send myserver.com/mytopic "This is my message" # Send message to different default host
  58. ntfy pub -p high backups "Backups failed" # Send high priority message
  59. ntfy pub --tags=warning,skull backups "Backups failed" # Add tags/emojis to message
  60. ntfy pub --delay=10s delayed_topic Laterzz # Delay message by 10s
  61. ntfy pub --at=8:30am delayed_topic Laterzz # Send message at 8:30am
  62. ntfy pub -e phil@example.com alerts 'App is down!' # Also send email to phil@example.com
  63. ntfy pub --click="https://reddit.com" redd 'New msg' # Opens Reddit when notification is clicked
  64. ntfy pub --icon="http://some.tld/icon.png" 'Icon!' # Send notification with custom icon
  65. ntfy pub --attach="http://some.tld/file.zip" files # Send ZIP archive from URL as attachment
  66. ntfy pub --file=flower.jpg flowers 'Nice!' # Send image.jpg as attachment
  67. ntfy pub -u phil:mypass secret Psst # Publish with username/password
  68. ntfy pub --wait-pid 1234 mytopic # Wait for process 1234 to exit before publishing
  69. ntfy pub --wait-cmd mytopic rsync -av ./ /tmp/a # Run command and publish after it completes
  70. NTFY_USER=phil:mypass ntfy pub secret Psst # Use env variables to set username/password
  71. NTFY_TOPIC=mytopic ntfy pub "some message" # Use NTFY_TOPIC variable as topic
  72. cat flower.jpg | ntfy pub --file=- flowers 'Nice!' # Same as above, send image.jpg as attachment
  73. ntfy trigger mywebhook # Sending without message, useful for webhooks
  74. Please also check out the docs on publishing messages. Especially for the --tags and --delay options,
  75. it has incredibly useful information: https://ntfy.sh/docs/publish/.
  76. ` + clientCommandDescriptionSuffix,
  77. }
  78. func execPublish(c *cli.Context) error {
  79. conf, err := loadConfig(c)
  80. if err != nil {
  81. return err
  82. }
  83. title := c.String("title")
  84. priority := c.String("priority")
  85. tags := c.String("tags")
  86. delay := c.String("delay")
  87. click := c.String("click")
  88. icon := c.String("icon")
  89. actions := c.String("actions")
  90. attach := c.String("attach")
  91. markdown := c.Bool("markdown")
  92. filename := c.String("filename")
  93. file := c.String("file")
  94. email := c.String("email")
  95. user := c.String("user")
  96. token := c.String("token")
  97. noCache := c.Bool("no-cache")
  98. noFirebase := c.Bool("no-firebase")
  99. quiet := c.Bool("quiet")
  100. pid := c.Int("wait-pid")
  101. // Checks
  102. if user != "" && token != "" {
  103. return errors.New("cannot set both --user and --token")
  104. }
  105. // Do the things
  106. topic, message, command, err := parseTopicMessageCommand(c)
  107. if err != nil {
  108. return err
  109. }
  110. var options []client.PublishOption
  111. if title != "" {
  112. options = append(options, client.WithTitle(title))
  113. }
  114. if priority != "" {
  115. options = append(options, client.WithPriority(priority))
  116. }
  117. if tags != "" {
  118. options = append(options, client.WithTagsList(tags))
  119. }
  120. if delay != "" {
  121. options = append(options, client.WithDelay(delay))
  122. }
  123. if click != "" {
  124. options = append(options, client.WithClick(click))
  125. }
  126. if icon != "" {
  127. options = append(options, client.WithIcon(icon))
  128. }
  129. if actions != "" {
  130. options = append(options, client.WithActions(strings.ReplaceAll(actions, "\n", " ")))
  131. }
  132. if attach != "" {
  133. options = append(options, client.WithAttach(attach))
  134. }
  135. if markdown {
  136. options = append(options, client.WithMarkdown())
  137. }
  138. if filename != "" {
  139. options = append(options, client.WithFilename(filename))
  140. }
  141. if email != "" {
  142. options = append(options, client.WithEmail(email))
  143. }
  144. if noCache {
  145. options = append(options, client.WithNoCache())
  146. }
  147. if noFirebase {
  148. options = append(options, client.WithNoFirebase())
  149. }
  150. if token != "" {
  151. options = append(options, client.WithBearerAuth(token))
  152. } else if user != "" {
  153. var pass string
  154. parts := strings.SplitN(user, ":", 2)
  155. if len(parts) == 2 {
  156. user = parts[0]
  157. pass = parts[1]
  158. } else {
  159. fmt.Fprint(c.App.ErrWriter, "Enter Password: ")
  160. p, err := util.ReadPassword(c.App.Reader)
  161. if err != nil {
  162. return err
  163. }
  164. pass = string(p)
  165. fmt.Fprintf(c.App.ErrWriter, "\r%s\r", strings.Repeat(" ", 20))
  166. }
  167. options = append(options, client.WithBasicAuth(user, pass))
  168. } else if conf.DefaultToken != "" {
  169. options = append(options, client.WithBearerAuth(conf.DefaultToken))
  170. } else if conf.DefaultUser != "" && conf.DefaultPassword != nil {
  171. options = append(options, client.WithBasicAuth(conf.DefaultUser, *conf.DefaultPassword))
  172. }
  173. if pid > 0 {
  174. newMessage, err := waitForProcess(pid)
  175. if err != nil {
  176. return err
  177. } else if message == "" {
  178. message = newMessage
  179. }
  180. } else if len(command) > 0 {
  181. newMessage, err := runAndWaitForCommand(command)
  182. if err != nil {
  183. return err
  184. } else if message == "" {
  185. message = newMessage
  186. }
  187. }
  188. var body io.Reader
  189. if file == "" {
  190. body = strings.NewReader(message)
  191. } else {
  192. if message != "" {
  193. options = append(options, client.WithMessage(message))
  194. }
  195. if file == "-" {
  196. if filename == "" {
  197. options = append(options, client.WithFilename("stdin"))
  198. }
  199. body = c.App.Reader
  200. } else {
  201. if filename == "" {
  202. options = append(options, client.WithFilename(filepath.Base(file)))
  203. }
  204. body, err = os.Open(file)
  205. if err != nil {
  206. return err
  207. }
  208. }
  209. }
  210. cl := client.New(conf)
  211. m, err := cl.PublishReader(topic, body, options...)
  212. if err != nil {
  213. return err
  214. }
  215. if !quiet {
  216. fmt.Fprintln(c.App.Writer, strings.TrimSpace(m.Raw))
  217. }
  218. return nil
  219. }
  220. // parseTopicMessageCommand reads the topic and the remaining arguments from the context.
  221. // There are a few cases to consider:
  222. //
  223. // ntfy publish <topic> [<message>]
  224. // ntfy publish --wait-cmd <topic> <command>
  225. // NTFY_TOPIC=.. ntfy publish [<message>]
  226. // NTFY_TOPIC=.. ntfy publish --wait-cmd <command>
  227. func parseTopicMessageCommand(c *cli.Context) (topic string, message string, command []string, err error) {
  228. var args []string
  229. topic, args, err = parseTopicAndArgs(c)
  230. if err != nil {
  231. return
  232. }
  233. if c.Bool("wait-cmd") {
  234. if len(args) == 0 {
  235. err = errors.New("must specify command when --wait-cmd is passed, type 'ntfy publish --help' for help")
  236. return
  237. }
  238. command = args
  239. } else {
  240. message = strings.Join(args, " ")
  241. }
  242. if c.String("message") != "" {
  243. message = c.String("message")
  244. }
  245. return
  246. }
  247. func parseTopicAndArgs(c *cli.Context) (topic string, args []string, err error) {
  248. envTopic := os.Getenv("NTFY_TOPIC")
  249. if envTopic != "" {
  250. topic = envTopic
  251. return topic, remainingArgs(c, 0), nil
  252. }
  253. if c.NArg() < 1 {
  254. return "", nil, errors.New("must specify topic, type 'ntfy publish --help' for help")
  255. }
  256. return c.Args().Get(0), remainingArgs(c, 1), nil
  257. }
  258. func remainingArgs(c *cli.Context, fromIndex int) []string {
  259. if c.NArg() > fromIndex {
  260. return c.Args().Slice()[fromIndex:]
  261. }
  262. return []string{}
  263. }
  264. func waitForProcess(pid int) (message string, err error) {
  265. if !processExists(pid) {
  266. return "", fmt.Errorf("process with PID %d not running", pid)
  267. }
  268. start := time.Now()
  269. log.Debug("Waiting for process with PID %d to exit", pid)
  270. for processExists(pid) {
  271. time.Sleep(500 * time.Millisecond)
  272. }
  273. runtime := time.Since(start).Round(time.Millisecond)
  274. log.Debug("Process with PID %d exited after %s", pid, runtime)
  275. return fmt.Sprintf("Process with PID %d exited after %s", pid, runtime), nil
  276. }
  277. func runAndWaitForCommand(command []string) (message string, err error) {
  278. prettyCmd := util.QuoteCommand(command)
  279. log.Debug("Running command: %s", prettyCmd)
  280. start := time.Now()
  281. cmd := exec.Command(command[0], command[1:]...)
  282. if log.IsTrace() {
  283. cmd.Stdout = os.Stdout
  284. cmd.Stderr = os.Stderr
  285. }
  286. err = cmd.Run()
  287. runtime := time.Since(start).Round(time.Millisecond)
  288. if err != nil {
  289. if exitError, ok := err.(*exec.ExitError); ok {
  290. log.Debug("Command failed after %s (exit code %d): %s", runtime, exitError.ExitCode(), prettyCmd)
  291. return fmt.Sprintf("Command failed after %s (exit code %d): %s", runtime, exitError.ExitCode(), prettyCmd), nil
  292. }
  293. // Hard fail when command does not exist or could not be properly launched
  294. return "", fmt.Errorf("command failed: %s, error: %s", prettyCmd, err.Error())
  295. }
  296. log.Debug("Command succeeded after %s: %s", runtime, prettyCmd)
  297. return fmt.Sprintf("Command succeeded after %s: %s", runtime, prettyCmd), nil
  298. }