Finding, from cocoa application, if a package installer (like DivXInstaller.pkg) is running - objective-c

I do not know if this is possible, so I hope that the question does not appear stupid:
I can get in a cocoa application, or even using a bash script, the pid of a specific running Application. So I can take actions (such as alert and ask if you want to close it).
We can the same with a package (pkg), knowing its id (like "org.someIdentity.pkg") in some way?
EDIT
this is what i use in cocoa:
- (void)unWantedApp:(NSNotification *)notification {
NSDictionary *userInfo = [notification userInfo];
NSLog(#"userInfo == %#", userInfo);
if ([NSRunningApplication runningApplicationsWithBundleIdentifier:#"com.blabla"] || [NSRunningApplication runningApplicationsWithBundleIdentifier:#"com.blabla2"]) {
[[NSAlert alertWithMessageText:[NSString stringWithFormat:NSLocalizedString(#"blabla is running..", nil), [[NSBundle mainBundle] objectForInfoDictionaryKey:(NSString *)kCFBundleNameKey]]
defaultButton:nil alternateButton:nil otherButton:nil informativeTextWithFormat:NSLocalizedString(#"Well, I hope you are not joking with more then one Tool at same time...", nil)] runModal];
}
}
EDIT
what i used with bash:
isOpen=$(ps auxwww | grep '/Applications/blabla.app' | grep -v 'grep' | wc -l)
if [ -e '/Applications/blabla.app' ]; then
if [ $isOpen -ge 0 ]; then
# do what you are intresting for... But a packages is not in Application folder and is opened by Installer.app :-(
fi
fi
EDIT
also the bash script can be used in cocoa in this way:
#include <stdio.h>
#include <stdlib.h>
#define SCRIPT "\
#/bin/bash \n\
if [ -e '/Applications/blabla.app' ];then\n\
#variable and other statement here(escape all special caracter and manually add the new line ->> \n)\n\
else\n\
exit 0\n\
fi"
int main()
{
system(SCRIPT);
return 0;
}

Maybe this helps a bit:
app=${1:-VirtualBox} #tested on it
run_searched() {
echo "The installer installing $1 as: $2"
}
run_other() {
echo "The installer NOT installing $1. (but installing: $2)"
}
not_running() {
echo "The installer is not running"
}
isasdir="$HOME/Library/Saved Application State/com.apple.installer.savedState"
isasfile="$isasdir/windows.plist"
if [[ -d "$isasdir" && -f "$isasfile" ]]
then
win=$(plutil -p "$isasfile" | grep '"NSTitle"' | sed 's:.*"NSTitle".*=>.*"\([^"]*\)":\1:')
if [[ "$win" =~ $app ]]
then
run_searched "$app" "$win"
else
run_other "$app" "$win"
fi
else
not_running
fi

I added a comment with some questions, but I will provide some kind of answer too.
As mentioned in my comment: If the applications run with absolute path you can probably look for processes with org.someIdentity
If applications you want to 'monitor' are running from the same path(s), you could probably do something along these lines (bash):
apps="org.someIdentity org.someOtherIdentity"
for app in ${apps}; do
echo "Checking app ${app}..."
lsof /Applications/${app}
done
This is a crude example - you might have to expand on the paths a bit (I'm not on a Mac), but the idea is that the application/package names exist in the file structure (as directories). Running lsof on these directories will tell us which processes are using resources in that directory (i.e. opened files). Depending on your needs you can probably pass lsof some more parameters.
I'm not saying this is a very pretty approach, though ;)

If using OS X 10.8 or later, pgrep is the best tool to return a list of process IDs by application name.
$ pgrep firefox
905

Related

how can I add my path to ~/.zshenv in order to install expo?

I am installing Android studio and following this instruction. https://docs.expo.dev/workflow/android-studio-emulator/
I need to add
[ -d "$HOME/Library/Android/sdk" ] && ANDROID_SDK=$HOME/Library/Android/sdk || ANDROID_SDK=$HOME/Android/Sdk
echo "export ANDROID_SDK=$ANDROID_SDK" >> ~/`[[ $SHELL == *"zsh" ]] && echo '.zshenv' || echo '.bash_profile'
and
echo "export PATH=$HOME/Library/Android/sdk/platform-tools:\$PATH" >> ~/`[[ $SHELL == *"zsh" ]] && echo '.zshenv' || echo '.bash_profile'`
to ~/.zshrc
what I did is,
from the android studio, I see my path is Users/myname/Library/Android/sdk therefore,
nano ~/.zshrc
open ~/.zshrc window.
and added this two line like this...
[ -d "Users/<myname>/Library/Android/sdk" ] && ANDROID_SDK=Users/<myname>/Library/Android/sdk || ANDROID_SDK=Users/<myname>/Android/Sdk
echo "export ANDROID_SDK=$ANDROID_SDK" >> ~/`[[ $SHELL == *"zsh" ]] && echo '.zshenv' || echo '.bash_profile'
and next line, I added..
echo "export PATH=Users/<myname>/Library/Android/sdk/platform-tools:\$PATH" >> ~/`[[ $SHELL == *"zsh" ]] && echo '.zshenv' || echo '.bash_profile'`
and it said, I need to make sure adb is working in terminal. So I typed adb in terminal, and it returns this err msg
zsh: command not found: adb
I am very new to shell things.. please help me!
You don't need to open the file with an editor: just run the two shell lines themselves in your terminal and they will append the EXPORT command to .zshenv with the proper ANDROID_SDK to be sourced next time you open the terminal and at the same time you'll the have ANDROID_SDK populated for your current session to keep on going with the setup.
The lines are doing the two following things:
Checking if $HOME/Library/Android/sdk exists: if so assign $HOME/Library/Android/sdk to ANDROID_SDK, else assign it $HOME/Android/Sdk
Checking if you're using zsh by running $SHELL == *"zsh": if so, append export ANDROID_SDK=$ANDROID_SDK to .zshenv, if not, append it to .bash_profile
If you wanted to do that manually, open .zshenv and append to it export ANDROID_SDK=$ANDROID_SDK (without the echo part) where $ANDROID_SDK is the directory above mentioned ( $HOME/Library/Android/sdk or $HOME/Android/Sdk depending on you having the $HOME/Library/Android/sdk directory or not )

MSYS2 path to Windows clipboard

Is there a way to copy a Unix path from the MSYS2 bash shell to the Windows clipboard?
A work-around is to start a Windows explorer with the current directory: /c/windows/explorer .
The MSYS2 pwd command has a -W switch to output the current path as Windows path (with forward slashes).
The Windows clipboard can be accessed as a Unix device: /dev/clipboard
So this makes a shell function like this:
# pathw [-c] [dir]
pathw () {
local p=''
local clip=false
if [ "$1x" = "-cx" ]; then
clip=true
shift
fi
if [ "$1x" = "x" ]; then
p=$(pwd -W)
else
p=$(cd $1 && pwd -W)
fi
p=$(echo $p | sed 's|/|\\|g')
echo $p
if [ "$clip" = true ]; then
echo $p > /dev/clipboard
fi
}
pathw ~
C:\msys64\home\weberjn

Creating a Perl 6 module containing Perl 5 utility scripts in bin/

Perl 6 script in a Perl 5 module distribution
I can include a Perl 6 script in a Perl 5 module distribution:
# Create a new module
dzil new My::Dist
cd My-Dist/
# Add necessary boilerplate
echo '# ABSTRACT: boilerplate' >> lib/My/Dist.pm
# Create Perl 6 script in bin directory
mkdir bin
echo '#!/usr/bin/env perl6' > bin/hello.p6
echo 'put "Hello world!";' >> bin/hello.p6
# Install module
dzil install
# Test script
hello.p6
# Hello world!
# See that it is actually installed
which hello.p6
# ~/perl5/perlbrew/perls/perl-5.20.1/bin/hello.p6
Perl 5 script in a Perl 6 module distribution
However, I'm having a hard time including Perl 5 scripts in a Perl 6 distribution.
In the module directory is a META6.json file and a subdirectory called bin. In bin is a Perl 5 file called hello.pl.
zef install . runs without error in the top directory. But when trying to run hello.pl, I get an error. Come to find out, a Perl 6 wrapper script had been installed for hello.pl and that is what is giving me the error. If I run the original hello.pl directly, it works fine.
META6.json
{
"perl" : "6.c",
"name" : "TESTING1234",
"license" : "Artistic-2.0",
"version" : "0.0.2",
"auth" : "github:author",
"authors" : ["First Last"],
"description" : "TESTING module creation",
"provides" : {
},
"depends" : [ ],
"test-depends" : [ "Test", "Test::META" ]
}
bin/hello.pl
#!/usr/bin/env perl
use v5.10;
use strict;
use warnings;
say 'Hello world!';
This installs without error, but when I try to run hello.pl, I get the following error:
===SORRY!===
Could not find Perl5 at line 2 in:
/home/username/.perl6
/path/to/perl6/rakudo-star-2017.07/install/share/perl6/site
/path/to/perl6/rakudo-star-2017.07/install/share/perl6/vendor
/path/to/perl6/rakudo-star-2017.07/install/share/perl6
CompUnit::Repository::AbsolutePath<64730416>
CompUnit::Repository::NQP<43359856>
CompUnit::Repository::Perl5<43359896>
which hello.pl from the command line indicated that it was installed in /path/to/perl6/rakudo-star-2017.07/install/share/perl6/site/bin/hello.pl. That file is actually the following code:
/path/to/perl6/rakudo-star-2017.07/install/share/perl6/site/bin/hello.pl
#!/usr/bin/env perl6
sub MAIN(:$name is copy, :$auth, :$ver, *#, *%) {
CompUnit::RepositoryRegistry.run-script("hello.pl", :dist-name<TESTING1234>, :$name, :$auth, :$ver);
}
I filed a Rakudo bug report (https://rt.perl.org/Ticket/Display.html?id=131911), but I'm not totally convinced that there isn't a simple work around.
As an example, I created a simple cat replacement in Perl 5 and created a Perl 6 module that "wrapped" around it (see the GitHub repository for it if you'd like to download the code and try it yourself).
Below are copies of the relevant files. After creating these files, running zef install . installs fine with my Rakudo Star 2017.07 installation. This installs a run_cat executable in your Rakudo bin directory.
It seemed like the secret was to make a Perl 6 module file to wrap the Perl 5 script and a corresponding Perl 6 script to use the Perl 6 module.
Perl 5 script
resources/scripts/cat.pl
#!/bin/env perl
use v5.10;
use strict;
use warnings;
while(<>) {
print;
}
Wrapper scripts
module: lib/catenate.pm6
unit module catenate;
sub cat ($filename) is export {
run('perl',%?RESOURCES<scripts/cat.pl>,$filename);
}
executable: bin/run_cat
#!/bin/env perl6
use catenate;
sub MAIN ($filename) {
cat($filename);
}
Boilerplate and tests
META6.json`
{
"perl" : "6.c",
"name" : "cat",
"license" : "Artistic-2.0",
"version" : "0.0.9",
"auth" : "github:author",
"authors" : ["First Last"],
"description" : "file catenation utility",
"provides" : { "catenate" : "lib/catenate.pm6" },
"test-depends" : [ "Test", "Test::META" ],
"resources" : [ "scripts/cat.pl" ]
}
t/cat.t
#!/bin/env perl6
use Test;
constant GREETING = 'Hello world!';
my $filename = 'test.txt';
spurt($filename, GREETING);
my $p5 = qqx{ resources/scripts/cat.pl $filename };
my $p6 = qqx{ bin/run_cat $filename };
is $p6, $p5, 'wrapped script gives same result as original';
is $p6, GREETING, "output is '{GREETING}' as expected";
unlink $filename;
done-testing;
Thanks #moritz and #ugexe for getting me pointed in the right direction!

Running Celery as daemon won't use redis broker

I have
celery==3.1.23
Django==1.9.1
redis==2.10.5
ii redis-server 2:2.8.19-3 amd64 Persistent key-value database with networ
ii redis-tools 2:2.8.19-3 amd64 Persistent key-value database with networ
My configuration settings have the lines
# Celery
BROKER_URL = 'redis://127.0.0.1:6379/0'
BROKER_TRANSPORT = 'redis'
# start worker with '$ celery -A intro worker -l debug'
and my configuration file celery.py (standard practice is to name it this way, but confusing in my opinion) is
from __future__ import absolute_import
import os
import django
from celery import Celery
from django.conf import settings
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'intro.settings')
django.setup()
app = Celery('intro')
app.config_from_object('django.conf:settings')
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)
The config /etc/default/celeryd (also confusing naming) is
# copy this file to /etc/default/celeryd
CELERYD_NODES="w1 w2 w3"
VIRTUAL_ENV_PATH="/srv/intro/bin"
# JRT
CELERY_BIN="${VIRTUAL_ENV_PATH}/celery"
# Where to chdir at start.
CELERYD_CHDIR="/srv/intro/intro"
# Python interpreter from environment.
ENV_PYTHON="$VIRTUAL_ENV_PATH/python"
# How to call "manage.py celeryd_multi"
CELERYD_MULTI="$ENV_PYTHON $CELERYD_CHDIR/manage.py celeryd_multi"
# How to call "manage.py celeryctl"
CELERYCTL="$ENV_PYTHON $CELERYD_CHDIR/manage.py celeryctl"
# Extra arguments to celeryd NOTE --beat is vital, otherwise scheduler
# will not run
CELERYD_OPTS="--concurrency=1 --beat"
# %n will be replaced with the nodename.
CELERYD_LOG_FILE="/var/log/celery/%n.log"
CELERYD_PID_FILE="/var/run/celery/%n.pid"
# Workers should run as an unprivileged user.
CELERYD_USER="jimmy"
CELERYD_GROUP="jimmy"
# Name of the projects settings module.
export DJANGO_SETTINGS_MODULE="intro.settings"
#CELERY_BROKER_URL = 'redis://127.0.0.1:6379/0'
#export DJANGO_SETTINGS_MODULE="settings"
#CELERYD_MULTI="/home/webapps/.virtualenvs/crowdstaff/bin/django-admin.py celeryd_detach"
My /etc/init.d/celeryd file is
#!/bin/sh -e
VERSION=10.1
echo "celery init v${VERSION}."
if [ $(id -u) -ne 0 ]; then
echo "Error: This program can only be used by the root user."
echo " Unprivileged users must use the 'celery multi' utility, "
echo " or 'celery worker --detach'."
exit 1
fi
# Can be a runlevel symlink (e.g. S02celeryd)
if [ -L "$0" ]; then
SCRIPT_FILE=$(readlink "$0")
else
SCRIPT_FILE="$0"
fi
SCRIPT_NAME="$(basename "$SCRIPT_FILE")"
DEFAULT_USER="celery"
DEFAULT_PID_FILE="/var/run/celery/%n.pid"
DEFAULT_LOG_FILE="/var/log/celery/%n.log"
DEFAULT_LOG_LEVEL="INFO"
DEFAULT_NODES="celery"
DEFAULT_CELERYD="-m celery worker --detach"
CELERY_DEFAULTS=${CELERY_DEFAULTS:-"/etc/default/${SCRIPT_NAME}"}
# Make sure executable configuration script is owned by root
_config_sanity() {
local path="$1"
local owner=$(ls -ld "$path" | awk '{print $3}')
local iwgrp=$(ls -ld "$path" | cut -b 6)
local iwoth=$(ls -ld "$path" | cut -b 9)
if [ "$(id -u $owner)" != "0" ]; then
echo "Error: Config script '$path' must be owned by root!"
echo
echo "Resolution:"
echo "Review the file carefully and make sure it has not been "
echo "modified with mailicious intent. When sure the "
echo "script is safe to execute with superuser privileges "
echo "you can change ownership of the script:"
echo " $ sudo chown root '$path'"
exit 1
fi
if [ "$iwoth" != "-" ]; then # S_IWOTH
echo "Error: Config script '$path' cannot be writable by others!"
echo
echo "Resolution:"
echo "Review the file carefully and make sure it has not been "
echo "modified with malicious intent. When sure the "
echo "script is safe to execute with superuser privileges "
echo "you can change the scripts permissions:"
echo " $ sudo chmod 640 '$path'"
exit 1
fi
if [ "$iwgrp" != "-" ]; then # S_IWGRP
echo "Error: Config script '$path' cannot be writable by group!"
echo
echo "Resolution:"
echo "Review the file carefully and make sure it has not been "
echo "modified with malicious intent. When sure the "
echo "script is safe to execute with superuser privileges "
echo "you can change the scripts permissions:"
echo " $ sudo chmod 640 '$path'"
exit 1
fi
}
if [ -f "$CELERY_DEFAULTS" ]; then
_config_sanity "$CELERY_DEFAULTS"
echo "Using config script: $CELERY_DEFAULTS"
. "$CELERY_DEFAULTS"
fi
# Sets --app argument for CELERY_BIN
CELERY_APP_ARG=""
if [ ! -z "$CELERY_APP" ]; then
CELERY_APP_ARG="--app=$CELERY_APP"
fi
CELERYD_USER=${CELERYD_USER:-$DEFAULT_USER}
# Set CELERY_CREATE_DIRS to always create log/pid dirs.
CELERY_CREATE_DIRS=${CELERY_CREATE_DIRS:-0}
CELERY_CREATE_RUNDIR=$CELERY_CREATE_DIRS
CELERY_CREATE_LOGDIR=$CELERY_CREATE_DIRS
if [ -z "$CELERYD_PID_FILE" ]; then
CELERYD_PID_FILE="$DEFAULT_PID_FILE"
CELERY_CREATE_RUNDIR=1
fi
if [ -z "$CELERYD_LOG_FILE" ]; then
CELERYD_LOG_FILE="$DEFAULT_LOG_FILE"
CELERY_CREATE_LOGDIR=1
fi
CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-${CELERYD_LOGLEVEL:-$DEFAULT_LOG_LEVEL}}
CELERY_BIN=${CELERY_BIN:-"celery"}
CELERYD_MULTI=${CELERYD_MULTI:-"$CELERY_BIN multi"}
CELERYD_NODES=${CELERYD_NODES:-$DEFAULT_NODES}
export CELERY_LOADER
if [ -n "$2" ]; then
CELERYD_OPTS="$CELERYD_OPTS $2"
fi
CELERYD_LOG_DIR=`dirname $CELERYD_LOG_FILE`
CELERYD_PID_DIR=`dirname $CELERYD_PID_FILE`
# Extra start-stop-daemon options, like user/group.
if [ -n "$CELERYD_CHDIR" ]; then
DAEMON_OPTS="$DAEMON_OPTS --workdir=$CELERYD_CHDIR"
fi
check_dev_null() {
if [ ! -c /dev/null ]; then
echo "/dev/null is not a character device!"
exit 75 # EX_TEMPFAIL
fi
}
maybe_die() {
if [ $? -ne 0 ]; then
echo "Exiting: $* (errno $?)"
exit 77 # EX_NOPERM
fi
}
create_default_dir() {
if [ ! -d "$1" ]; then
echo "- Creating default directory: '$1'"
mkdir -p "$1"
maybe_die "Couldn't create directory $1"
echo "- Changing permissions of '$1' to 02755"
chmod 02755 "$1"
maybe_die "Couldn't change permissions for $1"
if [ -n "$CELERYD_USER" ]; then
echo "- Changing owner of '$1' to '$CELERYD_USER'"
chown "$CELERYD_USER" "$1"
maybe_die "Couldn't change owner of $1"
fi
if [ -n "$CELERYD_GROUP" ]; then
echo "- Changing group of '$1' to '$CELERYD_GROUP'"
chgrp "$CELERYD_GROUP" "$1"
maybe_die "Couldn't change group of $1"
fi
fi
}
check_paths() {
if [ $CELERY_CREATE_LOGDIR -eq 1 ]; then
create_default_dir "$CELERYD_LOG_DIR"
fi
if [ $CELERY_CREATE_RUNDIR -eq 1 ]; then
create_default_dir "$CELERYD_PID_DIR"
fi
}
create_paths() {
create_default_dir "$CELERYD_LOG_DIR"
create_default_dir "$CELERYD_PID_DIR"
}
export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"
_get_pidfiles () {
# note: multi < 3.1.14 output to stderr, not stdout, hence the redirect.
${CELERYD_MULTI} expand "${CELERYD_PID_FILE}" ${CELERYD_NODES} 2>&1
}
_get_pids() {
found_pids=0
my_exitcode=0
for pidfile in $(_get_pidfiles); do
local pid=`cat "$pidfile"`
local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'`
if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then
echo "bad pid file ($pidfile)"
one_failed=true
my_exitcode=1
else
found_pids=1
echo "$pid"
fi
if [ $found_pids -eq 0 ]; then
echo "${SCRIPT_NAME}: All nodes down"
exit $my_exitcode
fi
done
}
_chuid () {
su "$CELERYD_USER" -c "$CELERYD_MULTI $*"
}
start_workers () {
if [ ! -z "$CELERYD_ULIMIT" ]; then
ulimit $CELERYD_ULIMIT
fi
_chuid $* start $CELERYD_NODES $DAEMON_OPTS \
--pidfile="$CELERYD_PID_FILE" \
--logfile="$CELERYD_LOG_FILE" \
--loglevel="$CELERYD_LOG_LEVEL" \
$CELERY_APP_ARG \
$CELERYD_OPTS
}
dryrun () {
(C_FAKEFORK=1 start_workers --verbose)
}
stop_workers () {
_chuid stopwait $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
}
restart_workers () {
_chuid restart $CELERYD_NODES $DAEMON_OPTS \
--pidfile="$CELERYD_PID_FILE" \
--logfile="$CELERYD_LOG_FILE" \
--loglevel="$CELERYD_LOG_LEVEL" \
$CELERY_APP_ARG \
$CELERYD_OPTS
}
kill_workers() {
_chuid kill $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
}
restart_workers_graceful () {
echo "WARNING: Use with caution in production"
echo "The workers will attempt to restart, but they may not be able to."
local worker_pids=
worker_pids=`_get_pids`
[ "$one_failed" ] && exit 1
for worker_pid in $worker_pids; do
local failed=
kill -HUP $worker_pid 2> /dev/null || failed=true
if [ "$failed" ]; then
echo "${SCRIPT_NAME} worker (pid $worker_pid) could not be restarted"
one_failed=true
else
echo "${SCRIPT_NAME} worker (pid $worker_pid) received SIGHUP"
fi
done
[ "$one_failed" ] && exit 1 || exit 0
}
check_status () {
my_exitcode=0
found_pids=0
local one_failed=
for pidfile in $(_get_pidfiles); do
if [ ! -r $pidfile ]; then
echo "${SCRIPT_NAME} down: no pidfiles found"
one_failed=true
break
fi
local node=`basename "$pidfile" .pid`
local pid=`cat "$pidfile"`
local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'`
if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then
echo "bad pid file ($pidfile)"
one_failed=true
else
local failed=
kill -0 $pid 2> /dev/null || failed=true
if [ "$failed" ]; then
echo "${SCRIPT_NAME} (node $node) (pid $pid) is down, but pidfile exists!"
one_failed=true
else
echo "${SCRIPT_NAME} (node $node) (pid $pid) is up..."
fi
fi
done
[ "$one_failed" ] && exit 1 || exit 0
}
case "$1" in
start)
check_dev_null
check_paths
start_workers
;;
stop)
check_dev_null
check_paths
stop_workers
;;
reload|force-reload)
echo "Use restart"
;;
status)
check_status
;;
restart)
check_dev_null
check_paths
restart_workers
;;
graceful)
check_dev_null
restart_workers_graceful
;;
kill)
check_dev_null
kill_workers
;;
dryrun)
check_dev_null
dryrun
;;
try-restart)
check_dev_null
check_paths
restart_workers
;;
create-paths)
check_dev_null
create_paths
;;
check-paths)
check_dev_null
check_paths
;;
*)
echo "Usage: /etc/init.d/${SCRIPT_NAME} {start|stop|restart|graceful|kill|dryrun|create-paths}"
exit 64 # EX_USAGE
;;
esac
exit 0
Which is old, very long, and seems to contain nothing I can change to effect the broker used except the location of the default values script CELERY_DEFAULTS=/etc/default/celeryd (confusing name again). I admit I pretty well copied and pasted this script without a full understanding though I do know how init.d scripts work.
When I run /etc/init.d/celeryd start The workers start up, but ignore the BROKER django settings pointing to my redis server, and try to read RabbitMQ instead. The log file /var/log/celery/w1.log
[2016-11-30 23:44:51,873: ERROR/MainProcess] consumer: Cannot connect to amqp://guest:**#127.0.0.1:5672//: [Errno 111] Connection refused.
So celery is trying to use RabbitMQ, not Redis. There are other posts that complain of the same problem on Stack overflow, but none are resolved (as far as I can tell). I put djcelery in installed apps, as it seemed to make celeryd_multi management command available, but I don't want to use celery beat, and the documentation says this is no longer necessary. I have my own queue set up to run management commands, and I have had too many problems with setting up celerybeat in the past.
I have got the thing working by running sudo -u jimmy /srv/intro/bin/celery -A intro worker & and this works and uses the correct Redis queue (does anyone know why is it called a broker?), but wont restart on server power cycle, does not write to the log files, and I just don't feel this is a clean way to run celery workers.
I don't really want to use /etc/init.d scripts as this is the old way of doing things, and running as upstart has come and gone to replace this, and now systemd is the supported way of doing this (please correct me if I am wrong). There is no mention of these methods on the official documentation
http://docs.celeryproject.org/en/v4.0.0/userguide/daemonizing.html#init-script-celeryd
which makes me think that celery is no longer being supported, and perhaps there is a better maintained way of doing this. It is a wonder it has not been built into the core.
I did find this
https://github.com/celery/celery/blob/3.1/extra/supervisord/supervisord.conf
but there is no mention of broker in the config files, and I doubt that this will help me using Redis.
How do I get Celery running as a daemon to start automatically on reboot, and use Redis as a message queue, or is my only way of using Celery for asynchronous running of functions in Django to use the RabbitMQ message queue?
To ensure celery loads the correct broker, add broker parameter to Celery class.
app = Celery('intro', broker=settings.BROKER_URL)
Reference:
http://docs.celeryproject.org/en/latest/getting-started/first-steps-with-celery.html#application

ImageMagick or GhostScript: convert a multi-page TIFF to a multi-page PDF

I need to convert a multi-page TIFF to a multi-page PDF. I have access to ImageMagick and GhostScript (in *nix environment). How do I do this? Thanks.
UPDATE:
It turns out that my test file was wrong (it didn't have multiple pages), which made me think my command was wrong. This seems to work for me: convert input.tif output.pdf
convert multipage.tiff -density 300x300 -compress jpeg multipage.pdf
This should work, though there can be some issues.
Use a tool called tiff2ps from the tool set provided by libtiff:
http://www.libtiff.org/tools.html
Once you have the tiff in ps format, you can call ps2pdf to convert to pdf, which is part of the ghostscript package in most linux distributions.
Use following code to generate multi page pdf from multi page tiff file:
<?php
$images = new Imagick($pathToYourFile);
foreach($images as $i=>$image) {
$image->setImageFormat("pdf");
$images->addImage( $image );
}
$images->writeImages($yourFileName.'.pdf', true);
?>
I had a similar situation of converting a multipage TIFF file. but in my case the resulting extension was JPG thumbnail. However, I believe that this following code will run for converting TIFF to PDF. http://sourcecodemania.com/how-to-convert-text-to-speech-with-php/
<?php
try
{
// Saving every page of a TIFF separately as a JPG thumbnail
$images = new Imagick("testing.tif");
foreach($images as $i=>$image) {
// Providing 0 forces thumbnail Image to maintain aspect ratio
$image->thumbnailImage(768,0);
$image->writeImage("page".$i.".jpg");
echo "<img src='page$i.jpg' alt='images' ></img>";
}
$images->clear();
}
catch(Exception $e)
{
echo $e->getMessage();
}
?>
Comments are welcome
http://www.sourcecodemania.com
#!/bin/bash
# scanadf frontend
# kdialog info at http://techbase.kde.org/Development/Tutorials/Shell_Scripting_with_KDE_Dialogs#Menu_and_Selection_Dialogs
# i/o redirection at http://tldp.org/LDP/abs/html/io-redirection.html
# variable to file i/o at http://www.linuxquestions.org/questions/programming-9/bash-script-%96-reading-and-writing variables-to-a-separate-file-365158/
#
#rev. 1.2 03.02.12
#
#NOTE: TO RUN THIS SCRIPT YOU WILL NEED TO CREATE THE DIRECTORIES REFERRED TO IN THE SCRIPT.
#THE ANSWER TO THE QUESTION IS THE TWO-PASS COMMANDS BELOW "convert" and "gs"
#THE CONVERT COMMAND COMBINES ALL THE TIFFS IN THE DIRECTORY INTO A SINGLE PDF
#THE GS (GHOSTSCRIPT) COMMAND RESIZES TO 8.5X11 AND COMPRESSES
#
#
#THIS IS A KDIALOG SCRIPT AND WILL ONLY RUN IN KDE. KDIALOG COMMANDS COULD BE REPLACED BY DIALOG COMMANDS
#ALTERNATIVELY, THE KDIALOG COMMANDS COULD BE REPLACED BY COMMAND LINE COMMANDS AND RUN IN A TERMINAL.
#
yn1=1
cd ~/.getscan/
. config
while [ $yn1 = 1 ];
do
cd ~/.getscan/tmp/
kdialog --title "scanner activated" --passivepopup "scanner warming up"
if [ $scnr = 2 ];then
scanadf --mode $clr --resolution $res -y 279 --source 'Automatic Document Feeder(left aligned,Duplex)' 2>test.txt
else
scanadf --mode $clr --resolution $res -y 279 2>test.txt
fi
err1=$(cat test.txt)
rm test.txt
#
#scanner error trap
#
if [ $? = 1 ];then
kdialog --title "scanner error" --msgbox "$err1"
else
#
#don't want to accidentally create in tmp folder.
#"label" kdialog option didn't work
#
kdialog --title "scanner info" --passivepopup "$err1" 5
cd ~/downloads/transfer
name=`kdialog --getsavefilename :newscan.pdf "*.pdf"`
cd ~/.getscan/tmp/
# convert * $name
convert * tmp/temp.pdf
gs -o $name -sDEVICE=pdfwrite -dPDFFitPage -r300x300 -g2550x3300 tmp/temp.pdf
rm *
rm tmp/*
okular $name
fi
yn1=`kdialog --title "continue?" --radiolist "Select:" 1 "scan another document?" on 2 "stop" off 3 "change settings" off --geometry 150x100+300+300 `
if [ $yn1 = 2 ];then
yn1="y"
fi
if [ $yn1 = 3 ];then
cd ~/.getscan/
. config
if [ $scnr = 2 ];then
scnr="ADF-Duplex"
fi
res1=`kdialog --title "scanner resolution" --radiolist "Select Resolution:" 1 "100" off 2 "200" off 3 "300" on 4 "400" off 5 "500" off 6 "600"`
if [ $res1 = 3 ];then
res1=300
fi
echo res=$res1 > config
clr1=`kdialog --title "color" --radiolist "Select Resolution:" 1 "black & white" on 2 "24bit color" off`
if [ $clr1 = 1 ];then
clr1=black
fi
if [ $clr1 = 2 ];then
clr1="'24bit color'"
fi
echo clr=$clr1 >> config
scnr1=`kdialog --title "mode" --radiolist "Select Resolution:" 1 "ADF" on 2 "ADF duplex" off`
if [ $scnr1 = 1 ];then
scnr1="1"
fi
if [ $scnr1 = 2 ];then
scnr1="2"
fi
echo scnr=$scnr1 >> config
. config
yn1=1
fi
done
exit 0