GitHub Setup for Windows in Corporate Environments

These steps are necessary to get Git working with GitHub from behind a corporate firewall. These steps are for a Microsoft Windows centric environment.

Installing the Windows Git Package

Download the windows installer from http://git-scm.com then run the installer with the recommended default settings. You’ll need sufficient privileges to install applications at your desktop (condolences if you don’t).

SS1  SS2 SS3 SS4

Configure Git Proxy Settings

Locate the .gitconfig file in your users home directory and open with a text editor. If you have roaming profiles, it can be challenging to find this as it may be mapped to a shared network drive.

You can locate the file by identifying the home directory with the SET command in the DOS Command Window. In this example it happens to be on a network share mapped to the V: drive.

Make a note of your system Proxy Server settings here.

SS5

Looking at my .config file, there are six data points needed to configure git to be able to pass through my Proxy Server.

You can do this configuration from the command line with git configure –global but it feels simpler to just edit it here with your text editor.

SS6

  1. Your NTLM or Windows domain followed by a back slash (\), which has to be escaped so two slashes (\\)
  2. Your Windows Domain Username followed by a colon (:)
  3. Your Windows Domain Password (remember to escape any special characters) followed by an at sympol (@)
  4. Your Proxy Server address or hostname followed by a colon (:)
  5. Your Proxy Server TCP port number
  6. This turns off SSL Certificate verification as this proxy substitutes signed certificates with its own self-signed version. Presumably in order to allow admins to inspect what you’re transmitting!

String it all together and you get something like

https://mywindomain\\cwhite:foofoobar@savageproxyserver:8081

Repeat these settings for the https directive below.

Setup a GitHub Repository

Go back to Github.com and create a new Repository. I’ve called mine Git_Setup.

SS7

Once it has bee created be sure to select the HTTP tab. If you fail to do this, instructions will assume you can perform outbound SSH from your host. Typical corporate Proxy and Firewall settings will deny this. So be sure to understand, you will be using Git over HTTPS through your Proxy Server.

You should then be able to perform the instructions identified in the red box from your Dos Command Window.

SS8

Seems to work for me…

SS9

Advertisements

Example to connect to SQLite with PHP and return JSON

You can spend a long time googling for examples of how to do this with PDO. The real juice is in lines 17 and 18. I record it here for posterity.


<?php
/*
* Code to query an SQLite database and return
* results as JSON.
*/

// Specify your sqlite database name and path //
$dir = 'sqlite:mydir/myDatabase.sqlite';

// Instantiate PDO connection object and failure msg //
$dbh = new PDO($dir) or die("cannot open database");

// Define your SQL statement //
$query = "SELECT * FROM myTable";

// Iterate through the results and pass into JSON encoder //
foreach ($dbh->query($query) as $row) {
echo json_encode($row[0]);
}
?>

OSX Litecoint (LTC) mining Example with bfgminer and Macports

This post is a little OT so I’ll keep it terse. The goal is to perform LTC mining on OSX Maverics 10.9.2. But here’s the challenge – compile everything natively from source code, on old equipment. There are several good packages and binaries floating around which you should try first. If you prefer to know what’s in them and how they’re built, here’s a step by step tutorial to roll your own. Most of the documentation for this exercise is buried in obscure forum threads and uses the Homebrew package manager. This post is for MacPorts users; and those still running MacBooks from mid 2009(!) and because I enjoy a GNU challenge… Screen Shot 2014-03-17 at 3.36.47 PM

Your first task is to identify your graphics card with the help of the Apple website and check it supports OpenCL. In my case, it’s a rather sucky NVIDIA GeForce 9400M. It seems  the System Preferences, Displays Tool in Maverics can’t identify some of these older graphics devices. Once you know your graphics hardware supports OpenCL, the process is as follows:

1. Select an online mining pool and open an account. You’ll need to setup a “worker” with a username and password.

2. Update your MacPorts package manager (or install it if you don’t have it).

sudo port selfupdate
sudo port upgrade outdated

3. Check your Xcode Command Line Tools are working so you can actually run the compiler. If you haven’t installed Xcode you can grab it (free) from the OSX App Store.

pkgutil --pkg-info=com.apple.pkg.CLTools_Executables

Try this on something older than Maverics (like Lion or Snow Leopard)

pkgutil --pkg-info=com.apple.pkg.DeveloperToolsCLI

4. Install all the lib dependencies (C header files) needed to compile bfgminer. Looking at the README around lines 84-86 you can see what you’ll need to install. Start at the beginning of the list and work through like so,

sudo port install libusb
sudo port install libevent
sudo port install libmicrohttpd
...

Ignore (but note) any errors as MacPorts doesn’t have packages for all these. In these cases you’ll have to install them do by hand. Create a working directory,

 mkdir ~/Miner; cd Miner; ls 

To install uthash headers, clone them from the git repo,

git clone https://github.com/troydhanson/uthash

Then copy thee C headers (.h files) to /usr/local/include

 sudo cp ./uthash/src/*.h /usr/local/include 

The process for the hidapi drivers for USB devices is a little different. I include these in case you want to try your hand at SHA-256 based crypto currencies and deploy a USB ASIC.

git clone https://github.com/signal11/hidapi
./bootstrap
./configure
sudo make
sudo make install

5. Now, the coin miner itself. I chose bfgminer, as Scrypt based LTC is no longer supported by cgminer. Clone the git repo into your working directory,

cd ./Miner
git clone https://github.com/luke-jr/bfgminer
cd ./bfgminer; ls

Run the autogen.sh script. Not clear what this does but it appears to run GNU autoconf and generate a Configure script.

./autogen.sh

autogen

Next, run the Configure script.

./configure --enable-scrypt --enable-opencl CFLAGS=”-g -O2 -Wall”

Configure

Now, compile and read but ignore any Warning messages.

sudo make
sudo make install

Create a bfgminer config file called bfg.conf. This is a json file and can look something like this example. Obviously, enter the specific details of the mining pool you registered with –

{
    "pools" : [
    {
        "url" : "stratum+tcp://crypto-coin-pool.com:3335",
        "user" : "<worker_name.worker_number>",
        "pass" : "<worker pwd>",
        "pool-priority" : "0"
    }
    ]
}

Start things up with,

 ./bfgminer --scrypt -c ./bfg.conf -w 128 

The explanation for the -w 128 can be found here. It’s to do with the sucky performance capabilities of the GeForce card. With any luck, your bfgminer will start up… bfgminer no dev

If it doesn’t find your GPU device you’ll need to configure it with the [M]anage devices option (press “m”, obviously). Then hit the “+” sign and enter “auto”. manage devs

With any luck, you should be good to go…bfg running

Now let it run for a while… In this example it ran for 21:33 mins:secs before anything meaningful started showing up.

Successful mining

You can see (red boxes) submitted work packages being accepted by the online  mining pool. You can expect to see these every 3 mins or so.

Top Tip for learning D3.js

WP 20 PostsI’m probably just a little slow on the update but it took me a long time (too long) to realize this key point –

To get productive with D3.js quickly, invest your time in coercing your data to match that of the examples. As opposed to coercing the example code to work with your data format.

Coercing your data requires use of tools you’re already familiar with (Excel, SQL, Shell Script  whatever). Staying in your comfort zone here will help (quickly) get something pretty into your DOM, which you can then hack on.

The alternative will have you pouring over lots of code and API documentation. The wonderful example code is often quite sophisticated and inaccessible to JavaScript novices and the API documentation is comprehensive but dense and somewhat terse.

While this effort is educational, it can be frustrating to get something working (and subsequently demotivating). When you’re starting out, quick and easy wins help enormously. Much motivation can come from these early dopamine responses (Ooh bar chart! Woot! Woot!).

Hence examples like this, this and this to expose D3 friendly data.

Again, focus your time on getting your data to match the examples rather than changing the examples to handle your data.

Oh, and buy Scott Murray’s, “Interactive Data Visualization” published by O’Reilly Media.

Hopefully this will help open up D3 for you more quickly than it did for me.

JSON from MS SQL Server with PHP Example

Someone much smarter than me, pointed out that my previous solution would hit a size limit (max cell width). This stored proc returns the JSON stream as a single table cell (albeit a big one). So their alternative solution is to do the JSON conversion on the webserver with PHP’s json_encode().

It works nicely.

EDIT: Don’t forget the UTF-8 encoding or you’ll experience random NULLs in your JSON.


<?php
/* Set Connection Credentials */
$serverName="(local)";
$uid = "";
$pwd = "";
$connectionInfo = array( "UID"=>$uid,
                         "PWD"=>$pwd,
                         "Database"=>"TEST",
                         "CharacterSet"=>"UTF-8");

/* Connect using SQL Server Authentication. */
$conn = sqlsrv_connect( $serverName, $connectionInfo);

if( $conn === false ) {
     echo "Unable to connect.</br>";
     die( print_r( sqlsrv_errors(), true));
}

/* TSQL Query */
$tsql = "SELECT TOP 100 * FROM AtxJSON";
$stmt = sqlsrv_query( $conn, $tsql);

if( $stmt === false ) {
     echo "Error in executing query.</br>";
     die( print_r( sqlsrv_errors(), true));
}

/* Process results */
$json = array();

do {
     while ($row = sqlsrv_fetch_array($stmt, SQLSRV_FETCH_ASSOC)) {
     $json[] = $row;
     }
} while ( sqlsrv_next_result($stmt) );

/* Run the tabular results through json_encode() */
/* And ensure numbers don't get cast to trings */
echo json_encode($json,<code> JSON_NUMERIC_CHECK</code>);
/* Free statement and connection resources. */
sqlsrv_free_stmt( $stmt);
sqlsrv_close( $conn);

?>