फ़ाइल परिवर्तन पर स्वचालित संस्करणकरण (संशोधित / बनाना / हटाना)

Question

मैं एक तंत्र के कार्यान्वयन (लिनक्स पर) की तलाश कर रहा हूं जो स्वचालित रूप से और पारदर्शी रूप से किसी निर्देशिका (पुनरावर्ती) में किसी भी परिवर्तन का संस्करण देगा। यह अतिरिक्त वर्जनिंग (SVN, git, ...) के अलावा (संभवतः प्रतिस्थापन यदि सभी अनुरोधित सुविधाएं उपलब्ध हैं) होने का इरादा है।

MS Windows पर एक उत्पाद जो ऐसा करता है वह है AutoVer (आवश्यकताओं का बेहतर विचार रखना)। मैं ऐसा कुछ करना पसंद करूंगा, लेकिन एक गैर-ग्राफिकल वातावरण में लिनक्स के लिए इसका उद्देश्य है।

मैंने देखा कि लिनक्स पर इस कार्यशीलता के लिए कुछ प्रयास हैं, मुझे जो निकटतम मिला वह सबवर्सन पर स्वतः-लोड हो रहा है लेकिन मौजूदा वातावरण (सर्वर, उदाहरण के लिए, कॉन्फ़िगरेशन फ़ाइल स्थानीय हैं) पर लागू करना स्पष्ट नहीं है।

शायद कुछ के साथ काम inotify?

किसी भी संकेत के लिए अग्रिम धन्यवाद! woj

Comments

संबंधित: फ्लैशबेक

— डेन डी।

sourceforge.net/apps/mediawiki/fuse/…

— SleighBoy

क्या कोई विशेष आवश्यकता है कि आप किस सॉफ्टवेयर का उपयोग करते हैं? क्योंकि यदि आप केवल उन परिवर्तनों को ट्रैक करने की तलाश कर रहे हैं जो आप मैन्युअल रूप से करते हैं (फ़ाइलों को संपादित करके), तो ग्रहण में यह सुविधा अंतर्निहित है, इसे "नया इतिहास" कहा जाता है।

— स्टीफन सेडेल

@StefanSeidel मैं विषय-स्टार्टर नहीं हूं, लेकिन मैं नो-आईडीई समाधान पसंद करूंगा।

— माइकल पैंकोव

Answer 1

1. सामान्य उद्देश्य विधि का उपयोग कर बाजार और inotify है

यह मेरे द्वारा अप्रमाणित है, लेकिन मैंने यह लिखा है कि इसका उपयोग bzr(बाजार) का उपयोग करता है और inotifywaitएक निर्देशिका की निगरानी करने के लिए और बाजार का उपयोग करके इसमें फ़ाइलों को नियंत्रित करता है।

यह स्क्रिप्ट परिवर्तन के लिए निर्देशिका देखने का सारा काम करती है:

#!/bin/bash

# go to checkout repository folder you want to watch
cd path/to/www/parent/www
# start watching the directory for changes recusively, ignoring .bzr dir
# comment is made out of dir/filename
# no output is shown from this, but wrinting a filename instead of /dev/null 
# would allow logging
inotifywait –exclude \.bzr -r -q -m -e CLOSE_WRITE \
    –format=”bzr commit -m ‘autocommit for %w/%f’” ./ | \
    sh  2>/dev/null 1>&2 &
# disown the pid, so the inotify thread will get free from parent process
# and will not be terminated with it
PID=`ps aux | grep inotify | grep CLOSE_WRITE | grep -v grep | awk ‘{print $2}’`
disown $PID

# this is for new files, not modifications, optional
inotifywait –exclude \.bzr -r -q -m -e CREATE \
    –format=”bzr add *; bzr commit -m ‘new file added %w/%f’” ./ | \
    sh  2>/dev/null 1>&2 &
PID=`ps aux | grep inotify | grep CREATE | grep -v grep | awk ‘{print $2}’`
disown $PID

exit 0;

2. प्रबंध / आदि

अपने सिस्टम की /etcनिर्देशिका को प्रबंधित करने के विशेष मामले के लिए , आप ऐप एटकीपर का उपयोग कर सकते हैं ।

etckeeper, git, mercurial, darcs, या bzr रिपॉजिटरी में संग्रहित करने के लिए टूल्स का एक संग्रह है। यह उपयुक्त रूप से (और यम और पैक्मैन-जी 2 सहित अन्य पैकेज मैनेजर) को हुक करता है, जो पैकेज अपग्रेडेशन के लिए / आदि किए गए बदलावों को स्वचालित रूप से करने के लिए होता है। यह फ़ाइल मेटाडेटा को ट्रैक करता है जो नियंत्रण प्रणाली को सामान्य रूप से समर्थन नहीं करता है, लेकिन यह / etc / छाया या की अनुमतियों जैसे / etc के लिए महत्वपूर्ण है। यदि आप संशोधन नियंत्रण के साथ काम करने की मूल बातें समझते हैं, तो इसका उपयोग करना सरल होने के साथ-साथ यह काफी मॉड्यूलर और विन्यास योग्य है।

यहाँ एक अच्छा ट्यूटोरियल है जिसे आपने इसके साथ शुरू किया है।

3. git और incron का उपयोग करना

इस तकनीक का उपयोग करता है gitऔर incron। इस विधि के लिए आपको निम्नलिखित कार्य करने होंगे:

A. रेपो बनाओ

% mkdir $HOME/git
% cd $HOME/git
% git init

B. एक $HOME/bin/git-autocommitस्क्रिप्ट बनाएं

#!/bin/bash

REP_DIR="$HOME/git"       # repository directory
NOTIFY_DIR="$HOME/srv"    # directory to version

cd $REP_DIR
GIT_WORK_TREE=$NOTIFY_DIR /usr/bin/git add .
GIT_WORK_TREE=$NOTIFY_DIR /usr/bin/git commit -a -m "auto"

C. incrontab में एक प्रविष्टि जोड़ें

% sudo incrontab -e $HOME/srv IN_MODIFY,IN_CREATE,IN_MOVED_FROM,IN_MOVED_TO $HOME/bin/git-autocommit

4. फ्लैशबेक का उपयोग करना

एक अन्य विकल्प फ्लैशबेक जैसे उपकरण का उपयोग करना है । Flashbake संस्करण नियंत्रण प्रणाली है जिसे Cory Doctorow (BoingBoing प्रसिद्धि का) अपनी पुस्तकों को लिखने के लिए उपयोग करता है।

फ्लैशबेक परिवर्तनों को ट्रैक करने के लिए हुड के नीचे गिट का उपयोग करता है, लेकिन स्वचालित बैकअप करने और स्वयं सादे संस्करण नियंत्रण प्रणाली का उपयोग करने के बीच कहीं है।

कोरी चाहते थे कि संस्करण प्रोमप्स ले जाए, उस समय का स्नैपशॉट जहां वह एक स्वचालित कमिट हुआ था और वह क्या सोच रहा था। मैंने जल्दी से एक पाइथन स्क्रिप्ट को छोड़ दिया, जिसमें वह प्रासंगिक जानकारी खींचना चाहता था और जीआईटी को चलाने के लिए एक शेल स्क्रिप्ट को एक साथ हैक करना शुरू कर दिया, जब एक क्रॉन जॉब ने शेल आवरण को लागू किया, तो कमेंट कमेंट के लिए पायथन स्क्रिप्ट के आउटपुट का उपयोग किया।

साधन

• अपलोड पर स्वचालित फ़ाइल संशोधन

Comments

inotifywait + "git local" = gitwatch.sh, यहाँ देखें: github.com/nevik/gitwatch/blob/master/gitwatch.sh

— diyism

Answer 2

तुरंत ZFS के दिमाग में आता है। यह स्नैपशॉट बना सकता है - और स्नैपशॉट बनाने के लिए स्वचालित रूप से कुछ प्रोजेक्ट हैं ।

Comments

मैं ZFS के बारे में पढ़ता हूं, लेकिन ऐसा लगता है कि यह बुनियादी फाइल सिस्टम के लिए एक स्थिर समाधान नहीं है (कम से कम लिनक्स में)

— WoJ

मैं वास्तव में मौजूदा FS पर स्नैप करने के लिए एक समाधान चाहूंगा।

— माइकल पैंकोव

शायद यह? ext3cow.com

— Zac B

Answer 3

मुझे लगता है कि आप सही रास्ते पर हैं inotify। यह लेख आपके समान मामले में इसके मूल उपयोग का विवरण देता है। मैं इसे सीधे उपयोग करने का सुझाव दूंगा , या fschange जैसी कर्नेल-स्तरीय उपयोगिता का संकलन करूंगा । यह एक परेशानी की बात है, लेकिन आप तब git commitया इससे मिलते-जुलते परिवर्तनों का पता लगा सकते हैं ।

उन समाधानों में कुछ हद तक तीसरे पक्ष के समाधानों पर भरोसा करने का मुद्दा है। यदि आपको अपने हाथों को गंदा करने में कोई आपत्ति नहीं है, तो NodeJS इस सटीक उद्देश्य के लिए एक उत्कृष्ट, क्रॉस-प्लेटफ़ॉर्म सुविधा ( fs.watch ) प्रदान करता है। NodeJS में परिवर्तन के लिए फ़ाइलों को देखने का एक बुनियादी ट्यूटोरियल यहां पाया जा सकता है । कुछ दर्जन लाइनों या उससे कम में, आप कुछ ऐसा लिख ​​सकते हैं जो फाइलों के लिए एक निर्देशिका देखता है, और फिर बाहर ( चाइल्ड_प्रोसेस के माध्यम से ) खोल देता है और एक git commitया समान चलाता है (या मैन्युअल रूप से एक संस्करण फ़ाइल इंडेक्स बढ़ाता है, अगर आपको रोल-आपकी पसंद है- अपना दृष्टिकोण)।

fs.watchinotifyलाइनक्स द्वारा समर्थित है , लेकिन उपयोग करने के लिए बहुत अधिक सहज है। NodeJS की अन्य परियोजनाएँ हैं जो उस फ़ाइल-देखने की कार्यक्षमता को सुविधा के विभिन्न स्तरों में लपेटती हैं, जैसे यह एक या यह ।

Comments

अभी भी एक तैयार समाधान नहीं है, और, ठीक है, मैं शायद पायथन के साथ जाऊंगा inotify। लेकिन धन्यवाद।

— माइकल पैंकोव

Answer 4

लिनक्स पर inotify (2) एक बड़े पेड़ को देखने में सक्षम नहीं होगा, लेकिन फ़्यूज़ फ़ाइल सिस्टम (अलग-अलग स्थान पर घुड़सवार) शायद इसे संभाल सकता है, svn या git कॉल के लिए फाइल सिस्टम अनुरोधों का अनुवाद करके, या सीधे svn / git metatata को बदलकर।

यह एक बहुत ही दिलचस्प विचार है, लेकिन मैंने किसी भी मौजूदा कार्यान्वयन के बारे में नहीं सुना था।

Comments

मान लीजिए कि मेरे पास केवल कुछ फाइलें हैं।

— माइकल पैंकोव

Answer 5

ऐसी पटकथा लिखना कठिन नहीं है।

मेरा पसंदीदा संस्करण नियंत्रण git है।

निम्नलिखित स्क्रिप्ट को यह करना चाहिए:

#!/bin/sh
git add .
git commit -am "my automatic commit"

या तो समय-समय पर अपनी निर्देशिका की जाँच करें - या यदि आपका संपादक आपके द्वारा सेव करने के बाद स्क्रिप्ट करने योग्य कॉल है।

लेकिन अगर आप इसे इस तरह करते हैं तो बड़ी फ़ाइलों को बाहर करने के लिए समझ में आ सकता है और शायद कुछ "बेकार" जैसे ऑटोसैव।

Comments

हां मुझे पता है कि क्रोन आधारित समाधान लागू करने के लिए सरल है। हालाँकि मैं कुछ ऐसी चीज़ों की तलाश में हूँ, जो सेव करने पर किसी भी तरह की बचत न करें। यही कारण है कि मैंने svn पर ऑटोवोस्क्रिनफ का उल्लेख किया और साथ ही अपने प्रश्न में संक्षेपण किया।

— WoJ

Answer 6

SparkleShare ( http://sparkleshare.org ) git पर आधारित है और संस्करण नियंत्रण के साथ ड्रॉपबॉक्स जैसी कार्यक्षमता लागू करता है, लेकिन आपको एक ssh- सर्वर सेट करना होगा (स्थानीयहो सकता है)।

Comments

यह बात अनाड़ी है और इसके लिए बहुत सारे सेटअप की आवश्यकता है। इसके अलावा, ड्रॉपबॉक्स कार्यक्षमता अनावश्यक है।

— माइकल पैंकोव

Answer 7

मैं आपको NILFS आज़माने की सलाह दूंगा। के बारे में पृष्ठ देखें और आप जल्दी फैसला करने में सक्षम हो जाएगा यह वही है जो आप देख रहे हैं या नहीं।

HTH

Answer 8

केवल rsync और क्रॉन जॉब का उपयोग करके ऐसा करने का "गरीब आदमी" तरीका है। आप मूल रूप से rsync की बैकअप सुविधा पर भरोसा करते हैं और अपनी फ़ाइलों का ट्रैक रखने के लिए दो अलग-अलग रास्तों का उपयोग करते हैं।

यह इस तरह कम दिखाई देता है: / usr / bin / rsync -a -A -X --backup --suffix = date +".%Y-%m-%d_%H-%M-%S"$ source_path $ backup_path

अंतिम परिणाम: प्रारंभिक निष्पादन के बाद स्रोत पथ में test_rsync नामक फ़ाइल को बदलने से बैकअप पथ में test_rsync.2017-02-09_11-00-01 नामक फ़ाइल हो जाएगी।

इसके साथ समस्याओं का एक गुच्छा है (यह काम करता है यदि आपके पास केवल फ़ाइलों की एक सभ्य राशि है और उन परिवर्तनों के लिए विफल हो जाएगी जो rsync के दो लगातार रन (मेरे मामले में 1 मिनट) के बीच होते हैं), लेकिन यह आपकी आवश्यकताओं के लिए पर्याप्त हो सकता है।

अगर हम यहां सांबा के शेयरों के बारे में बात कर रहे हैं तो एक बहिष्करण सूची क्रम में हो सकती है, इसके आसपास नहीं मिला है, फिर भी मुझे डर है।

अगर आप इसमें सुधार करते हैं तो मुझे बताएं।

Answer 9

यहां एक पायथन 3 स्क्रिप्ट है जो वीएमएस की तरह ऑटो फाइल वर्जनिंग करती है, जिसे सहेजने के समय मूल फाइल नाम से जोड़कर स्टांप लगाया जाता है।

मैंने स्क्रिप्ट में कमेंट्री का एक समूह रखा है और अपनी ubuntu मशीन पर आधा दर्जन ऐसी स्क्रिप्ट चला रहा हूँ, जिसमें केवल निर्देशिका ही स्क्रिप्ट के प्रत्येक भिन्न संस्करण में अलग-अलग होती है ताकि मैं एक साथ कई निर्देशिकाओं का संस्करण तैयार कर सकूँ। मशीनों के प्रदर्शन पर कोई वास्तविक जुर्माना नहीं।

/ usr / bin / env python3

प्रिंट करें ("PROJECT FILES VERSIONING STARTED") प्रिंट करें ("version_creation.py") #place इस नाम की स्क्रिप्ट के सभी कोड को प्रिंट करें ("कमांड के रूप में चलाएं .. 'python3 version_creation.py') प्रिंट (" ctrl ') c 'to stop ") प्रिंट (" ") प्रिंट (" कमांड लाइन के नीचे पृष्ठभूमि प्रकार में प्रोग्राम चलाने के लिए और फिर विंडो बंद करें। ") प्रिंट (" nohup python3 version_creation.py ") प्रिंट (" .... " स्टॉप प्रोसेस गो मेन्यू / एडमिनिस्ट्रेशन / सिस्टम मॉनीटर ... और पाइथन 3 को मारें ") प्रिंट (" ") प्रिंट (" फाइल को हमेशा 'प्रोजेक्टफाइल्स' डायरेक्टरी और वर्जन फाइल्स को सेव करें ") प्रिंट (" भी उस डायरेक्टरी में बनेगा ") ") प्रिंट (" ") प्रिंट (" ") प्रिंट (" ") प्रिंट (" ")

आयात शील आयात os आयात समय

--- नीचे नई फ़ाइलों (सेकंड में) की जाँच करने के लिए समय अंतराल सेट करें

- यह अंतराल अंतराल से छोटी होनी चाहिए नई फाइलें दिखाई देती हैं!

टी = १०

--- स्रोत निर्देशिका (dr1) और लक्ष्य निर्देशिका (dr2) सेट करें

dr1 = "/ पथ / से / source_directory"

dr2 = "/ पथ / से / target_directory"

आयात glob आयात os

dr1 = "/ home / michael / ProjectFiles" # मूल और संस्करणों को इस निर्देशिका में सहेजा जाएगा

dr2 = "/ होम / माइकेल / प्रोजेक्ट फ़िलेवीर्स"

जबकि सच:

if os.listdir(dr1) == []:

प्रिंट ("खाली")

    n = 100
else:
    list_of_files = glob.glob(dr1+'/*')   # * means all if need specific format then *.csv
    latest_file_path = max(list_of_files, key=os.path.getctime)

प्रिंट करें ("1 नवीनतम_फाइल_पथ =", नवीनतम_फाइल_पैथ)

    originalname = latest_file_path.split('/')[-1]

प्रिंट ("2 ओरिजिनल =", ओरिजिनल)

    filecreation = (os.path.getmtime(latest_file_path))

प्रिंट ("फ़ाइलक्रीशन =", फ़ाइलक्रीट)

    now = time.time()
    fivesec_ago = now - 5 # Number of seconds

प्रिंट ("fivesec_ago =", fivesec_ago)

    timedif = fivesec_ago - filecreation #time between file creation

प्रिंट ("समयसीमा =", समयसीमा)

    if timedif <= 5: #if file created less than 5 seconds ago

        nameroot = originalname.split(".")[-0]
        print ("3 nameroot= ", nameroot)

        extension = os.path.splitext(originalname)[1][1:]
        print ("4 extension = ", extension)

        curdatetime = time.strftime('%Y%m%d-%H%M%S')
        print ("5 curdatetime = ", curdatetime)

        newassembledname = (nameroot + "_" + curdatetime + "." + extension)
        print ("6 newassembledname = ", newassembledname)



        source = dr1+"/"+originalname
        print ("7 source = ", source)

        target = dr1+"/"+newassembledname
        print ("8 target = ", target)

        shutil.copy(source, target)


    time.sleep(t)

शेयर

नीचे पहले रखा गया था और काम करता है लेकिन मुझे उपरोक्त अजगर की स्क्रिप्ट बहुत अच्छी लगती है ...... (3 साल से अजगर का उपयोग कर रहा है)

#!/usr/bin/env python3

print ("PROJECT FILES VERSIONING STARTED")
print ("projectfileversioning.py")
print ("run as..  'python3 projectfileversioning.py'       from command line")
print ("ctrl 'c'      to stop")
print (" ")
print ("To run program in background type below to command line and then close the window. ")
print ("nohup python3 projectfileversioning.py")
print ("....to stop process go menu/administration/system monitor... and kill python")
print (" ")
print ("Always save files to the 'ProjectFiles' directory and the file ")
print ("   will be redirected to the ProjectFileVersions where")
print ("   time stamped versions will also be created.")
print (" ")
print ("If you like you may then copy/move the versioned and original file from 'ProjectFileVersions' to ")
print ("any other directory you like.")

import shutil
import os
import time

#--- set the time interval to check for new files (in seconds) below 
#-   this interval should be smaller than the interval new files appear!
t = 10

#--- set the source directory (dr1) and target directory (dr2)
#dr1 = "/path/to/source_directory"
#dr2 = "/path/to/target_directory"

import glob
import os

dr1 = "/home/michael/ProjectFiles"
dr2 = "/home/michael/ProjectFileVersions"


while True:

    if os.listdir(dr1) == []:
        n = 100
    else:
        list_of_files = glob.glob(dr1+'/*')   # * means all if need specific format then *.csv
        latest_file_path = max(list_of_files, key=os.path.getctime)
        print ("1 Latest_file_path = ", latest_file_path)

        originalname = latest_file_path.split('/')[-1]
        print ("2 originalname = ", originalname)

        nameroot = originalname.split(".")[-0]
        print ("3 nameroot= ", nameroot)

        extension = os.path.splitext(originalname)[1][1:]
        print ("4 extension = ", extension)

        curdatetime = time.strftime('%Y%m%d-%H%M%S')
        print ("5 curdatetime = ", curdatetime)

        newassembledname = (nameroot + "_" + curdatetime + "." + extension)
        print ("6 newassembledname = ", newassembledname)




        source = dr1+"/"+originalname
        print ("7 source = ", source)

        target = dr2+"/"+originalname
        print ("8 target = ", target)

        shutil.copy(source, target)



        source = dr1+"/"+originalname
        print ("9 source = ", source)

        target = dr2+"/"+newassembledname
        print ("10 target = ", target)

        shutil.move(source, target)
        time.sleep(t)


#share