func GetHash(a string) (hash.Hash, error) { var h hash.Hash switch a { case "adler32": h = adler32.New() case "crc32", "crc32ieee": h = crc32.New(crc32.MakeTable(crc32.IEEE)) case "crc32castagnoli": h = crc32.New(crc32.MakeTable(crc32.Castagnoli)) case "crc32koopman": h = crc32.New(crc32.MakeTable(crc32.Koopman)) case "crc64", "crc64iso": h = crc64.New(crc64.MakeTable(crc64.ISO)) case "crc64ecma": h = crc64.New(crc64.MakeTable(crc64.ECMA)) case "fnv", "fnv32": h = fnv.New32() case "fnv32a": h = fnv.New32a() case "fnv64": h = fnv.New64() case "fnv64a": h = fnv.New64a() case "hmac", "hmacsha256": h = hmac.New(sha256.New, []byte(key)) case "hmacmd5": h = hmac.New(md5.New, []byte(key)) case "hmacsha1": h = hmac.New(sha1.New, []byte(key)) case "hmacsha512": h = hmac.New(sha512.New, []byte(key)) case "md4": h = md4.New() case "md5": h = md5.New() case "ripemd160": h = ripemd160.New() case "sha1": h = sha1.New() case "sha224": h = sha256.New224() case "sha256": h = sha256.New() case "sha384": h = sha512.New384() case "sha512": h = sha512.New() default: return nil, errors.New("Invalid algorithm") } return h, nil }
func TestDeepObjectPointer(t *testing.T) { // Arrange wheel1 := wheel{radius: 17} wheel2 := wheel{radius: 22} wheel3 := wheel{radius: 17} myUni1 := unicycle{licencePlateID: "blah", primaryWheel: &wheel1, tags: map[string]string{"color": "blue", "name": "john"}} myUni2 := unicycle{licencePlateID: "blah", primaryWheel: &wheel2, tags: map[string]string{"color": "blue", "name": "john"}} myUni3 := unicycle{licencePlateID: "blah", primaryWheel: &wheel3, tags: map[string]string{"color": "blue", "name": "john"}} // Run it more than once to verify determinism of hasher. for i := 0; i < 100; i++ { hasher1 := adler32.New() hasher2 := adler32.New() hasher3 := adler32.New() // Act DeepHashObject(hasher1, myUni1) hash1 := hasher1.Sum32() DeepHashObject(hasher2, myUni2) hash2 := hasher2.Sum32() DeepHashObject(hasher3, myUni3) hash3 := hasher3.Sum32() // Assert if hash1 == hash2 { t.Errorf("hash1 (%d) and hash2(%d) must be different because they have different values for wheel size", hash1, hash2) } if hash1 != hash3 { t.Errorf("hash1 (%d) and hash3(%d) must be the same because although they point to different objects, they have the same values for wheel size", hash1, hash3) } } }
func TestDeepObjectPointer(t *testing.T) { // Arrange wheel1 := wheel{radius: 17} wheel2 := wheel{radius: 22} wheel3 := wheel{radius: 17} myUni1 := unicycle{licencePlateID: "blah", primaryWheel: &wheel1} myUni2 := unicycle{licencePlateID: "blah", primaryWheel: &wheel2} myUni3 := unicycle{licencePlateID: "blah", primaryWheel: &wheel3} hasher1 := adler32.New() hasher2 := adler32.New() hasher3 := adler32.New() // Act DeepHashObject(hasher1, myUni1) hash1 := hasher1.Sum32() DeepHashObject(hasher2, myUni2) hash2 := hasher2.Sum32() DeepHashObject(hasher3, myUni3) hash3 := hasher3.Sum32() // Assert if hash1 == hash2 { t.Errorf("hash1 (%d) and hash2(%d) must be different because they have different values for wheel size", hash1, hash2) } if hash1 != hash3 { t.Errorf("hash1 (%d) and hash3(%d) must be the same because although they point to different objects, they have the same values for wheel size", hash1, hash3) } }
func (pm *PrinterManager) syncPrinters(ignorePrivet bool) error { glog.Info("Synchronizing printers, stand by") // Get current snapshot of CUPS printers. cupsPrinters, err := pm.cups.GetPrinters() if err != nil { return fmt.Errorf("Sync failed while calling GetPrinters(): %s", err) } if pm.ignoreRawPrinters { cupsPrinters, _ = lib.FilterRawPrinters(cupsPrinters) } // Augment CUPS printers with extra information from SNMP. if pm.snmp != nil { err = pm.snmp.AugmentPrinters(cupsPrinters) if err != nil { glog.Warningf("Failed to augment printers with SNMP data: %s", err) } } // Set CapsHash on all printers. for i := range cupsPrinters { h := adler32.New() lib.DeepHash(cupsPrinters[i].Tags, h) cupsPrinters[i].Tags["tagshash"] = fmt.Sprintf("%x", h.Sum(nil)) h = adler32.New() lib.DeepHash(cupsPrinters[i].Description, h) cupsPrinters[i].CapsHash = fmt.Sprintf("%x", h.Sum(nil)) } // Compare the snapshot to what we know currently. diffs := lib.DiffPrinters(cupsPrinters, pm.printers.GetAll()) if diffs == nil { glog.Infof("Printers are already in sync; there are %d", len(cupsPrinters)) return nil } // Update GCP. ch := make(chan lib.Printer, len(diffs)) for i := range diffs { go pm.applyDiff(&diffs[i], ch, ignorePrivet) } currentPrinters := make([]lib.Printer, 0, len(diffs)) for _ = range diffs { p := <-ch if p.Name != "" { currentPrinters = append(currentPrinters, p) } } // Update what we know. pm.printers.Refresh(currentPrinters) glog.Infof("Finished synchronizing %d printers", len(currentPrinters)) return nil }
func TestDeepHashObject(t *testing.T) { successCases := []func() interface{}{ func() interface{} { return 8675309 }, func() interface{} { return "Jenny, I got your number" }, func() interface{} { return []string{"eight", "six", "seven"} }, func() interface{} { return [...]int{5, 3, 0, 9} }, func() interface{} { return map[int]string{8: "8", 6: "6", 7: "7"} }, func() interface{} { return map[string]int{"5": 5, "3": 3, "0": 0, "9": 9} }, func() interface{} { return A{867, "5309"} }, func() interface{} { return &A{867, "5309"} }, func() interface{} { return B{[]int{8, 6, 7}, map[string]bool{"5": true, "3": true, "0": true, "9": true}} }, func() interface{} { return map[A]bool{A{8675309, "Jenny"}: true, A{9765683, "!Jenny"}: false} }, func() interface{} { return map[C]bool{C{8675309, "Jenny"}: true, C{9765683, "!Jenny"}: false} }, func() interface{} { return map[*A]bool{&A{8675309, "Jenny"}: true, &A{9765683, "!Jenny"}: false} }, func() interface{} { return map[*C]bool{&C{8675309, "Jenny"}: true, &C{9765683, "!Jenny"}: false} }, } for _, tc := range successCases { hasher1 := adler32.New() DeepHashObject(hasher1, tc()) hash1 := hasher1.Sum32() DeepHashObject(hasher1, tc()) hash2 := hasher1.Sum32() if hash1 != hash2 { t.Fatalf("hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash1, hash2) } for i := 0; i < 100; i++ { hasher2 := adler32.New() DeepHashObject(hasher1, tc()) hash1a := hasher1.Sum32() DeepHashObject(hasher2, tc()) hash2a := hasher2.Sum32() if hash1a != hash1 { t.Errorf("repeated hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash1, hash1a) } if hash2a != hash2 { t.Errorf("repeated hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash2, hash2a) } if hash1a != hash2a { t.Errorf("hash of the same object produced (%q) different results: %d vs %d", toString(tc()), hash1a, hash2a) } } } }
func picHash(picf io.Reader) string { hash := adler32.New() if _, err := io.Copy(hash, picf); err != nil { log.Panic(err) } return fmt.Sprintf("%x", hash.Sum32()) }
func (c *controller) computeChecksum(fn string) (string, error) { checksumType := strings.ToLower(c.conf.GetDirectives().Data.Simple.Checksum) var hash hash.Hash switch checksumType { case "md5": hash = md5.New() case "adler32": hash = adler32.New() case "sha1": hash = sha1.New() case "sha256": hash = sha256.New() default: return "", errors.New("provided checksum not implemented") } fd, err := os.Open(fn) defer fd.Close() if err != nil { return "", err } if _, err := io.Copy(hash, fd); err != nil { return "", err } checksum := fmt.Sprintf("%x", hash.Sum([]byte{})) return checksumType + ":" + checksum, nil }
// NewDeflater creates a new io.WriteCloser that satisfies writes by compressing data written to w. // It is the caller's responsibility to call Close on the WriteCloser when done. // level is the compression level, which can be DefaultCompression, NoCompression, // or any integer value between BestSpeed and BestCompression (inclusive). func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) { z := new(writer) // ZLIB has a two-byte header (as documented in RFC 1950). // The first four bits is the CINFO (compression info), which is 7 for the default deflate window size. // The next four bits is the CM (compression method), which is 8 for deflate. z.scratch[0] = 0x78 // The next two bits is the FLEVEL (compression level). The four values are: // 0=fastest, 1=fast, 2=default, 3=best. // The next bit, FDICT, is unused, in this implementation. // The final five FCHECK bits form a mod-31 checksum. switch level { case 0, 1: z.scratch[1] = 0x01 case 2, 3, 4, 5: z.scratch[1] = 0x5e case 6, -1: z.scratch[1] = 0x9c case 7, 8, 9: z.scratch[1] = 0xda default: return nil, os.NewError("level out of range") } _, err := w.Write(z.scratch[0:2]) if err != nil { return nil, err } z.w = w z.deflater = flate.NewDeflater(w, level) z.digest = adler32.New() return z, nil }
// Helper function to take the key string and determine which bucket // the item should be placed in. This is the simplest hash function // I found in the core libraries. Not really sure how appropriate it is. func getIndex(key string, max int) int { hash := adler32.New() hash.Write([]byte(key)) digest := hash.Sum32() return int(digest) % max }
// Returns an RC that matches the intent of the given deployment. // It creates a new RC if required. func (d *DeploymentController) getDesiredRC(deployment *experimental.Deployment) (*api.ReplicationController, error) { namespace := deployment.ObjectMeta.Namespace // Find if the required RC exists already. rcList, err := d.client.ReplicationControllers(namespace).List(labels.Everything()) if err != nil { return nil, fmt.Errorf("error listing replication controllers: %v", err) } for _, rc := range rcList.Items { if api.Semantic.DeepEqual(rc.Spec.Template, deployment.Spec.Template) { // This is the desired RC. return &rc, nil } } // desired RC does not exist, create a new one. podTemplateSpecHasher := adler32.New() util.DeepHashObject(podTemplateSpecHasher, deployment.Spec.Template) podTemplateSpecHash := podTemplateSpecHasher.Sum32() rcName := fmt.Sprintf("deploymentrc-%d", podTemplateSpecHash) desiredRC := api.ReplicationController{ ObjectMeta: api.ObjectMeta{ Name: rcName, Namespace: namespace, }, Spec: api.ReplicationControllerSpec{ Replicas: 0, Template: deployment.Spec.Template, }, } createdRC, err := d.client.ReplicationControllers(namespace).Create(&desiredRC) if err != nil { return nil, fmt.Errorf("error creating replication controller: %v", err) } return createdRC, nil }
func (e *Engine) adler32() error { data, err := computeHash(adler32.New(), e.stack.Pop()) if err == nil { e.stack.Push(data) } return err }
func (self *FileService) AddFile(file File) error { writer := adler32.New() job := NewJob(file, writer, 2048, func(job *Job) error { var data []byte var err error switch { case file.Type() == FILE_DEFAULT: // Unchecked conversion. May cause problems defaultFile, _ := file.(DefaultFile) defaultFile.SetId(fmt.Sprintf("%x", writer.Sum32())) log.Printf("Adding file %s", defaultFile.Id()) data, err = json.Marshal(defaultFile.Data()) if err != nil { return err } } err = self.ctx.Database.Update(func(tx *bolt.Tx) error { b := tx.Bucket(filesBucketName) return b.Put([]byte(file.Id()), data) }) return nil }) self.ctx.JobService.Channel() <- job return nil }
func TestGolden(t *testing.T) { for _, g := range golden { in := g.in // We test the vanilla implementation p := []byte(g.in) vanilla := adler32.New() vanilla.Write(p) if got := vanilla.Sum32(); got != g.out { t.Errorf("vanilla implentation: for %q, expected 0x%x, got 0x%x", in, g.out, got) continue } // We test the rolling implementation by prefixing the slice by a // space, writing it to our rolling hash, and then rolling once q := []byte(" ") q = append(q, p...) rolling := rollsum.New() rolling.Write(q[:len(q)-1]) rolling.Roll(q[len(q)-1]) if got := rolling.Sum32(); got != g.out { t.Errorf("rolling implentation: for %q, expected 0x%x, got 0x%x", in, g.out, got) continue } } }
// NewReaderDict is like NewReader but uses a preset dictionary. // NewReaderDict ignores the dictionary if the compressed data does not refer to it. func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, os.Error) { z := new(reader) if fr, ok := r.(flate.Reader); ok { z.r = fr } else { z.r = bufio.NewReader(r) } _, err := io.ReadFull(z.r, z.scratch[0:2]) if err != nil { return nil, err } h := uint(z.scratch[0])<<8 | uint(z.scratch[1]) if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) { return nil, HeaderError } if z.scratch[1]&0x20 != 0 { _, err = io.ReadFull(z.r, z.scratch[0:4]) if err != nil { return nil, err } checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]) if checksum != adler32.Checksum(dict) { return nil, DictionaryError } z.decompressor = flate.NewReaderDict(z.r, dict) } else { z.decompressor = flate.NewReader(z.r) } z.digest = adler32.New() return z, nil }
func extractFromFile(filename string) (api.BoundPod, error) { var pod api.BoundPod glog.V(3).Infof("Reading config file %q", filename) file, err := os.Open(filename) if err != nil { return pod, err } defer file.Close() data, err := ioutil.ReadAll(file) if err != nil { return pod, err } manifest := &api.ContainerManifest{} // TODO: use api.Scheme.DecodeInto if err := yaml.Unmarshal(data, manifest); err != nil { return pod, fmt.Errorf("can't unmarshal file %q: %v", filename, err) } if err := api.Scheme.Convert(manifest, &pod); err != nil { return pod, fmt.Errorf("can't convert pod from file %q: %v", filename, err) } hostname, err := os.Hostname() //TODO: kubelet name would be better if err != nil { return pod, err } if len(pod.UID) == 0 { hasher := md5.New() fmt.Fprintf(hasher, "host:%s", hostname) fmt.Fprintf(hasher, "file:%s", filename) util.DeepHashObject(hasher, pod) pod.UID = hex.EncodeToString(hasher.Sum(nil)[0:]) glog.V(5).Infof("Generated UID %q for pod %q from file %s", pod.UID, pod.Name, filename) } if len(pod.Namespace) == 0 { hasher := adler32.New() fmt.Fprint(hasher, filename) // TODO: file-<sum>.hostname would be better, if DNS subdomains // are allowed for namespace (some places only allow DNS // labels). pod.Namespace = fmt.Sprintf("file-%08x-%s", hasher.Sum32(), hostname) glog.V(5).Infof("Generated namespace %q for pod %q from file %s", pod.Namespace, pod.Name, filename) } // TODO(dchen1107): BoundPod is not type of runtime.Object. Once we allow kubelet talks // about Pod directly, we can use SelfLinker defined in package: latest // Currently just simply follow the same format in resthandler.go pod.ObjectMeta.SelfLink = fmt.Sprintf("/api/v1beta2/pods/%s?namespace=%s", pod.Name, pod.Namespace) if glog.V(4) { glog.Infof("Got pod from file %q: %#v", filename, pod) } else { glog.V(1).Infof("Got pod from file %q: %s.%s (%s)", filename, pod.Namespace, pod.Name, pod.UID) } return pod, nil }
func (z *Writer) init(w io.Writer, level int) { z.compressor = nil z.ModTime = time.Now() z.level = level z.adler32 = adler32.New() z.crc32 = crc32.NewIEEE() z.w = io.MultiWriter(w, z.adler32, z.crc32) }
func (pm *PrinterManager) syncPrinters(ignorePrivet bool) error { log.Info("Synchronizing printers, stand by") // Get current snapshot of native printers. nativePrinters, err := pm.native.GetPrinters() if err != nil { return fmt.Errorf("Sync failed while calling GetPrinters(): %s", err) } // Set CapsHash on all printers. for i := range nativePrinters { h := adler32.New() lib.DeepHash(nativePrinters[i].Tags, h) nativePrinters[i].Tags["tagshash"] = fmt.Sprintf("%x", h.Sum(nil)) h = adler32.New() lib.DeepHash(nativePrinters[i].Description, h) nativePrinters[i].CapsHash = fmt.Sprintf("%x", h.Sum(nil)) } // Compare the snapshot to what we know currently. diffs := lib.DiffPrinters(nativePrinters, pm.printers.GetAll()) if diffs == nil { log.Infof("Printers are already in sync; there are %d", len(nativePrinters)) return nil } // Update GCP. ch := make(chan lib.Printer, len(diffs)) for i := range diffs { go pm.applyDiff(&diffs[i], ch, ignorePrivet) } currentPrinters := make([]lib.Printer, 0, len(diffs)) for _ = range diffs { p := <-ch if p.Name != "" { currentPrinters = append(currentPrinters, p) } } // Update what we know. pm.printers.Refresh(currentPrinters) log.Infof("Finished synchronizing %d printers", len(currentPrinters)) return nil }
// keyFunc returns the key of an object, which is used to look up in the cache for it's matching object. // Since we match objects by namespace and Labels/Selector, so if two objects have the same namespace and labels, // they will have the same key. func keyFunc(obj objectWithMeta) uint64 { hash := adler32.New() hashutil.DeepHashObject(hash, &equivalenceLabelObj{ namespace: obj.GetNamespace(), labels: obj.GetLabels(), }) return uint64(hash.Sum32()) }
func hashSliceFactory(length int) []Hash32 { fmt.Println(length) hashSlice := []Hash32{} for j := 0; j <= 10; j++ { hashSlice = append(hashSlice, adler32.New()) } return hashSlice }
// NewReader creates a new Reader reading the given reader. func NewReader(r io.Reader) (*Reader, error) { z := new(Reader) z.adler32 = adler32.New() z.crc32 = crc32.NewIEEE() z.r = io.TeeReader(r, io.MultiWriter(z.adler32, z.crc32)) if err := z.readHeader(); err != nil { return nil, err } return z, nil }
func (h *Hasher) initAlgorithm() { switch h.Algorithm { case "SHA1": h.Hash = sha1.New() case "MD5": h.Hash = md5.New() case "ADLER32": h.Hash = adler32.New() } }
func main() { var s string = "hello world" fmt.Printf("s=\"%s\"\n", s) adler := adler32.New() adler.Write([]byte(s)) fmt.Printf("adler32(s)=%x\n", adler.Sum32()) md := md5.New() md.Write([]byte(s)) v := uint64(md.Sum(nil)) fmt.Printf("md5(s)=%x\n", v) }
func verifyPackUnpack(t *testing.T, podNamespace, podUID, podName, containerName string) { container := &api.Container{Name: containerName} hasher := adler32.New() util.DeepHashObject(hasher, *container) computedHash := uint64(hasher.Sum32()) podFullName := fmt.Sprintf("%s.%s", podName, podNamespace) name := BuildDockerName(podUID, podFullName, container) returnedPodFullName, returnedUID, returnedContainerName, hash := ParseDockerName(name) if podFullName != returnedPodFullName || podUID != returnedUID || containerName != returnedContainerName || computedHash != hash { t.Errorf("For (%s, %s, %s, %d), unpacked (%s, %s, %s, %d)", podFullName, podUID, containerName, computedHash, returnedPodFullName, returnedUID, returnedContainerName, hash) } }
func ZlibCompress(options *Options, in []byte, out io.Writer) error { var counter countingWriter if options.Verbose { counter = newCountingWriter(out) out = &counter } const cmf = 120 /* CM 8, CINFO 7. See zlib spec.*/ const flevel = 0 const fdict = 0 var cmfflg uint16 = 256*cmf + fdict*32 + flevel*64 fcheck := 31 - cmfflg%31 cmfflg += fcheck flagBytes := []byte{ byte(cmfflg >> 8), byte(cmfflg), } _, flagErr := out.Write(flagBytes) if flagErr != nil { return flagErr } z := NewDeflator(out, options) writeErr := z.Deflate(true, in) if writeErr != nil { return writeErr } checksum := adler32.New() checksum.Write(in) final := checksum.Sum32() checksumBytes := []byte{ byte(final >> 24), byte(final >> 16), byte(final >> 8), byte(final), } _, checksumErr := out.Write(checksumBytes) if checksumErr != nil { return checksumErr } if options.Verbose { inSize := len(in) outSize := counter.written fmt.Fprintf(os.Stderr, "Original Size: %d, Zlib: %d, Compression: %f%% Removed\n", inSize, outSize, 100*float64(inSize-outSize)/float64(inSize)) } return nil }
// Write (via the embedded io.Writer interface) adds more data to the // running hash. It never returns an error. func (d *digest) Write(p []byte) (int, error) { // Copy the window d.window = make([]byte, len(p)) copy(d.window, p) // Piggy-back on the core implementation h := vanilla.New() h.Write(p) s := h.Sum32() d.a, d.b = s&0xffff, s>>16 d.n = uint32(len(p)) % mod return len(d.window), nil }
func verifyPackUnpack(t *testing.T, podNamespace, podName, containerName string) { container := &api.Container{Name: containerName} hasher := adler32.New() data := fmt.Sprintf("%#v", *container) hasher.Write([]byte(data)) computedHash := uint64(hasher.Sum32()) podFullName := fmt.Sprintf("%s.%s", podName, podNamespace) name := BuildDockerName("", podFullName, container) returnedPodFullName, _, returnedContainerName, hash := ParseDockerName(name) if podFullName != returnedPodFullName || containerName != returnedContainerName || computedHash != hash { t.Errorf("For (%s, %s, %d), unpacked (%s, %s, %d)", podFullName, containerName, computedHash, returnedPodFullName, returnedContainerName, hash) } }
func makeHash(name string) hash.Hash { switch strings.ToLower(name) { case "ripemd160": return ripemd160.New() case "md4": return md4.New() case "md5": return md5.New() case "sha1": return sha1.New() case "sha256": return sha256.New() case "sha384": return sha512.New384() case "sha3-224": return sha3.New224() case "sha3-256": return sha3.New256() case "sha3-384": return sha3.New384() case "sha3-512": return sha3.New512() case "sha512": return sha512.New() case "sha512-224": return sha512.New512_224() case "sha512-256": return sha512.New512_256() case "crc32-ieee": return crc32.NewIEEE() case "crc64-iso": return crc64.New(crc64.MakeTable(crc64.ISO)) case "crc64-ecma": return crc64.New(crc64.MakeTable(crc64.ECMA)) case "adler32": return adler32.New() case "fnv32": return fnv.New32() case "fnv32a": return fnv.New32a() case "fnv64": return fnv.New64() case "fnv64a": return fnv.New64a() case "xor8": return new(xor8) case "fletch16": return &fletch16{} } return nil }
// writeHeader writes the ZLIB header. func (z *Writer) writeHeader() (err error) { z.wroteHeader = true // ZLIB has a two-byte header (as documented in RFC 1950). // The first four bits is the CINFO (compression info), which is 7 for the default deflate window size. // The next four bits is the CM (compression method), which is 8 for deflate. z.scratch[0] = 0x78 // The next two bits is the FLEVEL (compression level). The four values are: // 0=fastest, 1=fast, 2=default, 3=best. // The next bit, FDICT, is set if a dictionary is given. // The final five FCHECK bits form a mod-31 checksum. switch z.level { case 0, 1: z.scratch[1] = 0 << 6 case 2, 3, 4, 5: z.scratch[1] = 1 << 6 case 6, -1: z.scratch[1] = 2 << 6 case 7, 8, 9: z.scratch[1] = 3 << 6 default: panic("unreachable") } if z.dict != nil { z.scratch[1] |= 1 << 5 } z.scratch[1] += uint8(31 - (uint16(z.scratch[0])<<8+uint16(z.scratch[1]))%31) if _, err = z.w.Write(z.scratch[0:2]); err != nil { return err } if z.dict != nil { // The next four bytes are the Adler-32 checksum of the dictionary. checksum := adler32.Checksum(z.dict) z.scratch[0] = uint8(checksum >> 24) z.scratch[1] = uint8(checksum >> 16) z.scratch[2] = uint8(checksum >> 8) z.scratch[3] = uint8(checksum >> 0) if _, err = z.w.Write(z.scratch[0:4]); err != nil { return err } } if z.compressor == nil { // Initialize deflater unless the Writer is being reused // after a Reset call. z.compressor, err = flate.NewWriterDict(z.w, z.level, z.dict) if err != nil { return err } z.digest = adler32.New() } return nil }
func uploadFile(client *Client, ccmBaseUrl string, filepath string, contentType string) (string, int64, int64, error) { uuid := generateUUID() file, err := os.Open(filepath) if err != nil { return "", -1, -1, err } hash := adler32.New() _, err = io.Copy(hash, file) if err != nil { return "", -1, -1, err } file.Close() sum := hash.Sum(nil) sumInt := int64(sum[0])<<(8*3) | int64(sum[1])<<(8*2) | int64(sum[2])<<(8*1) | int64(sum[3]) file, err = os.Open(filepath) if err != nil { return "", -1, -1, err } defer file.Close() uploadFileServiceUrl := path.Join(ccmBaseUrl, "/team/service/com.ibm.team.repository.common.transport.IDirectWritingContentService", uuid, strconv.FormatInt(sumInt, 10)) uploadFileServiceUrl = strings.Replace(uploadFileServiceUrl, ":/", "://", 1) request, err := http.NewRequest("PUT", uploadFileServiceUrl, file) if err != nil { return "", -1, -1, err } request.Header.Add("Content-Type", contentType) s, err := os.Stat(file.Name()) if err != nil { return "", -1, -1, err } request.ContentLength = s.Size() response, err := client.Do(request) if err != nil { return "", -1, -1, err } defer response.Body.Close() if response.StatusCode != 200 { return "", -1, -1, errorFromResponse(response) } return uuid, s.Size(), sumInt, nil }
func (z *reader) Reset(r io.Reader, dict []byte) error { *z = reader{decompressor: z.decompressor} if fr, ok := r.(flate.Reader); ok { z.r = fr } else { z.r = bufio.NewReader(r) } // Read the header (RFC 1950 section 2.2.). _, z.err = io.ReadFull(z.r, z.scratch[0:2]) if z.err != nil { if z.err == io.EOF { z.err = io.ErrUnexpectedEOF } return z.err } h := uint(z.scratch[0])<<8 | uint(z.scratch[1]) if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) { z.err = ErrHeader return z.err } haveDict := z.scratch[1]&0x20 != 0 if haveDict { _, z.err = io.ReadFull(z.r, z.scratch[0:4]) if z.err != nil { if z.err == io.EOF { z.err = io.ErrUnexpectedEOF } return z.err } checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]) if checksum != adler32.Checksum(dict) { z.err = ErrDictionary return z.err } } if z.decompressor == nil { if haveDict { z.decompressor = flate.NewReaderDict(z.r, dict) } else { z.decompressor = flate.NewReader(z.r) } } else { z.decompressor.(flate.Resetter).Reset(z.r, dict) } z.digest = adler32.New() return nil }