Fabric: फैब्रिक 2 अल्फा/बीटा फीडबैक मेटा-टिकट!

यूआरएल में छोटी सी गलती, यह होना चाहिए http://bitprophet.org/blog/2017/04/17/fabric-2-alpha-beta/

यह दिखाने के लिए जाता है कि मुझे अपनी वेबसाइट कितनी अच्छी तरह याद है, एह? धन्यवाद! मैंने अपनी पोस्ट पर एक लिंक चेकर भी चलाया, लेकिन ... इस टिकट के खिलाफ नहीं;)

मेरे पास एक प्रस्ताव है कि कैसे कपड़े 1 के रोलडेफ सिस्टम को इस तरह से लागू किया जा सकता है कि मैं इसे कपड़े 2 के दर्शन के अनुरूप मानता हूं। कार्यों के प्रत्येक Collection में समान नामस्थान में @group सजाए गए फ़ंक्शन भी हो सकते हैं जो आबादी वाले Group ऑब्जेक्ट लौटाते हैं जिनके विरुद्ध कार्य चलाया जा सकता है। नेमस्पेस मायने रखता है, इसलिए यदि fabfile.py में Collection होता है जिसे deploy $ कहा जाता है, जिसके पास @group s जिसे web और db कहा जाता है , web समूह में प्रत्येक होस्ट पर mytask निष्पादित करने के लिए कोई deploy.web.execute(mytask) या fab -G deploy.web mytask का उपयोग कर सकता है। इन सजाए गए कार्यों को अनावश्यक एपीआई कॉल को रोकने के लिए आलसी और याद किया जाएगा, यदि होस्ट सूची लुकअप उपयोगकर्ता द्वारा कार्यान्वित धीमी गति से संचालन होना चाहिए।

क्या यह फैब्रिक 2 के डिजाइन दर्शन के अनुरूप है? यदि ऐसा है तो मुझे कार्यान्वयन पर एक स्विंग लेना अच्छा लगेगा।

यह एक अच्छा विचार है, @RedKrieg! मैं समूह वस्तुओं को उत्पन्न करने के लिए "सर्वश्रेष्ठ" और/या सीएलआई पर उन्हें कैसे संदर्भित करना है, लेकिन ऑफहैंड जो जाने का एक उचित तरीका लगता है, के लिए मैं अपने स्वयं के मंथन को स्थगित कर रहा हूं। मैंने अभी-अभी #1594 में बहुत अधिक शब्द निकाले हैं और वहां आपके विचार (+ एक लिंक) शामिल किए हैं। आइए वहां चर्चा जारी रखें, लेकिन हां, मुझे पीओसी पीआर देखना अच्छा लगेगा।

-H तर्क मौजूद होने के बावजूद स्थानीय रूप से कमांड चलाने का सबसे अच्छा तरीका क्या है, उदाहरण के लिए यदि मैं स्थानीय बिल्ड और rsync को रिमोट होस्ट में एक ही कार्य में जोड़ना चाहता हूं?

@ मैक्स-अर्नोल्ड कनेक्शन ऑब्जेक्ट्स में .local विशेषता होती है जो स्थानीय मशीन पर .run की तरह काम करती है: http://docs.fabfile.org/en/v2/api/connection.html#fabric .कनेक्शन।कनेक्शन।स्थानीय

ठीक है, मुझे लगता है कि एक उदाहरण शब्दों से बेहतर है:

<strong i="6">@task</strong>
def build(ctx):
    # should always run locally
    ctx.local('uname -a')


<strong i="7">@task</strong>
def deploy(ctx):
    build(ctx)
    # this one should run on remote host
    ctx.run('uname -a')

संयुक्त कार्य ठीक चलता है:

fab -H host deploy

केवल स्थानीय कार्य विशेषता त्रुटि के साथ विफल रहता है: 'स्थानीय' के लिए कोई विशेषता या कॉन्फ़िगरेशन कुंजी नहीं मिली:

fab build

असल में मैं एक ऐसा कार्य करना चाहता हूं जो स्थानीय रूप से कुछ करता है, इससे कोई फर्क नहीं पड़ता कि इसे कैसे लागू किया गया था ( -H के साथ या बिना)।

दूसरी ओर से, कुछ आदेश केवल दूरस्थ रूप से चलाने के लिए अभिप्रेत हैं। यदि कोई होस्ट मौजूद नहीं है, तो ctx.run उन्हें स्थानीय रूप से चलाने का प्रयास करेगा, जिसके अनपेक्षित परिणाम हो सकते हैं।

| उपयोगकर्ता कार्य चलाता है | कमांड/कार्य लेखक चाहता है कि इसे चलाया जाए | इसे कैसा व्यवहार करना चाहिए? |
|---------------------|------------------------------------- ---|----------------|
| स्थानीय रूप से | स्थानीय रूप से | रन () व्यवहार ठीक है (लेकिन दूर से चलाने पर लेखक के इरादे का उल्लंघन होगा) |
| स्थानीय रूप से | दूर से | यह विफल होना चाहिए (या पुराने कपड़े की तरह मेजबान स्ट्रिंग के लिए पूछें) |
|स्थानीय रूप से | स्थानीय या दूर से | रन () व्यवहार ठीक है |
| दूर से | स्थानीय रूप से | इसे हमेशा स्थानीय रूप से चलाना चाहिए, लेकिन इसे सुनिश्चित करने के लिए Context के पास कोई स्थानीय () विधि नहीं है |
| दूर से | दूर से | रन () व्यवहार ठीक है (लेकिन स्थानीय आह्वान के दौरान समस्याएँ अपेक्षित हैं) |
| दूर से | स्थानीय या दूर से | रन () व्यवहार ठीक है |

@ मैक्स-अर्नोल्ड यह बिल्कुल #98 है! जिसे मैंने अभी तक पूरी तरह से हल नहीं किया है। कुछ आधुनिक विचारों को एक टिप्पणी के रूप में वहाँ रखना...संपादित करें: यह वाला

मैंने देखा है कि सुडो के साथ असंगतता क्या प्रतीत होती है।

जहां connection एक दूरस्थ सर्वर है, जो रूट के रूप में प्रमाणित है।

टिल्ड को रूट के अलावा किसी अन्य उपयोगकर्ता के रूप में विस्तारित करने का प्रयास कर रहा है:

c.sudo("echo bar > ~/foo", user="builder")

यह सफल होता है, लेकिन लिखने के बजाय /home/builder/foo, इसके बजाय /root/foo.

दूसरी ओर, अगर मैं सिर्फ ls करने की कोशिश करता हूं:

c.sudo("ls", user="builder")

मुझे Permission denied मिलता है।

कुछ हटकर लगता है।

मेरा अनुमान है कि जब डस्टिन ने उपरोक्त आउट-ऑफ-बैंड की सूचना दी, तो यह था कि यह एक sudo (कमांड, विधि नहीं) विशिष्ट शिकन है, क्योंकि आखिरी बार मैंने देखा कि हम -H का उपयोग कर रहे हैं और जाहिरा तौर पर यह 100% वैसा व्यवहार नहीं करता जैसा हम उम्मीद कर रहे हैं।

हाय जेफ,
चूंकि मैं पहले से ही अजगर 3 में काम कर रहा हूं, अभी मैं fabric3 (कपड़े की पोर्टिंग 1.x) का उपयोग कर रहा हूं।

मैं फैब्रिक 2 में माइग्रेशन की कोशिश करने के लिए ललचा गया था, लेकिन मैंने तुरंत एक शो स्टॉपर मारा। मैं fabric.contrib फ़ंक्शंस का व्यापक उपयोग करता हूं, लेकिन माइग्रेशन दस्तावेज़ का कहना है कि यह अब मौजूद नहीं है।

निश्चित रूप से मैं कोड को उनके शेल समकक्ष पर वापस नहीं लाना चाहता, और चूंकि, contrib.* कपड़े 1.x पर मुद्दों की संख्या को देखते हुए, ऐसा लगता है कि इसका बहुत उपयोग किया जाता है, मुझे लगता है कि इसका कमी कई अन्य लोगों के प्रवास के लिए एक गंभीर बाधा हो सकती है।
मुझे पैचवर्क प्रोजेक्ट मिला जिसमें स्पष्ट रूप से fabric.contrib के बराबर है, लेकिन इसका कोड वर्षों से अपडेट नहीं किया गया है।
क्या आपके पास fabric.contrib को फैब्रिक 2 में पोर्ट करने की कोई योजना है?

धन्यवाद,
गैब्रिएल

@ garu57 हां, अभी योजना patchwork को मूल रूप से "2.0 के योगदान" के रूप में उपयोग करने की है। फिलहाल यह फैब्रिक 1 आधारित है लेकिन फैब्रिक 2.0.0 के बाहर आने के बाद यह बदल जाएगा। मुझे उम्मीद है कि सबसे अधिक इस्तेमाल किए जाने वाले कंट्रीब बिट्स को जल्दी से पोर्ट किया जाएगा।

हेलो सब लोग,

कभी-कभी मेरा प्रोग्राम रिमोट कमांड चलाता है जैसे

source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./00-update-kernel.sh'

मैं देखता हूं कि स्क्रिप्ट इस तरह निष्पादित की जाती हैं:

033[0;32m[DONE]\033[0m'
+ return 0
+ alt_test_done_msg 'Prepare evironment'
+ echo -e '* Prepare evironment    \033[0;32m[DONE]\033[0m'
+ exit 0

और मुझे अपना डिबग आउटपुट भी देखना चाहिए "?" मेरे कोड के अनुसार:

class GenericFabric(object):
    def __init__(self, host, user, key_filename=None, port=22):
        connection_string = "{u}@{h}:{p}".format(u=user, h=host, p=port)
        self.connection = Connection(connection_string)
        self.key_filename = key_filename

    #<strong i="13">@with_settings</strong>
    def generic_cmd(self, command_str, timeout, fabric_timeout, **kwargs):
        """
        Creating remote container from template

        <strong i="14">@type</strong> command_str:     str
        <strong i="15">@param</strong> command_str:    command for execute with VM
        <strong i="16">@type</strong> timeout          int or float
        <strong i="17">@param</strong> timeout         number of seconds for pause
        <strong i="18">@type</strong> fabric_timeout   int or float
        <strong i="19">@param</strong> fabric_timeout  number of seconds for timeout fabric run

        <strong i="20">@rtype</strong>:                FabricResponse
        <strong i="21">@return</strong>:               Return remote status of operation VM
        """
        if fabric_timeout > 0:
            command = self.connection.run(command_str.format(**kwargs),
                                          timeout=fabric_timeout,
                                          warn=True, echo=True)
        else:
            command = self.connection.run(command_str.format(**kwargs),
                                          warn=True, echo=True)
        print("?")
        if timeout > 0:
            sleep(timeout)
        return FabricResponse(command)

    def simple_generic_cmd(self, command_str, **kwargs):
        """
        <strong i="22">@type</strong> command_str:     str
        <strong i="23">@param</strong> command_str:    command for execute with VM

        <strong i="24">@rtype</strong>:                FabricResponse
        <strong i="25">@return</strong>:               Return remote status of operation VM
        """
        return self.generic_cmd(command_str, 0.1, 0, **kwargs)

लेकिन कोई "?" नहीं हैं। तो मेरा सुझाव है कि रन () में लटक रहे थे।

दरअसल, मेरा प्रोग्राम बहुत बड़ा है और इसमें मल्टी-प्रोसेस प्रोग्रामिंग है। फांसी पकड़ने के लिए मैं निम्नलिखित कोड के साथ रिमोट कमांड निष्पादित कर रहा हूं:

class TestingSystemVM(GenericFabric):
#######
    <strong i="7">@signal_alarm_down</strong>
    def run_rpm_test(self, command_test, package, type_of_test="base"):
        """

        """
        signal.signal(signal.SIGALRM, alarm_handler)
        signal.alarm(self.__timeout)
        returned_value = Queue()
        start_time = datetime.utcnow()
        directory, command_test = os.path.split(command_test)
        try:
            if command_test.endswith(".yml"):
                directory = directory.replace("/opt/QA", self.ansible.git_qa_repo)
                output = self.ansible.play_ansible(command_test,
                                                   package,
                                                   directory)
            else:
                vm_instance = (self.host,
                               self.user,
                               self.key_filename,
                               self.os_name,
                               self.platform,
                               self.arch)
                running_test = Process(target=separate_process_running_test,
                                       args=(vm_instance,
                                             returned_value,
                                             directory,
                                             command_test,
                                             package,
                                             type_of_test))
                running_test.start()
                running_test.join(self.__timeout)
                if running_test.is_alive():
                    running_test.terminate()
                    command_test_res = "FAIL: Timeout\n"
                    return command_test_res, work_time(start_time), 1
                elif returned_value.empty():
                    command_test_res = "FAIL: Problem while getting result\n"
                    return command_test_res, work_time(start_time), 1
                else:
                    output = returned_value.get()
        except TimeOut:
            command_test_res = "FAIL: Timeout\n"
            return command_test_res, work_time(start_time), 1
        if output.failed or (package.name in ("lve-utils", "lve-stats") and
                                     "FAIL" in output.stdout):
            res_output = "FAIL: " + output.stdout
        else:
            res_output = output.stdout
        return res_output, work_time(start_time), 0 if output.succeeded else 1

def separate_process_running_test(vm_instance, return_value_queue,
                                  directory, command_test, package,
                                  type_of_test="base"):
    """

    """
    sleep(0.5)

    signal.signal(signal.SIGTERM, kill_fabric_runner)
    signal.signal(signal.SIGINT, kill_fabric_runner)
    (host,
     user,
     key_filename,
     os_name,
     platform,
     arch) = vm_instance
    child_vm_instance = TestingSystemVM(host,
                                        user,
                                        key_filename,
                                        os_name,
                                        platform,
                                        arch,
                                        FakeAnsible())
    if command_test.endswith(".bats"):
        command_test = "/usr/bin/bats --tap " + command_test
    else:
        command_test = os.path.join("./", command_test)

    output = child_vm_instance.simple_generic_cmd(child_vm_instance._c_run_test,
                                                  envvars=child_vm_instance.env_vars,
                                                  exec_test=command_test,
                                                  dir=directory,
                                                  package=package.name,
                                                  pver=package.version,
                                                  prel=package.release,
                                                  type_test=type_of_test)
    print("!")
    return_value_queue.put(output)

जब मैं फ़ैब्रिक 2 का उपयोग करता हूं, तो समय-समय पर बाल प्रक्रियाओं से लॉन्च किए गए कुछ आदेश लटक रहे हैं।
अद्यतन दरअसल, कोड में यह मेरी गलती थी। इसलिए, फ़ैब्रिक2 में हैंगिंग शामिल नहीं है

सभी को नमस्कार,
मैंने कुछ लॉन्च प्रयोग किए और अपना अनुभव साझा कर सकता हूं।

सबसे पहले, मैंने अपने कंसोल से कमांड चलाया

ssh [email protected] -t "source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'"

और वह पूरी तरह से और तेजी से बाहर निकलने के साथ समाप्त हुआ = 0:

###
+ echo -e '* Prepare evironment    \033[0;32m[DONE]\033[0m'
* Prepare evironment    [DONE]
+ exit 0
Connection to 192.168.0.34 closed.

अच्छा।
तब मैंने एक और आदेश निष्पादित किया:

ssh [email protected] "source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'"

वह इतनी तेजी से बाहर निकलें = 0 के साथ भी समाप्त हो गया था:

###
+ echo -e '* Prepare evironment    \033[0;32m[DONE]\033[0m'
+ exit 0

लेकिन "192.168.0.36 से कनेक्शन बंद" नहीं है। मुझे नहीं पता कि यह महत्वपूर्ण है या नहीं।

उसके बाद मैंने VMs को फिर से बनाया और फैब्रिक 2 (IPython से) द्वारा कमांड लॉन्च किया:

In [1]: from fabric import Connection
In [2]: Connection('[email protected]').run("source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'", pty=True)
....
+ echo -e '* Prepare evironment    \033[0;32m[DONE]\033[0m'
* Prepare evironment    [DONE]
+ exit 0
Out[2]: <Result cmd="source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'" exited=0>

इसके अलावा, मैं पीटी = गलत के साथ भागा:

In [1]: from fabric import Connection

In [2]: Connection('[email protected]').run("source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'", pty=False)
+ echo -e '* Prepare evironment    \033[0;32m[DONE]\033[0m'
+ exit 0
Out[2]: <Result cmd="source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'" exited=0>

"से कनेक्शन" नहीं थाबंद।" दोनों परीक्षणों पर। फिर से मुझे नहीं पता कि यह महत्वपूर्ण है या नहीं।

दूसरे, मैंने फैसला किया कि यह मेरे स्टैंड के लिए अच्छा माहौल नहीं है, क्योंकि मुझे चाइल्ड प्रोसेस से लॉन्च की जरूरत है। इसलिए, मैंने VMs को फिर से बनाया और स्क्रिप्ट को अगले कोड के साथ चलाया:

In [1]: import subprocess

In [2]: t = subprocess.Popen(""" ssh [email protected] -t "source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'" """, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True); r = t.communicate()

इस रनिंग के आउटपुट में "कनेक्शन टू 192.168.0.34 क्लोज्ड" था।

दूसरी ओर

In [1]: import subprocess

In [2]: t = subprocess.Popen(""" ssh [email protected] "source /opt/centos/vars && su - -c 'cd /opt/QA/rpm_tests/p_lvemanager && ALT_TEST=base ALT_PACKAGE_NAME=lvemanager ALT_PACKAGE_VERSION=3.0 ALT_PACKAGE_RELEASE=11.el6.cloudlinux.21100.1.1505113712 ./01-prepare-environment.sh'" """, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True); r = t.communicate()

दोनों को फांसी नहीं हुई है।

आज रात मैं अपनी स्क्रिप्ट को फ़ैब्रिक 2 के साथ उस प्रक्रिया पर लॉन्च करूँगा जिसे फोर्क किया गया था और मैं लिखूंगा।
अद्यतन दरअसल, कोड में यह मेरी गलती थी। तो, फैब्रिक 2 में हैंगिंग नहीं है।

use_sudo के लिए Transfer.put का समर्थन प्राप्त करना अच्छा होगा।

मुझे लगता है कि अभी के लिए सबसे आसान समाधान सिर्फ put करना है कहीं मेरे पास अनुमतियां हैं तो sudo mv ?

@ ned2 वैसे भी use_sudo वास्तव में get / put में वास्तव में कर सकता है, उदाहरण के लिए यह कैसे v1 करता है। जहां तक ​​​​मुझे पता है, "सुडो के साथ" फ़ाइल अपलोड करना वास्तव में संभव नहीं है! (रूट के रूप में कनेक्ट किए बिना नहीं, जो एक बुरा विचार है और आदर्श रूप से इसकी अनुमति भी नहीं है।)

v2 में कुछ हद तक क्लीनर एपीआई रखने के प्रयास को देखते हुए, मुझे उस व्यवहार को get / put के अंदर बंडल करने के बजाय एक रैपर लागू करने की लगभग अधिक संभावना है। शायद कुछ ऐसा ही Transfer.sudo_put (जिसे self.put कहा जाएगा)। इस तरह "शुद्ध" put को न्यूनतम रखा जाता है।

@bitprophet मैं आपको कुछ सुंदर स्थिर और उपयोगी सॉफ़्टवेयर के लिए फ़ैब्रिक1 और फ़ैब्रिक 2 रिलीज़ करने के आपके दृष्टिकोण के लिए धन्यवाद देकर शुरुआत करना चाहता हूँ।

मैंने v2 के साथ खेलना शुरू कर दिया है, लेकिन मैंने कनेक्शन के साथ एक समस्या का सामना किया है। मैं फैब्रिक 1 से अपने एसएसएच कॉन्फ़िगरेशन का उपयोग कर रहा हूं, फैब्रिक 1 कनेक्ट करने का प्रयास करते समय मुझे पासवर्ड के लिए संकेत देगा। फैब्रिक 2 ऐसा नहीं कर रहा है और यह कहते हुए विफल हो जाता है कि प्रमाणीकरण विफल हो गया है। मैं v2 दस्तावेज़ों में कहीं भी नहीं देख सकता जो कनेक्शन के लिए प्रमाणीकरण तंत्र का उल्लेख करता है। सुडो के साथ पासवर्ड का उल्लेख है लेकिन कनेक्शन के सफल होने के बाद भी मैं इसे इकट्ठा कर सकता हूं ..

मेरा प्रश्न यह है कि क्या मैंने दस्तावेज़ों में कुछ याद किया है या यह एक अनुपलब्ध विशेषता है या कोई समस्या है।

कोड:

<strong i="10">@task</strong>
def testing(c):
    with Connection('MyHostname') as cxn:
        print("Connected")

        cxn.run('ls -l')

त्रुटि:

  File /lib/python3.4/site-packages/paramiko/auth_handler.py", line 223, in wait_for_response
    raise e 
paramiko.ssh_exception.AuthenticationException: Authentication failed.

मेरा SSH कॉन्फिग (यहां पोस्ट करने के लिए बदले गए मान):

Host MyHostname
  HostName replacedhostname.co.uk
  Port 22
  IdentityFile ~/.ssh/id_rsa
  User replaceduser

मैं नवीनतम v2 संस्करण पर हूँ: https://github.com/fabric/fabric/commit/fec3a22ee89900500ae731913fd33f9b56e89f46

उम्मीद है कि इसे हल करने से किसी और को भी इसी मुद्दे से मदद मिलेगी।

आपके समय के लिए शुक्रिया।

@ Aiky30 यह शायद आप नहीं हैं, लेख सामग्री को अभी भी काम करने की ज़रूरत है (बड़े हिस्से में कुछ प्रगति पैरामीको काम की आवश्यकता के कारण, इसलिए अपवादों को सही ढंग से व्याख्या करना बहुत कठिन नहीं है।) मुझे लगता है कि इस मामले में यह बस फैब हो सकता है 2 IdentityFile की व्याख्या नहीं कर रहा है - हम होस्ट, उपयोगकर्ता, पोर्ट और अन्य सेटिंग्स का एक समूह हड़प लेते हैं लेकिन IdentityFile अभी भी एक TODO है।

यह आंशिक रूप से है क्योंकि हम अभी भी पासफ़्रेज़ से निपटते नहीं हैं (ऊपर देखें - एक बड़े फैब्रिक 1 क्लज से बचना चाहते हैं, जहां हमें जंगली अनुमान लगाना होगा यदि किसी दिए गए ऑथ फेल का मतलब पासवर्ड या पासफ़्रेज़ की आवश्यकता है)। तो आप शायद उसके बाद "मैं इस फ़ाइल को अनलॉक नहीं कर सकता" त्रुटि के लिए संक्रमण करेगा। और वे दोनों इसलिए हैं क्योंकि मैं ज्यादातर समय एक ssh- एजेंट का उपयोग करता हूं - जो कि तत्काल समाधान के लिए मेरा पहला सुझाव होगा।

उस ने कहा, मुझे लगता है कि यह शायद मेरे लिए IdentityFile और स्पष्ट पासफ़्रेज़ कॉन्फ़िगरेशन समर्थन दोनों में हैकिंग के लायक है, क्योंकि गैर-एजेंट कुंजियाँ संभवतः नंबर 1 सबसे आम ऑथ सेटअप हैं, इसलिए इसकी कमी का मतलब है कि अधिकांश अल्फा/बीटा उपयोगकर्ता लर्च में छोड़ दिए गए हैं . देखेंगे कि क्या मैं आज इसे धमाका कर सकता हूं।

एक स्पिन के लिए 2.0a लिया।

1) मैं मेजबानों को वास्तव में परिभाषित और उपयोग करने के तरीके पर भी थोड़ा सा खो गया हूं। मैं चल सकता हुँ:

   fab -H user<strong i="7">@host</strong>:22 some-task

लेकिन अगर मैं हर बार होस्ट विवरण (उपयोगकर्ता, होस्ट, पोर्ट) में पास नहीं करना चाहता, तो मुझे यकीन नहीं है कि होस्ट को fabfile.py ( Connection s या Group में कैसे कॉन्फ़िगर किया जाए) https://github.com/fabric/fabric/issues/1591#issuecomment -296343613 सही ढंग से समझ गया, तो यह अभी समर्थित नहीं है (और https://github.com/fabric/fabric/issues/1594 में ट्रैक किया गया है) )?

2) साथ ही, मैंने उस मुद्दे को मारा जहां मैंने एसएसएच कुंजी एन्क्रिप्ट की है ( ~/.ssh/id_rsa पर) और मेरे पास ssh-add 'd वह ssh-agent है। यह दिखाता है कि क्या मैं ssh-add -l के माध्यम से चाबियों को सूचीबद्ध करता हूं। जब मैं कुछ कार्य चलाता हूं, उचित उपयोगकर्ता नाम देता हूं:

   fab -H musttu<strong i="20">@host</strong> sometask

चीजें ठीक काम करती हैं। लेकिन अगर मैं गलत उपयोगकर्ता का उपयोग करता हूं, उदाहरण के लिए fab -H bad_user<strong i="23">@host</strong> sometask , तो मुझे मिलता है:

Traceback (most recent call last): ... File "/home/maximus/.virtualenvs/testenv/lib/python3.6/site-packages/paramiko/pkey.py", line 326, in _read_private_key raise PasswordRequiredException('Private key file is encrypted') paramiko.ssh_exception.PasswordRequiredException: Private key file is encrypted

लेकिन मुझे लगता है कि https://github.com/paramiko/paramiko/issues/387 के अंतर्गत आता है और वास्तव में कपड़े 2.0 के लिए विशिष्ट नहीं है। लेकिन हाँ, PasswordRequiredException: Private key file is encrypted त्रुटि प्राप्त करना अजीब लगता है, जब ssh- एजेंट के पास पहले से ही डिक्रिप्ट की गई कुंजी होती है। अगर मैं सही ढंग से समझ गया, तो अमान्य लॉगिन के बाद, paramiko सीधे कुंजी का उपयोग करने के लिए वापस आ जाएगा, और बिना पासफ़्रेज़ के इस त्रुटि को फेंक देगा।

3) टाइप एनोटेटिंग टास्क फ़ंक्शंस (आईडीई में बेहतर ऑटो-पूर्णता के लिए) की अनुमति देना अच्छा होगा। क्या आपके पास https://github.com/pyinvoke/invoke/pull/458 पर विचार करने का समय है?

4) मुझे पैचवर्क लाइब्रेरी का विचार पसंद है। कपड़े 1.x के लिए, https://github.com/sebastien/cuisine (जो बहुत मृत लगता है) है जिसमें बहुत सारे अतिरिक्त कार्य हैं (इसे स्वयं उपयोग नहीं किया है)। क्या पैचवर्क के साथ कुछ समान बनाने का विचार है (इसलिए शेफ/अन्सिबल/साल्टस्टैक-शैली घोषणात्मक कार्य, हालांकि कम दायरे के साथ)? मैं हमेशा बहु-डीआईआर/मल्टी-फाइल वाईएएमएल/डीएसएल दृष्टिकोण से नफरत करता हूं जो अन्य टूल्स का पालन करते हैं, और अधिक लचीलापन, कम वर्बोज़ सिंटैक्स, आईडीई ऑटो-पूर्णता, आसान डिबगिंग इत्यादि प्राप्त करने के लिए, पाइथन में रहना पसंद करेंगे।

5) फैब्रिक 2.0 के लिए बस py 2.6 और 3.2-3.3 सपोर्ट ड्रॉप करें। क्या लोगों को आगे नहीं बढ़ना चाहिए?

@tuukkamustonen - प्रतिक्रिया के लिए धन्यवाद! प्रतिक्रियाएं:

1. भूमिकाएं वास्तव में #1594 के अंतर्गत आती हैं - और मुझे लगता है कि प्रति-होस्ट कॉन्फ़िगरेशन डेटा होने के संबंधित मुद्दे के लिए वहां एक और टिकट है, इसके अलावा ssh_config समर्थन अपने स्तर पर ऐसा कैसे करता है।

   फ़ैब्रिक-स्तरीय कॉन्फ़िगरेशन को ssh_config के साथ और फिर समूह या रनटाइम डेटा से किसी भी चीज़ के साथ कैसे मेल करना है, यह तय करना मामूली नहीं है। हालांकि यह निश्चित रूप से जल्द ही होने की जरूरत है; मैं पहले मसौदे के बजाय सिर्फ आधा सोचा समाधान चाहता हूं।

2. फिर से, हाँ, यह पैरामिको टिकट है जिसका आपने उल्लेख किया है, और आपका अनुमान सटीक है, खराब-उपयोगकर्ता नाम की स्थिति हमेशा विफल हो जाएगी, और चूंकि पैरामीको केवल उस अंतिम त्रुटि को ट्रैक करता है जो उसे मिली थी, ऐसा होता है कि आखिरी चीज जो उसने कोशिश की थी ऑन-डिस्क, कुंजी की एन्क्रिप्टेड कॉपी। (यदि आप उस कुंजी को कहीं और स्थानांतरित करते हैं, उदाहरण के लिए, अंतिम त्रुटि कुछ और होगी।)

3. मैंने अभी उस टिकट पर टिप्पणी की है, यह एक ही समग्र सुविधा के लिए मौजूदा टिकटों को डुप्लिकेट कर सकता है (या नहीं)। मैंने उन पुराने लोगों पर टिप्पणी की है और आईआईआरसी यह "हाँ, मुझे लगता है कि यह अच्छा होगा जब तक कि यह पायथन 2 को खराब नहीं करता।" हालाँकि यह उतनी उच्च प्राथमिकता नहीं है जितनी कि अधिकांश बड़ी अनुपलब्ध सुविधाएँ हैं, इसलिए यह "एक महान की आवश्यकता है, सभी बक्से पीआर की जाँच करते हैं कि मैं बस-विलय कर सकता हूँ" बाल्टी :)

4. हाँ, देखिए #461 जो बहुत पुराना है लेकिन अभी भी मेरे दिमाग में है। इन दिनों बड़ा सवाल यह है कि इनवोक और फैब्रिक दोनों को फैलाने के लिए इस तरह के एक लिब को कैसे लिखा जाएगा; कई/अधिकांश मामलों में कोई भी सामान्य इनवोक कार्यों को लिख सकता है जो किसी भी विभाजित स्थानीय/दूरस्थ संदर्भों के बारे में "जानते" नहीं हैं, जिन्हें एक रिमोट सिस्टम के खिलाफ चलाने के लिए फैब्रिक कनेक्शन संदर्भ दिया जा सकता है।

   ऐसे "संदर्भ अज्ञेयवादी" कार्य 'आमंत्रण' पुस्तकालय (या कुछ अन्य अभी भी आह्वान-विशिष्ट lib) में रहना चाहेंगे; लेकिन कुछ (उदाहरण के लिए फ़ाइल स्थानांतरण और केवल शेल कमांड से जुड़ी कोई भी चीज़) को "फ़ैब्रिक-अवेयर" होने की आवश्यकता होगी। यह पता लगाना कि उस अंतर को कैसे पाटना है, समस्या है।

   मार्ग जा सकता है "कि lib को केवल आह्वान की आवश्यकता है, कपड़े की कठोर आवश्यकता नहीं है, _but_ कार्यों का एक सबसेट शिकायत करेगा यदि आप कपड़े स्थापित नहीं करते हैं और उन्हें एक कनेक्शन संदर्भ सौंपते हैं।" दो libs में विभाजित हो सकता है (फैब्रिक-उन्मुख एक के साथ अधिक सामान्य Invoke एक की आवश्यकता होती है।) आदि।

5. हाल ही में, यह निश्चित रूप से कार्ड में है, paramiko/paramiko#1070 और/या pyinvoke/invoke#364 देखें। इनवोक 1.0, फैब्रिक 2.0 और पैरामिको 3.0 (या, _maybe_, 2.4/2.5/जो भी हो) सभी Python 2.7 / 3.4 और बाद के संस्करण होंगे।

के बारे में (1):

मुझे यकीन है कि आप इसे पहले से ही जानते हैं, लेकिन हो सकता है कि आप Ansible की सूची से कुछ विचार प्राप्त करना चाहें। या शायद नहीं :)।

के बारे में (4):

मुझे लगता है कि https://github.com/pyinvoke/invocations इसके लिए विचार करने का तरीका है। इनवोकेशन _conventions_ प्रदान करता है और पैचवर्क/व्यंजन-शैली पैकेज के शीर्ष पर बना सकता है, लेकिन मैं उपयोगिताओं (फ़ाइल की प्रतिलिपि बनाने या अनुमतियों को बदलने के तरीके) के साथ सम्मेलनों (कैसे जारी या सबसे अच्छा) मिश्रण नहीं करता।

मुझे एक ही पुस्तकालय (पैचवर्क) में स्थानीय-केवल, दूरस्थ-केवल और स्थानीय + दूरस्थ संचालन के लिए बर्तन डालने में समस्या नहीं दिखती है। कौन सा ऑपरेशन समर्थन करता है कि किस मोड को दस्तावेज़ीकरण के रूप में निपटाया जा सकता है (जैसे डॉकस्ट्रिंग, एनोटेशन से स्वत: उत्पन्न, आदि)।

यह तर्क को 2+ पैकेज में विभाजित करने से बेहतर लगता है। क्योंकि क्या होगा यदि आप पहले अपने "केवल-आमंत्रण" पैकेज में एक ऑपरेशन जोड़ते हैं (और यहां तक ​​​​कि "रिमोट-ओनली" ऑपरेशन भी हो सकते हैं), और फिर बाद में इसके लिए रिमोट सर्वर पर भी काम करने के लिए समर्थन जोड़ते हैं? क्या आप कोड को स्थानांतरित, कॉपी या विस्तारित करेंगे? किसी भी मामले में, यह अधिक काम है, और उपयोगकर्ता को अलग-अलग आयात आदि की आवश्यकता होती है, इसलिए यह थोड़ा बोझिल लगता है।

PyPi पर जाने के लिए इसे पर्याप्त पॉलिश करने के लिए मैं क्या कर सकता हूं?

@haydenflinner यह अगले एक या दो सप्ताह में हो रहा है !! (मेरा लक्ष्य पाइकॉन के लिए अपने विमान पर चढ़ने से पहले रिलीज करना है, जो कि 10 मई है।)

उदाहरण के लिए, कृपया हाल ही में अपडेट किए गए अपग्रेड डॉक्स देखें जिन पर मैं अभी इस सप्ताह काम कर रहा था: http://docs.fabfile.org/en/v2/upgrading.html

वास्तव में, मैं अब इस टिकट को बंद भी कर सकता हूं, क्योंकि मैं 2.0.0 और उससे अधिक के लिए वास्तविक वास्तविक टिकट जल्द ही स्वीकार करूंगा

ध्यान दें, यदि आप चाहें तो आप अभी भी यहां टिप्पणी कर सकते हैं। ध्यान दें कि मैं उम्मीद कर रहा हूं कि रिलीज से पहले कम से कम फीचर काम के कुछ हिस्सों को पूरा करने के लिए, सभी परियोजना प्रबंधन तैयारी के साथ।

मैंने आज फैब्रिक v2 को देखा और मुझे खेद है, मैं इसे इस्तेमाल करने के लिए खुद को नहीं ला सकता।

1. रोलडेफ्स कहां गए? मैं अब कमांड लाइन पर भूमिका का नाम क्यों नहीं दे सकता? क्या मुझे इसे स्वयं लागू करना चाहिए?
2. मैं अब कमांड लाइन पर कार्यों के लिए तर्क क्यों नहीं दे सकता? क्या मुझे इसे स्वयं भी लागू करना चाहिए?
3. -H पैरामीटर को टास्क पैरामीटर से पहले क्यों आना पड़ता है? होना तो इसका उलटा चाहिए। यह बहुत भयानक है।

कार्य तर्क लेते हैं, लेकिन वाक्यविन्यास बदल गया है। देखें http://docs.pyinvoke.org/en/1.1/concepts/invoking-tasks.html#task -command-line-arguments

@dgarstang आप उन लोगों के साथ अधिक तटस्थ या सहानुभूतिपूर्ण स्वर लेने पर विचार कर सकते हैं जो आपको अपना निःशुल्क श्रम देते हैं! बस कह रहा हूँ

1. #1594 देखें, जो IIRC अपग्रेडिंग दस्तावेज़ में जुड़ा हुआ है
2. @ploxiln को आपकी पीठ यहाँ मिल गई
3. (आंशिक रूप से) #1772 देखें जो मास्टर में विलय हो गया है और जल्द ही बाहर हो जाएगा; यह @task(hosts=xxx) का उपयोग करने की क्षमता जोड़ता है।

(पुनः 3: --hosts और दोस्तों को देने के संदर्भ में जैसे कि वे प्रति-कार्य तर्क थे, यह कुछ ऐसा है जिसे मैं कभी-कभी जोड़ सकता हूं, इस पर फाड़ा गया है कि क्या यह इसके लायक है। प्रति-कार्य --help के समान