I'm trying to use the linux find command to show me the files in my current directory that have been modified in the last 24h. To test my command, I piped it to ls as below.
find . -maxdepth 1 -mtime -1 | xargs -I{} ls -lh {}
but this command displays all the files in my directory, some of which were modified last year. What am I missing here? I also tried -atime and -ctime options out of curiosity and got seemingly the same file list.
Many thanks for the advice!
In my case the issues was caused because I had the wrong system time on my raspberry.
This was because systemd-timesyncd.service was no longer running.
After:
sudo systemctl unmask systemd-timesyncd.service
sudo systemctl enable systemd-timesyncd.service
sudo reboot
the system time was correct again. Note that the pi needs to be connected to a network for this to work. And also, of course, past wrong file dates don't get fixed by this (duh).
I have tried the following steps to install and setup mongodb in my mac from here https://docs.mongodb.com/manual/tutorial/install-mongodb-on-os-x/ but I got the following error when running the final "mongo" command in my terminal:
Error Message - Zsh: Command Not found : mongo
This error msg occurred after trying to install mongodb 4.2 using brew
sudo chown -R $(whoami) $(brew --prefix)/*
then
brew tap mongodb/brew
then
brew install mongodb-community#4.2
and
brew services start mongodb-community#4.2
or
mongod --config /usr/local/etc/mongod.conf
then
ps aux | grep -v grep | grep mongod
and
mongo
running brew services start mongodb-community#4.2 returns:
Successfully started `mongodb-community#4.2` (label: homebrew.mxcl.mongodb-community#4.2)
running ps aux | grep -v grep | grep mongod returns:
9081 0.2 0.5 5528024 41856 ?? S 3:01pm 0:01.48 /usr/local/opt/mongodb-community#4.2/bin/mongod --config /usr/local/etc/mongod.conf
7613 0.0 0.1 4298832 5600 s000 T 2:47pm 0:00.08 vim /usr/local/etc/mongod.conf
running mongod --config /usr/local/etc/mongod.conf returns:
zsh: command not found: mongod
There are also no mongo files in my /usr/local/bin directory after using these commands
I created a data/db folder in my /usr/local/bin directory using the following commands:
sudo mkdir -p /usr/local/bin/data/db
sudo chown -R `id -un` /usr/local/bin/data/db
Running "brew update" returns:
brew update
Updated 1 tap (homebrew/cask).
==> Updated Casks
brave-browser
brew install mongodb-community-shell
Fixed the problem for me.
Solved it by manually installing the mongodb community files and db tools using the website instead. Then copying them into /usr/local/bin. Then ignoring the app permissions whenever calling mongo or related commands in the terminal through System Preferences > Security & Privacy > General.
After googling I found out that mongoimport and the other features have to be installed separately: https://www.mongodb.com/try/download/database-tools
Followed by copying those bin files after extracting them into the same /usr/local/bin directory
Not sure why its' not working through homebrew though
This worked for me, I was having same issue on mongodb-community#4.4
brew reinstall mongodb-community#4.4
On terminal something like this will appear during reinstallation.
copy highlighted path with echo
echo 'export PATH="/opt/homebrew/opt/mongodb-community#4.4/bin:$PATH"' >> ~/.zshrc
Now open another terminal and start mongodb services
brew services restart mongodb/brew/mongodb-community#4.4
write mongo on terminal and here we fly
If you installed the mongodb via Homebrew. Need to add the mongo path in your bash_profile.
Edit the bash_profile vi ~/.bash_profile
Add the below line in EOF export PATH=$PATH:/usr/local/opt/mongodb-community#4.2/bin
After the edit bash_profile. Close all terminals and open them again. mongo command start works.
In addition to #ramesh-babu-t-b 's answer, https://stackoverflow.com/a/68407530/1279516, the issue could also be that your MongoDB installation did add mongod to your path, but the installation happened within the current shell session, and so your shell doesn't have the updates to the PATH variable yet.
In this case, only his last step is still necessary - Open a new console window and retry the mongod command.
redis dir is /var/lib/redis and dbfilename is dump.rdb and I have restore.rdb backup whichi is from another machine, I tried to replace dump.rdb with restore.rdb but after starting redis it is overwritten to previous steps , so I have changed my dbfilename to restore.rdb and restarted the server but dbfilename is same as before if check in redis-cli
steps I followed
sudo /etc/init.d/redis-server stop
sudo mv /var/lib/redis/dump.rdb /var/lib/redis/dump.rdb.bak
sudo cp restore.rdb /var/lib/redis/dump.rdb
sudo redis-server config/redis.conf
Once server is started dump.rdb is overwritten to previous state. So, instead replace dump.rdb I tried alternative method
sudo /etc/init.d/redis-server stop
sudo cp restore.rdb /var/lib/redis/dump.rdb
and then changed dbfilename to restore.rdb in redis.conf
then restarted the redis
sudo redis-server config/redis.conf.
then I entered into redis-cli and to check config and I realised that config hasn't changed
redis server version:
Redis server v=4.0.9 sha=00000000:0 malloc=jemalloc-3.6.0 bits=64 build=9435c3c2879311f3
the issue is redis server is running in background even after killing it with below command
sudo /etc/init.d/redis-server stop
so you need to make sure you stop redis server is killed
sudo /etc/init.d/redis-server stop
ps aux | grep redis-server | awk '{ print $2 }'| xargs kill -9
above commands will kill all redis related server then
sudo mv /var/lib/redis/dump.rdb /var/lib/redis/dump.rdb.bak
sudo cp restore.rdb /var/lib/redis/dump.rdb
sudo redis-server config/redis.conf
I'm trying to disable randomization via Dockerfile:
RUN sudo echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
but I get
Step 9 : RUN sudo echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
---> Running in 0f69e9ac1b6e
[91mtee: /proc/sys/kernel/randomize_va_space: Read-only file system
any way to work around this? (I see its saying read-only file system any way to get around this?) If its something which the kernel does this means it's outside of my container scope, in that case how am i supposed to work with gdb inside my container? please note this is my target to work with gdb in a container because i'm experimenting with it, so i wanted a container which encapsulates gcc and gdb which i'll use for experimentations.
In host
run:
sudo echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
not in docker
Docker has syntax for modifying some of the sysctls (not via dockerfile though) and kernel.randomize_va_space does not seem to be one of them.
Since you've said you're interested in running gcc/gdb you could disable ASLR only for these binaries with:
setarch `uname -m` -R /path/to/gcc/gdb
Also see other answers in this question.
Sounds like you are building a container for development on your own computer. Unlike production environment, you could (and probably should) opt for a privileged container. In a privileged container sysfs is mounted read-write, so you can control kernel parameters as you would on the host. This is an example of Amazon Linux container I use to develop for on my Debian desktop, which shows the difference
$ docker run --rm -it amazonlinux
bash-4.2# grep ^sysfs /etc/mtab
sysfs /sys sysfs ro,nosuid,nodev,noexec,relatime 0 0
bash-4.2# exit
$ docker run --rm -it --privileged amazonlinux
bash-4.2# grep ^sysfs /etc/mtab
sysfs /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0
bash-4.2# exit
$
Notice ro mount in the unprivileged, rw in the privileged case.
Note that the Dockerfile command
RUN sudo echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
makes no sense. It will be executed (a) during container build time (b) on the machine where you build the image. You want (a) happen at container's run time and (b) on the machine where you run the container. If you need to change sysctls on image start, write a script which does all the setup and then drops you into the interactive shell, like placing a script into e.g. /root and setting it as the ENTRYPOINT
#!/bin/sh
sudo sysctl kernel.randomize_va_space=0
exec /bin/bash -l
(Assuming you mount host working directory into /home/jas that's a good practice, as bash will read your startup files etc).
You need to make sure you have the same UID and GID inside the container, and can do sudo. How you enable sudo depends on a distro. In Debian, members of the sudo group have unrestricted sudo access, while on Amazon Linux (and, IIRC, other RedHat-like system, the group wheel has. Usually this boils down to an unwieldy run command that you rather want to script than type, like
docker run -it -v $HOME:$HOME -w $HOME -u $(id -u):$(id -g) --group-add wheel amazonlinux-devenv
Since your primary UID and GID match the host, files in mounted host directories won't end up owned by root. An alternative is create a bona fide user for yourself during image build (i.e., in the Dockerfile), but I find this more error-prone, because I can end up running this devenv image where my username has a different UID, and that will cause problems. The use of id(1) in a startup command guarantees UID match.
I apparently have a redis-server instance running because when I try to start a new server by entering redis-server, I'm greeted with the following:
Opening port: bind: Address already in use
I can't figure out how to stop this server and start a new one.
Is there any command I can append to redis-server when I'm typing in the CLI?
My OS is Ubuntu 10.04.
Either connect to node instance and use shutdown command or if you are on ubuntu you can try to restart redis server through init.d:
/etc/init.d/redis-server restart
or stop/start it:
/etc/init.d/redis-server stop
/etc/init.d/redis-server start
On Mac
redis-cli shutdown
A cleaner, more reliable way is to go into redis-cli and then type shutdown
In redis-cli, type help #server and you will see this near the bottom of the list:
SHUTDOWN - summary: Synchronously save the dataset to disk and then
shut down the server since: 0.07
And if you have a redis-server instance running in a terminal, you'll see this:
User requested shutdown...
[6716] 02 Aug 15:48:44 * Saving the final RDB snapshot before exiting.
[6716] 02 Aug 15:48:44 * DB saved on disk
[6716] 02 Aug 15:48:44 # Redis is now ready to exit, bye bye...
redis-cli shutdown is most effective. The accepted answer does not work for me (OSX Lion). Thanks, #JesseBuesking.
For OSX, I created the following aliases for starting and stopping redis (installed with Homebrew):
alias redstart='redis-server /usr/local/etc/redis/6379.conf'
alias redstop='redis-cli -h 127.0.0.1 -p 6379 shutdown'
This has worked great for local development!
Homebrew now has homebrew-services that can be used to start, stop and restart services. homebrew-services
brew services is automatically installed when run.
brew services start|run redis
brew services stop redis
brew services restart redis
If you use run, then it will not start it at login (nor boot). start will start the redis service and add it at login and boot.
stop the redis server type in terminal with root user
sudo service redis-server stop
the message will be display after stop the redis-server
Stopping redis-server: redis-server.
if you want to start the redis-server type
sudo service redis-server start
if you want to restart the server type
sudo service redis-server restart
Type SHUTDOWN in the CLI
or
if your don't care about your data in memory, you may also type SHUTDOWN NOSAVE to force shutdown the server.
Try killall redis-server. You may also use ps aux to find the name and pid of your server, and then kill it with kill -9 here_pid_number.
Option 1: go to redis installation directory and navigate to src , in my case :
/opt/redis3/src/redis-cli -p 6379 shutdown
where 6379 is the default port.
Option 2: find redis process and kill
ps aux | grep redis-server
t6b3fg 22292 0.0 0.0 106360 1588 pts/0 S+ 01:19 0:00 /bin/sh /sbin/service redis start
t6b3fg 22299 0.0 0.0 11340 1200 pts/0 S+ 01:19 0:00 /bin/sh /etc/init.d/redis start
And Then initiate kill:
kill -9 22292
kill -9 22299
I'm using Centos 6.7 , x86_64
hope it helps
I would suggest to disable Redis-server, which prevents auto start while computer restarts and very useful to use docker like tools etc.
Step 1: Stop the redis-server
sudo service redis-server stop
Step 2: Disable the redis-server
sudo systemctl disable redis-server
if you need redis, you can start it as:
sudo service redis-server start
Another way could be:
ps -ef | grep -i 'redis-server'
kill -9 PID owned by redis
Works on *NIX & OSX
MacOSX - It Worked :)
Step 1 : Find the previously Running Redis Server
ps auxx | grep redis-server
Step 2 : Kill the specific process by finding PID (Process ID) - Redis Sever
kill -9 PID
if you did make install (e.g ubuntu) while installing redis then you can do:
redis-cli shutdown
as pointed by #yojimbo87 :)
systemd, ubuntu 16.04:
$ sudo systemctl is-active redis-server
active
$ sudo systemctl is-enabled redis-server
enabled
$ sudo systemctl disable redis-server
Synchronizing state of redis-server.service with SysV service script with /lib/systemd/systemd-sysv-install.
Executing: /lib/systemd/systemd-sysv-install disable redis-server
Removed /etc/systemd/system/redis.service.
$ sudo systemctl stop redis-server
Usually this problem arises after I shut down my computer ( or leaving running ) an irregular way.. I believe the port gets stuck open, while the process stops but continues to be bound to the previous port.
9/10 times the fix can be:
$ ps aux | grep redis
-> MyUser 2976 0.0 0.0 2459704 320 ?? S Wed01PM 0:29.94 redis-server *:6379
$ kill 2976
$ redis-server
Good to go.
Another way could be :
brew services stop redis
If you know on what port it would be running(by default it would be 6379), you can use below command to get the pid of the process using that port and then can execute kill command for the same pid.
sudo lsof -i : <port> | awk '{print $2}'
the above command will give you pid.
kill <pid>;
This would shutdown your server.
Following worked for me on MAC
ps aux | grep 'redis-server' | awk '{print $2}' | xargs sudo kill -9
If you know on which port(default:6379) your redis server is running you can go with option 1 or you can check your redis process and you can kill with option 2
option 1:Kill process on port:
check : sudo lsof -t -i:6379
kill : sudo kill `sudo lsof -t -i:6379`
option 2:
Find the previously Running Redis Server:
ps auxx | grep redis-server
Kill the specific process by finding PID (Process ID) - Redis Sever
kill -9 PID
Now start your redis server with
redis-server /path/to/redis.conf
In my case it was:
/etc/init.d/redismaster stop
/etc/init.d/redismaster start
To find out what is your service name, you can run:
sudo updatedb
locate redis
And it will show you every Redis files in your system.
If you are running redis in a docker container, none of the present answers will help. You have to stop redis container. Otherwise, redis process will keep respawning.
$ docker ps
CONTAINER ID IMAGE PORTS
e1c008ab04a2 bitnami/redis:4.0.8-r0 0.0.0.0:6379->6379/tcp
$ docker stop e1c008ab04a2
e1c008ab04a2
To stop redis server
sudo service redis-server stop
and check the status of it using
sudo service redis-server status
If Redis is installed via snap:
sudo snap stop redis.server
I don't know specifically for redis, but for servers in general:
What OS or distribution? Often there will be a stop or /etc/init.d/... command that will be able to look up the existing pid in a pid file.
You can look up what process is already bound to the port with sudo netstat -nlpt (linux options; other netstat flavors will vary) and signal it to stop. I would not use kill -9 on a running server unless there really is no other signal or method to shut it down.
The commands below works for me on Ubuntu Server
$ service /etc/init.d/redis_6379 stop
$ service /etc/init.d/redis_6379 start
$ service /etc/init.d/redis_6379 restart
Redis has configuration parameter pidfile (e.g. /etc/redis.conf - check redis source code), for example:
# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
#
pidfile /var/run/redis.pid
If it is set or could be set, instead of searching for process id (pid) by using ps + grep something like this could be used:
kill $(cat /var/run/redis.pid)
If required one can make redis stop script like this (adapted default redis 5.0 init.d script in redis source code):
PIDFILE=/var/run/redis.pid
if [ ! -f $PIDFILE ]
then
echo "$PIDFILE does not exist, process is not running"
else
PID=$(cat $PIDFILE)
echo "Stopping ..."
kill $PID
while [ -x /proc/${PID} ]
do
echo "Waiting for Redis to shutdown ..."
sleep 1
done
echo "Redis stopped"
fi
On MacOSX,
This is what worked for me
/etc/init.d/redis restart
/etc/init.d/redis stop
/etc/init.d/redis start
One thing to check if the redis commands are not working for you is if your redis-server.pid is actually being created. You specify the location of where this file is in
/etc/systemd/system/redis.service
and it should have a section that looks something like this:
[Service]
Type=forking
User=redis
Group=redis
ExecStart=/usr/bin/redis-server /etc/redis/redis.conf
PIDFile=/run/redis/redis-server.pid
TimeoutStopSec=0
Restart=always
Check the location and permissions of the PIDFile directory (in my case, '/run/redis'). I was trying to restart the service logged in as deploy but the directory permissions were listed as
drwxrwsr-x 2 redis redis 40 Jul 20 17:37 redis
If you need a refresher on linux permissions, check this out. But the problem was I was executing the restart as my deploy user which the permissions above are r-x, not allowing my user to write to the PIDFile directory.
Once I realized that, I logged in using root, reran the restart command on the redis (service redis restart) and everything worked. That was a headache but hopefully this saves someone a little time.
To gracefully shutdown specific instances with passwords and not resorting to brute-force kill commands, use:
redis-cli -p <port> -a <pass> shutdown
root#machine:~# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 105 0.1 0.0 60552 10772 ? Ssl 23:27 0:02 redis-server 127.0.0.1:10002
root 111 0.1 0.0 60552 10900 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10003
root 117 0.1 0.0 60552 10872 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10004
root#machine:~# redis-cli -p 10002 -a mypassword shutdown
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
root#machine:~# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 111 0.1 0.0 60552 10900 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10003
root 117 0.1 0.0 60552 10872 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10004
root#machine:~#
Having a ton of instances warrants writing a batch script to loop through them all for a master shutdown.
The service name of redis is redis-server, so you can disable and stop redis with this command:
sudo systemctl disable redis-server
sudo systemctl stop redis-server
You can try this code:
sudo kill -9 $(ps aux | grep 'redis' | awk '{print $2}')