DB2 IMPORT 详解

IMPORT 实用程序概述

IMPORT 实用程序用一个输入文件将数据填充到一个表中,输入文件的文件类型可以是 ASC、DEL、IXF 或 WSF。目标是一个表、一个类型化表(typed table)或者一个视图。但是,不能导入到系统表、临时表和物化查询表。建议使用 MESSAGES 子句,以便记录错误、警告和包含有用信息的消息。

要想成功地导入数据,必须拥有 SYSADM 或 DBADM 权限,或者目标表或数据库上的底层特权(SELECT、INSERT、CONTROL 或 CREATETAB),这取决于使用什么选项。为了将数据导入到一个包含受保护的行和列的表中,必须拥有允许对表中所有受保护数据进行写访问的 LBAC 凭证。此外,将数据导入包含受保护行的表时,要求您的 LBAC 凭证是保护表的安全策略的一部分。

下面显示的 IMPORT 命令具有五个不同的选项:

[codesyntax lang=”sql”]

IMPORT FROM file_name OF file_type
   MESSAGES message_file
   [ INSERT | INSERT_UPDATE | REPLACE | REPLACE_CREATE | CREATE ]
   INTO target_table_name
   

[/codesyntax]

INSERT 选项将导入的数据插入表中。目标表必须已经存在。 INSERT_UPDATE 将数据插入表中,或者更新表中具有匹配主键的行。目标表必须已经存在,并且定义了一个主键。 REPLACE 选项删除所有已有的数据,并将导入的数据插入到一个已有的目标表中。 使用 REPLACE_CREATE 选项时,如果目标表已经存在,则导入实用程序删除已有的数据,并插入新的数据,就像 REPLACE 选项那样。如果目标表还没有定义,那么首先创建这个表以及它的相关索引,然后再导入数据。正如您可能想像的那样,输入文件必须是 PC/IXF 格式的文件,因为那种格式包含对导出表的结构化描述。如果目标表是被一个外键引用的一个父表,那么就不能使用 REPLACE_CREATE。 CREATE 选项首先创建目标表和它的索引,然后将数据导入到新表中。该选项惟一支持的文件格式是 PC/IXF。还可以指定新表所在表空间的名称。 例子:

[codesyntax lang=”sql”]

IMPORT FROM emp.ixf OF IXF
   MESSAGES msg.out
   CREATE INTO employee IN datatbsp INDEX IN indtbsp

[/codesyntax]

IMPORT 选项

IMPORT 基本上是用于成批插入数据的一个实用程序。这种成批插入操作就像一般的插入语句一样,也涉及到活动的日志记录、索引的更新、参照完整性检查和表约束检查。默认情况下,IMPORT 只在操作结束时提交一次。如果将大量的行一次性导入或插入到表中,那么需要有足够的事务记录用于回滚和恢复。此外也可以采用周期性的提交,以防日志写满。通过定期地提交插入,还可以减少导入操作期间出现失败时丢失的行数。COMMITCOUNT 选项规定在导入一组记录后强制执行 COMMIT。还可以指定 AUTOMATIC 选项,该选项允许导入实用程序在内部决定何时需要执行提交。该实用程序将考虑发出一个提交命令,以避免日志写满或者避免锁升级。下面是关于如何使用 COMMITCOUNT 选项的一个例子:

[codesyntax lang=”sql”]

IMPORT FROM myfile.ixf OF IXF
   COMMITCOUNT 500
   MESSAGES msg.out
   INSERT INTO newtable
   

[/codesyntax]

如果由于某种原因导致以上命令在执行期间遭到失败,那么可以使用消息文件来确定成功导入且已提交的最后一行。然后,可以使用 RESTARTCOUNT 选项重新开始导入。注意,SKIPCOUNT 选项的行为与 RESTARTCOUNT 是相同的。在下面的命令中,该实用程序在开始 IMPORT 操作之前,将忽略前 30,000 条记录。

[codesyntax lang=”sql”]

IMPORT FROM myfile.ixf OF IXF
   COMMITCOUNT 500 RESTARTCOUNT 30000 ROWCOUNT 100000
   MESSAGES msg.out
   INSERT INTO newtable

[/codesyntax]

注意,这个例子中还使用了 ROWCOUNT 选项。该选项指定要导入的物理记录的条数。由于使用了 RESTARTCOUNT 选项,导入实用程序将忽略前 30,000 条记录,并且将剩下的 100,000 条记录导入到表中。

默认情况下,在插入任何行之前,导入实用程序将获得目标表上的一个排它锁。一旦导入完成,这个排它锁将被释放。这是 ALLOW NO ACCESS 选项的行为。为了允许并发应用程序访问表数据,可以使用 ALLOW WRITE ACCESS 选项。注意,该选项与 REPLACE、CREATE 或 REPLACE_CREATE 导入选项不兼容。下面是关于 ALLOW WRITE ACCESS 选项的一个例子。

[codesyntax lang=”sql”]

IMPORT FROM myfile.ixf OF IXF
   ALLOW WRITE ACCESS
   MESSAGES msg.out
   INSERT INTO newtable

[/codesyntax]

导入 XML 数据

为了导入 XML 文件,可以使用 XML FROM 选项指定 XML 文件所在的一个或多个路径。否则,导入实用程序将在当前目录中查找 XML 文件。您可以选择如何解析 XML 文档;是去掉空白还是保留空白。如果没有指定 XMLPARSE 选项,那么将根据 CURRENT XMLPARSE OPTION 专用寄存器来决定对 XML 文档的解析行为。下面是关于 XML FROM 和 XMLPARSE 选项的一个例子。

[codesyntax lang=”sql”]

IMPORT FROM myfile.ixf OF IXF
   XML FROM d:\xmlpath
   XMLPARSE PRESERVE WHITESPACE
   MESSAGES msg.out
   INSERT INTO newtable
   

[/codesyntax]

当插入或更新一个 XML 文档时,您可能想确定 XML 文档的结构、内容和数据类型是否有效。导入实用程序还通过 XMLVALIDATE 选项提供了对 XML 验证的支持。下面是可用的三种方法。

USING XDS — 回想一下,您可以导出 XML 模式信息并将它存储在 XML Data Specifier (XDS) 的 SCH 属性中。SCH 属性的值将用于执行验证。如果在 XDS 中没有 SCH 属性,则考虑 DEFAULT、IGNORE 或 MAP 三者之中的一个值。 USING SCHEMA schema-sqlid — 使用这个子句中指定的 XML 模式。 USING SCHEMALOCATION HINTS — 根据源 XML 文档中 XML 模式位置提示所标识的模式来验证 XML 文档。

[codesyntax lang=”sql”]

IMPORT FROM myfile.ixf OF IXF
   XML FROM d:\xmlpath
   XMLPARSE PRESERVE WHITESPACE
   XMLVALIDATE USING XDS
   DEFAULT S1.SCHEMA_A
   IGNORE (S1.SCHEMA_X, S1.SCHEMA_Y, S1.SCHEMA_Z)
   MAP (S1.SCHEMA_A, S1.SCHEMA_B)
   COMMITCOUNT 500 RESTARTCOUNT 30000
   MESSAGES msg.out
   INSERT INTO newtable
   

[/codesyntax]

前面的 IMPORT 命令将:

插入 myfile.ixf 和 d:\xmlpath 下的 XML 文件中的数据。 当解析 XML 文档时,保留空白。 使用 XDS 的 SCH 属性标识的模式信息对每个 XML 文档进行验证。但是,如果用于任何特定行的 XDS 没有包含 SCH 属性,那么使用 S1.SCHEMA_A。 如果 SCH 属性被指定为 S1.SCHEMA_X 或 S1.SCHEMA_Y 或 S1.SCHEMA_Z,那么对于导入的 XML 文档不执行验证。 如果 SCH 属性被指定为 S1.SCHEMA_A,它将被映射到 S1.SCHEMA_B。注意,尽管 DEFAULT 子句指定了 S1.SCHEMA_A,但是后面的任何映射都将不会执行。 每导入 500 行之后,导入实用程序将发出一次提交命令。 导入操作从第 30,001 条记录开始。前 30,000 条记录被忽略。 任何错误、警告和包含信息的消息都写到 msg.out 文件中。 将新数据插入(或附加)到 newtable 中。 这个例子只是让您对如何验证导入的 XML 文档有一些认识。DB2 Information Center 中还有更多的例子来演示 XMLVALIDATE 选项的威力。

文件类型修饰符

IMPORT 实用程序还支持五种文件类型修饰符来定制导入操作。在 DB2 Command Reference 的 IMPORT 小节下有这些修饰符的一个完整的列表。下面列出了其中一些修饰符:

compound=x 使用非原子复合 SQL 插入数据。x 是每次将尝试的语句数量。 indexschema=schema 使用索引创建期间指定的用于索引的模式。 striptblanks 将数据装载到可变长度字段时,截去结尾空白。 lobsinfile 表明将导入 LOB 数据。导入实用程序将检查 LOBS FROM 子句,以获得输入 LOB 文件的路径。

下面是使用这些文件类型修饰符的一个例子:

[codesyntax lang=”sql”]

IMPORT FOR inputfile.asc OF ASC
   LOBS FROM /u/db2load/lob1, /u/db2load/lob2
   MODIFIED BY compount=5 lobinsfile
   INSERT INTO newtable
   

[/codesyntax]

使用 Control Center 执行导入

Control Center 提供了易于使用的图形界面来执行导入操作。这个界面中还提供了前一屏中讨论的所有导入选项和文件修饰符。

Git rebase 详解

1.出现情况的背景:

当你提交的代码后,管理员发现,您的代码不能提交到服务器上,主要原因在于,你的commit 中和服务器中的有些commit不再同一时间轴上,即:你的有些commit要插入到服务器中的某些commit之间,这样就会造成代码的冲突。所以这个时候就要使用git rebase。

假如,你平时使用的分支叫new ,然后在这个分支上你刚提交过几个commit。

做法:

1.新建一个分支,并且代码和服务器中代码同步

[codesyntax lang=”text”]


git checkout origin/v2.0 -b temp

[/codesyntax]

2.为了保证新建的temp分支代码是最新的,可以多执行下面一步

[codesyntax lang=”text”]


git pull

[/codesyntax]

3.当你新建分支后,系统会自动checkout到temp分支上,此时

[codesyntax lang=”text”]


git checkout new

[/codesyntax]

4.合并代码,并整理

[codesyntax lang=”text”]


git rebase temp //会将temp分支的代码合并过来,并按照提交的顺序排序

[/codesyntax]

5. 因为顺序是重新整理的,所以肯定会出现冲突

6.解决冲突,最后git add * ,但不许要git commit

7.解决后,执行

[codesyntax lang=”text”]


git rebase --continue

[/codesyntax]

8.重新提交代码

[codesyntax lang=”text”]


git push for-*

[/codesyntax]

注意:如果要对某些代码的commit重新整理

1. 可以记住某个commit号

2. git rebase -i commit号

3. 会显示一个整理提交的界面,有很多参数,e。p。等等

4.将前面的参数改为e。则wq保存后,系统会自动让你重新修改commit内容

5.修改完成后,再git push for-*

python urllib2 详解

urllib2是Python的一个获取URLs(Uniform Resource Locators)的组件。他以urlopen函数的形式提供了一个非常简单的接口,
这是具有利用不同协议获取URLs的能力,他同样提供了一个比较复杂的接口来处理一般情况,例如:基础验证,cookies,代理和其他。
它们通过handlers和openers的对象提供。
urllib2支持获取不同格式的URLs(在URL的”:”前定义的字串,例如:”ftp”是”ftp:python.ort/”的前缀),它们利用它们相关网络协议(例如FTP,HTTP)
进行获取。这篇教程关注最广泛的应用–HTTP。
对于简单的应用,urlopen是非常容易使用的。但当你在打开HTTP的URLs时遇到错误或异常,你将需要一些超文本传输协议(HTTP)的理解。
最权威的HTTP文档当然是RFC 2616(http://rfc.net/rfc2616.html)。这是一个技术文档,所以并不易于阅读。这篇HOWTO教程的目的是展现如何使用urllib2,
并提供足够的HTTP细节来帮助你理解。他并不是urllib2的文档说明,而是起一个辅助作用。
获取 URLs
最简单的使用urllib2将如下所示
[codesyntax lang=”python”]

import urllib2 
response = urllib2.urlopen('http://python.org/') 
html = response.read()

[/codesyntax]
urllib2的很多应用就是那么简单(记住,除了”http:”,URL同样可以使用”ftp:”,”file:”等等来替代)。但这篇文章是教授HTTP的更复杂的应用。
HTTP是基于请求和应答机制的–客户端提出请求,服务端提供应答。urllib2用一个Request对象来映射你提出的HTTP请求,在它最简单的使用形式中你将用你要请求的
地址创建一个Request对象,通过调用urlopen并传入Request对象,将返回一个相关请求response对象,这个应答对象如同一个文件对象,所以你可以在Response中调用.read()。
[python]
import urllib2
req = urllib2.Request(‘http://www.voidspace.org.uk’)
response = urllib2.urlopen(req)
the_page = response.read()

[/codesyntax]
记得urllib2使用相同的接口处理所有的URL头。例如你可以像下面那样创建一个ftp请求。
req = urllib2.Request(‘ftp://example.com/’)
在HTTP请求时,允许你做额外的两件事。首先是你能够发送data表单数据,其次你能够传送额外的关于数据或发送本身的信息(“metadata”)到服务器,此数据作为HTTP的”headers”来发送。
接下来让我们看看这些如何发送的吧。
Data数据
有时候你希望发送一些数据到URL(通常URL与CGI[通用网关接口]脚本,或其他WEB应用程序挂接)。在HTTP中,这个经常使用熟知的POST请求发送。这个通常在你提交一个HTML表单时由你的浏览器来做。
并不是所有的POSTs都来源于表单,你能够使用POST提交任意的数据到你自己的程序。一般的HTML表单,data需要编码成标准形式。然后做为data参数传到Request对象。编码工作使用urllib的函数而非
urllib2。
[codesyntax lang=”python”]

import urllib 
import urllib2 
url = 'http://www.someserver.com/cgi-bin/register.cgi' 
values = {'name' : 'Michael Foord', 
          'location' : 'Northampton', 
          'language' : 'Python' } 
data = urllib.urlencode(values) 
req = urllib2.Request(url, data) 
response = urllib2.urlopen(req) 
the_page = response.read()

[/codesyntax]
记住有时需要别的编码(例如从HTML上传文件–看http://www.w3.org/TR/REC-html40/interact/forms.html#h-17.13 HTML Specification, Form Submission的详细说明)。
如ugoni没有传送data参数,urllib2使用GET方式的请求。GET和POST请求的不同之处是POST请求通常有”副作用”,它们会由于某种途径改变系统状态(例如提交成堆垃圾到你的门口)。
尽管HTTP标准说的很清楚POSTs通常会产生副作用,GET请求不会产生副作用,但没有什么可以阻止GET请求产生副作用,同样POST请求也可能不产生副作用。Data同样可以通过在Get请求
的URL本身上面编码来传送。
可看如下例子
[python:nogutter]
>>> import urllib2
>>> import urllib
>>> data = {}
>>> data[‘name’] = ‘Somebody Here’
>>> data[‘location’] = ‘Northampton’
>>> data[‘language’] = ‘Python’
>>> url_values = urllib.urlencode(data)
>>> print url_values
name=Somebody+Here&language=Python&location=Northampton
>>> url = ‘http://www.example.com/example.cgi’
>>> full_url = url + ‘?’ + url_values
>>> data = urllib2.open(full_url)

[/codesyntax]
Headers
我们将在这里讨论特定的HTTP头,来说明怎样添加headers到你的HTTP请求。
有一些站点不喜欢被程序(非人为访问)访问,或者发送不同版本的内容到不同的浏览器。默认的urllib2把自己作为“Python-urllib/x.y”(x和y是Python主版本和次版本号,例如Python-urllib/2.5),
这个身份可能会让站点迷惑,或者干脆不工作。浏览器确认自己身份是通过User-Agent头,当你创建了一个请求对象,你可以给他一个包含头数据的字典。下面的例子发送跟上面一样的内容,但把自身
模拟成Internet Explorer。
[codesyntax lang=”python”]

import urllib 
import urllib2 
url = 'http://www.someserver.com/cgi-bin/register.cgi' 
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)' 
values = {'name' : 'Michael Foord', 
          'location' : 'Northampton', 
          'language' : 'Python' } 
headers = { 'User-Agent' : user_agent } 
data = urllib.urlencode(values) 
req = urllib2.Request(url, data, headers) 
response = urllib2.urlopen(req) 
the_page = response.read()

[/codesyntax]
response应答对象同样有两个很有用的方法。看下面的节info and geturl,我们将看到当发生错误时会发生什么。
Handle Exceptions处理异常
当urlopen不能够处理一个response时,产生urlError(不过通常的Python APIs异常如ValueError,TypeError等也会同时产生)。
HTTPError是urlError的子类,通常在特定HTTP URLs中产生。
URLError
通常,URLError在没有网络连接(没有路由到特定服务器),或者服务器不存在的情况下产生。这种情况下,异常同样会带有”reason”属性,它是一个tuple,包含了一个错误号和一个错误信息。
例如
[codesyntax lang=”python”]

>>> req = urllib2.Request('http://www.pretend_server.org') 
>>> try: urllib2.urlopen(req) 
>>> except URLError, e: 
>>>    print e.reason 
>>> 
(4, 'getaddrinfo failed')

[/codesyntax]
HTTPError
服务器上每一个HTTP 应答对象response包含一个数字”状态码”。有时状态码指出服务器无法完成请求。默认的处理器会为你处理一部分这种应答(例如:假如response是一个”重定向”,需要客户端从别的地址获取文档
,urllib2将为你处理)。其他不能处理的,urlopen会产生一个HTTPError。典型的错误包含”404″(页面无法找到),”403″(请求禁止),和”401″(带验证请求)。
请看RFC 2616 第十节有所有的HTTP错误码
HTTPError实例产生后会有一个整型’code’属性,是服务器发送的相关错误号。
Error Codes错误码
因为默认的处理器处理了重定向(300以外号码),并且100-299范围的号码指示成功,所以你只能看到400-599的错误号码。
BaseHTTPServer.BaseHTTPRequestHandler.response是一个很有用的应答号码字典,显示了RFC 2616使用的所有的应答号。这里为了方便重新展示该字典。(译者略)
当一个错误号产生后,服务器返回一个HTTP错误号,和一个错误页面。你可以使用HTTPError实例作为页面返回的应答对象response。这表示和错误属性一样,它同样包含了read,geturl,和info方法。
[codesyntax lang=”python”]

>>> req = urllib2.Request('http://www.python.org/fish.html') 
>>> try: 
>>>     urllib2.urlopen(req) 
>>> except URLError, e: 
>>>     print e.code 
>>>     print e.read() 
>>> 
404 

Error 404: File Not Found 
...... etc...

[/codesyntax]
Wrapping it Up包装
所以如果你想为HTTPError或URLError做准备,将有两个基本的办法。我则比较喜欢第二种。
第一个:
[codesyntax lang=”python”]

from urllib2 import Request, urlopen, URLError, HTTPError 
req = Request(someurl) 
try: 
    response = urlopen(req) 
except HTTPError, e: 
    print 'The server couldn/'t fulfill the request.' 
    print 'Error code: ', e.code 
except URLError, e: 
    print 'We failed to reach a server.' 
    print 'Reason: ', e.reason 
else: 
    # everything is fine

[/codesyntax]
注意:except HTTPError 必须在第一个,否则except URLError将同样接受到HTTPError。
第二个:
[codesyntax lang=”python”]

from urllib2 import Request, urlopen, URLError 
req = Request(someurl) 
try: 
    response = urlopen(req) 
except URLError, e: 
    if hasattr(e, 'reason'): 
        print 'We failed to reach a server.' 
        print 'Reason: ', e.reason 
    elif hasattr(e, 'code'): 
        print 'The server couldn/'t fulfill the request.' 
        print 'Error code: ', e.code 
else: 
    # everything is fine

[/codesyntax]
info and geturl
urlopen返回的应答对象response(或者HTTPError实例)有两个很有用的方法info()和geturl()
geturl — 这个返回获取的真实的URL,这个很有用,因为urlopen(或者opener对象使用的)或许
会有重定向。获取的URL或许跟请求URL不同。
info — 这个返回对象的字典对象,该字典描述了获取的页面情况。通常是服务器发送的特定头headers。目前是httplib.HTTPMessage 实例。
经典的headers包含”Content-length”,”Content-type”,和其他。查看Quick Reference to HTTP Headers(http://www.cs.tut.fi/~jkorpela/http.html)
获取有用的HTTP头列表,以及它们的解释意义。
Openers和Handlers
当你获取一个URL你使用一个opener(一个urllib2.OpenerDirector的实例,urllib2.OpenerDirector可能名字可能有点让人混淆。)正常情况下,我们
使用默认opener — 通过urlopen,但你能够创建个性的openers,Openers使用处理器handlers,所有的“繁重”工作由handlers处理。每个handlers知道
如何通过特定协议打开URLs,或者如何处理URL打开时的各个方面,例如HTTP重定向或者HTTP cookies。
如果你希望用特定处理器获取URLs你会想创建一个openers,例如获取一个能处理cookie的opener,或者获取一个不重定向的opener。
要创建一个 opener,实例化一个OpenerDirector,然后调用不断调用.add_handler(some_handler_instance).
同样,可以使用build_opener,这是一个更加方便的函数,用来创建opener对象,他只需要一次函数调用。
build_opener默认添加几个处理器,但提供快捷的方法来添加或更新默认处理器。
其他的处理器handlers你或许会希望处理代理,验证,和其他常用但有点特殊的情况。
install_opener 用来创建(全局)默认opener。这个表示调用urlopen将使用你安装的opener。
Opener对象有一个open方法,该方法可以像urlopen函数那样直接用来获取urls:通常不必调用install_opener,除了为了方便。
Basic Authentication 基本验证
为了展示创建和安装一个handler,我们将使用HTTPBasicAuthHandler,为了更加细节的描述本主题–包含一个基础验证的工作原理。
请看Basic Authentication Tutorial(http://www.voidspace.org.uk/python/articles/authentication.shtml)
当需要基础验证时,服务器发送一个header(401错误码) 请求验证。这个指定了scheme 和一个‘realm’,看起来像这样:Www-authenticate: SCHEME realm=”REALM”.
例如
Www-authenticate: Basic realm=”cPanel Users”
客户端必须使用新的请求,并在请求头里包含正确的姓名和密码。这是“基础验证”,为了简化这个过程,我们可以创建一个HTTPBasicAuthHandler的实例,并让opener使用这个
handler。
HTTPBasicAuthHandler使用一个密码管理的对象来处理URLs和realms来映射用户名和密码。如果你知道realm(从服务器发送来的头里)是什么,你就能使用HTTPPasswordMgr。
通常人们不关心realm是什么。那样的话,就能用方便的HTTPPasswordMgrWithDefaultRealm。这个将在你为URL指定一个默认的用户名和密码。这将在你为特定realm提供一个其他组合时
得到提供。我们通过给realm参数指定None提供给add_password来指示这种情况。
最高层次的URL是第一个要求验证的URL。你传给.add_password()更深层次的URLs将同样合适。
[codesyntax lang=”python”]

# 创建一个密码管理者 
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm() 
# 添加用户名和密码 
# 如果知道 realm, 我们可以使用他代替 ``None``. 
top_level_url = "http://example.com/foo/" 
password_mgr.add_password(None, top_level_url, username, password) 
handler = urllib2.HTTPBasicAuthHandler(password_mgr) 
# 创建 "opener" (OpenerDirector 实例) 
opener = urllib2.build_opener(handler) 
# 使用 opener 获取一个URL 
opener.open(a_url) 
# 安装 opener. 
# 现在所有调用 urllib2.urlopen 将用我们的 opener.

[/codesyntax]
urllib2.install_opener(opener)
注意:以上的例子我们仅仅提供我们的HHTPBasicAuthHandler给build_opener。默认的openers有正常状况的handlers–ProxyHandler,UnknownHandler,HTTPHandler,HTTPDefaultErrorHandler, HTTPRedirectHandler, FTPHandler, FileHandler, HTTPErrorProcessor。
top_level_url 实际上可以是完整URL(包含”http:”,以及主机名及可选的端口号)例如:http://example.com/,也可以是一个“authority”(即主机名和可选的
包含端口号)例如:“example.com” or “example.com:8080”(后者包含了端口号)。权限验证,如果递交的话不能包含”用户信息”部分,例如:
“joe@password:example.com”是错误的。
Proxies代理urllib 将自动监测你的代理设置并使用他们。这个通过ProxyHandler这个在正常处理器链中的对象来处理。通常,那工作的很好。但有时不起作用
。其中一个方法便是安装我们自己的代理处理器ProxyHandler,并不定义代理。这个跟使用Basic Authentication 处理器很相似。
[codesyntax lang=”python”]

>>> proxy_support = urllib.request.ProxyHandler({}) 
>>> opener = urllib.request.build_opener(proxy_support) 
>>> urllib.request.install_opener(opener)

[/codesyntax]
注意:
此时urllib.request不支持通过代理获取https地址。但,这个可以通过扩展urllib.request达到目的。
Sockets and Layers
Python支持获取网络资源是分层结构。urllib 使用http.client库,再调用socket库实现。
在Python2.3你可以指定socket的等待回应超时时间。这个在需要获取网页的应用程序里很有用。默认的socket模型没有超时和挂起。现在,socket超时没有暴露 www.2cto.com
给http.client或者urllib.request层。但你可以给所有的sockets设置全局的超时。

Git ignore详解

环境

Windows XP SP3 + TortoiseGit + msysGit

 

ignore files的三种方法

以下涉及的ignore文件均为如下格式:

#?以’#’开始的行,被视为注释.#?忽略掉所有文件名是?foo.txt的文件.

foo.txt

#?忽略所有生成的?html文件,

*.html

# foo.html是手工维护的,所以例外.

!foo.html

#?忽略所有.o和?.a文件.

*.[oa]

 

【方式一】

在仓库目录下新建一个名为.gitignore的文件(因为是点开头,没有文件名,没办法直接在windows目录下直接创建,必须通过右键Git Bash,按照linux的方式来新建.gitignore文件)。如下图所示。

.gitignore文件对其所在的目录及所在目录的全部子目录均有效。通过将.gitignore文件添加到仓库,其他开发者更新该文件到本地仓库,以共享同一套忽略规则。

【方式二】

通过配置.git/info/exclude文件来忽略文件。这种方式对仓库全局有效,只能对自己本地仓库有作用,其他人没办法通过这种方式来共享忽略规则,除非他人也修改其本地仓库的该文件。

 

【方式三】

通过.git/config配置文件的core. Excludesfile选项,指定一个忽略规则文件(完整路径),如下图所示。忽略规则在文件e:/gitignore.txt中(当然该文件名可以任意取)。

该方式的作用域是也全局的。

 

【例子】

[codesyntax lang=”text”]
# 忽略*.o和*.a文件
?*.[oa]
# 忽略*.b和*.B文件,my.b除外
*.[bB]
!my.b
# 忽略dbg文件和dbg目录
dbg
# 只忽略dbg目录,不忽略dbg文件
dbg/
# 只忽略dbg文件,不忽略dbg目录
dbg
!dbg/
# 只忽略当前目录下的dbg文件和目录,子目录的dbg不在忽略范围内
/dbg
[/codesyntax]

Git branch详解

查看分支:
$ git branch    该命令会类出当先项目中的所有分支信息,其中以*开头的表示当前所在的分支。参数-r列出远程仓库中的分支,而-a则远程与本地仓库的全部分支。
创建新分支:
$ git branch testing    创建一个名为testing的分支

切换分支:
$ git checkout teting   切换到testing分支上。通过向该命令传递一个-b参数,可以实现创建并切换分支的功能。

合并分支:
$ git merge hotfix      将hotfix分支合并到当前分支当中去

删除分支:
$ git branch -d hotfix  删除分支hotfix,-d选项只能删除已经被当前分支所合并过的分支,而要强制删除没有被合并过的分支,可以使用-D。

重命名分支:
$ git branch -m oldbranch newbranch     -M用来强制重命名,如newbranch已经存在的时候。

查看分支之间的不同:
$ git diff branchName   查看当前分支与branchName分支之间的差异,也可以使用:$ git diff branch1 branch2 来比较这1和2分支之间的差异,当使用第一种方式比较时,如果当前工作目录中存在与branchName同名的文件,系统则会提示错误,要是指明要比较的是文件还是分支,如果比较分支,可以进入.git中进行比较或切换分支,如果是>比较文件,则使用$ git diff — fileName命令。
$ git diff <branchA>:<fileA> <branchB>:<fileB>
$ git ls-tree -r branch 列出所有的树对象

合并冲突:
如果在不同的分支中都修改了同一个文件的同一部分,Git 就无法干净地把两者合到一起(译注:逻辑上说,这种问题只能由人来裁决。)
任何包含未解决冲突的文件都会以未合并(unmerged)的状态列出。Git 会在有冲突的文件里加入标准的冲突解决标记,可以通过它们来手工定位并解决这些冲突。
在解决了所有文件里的所有冲突后,运行 git add 将把它们标记为已解决状态(译注:实际上就是来一次快照保存到暂存区域。)。因为一旦暂存,就表示冲突已经解决。如
果你想用一个有图形界面的工具来解决这些问题,不妨运行 git mergetool,它会调用一个可视化的合并工具并引导你解决所有冲突。
要从该清单中筛选出你已经(或尚未)与当前分支合并的分支,可以用 –merge 和 –no-merged 选项(Git 1.5.6 以上版本)。比如用 git branch –merge 查看哪些分支>已被并入当前分支(译注:也就是说哪些分支是当前分支的直接上游。)

远程分支:
远程分支是对远程仓库分支的索引。它们是一些无法移动的本地分支,只有在Git进行网络交互时才会更新。我们用(远程仓库名)/(分支名)来表示远程分支。比如想查看上次>同origin仓库通讯时master的样子,就应该查看origin/master分支。

推送本地分支:
$ git push (远程仓库名字) (分支名)  如:$ git push orgin serverfix 该命令会将本地serverfix分支推送到origin远程仓库的serverfix分支中去,也可以使用命令 $ git push origin serverfix:serferfix实现同样的效果,可以将第二个serverfix更改为其它名字来指定要将该本地分支推送到远程仓库中的的指定分支中去,如果不存在,则会在
远程仓库中新建分支。

获取远程分支:
在使用git clone命令从远程服务器克隆Git仓库时,只是将远程仓库当前分支的内容克隆到本地,要是克隆其他分支的内容,需要使用下面命令:可通过git branch -r命令来
查看想要获取的远程仓库中的分支。
$ git fetch origin  值得注意的是,在 fetch 操作下载好新的远程分支之后,你仍然无法在本地编辑该远程仓库中的分支。
如果要把该内容合并到当前分支,可以运行 git merge origin/serverfix。如果想要一份自己的 serverfix 来开发,可以在远程分支的基础上分化出一个新的分支来:
$ git checkout -b serverfix origin/serverfix
这会切换到新建的 serverfix 本地分支,其内容同远程分支 origin/serverfix 一致,这样你就可以在里面继续开发了。

Git pull:
从服务器的仓库中获取代码,和本地代码合并。(与服务器交互,从服务器上下载最新代码,等同于: Git fetch + Git merge)。
从其它的版本库(既可以是远程的也可以是本地的)将代码更新到本地,例如:“git pull origin master ”就是将origin这个版本库的代码更新到本地的master主分支。
git pull可以从任意一个git库获取某个分支的内容。用法如下:
git pull username@ipaddr: 远端repository名 远端分支名:本地分支名。这条命令将从远端git库的远端分支名获取到本地git库的一个本地分支中。其中,如果不写本地
分支名,则默认pull到本地当前分支。
需要注意的是,git pull也可以用来合并分支。 和git merge的作用相同。 因此,如果你的本地分支已经有内容,则git pull会合并这些文件,如果有冲突会报警。

Git push
将本地commit的代码更新到远程版本库中,例如 “git push origin”就会将本地的代码更新到名为orgin的远程版本库中。
git push和git pull正好想反,是将本地某个分支的内容提交到远端某个分支上。用法: git pushusername@ipaddr: 远端repository名 本地分支名:远端分支名。这条命
令将本地git库的一个本地分支push到远端git库的远端分支名中。
需要格外注意的是,git push好像不会自动合并文件。因此,如果git push时,发生了冲突,就会被后push的文件内容强行覆盖,而且没有什么提示。 这在合作开发时是>很危险的事情。

git-clone命令只要碰到类似下面格式的远程仓库地址,都会被认为地址是符合SSH协议的:        账户@IP:工作目录

git checkout -b [分支名] [远程名]/[分支名]
如果你有 1.6.2 以上版本的 Git,还可以用 –track 选项简化
$ git checkout –track origin/serverfix

删除远程分支:
git push [远程名] :[分支名]

git pull 远程仓库名 远程分支:本地分支
git push 远程仓库名 远程分支:本地分支
git checkout -b 分支名 远程仓库名/分支名

Git Merge详解

git merge 用来做分支合并,将其他分支中的内容合并到当前分支中。比如分支结构如下:
[codesyntax lang=”text”]

                        master
                         /
C0 ---- C1 ---- C2 ---- C4
                         \
                         C3 ---- C5
                                  \
                                issueFix

[/codesyntax]
当前分支是master
$ git checkout master

把issueFix中的内容Merge进来:
$ git merge issueFix

如果没有冲突的话,merge完成。有冲突的话,git会提示那个文件中有冲突,比如有如下冲突:

<<<<<<< HEAD:test.c

printf (“test1″);

=======

printf (“test2″);

>>>>>>> issueFix:test.c

可以看到 ======= 隔开的上半部分,是 HEAD(即 master 分支,在运行 merge 命令时检出的分支)中的内容,下半部分是在 issueFix 分支中的内容。解决冲突的办法无非是二者选其一或者由你亲自整合到一起。比如你可以通过把这段内容替换为下面这样来解决:

printf (“test2″);

这个解决方案各采纳了两个分支中的一部分内容,而且删除了 <<<<<<<,=======,和>>>>>>> 这些行。在解决了所有文件里的所有冲突后,运行 git add 将把它们标记为已解决(resolved)。因为一旦暂存,就表示冲突已经解决。如果你想用一个有图形界面的工具来解决这些问题,不妨运行 git mergetool,它会调用一个可视化的合并工具并引导你解决所有冲突:

$ git mergetool
merge tool candidates: kdiff3 tkdiff xxdiff meld gvimdiff opendiff emerge vimdiff
Merging the files: index.html

Normal merge conflict for ‘test.c’:
{local}: modified
{remote}: modified
Hit return to start merge resolution tool (kdiff3):

合并后的分支图如下:
[codesyntax lang=”text”]

                               master
                                 /
C0 ---- C1 ---- C2 ---- C4 ---- C6
                        \       /
                        C3 ----C5
                                \
                              issueFix

[/codesyntax]
注意,这次合并的实现,由于当前 master 分支所指向的 commit (C4)并非想要并入分支(issueFix)的直接祖先,Git 不得不进行一些处理。就此例而言,Git 会用两个分支的末端(C4 和 C5)和它们的共同祖先(C2)进行一次简单的三方合并。对三方合并的结果作一新的快照,并自动创建一个指向它的 commit(C6)

退出合并工具以后,Git 会询问你合并是否成功。如果回答是,它会为你把相关文件暂存起来,以表明状态为已解决。然后可以用 git commit 来完成这次合并提交。

Python字典详解

创建

方法一:
[codesyntax lang=”python”]

>>> dict1 = {}
>>> dict2 = {'name': 'earth', 'port': 80}
>>> dict1, dict2
({}, {'port': 80, 'name': 'earth'})

[/codesyntax]
方法二:从Python 2.2 版本起,可以使用一个工厂方法,传入一个元素是列表的元组作为参数
[codesyntax lang=”python”]

>>> fdict = dict((['x', 1], ['y', 2]))
>>> fdict
{'y': 2, 'x': 1}

[/codesyntax]
方法三:

从Python 2.3 版本起, 可以用一个很方便的内建方法fromkeys() 来创建一个”默认”字典, 字典中元素具有相同的值 (如果没有给出, 默认为None,这个有点像我框架的oneObject方法):
[codesyntax lang=”python”]

>>> ddict = {}.fromkeys(('x', 'y'), -1) 
>>> ddict
{'y': -1, 'x': -1}
>>>
>>> edict = {}.fromkeys(('foo', 'bar'))
>>> edict
{'foo': None, 'bar': None}

[/codesyntax]

访问字典中的值

想遍历一个字典(一般用键), 你只需要循环查看它的键, 像这样:
[codesyntax lang=”python”]

>>> dict2 = {'name': 'earth', 'port': 80}
>>>
>>>> for key in dict2.keys():
... print 'key=%s, value=%s' % (key, dict2[key])
...
key=name, value=earth
key=port, value=80

[/codesyntax]
从Python 2.2 开始,可以直接在 for 循环里遍历字典。
[codesyntax lang=”python”]

>>> dict2 = {'name': 'earth', 'port': 80}
>>>
>>>> for key in dict2:
... print 'key=%s, value=%s' % (key, dict2[key])
...
key=name, value=earth
key=port, value=80

[/codesyntax]
想判定其是否存在某个键值对,可以使用has_key()或 in 、 not in 操作符
[codesyntax lang=”python”]

>>> 'server' in dict2 # 或 dict2.has_key('server')
False
>>> 'name' in dict # 或 dict2.has_key('name')
True
>>> dict2['name']
'earth'

[/codesyntax]
一个字典中混用数字和字符串的例子:
[codesyntax lang=”python”]

>>> dict3 = {}
>>> dict3[1] = 'abc'
>>> dict3['1'] = 3.14159
>>> dict3[3.2] = 'xyz'
>>> dict3
{3.2: 'xyz', 1: 'abc', '1': 3.14159}

[/codesyntax]

更新字典

采取覆盖更新

上例中 dict2[‘name’]=’earth’;

更新 dict2[‘name’]=’abc’;

删除字典元素和字典

del dict2[‘name’] # 删除键为“name”的条目

dict2.clear() # 删除dict2 中所有的条目

del dict2 # 删除整个dict2 字典

dict2.pop(‘name’) # 删除并返回键为“name”的条目
[codesyntax lang=”python”]

dict2 = {'name': 'earth', 'port': 80}
>>> dict2.keys()
['port', 'name']
>>>
>>> dict2.values()
[80, 'earth']
>>>
>>> dict2.items()
[('port', 80), ('name', 'earth')]
>>>
>>> for eachKey in dict2.keys():
... print 'dict2 key', eachKey, 'has value', dict2[eachKey]
...
dict2 key port has value 80
dict2 key name has value earth

[/codesyntax]
update()方法可以用来将一个字典的内容添加到另外一个字典中
[codesyntax lang=”python”]

dict3 = {'server': 'http', 'port': 80, 'host': 'venus'}
>>> dict3.clear()
>>> dict3
{}

[/codesyntax]
映射类型相关的函数
[codesyntax lang=”python”]

>>> dict(x=1, y=2)
{'y': 2, 'x': 1}
>>> dict8 = dict(x=1, y=2)
>>> dict8
{'y': 2, 'x': 1}
>>> dict9 = dict(**dict8)
>>> dict9
{'y': 2, 'x': 1}

dict9 = dict8.copy()

[/codesyntax]

字典内建方法

方法名字 操作
dict.clear() 删除字典中所有元素
dict.copy() 返回字典(浅复制)的一个副本
dict.fromkeysc(seq,val=None) 创建并返回一个新字典,以seq 中的元素做该字典的键,val 做该字典中所有键对应的初始值(如果不提供此值,则默认为None)
dict.get(key,default=None) 对字典dict 中的键key,返回它对应的值value,如果字典中不存在此键,则返回default 的值(注意,参数default 的默认值为None)
dict.has_key(key) 如果键(key)在字典中存在,返回True,否则返回False. 在Python2.2版本引入in 和not in 后,此方法几乎已废弃不用了,但仍提供一个 可工作的接口。
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.values() 返回一个包含字典中所有值的列表
dict.iter() 方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表。
dict.pop(key[, default]) 和方法get()相似,如果字典中key 键存在,删除并返回dict[key],如果key 键不存在,且没有给出default 的值,引发KeyError 异常。
dict.setdefault(key,default=None) 和方法set()相似,如果字典中不存在key 键,由dict[key]=default 为它赋值。
dict.setdefault(key,default=None) 和方法set()相似,如果字典中不存在key 键,由dict[key]=default 为它赋值。

Git 常用操作详解

简介

版本控制系统(VCS, Version Control System) 可以分为集中式(CVCS, Centralized Version Control System, 如 CVS, Subversion)和分布式(DVCS, Distributed Version Control System,如 Git 等)版本控制系统。

传统的集中式版本控制系统,本地只保存代码库的一个版本拷贝。 所有历史版本都保存在服务器。GIT 与之最大的不同是,本地不仅保存一个快照,而且保存着整个代码库(repository)。因此它可以“离线”工作。

在 Window 上安装: http://code.google.com/p/msysgit

GIT 起源于 LINUX 开发。Linux 开发早期(1992-2002)没有使用版本控制工具,直到 2002 年开始使用一个非开源的工具 BitKeeper。一开始这个工具还给 Linux 免费使用,后来想收费了,充满自由精神 Linux 成员们肯定不会屈服于这个要挟,一怒之下开发了一个自由的版本控制工具。2005 年,GIT 诞生 。

参考: 官网:http://git-scm.com/

手册:http://www.kernel.org/pub/software/scm/git/docs/

参考:http://gitref.org/

ProGit: http://progit.org/book/

GIT 基础

GIT 使用 SHA-1 哈希码(40个字符)来标识提交,同时保证本次提交后整体(一个快照)的完整性。

文件状态:

文件状态分为:未跟踪 (untracked) 和已跟踪 (tracked),已跟踪又分为三种状态: 已暂存(staged),已修改(modified),已提交(committed)

一般过程如下:

1) 新建文件,该文件状态为“未跟踪”,位于工作区

2) 用 git add a.txt? 加入该文件,状态变为已跟踪的“已暂存”,位于暂存区

3) 用 git commit a.txt -m “ha”? 提交该文件,状态变为“已提交”,位于代码库(repository )

或者,如果存在修改的情况,增加如下2.1和2.2两个步骤:

1) 新建文件,该文件状态为“未跟踪”,位于工作区

2) 用 git add a.txt? 加入该文件,状态变为已跟踪的“已暂存”,位于暂存区

2.1)编辑该文件并保存,状态变为“已修改”,位于工作区。(注意,位于暂存区的文件独立存在!)

2.2) 用 git add a.txt? 加入该文件,状态变为“已暂存”,位于暂存区。(注意,原暂存区的文件被覆盖!)

3) 用 git commit a.txt -m “ha”? 提交该文件,状态变为“已提交”,位于代码库(repository )

考虑更广泛的情况,状态迁移图如下所示:

Git?<wbr>使用?<wbr>-?<wbr>1.?<wbr>文件操作和历史查看

注意:用 git status 查看目前所有文件的状态。

GIT 配置:

三种配置范围类型:

1)所有用户 –system,?? 存在 /etc/gitconfig 文件中。(对windows来说,是 msysgit 的安装目录)

2)本用户 –global,?? 存在 ~/.gitconfig? 文件中。(对windows 来说,是 C:\Documents and Settings\$USER)

3)本项目?? 存在 .git/config 文件中。

注意:后面的重载前面的。例如:用–global设置,可以在所有项目中使用这个设置;如果有一个项目你想使用一个特别的设置,就可以使用不带参数的 git config 重新设置,则它只作用于这个项目。如果用 git config –list 查看这些设置,可能会列出多个,但最后那个起作用。

用户信息

$ git config –global user.name “iprayz”
$ git config –global user.email iprayz@example.com

文本编辑器

$ git config –global core.editor emacs

查看配置信息

$ git config –list

或者只看一个信息:

$ git config <key>

 

常用操作

(GIT 1.7.4 on? Windows)

获取帮助:?? $ git help <verb>

初始化仓库:? $ git init

(说明: 如果该目录有文件,则都会处于“未跟踪”状态的。)

克隆仓库:? $ git clone git://github.com/schacon/grit.git

克隆仓库,并换个名字:?? $ git clone git://github.com/schacon/grit.git mygrit

跟踪一个新文件:? $ git add readme.txt

说明:

1) 跟踪之后,该文件状态是“已暂存”的。 (Changes to be committed:)

2)修改一个已暂存的文件,该文件会出现在两个记录区中。

3) 如果跟踪错了,想把他删除(不删除工作区的),则用 git rm –cached readme.txt。状态变成“未跟踪”,如果该文件已经修改了,则加? -f 参数强行删除暂存区的文件(已修改的文件不被覆盖)。

跟踪一组新文件:? $ git add *.txt

跟踪一个目录中的所有文件:? $ git add mydir

说明:如果该目录下有子目录,则进行递归操作。

修改之后,暂存一个文件:?? $ git add readme.txt

说明:取消已暂存的文件(已暂存到已修改):? $ git reset HEAD readme.txt

忽略某些文件:? 在.gitignore 文件中加入下面两行:? *.[oa]? *~

*.a? # 忽略所有 .a 结尾的文件
!lib.a? # 但 lib.a 除外
/TODO? # 仅仅忽略项目根目录下的 TODO 文件,不包括 subdir/TODO
build/? # 忽略 build/ 目录下的所有文件
doc/*.txt # 会忽略 doc/notes.txt 但不包括 doc/server/arch.txt

注意:

.gitignore 文件放在工程的根目录即可,但是要把它用 git add 加入跟踪或者提交。

比较:

查看尚未暂存的更新:? $ git diff

说明:比较“已修改”和“已暂存(或已提交)”。

查看尚未提交的更新:? $ git diff –cached

或? $ git diff –staged

说明:比较“已暂存”和已提交。

提交:

提交更新(只更新暂存中的):? $ git commit

提交更新(只更新暂存中的):? $ git commit -m “task12, added implementation for usr mrg.”

直接提交更新(更新暂存中的和已修改的): $ git commit -a -m “task12, added implementation forg.”

从文件中取注释:?? $ git commit –file notefile

重新获取:

抛弃已修改,用已提交覆盖?? $ git checkout A.java

说明:此命令对已暂存文件没作用。

删除文件:

从工作区可以直接删除文件,这是运行 git status, 显示:

Changes not staged for commit:

(use “git add/rm <file>…” to update what will be committed)

(use “git checkout — <file>…” to discard changes in working directory)

deleted:?? a

可以用 git rm 删除 a。注意:如果 a 是已提交的文件,则还需要运行 git commit 以确保在代码库中删除。如果该文件尚未提交,则无需运行git commit。

也可以直接使用 git rm 删除文件,但如何文件处于“已修改” 则需要加 -f

移除已跟踪文件,恢复到“未跟踪”?? $ git rm –cached A.java

说明:如果文件已修改,则需 -f ,并且不覆盖修改过的内容。

强行移除修改后文件(从暂存区和工作区中删除):? $ git rm -f a.a

移除目录下的所有文件(递归):? $ git rm log/\*.log

移除目录下的所有文件(无递归):? $ git rm log/*.log

改名(只改工作区和暂存区):? $ git mv file1 file2

相当于:? $ mv README.txt README
$ git rm README.txt
$ git add README

历史查看 :

查看提交历史(全部):? $ git log

查看提交历史,并显示统计信息:? $ git log –stat

查看提交历史并查看差异:? $ git log -p

查看最近2次提交历史并查看差异:? $ git log -p -2

查看最近2周内提交历史:? $ git log –since=2.weeks

查看某个时刻之后的提交历史:? $ git log –since=”2008-09-14″

查看某个时刻以前的提交历史:? $ git log –until=”2008-09-14″

查看某个作者的提交历史:? $ git log –author=”stupid”

其他:

-(n) 仅显示最近的 n 条提交
–since, –after 仅显示指定时间之后的提交。
–until, –before 仅显示指定时间之前的提交。
–author 仅显示指定作者相关的提交。
–committer 仅显示指定提交者相关的提交。

例如:

$ git log –pretty=”%h:%s” –author=gitster –since=”2008-10-01″ \
–before=”2008-11-01″ –no-merges — t/

查看提交历史,并单行显示:? $ git log –pretty=oneline

查看提交历史,并格式化显示:? $ git log –pretty=format:”%h – %an, %ar : %s”

例如:

$ git log –pretty=format:”%h – %an, %ar : %s”
[codesyntax lang=”text”]

ca82a6d - Scott Chacon, 11 months ago : changed the version number
085bb3b - Scott Chacon, 11 months ago : removed unnecessary test code
a11bef0 - Scott Chacon, 11 months ago : first commit

[/codesyntax]

%H 提交对象(commit)的完整哈希字串
%h 提交对象的简短哈希字串
%T 树对象(tree)的完整哈希字串
%t 树对象的简短哈希字串
%P 父对象(parent)的完整哈希字串
%p 父对象的简短哈希字串
%an 作者(author)的名字
? 作者的电子邮件地址
? 作者修订日期(可以用 -date= 选项定制格式)
%ar 作者修订日期,按多久以前的方式显示
%cn 提交者(committer)的名字
? 提交者的电子邮件地址
? 提交日期
%cr 提交日期,按多久以前的方式显示
%s 提交说明

查看提交历史,并图形化显示:? $ git log –pretty=format:”%h %s” –graph

例如:

$ git log –pretty=format:”%h %s” –graph

[codesyntax lang=”text”]

* 2d3acf9 ignore errors from SIGCHLD on trap
*? 5e3ee11 Merge branch 'master' of git://github.com/dustin/grit
|\
| * 420eac9 Added a method for getting the current branch.
* | 30e367c timeout code and tests
* | 5a09431 add timeout protection to grit
* | e1193f8 support for heads with slashes in them
|/
* d6016bc require time for xmlschema
*? 11d191e Merge branch 'defunkt' into local

[/codesyntax]

其它:

-p 按补丁格式显示每个更新之间的差异。
–stat 显示每次更新的文件修改统计信息。
–shortstat 只显示 –stat 中最后的行数修改添加移除统计。
–name-only 仅在提交信息后显示已修改的文件清单。
–name-status 显示新增、修改、删除的文件清单。
–abbrev-commit 仅显示 SHA-1 的前几个字符,而非所有的 40 个字符。
–relative-date 使用较短的相对时间显示(比如,“2 weeks ago”)。
–graph 显示 ASCII 图形表示的分支合并历史。
–pretty 使用其他格式显示历史提交信息。可用的选项包括 oneline,short,full,fuller 和 format(后跟指定格式)。

最重要的是,如果你觉着上面这些查看历史的命令太难用,你可以使用图形化工具:gitk,一切都清晰了。

Git log参数详解

git log 查看提交记录,参数:
-n      (n是一个正整数),查看最近n次的提交信息
[codesyntax lang=”text”]

$ git log -2    
查看最近2次的提交历史记录

[/codesyntax]

— fileName     fileName为任意文件名,查看指定文件的提交信息。(注:文件名应该放到参数的最后位置,通常在前面加上–并用空格隔开表示是文件。)
[codesyntax lang=”text”]

$ git log file1 file2   查看file1文件file2文件的提交记录
$ git log file/         查看file文件夹下所有文件的提交记录

[/codesyntax]

–branchName    branchName为任意一个分支名字,查看莫个分支上的提交记录。同上,需要放到参数中的最后位置处。(注:如果分支名与文件名相同,系统会提示错误,可通过–选项来指定给定的参数是分支名还是文件名。)例:在当前分支中有一个名为v1的文件,同时还存在一个名为v1的分支,则:
[codesyntax lang=”text”]

$ git log v1 
-- 此时的v1代表的是分支名字
$ git log -- v1 此时的v1代表的是名为v1的文件
$ git log v1 -- v1

[/codesyntax]

tagName或branchame               查询指定标签/分支中的提交记录信息
[codesyntax lang=”text”]

$ git log v1.0..        查询从v1.0以后的提交历史记录(不包含v1.0)
$ git log test..master  查询master分支中的提交记录但不包含test分支记录
$ git log master..test  查询test分支中的提交记录但不办含master分支记录
$ git log master...test 查询master或test分支中的提交记录。
$ git log test --not master  屏蔽master分支

[/codesyntax]

根据commit查询日志
[codesyntax lang=”text”]

$ git log commit    查询commit之前的记录,包含commit
$ git log commit1 commit2 查询commit1与commit2之间的记录,包括commit1和commit2
$ git log commit1..commit2 同上,但是不包括commit1

[/codesyntax]

其中,commit可以是提交哈希值的简写模式,也可以使用HEAD代替。HEAD代表最后一次提交,HEAD^为最后一个提交的父提交,等同于HEAD~1,HEAD~2代表倒数第二次提交
–pretty
       按指定格式显示日志信息,可选项有:oneline,short,medium,full,fuller,email,raw以及format:<string>,默认为medium,可以通过修改配置文件来指定默认的
方式。
[codesyntax lang=”text”]

$ git log (--pretty=)oneline

[/codesyntax]

常见的format选项:

[codesyntax lang=”text”]

选项     说明
%H      提交对象(commit)的完整哈希字串
%h      提交对象的简短哈希字串
%T      树对象(tree)的完整哈希字串
%t      树对象的简短哈希字串
%P      父对象(parent)的完整哈希字串
%p      父对象的简短哈希字串
%an     作者(author)的名字
%ae     作者的电子邮件地址
%ad     作者修订日期(可以用 -date= 选项定制格式)
%ar     作者修订日期,按多久以前的方式显示
%cn     提交者(committer)的名字
%ce     提交者的电子邮件地址
%cd     提交日期
%cr     提交日期,按多久以前的方式显示
%s      提交说明

[/codesyntax]

注:作者是指最后一次修改文件的人;而提交者是指提交该文件的人。
[codesyntax lang=”text”]

$ git log --pretty=format:"%an %ae %ad %cn %ce %cd %cr %s" --graph

[/codesyntax]

–mergs 查看所有合并过的提交历史记录
–no-merges     查看所有未被合并过的提交信息
–author=someonet       查询指定作者的提交记录
[codesyntax lang=”text”]

$ git log --author=gbyukg

[/codesyntax]

–since,–affter       仅显示指定时间之后的提交(不包含当前日期)
–until,–before       仅显示指定时间之前的提交(包含当前日期)
[codesyntax lang=”text”]

$ git log --before={3,weeks,ago} --after={2010-04-18}

[/codesyntax]

–grep  通过提交说明信息过滤提交日志
[codesyntax lang=”text”]

$ git log --grep=hotfix 该命令会列出所有包含hotfix字样的提交信息说明的提交记录

[/codesyntax]

注意:如果想同时使用–grep和–author,必须在附加一个–all-match参数。
-S      通过查询文件的变更内容来检索出指定提交日志 注:-S后没有”=”,与查询内容之间也没有空格符
[codesyntax lang=”text”]

$ git log --Snew

[/codesyntax]

-p      查看提交时的补丁信息
[codesyntax lang=”text”]

$ git log -p --no-merges -2

[/codesyntax]

–stat  列出文件的修改行数
–sortstat      只显示–stat中最后行数修改添加移除的统计
–graph 以简单的图形方式列出提交记录
–abbrev-commit 仅显示 SHA-1 的前几个字符,而非所有的 40 个字符。
–relative-date 使用较短的相对时间显示(比如,“2 weeks ago”)。
–name-only 仅在提交信息后显示已修改的文件清单。
–name-status 显示新增、修改、删除的文件清单。

GIT Blame
用来查看文件的每个部分修改详情
[codesyntax lang=”text”]

$git blame index.php

[/codesyntax]

NAT路由详解

由于Internet的快速发展 IPV4地址不够用,不能每个主机分到一个公网IP 所以使用NAT地址转换。

下面是我在网上找到的一副图

一般来说都是由私网内主机(例如上图中“电脑A-01”)主动发起连接,数据包经过NAT地址转换后送给公网上的服务器(例如上图中的“Server”),连接建立以后可双向传送数据,NAT设备允许私网内主机主动向公网内主机发送数据,但却禁止反方向的主动传递,但在一些特殊的场合需要不同私网内的主机进行互联(例如P2P软件、网络会议、视频传输等),TCP穿越NAT的问题必须解决。

下面是NAT的几种类型

NAT设备的类型对于TCP穿越NAT,有着十分重要的影响,根据端口映射方式,NAT可分为如下4类,前3种NAT类型可统称为cone类型。
(1)全克隆( Full Cone) : NAT把所有来自相同内部IP地址和端口的请求映射到相同的外部IP地址和端口。任何一个外部主机均可通过该映射发送IP包到该内部主机。
(2)限制性克隆(Restricted Cone) : NAT把所有来自相同内部IP地址和端口的请求映射到相同的外部IP地址和端口。但是,只有当内部主机先给IP地址为X的外部主机发送IP包,该外部主机才能向该内部主机发送IP包。
(3)端口限制性克隆( Port Restricted Cone) :端口限制性克隆与限制性克隆类似,只是多了端口号的限制,即只有内部主机先向IP地址为X,端口号为P的外部主机发送1个IP包,该外部主机才能够把源端口号为P的IP包发送给该内部主机。
(4)对称式NAT ( Symmetric NAT): 对称式NAT与端口限制性克隆类似,唯一不同的是当同一内部主机使用相同的端口与不同IP地址或端口的外部主机进行通信时, NAT对该内部主机的端口映射会有所不同,这种情况下NAT会针对不同IP地址或端口的外部主机为内部主机的相同端口分配新的外部端口号。对称式NAT不保证所有会话中的私有地址端口和公开地址端口之间绑定的一致性。相反,它为每个新的会话分配一个新的端口号。这种情况下内部主机的“内网IP地址和端口”与“NAT IP地址和端口”之间会形成一对多关系。

这是我在网上找到的另一份关于NAT四种类型的解释,我觉得这个叙述更加清楚明了,这里写下来作为补充,请按照顺序和上面叙述的四种NAT类型进行对照理解:

从内网主机发出报文访问外网目标时,可用四元组[源IP,源端口,目标IP,目标端口]来表示会话:
[私有源地址,私有源端口,全局目标地址,全局目标端口]
     ↓NAT
[全局源地址,全局源端口,全局目标地址,全局目标端口]
   NAT在对不同的私有源地址进行转换的时候,可能转换成同一全局源地址,也可能转换成不同的全局源地址(如果NAT地址池配置有多个全局地址)。
   而对于同一私有源地址和端口的转换情况则分为以下几种:
(1)完全Cone NAT 无论目标地址和端口怎样,每次都把该私有源IP地址/端口映射到同一个全局源地址/端口;外网的任何主机都可以发送报文到该映射的全局地址而访问到该内部主机。路由器的静态地址映射就是属于这种。
(2)限制Cone NAT 地址/端口映射的情况同完全Cone NAT的,但外网的主机要访问内网主机,该内网主机必须先发送过报文给该外网主机的地址。
(3)端口限制Cone NAT 地址/端口映射情况同完全Cone NAT的,但外网主机要访问内网主机,该内网主机必须先发送过报文给该外网主机的地址和端口。大多数路由器的NAPT就是属于这种情况。本文后面论及的Cone NAT也是指这种情况。

(4)Symmetric NAT 对不同的目标地址/端口,源私有地址映射到源全局地址不变,但是映射的全局端口会改变。外网主机必须先收到过内网主机的报文,才能访问到该内网主机。一些路由器和防火墙产品的NAT就是属于这种情况。

    Symmetric NAT并不对新会话进行端口绑定,而是分配一个全新的NAT端口给每一个新的会话.
     Server S1                                     Server S2
        18.181.0.31:1235                              138.76.29.7:1235
               |                                             |
               |                                             |
               +———————-+———————-+
                                      |
          ^  Session 1 (A-S1)  ^      |      ^  Session 2 (A-S2)  ^
          |  18.181.0.31:1235  |      |      |  138.76.29.7:1235  |
          v 155.99.25.11:62000 v      |      v 155.99.25.11:62001 v
                                      |
                                 Symmetric NAT
                                 155.99.25.11
                                      |
          ^  Session 1 (A-S1)  ^      |      ^  Session 2 (A-S2)  ^
          |  18.181.0.31:1235  |      |      |  138.76.29.7:1235  |
          v   10.0.0.1:1234    v      |      v   10.0.0.1:1234    v
                                      |
                                   Client A
                                10.0.0.1:1234
    如上图,如果Client A同时发起两个会话到S1和S2,对称NAT会分配NAT地址155.99.25.11:62000给Session1,然后分配另一个不同的NAT地址155.99.25.11:62001给Session2.对称NAT能够区别两个不同的会话并进行地址转换,应用程序每发出一个会话都会使用一个新的端口.

下面我们接着来看看对NAT进行打洞的流程与原理

先假设:有一个服务器S在公网上有一个IP,两个私网分别由NAT-A和NAT-B连接到公网,NAT-A后面有一台客户端A,NAT-B后面有一台客户端B,现在,我们需要借助S将A和B建立直接的TCP连接,即由B向A打一个洞,让A可以沿这个洞直接连接到B主机,就好像NAT-B不存在一样。

实现过程如下:
1、 S启动两个网络侦听,一个叫【主连接】侦听,一个叫【协助打洞】的侦听。
2、 A和B分别与S的【主连接】保持联系。
3、 当A需要和B建立直接的TCP连接时,首先连接S的【协助打洞】端口,并发送协助连接申请。同时在该端口号上启动侦听。注意由于要在相同的网络终端上绑定到不同的套接字上,所以必须为这些套接字设置 SO_REUSEADDR 属性(即允许重用),否则侦听会失败。
4、 S的【协助打洞】连接收到A的申请后通过【主连接】通知B,并将A经过NAT-A转换后的公网IP地址和端口等信息告诉B。
5、 B收到S的连接通知后首先与S的【协助打洞】端口连接,随便发送一些数据后立即断开,这样做的目的是让S能知道B经过NAT-B转换后的公网IP和端口号。
6、 B尝试与A的经过NAT-A转换后的公网IP地址和端口进行connect,根据不同的路由器会有不同的结果,有些路由器在这个操作就能建立连接,大多数路由器对于不请自到的SYN请求包直接丢弃而导致connect失败,但NAT-B会纪录此次连接的目标地址和端口号(即A经过NAT-A转换后的公网IP和端口号),为接下来真正的连接做好了准备,这就是所谓的打洞,即B向A打了一个洞,下次A就能直接连接到B刚才使用的端口号了。
7、 客户端B打洞的同时在相同的端口上启动侦听。B在一切准备就绪以后通过与S的【主连接】回复消息“我已经准备好”,S在收到以后将B经过NAT-B转换后的公网IP和端口号告诉给A。
8、 A收到S回复的B的公网IP和端口号等信息以后,开始连接到B公网IP和端口号(此时NAT-A也会纪录此次连接的目标地址和端口号(即B经过NAT-B转换后的公网IP和端口号),即A也向B打了一个洞,之后B也能直接连接到A的公网IP和端口号了),由于在步骤6中B曾经尝试连接过A的公网IP地址和端口,NAT-B纪录了此次连接的信息,所以当A主动连接B时,NAT-B会认为是合法的SYN数据,并允许通过,从而直接的TCP连接建立起来了。

有了一定的知识补充,接下来开始实现UDP和TCP打洞。因为没干过这个 可能要花一定的时间